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 int serial_stub_start(struct stdio_dev *sdev) 258 { 259 struct serial_device *dev = sdev->priv; 260 261 return dev->start(); 262 } 263 264 int serial_stub_stop(struct stdio_dev *sdev) 265 { 266 struct serial_device *dev = sdev->priv; 267 268 return dev->stop(); 269 } 270 271 void serial_stub_putc(struct stdio_dev *sdev, const char ch) 272 { 273 struct serial_device *dev = sdev->priv; 274 275 dev->putc(ch); 276 } 277 278 void serial_stub_puts(struct stdio_dev *sdev, const char *str) 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 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 */ 306 void serial_stdio_init(void) 307 { 308 struct stdio_dev dev; 309 struct serial_device *s = serial_devices; 310 311 while (s) { 312 memset(&dev, 0, sizeof(dev)); 313 314 strcpy(dev.name, s->name); 315 dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT; 316 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; 323 324 stdio_register(&dev); 325 326 s = s->next; 327 } 328 } 329 330 /** 331 * serial_assign() - Select the serial output device by name 332 * @name: Name of the serial driver to be used as default output 333 * 334 * This function configures the serial output multiplexing by 335 * selecting which serial device will be used as default. In case 336 * the STDIO "serial" device is selected as stdin/stdout/stderr, 337 * the serial device previously configured by this function will be 338 * used for the particular operation. 339 * 340 * Returns 0 on success, negative on error. 341 */ 342 int serial_assign(const char *name) 343 { 344 struct serial_device *s; 345 346 for (s = serial_devices; s; s = s->next) { 347 if (strcmp(s->name, name)) 348 continue; 349 serial_current = s; 350 return 0; 351 } 352 353 return -EINVAL; 354 } 355 356 /** 357 * serial_reinit_all() - Reinitialize all compiled-in serial ports 358 * 359 * This function reinitializes all serial ports that are compiled 360 * into U-Boot by calling their serial_start() functions. 361 */ 362 void serial_reinit_all(void) 363 { 364 struct serial_device *s; 365 366 for (s = serial_devices; s; s = s->next) 367 s->start(); 368 } 369 370 /** 371 * get_current() - Return pointer to currently selected serial port 372 * 373 * This function returns a pointer to currently selected serial port. 374 * The currently selected serial port is altered by serial_assign() 375 * function. 376 * 377 * In case this function is called before relocation or before any serial 378 * port is configured, this function calls default_serial_console() to 379 * determine the serial port. Otherwise, the configured serial port is 380 * returned. 381 * 382 * Returns pointer to the currently selected serial port on success, 383 * NULL on error. 384 */ 385 static struct serial_device *get_current(void) 386 { 387 struct serial_device *dev; 388 389 if (!(gd->flags & GD_FLG_RELOC)) 390 dev = default_serial_console(); 391 else if (!serial_current) 392 dev = default_serial_console(); 393 else 394 dev = serial_current; 395 396 /* We must have a console device */ 397 if (!dev) { 398 #ifdef CONFIG_SPL_BUILD 399 puts("Cannot find console\n"); 400 hang(); 401 #else 402 panic("Cannot find console\n"); 403 #endif 404 } 405 406 return dev; 407 } 408 409 /** 410 * serial_init() - Initialize currently selected serial port 411 * 412 * This function initializes the currently selected serial port. This 413 * usually involves setting up the registers of that particular port, 414 * enabling clock and such. This function uses the get_current() call 415 * to determine which port is selected. 416 * 417 * Returns 0 on success, negative on error. 418 */ 419 int serial_init(void) 420 { 421 return get_current()->start(); 422 } 423 424 /** 425 * serial_setbrg() - Configure baud-rate of currently selected serial port 426 * 427 * This function configures the baud-rate of the currently selected 428 * serial port. The baud-rate is retrieved from global data within 429 * the serial port driver. This function uses the get_current() call 430 * to determine which port is selected. 431 * 432 * Returns 0 on success, negative on error. 433 */ 434 void serial_setbrg(void) 435 { 436 get_current()->setbrg(); 437 } 438 439 /** 440 * serial_getc() - Read character from currently selected serial port 441 * 442 * This function retrieves a character from currently selected serial 443 * port. In case there is no character waiting on the serial port, 444 * this function will block and wait for the character to appear. This 445 * function uses the get_current() call to determine which port is 446 * selected. 447 * 448 * Returns the character on success, negative on error. 449 */ 450 int serial_getc(void) 451 { 452 return get_current()->getc(); 453 } 454 455 /** 456 * serial_tstc() - Test if data is available on currently selected serial port 457 * 458 * This function tests if one or more characters are available on 459 * currently selected serial port. This function never blocks. This 460 * function uses the get_current() call to determine which port is 461 * selected. 462 * 463 * Returns positive if character is available, zero otherwise. 464 */ 465 int serial_tstc(void) 466 { 467 return get_current()->tstc(); 468 } 469 470 /** 471 * serial_putc() - Output character via currently selected serial port 472 * @c: Single character to be output from the serial port. 473 * 474 * This function outputs a character via currently selected serial 475 * port. This character is passed to the serial port driver responsible 476 * for controlling the hardware. The hardware may still be in process 477 * of transmitting another character, therefore this function may block 478 * for a short amount of time. This function uses the get_current() 479 * call to determine which port is selected. 480 */ 481 void serial_putc(const char c) 482 { 483 get_current()->putc(c); 484 } 485 486 /** 487 * serial_puts() - Output string via currently selected serial port 488 * @s: Zero-terminated string to be output from the serial port. 489 * 490 * This function outputs a zero-terminated string via currently 491 * selected serial port. This function behaves as an accelerator 492 * in case the hardware can queue multiple characters for transfer. 493 * The whole string that is to be output is available to the function 494 * implementing the hardware manipulation. Transmitting the whole 495 * string may take some time, thus this function may block for some 496 * amount of time. This function uses the get_current() call to 497 * determine which port is selected. 498 */ 499 void serial_puts(const char *s) 500 { 501 get_current()->puts(s); 502 } 503 504 /** 505 * default_serial_puts() - Output string by calling serial_putc() in loop 506 * @s: Zero-terminated string to be output from the serial port. 507 * 508 * This function outputs a zero-terminated string by calling serial_putc() 509 * in a loop. Most drivers do not support queueing more than one byte for 510 * transfer, thus this function precisely implements their serial_puts(). 511 * 512 * To optimize the number of get_current() calls, this function only 513 * calls get_current() once and then directly accesses the putc() call 514 * of the &struct serial_device . 515 */ 516 void default_serial_puts(const char *s) 517 { 518 struct serial_device *dev = get_current(); 519 while (*s) 520 dev->putc(*s++); 521 } 522 523 #if CONFIG_POST & CONFIG_SYS_POST_UART 524 static const int bauds[] = CONFIG_SYS_BAUDRATE_TABLE; 525 526 /** 527 * uart_post_test() - Test the currently selected serial port using POST 528 * @flags: POST framework flags 529 * 530 * Do a loopback test of the currently selected serial port. This 531 * function is only useful in the context of the POST testing framwork. 532 * The serial port is firstly configured into loopback mode and then 533 * characters are sent through it. 534 * 535 * Returns 0 on success, value otherwise. 536 */ 537 /* Mark weak until post/cpu/.../uart.c migrate over */ 538 __weak 539 int uart_post_test(int flags) 540 { 541 unsigned char c; 542 int ret, saved_baud, b; 543 struct serial_device *saved_dev, *s; 544 545 /* Save current serial state */ 546 ret = 0; 547 saved_dev = serial_current; 548 saved_baud = gd->baudrate; 549 550 for (s = serial_devices; s; s = s->next) { 551 /* If this driver doesn't support loop back, skip it */ 552 if (!s->loop) 553 continue; 554 555 /* Test the next device */ 556 serial_current = s; 557 558 ret = serial_init(); 559 if (ret) 560 goto done; 561 562 /* Consume anything that happens to be queued */ 563 while (serial_tstc()) 564 serial_getc(); 565 566 /* Enable loop back */ 567 s->loop(1); 568 569 /* Test every available baud rate */ 570 for (b = 0; b < ARRAY_SIZE(bauds); ++b) { 571 gd->baudrate = bauds[b]; 572 serial_setbrg(); 573 574 /* 575 * Stick to printable chars to avoid issues: 576 * - terminal corruption 577 * - serial program reacting to sequences and sending 578 * back random extra data 579 * - most serial drivers add in extra chars (like \r\n) 580 */ 581 for (c = 0x20; c < 0x7f; ++c) { 582 /* Send it out */ 583 serial_putc(c); 584 585 /* Make sure it's the same one */ 586 ret = (c != serial_getc()); 587 if (ret) { 588 s->loop(0); 589 goto done; 590 } 591 592 /* Clean up the output in case it was sent */ 593 serial_putc('\b'); 594 ret = ('\b' != serial_getc()); 595 if (ret) { 596 s->loop(0); 597 goto done; 598 } 599 } 600 } 601 602 /* Disable loop back */ 603 s->loop(0); 604 605 /* XXX: There is no serial_stop() !? */ 606 if (s->stop) 607 s->stop(); 608 } 609 610 done: 611 /* Restore previous serial state */ 612 serial_current = saved_dev; 613 gd->baudrate = saved_baud; 614 serial_reinit_all(); 615 serial_setbrg(); 616 617 return ret; 618 } 619 #endif 620