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