1 /* 2 * (C) Copyright 2004 3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 8 #include <common.h> 9 #include <environment.h> 10 #include <serial.h> 11 #include <stdio_dev.h> 12 #include <post.h> 13 #include <linux/compiler.h> 14 #include <errno.h> 15 16 DECLARE_GLOBAL_DATA_PTR; 17 18 static struct serial_device *serial_devices; 19 static struct serial_device *serial_current; 20 /* 21 * Table with supported baudrates (defined in config_xyz.h) 22 */ 23 static const unsigned long baudrate_table[] = CONFIG_SYS_BAUDRATE_TABLE; 24 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 */ 33 static void serial_null(void) 34 { 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 60 for (i = 0; i < ARRAY_SIZE(baudrate_table); ++i) { 61 if (baudrate == baudrate_table[i]) 62 break; 63 } 64 if (i == ARRAY_SIZE(baudrate_table)) { 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; 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 } 95 } 96 U_BOOT_ENV_CALLBACK(baudrate, on_baudrate); 97 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 */ 108 #define serial_initfunc(name) \ 109 void name(void) \ 110 __attribute__((weak, alias("serial_null"))); 111 112 serial_initfunc(mpc8xx_serial_initialize); 113 serial_initfunc(ns16550_serial_initialize); 114 serial_initfunc(pxa_serial_initialize); 115 serial_initfunc(s3c24xx_serial_initialize); 116 serial_initfunc(s5p_serial_initialize); 117 serial_initfunc(zynq_serial_initialize); 118 serial_initfunc(bfin_serial_initialize); 119 serial_initfunc(bfin_jtag_initialize); 120 serial_initfunc(mpc512x_serial_initialize); 121 serial_initfunc(uartlite_serial_initialize); 122 serial_initfunc(au1x00_serial_initialize); 123 serial_initfunc(asc_serial_initialize); 124 serial_initfunc(jz_serial_initialize); 125 serial_initfunc(mpc5xx_serial_initialize); 126 serial_initfunc(mpc8260_scc_serial_initialize); 127 serial_initfunc(mpc8260_smc_serial_initialize); 128 serial_initfunc(mpc85xx_serial_initialize); 129 serial_initfunc(iop480_serial_initialize); 130 serial_initfunc(leon2_serial_initialize); 131 serial_initfunc(leon3_serial_initialize); 132 serial_initfunc(marvell_serial_initialize); 133 serial_initfunc(amirix_serial_initialize); 134 serial_initfunc(bmw_serial_initialize); 135 serial_initfunc(cogent_serial_initialize); 136 serial_initfunc(cpci750_serial_initialize); 137 serial_initfunc(evb64260_serial_initialize); 138 serial_initfunc(ml2_serial_initialize); 139 serial_initfunc(sconsole_serial_initialize); 140 serial_initfunc(p3mx_serial_initialize); 141 serial_initfunc(altera_jtag_serial_initialize); 142 serial_initfunc(altera_serial_initialize); 143 serial_initfunc(atmel_serial_initialize); 144 serial_initfunc(lpc32xx_serial_initialize); 145 serial_initfunc(mcf_serial_initialize); 146 serial_initfunc(oc_serial_initialize); 147 serial_initfunc(sandbox_serial_initialize); 148 serial_initfunc(clps7111_serial_initialize); 149 serial_initfunc(imx_serial_initialize); 150 serial_initfunc(ks8695_serial_initialize); 151 serial_initfunc(lh7a40x_serial_initialize); 152 serial_initfunc(max3100_serial_initialize); 153 serial_initfunc(mxc_serial_initialize); 154 serial_initfunc(pl01x_serial_initialize); 155 serial_initfunc(sa1100_serial_initialize); 156 serial_initfunc(sh_serial_initialize); 157 serial_initfunc(arm_dcc_initialize); 158 serial_initfunc(mxs_auart_initialize); 159 serial_initfunc(arc_serial_initialize); 160 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 */ 171 void serial_register(struct serial_device *dev) 172 { 173 #ifdef CONFIG_NEEDS_MANUAL_RELOC 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; 188 #endif 189 190 dev->next = serial_devices; 191 serial_devices = dev; 192 } 193 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 */ 203 void serial_initialize(void) 204 { 205 mpc8xx_serial_initialize(); 206 ns16550_serial_initialize(); 207 pxa_serial_initialize(); 208 s3c24xx_serial_initialize(); 209 s5p_serial_initialize(); 210 mpc512x_serial_initialize(); 211 bfin_serial_initialize(); 212 bfin_jtag_initialize(); 213 uartlite_serial_initialize(); 214 zynq_serial_initialize(); 215 au1x00_serial_initialize(); 216 asc_serial_initialize(); 217 jz_serial_initialize(); 218 mpc5xx_serial_initialize(); 219 mpc8260_scc_serial_initialize(); 220 mpc8260_smc_serial_initialize(); 221 mpc85xx_serial_initialize(); 222 iop480_serial_initialize(); 223 leon2_serial_initialize(); 224 leon3_serial_initialize(); 225 marvell_serial_initialize(); 226 amirix_serial_initialize(); 227 bmw_serial_initialize(); 228 cogent_serial_initialize(); 229 cpci750_serial_initialize(); 230 evb64260_serial_initialize(); 231 ml2_serial_initialize(); 232 sconsole_serial_initialize(); 233 p3mx_serial_initialize(); 234 altera_jtag_serial_initialize(); 235 altera_serial_initialize(); 236 atmel_serial_initialize(); 237 lpc32xx_serial_initialize(); 238 mcf_serial_initialize(); 239 oc_serial_initialize(); 240 sandbox_serial_initialize(); 241 clps7111_serial_initialize(); 242 imx_serial_initialize(); 243 ks8695_serial_initialize(); 244 lh7a40x_serial_initialize(); 245 max3100_serial_initialize(); 246 mxc_serial_initialize(); 247 pl01x_serial_initialize(); 248 sa1100_serial_initialize(); 249 sh_serial_initialize(); 250 arm_dcc_initialize(); 251 mxs_auart_initialize(); 252 arc_serial_initialize(); 253 254 serial_assign(default_serial_console()->name); 255 } 256 257 /** 258 * serial_stdio_init() - Register serial ports with STDIO core 259 * 260 * This function generates a proxy driver for each serial port driver. 261 * These proxy drivers then register with the STDIO core, making the 262 * serial drivers available as STDIO devices. 263 */ 264 void serial_stdio_init(void) 265 { 266 struct stdio_dev dev; 267 struct serial_device *s = serial_devices; 268 269 while (s) { 270 memset(&dev, 0, sizeof(dev)); 271 272 strcpy(dev.name, s->name); 273 dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT; 274 275 dev.start = s->start; 276 dev.stop = s->stop; 277 dev.putc = s->putc; 278 dev.puts = s->puts; 279 dev.getc = s->getc; 280 dev.tstc = s->tstc; 281 282 stdio_register(&dev); 283 284 s = s->next; 285 } 286 } 287 288 /** 289 * serial_assign() - Select the serial output device by name 290 * @name: Name of the serial driver to be used as default output 291 * 292 * This function configures the serial output multiplexing by 293 * selecting which serial device will be used as default. In case 294 * the STDIO "serial" device is selected as stdin/stdout/stderr, 295 * the serial device previously configured by this function will be 296 * used for the particular operation. 297 * 298 * Returns 0 on success, negative on error. 299 */ 300 int serial_assign(const char *name) 301 { 302 struct serial_device *s; 303 304 for (s = serial_devices; s; s = s->next) { 305 if (strcmp(s->name, name)) 306 continue; 307 serial_current = s; 308 return 0; 309 } 310 311 return -EINVAL; 312 } 313 314 /** 315 * serial_reinit_all() - Reinitialize all compiled-in serial ports 316 * 317 * This function reinitializes all serial ports that are compiled 318 * into U-Boot by calling their serial_start() functions. 319 */ 320 void serial_reinit_all(void) 321 { 322 struct serial_device *s; 323 324 for (s = serial_devices; s; s = s->next) 325 s->start(); 326 } 327 328 /** 329 * get_current() - Return pointer to currently selected serial port 330 * 331 * This function returns a pointer to currently selected serial port. 332 * The currently selected serial port is altered by serial_assign() 333 * function. 334 * 335 * In case this function is called before relocation or before any serial 336 * port is configured, this function calls default_serial_console() to 337 * determine the serial port. Otherwise, the configured serial port is 338 * returned. 339 * 340 * Returns pointer to the currently selected serial port on success, 341 * NULL on error. 342 */ 343 static struct serial_device *get_current(void) 344 { 345 struct serial_device *dev; 346 347 if (!(gd->flags & GD_FLG_RELOC)) 348 dev = default_serial_console(); 349 else if (!serial_current) 350 dev = default_serial_console(); 351 else 352 dev = serial_current; 353 354 /* We must have a console device */ 355 if (!dev) { 356 #ifdef CONFIG_SPL_BUILD 357 puts("Cannot find console\n"); 358 hang(); 359 #else 360 panic("Cannot find console\n"); 361 #endif 362 } 363 364 return dev; 365 } 366 367 /** 368 * serial_init() - Initialize currently selected serial port 369 * 370 * This function initializes the currently selected serial port. This 371 * usually involves setting up the registers of that particular port, 372 * enabling clock and such. This function uses the get_current() call 373 * to determine which port is selected. 374 * 375 * Returns 0 on success, negative on error. 376 */ 377 int serial_init(void) 378 { 379 return get_current()->start(); 380 } 381 382 /** 383 * serial_setbrg() - Configure baud-rate of currently selected serial port 384 * 385 * This function configures the baud-rate of the currently selected 386 * serial port. The baud-rate is retrieved from global data within 387 * the serial port driver. This function uses the get_current() call 388 * to determine which port is selected. 389 * 390 * Returns 0 on success, negative on error. 391 */ 392 void serial_setbrg(void) 393 { 394 get_current()->setbrg(); 395 } 396 397 /** 398 * serial_getc() - Read character from currently selected serial port 399 * 400 * This function retrieves a character from currently selected serial 401 * port. In case there is no character waiting on the serial port, 402 * this function will block and wait for the character to appear. This 403 * function uses the get_current() call to determine which port is 404 * selected. 405 * 406 * Returns the character on success, negative on error. 407 */ 408 int serial_getc(void) 409 { 410 return get_current()->getc(); 411 } 412 413 /** 414 * serial_tstc() - Test if data is available on currently selected serial port 415 * 416 * This function tests if one or more characters are available on 417 * currently selected serial port. This function never blocks. This 418 * function uses the get_current() call to determine which port is 419 * selected. 420 * 421 * Returns positive if character is available, zero otherwise. 422 */ 423 int serial_tstc(void) 424 { 425 return get_current()->tstc(); 426 } 427 428 /** 429 * serial_putc() - Output character via currently selected serial port 430 * @c: Single character to be output from the serial port. 431 * 432 * This function outputs a character via currently selected serial 433 * port. This character is passed to the serial port driver responsible 434 * for controlling the hardware. The hardware may still be in process 435 * of transmitting another character, therefore this function may block 436 * for a short amount of time. This function uses the get_current() 437 * call to determine which port is selected. 438 */ 439 void serial_putc(const char c) 440 { 441 get_current()->putc(c); 442 } 443 444 /** 445 * serial_puts() - Output string via currently selected serial port 446 * @s: Zero-terminated string to be output from the serial port. 447 * 448 * This function outputs a zero-terminated string via currently 449 * selected serial port. This function behaves as an accelerator 450 * in case the hardware can queue multiple characters for transfer. 451 * The whole string that is to be output is available to the function 452 * implementing the hardware manipulation. Transmitting the whole 453 * string may take some time, thus this function may block for some 454 * amount of time. This function uses the get_current() call to 455 * determine which port is selected. 456 */ 457 void serial_puts(const char *s) 458 { 459 get_current()->puts(s); 460 } 461 462 /** 463 * default_serial_puts() - Output string by calling serial_putc() in loop 464 * @s: Zero-terminated string to be output from the serial port. 465 * 466 * This function outputs a zero-terminated string by calling serial_putc() 467 * in a loop. Most drivers do not support queueing more than one byte for 468 * transfer, thus this function precisely implements their serial_puts(). 469 * 470 * To optimize the number of get_current() calls, this function only 471 * calls get_current() once and then directly accesses the putc() call 472 * of the &struct serial_device . 473 */ 474 void default_serial_puts(const char *s) 475 { 476 struct serial_device *dev = get_current(); 477 while (*s) 478 dev->putc(*s++); 479 } 480 481 #if CONFIG_POST & CONFIG_SYS_POST_UART 482 static const int bauds[] = CONFIG_SYS_BAUDRATE_TABLE; 483 484 /** 485 * uart_post_test() - Test the currently selected serial port using POST 486 * @flags: POST framework flags 487 * 488 * Do a loopback test of the currently selected serial port. This 489 * function is only useful in the context of the POST testing framwork. 490 * The serial port is firstly configured into loopback mode and then 491 * characters are sent through it. 492 * 493 * Returns 0 on success, value otherwise. 494 */ 495 /* Mark weak until post/cpu/.../uart.c migrate over */ 496 __weak 497 int uart_post_test(int flags) 498 { 499 unsigned char c; 500 int ret, saved_baud, b; 501 struct serial_device *saved_dev, *s; 502 503 /* Save current serial state */ 504 ret = 0; 505 saved_dev = serial_current; 506 saved_baud = gd->baudrate; 507 508 for (s = serial_devices; s; s = s->next) { 509 /* If this driver doesn't support loop back, skip it */ 510 if (!s->loop) 511 continue; 512 513 /* Test the next device */ 514 serial_current = s; 515 516 ret = serial_init(); 517 if (ret) 518 goto done; 519 520 /* Consume anything that happens to be queued */ 521 while (serial_tstc()) 522 serial_getc(); 523 524 /* Enable loop back */ 525 s->loop(1); 526 527 /* Test every available baud rate */ 528 for (b = 0; b < ARRAY_SIZE(bauds); ++b) { 529 gd->baudrate = bauds[b]; 530 serial_setbrg(); 531 532 /* 533 * Stick to printable chars to avoid issues: 534 * - terminal corruption 535 * - serial program reacting to sequences and sending 536 * back random extra data 537 * - most serial drivers add in extra chars (like \r\n) 538 */ 539 for (c = 0x20; c < 0x7f; ++c) { 540 /* Send it out */ 541 serial_putc(c); 542 543 /* Make sure it's the same one */ 544 ret = (c != serial_getc()); 545 if (ret) { 546 s->loop(0); 547 goto done; 548 } 549 550 /* Clean up the output in case it was sent */ 551 serial_putc('\b'); 552 ret = ('\b' != serial_getc()); 553 if (ret) { 554 s->loop(0); 555 goto done; 556 } 557 } 558 } 559 560 /* Disable loop back */ 561 s->loop(0); 562 563 /* XXX: There is no serial_stop() !? */ 564 if (s->stop) 565 s->stop(); 566 } 567 568 done: 569 /* Restore previous serial state */ 570 serial_current = saved_dev; 571 gd->baudrate = saved_baud; 572 serial_reinit_all(); 573 serial_setbrg(); 574 575 return ret; 576 } 577 #endif 578