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