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