common/console.c

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