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