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 /* For this to work, printbuffer must be larger than 570 * anything we ever want to print. 571 */ 572 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args); 573 va_end(args); 574 575 /* Print the string */ 576 puts(printbuffer); 577 return i; 578 } 579 580 int vprintf(const char *fmt, va_list args) 581 { 582 uint i; 583 char printbuffer[CONFIG_SYS_PBSIZE]; 584 585 #if defined(CONFIG_PRE_CONSOLE_BUFFER) && !defined(CONFIG_SANDBOX) 586 if (!gd->have_console) 587 return 0; 588 #endif 589 590 /* For this to work, printbuffer must be larger than 591 * anything we ever want to print. 592 */ 593 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args); 594 595 /* Print the string */ 596 puts(printbuffer); 597 return i; 598 } 599 600 #ifdef CONFIG_CONSOLE_RECORD 601 int console_record_init(void) 602 { 603 int ret; 604 605 ret = membuff_new(&gd->console_out, CONFIG_CONSOLE_RECORD_OUT_SIZE); 606 if (ret) 607 return ret; 608 ret = membuff_new(&gd->console_in, CONFIG_CONSOLE_RECORD_IN_SIZE); 609 610 return ret; 611 } 612 613 void console_record_reset(void) 614 { 615 membuff_purge(&gd->console_out); 616 membuff_purge(&gd->console_in); 617 } 618 619 void console_record_reset_enable(void) 620 { 621 console_record_reset(); 622 gd->flags |= GD_FLG_RECORD; 623 } 624 #endif 625 626 /* test if ctrl-c was pressed */ 627 static int ctrlc_disabled = 0; /* see disable_ctrl() */ 628 static int ctrlc_was_pressed = 0; 629 int ctrlc(void) 630 { 631 #ifndef CONFIG_SANDBOX 632 if (!ctrlc_disabled && gd->have_console) { 633 if (tstc()) { 634 switch (getc()) { 635 case 0x03: /* ^C - Control C */ 636 ctrlc_was_pressed = 1; 637 return 1; 638 default: 639 break; 640 } 641 } 642 } 643 #endif 644 645 return 0; 646 } 647 /* Reads user's confirmation. 648 Returns 1 if user's input is "y", "Y", "yes" or "YES" 649 */ 650 int confirm_yesno(void) 651 { 652 int i; 653 char str_input[5]; 654 655 /* Flush input */ 656 while (tstc()) 657 getc(); 658 i = 0; 659 while (i < sizeof(str_input)) { 660 str_input[i] = getc(); 661 putc(str_input[i]); 662 if (str_input[i] == '\r') 663 break; 664 i++; 665 } 666 putc('\n'); 667 if (strncmp(str_input, "y\r", 2) == 0 || 668 strncmp(str_input, "Y\r", 2) == 0 || 669 strncmp(str_input, "yes\r", 4) == 0 || 670 strncmp(str_input, "YES\r", 4) == 0) 671 return 1; 672 return 0; 673 } 674 /* pass 1 to disable ctrlc() checking, 0 to enable. 675 * returns previous state 676 */ 677 int disable_ctrlc(int disable) 678 { 679 int prev = ctrlc_disabled; /* save previous state */ 680 681 ctrlc_disabled = disable; 682 return prev; 683 } 684 685 int had_ctrlc (void) 686 { 687 return ctrlc_was_pressed; 688 } 689 690 void clear_ctrlc(void) 691 { 692 ctrlc_was_pressed = 0; 693 } 694 695 #ifdef CONFIG_MODEM_SUPPORT_DEBUG 696 char screen[1024]; 697 char *cursor = screen; 698 int once = 0; 699 inline void dbg(const char *fmt, ...) 700 { 701 va_list args; 702 uint i; 703 char printbuffer[CONFIG_SYS_PBSIZE]; 704 705 if (!once) { 706 memset(screen, 0, sizeof(screen)); 707 once++; 708 } 709 710 va_start(args, fmt); 711 712 /* For this to work, printbuffer must be larger than 713 * anything we ever want to print. 714 */ 715 i = vsnprintf(printbuffer, sizeof(printbuffer), fmt, args); 716 va_end(args); 717 718 if ((screen + sizeof(screen) - 1 - cursor) 719 < strlen(printbuffer) + 1) { 720 memset(screen, 0, sizeof(screen)); 721 cursor = screen; 722 } 723 sprintf(cursor, printbuffer); 724 cursor += strlen(printbuffer); 725 726 } 727 #else 728 static inline void dbg(const char *fmt, ...) 729 { 730 } 731 #endif 732 733 /** U-Boot INIT FUNCTIONS *************************************************/ 734 735 struct stdio_dev *search_device(int flags, const char *name) 736 { 737 struct stdio_dev *dev; 738 739 dev = stdio_get_by_name(name); 740 741 if (dev && (dev->flags & flags)) 742 return dev; 743 744 return NULL; 745 } 746 747 int console_assign(int file, const char *devname) 748 { 749 int flag; 750 struct stdio_dev *dev; 751 752 /* Check for valid file */ 753 switch (file) { 754 case stdin: 755 flag = DEV_FLAGS_INPUT; 756 break; 757 case stdout: 758 case stderr: 759 flag = DEV_FLAGS_OUTPUT; 760 break; 761 default: 762 return -1; 763 } 764 765 /* Check for valid device name */ 766 767 dev = search_device(flag, devname); 768 769 if (dev) 770 return console_setfile(file, dev); 771 772 return -1; 773 } 774 775 /* Called before relocation - use serial functions */ 776 int console_init_f(void) 777 { 778 gd->have_console = 1; 779 780 #ifdef CONFIG_SILENT_CONSOLE 781 if (getenv("silent") != NULL) 782 gd->flags |= GD_FLG_SILENT; 783 #endif 784 785 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT1_SERIAL); 786 787 return 0; 788 } 789 790 void stdio_print_current_devices(void) 791 { 792 /* Print information */ 793 puts("In: "); 794 if (stdio_devices[stdin] == NULL) { 795 puts("No input devices available!\n"); 796 } else { 797 printf ("%s\n", stdio_devices[stdin]->name); 798 } 799 800 puts("Out: "); 801 if (stdio_devices[stdout] == NULL) { 802 puts("No output devices available!\n"); 803 } else { 804 printf ("%s\n", stdio_devices[stdout]->name); 805 } 806 807 puts("Err: "); 808 if (stdio_devices[stderr] == NULL) { 809 puts("No error devices available!\n"); 810 } else { 811 printf ("%s\n", stdio_devices[stderr]->name); 812 } 813 } 814 815 #ifdef CONFIG_SYS_CONSOLE_IS_IN_ENV 816 /* Called after the relocation - use desired console functions */ 817 int console_init_r(void) 818 { 819 char *stdinname, *stdoutname, *stderrname; 820 struct stdio_dev *inputdev = NULL, *outputdev = NULL, *errdev = NULL; 821 #ifdef CONFIG_SYS_CONSOLE_ENV_OVERWRITE 822 int i; 823 #endif /* CONFIG_SYS_CONSOLE_ENV_OVERWRITE */ 824 #ifdef CONFIG_CONSOLE_MUX 825 int iomux_err = 0; 826 #endif 827 828 /* set default handlers at first */ 829 gd->jt->getc = serial_getc; 830 gd->jt->tstc = serial_tstc; 831 gd->jt->putc = serial_putc; 832 gd->jt->puts = serial_puts; 833 gd->jt->printf = serial_printf; 834 835 /* stdin stdout and stderr are in environment */ 836 /* scan for it */ 837 stdinname = getenv("stdin"); 838 stdoutname = getenv("stdout"); 839 stderrname = getenv("stderr"); 840 841 if (OVERWRITE_CONSOLE == 0) { /* if not overwritten by config switch */ 842 inputdev = search_device(DEV_FLAGS_INPUT, stdinname); 843 outputdev = search_device(DEV_FLAGS_OUTPUT, stdoutname); 844 errdev = search_device(DEV_FLAGS_OUTPUT, stderrname); 845 #ifdef CONFIG_CONSOLE_MUX 846 iomux_err = iomux_doenv(stdin, stdinname); 847 iomux_err += iomux_doenv(stdout, stdoutname); 848 iomux_err += iomux_doenv(stderr, stderrname); 849 if (!iomux_err) 850 /* Successful, so skip all the code below. */ 851 goto done; 852 #endif 853 } 854 /* if the devices are overwritten or not found, use default device */ 855 if (inputdev == NULL) { 856 inputdev = search_device(DEV_FLAGS_INPUT, "serial"); 857 } 858 if (outputdev == NULL) { 859 outputdev = search_device(DEV_FLAGS_OUTPUT, "serial"); 860 } 861 if (errdev == NULL) { 862 errdev = search_device(DEV_FLAGS_OUTPUT, "serial"); 863 } 864 /* Initializes output console first */ 865 if (outputdev != NULL) { 866 /* need to set a console if not done above. */ 867 console_doenv(stdout, outputdev); 868 } 869 if (errdev != NULL) { 870 /* need to set a console if not done above. */ 871 console_doenv(stderr, errdev); 872 } 873 if (inputdev != NULL) { 874 /* need to set a console if not done above. */ 875 console_doenv(stdin, inputdev); 876 } 877 878 #ifdef CONFIG_CONSOLE_MUX 879 done: 880 #endif 881 882 #ifndef CONFIG_SYS_CONSOLE_INFO_QUIET 883 stdio_print_current_devices(); 884 #endif /* CONFIG_SYS_CONSOLE_INFO_QUIET */ 885 886 #ifdef CONFIG_SYS_CONSOLE_ENV_OVERWRITE 887 /* set the environment variables (will overwrite previous env settings) */ 888 for (i = 0; i < 3; i++) { 889 setenv(stdio_names[i], stdio_devices[i]->name); 890 } 891 #endif /* CONFIG_SYS_CONSOLE_ENV_OVERWRITE */ 892 893 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */ 894 895 #if 0 896 /* If nothing usable installed, use only the initial console */ 897 if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL)) 898 return 0; 899 #endif 900 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL); 901 return 0; 902 } 903 904 #else /* CONFIG_SYS_CONSOLE_IS_IN_ENV */ 905 906 /* Called after the relocation - use desired console functions */ 907 int console_init_r(void) 908 { 909 struct stdio_dev *inputdev = NULL, *outputdev = NULL; 910 int i; 911 struct list_head *list = stdio_get_list(); 912 struct list_head *pos; 913 struct stdio_dev *dev; 914 915 #ifdef CONFIG_SPLASH_SCREEN 916 /* 917 * suppress all output if splash screen is enabled and we have 918 * a bmp to display. We redirect the output from frame buffer 919 * console to serial console in this case or suppress it if 920 * "silent" mode was requested. 921 */ 922 if (getenv("splashimage") != NULL) { 923 if (!(gd->flags & GD_FLG_SILENT)) 924 outputdev = search_device (DEV_FLAGS_OUTPUT, "serial"); 925 } 926 #endif 927 928 /* Scan devices looking for input and output devices */ 929 list_for_each(pos, list) { 930 dev = list_entry(pos, struct stdio_dev, list); 931 932 if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) { 933 inputdev = dev; 934 } 935 if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) { 936 outputdev = dev; 937 } 938 if(inputdev && outputdev) 939 break; 940 } 941 942 /* Initializes output console first */ 943 if (outputdev != NULL) { 944 console_setfile(stdout, outputdev); 945 console_setfile(stderr, outputdev); 946 #ifdef CONFIG_CONSOLE_MUX 947 console_devices[stdout][0] = outputdev; 948 console_devices[stderr][0] = outputdev; 949 #endif 950 } 951 952 /* Initializes input console */ 953 if (inputdev != NULL) { 954 console_setfile(stdin, inputdev); 955 #ifdef CONFIG_CONSOLE_MUX 956 console_devices[stdin][0] = inputdev; 957 #endif 958 } 959 960 #ifndef CONFIG_SYS_CONSOLE_INFO_QUIET 961 stdio_print_current_devices(); 962 #endif /* CONFIG_SYS_CONSOLE_INFO_QUIET */ 963 964 /* Setting environment variables */ 965 for (i = 0; i < 3; i++) { 966 setenv(stdio_names[i], stdio_devices[i]->name); 967 } 968 969 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */ 970 971 #if 0 972 /* If nothing usable installed, use only the initial console */ 973 if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL)) 974 return 0; 975 #endif 976 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL); 977 return 0; 978 } 979 980 #endif /* CONFIG_SYS_CONSOLE_IS_IN_ENV */ 981