]> git.sur5r.net Git - u-boot/blob - common/console.c
ARM: dts: exnyos: enable dw-mmc controller
[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();
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();
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();
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(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(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();
226 }
227
228 static inline int console_tstc(int file)
229 {
230         return stdio_devices[file]->tstc();
231 }
232
233 static inline void console_putc(int file, const char c)
234 {
235         stdio_devices[file]->putc(c);
236 }
237
238 static inline void console_puts(int file, const char *s)
239 {
240         stdio_devices[file]->puts(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) {
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) {
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 #ifndef CONFIG_PRE_CONSOLE_BUFFER
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
541 /* pass 1 to disable ctrlc() checking, 0 to enable.
542  * returns previous state
543  */
544 int disable_ctrlc(int disable)
545 {
546         int prev = ctrlc_disabled;      /* save previous state */
547
548         ctrlc_disabled = disable;
549         return prev;
550 }
551
552 int had_ctrlc (void)
553 {
554         return ctrlc_was_pressed;
555 }
556
557 void clear_ctrlc(void)
558 {
559         ctrlc_was_pressed = 0;
560 }
561
562 #ifdef CONFIG_MODEM_SUPPORT_DEBUG
563 char    screen[1024];
564 char *cursor = screen;
565 int once = 0;
566 inline void dbg(const char *fmt, ...)
567 {
568         va_list args;
569         uint    i;
570         char    printbuffer[CONFIG_SYS_PBSIZE];
571
572         if (!once) {
573                 memset(screen, 0, sizeof(screen));
574                 once++;
575         }
576
577         va_start(args, fmt);
578
579         /* For this to work, printbuffer must be larger than
580          * anything we ever want to print.
581          */
582         i = vsnprintf(printbuffer, sizeof(printbuffer), fmt, args);
583         va_end(args);
584
585         if ((screen + sizeof(screen) - 1 - cursor)
586             < strlen(printbuffer) + 1) {
587                 memset(screen, 0, sizeof(screen));
588                 cursor = screen;
589         }
590         sprintf(cursor, printbuffer);
591         cursor += strlen(printbuffer);
592
593 }
594 #else
595 inline void dbg(const char *fmt, ...)
596 {
597 }
598 #endif
599
600 /** U-Boot INIT FUNCTIONS *************************************************/
601
602 struct stdio_dev *search_device(int flags, const char *name)
603 {
604         struct stdio_dev *dev;
605
606         dev = stdio_get_by_name(name);
607
608         if (dev && (dev->flags & flags))
609                 return dev;
610
611         return NULL;
612 }
613
614 int console_assign(int file, const char *devname)
615 {
616         int flag;
617         struct stdio_dev *dev;
618
619         /* Check for valid file */
620         switch (file) {
621         case stdin:
622                 flag = DEV_FLAGS_INPUT;
623                 break;
624         case stdout:
625         case stderr:
626                 flag = DEV_FLAGS_OUTPUT;
627                 break;
628         default:
629                 return -1;
630         }
631
632         /* Check for valid device name */
633
634         dev = search_device(flag, devname);
635
636         if (dev)
637                 return console_setfile(file, dev);
638
639         return -1;
640 }
641
642 /* Called before relocation - use serial functions */
643 int console_init_f(void)
644 {
645         gd->have_console = 1;
646
647 #ifdef CONFIG_SILENT_CONSOLE
648         if (getenv("silent") != NULL)
649                 gd->flags |= GD_FLG_SILENT;
650 #endif
651
652         print_pre_console_buffer();
653
654         return 0;
655 }
656
657 void stdio_print_current_devices(void)
658 {
659         /* Print information */
660         puts("In:    ");
661         if (stdio_devices[stdin] == NULL) {
662                 puts("No input devices available!\n");
663         } else {
664                 printf ("%s\n", stdio_devices[stdin]->name);
665         }
666
667         puts("Out:   ");
668         if (stdio_devices[stdout] == NULL) {
669                 puts("No output devices available!\n");
670         } else {
671                 printf ("%s\n", stdio_devices[stdout]->name);
672         }
673
674         puts("Err:   ");
675         if (stdio_devices[stderr] == NULL) {
676                 puts("No error devices available!\n");
677         } else {
678                 printf ("%s\n", stdio_devices[stderr]->name);
679         }
680 }
681
682 #ifdef CONFIG_SYS_CONSOLE_IS_IN_ENV
683 /* Called after the relocation - use desired console functions */
684 int console_init_r(void)
685 {
686         char *stdinname, *stdoutname, *stderrname;
687         struct stdio_dev *inputdev = NULL, *outputdev = NULL, *errdev = NULL;
688 #ifdef CONFIG_SYS_CONSOLE_ENV_OVERWRITE
689         int i;
690 #endif /* CONFIG_SYS_CONSOLE_ENV_OVERWRITE */
691 #ifdef CONFIG_CONSOLE_MUX
692         int iomux_err = 0;
693 #endif
694
695         /* set default handlers at first */
696         gd->jt[XF_getc] = serial_getc;
697         gd->jt[XF_tstc] = serial_tstc;
698         gd->jt[XF_putc] = serial_putc;
699         gd->jt[XF_puts] = serial_puts;
700         gd->jt[XF_printf] = serial_printf;
701
702         /* stdin stdout and stderr are in environment */
703         /* scan for it */
704         stdinname  = getenv("stdin");
705         stdoutname = getenv("stdout");
706         stderrname = getenv("stderr");
707
708         if (OVERWRITE_CONSOLE == 0) {   /* if not overwritten by config switch */
709                 inputdev  = search_device(DEV_FLAGS_INPUT,  stdinname);
710                 outputdev = search_device(DEV_FLAGS_OUTPUT, stdoutname);
711                 errdev    = search_device(DEV_FLAGS_OUTPUT, stderrname);
712 #ifdef CONFIG_CONSOLE_MUX
713                 iomux_err = iomux_doenv(stdin, stdinname);
714                 iomux_err += iomux_doenv(stdout, stdoutname);
715                 iomux_err += iomux_doenv(stderr, stderrname);
716                 if (!iomux_err)
717                         /* Successful, so skip all the code below. */
718                         goto done;
719 #endif
720         }
721         /* if the devices are overwritten or not found, use default device */
722         if (inputdev == NULL) {
723                 inputdev  = search_device(DEV_FLAGS_INPUT,  "serial");
724         }
725         if (outputdev == NULL) {
726                 outputdev = search_device(DEV_FLAGS_OUTPUT, "serial");
727         }
728         if (errdev == NULL) {
729                 errdev    = search_device(DEV_FLAGS_OUTPUT, "serial");
730         }
731         /* Initializes output console first */
732         if (outputdev != NULL) {
733                 /* need to set a console if not done above. */
734                 console_doenv(stdout, outputdev);
735         }
736         if (errdev != NULL) {
737                 /* need to set a console if not done above. */
738                 console_doenv(stderr, errdev);
739         }
740         if (inputdev != NULL) {
741                 /* need to set a console if not done above. */
742                 console_doenv(stdin, inputdev);
743         }
744
745 #ifdef CONFIG_CONSOLE_MUX
746 done:
747 #endif
748
749 #ifndef CONFIG_SYS_CONSOLE_INFO_QUIET
750         stdio_print_current_devices();
751 #endif /* CONFIG_SYS_CONSOLE_INFO_QUIET */
752
753 #ifdef CONFIG_SYS_CONSOLE_ENV_OVERWRITE
754         /* set the environment variables (will overwrite previous env settings) */
755         for (i = 0; i < 3; i++) {
756                 setenv(stdio_names[i], stdio_devices[i]->name);
757         }
758 #endif /* CONFIG_SYS_CONSOLE_ENV_OVERWRITE */
759
760         gd->flags |= GD_FLG_DEVINIT;    /* device initialization completed */
761
762 #if 0
763         /* If nothing usable installed, use only the initial console */
764         if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
765                 return 0;
766 #endif
767         return 0;
768 }
769
770 #else /* CONFIG_SYS_CONSOLE_IS_IN_ENV */
771
772 /* Called after the relocation - use desired console functions */
773 int console_init_r(void)
774 {
775         struct stdio_dev *inputdev = NULL, *outputdev = NULL;
776         int i;
777         struct list_head *list = stdio_get_list();
778         struct list_head *pos;
779         struct stdio_dev *dev;
780
781 #ifdef CONFIG_SPLASH_SCREEN
782         /*
783          * suppress all output if splash screen is enabled and we have
784          * a bmp to display. We redirect the output from frame buffer
785          * console to serial console in this case or suppress it if
786          * "silent" mode was requested.
787          */
788         if (getenv("splashimage") != NULL) {
789                 if (!(gd->flags & GD_FLG_SILENT))
790                         outputdev = search_device (DEV_FLAGS_OUTPUT, "serial");
791         }
792 #endif
793
794         /* Scan devices looking for input and output devices */
795         list_for_each(pos, list) {
796                 dev = list_entry(pos, struct stdio_dev, list);
797
798                 if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
799                         inputdev = dev;
800                 }
801                 if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
802                         outputdev = dev;
803                 }
804                 if(inputdev && outputdev)
805                         break;
806         }
807
808         /* Initializes output console first */
809         if (outputdev != NULL) {
810                 console_setfile(stdout, outputdev);
811                 console_setfile(stderr, outputdev);
812 #ifdef CONFIG_CONSOLE_MUX
813                 console_devices[stdout][0] = outputdev;
814                 console_devices[stderr][0] = outputdev;
815 #endif
816         }
817
818         /* Initializes input console */
819         if (inputdev != NULL) {
820                 console_setfile(stdin, inputdev);
821 #ifdef CONFIG_CONSOLE_MUX
822                 console_devices[stdin][0] = inputdev;
823 #endif
824         }
825
826 #ifndef CONFIG_SYS_CONSOLE_INFO_QUIET
827         stdio_print_current_devices();
828 #endif /* CONFIG_SYS_CONSOLE_INFO_QUIET */
829
830         /* Setting environment variables */
831         for (i = 0; i < 3; i++) {
832                 setenv(stdio_names[i], stdio_devices[i]->name);
833         }
834
835         gd->flags |= GD_FLG_DEVINIT;    /* device initialization completed */
836
837 #if 0
838         /* If nothing usable installed, use only the initial console */
839         if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
840                 return 0;
841 #endif
842
843         return 0;
844 }
845
846 #endif /* CONFIG_SYS_CONSOLE_IS_IN_ENV */