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