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(); 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(); 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(); 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(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(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(); 226 } 227 228 static inline int console_tstc(int file) 229 { 230 return stdio_devices[file]->tstc(); 231 } 232 233 static inline void console_putc(int file, const char c) 234 { 235 stdio_devices[file]->putc(c); 236 } 237 238 static inline void console_puts(int file, const char *s) 239 { 240 stdio_devices[file]->puts(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) { 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) { 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 #ifndef CONFIG_PRE_CONSOLE_BUFFER 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 if (!ctrlc_disabled && gd->have_console) { 528 if (tstc()) { 529 switch (getc()) { 530 case 0x03: /* ^C - Control C */ 531 ctrlc_was_pressed = 1; 532 return 1; 533 default: 534 break; 535 } 536 } 537 } 538 return 0; 539 } 540 /* Reads user's confirmation. 541 Returns 1 if user's input is "y", "Y", "yes" or "YES" 542 */ 543 int confirm_yesno(void) 544 { 545 int i; 546 char str_input[5]; 547 548 /* Flush input */ 549 while (tstc()) 550 getc(); 551 i = 0; 552 while (i < sizeof(str_input)) { 553 str_input[i] = getc(); 554 putc(str_input[i]); 555 if (str_input[i] == '\r') 556 break; 557 i++; 558 } 559 putc('\n'); 560 if (strncmp(str_input, "y\r", 2) == 0 || 561 strncmp(str_input, "Y\r", 2) == 0 || 562 strncmp(str_input, "yes\r", 4) == 0 || 563 strncmp(str_input, "YES\r", 4) == 0) 564 return 1; 565 return 0; 566 } 567 /* pass 1 to disable ctrlc() checking, 0 to enable. 568 * returns previous state 569 */ 570 int disable_ctrlc(int disable) 571 { 572 int prev = ctrlc_disabled; /* save previous state */ 573 574 ctrlc_disabled = disable; 575 return prev; 576 } 577 578 int had_ctrlc (void) 579 { 580 return ctrlc_was_pressed; 581 } 582 583 void clear_ctrlc(void) 584 { 585 ctrlc_was_pressed = 0; 586 } 587 588 #ifdef CONFIG_MODEM_SUPPORT_DEBUG 589 char screen[1024]; 590 char *cursor = screen; 591 int once = 0; 592 inline void dbg(const char *fmt, ...) 593 { 594 va_list args; 595 uint i; 596 char printbuffer[CONFIG_SYS_PBSIZE]; 597 598 if (!once) { 599 memset(screen, 0, sizeof(screen)); 600 once++; 601 } 602 603 va_start(args, fmt); 604 605 /* For this to work, printbuffer must be larger than 606 * anything we ever want to print. 607 */ 608 i = vsnprintf(printbuffer, sizeof(printbuffer), fmt, args); 609 va_end(args); 610 611 if ((screen + sizeof(screen) - 1 - cursor) 612 < strlen(printbuffer) + 1) { 613 memset(screen, 0, sizeof(screen)); 614 cursor = screen; 615 } 616 sprintf(cursor, printbuffer); 617 cursor += strlen(printbuffer); 618 619 } 620 #else 621 inline void dbg(const char *fmt, ...) 622 { 623 } 624 #endif 625 626 /** U-Boot INIT FUNCTIONS *************************************************/ 627 628 struct stdio_dev *search_device(int flags, const char *name) 629 { 630 struct stdio_dev *dev; 631 632 dev = stdio_get_by_name(name); 633 634 if (dev && (dev->flags & flags)) 635 return dev; 636 637 return NULL; 638 } 639 640 int console_assign(int file, const char *devname) 641 { 642 int flag; 643 struct stdio_dev *dev; 644 645 /* Check for valid file */ 646 switch (file) { 647 case stdin: 648 flag = DEV_FLAGS_INPUT; 649 break; 650 case stdout: 651 case stderr: 652 flag = DEV_FLAGS_OUTPUT; 653 break; 654 default: 655 return -1; 656 } 657 658 /* Check for valid device name */ 659 660 dev = search_device(flag, devname); 661 662 if (dev) 663 return console_setfile(file, dev); 664 665 return -1; 666 } 667 668 /* Called before relocation - use serial functions */ 669 int console_init_f(void) 670 { 671 gd->have_console = 1; 672 673 #ifdef CONFIG_SILENT_CONSOLE 674 if (getenv("silent") != NULL) 675 gd->flags |= GD_FLG_SILENT; 676 #endif 677 678 print_pre_console_buffer(); 679 680 return 0; 681 } 682 683 void stdio_print_current_devices(void) 684 { 685 /* Print information */ 686 puts("In: "); 687 if (stdio_devices[stdin] == NULL) { 688 puts("No input devices available!\n"); 689 } else { 690 printf ("%s\n", stdio_devices[stdin]->name); 691 } 692 693 puts("Out: "); 694 if (stdio_devices[stdout] == NULL) { 695 puts("No output devices available!\n"); 696 } else { 697 printf ("%s\n", stdio_devices[stdout]->name); 698 } 699 700 puts("Err: "); 701 if (stdio_devices[stderr] == NULL) { 702 puts("No error devices available!\n"); 703 } else { 704 printf ("%s\n", stdio_devices[stderr]->name); 705 } 706 } 707 708 #ifdef CONFIG_SYS_CONSOLE_IS_IN_ENV 709 /* Called after the relocation - use desired console functions */ 710 int console_init_r(void) 711 { 712 char *stdinname, *stdoutname, *stderrname; 713 struct stdio_dev *inputdev = NULL, *outputdev = NULL, *errdev = NULL; 714 #ifdef CONFIG_SYS_CONSOLE_ENV_OVERWRITE 715 int i; 716 #endif /* CONFIG_SYS_CONSOLE_ENV_OVERWRITE */ 717 #ifdef CONFIG_CONSOLE_MUX 718 int iomux_err = 0; 719 #endif 720 721 /* set default handlers at first */ 722 gd->jt[XF_getc] = serial_getc; 723 gd->jt[XF_tstc] = serial_tstc; 724 gd->jt[XF_putc] = serial_putc; 725 gd->jt[XF_puts] = serial_puts; 726 gd->jt[XF_printf] = serial_printf; 727 728 /* stdin stdout and stderr are in environment */ 729 /* scan for it */ 730 stdinname = getenv("stdin"); 731 stdoutname = getenv("stdout"); 732 stderrname = getenv("stderr"); 733 734 if (OVERWRITE_CONSOLE == 0) { /* if not overwritten by config switch */ 735 inputdev = search_device(DEV_FLAGS_INPUT, stdinname); 736 outputdev = search_device(DEV_FLAGS_OUTPUT, stdoutname); 737 errdev = search_device(DEV_FLAGS_OUTPUT, stderrname); 738 #ifdef CONFIG_CONSOLE_MUX 739 iomux_err = iomux_doenv(stdin, stdinname); 740 iomux_err += iomux_doenv(stdout, stdoutname); 741 iomux_err += iomux_doenv(stderr, stderrname); 742 if (!iomux_err) 743 /* Successful, so skip all the code below. */ 744 goto done; 745 #endif 746 } 747 /* if the devices are overwritten or not found, use default device */ 748 if (inputdev == NULL) { 749 inputdev = search_device(DEV_FLAGS_INPUT, "serial"); 750 } 751 if (outputdev == NULL) { 752 outputdev = search_device(DEV_FLAGS_OUTPUT, "serial"); 753 } 754 if (errdev == NULL) { 755 errdev = search_device(DEV_FLAGS_OUTPUT, "serial"); 756 } 757 /* Initializes output console first */ 758 if (outputdev != NULL) { 759 /* need to set a console if not done above. */ 760 console_doenv(stdout, outputdev); 761 } 762 if (errdev != NULL) { 763 /* need to set a console if not done above. */ 764 console_doenv(stderr, errdev); 765 } 766 if (inputdev != NULL) { 767 /* need to set a console if not done above. */ 768 console_doenv(stdin, inputdev); 769 } 770 771 #ifdef CONFIG_CONSOLE_MUX 772 done: 773 #endif 774 775 #ifndef CONFIG_SYS_CONSOLE_INFO_QUIET 776 stdio_print_current_devices(); 777 #endif /* CONFIG_SYS_CONSOLE_INFO_QUIET */ 778 779 #ifdef CONFIG_SYS_CONSOLE_ENV_OVERWRITE 780 /* set the environment variables (will overwrite previous env settings) */ 781 for (i = 0; i < 3; i++) { 782 setenv(stdio_names[i], stdio_devices[i]->name); 783 } 784 #endif /* CONFIG_SYS_CONSOLE_ENV_OVERWRITE */ 785 786 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */ 787 788 #if 0 789 /* If nothing usable installed, use only the initial console */ 790 if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL)) 791 return 0; 792 #endif 793 return 0; 794 } 795 796 #else /* CONFIG_SYS_CONSOLE_IS_IN_ENV */ 797 798 /* Called after the relocation - use desired console functions */ 799 int console_init_r(void) 800 { 801 struct stdio_dev *inputdev = NULL, *outputdev = NULL; 802 int i; 803 struct list_head *list = stdio_get_list(); 804 struct list_head *pos; 805 struct stdio_dev *dev; 806 807 #ifdef CONFIG_SPLASH_SCREEN 808 /* 809 * suppress all output if splash screen is enabled and we have 810 * a bmp to display. We redirect the output from frame buffer 811 * console to serial console in this case or suppress it if 812 * "silent" mode was requested. 813 */ 814 if (getenv("splashimage") != NULL) { 815 if (!(gd->flags & GD_FLG_SILENT)) 816 outputdev = search_device (DEV_FLAGS_OUTPUT, "serial"); 817 } 818 #endif 819 820 /* Scan devices looking for input and output devices */ 821 list_for_each(pos, list) { 822 dev = list_entry(pos, struct stdio_dev, list); 823 824 if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) { 825 inputdev = dev; 826 } 827 if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) { 828 outputdev = dev; 829 } 830 if(inputdev && outputdev) 831 break; 832 } 833 834 /* Initializes output console first */ 835 if (outputdev != NULL) { 836 console_setfile(stdout, outputdev); 837 console_setfile(stderr, outputdev); 838 #ifdef CONFIG_CONSOLE_MUX 839 console_devices[stdout][0] = outputdev; 840 console_devices[stderr][0] = outputdev; 841 #endif 842 } 843 844 /* Initializes input console */ 845 if (inputdev != NULL) { 846 console_setfile(stdin, inputdev); 847 #ifdef CONFIG_CONSOLE_MUX 848 console_devices[stdin][0] = inputdev; 849 #endif 850 } 851 852 #ifndef CONFIG_SYS_CONSOLE_INFO_QUIET 853 stdio_print_current_devices(); 854 #endif /* CONFIG_SYS_CONSOLE_INFO_QUIET */ 855 856 /* Setting environment variables */ 857 for (i = 0; i < 3; i++) { 858 setenv(stdio_names[i], stdio_devices[i]->name); 859 } 860 861 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */ 862 863 #if 0 864 /* If nothing usable installed, use only the initial console */ 865 if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL)) 866 return 0; 867 #endif 868 869 return 0; 870 } 871 872 #endif /* CONFIG_SYS_CONSOLE_IS_IN_ENV */ 873