1 /* 2 * (C) Copyright 2000 3 * Paolo Scaffardi, AIRVENT SAM s.p.a - RIMINI(ITALY), arsenio@tin.it 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 8 #include <common.h> 9 #include <console.h> 10 #include <debug_uart.h> 11 #include <stdarg.h> 12 #include <iomux.h> 13 #include <malloc.h> 14 #include <os.h> 15 #include <serial.h> 16 #include <stdio_dev.h> 17 #include <exports.h> 18 #include <environment.h> 19 20 DECLARE_GLOBAL_DATA_PTR; 21 22 static int on_console(const char *name, const char *value, enum env_op op, 23 int flags) 24 { 25 int console = -1; 26 27 /* Check for console redirection */ 28 if (strcmp(name, "stdin") == 0) 29 console = stdin; 30 else if (strcmp(name, "stdout") == 0) 31 console = stdout; 32 else if (strcmp(name, "stderr") == 0) 33 console = stderr; 34 35 /* if not actually setting a console variable, we don't care */ 36 if (console == -1 || (gd->flags & GD_FLG_DEVINIT) == 0) 37 return 0; 38 39 switch (op) { 40 case env_op_create: 41 case env_op_overwrite: 42 43 #ifdef CONFIG_CONSOLE_MUX 44 if (iomux_doenv(console, value)) 45 return 1; 46 #else 47 /* Try assigning specified device */ 48 if (console_assign(console, value) < 0) 49 return 1; 50 #endif /* CONFIG_CONSOLE_MUX */ 51 return 0; 52 53 case env_op_delete: 54 if ((flags & H_FORCE) == 0) 55 printf("Can't delete \"%s\"\n", name); 56 return 1; 57 58 default: 59 return 0; 60 } 61 } 62 U_BOOT_ENV_CALLBACK(console, on_console); 63 64 #ifdef CONFIG_SILENT_CONSOLE 65 static int on_silent(const char *name, const char *value, enum env_op op, 66 int flags) 67 { 68 #ifndef CONFIG_SILENT_CONSOLE_UPDATE_ON_SET 69 if (flags & H_INTERACTIVE) 70 return 0; 71 #endif 72 #ifndef CONFIG_SILENT_CONSOLE_UPDATE_ON_RELOC 73 if ((flags & H_INTERACTIVE) == 0) 74 return 0; 75 #endif 76 77 if (value != NULL) 78 gd->flags |= GD_FLG_SILENT; 79 else 80 gd->flags &= ~GD_FLG_SILENT; 81 82 return 0; 83 } 84 U_BOOT_ENV_CALLBACK(silent, on_silent); 85 #endif 86 87 #ifdef CONFIG_SYS_CONSOLE_IS_IN_ENV 88 /* 89 * if overwrite_console returns 1, the stdin, stderr and stdout 90 * are switched to the serial port, else the settings in the 91 * environment are used 92 */ 93 #ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE 94 extern int overwrite_console(void); 95 #define OVERWRITE_CONSOLE overwrite_console() 96 #else 97 #define OVERWRITE_CONSOLE 0 98 #endif /* CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE */ 99 100 #endif /* CONFIG_SYS_CONSOLE_IS_IN_ENV */ 101 102 static int console_setfile(int file, struct stdio_dev * dev) 103 { 104 int error = 0; 105 106 if (dev == NULL) 107 return -1; 108 109 switch (file) { 110 case stdin: 111 case stdout: 112 case stderr: 113 /* Start new device */ 114 if (dev->start) { 115 error = dev->start(dev); 116 /* If it's not started dont use it */ 117 if (error < 0) 118 break; 119 } 120 121 /* Assign the new device (leaving the existing one started) */ 122 stdio_devices[file] = dev; 123 124 /* 125 * Update monitor functions 126 * (to use the console stuff by other applications) 127 */ 128 switch (file) { 129 case stdin: 130 gd->jt->getc = getc; 131 gd->jt->tstc = tstc; 132 break; 133 case stdout: 134 gd->jt->putc = putc; 135 gd->jt->puts = puts; 136 gd->jt->printf = printf; 137 break; 138 } 139 break; 140 141 default: /* Invalid file ID */ 142 error = -1; 143 } 144 return error; 145 } 146 147 #if defined(CONFIG_CONSOLE_MUX) 148 /** Console I/O multiplexing *******************************************/ 149 150 static struct stdio_dev *tstcdev; 151 struct stdio_dev **console_devices[MAX_FILES]; 152 int cd_count[MAX_FILES]; 153 154 /* 155 * This depends on tstc() always being called before getc(). 156 * This is guaranteed to be true because this routine is called 157 * only from fgetc() which assures it. 158 * No attempt is made to demultiplex multiple input sources. 159 */ 160 static int console_getc(int file) 161 { 162 unsigned char ret; 163 164 /* This is never called with testcdev == NULL */ 165 ret = tstcdev->getc(tstcdev); 166 tstcdev = NULL; 167 return ret; 168 } 169 170 static int console_tstc(int file) 171 { 172 int i, ret; 173 struct stdio_dev *dev; 174 175 disable_ctrlc(1); 176 for (i = 0; i < cd_count[file]; i++) { 177 dev = console_devices[file][i]; 178 if (dev->tstc != NULL) { 179 ret = dev->tstc(dev); 180 if (ret > 0) { 181 tstcdev = dev; 182 disable_ctrlc(0); 183 return ret; 184 } 185 } 186 } 187 disable_ctrlc(0); 188 189 return 0; 190 } 191 192 static void console_putc(int file, const char c) 193 { 194 int i; 195 struct stdio_dev *dev; 196 197 for (i = 0; i < cd_count[file]; i++) { 198 dev = console_devices[file][i]; 199 if (dev->putc != NULL) 200 dev->putc(dev, c); 201 } 202 } 203 204 #ifdef CONFIG_PRE_CONSOLE_BUFFER 205 static void console_puts_noserial(int file, const char *s) 206 { 207 int i; 208 struct stdio_dev *dev; 209 210 for (i = 0; i < cd_count[file]; i++) { 211 dev = console_devices[file][i]; 212 if (dev->puts != NULL && strcmp(dev->name, "serial") != 0) 213 dev->puts(dev, s); 214 } 215 } 216 #endif 217 218 static void console_puts(int file, const char *s) 219 { 220 int i; 221 struct stdio_dev *dev; 222 223 for (i = 0; i < cd_count[file]; i++) { 224 dev = console_devices[file][i]; 225 if (dev->puts != NULL) 226 dev->puts(dev, s); 227 } 228 } 229 230 static inline void console_printdevs(int file) 231 { 232 iomux_printdevs(file); 233 } 234 235 static inline void console_doenv(int file, struct stdio_dev *dev) 236 { 237 iomux_doenv(file, dev->name); 238 } 239 #else 240 static inline int console_getc(int file) 241 { 242 return stdio_devices[file]->getc(stdio_devices[file]); 243 } 244 245 static inline int console_tstc(int file) 246 { 247 return stdio_devices[file]->tstc(stdio_devices[file]); 248 } 249 250 static inline void console_putc(int file, const char c) 251 { 252 stdio_devices[file]->putc(stdio_devices[file], c); 253 } 254 255 #ifdef CONFIG_PRE_CONSOLE_BUFFER 256 static inline void console_puts_noserial(int file, const char *s) 257 { 258 if (strcmp(stdio_devices[file]->name, "serial") != 0) 259 stdio_devices[file]->puts(stdio_devices[file], s); 260 } 261 #endif 262 263 static inline void console_puts(int file, const char *s) 264 { 265 stdio_devices[file]->puts(stdio_devices[file], s); 266 } 267 268 static inline void console_printdevs(int file) 269 { 270 printf("%s\n", stdio_devices[file]->name); 271 } 272 273 static inline void console_doenv(int file, struct stdio_dev *dev) 274 { 275 console_setfile(file, dev); 276 } 277 #endif /* defined(CONFIG_CONSOLE_MUX) */ 278 279 /** U-Boot INITIAL CONSOLE-NOT COMPATIBLE FUNCTIONS *************************/ 280 281 int serial_printf(const char *fmt, ...) 282 { 283 va_list args; 284 uint i; 285 char printbuffer[CONFIG_SYS_PBSIZE]; 286 287 va_start(args, fmt); 288 289 /* For this to work, printbuffer must be larger than 290 * anything we ever want to print. 291 */ 292 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args); 293 va_end(args); 294 295 serial_puts(printbuffer); 296 return i; 297 } 298 299 int fgetc(int file) 300 { 301 if (file < MAX_FILES) { 302 #if defined(CONFIG_CONSOLE_MUX) 303 /* 304 * Effectively poll for input wherever it may be available. 305 */ 306 for (;;) { 307 /* 308 * Upper layer may have already called tstc() so 309 * check for that first. 310 */ 311 if (tstcdev != NULL) 312 return console_getc(file); 313 console_tstc(file); 314 #ifdef CONFIG_WATCHDOG 315 /* 316 * If the watchdog must be rate-limited then it should 317 * already be handled in board-specific code. 318 */ 319 udelay(1); 320 #endif 321 } 322 #else 323 return console_getc(file); 324 #endif 325 } 326 327 return -1; 328 } 329 330 int ftstc(int file) 331 { 332 if (file < MAX_FILES) 333 return console_tstc(file); 334 335 return -1; 336 } 337 338 void fputc(int file, const char c) 339 { 340 if (file < MAX_FILES) 341 console_putc(file, c); 342 } 343 344 void fputs(int file, const char *s) 345 { 346 if (file < MAX_FILES) 347 console_puts(file, s); 348 } 349 350 int fprintf(int file, const char *fmt, ...) 351 { 352 va_list args; 353 uint i; 354 char printbuffer[CONFIG_SYS_PBSIZE]; 355 356 va_start(args, fmt); 357 358 /* For this to work, printbuffer must be larger than 359 * anything we ever want to print. 360 */ 361 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args); 362 va_end(args); 363 364 /* Send to desired file */ 365 fputs(file, printbuffer); 366 return i; 367 } 368 369 /** U-Boot INITIAL CONSOLE-COMPATIBLE FUNCTION *****************************/ 370 371 int getc(void) 372 { 373 #ifdef CONFIG_DISABLE_CONSOLE 374 if (gd->flags & GD_FLG_DISABLE_CONSOLE) 375 return 0; 376 #endif 377 378 if (!gd->have_console) 379 return 0; 380 381 #ifdef CONFIG_CONSOLE_RECORD 382 if (gd->console_in.start) { 383 int ch; 384 385 ch = membuff_getbyte(&gd->console_in); 386 if (ch != -1) 387 return 1; 388 } 389 #endif 390 if (gd->flags & GD_FLG_DEVINIT) { 391 /* Get from the standard input */ 392 return fgetc(stdin); 393 } 394 395 /* Send directly to the handler */ 396 return serial_getc(); 397 } 398 399 int tstc(void) 400 { 401 #ifdef CONFIG_DISABLE_CONSOLE 402 if (gd->flags & GD_FLG_DISABLE_CONSOLE) 403 return 0; 404 #endif 405 406 if (!gd->have_console) 407 return 0; 408 #ifdef CONFIG_CONSOLE_RECORD 409 if (gd->console_in.start) { 410 if (membuff_peekbyte(&gd->console_in) != -1) 411 return 1; 412 } 413 #endif 414 if (gd->flags & GD_FLG_DEVINIT) { 415 /* Test the standard input */ 416 return ftstc(stdin); 417 } 418 419 /* Send directly to the handler */ 420 return serial_tstc(); 421 } 422 423 #define PRE_CONSOLE_FLUSHPOINT1_SERIAL 0 424 #define PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL 1 425 426 #ifdef CONFIG_PRE_CONSOLE_BUFFER 427 #define CIRC_BUF_IDX(idx) ((idx) % (unsigned long)CONFIG_PRE_CON_BUF_SZ) 428 429 static void pre_console_putc(const char c) 430 { 431 char *buffer = (char *)CONFIG_PRE_CON_BUF_ADDR; 432 433 buffer[CIRC_BUF_IDX(gd->precon_buf_idx++)] = c; 434 } 435 436 static void pre_console_puts(const char *s) 437 { 438 while (*s) 439 pre_console_putc(*s++); 440 } 441 442 static void print_pre_console_buffer(int flushpoint) 443 { 444 unsigned long in = 0, out = 0; 445 char *buf_in = (char *)CONFIG_PRE_CON_BUF_ADDR; 446 char buf_out[CONFIG_PRE_CON_BUF_SZ + 1]; 447 448 if (gd->precon_buf_idx > CONFIG_PRE_CON_BUF_SZ) 449 in = gd->precon_buf_idx - CONFIG_PRE_CON_BUF_SZ; 450 451 while (in < gd->precon_buf_idx) 452 buf_out[out++] = buf_in[CIRC_BUF_IDX(in++)]; 453 454 buf_out[out] = 0; 455 456 switch (flushpoint) { 457 case PRE_CONSOLE_FLUSHPOINT1_SERIAL: 458 puts(buf_out); 459 break; 460 case PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL: 461 console_puts_noserial(stdout, buf_out); 462 break; 463 } 464 } 465 #else 466 static inline void pre_console_putc(const char c) {} 467 static inline void pre_console_puts(const char *s) {} 468 static inline void print_pre_console_buffer(int flushpoint) {} 469 #endif 470 471 void putc(const char c) 472 { 473 #ifdef CONFIG_SANDBOX 474 /* sandbox can send characters to stdout before it has a console */ 475 if (!gd || !(gd->flags & GD_FLG_SERIAL_READY)) { 476 os_putc(c); 477 return; 478 } 479 #endif 480 #ifdef CONFIG_DEBUG_UART 481 /* if we don't have a console yet, use the debug UART */ 482 if (!gd || !(gd->flags & GD_FLG_SERIAL_READY)) { 483 printch(c); 484 return; 485 } 486 #endif 487 #ifdef CONFIG_CONSOLE_RECORD 488 if (gd && (gd->flags & GD_FLG_RECORD) && gd->console_out.start) 489 membuff_putbyte(&gd->console_out, c); 490 #endif 491 #ifdef CONFIG_SILENT_CONSOLE 492 if (gd->flags & GD_FLG_SILENT) 493 return; 494 #endif 495 496 #ifdef CONFIG_DISABLE_CONSOLE 497 if (gd->flags & GD_FLG_DISABLE_CONSOLE) 498 return; 499 #endif 500 501 if (!gd->have_console) 502 return pre_console_putc(c); 503 504 if (gd->flags & GD_FLG_DEVINIT) { 505 /* Send to the standard output */ 506 fputc(stdout, c); 507 } else { 508 /* Send directly to the handler */ 509 pre_console_putc(c); 510 serial_putc(c); 511 } 512 } 513 514 void puts(const char *s) 515 { 516 #ifdef CONFIG_SANDBOX 517 if (!gd || !(gd->flags & GD_FLG_SERIAL_READY)) { 518 os_puts(s); 519 return; 520 } 521 #endif 522 #ifdef CONFIG_DEBUG_UART 523 if (!gd || !(gd->flags & GD_FLG_SERIAL_READY)) { 524 while (*s) { 525 int ch = *s++; 526 527 printch(ch); 528 if (ch == '\n') 529 printch('\r'); 530 } 531 return; 532 } 533 #endif 534 #ifdef CONFIG_CONSOLE_RECORD 535 if (gd && (gd->flags & GD_FLG_RECORD) && gd->console_out.start) 536 membuff_put(&gd->console_out, s, strlen(s)); 537 #endif 538 #ifdef CONFIG_SILENT_CONSOLE 539 if (gd->flags & GD_FLG_SILENT) 540 return; 541 #endif 542 543 #ifdef CONFIG_DISABLE_CONSOLE 544 if (gd->flags & GD_FLG_DISABLE_CONSOLE) 545 return; 546 #endif 547 548 if (!gd->have_console) 549 return pre_console_puts(s); 550 551 if (gd->flags & GD_FLG_DEVINIT) { 552 /* Send to the standard output */ 553 fputs(stdout, s); 554 } else { 555 /* Send directly to the handler */ 556 pre_console_puts(s); 557 serial_puts(s); 558 } 559 } 560 561 int printf(const char *fmt, ...) 562 { 563 va_list args; 564 uint i; 565 char printbuffer[CONFIG_SYS_PBSIZE]; 566 567 va_start(args, fmt); 568 569 /* 570 * For this to work, printbuffer must be larger than 571 * anything we ever want to print. 572 */ 573 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args); 574 va_end(args); 575 576 /* Print the string */ 577 puts(printbuffer); 578 return i; 579 } 580 581 int vprintf(const char *fmt, va_list args) 582 { 583 uint i; 584 char printbuffer[CONFIG_SYS_PBSIZE]; 585 586 /* 587 * For this to work, printbuffer must be larger than 588 * anything we ever want to print. 589 */ 590 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args); 591 592 /* Print the string */ 593 puts(printbuffer); 594 return i; 595 } 596 597 #ifdef CONFIG_CONSOLE_RECORD 598 int console_record_init(void) 599 { 600 int ret; 601 602 ret = membuff_new(&gd->console_out, CONFIG_CONSOLE_RECORD_OUT_SIZE); 603 if (ret) 604 return ret; 605 ret = membuff_new(&gd->console_in, CONFIG_CONSOLE_RECORD_IN_SIZE); 606 607 return ret; 608 } 609 610 void console_record_reset(void) 611 { 612 membuff_purge(&gd->console_out); 613 membuff_purge(&gd->console_in); 614 } 615 616 void console_record_reset_enable(void) 617 { 618 console_record_reset(); 619 gd->flags |= GD_FLG_RECORD; 620 } 621 #endif 622 623 /* test if ctrl-c was pressed */ 624 static int ctrlc_disabled = 0; /* see disable_ctrl() */ 625 static int ctrlc_was_pressed = 0; 626 int ctrlc(void) 627 { 628 #ifndef CONFIG_SANDBOX 629 if (!ctrlc_disabled && gd->have_console) { 630 if (tstc()) { 631 switch (getc()) { 632 case 0x03: /* ^C - Control C */ 633 ctrlc_was_pressed = 1; 634 return 1; 635 default: 636 break; 637 } 638 } 639 } 640 #endif 641 642 return 0; 643 } 644 /* Reads user's confirmation. 645 Returns 1 if user's input is "y", "Y", "yes" or "YES" 646 */ 647 int confirm_yesno(void) 648 { 649 int i; 650 char str_input[5]; 651 652 /* Flush input */ 653 while (tstc()) 654 getc(); 655 i = 0; 656 while (i < sizeof(str_input)) { 657 str_input[i] = getc(); 658 putc(str_input[i]); 659 if (str_input[i] == '\r') 660 break; 661 i++; 662 } 663 putc('\n'); 664 if (strncmp(str_input, "y\r", 2) == 0 || 665 strncmp(str_input, "Y\r", 2) == 0 || 666 strncmp(str_input, "yes\r", 4) == 0 || 667 strncmp(str_input, "YES\r", 4) == 0) 668 return 1; 669 return 0; 670 } 671 /* pass 1 to disable ctrlc() checking, 0 to enable. 672 * returns previous state 673 */ 674 int disable_ctrlc(int disable) 675 { 676 int prev = ctrlc_disabled; /* save previous state */ 677 678 ctrlc_disabled = disable; 679 return prev; 680 } 681 682 int had_ctrlc (void) 683 { 684 return ctrlc_was_pressed; 685 } 686 687 void clear_ctrlc(void) 688 { 689 ctrlc_was_pressed = 0; 690 } 691 692 #ifdef CONFIG_MODEM_SUPPORT_DEBUG 693 char screen[1024]; 694 char *cursor = screen; 695 int once = 0; 696 inline void dbg(const char *fmt, ...) 697 { 698 va_list args; 699 uint i; 700 char printbuffer[CONFIG_SYS_PBSIZE]; 701 702 if (!once) { 703 memset(screen, 0, sizeof(screen)); 704 once++; 705 } 706 707 va_start(args, fmt); 708 709 /* For this to work, printbuffer must be larger than 710 * anything we ever want to print. 711 */ 712 i = vsnprintf(printbuffer, sizeof(printbuffer), fmt, args); 713 va_end(args); 714 715 if ((screen + sizeof(screen) - 1 - cursor) 716 < strlen(printbuffer) + 1) { 717 memset(screen, 0, sizeof(screen)); 718 cursor = screen; 719 } 720 sprintf(cursor, printbuffer); 721 cursor += strlen(printbuffer); 722 723 } 724 #else 725 static inline void dbg(const char *fmt, ...) 726 { 727 } 728 #endif 729 730 /** U-Boot INIT FUNCTIONS *************************************************/ 731 732 struct stdio_dev *search_device(int flags, const char *name) 733 { 734 struct stdio_dev *dev; 735 736 dev = stdio_get_by_name(name); 737 738 if (dev && (dev->flags & flags)) 739 return dev; 740 741 return NULL; 742 } 743 744 int console_assign(int file, const char *devname) 745 { 746 int flag; 747 struct stdio_dev *dev; 748 749 /* Check for valid file */ 750 switch (file) { 751 case stdin: 752 flag = DEV_FLAGS_INPUT; 753 break; 754 case stdout: 755 case stderr: 756 flag = DEV_FLAGS_OUTPUT; 757 break; 758 default: 759 return -1; 760 } 761 762 /* Check for valid device name */ 763 764 dev = search_device(flag, devname); 765 766 if (dev) 767 return console_setfile(file, dev); 768 769 return -1; 770 } 771 772 /* Called before relocation - use serial functions */ 773 int console_init_f(void) 774 { 775 gd->have_console = 1; 776 777 #ifdef CONFIG_SILENT_CONSOLE 778 if (getenv("silent") != NULL) 779 gd->flags |= GD_FLG_SILENT; 780 #endif 781 782 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT1_SERIAL); 783 784 return 0; 785 } 786 787 void stdio_print_current_devices(void) 788 { 789 /* Print information */ 790 puts("In: "); 791 if (stdio_devices[stdin] == NULL) { 792 puts("No input devices available!\n"); 793 } else { 794 printf ("%s\n", stdio_devices[stdin]->name); 795 } 796 797 puts("Out: "); 798 if (stdio_devices[stdout] == NULL) { 799 puts("No output devices available!\n"); 800 } else { 801 printf ("%s\n", stdio_devices[stdout]->name); 802 } 803 804 puts("Err: "); 805 if (stdio_devices[stderr] == NULL) { 806 puts("No error devices available!\n"); 807 } else { 808 printf ("%s\n", stdio_devices[stderr]->name); 809 } 810 } 811 812 #ifdef CONFIG_SYS_CONSOLE_IS_IN_ENV 813 /* Called after the relocation - use desired console functions */ 814 int console_init_r(void) 815 { 816 char *stdinname, *stdoutname, *stderrname; 817 struct stdio_dev *inputdev = NULL, *outputdev = NULL, *errdev = NULL; 818 #ifdef CONFIG_SYS_CONSOLE_ENV_OVERWRITE 819 int i; 820 #endif /* CONFIG_SYS_CONSOLE_ENV_OVERWRITE */ 821 #ifdef CONFIG_CONSOLE_MUX 822 int iomux_err = 0; 823 #endif 824 825 /* set default handlers at first */ 826 gd->jt->getc = serial_getc; 827 gd->jt->tstc = serial_tstc; 828 gd->jt->putc = serial_putc; 829 gd->jt->puts = serial_puts; 830 gd->jt->printf = serial_printf; 831 832 /* stdin stdout and stderr are in environment */ 833 /* scan for it */ 834 stdinname = getenv("stdin"); 835 stdoutname = getenv("stdout"); 836 stderrname = getenv("stderr"); 837 838 if (OVERWRITE_CONSOLE == 0) { /* if not overwritten by config switch */ 839 inputdev = search_device(DEV_FLAGS_INPUT, stdinname); 840 outputdev = search_device(DEV_FLAGS_OUTPUT, stdoutname); 841 errdev = search_device(DEV_FLAGS_OUTPUT, stderrname); 842 #ifdef CONFIG_CONSOLE_MUX 843 iomux_err = iomux_doenv(stdin, stdinname); 844 iomux_err += iomux_doenv(stdout, stdoutname); 845 iomux_err += iomux_doenv(stderr, stderrname); 846 if (!iomux_err) 847 /* Successful, so skip all the code below. */ 848 goto done; 849 #endif 850 } 851 /* if the devices are overwritten or not found, use default device */ 852 if (inputdev == NULL) { 853 inputdev = search_device(DEV_FLAGS_INPUT, "serial"); 854 } 855 if (outputdev == NULL) { 856 outputdev = search_device(DEV_FLAGS_OUTPUT, "serial"); 857 } 858 if (errdev == NULL) { 859 errdev = search_device(DEV_FLAGS_OUTPUT, "serial"); 860 } 861 /* Initializes output console first */ 862 if (outputdev != NULL) { 863 /* need to set a console if not done above. */ 864 console_doenv(stdout, outputdev); 865 } 866 if (errdev != NULL) { 867 /* need to set a console if not done above. */ 868 console_doenv(stderr, errdev); 869 } 870 if (inputdev != NULL) { 871 /* need to set a console if not done above. */ 872 console_doenv(stdin, inputdev); 873 } 874 875 #ifdef CONFIG_CONSOLE_MUX 876 done: 877 #endif 878 879 #ifndef CONFIG_SYS_CONSOLE_INFO_QUIET 880 stdio_print_current_devices(); 881 #endif /* CONFIG_SYS_CONSOLE_INFO_QUIET */ 882 883 #ifdef CONFIG_SYS_CONSOLE_ENV_OVERWRITE 884 /* set the environment variables (will overwrite previous env settings) */ 885 for (i = 0; i < 3; i++) { 886 setenv(stdio_names[i], stdio_devices[i]->name); 887 } 888 #endif /* CONFIG_SYS_CONSOLE_ENV_OVERWRITE */ 889 890 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */ 891 892 #if 0 893 /* If nothing usable installed, use only the initial console */ 894 if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL)) 895 return 0; 896 #endif 897 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL); 898 return 0; 899 } 900 901 #else /* CONFIG_SYS_CONSOLE_IS_IN_ENV */ 902 903 /* Called after the relocation - use desired console functions */ 904 int console_init_r(void) 905 { 906 struct stdio_dev *inputdev = NULL, *outputdev = NULL; 907 int i; 908 struct list_head *list = stdio_get_list(); 909 struct list_head *pos; 910 struct stdio_dev *dev; 911 912 #ifdef CONFIG_SPLASH_SCREEN 913 /* 914 * suppress all output if splash screen is enabled and we have 915 * a bmp to display. We redirect the output from frame buffer 916 * console to serial console in this case or suppress it if 917 * "silent" mode was requested. 918 */ 919 if (getenv("splashimage") != NULL) { 920 if (!(gd->flags & GD_FLG_SILENT)) 921 outputdev = search_device (DEV_FLAGS_OUTPUT, "serial"); 922 } 923 #endif 924 925 /* Scan devices looking for input and output devices */ 926 list_for_each(pos, list) { 927 dev = list_entry(pos, struct stdio_dev, list); 928 929 if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) { 930 inputdev = dev; 931 } 932 if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) { 933 outputdev = dev; 934 } 935 if(inputdev && outputdev) 936 break; 937 } 938 939 /* Initializes output console first */ 940 if (outputdev != NULL) { 941 console_setfile(stdout, outputdev); 942 console_setfile(stderr, outputdev); 943 #ifdef CONFIG_CONSOLE_MUX 944 console_devices[stdout][0] = outputdev; 945 console_devices[stderr][0] = outputdev; 946 #endif 947 } 948 949 /* Initializes input console */ 950 if (inputdev != NULL) { 951 console_setfile(stdin, inputdev); 952 #ifdef CONFIG_CONSOLE_MUX 953 console_devices[stdin][0] = inputdev; 954 #endif 955 } 956 957 #ifndef CONFIG_SYS_CONSOLE_INFO_QUIET 958 stdio_print_current_devices(); 959 #endif /* CONFIG_SYS_CONSOLE_INFO_QUIET */ 960 961 /* Setting environment variables */ 962 for (i = 0; i < 3; i++) { 963 setenv(stdio_names[i], stdio_devices[i]->name); 964 } 965 966 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */ 967 968 #if 0 969 /* If nothing usable installed, use only the initial console */ 970 if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL)) 971 return 0; 972 #endif 973 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL); 974 return 0; 975 } 976 977 #endif /* CONFIG_SYS_CONSOLE_IS_IN_ENV */ 978