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