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