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