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_doenv(int file, struct stdio_dev *dev) 231 { 232 iomux_doenv(file, dev->name); 233 } 234 #else 235 static inline int console_getc(int file) 236 { 237 return stdio_devices[file]->getc(stdio_devices[file]); 238 } 239 240 static inline int console_tstc(int file) 241 { 242 return stdio_devices[file]->tstc(stdio_devices[file]); 243 } 244 245 static inline void console_putc(int file, const char c) 246 { 247 stdio_devices[file]->putc(stdio_devices[file], c); 248 } 249 250 #ifdef CONFIG_PRE_CONSOLE_BUFFER 251 static inline void console_puts_noserial(int file, const char *s) 252 { 253 if (strcmp(stdio_devices[file]->name, "serial") != 0) 254 stdio_devices[file]->puts(stdio_devices[file], s); 255 } 256 #endif 257 258 static inline void console_puts(int file, const char *s) 259 { 260 stdio_devices[file]->puts(stdio_devices[file], s); 261 } 262 263 static inline void console_doenv(int file, struct stdio_dev *dev) 264 { 265 console_setfile(file, dev); 266 } 267 #endif /* defined(CONFIG_CONSOLE_MUX) */ 268 269 /** U-Boot INITIAL CONSOLE-NOT COMPATIBLE FUNCTIONS *************************/ 270 271 int serial_printf(const char *fmt, ...) 272 { 273 va_list args; 274 uint i; 275 char printbuffer[CONFIG_SYS_PBSIZE]; 276 277 va_start(args, fmt); 278 279 /* For this to work, printbuffer must be larger than 280 * anything we ever want to print. 281 */ 282 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args); 283 va_end(args); 284 285 serial_puts(printbuffer); 286 return i; 287 } 288 289 int fgetc(int file) 290 { 291 if (file < MAX_FILES) { 292 #if defined(CONFIG_CONSOLE_MUX) 293 /* 294 * Effectively poll for input wherever it may be available. 295 */ 296 for (;;) { 297 /* 298 * Upper layer may have already called tstc() so 299 * check for that first. 300 */ 301 if (tstcdev != NULL) 302 return console_getc(file); 303 console_tstc(file); 304 #ifdef CONFIG_WATCHDOG 305 /* 306 * If the watchdog must be rate-limited then it should 307 * already be handled in board-specific code. 308 */ 309 udelay(1); 310 #endif 311 } 312 #else 313 return console_getc(file); 314 #endif 315 } 316 317 return -1; 318 } 319 320 int ftstc(int file) 321 { 322 if (file < MAX_FILES) 323 return console_tstc(file); 324 325 return -1; 326 } 327 328 void fputc(int file, const char c) 329 { 330 if (file < MAX_FILES) 331 console_putc(file, c); 332 } 333 334 void fputs(int file, const char *s) 335 { 336 if (file < MAX_FILES) 337 console_puts(file, s); 338 } 339 340 int fprintf(int file, const char *fmt, ...) 341 { 342 va_list args; 343 uint i; 344 char printbuffer[CONFIG_SYS_PBSIZE]; 345 346 va_start(args, fmt); 347 348 /* For this to work, printbuffer must be larger than 349 * anything we ever want to print. 350 */ 351 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args); 352 va_end(args); 353 354 /* Send to desired file */ 355 fputs(file, printbuffer); 356 return i; 357 } 358 359 /** U-Boot INITIAL CONSOLE-COMPATIBLE FUNCTION *****************************/ 360 361 int getc(void) 362 { 363 #ifdef CONFIG_DISABLE_CONSOLE 364 if (gd->flags & GD_FLG_DISABLE_CONSOLE) 365 return 0; 366 #endif 367 368 if (!gd->have_console) 369 return 0; 370 371 #ifdef CONFIG_CONSOLE_RECORD 372 if (gd->console_in.start) { 373 int ch; 374 375 ch = membuff_getbyte(&gd->console_in); 376 if (ch != -1) 377 return 1; 378 } 379 #endif 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 #ifdef CONFIG_CONSOLE_RECORD 399 if (gd->console_in.start) { 400 if (membuff_peekbyte(&gd->console_in) != -1) 401 return 1; 402 } 403 #endif 404 if (gd->flags & GD_FLG_DEVINIT) { 405 /* Test the standard input */ 406 return ftstc(stdin); 407 } 408 409 /* Send directly to the handler */ 410 return serial_tstc(); 411 } 412 413 #define PRE_CONSOLE_FLUSHPOINT1_SERIAL 0 414 #define PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL 1 415 416 #ifdef CONFIG_PRE_CONSOLE_BUFFER 417 #define CIRC_BUF_IDX(idx) ((idx) % (unsigned long)CONFIG_PRE_CON_BUF_SZ) 418 419 static void pre_console_putc(const char c) 420 { 421 char *buffer = (char *)CONFIG_PRE_CON_BUF_ADDR; 422 423 buffer[CIRC_BUF_IDX(gd->precon_buf_idx++)] = c; 424 } 425 426 static void pre_console_puts(const char *s) 427 { 428 while (*s) 429 pre_console_putc(*s++); 430 } 431 432 static void print_pre_console_buffer(int flushpoint) 433 { 434 unsigned long in = 0, out = 0; 435 char *buf_in = (char *)CONFIG_PRE_CON_BUF_ADDR; 436 char buf_out[CONFIG_PRE_CON_BUF_SZ + 1]; 437 438 if (gd->precon_buf_idx > CONFIG_PRE_CON_BUF_SZ) 439 in = gd->precon_buf_idx - CONFIG_PRE_CON_BUF_SZ; 440 441 while (in < gd->precon_buf_idx) 442 buf_out[out++] = buf_in[CIRC_BUF_IDX(in++)]; 443 444 buf_out[out] = 0; 445 446 switch (flushpoint) { 447 case PRE_CONSOLE_FLUSHPOINT1_SERIAL: 448 puts(buf_out); 449 break; 450 case PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL: 451 console_puts_noserial(stdout, buf_out); 452 break; 453 } 454 } 455 #else 456 static inline void pre_console_putc(const char c) {} 457 static inline void pre_console_puts(const char *s) {} 458 static inline void print_pre_console_buffer(int flushpoint) {} 459 #endif 460 461 void putc(const char c) 462 { 463 #ifdef CONFIG_SANDBOX 464 /* sandbox can send characters to stdout before it has a console */ 465 if (!gd || !(gd->flags & GD_FLG_SERIAL_READY)) { 466 os_putc(c); 467 return; 468 } 469 #endif 470 #ifdef CONFIG_DEBUG_UART 471 /* if we don't have a console yet, use the debug UART */ 472 if (!gd || !(gd->flags & GD_FLG_SERIAL_READY)) { 473 printch(c); 474 return; 475 } 476 #endif 477 #ifdef CONFIG_CONSOLE_RECORD 478 if (gd && (gd->flags & GD_FLG_RECORD) && gd->console_out.start) 479 membuff_putbyte(&gd->console_out, c); 480 #endif 481 #ifdef CONFIG_SILENT_CONSOLE 482 if (gd->flags & GD_FLG_SILENT) 483 return; 484 #endif 485 486 #ifdef CONFIG_DISABLE_CONSOLE 487 if (gd->flags & GD_FLG_DISABLE_CONSOLE) 488 return; 489 #endif 490 491 if (!gd->have_console) 492 return pre_console_putc(c); 493 494 if (gd->flags & GD_FLG_DEVINIT) { 495 /* Send to the standard output */ 496 fputc(stdout, c); 497 } else { 498 /* Send directly to the handler */ 499 pre_console_putc(c); 500 serial_putc(c); 501 } 502 } 503 504 void puts(const char *s) 505 { 506 #ifdef CONFIG_SANDBOX 507 if (!gd || !(gd->flags & GD_FLG_SERIAL_READY)) { 508 os_puts(s); 509 return; 510 } 511 #endif 512 #ifdef CONFIG_DEBUG_UART 513 if (!gd || !(gd->flags & GD_FLG_SERIAL_READY)) { 514 while (*s) { 515 int ch = *s++; 516 517 printch(ch); 518 } 519 return; 520 } 521 #endif 522 #ifdef CONFIG_CONSOLE_RECORD 523 if (gd && (gd->flags & GD_FLG_RECORD) && gd->console_out.start) 524 membuff_put(&gd->console_out, s, strlen(s)); 525 #endif 526 #ifdef CONFIG_SILENT_CONSOLE 527 if (gd->flags & GD_FLG_SILENT) 528 return; 529 #endif 530 531 #ifdef CONFIG_DISABLE_CONSOLE 532 if (gd->flags & GD_FLG_DISABLE_CONSOLE) 533 return; 534 #endif 535 536 if (!gd->have_console) 537 return pre_console_puts(s); 538 539 if (gd->flags & GD_FLG_DEVINIT) { 540 /* Send to the standard output */ 541 fputs(stdout, s); 542 } else { 543 /* Send directly to the handler */ 544 pre_console_puts(s); 545 serial_puts(s); 546 } 547 } 548 549 #ifdef CONFIG_CONSOLE_RECORD 550 int console_record_init(void) 551 { 552 int ret; 553 554 ret = membuff_new(&gd->console_out, CONFIG_CONSOLE_RECORD_OUT_SIZE); 555 if (ret) 556 return ret; 557 ret = membuff_new(&gd->console_in, CONFIG_CONSOLE_RECORD_IN_SIZE); 558 559 return ret; 560 } 561 562 void console_record_reset(void) 563 { 564 membuff_purge(&gd->console_out); 565 membuff_purge(&gd->console_in); 566 } 567 568 void console_record_reset_enable(void) 569 { 570 console_record_reset(); 571 gd->flags |= GD_FLG_RECORD; 572 } 573 #endif 574 575 /* test if ctrl-c was pressed */ 576 static int ctrlc_disabled = 0; /* see disable_ctrl() */ 577 static int ctrlc_was_pressed = 0; 578 int ctrlc(void) 579 { 580 #ifndef CONFIG_SANDBOX 581 if (!ctrlc_disabled && gd->have_console) { 582 if (tstc()) { 583 switch (getc()) { 584 case 0x03: /* ^C - Control C */ 585 ctrlc_was_pressed = 1; 586 return 1; 587 default: 588 break; 589 } 590 } 591 } 592 #endif 593 594 return 0; 595 } 596 /* Reads user's confirmation. 597 Returns 1 if user's input is "y", "Y", "yes" or "YES" 598 */ 599 int confirm_yesno(void) 600 { 601 int i; 602 char str_input[5]; 603 604 /* Flush input */ 605 while (tstc()) 606 getc(); 607 i = 0; 608 while (i < sizeof(str_input)) { 609 str_input[i] = getc(); 610 putc(str_input[i]); 611 if (str_input[i] == '\r') 612 break; 613 i++; 614 } 615 putc('\n'); 616 if (strncmp(str_input, "y\r", 2) == 0 || 617 strncmp(str_input, "Y\r", 2) == 0 || 618 strncmp(str_input, "yes\r", 4) == 0 || 619 strncmp(str_input, "YES\r", 4) == 0) 620 return 1; 621 return 0; 622 } 623 /* pass 1 to disable ctrlc() checking, 0 to enable. 624 * returns previous state 625 */ 626 int disable_ctrlc(int disable) 627 { 628 int prev = ctrlc_disabled; /* save previous state */ 629 630 ctrlc_disabled = disable; 631 return prev; 632 } 633 634 int had_ctrlc (void) 635 { 636 return ctrlc_was_pressed; 637 } 638 639 void clear_ctrlc(void) 640 { 641 ctrlc_was_pressed = 0; 642 } 643 644 /** U-Boot INIT FUNCTIONS *************************************************/ 645 646 struct stdio_dev *search_device(int flags, const char *name) 647 { 648 struct stdio_dev *dev; 649 650 dev = stdio_get_by_name(name); 651 #ifdef CONFIG_VIDCONSOLE_AS_LCD 652 if (!dev && !strcmp(name, "lcd")) 653 dev = stdio_get_by_name("vidconsole"); 654 #endif 655 656 if (dev && (dev->flags & flags)) 657 return dev; 658 659 return NULL; 660 } 661 662 int console_assign(int file, const char *devname) 663 { 664 int flag; 665 struct stdio_dev *dev; 666 667 /* Check for valid file */ 668 switch (file) { 669 case stdin: 670 flag = DEV_FLAGS_INPUT; 671 break; 672 case stdout: 673 case stderr: 674 flag = DEV_FLAGS_OUTPUT; 675 break; 676 default: 677 return -1; 678 } 679 680 /* Check for valid device name */ 681 682 dev = search_device(flag, devname); 683 684 if (dev) 685 return console_setfile(file, dev); 686 687 return -1; 688 } 689 690 static void console_update_silent(void) 691 { 692 #ifdef CONFIG_SILENT_CONSOLE 693 if (getenv("silent") != NULL) 694 gd->flags |= GD_FLG_SILENT; 695 else 696 gd->flags &= ~GD_FLG_SILENT; 697 #endif 698 } 699 700 /* Called before relocation - use serial functions */ 701 int console_init_f(void) 702 { 703 gd->have_console = 1; 704 705 console_update_silent(); 706 707 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT1_SERIAL); 708 709 return 0; 710 } 711 712 void stdio_print_current_devices(void) 713 { 714 /* Print information */ 715 puts("In: "); 716 if (stdio_devices[stdin] == NULL) { 717 puts("No input devices available!\n"); 718 } else { 719 printf ("%s\n", stdio_devices[stdin]->name); 720 } 721 722 puts("Out: "); 723 if (stdio_devices[stdout] == NULL) { 724 puts("No output devices available!\n"); 725 } else { 726 printf ("%s\n", stdio_devices[stdout]->name); 727 } 728 729 puts("Err: "); 730 if (stdio_devices[stderr] == NULL) { 731 puts("No error devices available!\n"); 732 } else { 733 printf ("%s\n", stdio_devices[stderr]->name); 734 } 735 } 736 737 #ifdef CONFIG_SYS_CONSOLE_IS_IN_ENV 738 /* Called after the relocation - use desired console functions */ 739 int console_init_r(void) 740 { 741 char *stdinname, *stdoutname, *stderrname; 742 struct stdio_dev *inputdev = NULL, *outputdev = NULL, *errdev = NULL; 743 #ifdef CONFIG_SYS_CONSOLE_ENV_OVERWRITE 744 int i; 745 #endif /* CONFIG_SYS_CONSOLE_ENV_OVERWRITE */ 746 #ifdef CONFIG_CONSOLE_MUX 747 int iomux_err = 0; 748 #endif 749 750 /* set default handlers at first */ 751 gd->jt->getc = serial_getc; 752 gd->jt->tstc = serial_tstc; 753 gd->jt->putc = serial_putc; 754 gd->jt->puts = serial_puts; 755 gd->jt->printf = serial_printf; 756 757 /* stdin stdout and stderr are in environment */ 758 /* scan for it */ 759 stdinname = getenv("stdin"); 760 stdoutname = getenv("stdout"); 761 stderrname = getenv("stderr"); 762 763 if (OVERWRITE_CONSOLE == 0) { /* if not overwritten by config switch */ 764 inputdev = search_device(DEV_FLAGS_INPUT, stdinname); 765 outputdev = search_device(DEV_FLAGS_OUTPUT, stdoutname); 766 errdev = search_device(DEV_FLAGS_OUTPUT, stderrname); 767 #ifdef CONFIG_CONSOLE_MUX 768 iomux_err = iomux_doenv(stdin, stdinname); 769 iomux_err += iomux_doenv(stdout, stdoutname); 770 iomux_err += iomux_doenv(stderr, stderrname); 771 if (!iomux_err) 772 /* Successful, so skip all the code below. */ 773 goto done; 774 #endif 775 } 776 /* if the devices are overwritten or not found, use default device */ 777 if (inputdev == NULL) { 778 inputdev = search_device(DEV_FLAGS_INPUT, "serial"); 779 } 780 if (outputdev == NULL) { 781 outputdev = search_device(DEV_FLAGS_OUTPUT, "serial"); 782 } 783 if (errdev == NULL) { 784 errdev = search_device(DEV_FLAGS_OUTPUT, "serial"); 785 } 786 /* Initializes output console first */ 787 if (outputdev != NULL) { 788 /* need to set a console if not done above. */ 789 console_doenv(stdout, outputdev); 790 } 791 if (errdev != NULL) { 792 /* need to set a console if not done above. */ 793 console_doenv(stderr, errdev); 794 } 795 if (inputdev != NULL) { 796 /* need to set a console if not done above. */ 797 console_doenv(stdin, inputdev); 798 } 799 800 #ifdef CONFIG_CONSOLE_MUX 801 done: 802 #endif 803 804 #ifndef CONFIG_SYS_CONSOLE_INFO_QUIET 805 stdio_print_current_devices(); 806 #endif /* CONFIG_SYS_CONSOLE_INFO_QUIET */ 807 #ifdef CONFIG_VIDCONSOLE_AS_LCD 808 if (strstr(stdoutname, "lcd")) 809 printf("Warning: Please change 'lcd' to 'vidconsole' in stdout/stderr environment vars\n"); 810 #endif 811 812 #ifdef CONFIG_SYS_CONSOLE_ENV_OVERWRITE 813 /* set the environment variables (will overwrite previous env settings) */ 814 for (i = 0; i < 3; i++) { 815 setenv(stdio_names[i], stdio_devices[i]->name); 816 } 817 #endif /* CONFIG_SYS_CONSOLE_ENV_OVERWRITE */ 818 819 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */ 820 821 #if 0 822 /* If nothing usable installed, use only the initial console */ 823 if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL)) 824 return 0; 825 #endif 826 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL); 827 return 0; 828 } 829 830 #else /* CONFIG_SYS_CONSOLE_IS_IN_ENV */ 831 832 /* Called after the relocation - use desired console functions */ 833 int console_init_r(void) 834 { 835 struct stdio_dev *inputdev = NULL, *outputdev = NULL; 836 int i; 837 struct list_head *list = stdio_get_list(); 838 struct list_head *pos; 839 struct stdio_dev *dev; 840 841 console_update_silent(); 842 843 #ifdef CONFIG_SPLASH_SCREEN 844 /* 845 * suppress all output if splash screen is enabled and we have 846 * a bmp to display. We redirect the output from frame buffer 847 * console to serial console in this case or suppress it if 848 * "silent" mode was requested. 849 */ 850 if (getenv("splashimage") != NULL) { 851 if (!(gd->flags & GD_FLG_SILENT)) 852 outputdev = search_device (DEV_FLAGS_OUTPUT, "serial"); 853 } 854 #endif 855 856 /* Scan devices looking for input and output devices */ 857 list_for_each(pos, list) { 858 dev = list_entry(pos, struct stdio_dev, list); 859 860 if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) { 861 inputdev = dev; 862 } 863 if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) { 864 outputdev = dev; 865 } 866 if(inputdev && outputdev) 867 break; 868 } 869 870 /* Initializes output console first */ 871 if (outputdev != NULL) { 872 console_setfile(stdout, outputdev); 873 console_setfile(stderr, outputdev); 874 #ifdef CONFIG_CONSOLE_MUX 875 console_devices[stdout][0] = outputdev; 876 console_devices[stderr][0] = outputdev; 877 #endif 878 } 879 880 /* Initializes input console */ 881 if (inputdev != NULL) { 882 console_setfile(stdin, inputdev); 883 #ifdef CONFIG_CONSOLE_MUX 884 console_devices[stdin][0] = inputdev; 885 #endif 886 } 887 888 #ifndef CONFIG_SYS_CONSOLE_INFO_QUIET 889 stdio_print_current_devices(); 890 #endif /* CONFIG_SYS_CONSOLE_INFO_QUIET */ 891 892 /* Setting environment variables */ 893 for (i = 0; i < 3; i++) { 894 setenv(stdio_names[i], stdio_devices[i]->name); 895 } 896 897 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */ 898 899 #if 0 900 /* If nothing usable installed, use only the initial console */ 901 if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL)) 902 return 0; 903 #endif 904 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL); 905 return 0; 906 } 907 908 #endif /* CONFIG_SYS_CONSOLE_IS_IN_ENV */ 909