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