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