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