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