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