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 if (gd->flags & GD_FLG_DEVINIT) { 382 /* Get from the standard input */ 383 return fgetc(stdin); 384 } 385 386 /* Send directly to the handler */ 387 return serial_getc(); 388 } 389 390 int tstc(void) 391 { 392 #ifdef CONFIG_DISABLE_CONSOLE 393 if (gd->flags & GD_FLG_DISABLE_CONSOLE) 394 return 0; 395 #endif 396 397 if (!gd->have_console) 398 return 0; 399 400 if (gd->flags & GD_FLG_DEVINIT) { 401 /* Test the standard input */ 402 return ftstc(stdin); 403 } 404 405 /* Send directly to the handler */ 406 return serial_tstc(); 407 } 408 409 #define PRE_CONSOLE_FLUSHPOINT1_SERIAL 0 410 #define PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL 1 411 412 #ifdef CONFIG_PRE_CONSOLE_BUFFER 413 #define CIRC_BUF_IDX(idx) ((idx) % (unsigned long)CONFIG_PRE_CON_BUF_SZ) 414 415 static void pre_console_putc(const char c) 416 { 417 char *buffer = (char *)CONFIG_PRE_CON_BUF_ADDR; 418 419 buffer[CIRC_BUF_IDX(gd->precon_buf_idx++)] = c; 420 } 421 422 static void pre_console_puts(const char *s) 423 { 424 while (*s) 425 pre_console_putc(*s++); 426 } 427 428 static void print_pre_console_buffer(int flushpoint) 429 { 430 unsigned long in = 0, out = 0; 431 char *buf_in = (char *)CONFIG_PRE_CON_BUF_ADDR; 432 char buf_out[CONFIG_PRE_CON_BUF_SZ + 1]; 433 434 if (gd->precon_buf_idx > CONFIG_PRE_CON_BUF_SZ) 435 in = gd->precon_buf_idx - CONFIG_PRE_CON_BUF_SZ; 436 437 while (in < gd->precon_buf_idx) 438 buf_out[out++] = buf_in[CIRC_BUF_IDX(in++)]; 439 440 buf_out[out] = 0; 441 442 switch (flushpoint) { 443 case PRE_CONSOLE_FLUSHPOINT1_SERIAL: 444 puts(buf_out); 445 break; 446 case PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL: 447 console_puts_noserial(stdout, buf_out); 448 break; 449 } 450 } 451 #else 452 static inline void pre_console_putc(const char c) {} 453 static inline void pre_console_puts(const char *s) {} 454 static inline void print_pre_console_buffer(int flushpoint) {} 455 #endif 456 457 void putc(const char c) 458 { 459 #ifdef CONFIG_SANDBOX 460 /* sandbox can send characters to stdout before it has a console */ 461 if (!gd || !(gd->flags & GD_FLG_SERIAL_READY)) { 462 os_putc(c); 463 return; 464 } 465 #endif 466 #ifdef CONFIG_DEBUG_UART 467 /* if we don't have a console yet, use the debug UART */ 468 if (!gd || !(gd->flags & GD_FLG_SERIAL_READY)) { 469 printch(c); 470 return; 471 } 472 #endif 473 #ifdef CONFIG_SILENT_CONSOLE 474 if (gd->flags & GD_FLG_SILENT) 475 return; 476 #endif 477 478 #ifdef CONFIG_DISABLE_CONSOLE 479 if (gd->flags & GD_FLG_DISABLE_CONSOLE) 480 return; 481 #endif 482 483 if (!gd->have_console) 484 return pre_console_putc(c); 485 486 if (gd->flags & GD_FLG_DEVINIT) { 487 /* Send to the standard output */ 488 fputc(stdout, c); 489 } else { 490 /* Send directly to the handler */ 491 pre_console_putc(c); 492 serial_putc(c); 493 } 494 } 495 496 void puts(const char *s) 497 { 498 #ifdef CONFIG_SANDBOX 499 if (!gd || !(gd->flags & GD_FLG_SERIAL_READY)) { 500 os_puts(s); 501 return; 502 } 503 #endif 504 #ifdef CONFIG_DEBUG_UART 505 if (!gd || !(gd->flags & GD_FLG_SERIAL_READY)) { 506 while (*s) { 507 int ch = *s++; 508 509 printch(ch); 510 if (ch == '\n') 511 printch('\r'); 512 } 513 return; 514 } 515 #endif 516 #ifdef CONFIG_SILENT_CONSOLE 517 if (gd->flags & GD_FLG_SILENT) 518 return; 519 #endif 520 521 #ifdef CONFIG_DISABLE_CONSOLE 522 if (gd->flags & GD_FLG_DISABLE_CONSOLE) 523 return; 524 #endif 525 526 if (!gd->have_console) 527 return pre_console_puts(s); 528 529 if (gd->flags & GD_FLG_DEVINIT) { 530 /* Send to the standard output */ 531 fputs(stdout, s); 532 } else { 533 /* Send directly to the handler */ 534 pre_console_puts(s); 535 serial_puts(s); 536 } 537 } 538 539 int printf(const char *fmt, ...) 540 { 541 va_list args; 542 uint i; 543 char printbuffer[CONFIG_SYS_PBSIZE]; 544 545 va_start(args, fmt); 546 547 /* For this to work, printbuffer must be larger than 548 * anything we ever want to print. 549 */ 550 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args); 551 va_end(args); 552 553 /* Print the string */ 554 puts(printbuffer); 555 return i; 556 } 557 558 int vprintf(const char *fmt, va_list args) 559 { 560 uint i; 561 char printbuffer[CONFIG_SYS_PBSIZE]; 562 563 #if defined(CONFIG_PRE_CONSOLE_BUFFER) && !defined(CONFIG_SANDBOX) 564 if (!gd->have_console) 565 return 0; 566 #endif 567 568 /* For this to work, printbuffer must be larger than 569 * anything we ever want to print. 570 */ 571 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args); 572 573 /* Print the string */ 574 puts(printbuffer); 575 return i; 576 } 577 578 /* test if ctrl-c was pressed */ 579 static int ctrlc_disabled = 0; /* see disable_ctrl() */ 580 static int ctrlc_was_pressed = 0; 581 int ctrlc(void) 582 { 583 #ifndef CONFIG_SANDBOX 584 if (!ctrlc_disabled && gd->have_console) { 585 if (tstc()) { 586 switch (getc()) { 587 case 0x03: /* ^C - Control C */ 588 ctrlc_was_pressed = 1; 589 return 1; 590 default: 591 break; 592 } 593 } 594 } 595 #endif 596 597 return 0; 598 } 599 /* Reads user's confirmation. 600 Returns 1 if user's input is "y", "Y", "yes" or "YES" 601 */ 602 int confirm_yesno(void) 603 { 604 int i; 605 char str_input[5]; 606 607 /* Flush input */ 608 while (tstc()) 609 getc(); 610 i = 0; 611 while (i < sizeof(str_input)) { 612 str_input[i] = getc(); 613 putc(str_input[i]); 614 if (str_input[i] == '\r') 615 break; 616 i++; 617 } 618 putc('\n'); 619 if (strncmp(str_input, "y\r", 2) == 0 || 620 strncmp(str_input, "Y\r", 2) == 0 || 621 strncmp(str_input, "yes\r", 4) == 0 || 622 strncmp(str_input, "YES\r", 4) == 0) 623 return 1; 624 return 0; 625 } 626 /* pass 1 to disable ctrlc() checking, 0 to enable. 627 * returns previous state 628 */ 629 int disable_ctrlc(int disable) 630 { 631 int prev = ctrlc_disabled; /* save previous state */ 632 633 ctrlc_disabled = disable; 634 return prev; 635 } 636 637 int had_ctrlc (void) 638 { 639 return ctrlc_was_pressed; 640 } 641 642 void clear_ctrlc(void) 643 { 644 ctrlc_was_pressed = 0; 645 } 646 647 #ifdef CONFIG_MODEM_SUPPORT_DEBUG 648 char screen[1024]; 649 char *cursor = screen; 650 int once = 0; 651 inline void dbg(const char *fmt, ...) 652 { 653 va_list args; 654 uint i; 655 char printbuffer[CONFIG_SYS_PBSIZE]; 656 657 if (!once) { 658 memset(screen, 0, sizeof(screen)); 659 once++; 660 } 661 662 va_start(args, fmt); 663 664 /* For this to work, printbuffer must be larger than 665 * anything we ever want to print. 666 */ 667 i = vsnprintf(printbuffer, sizeof(printbuffer), fmt, args); 668 va_end(args); 669 670 if ((screen + sizeof(screen) - 1 - cursor) 671 < strlen(printbuffer) + 1) { 672 memset(screen, 0, sizeof(screen)); 673 cursor = screen; 674 } 675 sprintf(cursor, printbuffer); 676 cursor += strlen(printbuffer); 677 678 } 679 #else 680 static inline void dbg(const char *fmt, ...) 681 { 682 } 683 #endif 684 685 /** U-Boot INIT FUNCTIONS *************************************************/ 686 687 struct stdio_dev *search_device(int flags, const char *name) 688 { 689 struct stdio_dev *dev; 690 691 dev = stdio_get_by_name(name); 692 693 if (dev && (dev->flags & flags)) 694 return dev; 695 696 return NULL; 697 } 698 699 int console_assign(int file, const char *devname) 700 { 701 int flag; 702 struct stdio_dev *dev; 703 704 /* Check for valid file */ 705 switch (file) { 706 case stdin: 707 flag = DEV_FLAGS_INPUT; 708 break; 709 case stdout: 710 case stderr: 711 flag = DEV_FLAGS_OUTPUT; 712 break; 713 default: 714 return -1; 715 } 716 717 /* Check for valid device name */ 718 719 dev = search_device(flag, devname); 720 721 if (dev) 722 return console_setfile(file, dev); 723 724 return -1; 725 } 726 727 /* Called before relocation - use serial functions */ 728 int console_init_f(void) 729 { 730 gd->have_console = 1; 731 732 #ifdef CONFIG_SILENT_CONSOLE 733 if (getenv("silent") != NULL) 734 gd->flags |= GD_FLG_SILENT; 735 #endif 736 737 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT1_SERIAL); 738 739 return 0; 740 } 741 742 void stdio_print_current_devices(void) 743 { 744 /* Print information */ 745 puts("In: "); 746 if (stdio_devices[stdin] == NULL) { 747 puts("No input devices available!\n"); 748 } else { 749 printf ("%s\n", stdio_devices[stdin]->name); 750 } 751 752 puts("Out: "); 753 if (stdio_devices[stdout] == NULL) { 754 puts("No output devices available!\n"); 755 } else { 756 printf ("%s\n", stdio_devices[stdout]->name); 757 } 758 759 puts("Err: "); 760 if (stdio_devices[stderr] == NULL) { 761 puts("No error devices available!\n"); 762 } else { 763 printf ("%s\n", stdio_devices[stderr]->name); 764 } 765 } 766 767 #ifdef CONFIG_SYS_CONSOLE_IS_IN_ENV 768 /* Called after the relocation - use desired console functions */ 769 int console_init_r(void) 770 { 771 char *stdinname, *stdoutname, *stderrname; 772 struct stdio_dev *inputdev = NULL, *outputdev = NULL, *errdev = NULL; 773 #ifdef CONFIG_SYS_CONSOLE_ENV_OVERWRITE 774 int i; 775 #endif /* CONFIG_SYS_CONSOLE_ENV_OVERWRITE */ 776 #ifdef CONFIG_CONSOLE_MUX 777 int iomux_err = 0; 778 #endif 779 780 /* set default handlers at first */ 781 gd->jt->getc = serial_getc; 782 gd->jt->tstc = serial_tstc; 783 gd->jt->putc = serial_putc; 784 gd->jt->puts = serial_puts; 785 gd->jt->printf = serial_printf; 786 787 /* stdin stdout and stderr are in environment */ 788 /* scan for it */ 789 stdinname = getenv("stdin"); 790 stdoutname = getenv("stdout"); 791 stderrname = getenv("stderr"); 792 793 if (OVERWRITE_CONSOLE == 0) { /* if not overwritten by config switch */ 794 inputdev = search_device(DEV_FLAGS_INPUT, stdinname); 795 outputdev = search_device(DEV_FLAGS_OUTPUT, stdoutname); 796 errdev = search_device(DEV_FLAGS_OUTPUT, stderrname); 797 #ifdef CONFIG_CONSOLE_MUX 798 iomux_err = iomux_doenv(stdin, stdinname); 799 iomux_err += iomux_doenv(stdout, stdoutname); 800 iomux_err += iomux_doenv(stderr, stderrname); 801 if (!iomux_err) 802 /* Successful, so skip all the code below. */ 803 goto done; 804 #endif 805 } 806 /* if the devices are overwritten or not found, use default device */ 807 if (inputdev == NULL) { 808 inputdev = search_device(DEV_FLAGS_INPUT, "serial"); 809 } 810 if (outputdev == NULL) { 811 outputdev = search_device(DEV_FLAGS_OUTPUT, "serial"); 812 } 813 if (errdev == NULL) { 814 errdev = search_device(DEV_FLAGS_OUTPUT, "serial"); 815 } 816 /* Initializes output console first */ 817 if (outputdev != NULL) { 818 /* need to set a console if not done above. */ 819 console_doenv(stdout, outputdev); 820 } 821 if (errdev != NULL) { 822 /* need to set a console if not done above. */ 823 console_doenv(stderr, errdev); 824 } 825 if (inputdev != NULL) { 826 /* need to set a console if not done above. */ 827 console_doenv(stdin, inputdev); 828 } 829 830 #ifdef CONFIG_CONSOLE_MUX 831 done: 832 #endif 833 834 #ifndef CONFIG_SYS_CONSOLE_INFO_QUIET 835 stdio_print_current_devices(); 836 #endif /* CONFIG_SYS_CONSOLE_INFO_QUIET */ 837 838 #ifdef CONFIG_SYS_CONSOLE_ENV_OVERWRITE 839 /* set the environment variables (will overwrite previous env settings) */ 840 for (i = 0; i < 3; i++) { 841 setenv(stdio_names[i], stdio_devices[i]->name); 842 } 843 #endif /* CONFIG_SYS_CONSOLE_ENV_OVERWRITE */ 844 845 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */ 846 847 #if 0 848 /* If nothing usable installed, use only the initial console */ 849 if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL)) 850 return 0; 851 #endif 852 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL); 853 return 0; 854 } 855 856 #else /* CONFIG_SYS_CONSOLE_IS_IN_ENV */ 857 858 /* Called after the relocation - use desired console functions */ 859 int console_init_r(void) 860 { 861 struct stdio_dev *inputdev = NULL, *outputdev = NULL; 862 int i; 863 struct list_head *list = stdio_get_list(); 864 struct list_head *pos; 865 struct stdio_dev *dev; 866 867 #ifdef CONFIG_SPLASH_SCREEN 868 /* 869 * suppress all output if splash screen is enabled and we have 870 * a bmp to display. We redirect the output from frame buffer 871 * console to serial console in this case or suppress it if 872 * "silent" mode was requested. 873 */ 874 if (getenv("splashimage") != NULL) { 875 if (!(gd->flags & GD_FLG_SILENT)) 876 outputdev = search_device (DEV_FLAGS_OUTPUT, "serial"); 877 } 878 #endif 879 880 /* Scan devices looking for input and output devices */ 881 list_for_each(pos, list) { 882 dev = list_entry(pos, struct stdio_dev, list); 883 884 if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) { 885 inputdev = dev; 886 } 887 if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) { 888 outputdev = dev; 889 } 890 if(inputdev && outputdev) 891 break; 892 } 893 894 /* Initializes output console first */ 895 if (outputdev != NULL) { 896 console_setfile(stdout, outputdev); 897 console_setfile(stderr, outputdev); 898 #ifdef CONFIG_CONSOLE_MUX 899 console_devices[stdout][0] = outputdev; 900 console_devices[stderr][0] = outputdev; 901 #endif 902 } 903 904 /* Initializes input console */ 905 if (inputdev != NULL) { 906 console_setfile(stdin, inputdev); 907 #ifdef CONFIG_CONSOLE_MUX 908 console_devices[stdin][0] = inputdev; 909 #endif 910 } 911 912 #ifndef CONFIG_SYS_CONSOLE_INFO_QUIET 913 stdio_print_current_devices(); 914 #endif /* CONFIG_SYS_CONSOLE_INFO_QUIET */ 915 916 /* Setting environment variables */ 917 for (i = 0; i < 3; i++) { 918 setenv(stdio_names[i], stdio_devices[i]->name); 919 } 920 921 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */ 922 923 #if 0 924 /* If nothing usable installed, use only the initial console */ 925 if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL)) 926 return 0; 927 #endif 928 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL); 929 return 0; 930 } 931 932 #endif /* CONFIG_SYS_CONSOLE_IS_IN_ENV */ 933