common/console.c

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