1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * (C) Copyright 2004 4 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. 5 */ 6 7#include <common.h> 8#include <env_internal.h> 9#include <hang.h> 10#include <serial.h> 11#include <stdio_dev.h> 12#include <post.h> 13#include <asm/global_data.h> 14#include <linux/compiler.h> 15#include <errno.h> 16#include <linux/delay.h> 17 18DECLARE_GLOBAL_DATA_PTR; 19 20static struct serial_device *serial_devices; 21static struct serial_device *serial_current; 22/* 23 * Table with supported baudrates (defined in config_xyz.h) 24 */ 25static const unsigned long baudrate_table[] = CONFIG_SYS_BAUDRATE_TABLE; 26 27/** 28 * serial_null() - Void registration routine of a serial driver 29 * 30 * This routine implements a void registration routine of a serial 31 * driver. The registration routine of a particular driver is aliased 32 * to this empty function in case the driver is not compiled into 33 * U-Boot. 34 */ 35static void serial_null(void) 36{ 37} 38 39/** 40 * on_baudrate() - Update the actual baudrate when the env var changes 41 * 42 * @name: changed environment variable 43 * @value: new value of the environment variable 44 * @op: operation (create, overwrite, or delete) 45 * @flags: attributes of environment variable change, 46 * see flags H_* in include/search.h 47 * 48 * This will check for a valid baudrate and only apply it if valid. 49 * 50 * Return: 0 on success, 1 on error 51 */ 52static int on_baudrate(const char *name, const char *value, enum env_op op, 53 int flags) 54{ 55 int i; 56 int baudrate; 57 58 switch (op) { 59 case env_op_create: 60 case env_op_overwrite: 61 /* 62 * Switch to new baudrate if new baudrate is supported 63 */ 64 baudrate = dectoul(value, NULL); 65 66 /* Not actually changing */ 67 if (gd->baudrate == baudrate) 68 return 0; 69 70 for (i = 0; i < ARRAY_SIZE(baudrate_table); ++i) { 71 if (baudrate == baudrate_table[i]) 72 break; 73 } 74 if (i == ARRAY_SIZE(baudrate_table)) { 75 if ((flags & H_FORCE) == 0) 76 printf("## Baudrate %d bps not supported\n", 77 baudrate); 78 return 1; 79 } 80 if ((flags & H_INTERACTIVE) != 0) { 81 printf("## Switch baudrate to %d" 82 " bps and press ENTER ...\n", baudrate); 83 udelay(50000); 84 } 85 86 gd->baudrate = baudrate; 87 88 serial_setbrg(); 89 90 udelay(50000); 91 92 if ((flags & H_INTERACTIVE) != 0) 93 while (1) { 94 if (getchar() == '\r') 95 break; 96 } 97 98 return 0; 99 case env_op_delete: 100 printf("## Baudrate may not be deleted\n"); 101 return 1; 102 default: 103 return 0; 104 } 105} 106U_BOOT_ENV_CALLBACK(baudrate, on_baudrate); 107 108/** 109 * serial_initfunc() - Forward declare of driver registration routine 110 * @name: Name of the real driver registration routine. 111 * 112 * This macro expands onto forward declaration of a driver registration 113 * routine, which is then used below in serial_initialize() function. 114 * The declaration is made weak and aliases to serial_null() so in case 115 * the driver is not compiled in, the function is still declared and can 116 * be used, but aliases to serial_null() and thus is optimized away. 117 */ 118#define serial_initfunc(name) \ 119 void name(void) \ 120 __attribute__((weak, alias("serial_null"))); 121 122serial_initfunc(atmel_serial_initialize); 123serial_initfunc(mcf_serial_initialize); 124serial_initfunc(mpc85xx_serial_initialize); 125serial_initfunc(mxc_serial_initialize); 126serial_initfunc(ns16550_serial_initialize); 127serial_initfunc(pl01x_serial_initialize); 128serial_initfunc(pxa_serial_initialize); 129serial_initfunc(smh_serial_initialize); 130serial_initfunc(sh_serial_initialize); 131serial_initfunc(mtk_serial_initialize); 132 133/** 134 * serial_register() - Register serial driver with serial driver core 135 * @dev: Pointer to the serial driver structure 136 * 137 * This function registers the serial driver supplied via @dev with 138 * serial driver core, thus making U-Boot aware of it and making it 139 * available for U-Boot to use. On platforms that still require manual 140 * relocation of constant variables, relocation of the supplied structure 141 * is performed. 142 */ 143void serial_register(struct serial_device *dev) 144{ 145#ifdef CONFIG_NEEDS_MANUAL_RELOC 146 if (dev->start) 147 dev->start += gd->reloc_off; 148 if (dev->stop) 149 dev->stop += gd->reloc_off; 150 if (dev->setbrg) 151 dev->setbrg += gd->reloc_off; 152 if (dev->getc) 153 dev->getc += gd->reloc_off; 154 if (dev->tstc) 155 dev->tstc += gd->reloc_off; 156 if (dev->putc) 157 dev->putc += gd->reloc_off; 158 if (dev->puts) 159 dev->puts += gd->reloc_off; 160#endif 161 162 dev->next = serial_devices; 163 serial_devices = dev; 164} 165 166/** 167 * serial_initialize() - Register all compiled-in serial port drivers 168 * 169 * This function registers all serial port drivers that are compiled 170 * into the U-Boot binary with the serial core, thus making them 171 * available to U-Boot to use. Lastly, this function assigns a default 172 * serial port to the serial core. That serial port is then used as a 173 * default output. 174 */ 175int serial_initialize(void) 176{ 177 atmel_serial_initialize(); 178 mcf_serial_initialize(); 179 mpc85xx_serial_initialize(); 180 mxc_serial_initialize(); 181 ns16550_serial_initialize(); 182 pl01x_serial_initialize(); 183 pxa_serial_initialize(); 184 smh_serial_initialize(); 185 sh_serial_initialize(); 186 mtk_serial_initialize(); 187 188 serial_assign(default_serial_console()->name); 189 190 return 0; 191} 192 193static int serial_stub_start(struct stdio_dev *sdev) 194{ 195 struct serial_device *dev = sdev->priv; 196 197 return dev->start(); 198} 199 200static int serial_stub_stop(struct stdio_dev *sdev) 201{ 202 struct serial_device *dev = sdev->priv; 203 204 return dev->stop(); 205} 206 207static void serial_stub_putc(struct stdio_dev *sdev, const char ch) 208{ 209 struct serial_device *dev = sdev->priv; 210 211 dev->putc(ch); 212} 213 214static void serial_stub_puts(struct stdio_dev *sdev, const char *str) 215{ 216 struct serial_device *dev = sdev->priv; 217 218 dev->puts(str); 219} 220 221static int serial_stub_getc(struct stdio_dev *sdev) 222{ 223 struct serial_device *dev = sdev->priv; 224 225 return dev->getc(); 226} 227 228static int serial_stub_tstc(struct stdio_dev *sdev) 229{ 230 struct serial_device *dev = sdev->priv; 231 232 return dev->tstc(); 233} 234 235/** 236 * serial_stdio_init() - Register serial ports with STDIO core 237 * 238 * This function generates a proxy driver for each serial port driver. 239 * These proxy drivers then register with the STDIO core, making the 240 * serial drivers available as STDIO devices. 241 */ 242void serial_stdio_init(void) 243{ 244 struct stdio_dev dev; 245 struct serial_device *s = serial_devices; 246 247 while (s) { 248 memset(&dev, 0, sizeof(dev)); 249 250 strcpy(dev.name, s->name); 251 dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT; 252 253 dev.start = serial_stub_start; 254 dev.stop = serial_stub_stop; 255 dev.putc = serial_stub_putc; 256 dev.puts = serial_stub_puts; 257 dev.getc = serial_stub_getc; 258 dev.tstc = serial_stub_tstc; 259 dev.priv = s; 260 261 stdio_register(&dev); 262 263 s = s->next; 264 } 265} 266 267/** 268 * serial_assign() - Select the serial output device by name 269 * @name: Name of the serial driver to be used as default output 270 * 271 * This function configures the serial output multiplexing by 272 * selecting which serial device will be used as default. In case 273 * the STDIO "serial" device is selected as stdin/stdout/stderr, 274 * the serial device previously configured by this function will be 275 * used for the particular operation. 276 * 277 * Returns 0 on success, negative on error. 278 */ 279int serial_assign(const char *name) 280{ 281 struct serial_device *s; 282 283 for (s = serial_devices; s; s = s->next) { 284 if (strcmp(s->name, name)) 285 continue; 286 serial_current = s; 287 return 0; 288 } 289 290 return -EINVAL; 291} 292 293/** 294 * serial_reinit_all() - Reinitialize all compiled-in serial ports 295 * 296 * This function reinitializes all serial ports that are compiled 297 * into U-Boot by calling their serial_start() functions. 298 */ 299void serial_reinit_all(void) 300{ 301 struct serial_device *s; 302 303 for (s = serial_devices; s; s = s->next) 304 s->start(); 305} 306 307/** 308 * get_current() - Return pointer to currently selected serial port 309 * 310 * This function returns a pointer to currently selected serial port. 311 * The currently selected serial port is altered by serial_assign() 312 * function. 313 * 314 * In case this function is called before relocation or before any serial 315 * port is configured, this function calls default_serial_console() to 316 * determine the serial port. Otherwise, the configured serial port is 317 * returned. 318 * 319 * Returns pointer to the currently selected serial port on success, 320 * NULL on error. 321 */ 322static struct serial_device *get_current(void) 323{ 324 struct serial_device *dev; 325 326 if (!(gd->flags & GD_FLG_RELOC)) 327 dev = default_serial_console(); 328 else if (!serial_current) 329 dev = default_serial_console(); 330 else 331 dev = serial_current; 332 333 /* We must have a console device */ 334 if (!dev) { 335#ifdef CONFIG_SPL_BUILD 336 puts("Cannot find console\n"); 337 hang(); 338#else 339 panic("Cannot find console\n"); 340#endif 341 } 342 343 return dev; 344} 345 346/** 347 * serial_init() - Initialize currently selected serial port 348 * 349 * This function initializes the currently selected serial port. This 350 * usually involves setting up the registers of that particular port, 351 * enabling clock and such. This function uses the get_current() call 352 * to determine which port is selected. 353 * 354 * Returns 0 on success, negative on error. 355 */ 356int serial_init(void) 357{ 358 gd->flags |= GD_FLG_SERIAL_READY; 359 return get_current()->start(); 360} 361 362/** 363 * serial_setbrg() - Configure baud-rate of currently selected serial port 364 * 365 * This function configures the baud-rate of the currently selected 366 * serial port. The baud-rate is retrieved from global data within 367 * the serial port driver. This function uses the get_current() call 368 * to determine which port is selected. 369 * 370 * Returns 0 on success, negative on error. 371 */ 372void serial_setbrg(void) 373{ 374 get_current()->setbrg(); 375} 376 377/** 378 * serial_getc() - Read character from currently selected serial port 379 * 380 * This function retrieves a character from currently selected serial 381 * port. In case there is no character waiting on the serial port, 382 * this function will block and wait for the character to appear. This 383 * function uses the get_current() call to determine which port is 384 * selected. 385 * 386 * Returns the character on success, negative on error. 387 */ 388int serial_getc(void) 389{ 390 return get_current()->getc(); 391} 392 393/** 394 * serial_tstc() - Test if data is available on currently selected serial port 395 * 396 * This function tests if one or more characters are available on 397 * currently selected serial port. This function never blocks. This 398 * function uses the get_current() call to determine which port is 399 * selected. 400 * 401 * Returns positive if character is available, zero otherwise. 402 */ 403int serial_tstc(void) 404{ 405 return get_current()->tstc(); 406} 407 408/** 409 * serial_putc() - Output character via currently selected serial port 410 * @c: Single character to be output from the serial port. 411 * 412 * This function outputs a character via currently selected serial 413 * port. This character is passed to the serial port driver responsible 414 * for controlling the hardware. The hardware may still be in process 415 * of transmitting another character, therefore this function may block 416 * for a short amount of time. This function uses the get_current() 417 * call to determine which port is selected. 418 */ 419void serial_putc(const char c) 420{ 421 get_current()->putc(c); 422} 423 424/** 425 * serial_puts() - Output string via currently selected serial port 426 * @s: Zero-terminated string to be output from the serial port. 427 * 428 * This function outputs a zero-terminated string via currently 429 * selected serial port. This function behaves as an accelerator 430 * in case the hardware can queue multiple characters for transfer. 431 * The whole string that is to be output is available to the function 432 * implementing the hardware manipulation. Transmitting the whole 433 * string may take some time, thus this function may block for some 434 * amount of time. This function uses the get_current() call to 435 * determine which port is selected. 436 */ 437void serial_puts(const char *s) 438{ 439 get_current()->puts(s); 440} 441 442/** 443 * default_serial_puts() - Output string by calling serial_putc() in loop 444 * @s: Zero-terminated string to be output from the serial port. 445 * 446 * This function outputs a zero-terminated string by calling serial_putc() 447 * in a loop. Most drivers do not support queueing more than one byte for 448 * transfer, thus this function precisely implements their serial_puts(). 449 * 450 * To optimize the number of get_current() calls, this function only 451 * calls get_current() once and then directly accesses the putc() call 452 * of the &struct serial_device . 453 */ 454void default_serial_puts(const char *s) 455{ 456 struct serial_device *dev = get_current(); 457 while (*s) 458 dev->putc(*s++); 459} 460 461#if CONFIG_POST & CONFIG_SYS_POST_UART 462static const int bauds[] = CONFIG_SYS_BAUDRATE_TABLE; 463 464/** 465 * uart_post_test() - Test the currently selected serial port using POST 466 * @flags: POST framework flags 467 * 468 * Do a loopback test of the currently selected serial port. This 469 * function is only useful in the context of the POST testing framwork. 470 * The serial port is first configured into loopback mode and then 471 * characters are sent through it. 472 * 473 * Returns 0 on success, value otherwise. 474 */ 475/* Mark weak until post/cpu/.../uart.c migrate over */ 476__weak 477int uart_post_test(int flags) 478{ 479 unsigned char c; 480 int ret, saved_baud, b; 481 struct serial_device *saved_dev, *s; 482 483 /* Save current serial state */ 484 ret = 0; 485 saved_dev = serial_current; 486 saved_baud = gd->baudrate; 487 488 for (s = serial_devices; s; s = s->next) { 489 /* If this driver doesn't support loop back, skip it */ 490 if (!s->loop) 491 continue; 492 493 /* Test the next device */ 494 serial_current = s; 495 496 ret = serial_init(); 497 if (ret) 498 goto done; 499 500 /* Consume anything that happens to be queued */ 501 while (serial_tstc()) 502 serial_getc(); 503 504 /* Enable loop back */ 505 s->loop(1); 506 507 /* Test every available baud rate */ 508 for (b = 0; b < ARRAY_SIZE(bauds); ++b) { 509 gd->baudrate = bauds[b]; 510 serial_setbrg(); 511 512 /* 513 * Stick to printable chars to avoid issues: 514 * - terminal corruption 515 * - serial program reacting to sequences and sending 516 * back random extra data 517 * - most serial drivers add in extra chars (like \r\n) 518 */ 519 for (c = 0x20; c < 0x7f; ++c) { 520 /* Send it out */ 521 serial_putc(c); 522 523 /* Make sure it's the same one */ 524 ret = (c != serial_getc()); 525 if (ret) { 526 s->loop(0); 527 goto done; 528 } 529 530 /* Clean up the output in case it was sent */ 531 serial_putc('\b'); 532 ret = ('\b' != serial_getc()); 533 if (ret) { 534 s->loop(0); 535 goto done; 536 } 537 } 538 } 539 540 /* Disable loop back */ 541 s->loop(0); 542 543 /* XXX: There is no serial_stop() !? */ 544 if (s->stop) 545 s->stop(); 546 } 547 548 done: 549 /* Restore previous serial state */ 550 serial_current = saved_dev; 551 gd->baudrate = saved_baud; 552 serial_reinit_all(); 553 serial_setbrg(); 554 555 return ret; 556} 557#endif 558