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