1
2
3
4
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
23DECLARE_GLOBAL_DATA_PTR;
24
25static int on_console(const char *name, const char *value, enum env_op op,
26 int flags)
27{
28 int console = -1;
29
30
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
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
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}
65U_BOOT_ENV_CALLBACK(console, on_console);
66
67#ifdef CONFIG_SILENT_CONSOLE
68static 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}
87U_BOOT_ENV_CALLBACK(silent, on_silent);
88#endif
89
90#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
91
92
93
94
95
96#ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE
97extern int overwrite_console(void);
98#define OVERWRITE_CONSOLE overwrite_console()
99#else
100#define OVERWRITE_CONSOLE 0
101#endif
102
103#endif
104
105static 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
117 if (dev->start) {
118 error = dev->start(dev);
119
120 if (error < 0)
121 break;
122 }
123
124
125 stdio_devices[file] = dev;
126
127
128
129
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:
145 error = -1;
146 }
147 return error;
148}
149
150
151
152
153
154
155
156
157static 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
175
176static struct stdio_dev *tstcdev;
177struct stdio_dev **console_devices[MAX_FILES];
178int cd_count[MAX_FILES];
179
180
181
182
183
184
185
186static int console_getc(int file)
187{
188 unsigned char ret;
189
190
191 ret = tstcdev->getc(tstcdev);
192 tstcdev = NULL;
193 return ret;
194}
195
196static 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
219static 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
231static 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
243static 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#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
256static inline void console_doenv(int file, struct stdio_dev *dev)
257{
258 iomux_doenv(file, dev->name);
259}
260#endif
261#else
262static inline int console_getc(int file)
263{
264 return stdio_devices[file]->getc(stdio_devices[file]);
265}
266
267static inline int console_tstc(int file)
268{
269 return stdio_devices[file]->tstc(stdio_devices[file]);
270}
271
272static inline void console_putc(int file, const char c)
273{
274 stdio_devices[file]->putc(stdio_devices[file], c);
275}
276
277static inline void console_puts_noserial(int file, const char *s)
278{
279 if (!console_dev_is_serial(stdio_devices[file]))
280 stdio_devices[file]->puts(stdio_devices[file], s);
281}
282
283static inline void console_puts(int file, const char *s)
284{
285 stdio_devices[file]->puts(stdio_devices[file], s);
286}
287
288#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
289static inline void console_doenv(int file, struct stdio_dev *dev)
290{
291 console_setfile(file, dev);
292}
293#endif
294#endif
295
296
297
298int serial_printf(const char *fmt, ...)
299{
300 va_list args;
301 uint i;
302 char printbuffer[CONFIG_SYS_PBSIZE];
303
304 va_start(args, fmt);
305
306
307
308
309 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
310 va_end(args);
311
312 serial_puts(printbuffer);
313 return i;
314}
315
316int fgetc(int file)
317{
318 if (file < MAX_FILES) {
319
320
321
322 for (;;) {
323 WATCHDOG_RESET();
324#if CONFIG_IS_ENABLED(CONSOLE_MUX)
325
326
327
328
329 if (tstcdev != NULL)
330 return console_getc(file);
331 console_tstc(file);
332#else
333 if (console_tstc(file))
334 return console_getc(file);
335#endif
336#ifdef CONFIG_WATCHDOG
337
338
339
340
341 udelay(1);
342#endif
343 }
344 }
345
346 return -1;
347}
348
349int ftstc(int file)
350{
351 if (file < MAX_FILES)
352 return console_tstc(file);
353
354 return -1;
355}
356
357void fputc(int file, const char c)
358{
359 if (file < MAX_FILES)
360 console_putc(file, c);
361}
362
363void fputs(int file, const char *s)
364{
365 if (file < MAX_FILES)
366 console_puts(file, s);
367}
368
369int fprintf(int file, const char *fmt, ...)
370{
371 va_list args;
372 uint i;
373 char printbuffer[CONFIG_SYS_PBSIZE];
374
375 va_start(args, fmt);
376
377
378
379
380 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
381 va_end(args);
382
383
384 fputs(file, printbuffer);
385 return i;
386}
387
388
389
390int getc(void)
391{
392#ifdef CONFIG_DISABLE_CONSOLE
393 if (gd->flags & GD_FLG_DISABLE_CONSOLE)
394 return 0;
395#endif
396
397 if (!gd->have_console)
398 return 0;
399
400#ifdef CONFIG_CONSOLE_RECORD
401 if (gd->console_in.start) {
402 int ch;
403
404 ch = membuff_getbyte(&gd->console_in);
405 if (ch != -1)
406 return 1;
407 }
408#endif
409 if (gd->flags & GD_FLG_DEVINIT) {
410
411 return fgetc(stdin);
412 }
413
414
415 return serial_getc();
416}
417
418int tstc(void)
419{
420#ifdef CONFIG_DISABLE_CONSOLE
421 if (gd->flags & GD_FLG_DISABLE_CONSOLE)
422 return 0;
423#endif
424
425 if (!gd->have_console)
426 return 0;
427#ifdef CONFIG_CONSOLE_RECORD
428 if (gd->console_in.start) {
429 if (membuff_peekbyte(&gd->console_in) != -1)
430 return 1;
431 }
432#endif
433 if (gd->flags & GD_FLG_DEVINIT) {
434
435 return ftstc(stdin);
436 }
437
438
439 return serial_tstc();
440}
441
442#define PRE_CONSOLE_FLUSHPOINT1_SERIAL 0
443#define PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL 1
444
445#if CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
446#define CIRC_BUF_IDX(idx) ((idx) % (unsigned long)CONFIG_PRE_CON_BUF_SZ)
447
448static void pre_console_putc(const char c)
449{
450 char *buffer;
451
452 buffer = map_sysmem(CONFIG_PRE_CON_BUF_ADDR, CONFIG_PRE_CON_BUF_SZ);
453
454 buffer[CIRC_BUF_IDX(gd->precon_buf_idx++)] = c;
455
456 unmap_sysmem(buffer);
457}
458
459static void pre_console_puts(const char *s)
460{
461 while (*s)
462 pre_console_putc(*s++);
463}
464
465static void print_pre_console_buffer(int flushpoint)
466{
467 unsigned long in = 0, out = 0;
468 char buf_out[CONFIG_PRE_CON_BUF_SZ + 1];
469 char *buf_in;
470
471#ifdef CONFIG_SILENT_CONSOLE
472 if (gd->flags & GD_FLG_SILENT)
473 return;
474#endif
475
476 buf_in = map_sysmem(CONFIG_PRE_CON_BUF_ADDR, CONFIG_PRE_CON_BUF_SZ);
477 if (gd->precon_buf_idx > CONFIG_PRE_CON_BUF_SZ)
478 in = gd->precon_buf_idx - CONFIG_PRE_CON_BUF_SZ;
479
480 while (in < gd->precon_buf_idx)
481 buf_out[out++] = buf_in[CIRC_BUF_IDX(in++)];
482 unmap_sysmem(buf_in);
483
484 buf_out[out] = 0;
485
486 switch (flushpoint) {
487 case PRE_CONSOLE_FLUSHPOINT1_SERIAL:
488 puts(buf_out);
489 break;
490 case PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL:
491 console_puts_noserial(stdout, buf_out);
492 break;
493 }
494}
495#else
496static inline void pre_console_putc(const char c) {}
497static inline void pre_console_puts(const char *s) {}
498static inline void print_pre_console_buffer(int flushpoint) {}
499#endif
500
501void putc(const char c)
502{
503#ifdef CONFIG_SANDBOX
504
505 if (!gd || !(gd->flags & GD_FLG_SERIAL_READY)) {
506 os_putc(c);
507 return;
508 }
509#endif
510#ifdef CONFIG_DEBUG_UART
511
512 if (!gd || !(gd->flags & GD_FLG_SERIAL_READY)) {
513 printch(c);
514 return;
515 }
516#endif
517 if (!gd)
518 return;
519#ifdef CONFIG_CONSOLE_RECORD
520 if ((gd->flags & GD_FLG_RECORD) && gd->console_out.start)
521 membuff_putbyte(&gd->console_out, c);
522#endif
523#ifdef CONFIG_SILENT_CONSOLE
524 if (gd->flags & GD_FLG_SILENT) {
525 if (!(gd->flags & GD_FLG_DEVINIT))
526 pre_console_putc(c);
527 return;
528 }
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_putc(c);
538
539 if (gd->flags & GD_FLG_DEVINIT) {
540
541 fputc(stdout, c);
542 } else {
543
544 pre_console_putc(c);
545 serial_putc(c);
546 }
547}
548
549void puts(const char *s)
550{
551#ifdef CONFIG_SANDBOX
552
553 if (!gd || !(gd->flags & GD_FLG_SERIAL_READY)) {
554 os_puts(s);
555 return;
556 }
557#endif
558#ifdef CONFIG_DEBUG_UART
559 if (!gd || !(gd->flags & GD_FLG_SERIAL_READY)) {
560 while (*s) {
561 int ch = *s++;
562
563 printch(ch);
564 }
565 return;
566 }
567#endif
568 if (!gd)
569 return;
570#ifdef CONFIG_CONSOLE_RECORD
571 if ((gd->flags & GD_FLG_RECORD) && gd->console_out.start)
572 membuff_put(&gd->console_out, s, strlen(s));
573#endif
574#ifdef CONFIG_SILENT_CONSOLE
575 if (gd->flags & GD_FLG_SILENT) {
576 if (!(gd->flags & GD_FLG_DEVINIT))
577 pre_console_puts(s);
578 return;
579 }
580#endif
581
582#ifdef CONFIG_DISABLE_CONSOLE
583 if (gd->flags & GD_FLG_DISABLE_CONSOLE)
584 return;
585#endif
586
587 if (!gd->have_console)
588 return pre_console_puts(s);
589
590 if (gd->flags & GD_FLG_DEVINIT) {
591
592 fputs(stdout, s);
593 } else {
594
595 pre_console_puts(s);
596 serial_puts(s);
597 }
598}
599
600#ifdef CONFIG_CONSOLE_RECORD
601int console_record_init(void)
602{
603 int ret;
604
605 ret = membuff_new(&gd->console_out, CONFIG_CONSOLE_RECORD_OUT_SIZE);
606 if (ret)
607 return ret;
608 ret = membuff_new(&gd->console_in, CONFIG_CONSOLE_RECORD_IN_SIZE);
609
610 return ret;
611}
612
613void console_record_reset(void)
614{
615 membuff_purge(&gd->console_out);
616 membuff_purge(&gd->console_in);
617}
618
619void console_record_reset_enable(void)
620{
621 console_record_reset();
622 gd->flags |= GD_FLG_RECORD;
623}
624#endif
625
626
627static int ctrlc_disabled = 0;
628static int ctrlc_was_pressed = 0;
629int ctrlc(void)
630{
631 if (!ctrlc_disabled && gd->have_console) {
632 if (tstc()) {
633 switch (getc()) {
634 case 0x03:
635 ctrlc_was_pressed = 1;
636 return 1;
637 default:
638 break;
639 }
640 }
641 }
642
643 return 0;
644}
645
646
647
648int confirm_yesno(void)
649{
650 int i;
651 char str_input[5];
652
653
654 while (tstc())
655 getc();
656 i = 0;
657 while (i < sizeof(str_input)) {
658 str_input[i] = getc();
659 putc(str_input[i]);
660 if (str_input[i] == '\r')
661 break;
662 i++;
663 }
664 putc('\n');
665 if (strncmp(str_input, "y\r", 2) == 0 ||
666 strncmp(str_input, "Y\r", 2) == 0 ||
667 strncmp(str_input, "yes\r", 4) == 0 ||
668 strncmp(str_input, "YES\r", 4) == 0)
669 return 1;
670 return 0;
671}
672
673
674
675int disable_ctrlc(int disable)
676{
677 int prev = ctrlc_disabled;
678
679 ctrlc_disabled = disable;
680 return prev;
681}
682
683int had_ctrlc (void)
684{
685 return ctrlc_was_pressed;
686}
687
688void clear_ctrlc(void)
689{
690 ctrlc_was_pressed = 0;
691}
692
693
694
695struct stdio_dev *search_device(int flags, const char *name)
696{
697 struct stdio_dev *dev;
698
699 dev = stdio_get_by_name(name);
700#ifdef CONFIG_VIDCONSOLE_AS_LCD
701 if (!dev && !strcmp(name, "lcd"))
702 dev = stdio_get_by_name("vidconsole");
703#endif
704
705 if (dev && (dev->flags & flags))
706 return dev;
707
708 return NULL;
709}
710
711int console_assign(int file, const char *devname)
712{
713 int flag;
714 struct stdio_dev *dev;
715
716
717 switch (file) {
718 case stdin:
719 flag = DEV_FLAGS_INPUT;
720 break;
721 case stdout:
722 case stderr:
723 flag = DEV_FLAGS_OUTPUT;
724 break;
725 default:
726 return -1;
727 }
728
729
730
731 dev = search_device(flag, devname);
732
733 if (dev)
734 return console_setfile(file, dev);
735
736 return -1;
737}
738
739
740static bool console_update_silent(void)
741{
742#ifdef CONFIG_SILENT_CONSOLE
743 if (env_get("silent")) {
744 gd->flags |= GD_FLG_SILENT;
745 } else {
746 unsigned long flags = gd->flags;
747
748 gd->flags &= ~GD_FLG_SILENT;
749
750 return !!(flags & GD_FLG_SILENT);
751 }
752#endif
753
754 return false;
755}
756
757int console_announce_r(void)
758{
759#if !CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
760 char buf[DISPLAY_OPTIONS_BANNER_LENGTH];
761
762 display_options_get_banner(false, buf, sizeof(buf));
763
764 console_puts_noserial(stdout, buf);
765#endif
766
767 return 0;
768}
769
770
771int console_init_f(void)
772{
773 gd->have_console = 1;
774
775 console_update_silent();
776
777 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT1_SERIAL);
778
779 return 0;
780}
781
782void stdio_print_current_devices(void)
783{
784
785 puts("In: ");
786 if (stdio_devices[stdin] == NULL) {
787 puts("No input devices available!\n");
788 } else {
789 printf ("%s\n", stdio_devices[stdin]->name);
790 }
791
792 puts("Out: ");
793 if (stdio_devices[stdout] == NULL) {
794 puts("No output devices available!\n");
795 } else {
796 printf ("%s\n", stdio_devices[stdout]->name);
797 }
798
799 puts("Err: ");
800 if (stdio_devices[stderr] == NULL) {
801 puts("No error devices available!\n");
802 } else {
803 printf ("%s\n", stdio_devices[stderr]->name);
804 }
805}
806
807#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
808
809int console_init_r(void)
810{
811 char *stdinname, *stdoutname, *stderrname;
812 struct stdio_dev *inputdev = NULL, *outputdev = NULL, *errdev = NULL;
813#ifdef CONFIG_SYS_CONSOLE_ENV_OVERWRITE
814 int i;
815#endif
816#if CONFIG_IS_ENABLED(CONSOLE_MUX)
817 int iomux_err = 0;
818#endif
819 int flushpoint;
820
821
822 if (console_update_silent())
823 flushpoint = PRE_CONSOLE_FLUSHPOINT1_SERIAL;
824 else
825 flushpoint = PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL;
826
827
828 gd->jt->getc = serial_getc;
829 gd->jt->tstc = serial_tstc;
830 gd->jt->putc = serial_putc;
831 gd->jt->puts = serial_puts;
832 gd->jt->printf = serial_printf;
833
834
835
836 stdinname = env_get("stdin");
837 stdoutname = env_get("stdout");
838 stderrname = env_get("stderr");
839
840 if (OVERWRITE_CONSOLE == 0) {
841 inputdev = search_device(DEV_FLAGS_INPUT, stdinname);
842 outputdev = search_device(DEV_FLAGS_OUTPUT, stdoutname);
843 errdev = search_device(DEV_FLAGS_OUTPUT, stderrname);
844#if CONFIG_IS_ENABLED(CONSOLE_MUX)
845 iomux_err = iomux_doenv(stdin, stdinname);
846 iomux_err += iomux_doenv(stdout, stdoutname);
847 iomux_err += iomux_doenv(stderr, stderrname);
848 if (!iomux_err)
849
850 goto done;
851#endif
852 }
853
854 if (inputdev == NULL) {
855 inputdev = search_device(DEV_FLAGS_INPUT, "serial");
856 }
857 if (outputdev == NULL) {
858 outputdev = search_device(DEV_FLAGS_OUTPUT, "serial");
859 }
860 if (errdev == NULL) {
861 errdev = search_device(DEV_FLAGS_OUTPUT, "serial");
862 }
863
864 if (outputdev != NULL) {
865
866 console_doenv(stdout, outputdev);
867 }
868 if (errdev != NULL) {
869
870 console_doenv(stderr, errdev);
871 }
872 if (inputdev != NULL) {
873
874 console_doenv(stdin, inputdev);
875 }
876
877#if CONFIG_IS_ENABLED(CONSOLE_MUX)
878done:
879#endif
880
881#ifndef CONFIG_SYS_CONSOLE_INFO_QUIET
882 stdio_print_current_devices();
883#endif
884#ifdef CONFIG_VIDCONSOLE_AS_LCD
885 if (strstr(stdoutname, "lcd"))
886 printf("Warning: Please change 'lcd' to 'vidconsole' in stdout/stderr environment vars\n");
887#endif
888
889#ifdef CONFIG_SYS_CONSOLE_ENV_OVERWRITE
890
891 for (i = 0; i < MAX_FILES; i++) {
892 env_set(stdio_names[i], stdio_devices[i]->name);
893 }
894#endif
895
896 gd->flags |= GD_FLG_DEVINIT;
897
898#if 0
899
900 if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
901 return 0;
902#endif
903 print_pre_console_buffer(flushpoint);
904 return 0;
905}
906
907#else
908
909
910int console_init_r(void)
911{
912 struct stdio_dev *inputdev = NULL, *outputdev = NULL;
913 int i;
914 struct list_head *list = stdio_get_list();
915 struct list_head *pos;
916 struct stdio_dev *dev;
917 int flushpoint;
918
919
920 if (console_update_silent())
921 flushpoint = PRE_CONSOLE_FLUSHPOINT1_SERIAL;
922 else
923 flushpoint = PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL;
924
925#ifdef CONFIG_SPLASH_SCREEN
926
927
928
929
930
931
932 if (env_get("splashimage") != NULL) {
933 if (!(gd->flags & GD_FLG_SILENT))
934 outputdev = search_device (DEV_FLAGS_OUTPUT, "serial");
935 }
936#endif
937
938
939 list_for_each(pos, list) {
940 dev = list_entry(pos, struct stdio_dev, list);
941
942 if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
943 inputdev = dev;
944 }
945 if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
946 outputdev = dev;
947 }
948 if(inputdev && outputdev)
949 break;
950 }
951
952
953 if (outputdev != NULL) {
954 console_setfile(stdout, outputdev);
955 console_setfile(stderr, outputdev);
956#if CONFIG_IS_ENABLED(CONSOLE_MUX)
957 console_devices[stdout][0] = outputdev;
958 console_devices[stderr][0] = outputdev;
959#endif
960 }
961
962
963 if (inputdev != NULL) {
964 console_setfile(stdin, inputdev);
965#if CONFIG_IS_ENABLED(CONSOLE_MUX)
966 console_devices[stdin][0] = inputdev;
967#endif
968 }
969
970#ifndef CONFIG_SYS_CONSOLE_INFO_QUIET
971 stdio_print_current_devices();
972#endif
973
974
975 for (i = 0; i < MAX_FILES; i++) {
976 env_set(stdio_names[i], stdio_devices[i]->name);
977 }
978
979 gd->flags |= GD_FLG_DEVINIT;
980
981#if 0
982
983 if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
984 return 0;
985#endif
986 print_pre_console_buffer(flushpoint);
987 return 0;
988}
989
990#endif
991