blob: 5b113da9d575b371a0bcee17d3478849972007fe [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
wdenk47d1a6e2002-11-03 00:01:44 +00002/*
3 * (C) Copyright 2000
4 * Paolo Scaffardi, AIRVENT SAM s.p.a - RIMINI(ITALY), arsenio@tin.it
wdenk47d1a6e2002-11-03 00:01:44 +00005 */
6
7#include <common.h>
Simon Glass24b852a2015-11-08 23:47:45 -07008#include <console.h>
Simon Glassd6ea5302015-06-23 15:38:33 -06009#include <debug_uart.h>
Simon Glass7b3c4c32017-07-27 09:31:04 -060010#include <dm.h>
Simon Glass9fb625c2019-08-01 09:46:51 -060011#include <env.h>
wdenk47d1a6e2002-11-03 00:01:44 +000012#include <stdarg.h>
Jeroen Hofstee482f4692014-10-08 22:57:48 +020013#include <iomux.h>
wdenk47d1a6e2002-11-03 00:01:44 +000014#include <malloc.h>
Simon Glass4e6bafa2017-06-15 21:37:52 -060015#include <mapmem.h>
Simon Glass91b136c2013-11-10 10:27:01 -070016#include <os.h>
Joe Hershberger849d5d92012-12-11 22:16:29 -060017#include <serial.h>
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +020018#include <stdio_dev.h>
wdenk27b207f2003-07-24 23:38:38 +000019#include <exports.h>
Simon Glassf3998fd2019-08-02 09:44:25 -060020#include <env_internal.h>
Andreas J. Reichel64407462016-07-13 12:56:51 +020021#include <watchdog.h>
Simon Glassc05ed002020-05-10 11:40:11 -060022#include <linux/delay.h>
wdenk47d1a6e2002-11-03 00:01:44 +000023
Wolfgang Denkd87080b2006-03-31 18:32:53 +020024DECLARE_GLOBAL_DATA_PTR;
25
Joe Hershberger849d5d92012-12-11 22:16:29 -060026static int on_console(const char *name, const char *value, enum env_op op,
27 int flags)
28{
29 int console = -1;
30
31 /* Check for console redirection */
32 if (strcmp(name, "stdin") == 0)
33 console = stdin;
34 else if (strcmp(name, "stdout") == 0)
35 console = stdout;
36 else if (strcmp(name, "stderr") == 0)
37 console = stderr;
38
39 /* if not actually setting a console variable, we don't care */
40 if (console == -1 || (gd->flags & GD_FLG_DEVINIT) == 0)
41 return 0;
42
43 switch (op) {
44 case env_op_create:
45 case env_op_overwrite:
46
Patrick Delaunayc04f8562020-12-18 12:46:43 +010047 if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
48 if (iomux_doenv(console, value))
49 return 1;
50 } else {
51 /* Try assigning specified device */
52 if (console_assign(console, value) < 0)
53 return 1;
54 }
55
Joe Hershberger849d5d92012-12-11 22:16:29 -060056 return 0;
57
58 case env_op_delete:
59 if ((flags & H_FORCE) == 0)
60 printf("Can't delete \"%s\"\n", name);
61 return 1;
62
63 default:
64 return 0;
65 }
66}
67U_BOOT_ENV_CALLBACK(console, on_console);
68
Joe Hershbergere080d542012-12-11 22:16:30 -060069#ifdef CONFIG_SILENT_CONSOLE
70static int on_silent(const char *name, const char *value, enum env_op op,
71 int flags)
72{
Patrick Delaunayc04f8562020-12-18 12:46:43 +010073 if (!CONFIG_IS_ENABLED(SILENT_CONSOLE_UPDATE_ON_SET))
74 if (flags & H_INTERACTIVE)
75 return 0;
76
77 if (!CONFIG_IS_ENABLED(SILENT_CONSOLE_UPDATE_ON_RELOC))
78 if ((flags & H_INTERACTIVE) == 0)
79 return 0;
Joe Hershbergere080d542012-12-11 22:16:30 -060080
81 if (value != NULL)
82 gd->flags |= GD_FLG_SILENT;
83 else
84 gd->flags &= ~GD_FLG_SILENT;
85
86 return 0;
87}
88U_BOOT_ENV_CALLBACK(silent, on_silent);
89#endif
90
Patrick Delaunay1e993712020-12-18 12:46:45 +010091#ifdef CONFIG_CONSOLE_RECORD
92/* helper function: access to gd->console_out and gd->console_in */
93static void console_record_putc(const char c)
94{
95 if (!(gd->flags & GD_FLG_RECORD))
96 return;
97 if (gd->console_out.start)
98 membuff_putbyte((struct membuff *)&gd->console_out, c);
99}
100
101static void console_record_puts(const char *s)
102{
103 if (!(gd->flags & GD_FLG_RECORD))
104 return;
105 if (gd->console_out.start)
106 membuff_put((struct membuff *)&gd->console_out, s, strlen(s));
107}
108
109static int console_record_getc(void)
110{
111 if (!(gd->flags & GD_FLG_RECORD))
112 return -1;
113 if (!gd->console_in.start)
114 return -1;
115
116 return membuff_getbyte((struct membuff *)&gd->console_in);
117}
118
119static int console_record_tstc(void)
120{
121 if (!(gd->flags & GD_FLG_RECORD))
122 return 0;
123 if (gd->console_in.start) {
124 if (membuff_peekbyte((struct membuff *)&gd->console_in) != -1)
125 return 1;
126 }
127 return 0;
128}
129#else
130static void console_record_putc(char c)
131{
132}
133
134static void console_record_puts(const char *s)
135{
136}
137
138static int console_record_getc(void)
139{
140 return -1;
141}
142
143static int console_record_tstc(void)
144{
145 return 0;
146}
147#endif
148
Simon Glassb0265422017-01-16 07:03:26 -0700149#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
wdenk47d1a6e2002-11-03 00:01:44 +0000150/*
151 * if overwrite_console returns 1, the stdin, stderr and stdout
152 * are switched to the serial port, else the settings in the
153 * environment are used
154 */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200155#ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100156extern int overwrite_console(void);
157#define OVERWRITE_CONSOLE overwrite_console()
wdenk47d1a6e2002-11-03 00:01:44 +0000158#else
wdenk83e40ba2005-03-31 18:42:15 +0000159#define OVERWRITE_CONSOLE 0
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200160#endif /* CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE */
wdenk47d1a6e2002-11-03 00:01:44 +0000161
Simon Glassb0265422017-01-16 07:03:26 -0700162#endif /* CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */
wdenk47d1a6e2002-11-03 00:01:44 +0000163
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200164static int console_setfile(int file, struct stdio_dev * dev)
wdenk47d1a6e2002-11-03 00:01:44 +0000165{
166 int error = 0;
167
168 if (dev == NULL)
169 return -1;
170
171 switch (file) {
172 case stdin:
173 case stdout:
174 case stderr:
Andy Shevchenko41f668b2020-12-21 14:30:00 +0200175 error = console_start(file, dev);
176 if (error)
177 break;
wdenk47d1a6e2002-11-03 00:01:44 +0000178
179 /* Assign the new device (leaving the existing one started) */
180 stdio_devices[file] = dev;
181
182 /*
183 * Update monitor functions
184 * (to use the console stuff by other applications)
185 */
186 switch (file) {
187 case stdin:
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200188 gd->jt->getc = getchar;
Martin Dorwig49cad542015-01-26 15:22:54 -0700189 gd->jt->tstc = tstc;
wdenk47d1a6e2002-11-03 00:01:44 +0000190 break;
191 case stdout:
Martin Dorwig49cad542015-01-26 15:22:54 -0700192 gd->jt->putc = putc;
193 gd->jt->puts = puts;
194 gd->jt->printf = printf;
wdenk47d1a6e2002-11-03 00:01:44 +0000195 break;
196 }
197 break;
198
199 default: /* Invalid file ID */
200 error = -1;
201 }
202 return error;
203}
204
Simon Glass42f9f912017-07-27 09:31:03 -0600205/**
206 * console_dev_is_serial() - Check if a stdio device is a serial device
207 *
208 * @sdev: Device to check
Simon Glass7b3c4c32017-07-27 09:31:04 -0600209 * @return true if this device is in the serial uclass (or for pre-driver-model,
210 * whether it is called "serial".
Simon Glass42f9f912017-07-27 09:31:03 -0600211 */
212static bool console_dev_is_serial(struct stdio_dev *sdev)
213{
214 bool is_serial;
215
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100216 if (IS_ENABLED(CONFIG_DM_SERIAL) && (sdev->flags & DEV_FLAGS_DM)) {
Simon Glass7b3c4c32017-07-27 09:31:04 -0600217 struct udevice *dev = sdev->priv;
218
219 is_serial = device_get_uclass_id(dev) == UCLASS_SERIAL;
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100220 } else {
221 is_serial = !strcmp(sdev->name, "serial");
222 }
Simon Glass42f9f912017-07-27 09:31:03 -0600223
224 return is_serial;
225}
226
Simon Glassb0265422017-01-16 07:03:26 -0700227#if CONFIG_IS_ENABLED(CONSOLE_MUX)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100228/** Console I/O multiplexing *******************************************/
229
Patrick Delaunaya17b38c2020-12-18 12:46:46 +0100230/* tstcdev: save the last stdio device with pending characters, with tstc != 0 */
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200231static struct stdio_dev *tstcdev;
232struct stdio_dev **console_devices[MAX_FILES];
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100233int cd_count[MAX_FILES];
234
Patrick Delaunay45375ad2020-12-18 12:46:44 +0100235static void __maybe_unused console_devices_set(int file, struct stdio_dev *dev)
236{
237 console_devices[file][0] = dev;
238}
239
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100240/*
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200241 * This depends on tstc() always being called before getchar().
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100242 * This is guaranteed to be true because this routine is called
243 * only from fgetc() which assures it.
244 * No attempt is made to demultiplex multiple input sources.
245 */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100246static int console_getc(int file)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100247{
248 unsigned char ret;
249
250 /* This is never called with testcdev == NULL */
Simon Glass709ea542014-07-23 06:54:59 -0600251 ret = tstcdev->getc(tstcdev);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100252 tstcdev = NULL;
253 return ret;
254}
255
Patrick Delaunaya17b38c2020-12-18 12:46:46 +0100256/* Upper layer may have already called tstc(): check the saved result */
257static bool console_has_tstc(void)
258{
259 return !!tstcdev;
260}
261
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100262static int console_tstc(int file)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100263{
264 int i, ret;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200265 struct stdio_dev *dev;
Joe Hershbergerb2f58d82018-07-02 20:06:48 -0500266 int prev;
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100267
Joe Hershbergerb2f58d82018-07-02 20:06:48 -0500268 prev = disable_ctrlc(1);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100269 for (i = 0; i < cd_count[file]; i++) {
270 dev = console_devices[file][i];
271 if (dev->tstc != NULL) {
Simon Glass709ea542014-07-23 06:54:59 -0600272 ret = dev->tstc(dev);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100273 if (ret > 0) {
274 tstcdev = dev;
Joe Hershbergerb2f58d82018-07-02 20:06:48 -0500275 disable_ctrlc(prev);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100276 return ret;
277 }
278 }
279 }
Joe Hershbergerb2f58d82018-07-02 20:06:48 -0500280 disable_ctrlc(prev);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100281
282 return 0;
283}
284
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100285static void console_putc(int file, const char c)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100286{
287 int i;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200288 struct stdio_dev *dev;
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100289
290 for (i = 0; i < cd_count[file]; i++) {
291 dev = console_devices[file][i];
292 if (dev->putc != NULL)
Simon Glass709ea542014-07-23 06:54:59 -0600293 dev->putc(dev, c);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100294 }
295}
296
Simon Glass493a4c82020-07-02 21:12:13 -0600297/**
298 * console_puts_select() - Output a string to all console devices
299 *
300 * @file: File number to output to (e,g, stdout, see stdio.h)
301 * @serial_only: true to output only to serial, false to output to everything
302 * else
303 * @s: String to output
304 */
305static void console_puts_select(int file, bool serial_only, const char *s)
Siarhei Siamashka27669662015-01-08 09:02:31 +0200306{
307 int i;
308 struct stdio_dev *dev;
309
310 for (i = 0; i < cd_count[file]; i++) {
Simon Glass493a4c82020-07-02 21:12:13 -0600311 bool is_serial;
312
Siarhei Siamashka27669662015-01-08 09:02:31 +0200313 dev = console_devices[file][i];
Simon Glass493a4c82020-07-02 21:12:13 -0600314 is_serial = console_dev_is_serial(dev);
315 if (dev->puts && serial_only == is_serial)
Hans de Goedea8552c72015-05-05 13:13:36 +0200316 dev->puts(dev, s);
Siarhei Siamashka27669662015-01-08 09:02:31 +0200317 }
318}
Siarhei Siamashka27669662015-01-08 09:02:31 +0200319
Simon Glass493a4c82020-07-02 21:12:13 -0600320void console_puts_select_stderr(bool serial_only, const char *s)
321{
322 console_puts_select(stderr, serial_only, s);
323}
324
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100325static void console_puts(int file, const char *s)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100326{
327 int i;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200328 struct stdio_dev *dev;
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100329
330 for (i = 0; i < cd_count[file]; i++) {
331 dev = console_devices[file][i];
332 if (dev->puts != NULL)
Simon Glass709ea542014-07-23 06:54:59 -0600333 dev->puts(dev, s);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100334 }
335}
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100336
Tom Rini5e63c962019-10-30 09:18:43 -0400337#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200338static inline void console_doenv(int file, struct stdio_dev *dev)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100339{
340 iomux_doenv(file, dev->name);
341}
Tom Rini5e63c962019-10-30 09:18:43 -0400342#endif
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100343#else
Patrick Delaunay45375ad2020-12-18 12:46:44 +0100344
345static void __maybe_unused console_devices_set(int file, struct stdio_dev *dev)
346{
347}
348
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100349static inline int console_getc(int file)
350{
Simon Glass709ea542014-07-23 06:54:59 -0600351 return stdio_devices[file]->getc(stdio_devices[file]);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100352}
353
Patrick Delaunaya17b38c2020-12-18 12:46:46 +0100354static bool console_has_tstc(void)
355{
356 return false;
357}
358
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100359static inline int console_tstc(int file)
360{
Simon Glass709ea542014-07-23 06:54:59 -0600361 return stdio_devices[file]->tstc(stdio_devices[file]);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100362}
363
364static inline void console_putc(int file, const char c)
365{
Simon Glass709ea542014-07-23 06:54:59 -0600366 stdio_devices[file]->putc(stdio_devices[file], c);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100367}
368
Simon Glass493a4c82020-07-02 21:12:13 -0600369void console_puts_select(int file, bool serial_only, const char *s)
Siarhei Siamashka27669662015-01-08 09:02:31 +0200370{
Simon Glass493a4c82020-07-02 21:12:13 -0600371 if (serial_only == console_dev_is_serial(stdio_devices[file]))
Hans de Goedea8552c72015-05-05 13:13:36 +0200372 stdio_devices[file]->puts(stdio_devices[file], s);
Siarhei Siamashka27669662015-01-08 09:02:31 +0200373}
Siarhei Siamashka27669662015-01-08 09:02:31 +0200374
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100375static inline void console_puts(int file, const char *s)
376{
Simon Glass709ea542014-07-23 06:54:59 -0600377 stdio_devices[file]->puts(stdio_devices[file], s);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100378}
379
Tom Rini5e63c962019-10-30 09:18:43 -0400380#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200381static inline void console_doenv(int file, struct stdio_dev *dev)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100382{
383 console_setfile(file, dev);
384}
Tom Rini5e63c962019-10-30 09:18:43 -0400385#endif
Simon Glassb0265422017-01-16 07:03:26 -0700386#endif /* CONIFIG_IS_ENABLED(CONSOLE_MUX) */
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100387
Andy Shevchenko41f668b2020-12-21 14:30:00 +0200388int console_start(int file, struct stdio_dev *sdev)
389{
390 int error;
391
392 /* Start new device */
393 if (sdev->start) {
394 error = sdev->start(sdev);
395 /* If it's not started don't use it */
396 if (error < 0)
397 return error;
398 }
399 return 0;
400}
401
402void console_stop(int file, struct stdio_dev *sdev)
403{
404 if (sdev->stop)
405 sdev->stop(sdev);
406}
407
wdenk47d1a6e2002-11-03 00:01:44 +0000408/** U-Boot INITIAL CONSOLE-NOT COMPATIBLE FUNCTIONS *************************/
409
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200410int serial_printf(const char *fmt, ...)
wdenk47d1a6e2002-11-03 00:01:44 +0000411{
412 va_list args;
413 uint i;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200414 char printbuffer[CONFIG_SYS_PBSIZE];
wdenk47d1a6e2002-11-03 00:01:44 +0000415
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100416 va_start(args, fmt);
wdenk47d1a6e2002-11-03 00:01:44 +0000417
418 /* For this to work, printbuffer must be larger than
419 * anything we ever want to print.
420 */
Sonny Rao068af6f2011-10-10 09:22:31 +0000421 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100422 va_end(args);
wdenk47d1a6e2002-11-03 00:01:44 +0000423
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100424 serial_puts(printbuffer);
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200425 return i;
wdenk47d1a6e2002-11-03 00:01:44 +0000426}
427
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100428int fgetc(int file)
wdenk47d1a6e2002-11-03 00:01:44 +0000429{
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100430 if (file < MAX_FILES) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100431 /*
432 * Effectively poll for input wherever it may be available.
433 */
434 for (;;) {
Andreas J. Reichel64407462016-07-13 12:56:51 +0200435 WATCHDOG_RESET();
Patrick Delaunaya17b38c2020-12-18 12:46:46 +0100436 if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
437 /*
438 * Upper layer may have already called tstc() so
439 * check for that first.
440 */
441 if (console_has_tstc())
442 return console_getc(file);
443 console_tstc(file);
444 } else {
445 if (console_tstc(file))
446 return console_getc(file);
447 }
448
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100449 /*
450 * If the watchdog must be rate-limited then it should
451 * already be handled in board-specific code.
452 */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100453 if (IS_ENABLED(CONFIG_WATCHDOG))
454 udelay(1);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100455 }
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100456 }
wdenk47d1a6e2002-11-03 00:01:44 +0000457
458 return -1;
459}
460
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100461int ftstc(int file)
wdenk47d1a6e2002-11-03 00:01:44 +0000462{
463 if (file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100464 return console_tstc(file);
wdenk47d1a6e2002-11-03 00:01:44 +0000465
466 return -1;
467}
468
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100469void fputc(int file, const char c)
wdenk47d1a6e2002-11-03 00:01:44 +0000470{
471 if (file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100472 console_putc(file, c);
wdenk47d1a6e2002-11-03 00:01:44 +0000473}
474
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100475void fputs(int file, const char *s)
wdenk47d1a6e2002-11-03 00:01:44 +0000476{
477 if (file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100478 console_puts(file, s);
wdenk47d1a6e2002-11-03 00:01:44 +0000479}
480
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200481int fprintf(int file, const char *fmt, ...)
wdenk47d1a6e2002-11-03 00:01:44 +0000482{
483 va_list args;
484 uint i;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200485 char printbuffer[CONFIG_SYS_PBSIZE];
wdenk47d1a6e2002-11-03 00:01:44 +0000486
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100487 va_start(args, fmt);
wdenk47d1a6e2002-11-03 00:01:44 +0000488
489 /* For this to work, printbuffer must be larger than
490 * anything we ever want to print.
491 */
Sonny Rao068af6f2011-10-10 09:22:31 +0000492 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100493 va_end(args);
wdenk47d1a6e2002-11-03 00:01:44 +0000494
495 /* Send to desired file */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100496 fputs(file, printbuffer);
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200497 return i;
wdenk47d1a6e2002-11-03 00:01:44 +0000498}
499
500/** U-Boot INITIAL CONSOLE-COMPATIBLE FUNCTION *****************************/
501
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200502int getchar(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000503{
Patrick Delaunay1e993712020-12-18 12:46:45 +0100504 int ch;
505
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100506 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100507 return 0;
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100508
Graeme Russe3e454c2011-08-29 02:14:05 +0000509 if (!gd->have_console)
510 return 0;
511
Patrick Delaunay1e993712020-12-18 12:46:45 +0100512 ch = console_record_getc();
513 if (ch != -1)
514 return ch;
Simon Glass9854a872015-11-08 23:47:48 -0700515
wdenk47d1a6e2002-11-03 00:01:44 +0000516 if (gd->flags & GD_FLG_DEVINIT) {
517 /* Get from the standard input */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100518 return fgetc(stdin);
wdenk47d1a6e2002-11-03 00:01:44 +0000519 }
520
521 /* Send directly to the handler */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100522 return serial_getc();
wdenk47d1a6e2002-11-03 00:01:44 +0000523}
524
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100525int tstc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000526{
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100527 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100528 return 0;
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100529
Graeme Russe3e454c2011-08-29 02:14:05 +0000530 if (!gd->have_console)
531 return 0;
Patrick Delaunay1e993712020-12-18 12:46:45 +0100532
533 if (console_record_tstc())
534 return 1;
535
wdenk47d1a6e2002-11-03 00:01:44 +0000536 if (gd->flags & GD_FLG_DEVINIT) {
537 /* Test the standard input */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100538 return ftstc(stdin);
wdenk47d1a6e2002-11-03 00:01:44 +0000539 }
540
541 /* Send directly to the handler */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100542 return serial_tstc();
wdenk47d1a6e2002-11-03 00:01:44 +0000543}
544
Siarhei Siamashka27669662015-01-08 09:02:31 +0200545#define PRE_CONSOLE_FLUSHPOINT1_SERIAL 0
546#define PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL 1
547
Simon Glass8f925582016-10-17 20:12:36 -0600548#if CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
Graeme Russ9558b482011-09-01 00:48:27 +0000549#define CIRC_BUF_IDX(idx) ((idx) % (unsigned long)CONFIG_PRE_CON_BUF_SZ)
550
551static void pre_console_putc(const char c)
552{
Simon Glass4e6bafa2017-06-15 21:37:52 -0600553 char *buffer;
554
555 buffer = map_sysmem(CONFIG_PRE_CON_BUF_ADDR, CONFIG_PRE_CON_BUF_SZ);
Graeme Russ9558b482011-09-01 00:48:27 +0000556
557 buffer[CIRC_BUF_IDX(gd->precon_buf_idx++)] = c;
Simon Glass4e6bafa2017-06-15 21:37:52 -0600558
559 unmap_sysmem(buffer);
Graeme Russ9558b482011-09-01 00:48:27 +0000560}
561
Soeren Mochbe135cc2017-11-04 16:14:09 +0100562static void pre_console_puts(const char *s)
563{
564 while (*s)
565 pre_console_putc(*s++);
566}
567
Siarhei Siamashka27669662015-01-08 09:02:31 +0200568static void print_pre_console_buffer(int flushpoint)
Graeme Russ9558b482011-09-01 00:48:27 +0000569{
Hans de Goedea8552c72015-05-05 13:13:36 +0200570 unsigned long in = 0, out = 0;
Hans de Goedea8552c72015-05-05 13:13:36 +0200571 char buf_out[CONFIG_PRE_CON_BUF_SZ + 1];
Simon Glass4e6bafa2017-06-15 21:37:52 -0600572 char *buf_in;
Graeme Russ9558b482011-09-01 00:48:27 +0000573
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100574 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT))
Patrick Delaunay13551b92019-08-02 14:58:10 +0200575 return;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200576
Simon Glass4e6bafa2017-06-15 21:37:52 -0600577 buf_in = map_sysmem(CONFIG_PRE_CON_BUF_ADDR, CONFIG_PRE_CON_BUF_SZ);
Graeme Russ9558b482011-09-01 00:48:27 +0000578 if (gd->precon_buf_idx > CONFIG_PRE_CON_BUF_SZ)
Hans de Goedea8552c72015-05-05 13:13:36 +0200579 in = gd->precon_buf_idx - CONFIG_PRE_CON_BUF_SZ;
Graeme Russ9558b482011-09-01 00:48:27 +0000580
Hans de Goedea8552c72015-05-05 13:13:36 +0200581 while (in < gd->precon_buf_idx)
582 buf_out[out++] = buf_in[CIRC_BUF_IDX(in++)];
Simon Glass4e6bafa2017-06-15 21:37:52 -0600583 unmap_sysmem(buf_in);
Hans de Goedea8552c72015-05-05 13:13:36 +0200584
585 buf_out[out] = 0;
586
587 switch (flushpoint) {
588 case PRE_CONSOLE_FLUSHPOINT1_SERIAL:
589 puts(buf_out);
590 break;
591 case PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL:
Simon Glass493a4c82020-07-02 21:12:13 -0600592 console_puts_select(stdout, false, buf_out);
Hans de Goedea8552c72015-05-05 13:13:36 +0200593 break;
594 }
Graeme Russ9558b482011-09-01 00:48:27 +0000595}
596#else
597static inline void pre_console_putc(const char c) {}
Soeren Mochbe135cc2017-11-04 16:14:09 +0100598static inline void pre_console_puts(const char *s) {}
Siarhei Siamashka27669662015-01-08 09:02:31 +0200599static inline void print_pre_console_buffer(int flushpoint) {}
Graeme Russ9558b482011-09-01 00:48:27 +0000600#endif
601
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100602void putc(const char c)
wdenk47d1a6e2002-11-03 00:01:44 +0000603{
Patrick Delaunay93cdb522020-11-27 11:20:56 +0100604 if (!gd)
605 return;
Patrick Delaunay1e993712020-12-18 12:46:45 +0100606
607 console_record_putc(c);
608
Simon Glass64e9b4f2017-12-04 13:48:19 -0700609 /* sandbox can send characters to stdout before it has a console */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100610 if (IS_ENABLED(CONFIG_SANDBOX) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glass64e9b4f2017-12-04 13:48:19 -0700611 os_putc(c);
612 return;
613 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100614
Simon Glassd6ea5302015-06-23 15:38:33 -0600615 /* if we don't have a console yet, use the debug UART */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100616 if (IS_ENABLED(CONFIG_DEBUG_UART) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glassd6ea5302015-06-23 15:38:33 -0600617 printch(c);
618 return;
619 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100620
621 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT)) {
Patrick Delaunay13551b92019-08-02 14:58:10 +0200622 if (!(gd->flags & GD_FLG_DEVINIT))
623 pre_console_putc(c);
wdenkf6e20fc2004-02-08 19:38:38 +0000624 return;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200625 }
wdenka6cccae2004-02-06 21:48:22 +0000626
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100627 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100628 return;
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100629
Graeme Russe3e454c2011-08-29 02:14:05 +0000630 if (!gd->have_console)
Graeme Russ9558b482011-09-01 00:48:27 +0000631 return pre_console_putc(c);
Graeme Russe3e454c2011-08-29 02:14:05 +0000632
wdenk47d1a6e2002-11-03 00:01:44 +0000633 if (gd->flags & GD_FLG_DEVINIT) {
634 /* Send to the standard output */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100635 fputc(stdout, c);
wdenk47d1a6e2002-11-03 00:01:44 +0000636 } else {
637 /* Send directly to the handler */
Siarhei Siamashka27669662015-01-08 09:02:31 +0200638 pre_console_putc(c);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100639 serial_putc(c);
wdenk47d1a6e2002-11-03 00:01:44 +0000640 }
641}
642
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100643void puts(const char *s)
wdenk47d1a6e2002-11-03 00:01:44 +0000644{
Patrick Delaunay93cdb522020-11-27 11:20:56 +0100645 if (!gd)
646 return;
Patrick Delaunay1e993712020-12-18 12:46:45 +0100647
648 console_record_puts(s);
649
Simon Glass36bcea62018-11-15 18:44:04 -0700650 /* sandbox can send characters to stdout before it has a console */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100651 if (IS_ENABLED(CONFIG_SANDBOX) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glass36bcea62018-11-15 18:44:04 -0700652 os_puts(s);
653 return;
654 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100655
656 if (IS_ENABLED(CONFIG_DEBUG_UART) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Soeren Mochbe135cc2017-11-04 16:14:09 +0100657 while (*s) {
658 int ch = *s++;
659
660 printch(ch);
661 }
662 return;
663 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100664
665 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT)) {
Patrick Delaunay13551b92019-08-02 14:58:10 +0200666 if (!(gd->flags & GD_FLG_DEVINIT))
667 pre_console_puts(s);
Soeren Mochbe135cc2017-11-04 16:14:09 +0100668 return;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200669 }
Soeren Mochbe135cc2017-11-04 16:14:09 +0100670
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100671 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Soeren Mochbe135cc2017-11-04 16:14:09 +0100672 return;
Soeren Mochbe135cc2017-11-04 16:14:09 +0100673
674 if (!gd->have_console)
675 return pre_console_puts(s);
676
677 if (gd->flags & GD_FLG_DEVINIT) {
678 /* Send to the standard output */
679 fputs(stdout, s);
680 } else {
681 /* Send directly to the handler */
682 pre_console_puts(s);
683 serial_puts(s);
684 }
wdenk47d1a6e2002-11-03 00:01:44 +0000685}
686
Simon Glass9854a872015-11-08 23:47:48 -0700687#ifdef CONFIG_CONSOLE_RECORD
688int console_record_init(void)
689{
690 int ret;
691
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100692 ret = membuff_new((struct membuff *)&gd->console_out,
693 CONFIG_CONSOLE_RECORD_OUT_SIZE);
Simon Glass9854a872015-11-08 23:47:48 -0700694 if (ret)
695 return ret;
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100696 ret = membuff_new((struct membuff *)&gd->console_in,
697 CONFIG_CONSOLE_RECORD_IN_SIZE);
Simon Glass9854a872015-11-08 23:47:48 -0700698
699 return ret;
700}
701
702void console_record_reset(void)
703{
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100704 membuff_purge((struct membuff *)&gd->console_out);
705 membuff_purge((struct membuff *)&gd->console_in);
Simon Glass9854a872015-11-08 23:47:48 -0700706}
707
Simon Glassbd347152020-07-28 19:41:11 -0600708int console_record_reset_enable(void)
Simon Glass9854a872015-11-08 23:47:48 -0700709{
710 console_record_reset();
711 gd->flags |= GD_FLG_RECORD;
Simon Glassbd347152020-07-28 19:41:11 -0600712
713 return 0;
Simon Glass9854a872015-11-08 23:47:48 -0700714}
Simon Glassb6123122020-01-27 08:49:54 -0700715
716int console_record_readline(char *str, int maxlen)
717{
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100718 return membuff_readline((struct membuff *)&gd->console_out, str,
719 maxlen, ' ');
Simon Glassb6123122020-01-27 08:49:54 -0700720}
721
722int console_record_avail(void)
723{
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100724 return membuff_avail((struct membuff *)&gd->console_out);
Simon Glassb6123122020-01-27 08:49:54 -0700725}
726
Simon Glass9854a872015-11-08 23:47:48 -0700727#endif
728
wdenk47d1a6e2002-11-03 00:01:44 +0000729/* test if ctrl-c was pressed */
730static int ctrlc_disabled = 0; /* see disable_ctrl() */
731static int ctrlc_was_pressed = 0;
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100732int ctrlc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000733{
wdenk47d1a6e2002-11-03 00:01:44 +0000734 if (!ctrlc_disabled && gd->have_console) {
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100735 if (tstc()) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200736 switch (getchar()) {
wdenk47d1a6e2002-11-03 00:01:44 +0000737 case 0x03: /* ^C - Control C */
738 ctrlc_was_pressed = 1;
739 return 1;
740 default:
741 break;
742 }
743 }
744 }
Simon Glass8969ea32014-09-14 12:40:15 -0600745
wdenk47d1a6e2002-11-03 00:01:44 +0000746 return 0;
747}
Pierre Auberta5dffa42014-04-24 10:30:07 +0200748/* Reads user's confirmation.
749 Returns 1 if user's input is "y", "Y", "yes" or "YES"
750*/
751int confirm_yesno(void)
752{
753 int i;
754 char str_input[5];
wdenk47d1a6e2002-11-03 00:01:44 +0000755
Pierre Auberta5dffa42014-04-24 10:30:07 +0200756 /* Flush input */
757 while (tstc())
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200758 getchar();
Pierre Auberta5dffa42014-04-24 10:30:07 +0200759 i = 0;
760 while (i < sizeof(str_input)) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200761 str_input[i] = getchar();
Pierre Auberta5dffa42014-04-24 10:30:07 +0200762 putc(str_input[i]);
763 if (str_input[i] == '\r')
764 break;
765 i++;
766 }
767 putc('\n');
768 if (strncmp(str_input, "y\r", 2) == 0 ||
769 strncmp(str_input, "Y\r", 2) == 0 ||
770 strncmp(str_input, "yes\r", 4) == 0 ||
771 strncmp(str_input, "YES\r", 4) == 0)
772 return 1;
773 return 0;
774}
wdenk47d1a6e2002-11-03 00:01:44 +0000775/* pass 1 to disable ctrlc() checking, 0 to enable.
776 * returns previous state
777 */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100778int disable_ctrlc(int disable)
wdenk47d1a6e2002-11-03 00:01:44 +0000779{
780 int prev = ctrlc_disabled; /* save previous state */
781
782 ctrlc_disabled = disable;
783 return prev;
784}
785
786int had_ctrlc (void)
787{
788 return ctrlc_was_pressed;
789}
790
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100791void clear_ctrlc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000792{
793 ctrlc_was_pressed = 0;
794}
795
wdenk47d1a6e2002-11-03 00:01:44 +0000796/** U-Boot INIT FUNCTIONS *************************************************/
797
Mike Frysingerd7be3052010-10-20 07:18:03 -0400798struct stdio_dev *search_device(int flags, const char *name)
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200799{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200800 struct stdio_dev *dev;
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200801
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200802 dev = stdio_get_by_name(name);
Simon Glassa2931b32016-02-06 14:31:37 -0700803#ifdef CONFIG_VIDCONSOLE_AS_LCD
Patrick Delaunay27b5b9e2020-07-01 14:56:10 +0200804 if (!dev && !strcmp(name, CONFIG_VIDCONSOLE_AS_NAME))
Simon Glassa2931b32016-02-06 14:31:37 -0700805 dev = stdio_get_by_name("vidconsole");
806#endif
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200807
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100808 if (dev && (dev->flags & flags))
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200809 return dev;
810
811 return NULL;
812}
813
Mike Frysingerd7be3052010-10-20 07:18:03 -0400814int console_assign(int file, const char *devname)
wdenk47d1a6e2002-11-03 00:01:44 +0000815{
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200816 int flag;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200817 struct stdio_dev *dev;
wdenk47d1a6e2002-11-03 00:01:44 +0000818
819 /* Check for valid file */
820 switch (file) {
821 case stdin:
822 flag = DEV_FLAGS_INPUT;
823 break;
824 case stdout:
825 case stderr:
826 flag = DEV_FLAGS_OUTPUT;
827 break;
828 default:
829 return -1;
830 }
831
832 /* Check for valid device name */
833
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200834 dev = search_device(flag, devname);
wdenk47d1a6e2002-11-03 00:01:44 +0000835
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100836 if (dev)
837 return console_setfile(file, dev);
wdenk47d1a6e2002-11-03 00:01:44 +0000838
839 return -1;
840}
841
Patrick Delaunay13551b92019-08-02 14:58:10 +0200842/* return true if the 'silent' flag is removed */
843static bool console_update_silent(void)
Chris Packham43e0a3d2016-09-23 15:59:43 +1200844{
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100845 unsigned long flags = gd->flags;
846
847 if (!IS_ENABLED(CONFIG_SILENT_CONSOLE))
848 return false;
849
Patrick Delaunay13551b92019-08-02 14:58:10 +0200850 if (env_get("silent")) {
Chris Packham43e0a3d2016-09-23 15:59:43 +1200851 gd->flags |= GD_FLG_SILENT;
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100852 return false;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200853 }
Patrick Delaunay13551b92019-08-02 14:58:10 +0200854
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100855 gd->flags &= ~GD_FLG_SILENT;
856
857 return !!(flags & GD_FLG_SILENT);
Chris Packham43e0a3d2016-09-23 15:59:43 +1200858}
859
Simon Glassb0895382017-06-15 21:37:50 -0600860int console_announce_r(void)
861{
862#if !CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
863 char buf[DISPLAY_OPTIONS_BANNER_LENGTH];
864
865 display_options_get_banner(false, buf, sizeof(buf));
866
Simon Glass493a4c82020-07-02 21:12:13 -0600867 console_puts_select(stdout, false, buf);
Simon Glassb0895382017-06-15 21:37:50 -0600868#endif
869
870 return 0;
871}
872
wdenk47d1a6e2002-11-03 00:01:44 +0000873/* Called before relocation - use serial functions */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100874int console_init_f(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000875{
wdenk47d1a6e2002-11-03 00:01:44 +0000876 gd->have_console = 1;
wdenkf72da342003-10-10 10:05:42 +0000877
Chris Packham43e0a3d2016-09-23 15:59:43 +1200878 console_update_silent();
wdenkf72da342003-10-10 10:05:42 +0000879
Siarhei Siamashka27669662015-01-08 09:02:31 +0200880 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT1_SERIAL);
Graeme Russ9558b482011-09-01 00:48:27 +0000881
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100882 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +0000883}
884
Jean-Christophe PLAGNIOL-VILLARD7e3be7c2009-05-16 12:14:55 +0200885void stdio_print_current_devices(void)
886{
Jean-Christophe PLAGNIOL-VILLARD7e3be7c2009-05-16 12:14:55 +0200887 /* Print information */
888 puts("In: ");
889 if (stdio_devices[stdin] == NULL) {
890 puts("No input devices available!\n");
891 } else {
892 printf ("%s\n", stdio_devices[stdin]->name);
893 }
894
895 puts("Out: ");
896 if (stdio_devices[stdout] == NULL) {
897 puts("No output devices available!\n");
898 } else {
899 printf ("%s\n", stdio_devices[stdout]->name);
900 }
901
902 puts("Err: ");
903 if (stdio_devices[stderr] == NULL) {
904 puts("No error devices available!\n");
905 } else {
906 printf ("%s\n", stdio_devices[stderr]->name);
907 }
Jean-Christophe PLAGNIOL-VILLARD7e3be7c2009-05-16 12:14:55 +0200908}
909
Simon Glassb0265422017-01-16 07:03:26 -0700910#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
wdenk47d1a6e2002-11-03 00:01:44 +0000911/* Called after the relocation - use desired console functions */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100912int console_init_r(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000913{
914 char *stdinname, *stdoutname, *stderrname;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200915 struct stdio_dev *inputdev = NULL, *outputdev = NULL, *errdev = NULL;
wdenk6e592382004-04-18 17:39:38 +0000916 int i;
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100917 int iomux_err = 0;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200918 int flushpoint;
wdenk47d1a6e2002-11-03 00:01:44 +0000919
Patrick Delaunaybf46be72019-08-02 14:58:09 +0200920 /* update silent for env loaded from flash (initr_env) */
Patrick Delaunay13551b92019-08-02 14:58:10 +0200921 if (console_update_silent())
922 flushpoint = PRE_CONSOLE_FLUSHPOINT1_SERIAL;
923 else
924 flushpoint = PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL;
Patrick Delaunaybf46be72019-08-02 14:58:09 +0200925
wdenk47d1a6e2002-11-03 00:01:44 +0000926 /* set default handlers at first */
Martin Dorwig49cad542015-01-26 15:22:54 -0700927 gd->jt->getc = serial_getc;
928 gd->jt->tstc = serial_tstc;
929 gd->jt->putc = serial_putc;
930 gd->jt->puts = serial_puts;
931 gd->jt->printf = serial_printf;
wdenk47d1a6e2002-11-03 00:01:44 +0000932
933 /* stdin stdout and stderr are in environment */
934 /* scan for it */
Simon Glass00caae62017-08-03 12:22:12 -0600935 stdinname = env_get("stdin");
936 stdoutname = env_get("stdout");
937 stderrname = env_get("stderr");
wdenk47d1a6e2002-11-03 00:01:44 +0000938
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200939 if (OVERWRITE_CONSOLE == 0) { /* if not overwritten by config switch */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100940 inputdev = search_device(DEV_FLAGS_INPUT, stdinname);
941 outputdev = search_device(DEV_FLAGS_OUTPUT, stdoutname);
942 errdev = search_device(DEV_FLAGS_OUTPUT, stderrname);
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100943 if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
944 iomux_err = iomux_doenv(stdin, stdinname);
945 iomux_err += iomux_doenv(stdout, stdoutname);
946 iomux_err += iomux_doenv(stderr, stderrname);
947 if (!iomux_err)
948 /* Successful, so skip all the code below. */
949 goto done;
950 }
wdenk47d1a6e2002-11-03 00:01:44 +0000951 }
952 /* if the devices are overwritten or not found, use default device */
953 if (inputdev == NULL) {
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100954 inputdev = search_device(DEV_FLAGS_INPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +0000955 }
956 if (outputdev == NULL) {
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100957 outputdev = search_device(DEV_FLAGS_OUTPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +0000958 }
959 if (errdev == NULL) {
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100960 errdev = search_device(DEV_FLAGS_OUTPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +0000961 }
962 /* Initializes output console first */
963 if (outputdev != NULL) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100964 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100965 console_doenv(stdout, outputdev);
wdenk47d1a6e2002-11-03 00:01:44 +0000966 }
967 if (errdev != NULL) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100968 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100969 console_doenv(stderr, errdev);
wdenk47d1a6e2002-11-03 00:01:44 +0000970 }
971 if (inputdev != NULL) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100972 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100973 console_doenv(stdin, inputdev);
wdenk47d1a6e2002-11-03 00:01:44 +0000974 }
975
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100976done:
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100977
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100978 if (!IS_ENABLED(CONFIG_SYS_CONSOLE_INFO_QUIET))
979 stdio_print_current_devices();
980
Simon Glassa2931b32016-02-06 14:31:37 -0700981#ifdef CONFIG_VIDCONSOLE_AS_LCD
Patrick Delaunay27b5b9e2020-07-01 14:56:10 +0200982 if (strstr(stdoutname, CONFIG_VIDCONSOLE_AS_NAME))
Anatolij Gustschin22b897a2020-05-23 17:11:20 +0200983 printf("Warning: Please change '%s' to 'vidconsole' in stdout/stderr environment vars\n",
Patrick Delaunay27b5b9e2020-07-01 14:56:10 +0200984 CONFIG_VIDCONSOLE_AS_NAME);
Simon Glassa2931b32016-02-06 14:31:37 -0700985#endif
wdenk47d1a6e2002-11-03 00:01:44 +0000986
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100987 if (IS_ENABLED(CONFIG_SYS_CONSOLE_ENV_OVERWRITE)) {
988 /* set the environment variables (will overwrite previous env settings) */
989 for (i = 0; i < MAX_FILES; i++)
990 env_set(stdio_names[i], stdio_devices[i]->name);
wdenk47d1a6e2002-11-03 00:01:44 +0000991 }
wdenk47d1a6e2002-11-03 00:01:44 +0000992
Joe Hershbergerc4e00572012-12-11 22:16:19 -0600993 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */
994
wdenk47d1a6e2002-11-03 00:01:44 +0000995#if 0
996 /* If nothing usable installed, use only the initial console */
997 if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100998 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +0000999#endif
Patrick Delaunay13551b92019-08-02 14:58:10 +02001000 print_pre_console_buffer(flushpoint);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001001 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +00001002}
1003
Simon Glassb0265422017-01-16 07:03:26 -07001004#else /* !CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */
wdenk47d1a6e2002-11-03 00:01:44 +00001005
1006/* Called after the relocation - use desired console functions */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001007int console_init_r(void)
wdenk47d1a6e2002-11-03 00:01:44 +00001008{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001009 struct stdio_dev *inputdev = NULL, *outputdev = NULL;
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001010 int i;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001011 struct list_head *list = stdio_get_list();
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001012 struct list_head *pos;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001013 struct stdio_dev *dev;
Patrick Delaunay13551b92019-08-02 14:58:10 +02001014 int flushpoint;
wdenk47d1a6e2002-11-03 00:01:44 +00001015
Patrick Delaunaybf46be72019-08-02 14:58:09 +02001016 /* update silent for env loaded from flash (initr_env) */
Patrick Delaunay13551b92019-08-02 14:58:10 +02001017 if (console_update_silent())
1018 flushpoint = PRE_CONSOLE_FLUSHPOINT1_SERIAL;
1019 else
1020 flushpoint = PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL;
Chris Packham43e0a3d2016-09-23 15:59:43 +12001021
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001022 /*
1023 * suppress all output if splash screen is enabled and we have
Anatolij Gustschina7490812010-03-16 15:29:33 +01001024 * a bmp to display. We redirect the output from frame buffer
1025 * console to serial console in this case or suppress it if
1026 * "silent" mode was requested.
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001027 */
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001028 if (IS_ENABLED(CONFIG_SPLASH_SCREEN) && env_get("splashimage")) {
Anatolij Gustschina7490812010-03-16 15:29:33 +01001029 if (!(gd->flags & GD_FLG_SILENT))
1030 outputdev = search_device (DEV_FLAGS_OUTPUT, "serial");
1031 }
wdenkf72da342003-10-10 10:05:42 +00001032
wdenk47d1a6e2002-11-03 00:01:44 +00001033 /* Scan devices looking for input and output devices */
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001034 list_for_each(pos, list) {
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001035 dev = list_entry(pos, struct stdio_dev, list);
wdenk47d1a6e2002-11-03 00:01:44 +00001036
1037 if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
1038 inputdev = dev;
1039 }
1040 if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
1041 outputdev = dev;
1042 }
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001043 if(inputdev && outputdev)
1044 break;
wdenk47d1a6e2002-11-03 00:01:44 +00001045 }
1046
1047 /* Initializes output console first */
1048 if (outputdev != NULL) {
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001049 console_setfile(stdout, outputdev);
1050 console_setfile(stderr, outputdev);
Patrick Delaunay45375ad2020-12-18 12:46:44 +01001051 console_devices_set(stdout, outputdev);
1052 console_devices_set(stderr, outputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001053 }
1054
1055 /* Initializes input console */
1056 if (inputdev != NULL) {
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001057 console_setfile(stdin, inputdev);
Patrick Delaunay45375ad2020-12-18 12:46:44 +01001058 console_devices_set(stdin, inputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001059 }
1060
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001061 if (!IS_ENABLED(CONFIG_SYS_CONSOLE_INFO_QUIET))
1062 stdio_print_current_devices();
wdenk47d1a6e2002-11-03 00:01:44 +00001063
1064 /* Setting environment variables */
Tom Rini27b42252018-05-03 09:12:26 -04001065 for (i = 0; i < MAX_FILES; i++) {
Simon Glass382bee52017-08-03 12:22:09 -06001066 env_set(stdio_names[i], stdio_devices[i]->name);
wdenk47d1a6e2002-11-03 00:01:44 +00001067 }
1068
Joe Hershbergerc4e00572012-12-11 22:16:19 -06001069 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */
1070
wdenk47d1a6e2002-11-03 00:01:44 +00001071#if 0
1072 /* If nothing usable installed, use only the initial console */
1073 if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001074 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +00001075#endif
Patrick Delaunay13551b92019-08-02 14:58:10 +02001076 print_pre_console_buffer(flushpoint);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001077 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +00001078}
1079
Simon Glassb0265422017-01-16 07:03:26 -07001080#endif /* CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */