wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 1 | /* |
| 2 | * (C) Copyright 2004 |
| 3 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. |
| 4 | * |
Wolfgang Denk | d79de1d | 2013-07-08 09:37:19 +0200 | [diff] [blame] | 5 | * SPDX-License-Identifier: GPL-2.0+ |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 6 | */ |
| 7 | |
| 8 | #include <common.h> |
Joe Hershberger | 3928bb6 | 2012-12-11 22:16:27 -0600 | [diff] [blame] | 9 | #include <environment.h> |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 10 | #include <serial.h> |
Jean-Christophe PLAGNIOL-VILLARD | 2a7a031 | 2009-05-16 12:14:54 +0200 | [diff] [blame] | 11 | #include <stdio_dev.h> |
Mike Frysinger | 078f2f1 | 2011-05-14 06:56:15 +0000 | [diff] [blame] | 12 | #include <post.h> |
| 13 | #include <linux/compiler.h> |
Marek Vasut | 0e1b577 | 2012-10-06 14:07:03 +0000 | [diff] [blame] | 14 | #include <errno.h> |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 15 | |
Wolfgang Denk | 6405a15 | 2006-03-31 18:32:53 +0200 | [diff] [blame] | 16 | DECLARE_GLOBAL_DATA_PTR; |
| 17 | |
Gerlando Falauto | 34148d6 | 2011-11-18 06:49:11 +0000 | [diff] [blame] | 18 | static struct serial_device *serial_devices; |
| 19 | static struct serial_device *serial_current; |
Joe Hershberger | 3928bb6 | 2012-12-11 22:16:27 -0600 | [diff] [blame] | 20 | /* |
| 21 | * Table with supported baudrates (defined in config_xyz.h) |
| 22 | */ |
| 23 | static const unsigned long baudrate_table[] = CONFIG_SYS_BAUDRATE_TABLE; |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 24 | |
Marek Vasut | 95656ea | 2012-10-08 11:36:39 +0000 | [diff] [blame] | 25 | /** |
| 26 | * serial_null() - Void registration routine of a serial driver |
| 27 | * |
| 28 | * This routine implements a void registration routine of a serial |
| 29 | * driver. The registration routine of a particular driver is aliased |
| 30 | * to this empty function in case the driver is not compiled into |
| 31 | * U-Boot. |
| 32 | */ |
Marek Vasut | f6af048 | 2012-09-12 17:49:58 +0200 | [diff] [blame] | 33 | static void serial_null(void) |
| 34 | { |
Joe Hershberger | 3928bb6 | 2012-12-11 22:16:27 -0600 | [diff] [blame] | 35 | } |
| 36 | |
| 37 | /** |
| 38 | * on_baudrate() - Update the actual baudrate when the env var changes |
| 39 | * |
| 40 | * This will check for a valid baudrate and only apply it if valid. |
| 41 | */ |
| 42 | static int on_baudrate(const char *name, const char *value, enum env_op op, |
| 43 | int flags) |
| 44 | { |
| 45 | int i; |
| 46 | int baudrate; |
| 47 | |
| 48 | switch (op) { |
| 49 | case env_op_create: |
| 50 | case env_op_overwrite: |
| 51 | /* |
| 52 | * Switch to new baudrate if new baudrate is supported |
| 53 | */ |
| 54 | baudrate = simple_strtoul(value, NULL, 10); |
| 55 | |
| 56 | /* Not actually changing */ |
| 57 | if (gd->baudrate == baudrate) |
| 58 | return 0; |
| 59 | |
Axel Lin | ebca873 | 2013-06-23 00:46:41 +0800 | [diff] [blame] | 60 | for (i = 0; i < ARRAY_SIZE(baudrate_table); ++i) { |
Joe Hershberger | 3928bb6 | 2012-12-11 22:16:27 -0600 | [diff] [blame] | 61 | if (baudrate == baudrate_table[i]) |
| 62 | break; |
| 63 | } |
Axel Lin | ebca873 | 2013-06-23 00:46:41 +0800 | [diff] [blame] | 64 | if (i == ARRAY_SIZE(baudrate_table)) { |
Joe Hershberger | 3928bb6 | 2012-12-11 22:16:27 -0600 | [diff] [blame] | 65 | if ((flags & H_FORCE) == 0) |
| 66 | printf("## Baudrate %d bps not supported\n", |
| 67 | baudrate); |
| 68 | return 1; |
| 69 | } |
| 70 | if ((flags & H_INTERACTIVE) != 0) { |
| 71 | printf("## Switch baudrate to %d" |
| 72 | " bps and press ENTER ...\n", baudrate); |
| 73 | udelay(50000); |
| 74 | } |
| 75 | |
| 76 | gd->baudrate = baudrate; |
Joe Hershberger | 3928bb6 | 2012-12-11 22:16:27 -0600 | [diff] [blame] | 77 | |
| 78 | serial_setbrg(); |
| 79 | |
| 80 | udelay(50000); |
| 81 | |
| 82 | if ((flags & H_INTERACTIVE) != 0) |
| 83 | while (1) { |
| 84 | if (getc() == '\r') |
| 85 | break; |
| 86 | } |
| 87 | |
| 88 | return 0; |
| 89 | case env_op_delete: |
| 90 | printf("## Baudrate may not be deleted\n"); |
| 91 | return 1; |
| 92 | default: |
| 93 | return 0; |
| 94 | } |
Marek Vasut | f6af048 | 2012-09-12 17:49:58 +0200 | [diff] [blame] | 95 | } |
Joe Hershberger | 3928bb6 | 2012-12-11 22:16:27 -0600 | [diff] [blame] | 96 | U_BOOT_ENV_CALLBACK(baudrate, on_baudrate); |
Marek Vasut | f6af048 | 2012-09-12 17:49:58 +0200 | [diff] [blame] | 97 | |
Marek Vasut | 95656ea | 2012-10-08 11:36:39 +0000 | [diff] [blame] | 98 | /** |
| 99 | * serial_initfunc() - Forward declare of driver registration routine |
| 100 | * @name: Name of the real driver registration routine. |
| 101 | * |
| 102 | * This macro expands onto forward declaration of a driver registration |
| 103 | * routine, which is then used below in serial_initialize() function. |
| 104 | * The declaration is made weak and aliases to serial_null() so in case |
| 105 | * the driver is not compiled in, the function is still declared and can |
| 106 | * be used, but aliases to serial_null() and thus is optimized away. |
| 107 | */ |
Marek Vasut | f6af048 | 2012-09-12 17:49:58 +0200 | [diff] [blame] | 108 | #define serial_initfunc(name) \ |
| 109 | void name(void) \ |
| 110 | __attribute__((weak, alias("serial_null"))); |
| 111 | |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 112 | serial_initfunc(altera_jtag_serial_initialize); |
| 113 | serial_initfunc(altera_serial_initialize); |
Marek Vasut | 42cde13 | 2012-09-13 12:27:37 +0200 | [diff] [blame] | 114 | serial_initfunc(amirix_serial_initialize); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 115 | serial_initfunc(arc_serial_initialize); |
| 116 | serial_initfunc(arm_dcc_initialize); |
| 117 | serial_initfunc(asc_serial_initialize); |
| 118 | serial_initfunc(atmel_serial_initialize); |
| 119 | serial_initfunc(au1x00_serial_initialize); |
| 120 | serial_initfunc(bfin_jtag_initialize); |
| 121 | serial_initfunc(bfin_serial_initialize); |
Marek Vasut | bf5314b | 2012-09-13 12:28:07 +0200 | [diff] [blame] | 122 | serial_initfunc(bmw_serial_initialize); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 123 | serial_initfunc(clps7111_serial_initialize); |
Marek Vasut | f728402 | 2012-09-13 12:29:31 +0200 | [diff] [blame] | 124 | serial_initfunc(cogent_serial_initialize); |
Marek Vasut | 7aa03ef | 2012-09-13 12:32:56 +0200 | [diff] [blame] | 125 | serial_initfunc(cpci750_serial_initialize); |
Marek Vasut | adede69 | 2012-09-13 12:33:50 +0200 | [diff] [blame] | 126 | serial_initfunc(evb64260_serial_initialize); |
Marek Vasut | 9784bde | 2012-09-14 22:34:51 +0200 | [diff] [blame] | 127 | serial_initfunc(imx_serial_initialize); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 128 | serial_initfunc(iop480_serial_initialize); |
| 129 | serial_initfunc(jz_serial_initialize); |
Marek Vasut | 5ee4656 | 2012-09-14 22:35:43 +0200 | [diff] [blame] | 130 | serial_initfunc(ks8695_serial_initialize); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 131 | serial_initfunc(leon2_serial_initialize); |
| 132 | serial_initfunc(leon3_serial_initialize); |
Marek Vasut | 58177b7 | 2012-09-14 22:36:27 +0200 | [diff] [blame] | 133 | serial_initfunc(lh7a40x_serial_initialize); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 134 | serial_initfunc(lpc32xx_serial_initialize); |
| 135 | serial_initfunc(marvell_serial_initialize); |
Marek Vasut | 0079786 | 2012-09-14 22:37:17 +0200 | [diff] [blame] | 136 | serial_initfunc(max3100_serial_initialize); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 137 | serial_initfunc(mcf_serial_initialize); |
| 138 | serial_initfunc(ml2_serial_initialize); |
| 139 | serial_initfunc(mpc512x_serial_initialize); |
| 140 | serial_initfunc(mpc5xx_serial_initialize); |
| 141 | serial_initfunc(mpc8260_scc_serial_initialize); |
| 142 | serial_initfunc(mpc8260_smc_serial_initialize); |
| 143 | serial_initfunc(mpc85xx_serial_initialize); |
| 144 | serial_initfunc(mpc8xx_serial_initialize); |
Marek Vasut | 64c6055 | 2012-09-14 22:37:43 +0200 | [diff] [blame] | 145 | serial_initfunc(mxc_serial_initialize); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 146 | serial_initfunc(mxs_auart_initialize); |
| 147 | serial_initfunc(ns16550_serial_initialize); |
| 148 | serial_initfunc(oc_serial_initialize); |
| 149 | serial_initfunc(p3mx_serial_initialize); |
Marek Vasut | 46e4d5f | 2012-09-14 22:38:46 +0200 | [diff] [blame] | 150 | serial_initfunc(pl01x_serial_initialize); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 151 | serial_initfunc(pxa_serial_initialize); |
| 152 | serial_initfunc(s3c24xx_serial_initialize); |
| 153 | serial_initfunc(s5p_serial_initialize); |
Marek Vasut | 0d19c02 | 2012-09-14 22:39:44 +0200 | [diff] [blame] | 154 | serial_initfunc(sa1100_serial_initialize); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 155 | serial_initfunc(sandbox_serial_initialize); |
| 156 | serial_initfunc(sconsole_serial_initialize); |
Marek Vasut | 904d3d7 | 2012-09-14 22:40:08 +0200 | [diff] [blame] | 157 | serial_initfunc(sh_serial_initialize); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 158 | serial_initfunc(uartlite_serial_initialize); |
| 159 | serial_initfunc(zynq_serial_initialize); |
Marek Vasut | 419d894 | 2012-09-12 13:50:56 +0200 | [diff] [blame] | 160 | |
Marek Vasut | 95656ea | 2012-10-08 11:36:39 +0000 | [diff] [blame] | 161 | /** |
| 162 | * serial_register() - Register serial driver with serial driver core |
| 163 | * @dev: Pointer to the serial driver structure |
| 164 | * |
| 165 | * This function registers the serial driver supplied via @dev with |
| 166 | * serial driver core, thus making U-Boot aware of it and making it |
| 167 | * available for U-Boot to use. On platforms that still require manual |
| 168 | * relocation of constant variables, relocation of the supplied structure |
| 169 | * is performed. |
| 170 | */ |
Mike Frysinger | ffadc82 | 2011-04-29 18:03:30 +0000 | [diff] [blame] | 171 | void serial_register(struct serial_device *dev) |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 172 | { |
Wolfgang Denk | d0813e5 | 2010-10-28 20:00:11 +0200 | [diff] [blame] | 173 | #ifdef CONFIG_NEEDS_MANUAL_RELOC |
Marek Vasut | 2206b34 | 2012-09-16 18:54:22 +0200 | [diff] [blame] | 174 | if (dev->start) |
| 175 | dev->start += gd->reloc_off; |
| 176 | if (dev->stop) |
| 177 | dev->stop += gd->reloc_off; |
| 178 | if (dev->setbrg) |
| 179 | dev->setbrg += gd->reloc_off; |
| 180 | if (dev->getc) |
| 181 | dev->getc += gd->reloc_off; |
| 182 | if (dev->tstc) |
| 183 | dev->tstc += gd->reloc_off; |
| 184 | if (dev->putc) |
| 185 | dev->putc += gd->reloc_off; |
| 186 | if (dev->puts) |
| 187 | dev->puts += gd->reloc_off; |
Peter Tyser | 9057cbf | 2009-09-21 11:20:36 -0500 | [diff] [blame] | 188 | #endif |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 189 | |
| 190 | dev->next = serial_devices; |
| 191 | serial_devices = dev; |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 192 | } |
| 193 | |
Marek Vasut | 95656ea | 2012-10-08 11:36:39 +0000 | [diff] [blame] | 194 | /** |
| 195 | * serial_initialize() - Register all compiled-in serial port drivers |
| 196 | * |
| 197 | * This function registers all serial port drivers that are compiled |
| 198 | * into the U-Boot binary with the serial core, thus making them |
| 199 | * available to U-Boot to use. Lastly, this function assigns a default |
| 200 | * serial port to the serial core. That serial port is then used as a |
| 201 | * default output. |
| 202 | */ |
Gerlando Falauto | 34148d6 | 2011-11-18 06:49:11 +0000 | [diff] [blame] | 203 | void serial_initialize(void) |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 204 | { |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 205 | altera_jtag_serial_initialize(); |
| 206 | altera_serial_initialize(); |
Marek Vasut | 42cde13 | 2012-09-13 12:27:37 +0200 | [diff] [blame] | 207 | amirix_serial_initialize(); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 208 | arc_serial_initialize(); |
| 209 | arm_dcc_initialize(); |
| 210 | asc_serial_initialize(); |
| 211 | atmel_serial_initialize(); |
| 212 | au1x00_serial_initialize(); |
| 213 | bfin_jtag_initialize(); |
| 214 | bfin_serial_initialize(); |
Marek Vasut | bf5314b | 2012-09-13 12:28:07 +0200 | [diff] [blame] | 215 | bmw_serial_initialize(); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 216 | clps7111_serial_initialize(); |
Marek Vasut | f728402 | 2012-09-13 12:29:31 +0200 | [diff] [blame] | 217 | cogent_serial_initialize(); |
Marek Vasut | 7aa03ef | 2012-09-13 12:32:56 +0200 | [diff] [blame] | 218 | cpci750_serial_initialize(); |
Marek Vasut | adede69 | 2012-09-13 12:33:50 +0200 | [diff] [blame] | 219 | evb64260_serial_initialize(); |
Marek Vasut | 9784bde | 2012-09-14 22:34:51 +0200 | [diff] [blame] | 220 | imx_serial_initialize(); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 221 | iop480_serial_initialize(); |
| 222 | jz_serial_initialize(); |
Marek Vasut | 5ee4656 | 2012-09-14 22:35:43 +0200 | [diff] [blame] | 223 | ks8695_serial_initialize(); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 224 | leon2_serial_initialize(); |
| 225 | leon3_serial_initialize(); |
Marek Vasut | 58177b7 | 2012-09-14 22:36:27 +0200 | [diff] [blame] | 226 | lh7a40x_serial_initialize(); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 227 | lpc32xx_serial_initialize(); |
| 228 | marvell_serial_initialize(); |
Marek Vasut | 0079786 | 2012-09-14 22:37:17 +0200 | [diff] [blame] | 229 | max3100_serial_initialize(); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 230 | mcf_serial_initialize(); |
| 231 | ml2_serial_initialize(); |
| 232 | mpc512x_serial_initialize(); |
| 233 | mpc5xx_serial_initialize(); |
| 234 | mpc8260_scc_serial_initialize(); |
| 235 | mpc8260_smc_serial_initialize(); |
| 236 | mpc85xx_serial_initialize(); |
| 237 | mpc8xx_serial_initialize(); |
Marek Vasut | 64c6055 | 2012-09-14 22:37:43 +0200 | [diff] [blame] | 238 | mxc_serial_initialize(); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 239 | mxs_auart_initialize(); |
| 240 | ns16550_serial_initialize(); |
| 241 | oc_serial_initialize(); |
| 242 | p3mx_serial_initialize(); |
Marek Vasut | 46e4d5f | 2012-09-14 22:38:46 +0200 | [diff] [blame] | 243 | pl01x_serial_initialize(); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 244 | pxa_serial_initialize(); |
| 245 | s3c24xx_serial_initialize(); |
| 246 | s5p_serial_initialize(); |
Marek Vasut | 0d19c02 | 2012-09-14 22:39:44 +0200 | [diff] [blame] | 247 | sa1100_serial_initialize(); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 248 | sandbox_serial_initialize(); |
| 249 | sconsole_serial_initialize(); |
Marek Vasut | 904d3d7 | 2012-09-14 22:40:08 +0200 | [diff] [blame] | 250 | sh_serial_initialize(); |
Jeroen Hofstee | 6512cc1 | 2014-10-27 20:10:07 +0100 | [diff] [blame] | 251 | uartlite_serial_initialize(); |
| 252 | zynq_serial_initialize(); |
Marek Vasut | 01f9ea8 | 2012-09-13 01:16:50 +0200 | [diff] [blame] | 253 | |
Gerlando Falauto | 34148d6 | 2011-11-18 06:49:11 +0000 | [diff] [blame] | 254 | serial_assign(default_serial_console()->name); |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 255 | } |
| 256 | |
Jeroen Hofstee | 169eda6 | 2014-10-08 22:57:44 +0200 | [diff] [blame] | 257 | static int serial_stub_start(struct stdio_dev *sdev) |
Simon Glass | 0d1e1f7 | 2014-07-23 06:54:59 -0600 | [diff] [blame] | 258 | { |
| 259 | struct serial_device *dev = sdev->priv; |
| 260 | |
| 261 | return dev->start(); |
| 262 | } |
| 263 | |
Jeroen Hofstee | 169eda6 | 2014-10-08 22:57:44 +0200 | [diff] [blame] | 264 | static int serial_stub_stop(struct stdio_dev *sdev) |
Simon Glass | 0d1e1f7 | 2014-07-23 06:54:59 -0600 | [diff] [blame] | 265 | { |
| 266 | struct serial_device *dev = sdev->priv; |
| 267 | |
| 268 | return dev->stop(); |
| 269 | } |
| 270 | |
Jeroen Hofstee | 169eda6 | 2014-10-08 22:57:44 +0200 | [diff] [blame] | 271 | static void serial_stub_putc(struct stdio_dev *sdev, const char ch) |
Simon Glass | 0d1e1f7 | 2014-07-23 06:54:59 -0600 | [diff] [blame] | 272 | { |
| 273 | struct serial_device *dev = sdev->priv; |
| 274 | |
| 275 | dev->putc(ch); |
| 276 | } |
| 277 | |
Jeroen Hofstee | 169eda6 | 2014-10-08 22:57:44 +0200 | [diff] [blame] | 278 | static void serial_stub_puts(struct stdio_dev *sdev, const char *str) |
Simon Glass | 0d1e1f7 | 2014-07-23 06:54:59 -0600 | [diff] [blame] | 279 | { |
| 280 | struct serial_device *dev = sdev->priv; |
| 281 | |
| 282 | dev->puts(str); |
| 283 | } |
| 284 | |
| 285 | int serial_stub_getc(struct stdio_dev *sdev) |
| 286 | { |
| 287 | struct serial_device *dev = sdev->priv; |
| 288 | |
| 289 | return dev->getc(); |
| 290 | } |
| 291 | |
| 292 | int serial_stub_tstc(struct stdio_dev *sdev) |
| 293 | { |
| 294 | struct serial_device *dev = sdev->priv; |
| 295 | |
| 296 | return dev->tstc(); |
| 297 | } |
| 298 | |
Marek Vasut | 95656ea | 2012-10-08 11:36:39 +0000 | [diff] [blame] | 299 | /** |
| 300 | * serial_stdio_init() - Register serial ports with STDIO core |
| 301 | * |
| 302 | * This function generates a proxy driver for each serial port driver. |
| 303 | * These proxy drivers then register with the STDIO core, making the |
| 304 | * serial drivers available as STDIO devices. |
| 305 | */ |
Gerlando Falauto | 34148d6 | 2011-11-18 06:49:11 +0000 | [diff] [blame] | 306 | void serial_stdio_init(void) |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 307 | { |
Jean-Christophe PLAGNIOL-VILLARD | 2a7a031 | 2009-05-16 12:14:54 +0200 | [diff] [blame] | 308 | struct stdio_dev dev; |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 309 | struct serial_device *s = serial_devices; |
| 310 | |
wdenk | 8f08c5b | 2004-10-11 22:43:02 +0000 | [diff] [blame] | 311 | while (s) { |
Gerlando Falauto | 34148d6 | 2011-11-18 06:49:11 +0000 | [diff] [blame] | 312 | memset(&dev, 0, sizeof(dev)); |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 313 | |
Gerlando Falauto | 34148d6 | 2011-11-18 06:49:11 +0000 | [diff] [blame] | 314 | strcpy(dev.name, s->name); |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 315 | dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT; |
| 316 | |
Simon Glass | 0d1e1f7 | 2014-07-23 06:54:59 -0600 | [diff] [blame] | 317 | dev.start = serial_stub_start; |
| 318 | dev.stop = serial_stub_stop; |
| 319 | dev.putc = serial_stub_putc; |
| 320 | dev.puts = serial_stub_puts; |
| 321 | dev.getc = serial_stub_getc; |
| 322 | dev.tstc = serial_stub_tstc; |
Simon Glass | ac2a14f | 2014-09-04 16:27:23 -0600 | [diff] [blame] | 323 | dev.priv = s; |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 324 | |
Gerlando Falauto | 34148d6 | 2011-11-18 06:49:11 +0000 | [diff] [blame] | 325 | stdio_register(&dev); |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 326 | |
| 327 | s = s->next; |
| 328 | } |
| 329 | } |
| 330 | |
Marek Vasut | 95656ea | 2012-10-08 11:36:39 +0000 | [diff] [blame] | 331 | /** |
| 332 | * serial_assign() - Select the serial output device by name |
| 333 | * @name: Name of the serial driver to be used as default output |
| 334 | * |
| 335 | * This function configures the serial output multiplexing by |
| 336 | * selecting which serial device will be used as default. In case |
| 337 | * the STDIO "serial" device is selected as stdin/stdout/stderr, |
| 338 | * the serial device previously configured by this function will be |
| 339 | * used for the particular operation. |
| 340 | * |
| 341 | * Returns 0 on success, negative on error. |
| 342 | */ |
Gerlando Falauto | 9299958 | 2011-11-18 06:49:12 +0000 | [diff] [blame] | 343 | int serial_assign(const char *name) |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 344 | { |
| 345 | struct serial_device *s; |
| 346 | |
wdenk | 8f08c5b | 2004-10-11 22:43:02 +0000 | [diff] [blame] | 347 | for (s = serial_devices; s; s = s->next) { |
Marek Vasut | 0e1b577 | 2012-10-06 14:07:03 +0000 | [diff] [blame] | 348 | if (strcmp(s->name, name)) |
| 349 | continue; |
| 350 | serial_current = s; |
| 351 | return 0; |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 352 | } |
| 353 | |
Marek Vasut | 0e1b577 | 2012-10-06 14:07:03 +0000 | [diff] [blame] | 354 | return -EINVAL; |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 355 | } |
| 356 | |
Marek Vasut | 95656ea | 2012-10-08 11:36:39 +0000 | [diff] [blame] | 357 | /** |
| 358 | * serial_reinit_all() - Reinitialize all compiled-in serial ports |
| 359 | * |
| 360 | * This function reinitializes all serial ports that are compiled |
| 361 | * into U-Boot by calling their serial_start() functions. |
| 362 | */ |
Gerlando Falauto | 34148d6 | 2011-11-18 06:49:11 +0000 | [diff] [blame] | 363 | void serial_reinit_all(void) |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 364 | { |
| 365 | struct serial_device *s; |
| 366 | |
Gerlando Falauto | 34148d6 | 2011-11-18 06:49:11 +0000 | [diff] [blame] | 367 | for (s = serial_devices; s; s = s->next) |
Marek Vasut | b46931d | 2012-09-07 14:35:31 +0200 | [diff] [blame] | 368 | s->start(); |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 369 | } |
| 370 | |
Marek Vasut | 95656ea | 2012-10-08 11:36:39 +0000 | [diff] [blame] | 371 | /** |
| 372 | * get_current() - Return pointer to currently selected serial port |
| 373 | * |
| 374 | * This function returns a pointer to currently selected serial port. |
| 375 | * The currently selected serial port is altered by serial_assign() |
| 376 | * function. |
| 377 | * |
| 378 | * In case this function is called before relocation or before any serial |
| 379 | * port is configured, this function calls default_serial_console() to |
| 380 | * determine the serial port. Otherwise, the configured serial port is |
| 381 | * returned. |
| 382 | * |
| 383 | * Returns pointer to the currently selected serial port on success, |
| 384 | * NULL on error. |
| 385 | */ |
Simon Glass | 8f4e6f1 | 2011-08-19 11:09:43 +0000 | [diff] [blame] | 386 | static struct serial_device *get_current(void) |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 387 | { |
Simon Glass | 8f4e6f1 | 2011-08-19 11:09:43 +0000 | [diff] [blame] | 388 | struct serial_device *dev; |
| 389 | |
Marek Vasut | bdad807 | 2012-10-06 14:07:04 +0000 | [diff] [blame] | 390 | if (!(gd->flags & GD_FLG_RELOC)) |
Simon Glass | 8f4e6f1 | 2011-08-19 11:09:43 +0000 | [diff] [blame] | 391 | dev = default_serial_console(); |
Marek Vasut | bdad807 | 2012-10-06 14:07:04 +0000 | [diff] [blame] | 392 | else if (!serial_current) |
| 393 | dev = default_serial_console(); |
| 394 | else |
| 395 | dev = serial_current; |
wdenk | 8f08c5b | 2004-10-11 22:43:02 +0000 | [diff] [blame] | 396 | |
Marek Vasut | bdad807 | 2012-10-06 14:07:04 +0000 | [diff] [blame] | 397 | /* We must have a console device */ |
| 398 | if (!dev) { |
Marek Vasut | a6f6334 | 2012-09-15 10:33:51 +0200 | [diff] [blame] | 399 | #ifdef CONFIG_SPL_BUILD |
Marek Vasut | bdad807 | 2012-10-06 14:07:04 +0000 | [diff] [blame] | 400 | puts("Cannot find console\n"); |
| 401 | hang(); |
Marek Vasut | a6f6334 | 2012-09-15 10:33:51 +0200 | [diff] [blame] | 402 | #else |
Marek Vasut | bdad807 | 2012-10-06 14:07:04 +0000 | [diff] [blame] | 403 | panic("Cannot find console\n"); |
Marek Vasut | a6f6334 | 2012-09-15 10:33:51 +0200 | [diff] [blame] | 404 | #endif |
Marek Vasut | bdad807 | 2012-10-06 14:07:04 +0000 | [diff] [blame] | 405 | } |
| 406 | |
Simon Glass | 8f4e6f1 | 2011-08-19 11:09:43 +0000 | [diff] [blame] | 407 | return dev; |
| 408 | } |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 409 | |
Marek Vasut | 95656ea | 2012-10-08 11:36:39 +0000 | [diff] [blame] | 410 | /** |
| 411 | * serial_init() - Initialize currently selected serial port |
| 412 | * |
| 413 | * This function initializes the currently selected serial port. This |
| 414 | * usually involves setting up the registers of that particular port, |
| 415 | * enabling clock and such. This function uses the get_current() call |
| 416 | * to determine which port is selected. |
| 417 | * |
| 418 | * Returns 0 on success, negative on error. |
| 419 | */ |
Simon Glass | 8f4e6f1 | 2011-08-19 11:09:43 +0000 | [diff] [blame] | 420 | int serial_init(void) |
| 421 | { |
Simon Glass | b9d5f6b | 2014-07-23 06:55:07 -0600 | [diff] [blame] | 422 | gd->flags |= GD_FLG_SERIAL_READY; |
Marek Vasut | b46931d | 2012-09-07 14:35:31 +0200 | [diff] [blame] | 423 | return get_current()->start(); |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 424 | } |
| 425 | |
Marek Vasut | 95656ea | 2012-10-08 11:36:39 +0000 | [diff] [blame] | 426 | /** |
| 427 | * serial_setbrg() - Configure baud-rate of currently selected serial port |
| 428 | * |
| 429 | * This function configures the baud-rate of the currently selected |
| 430 | * serial port. The baud-rate is retrieved from global data within |
| 431 | * the serial port driver. This function uses the get_current() call |
| 432 | * to determine which port is selected. |
| 433 | * |
| 434 | * Returns 0 on success, negative on error. |
| 435 | */ |
Gerlando Falauto | 34148d6 | 2011-11-18 06:49:11 +0000 | [diff] [blame] | 436 | void serial_setbrg(void) |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 437 | { |
Simon Glass | 8f4e6f1 | 2011-08-19 11:09:43 +0000 | [diff] [blame] | 438 | get_current()->setbrg(); |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 439 | } |
| 440 | |
Marek Vasut | 95656ea | 2012-10-08 11:36:39 +0000 | [diff] [blame] | 441 | /** |
| 442 | * serial_getc() - Read character from currently selected serial port |
| 443 | * |
| 444 | * This function retrieves a character from currently selected serial |
| 445 | * port. In case there is no character waiting on the serial port, |
| 446 | * this function will block and wait for the character to appear. This |
| 447 | * function uses the get_current() call to determine which port is |
| 448 | * selected. |
| 449 | * |
| 450 | * Returns the character on success, negative on error. |
| 451 | */ |
Gerlando Falauto | 34148d6 | 2011-11-18 06:49:11 +0000 | [diff] [blame] | 452 | int serial_getc(void) |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 453 | { |
Simon Glass | 8f4e6f1 | 2011-08-19 11:09:43 +0000 | [diff] [blame] | 454 | return get_current()->getc(); |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 455 | } |
| 456 | |
Marek Vasut | 95656ea | 2012-10-08 11:36:39 +0000 | [diff] [blame] | 457 | /** |
| 458 | * serial_tstc() - Test if data is available on currently selected serial port |
| 459 | * |
| 460 | * This function tests if one or more characters are available on |
| 461 | * currently selected serial port. This function never blocks. This |
| 462 | * function uses the get_current() call to determine which port is |
| 463 | * selected. |
| 464 | * |
| 465 | * Returns positive if character is available, zero otherwise. |
| 466 | */ |
Gerlando Falauto | 34148d6 | 2011-11-18 06:49:11 +0000 | [diff] [blame] | 467 | int serial_tstc(void) |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 468 | { |
Simon Glass | 8f4e6f1 | 2011-08-19 11:09:43 +0000 | [diff] [blame] | 469 | return get_current()->tstc(); |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 470 | } |
| 471 | |
Marek Vasut | 95656ea | 2012-10-08 11:36:39 +0000 | [diff] [blame] | 472 | /** |
| 473 | * serial_putc() - Output character via currently selected serial port |
| 474 | * @c: Single character to be output from the serial port. |
| 475 | * |
| 476 | * This function outputs a character via currently selected serial |
| 477 | * port. This character is passed to the serial port driver responsible |
| 478 | * for controlling the hardware. The hardware may still be in process |
| 479 | * of transmitting another character, therefore this function may block |
| 480 | * for a short amount of time. This function uses the get_current() |
| 481 | * call to determine which port is selected. |
| 482 | */ |
Gerlando Falauto | 34148d6 | 2011-11-18 06:49:11 +0000 | [diff] [blame] | 483 | void serial_putc(const char c) |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 484 | { |
Simon Glass | 8f4e6f1 | 2011-08-19 11:09:43 +0000 | [diff] [blame] | 485 | get_current()->putc(c); |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 486 | } |
| 487 | |
Marek Vasut | 95656ea | 2012-10-08 11:36:39 +0000 | [diff] [blame] | 488 | /** |
| 489 | * serial_puts() - Output string via currently selected serial port |
| 490 | * @s: Zero-terminated string to be output from the serial port. |
| 491 | * |
| 492 | * This function outputs a zero-terminated string via currently |
| 493 | * selected serial port. This function behaves as an accelerator |
| 494 | * in case the hardware can queue multiple characters for transfer. |
| 495 | * The whole string that is to be output is available to the function |
| 496 | * implementing the hardware manipulation. Transmitting the whole |
| 497 | * string may take some time, thus this function may block for some |
| 498 | * amount of time. This function uses the get_current() call to |
| 499 | * determine which port is selected. |
| 500 | */ |
Gerlando Falauto | 34148d6 | 2011-11-18 06:49:11 +0000 | [diff] [blame] | 501 | void serial_puts(const char *s) |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 502 | { |
Simon Glass | 8f4e6f1 | 2011-08-19 11:09:43 +0000 | [diff] [blame] | 503 | get_current()->puts(s); |
wdenk | 7ac1610 | 2004-08-01 22:48:16 +0000 | [diff] [blame] | 504 | } |
Mike Frysinger | 078f2f1 | 2011-05-14 06:56:15 +0000 | [diff] [blame] | 505 | |
Marek Vasut | 95656ea | 2012-10-08 11:36:39 +0000 | [diff] [blame] | 506 | /** |
| 507 | * default_serial_puts() - Output string by calling serial_putc() in loop |
| 508 | * @s: Zero-terminated string to be output from the serial port. |
| 509 | * |
| 510 | * This function outputs a zero-terminated string by calling serial_putc() |
| 511 | * in a loop. Most drivers do not support queueing more than one byte for |
| 512 | * transfer, thus this function precisely implements their serial_puts(). |
| 513 | * |
| 514 | * To optimize the number of get_current() calls, this function only |
| 515 | * calls get_current() once and then directly accesses the putc() call |
| 516 | * of the &struct serial_device . |
| 517 | */ |
Marek Vasut | 6b9124e | 2012-10-06 14:07:01 +0000 | [diff] [blame] | 518 | void default_serial_puts(const char *s) |
| 519 | { |
| 520 | struct serial_device *dev = get_current(); |
| 521 | while (*s) |
| 522 | dev->putc(*s++); |
| 523 | } |
| 524 | |
Mike Frysinger | 078f2f1 | 2011-05-14 06:56:15 +0000 | [diff] [blame] | 525 | #if CONFIG_POST & CONFIG_SYS_POST_UART |
| 526 | static const int bauds[] = CONFIG_SYS_BAUDRATE_TABLE; |
| 527 | |
Marek Vasut | 95656ea | 2012-10-08 11:36:39 +0000 | [diff] [blame] | 528 | /** |
| 529 | * uart_post_test() - Test the currently selected serial port using POST |
| 530 | * @flags: POST framework flags |
| 531 | * |
| 532 | * Do a loopback test of the currently selected serial port. This |
| 533 | * function is only useful in the context of the POST testing framwork. |
| 534 | * The serial port is firstly configured into loopback mode and then |
| 535 | * characters are sent through it. |
| 536 | * |
| 537 | * Returns 0 on success, value otherwise. |
| 538 | */ |
Mike Frysinger | 078f2f1 | 2011-05-14 06:56:15 +0000 | [diff] [blame] | 539 | /* Mark weak until post/cpu/.../uart.c migrate over */ |
| 540 | __weak |
| 541 | int uart_post_test(int flags) |
| 542 | { |
| 543 | unsigned char c; |
| 544 | int ret, saved_baud, b; |
| 545 | struct serial_device *saved_dev, *s; |
Mike Frysinger | 078f2f1 | 2011-05-14 06:56:15 +0000 | [diff] [blame] | 546 | |
| 547 | /* Save current serial state */ |
| 548 | ret = 0; |
| 549 | saved_dev = serial_current; |
Masahiro Yamada | 197c720 | 2014-04-04 20:09:58 +0900 | [diff] [blame] | 550 | saved_baud = gd->baudrate; |
Mike Frysinger | 078f2f1 | 2011-05-14 06:56:15 +0000 | [diff] [blame] | 551 | |
| 552 | for (s = serial_devices; s; s = s->next) { |
| 553 | /* If this driver doesn't support loop back, skip it */ |
| 554 | if (!s->loop) |
| 555 | continue; |
| 556 | |
| 557 | /* Test the next device */ |
| 558 | serial_current = s; |
| 559 | |
| 560 | ret = serial_init(); |
| 561 | if (ret) |
| 562 | goto done; |
| 563 | |
| 564 | /* Consume anything that happens to be queued */ |
| 565 | while (serial_tstc()) |
| 566 | serial_getc(); |
| 567 | |
| 568 | /* Enable loop back */ |
| 569 | s->loop(1); |
| 570 | |
| 571 | /* Test every available baud rate */ |
| 572 | for (b = 0; b < ARRAY_SIZE(bauds); ++b) { |
Masahiro Yamada | 197c720 | 2014-04-04 20:09:58 +0900 | [diff] [blame] | 573 | gd->baudrate = bauds[b]; |
Mike Frysinger | 078f2f1 | 2011-05-14 06:56:15 +0000 | [diff] [blame] | 574 | serial_setbrg(); |
| 575 | |
| 576 | /* |
| 577 | * Stick to printable chars to avoid issues: |
| 578 | * - terminal corruption |
| 579 | * - serial program reacting to sequences and sending |
| 580 | * back random extra data |
| 581 | * - most serial drivers add in extra chars (like \r\n) |
| 582 | */ |
| 583 | for (c = 0x20; c < 0x7f; ++c) { |
| 584 | /* Send it out */ |
| 585 | serial_putc(c); |
| 586 | |
| 587 | /* Make sure it's the same one */ |
| 588 | ret = (c != serial_getc()); |
| 589 | if (ret) { |
| 590 | s->loop(0); |
| 591 | goto done; |
| 592 | } |
| 593 | |
| 594 | /* Clean up the output in case it was sent */ |
| 595 | serial_putc('\b'); |
| 596 | ret = ('\b' != serial_getc()); |
| 597 | if (ret) { |
| 598 | s->loop(0); |
| 599 | goto done; |
| 600 | } |
| 601 | } |
| 602 | } |
| 603 | |
| 604 | /* Disable loop back */ |
| 605 | s->loop(0); |
| 606 | |
Marek Vasut | b46931d | 2012-09-07 14:35:31 +0200 | [diff] [blame] | 607 | /* XXX: There is no serial_stop() !? */ |
| 608 | if (s->stop) |
| 609 | s->stop(); |
Mike Frysinger | 078f2f1 | 2011-05-14 06:56:15 +0000 | [diff] [blame] | 610 | } |
| 611 | |
| 612 | done: |
| 613 | /* Restore previous serial state */ |
| 614 | serial_current = saved_dev; |
Masahiro Yamada | 197c720 | 2014-04-04 20:09:58 +0900 | [diff] [blame] | 615 | gd->baudrate = saved_baud; |
Mike Frysinger | 078f2f1 | 2011-05-14 06:56:15 +0000 | [diff] [blame] | 616 | serial_reinit_all(); |
| 617 | serial_setbrg(); |
| 618 | |
| 619 | return ret; |
| 620 | } |
| 621 | #endif |