blob: f3cc45cab5488efe7336b6f6c850ae3c4f29b627 [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
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200240/**
241 * console_needs_start_stop() - check if we need to start or stop the STDIO device
242 * @file: STDIO file
243 * @sdev: STDIO device in question
244 *
245 * This function checks if we need to start or stop the stdio device used for
246 * a console. For IOMUX case it simply enforces one time start and one time
247 * stop of the device independently of how many STDIO files are using it. In
248 * other words, we start console once before first STDIO device wants it and
249 * stop after the last is gone.
250 */
251static bool console_needs_start_stop(int file, struct stdio_dev *sdev)
252{
253 int i, j;
254
255 for (i = 0; i < ARRAY_SIZE(cd_count); i++) {
256 if (i == file)
257 continue;
258
259 for (j = 0; j < cd_count[i]; j++)
260 if (console_devices[i][j] == sdev)
261 return false;
262 }
263 return true;
264}
265
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100266/*
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200267 * This depends on tstc() always being called before getchar().
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100268 * This is guaranteed to be true because this routine is called
269 * only from fgetc() which assures it.
270 * No attempt is made to demultiplex multiple input sources.
271 */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100272static int console_getc(int file)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100273{
274 unsigned char ret;
275
276 /* This is never called with testcdev == NULL */
Simon Glass709ea542014-07-23 06:54:59 -0600277 ret = tstcdev->getc(tstcdev);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100278 tstcdev = NULL;
279 return ret;
280}
281
Patrick Delaunaya17b38c2020-12-18 12:46:46 +0100282/* Upper layer may have already called tstc(): check the saved result */
283static bool console_has_tstc(void)
284{
285 return !!tstcdev;
286}
287
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100288static int console_tstc(int file)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100289{
290 int i, ret;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200291 struct stdio_dev *dev;
Joe Hershbergerb2f58d82018-07-02 20:06:48 -0500292 int prev;
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100293
Joe Hershbergerb2f58d82018-07-02 20:06:48 -0500294 prev = disable_ctrlc(1);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100295 for (i = 0; i < cd_count[file]; i++) {
296 dev = console_devices[file][i];
297 if (dev->tstc != NULL) {
Simon Glass709ea542014-07-23 06:54:59 -0600298 ret = dev->tstc(dev);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100299 if (ret > 0) {
300 tstcdev = dev;
Joe Hershbergerb2f58d82018-07-02 20:06:48 -0500301 disable_ctrlc(prev);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100302 return ret;
303 }
304 }
305 }
Joe Hershbergerb2f58d82018-07-02 20:06:48 -0500306 disable_ctrlc(prev);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100307
308 return 0;
309}
310
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100311static void console_putc(int file, const char c)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100312{
313 int i;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200314 struct stdio_dev *dev;
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100315
316 for (i = 0; i < cd_count[file]; i++) {
317 dev = console_devices[file][i];
318 if (dev->putc != NULL)
Simon Glass709ea542014-07-23 06:54:59 -0600319 dev->putc(dev, c);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100320 }
321}
322
Simon Glass493a4c82020-07-02 21:12:13 -0600323/**
324 * console_puts_select() - Output a string to all console devices
325 *
326 * @file: File number to output to (e,g, stdout, see stdio.h)
327 * @serial_only: true to output only to serial, false to output to everything
328 * else
329 * @s: String to output
330 */
331static void console_puts_select(int file, bool serial_only, const char *s)
Siarhei Siamashka27669662015-01-08 09:02:31 +0200332{
333 int i;
334 struct stdio_dev *dev;
335
336 for (i = 0; i < cd_count[file]; i++) {
Simon Glass493a4c82020-07-02 21:12:13 -0600337 bool is_serial;
338
Siarhei Siamashka27669662015-01-08 09:02:31 +0200339 dev = console_devices[file][i];
Simon Glass493a4c82020-07-02 21:12:13 -0600340 is_serial = console_dev_is_serial(dev);
341 if (dev->puts && serial_only == is_serial)
Hans de Goedea8552c72015-05-05 13:13:36 +0200342 dev->puts(dev, s);
Siarhei Siamashka27669662015-01-08 09:02:31 +0200343 }
344}
Siarhei Siamashka27669662015-01-08 09:02:31 +0200345
Simon Glass493a4c82020-07-02 21:12:13 -0600346void console_puts_select_stderr(bool serial_only, const char *s)
347{
348 console_puts_select(stderr, serial_only, s);
349}
350
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100351static void console_puts(int file, const char *s)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100352{
353 int i;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200354 struct stdio_dev *dev;
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100355
356 for (i = 0; i < cd_count[file]; i++) {
357 dev = console_devices[file][i];
358 if (dev->puts != NULL)
Simon Glass709ea542014-07-23 06:54:59 -0600359 dev->puts(dev, s);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100360 }
361}
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100362
Tom Rini5e63c962019-10-30 09:18:43 -0400363#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200364static inline void console_doenv(int file, struct stdio_dev *dev)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100365{
366 iomux_doenv(file, dev->name);
367}
Tom Rini5e63c962019-10-30 09:18:43 -0400368#endif
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100369#else
Patrick Delaunay45375ad2020-12-18 12:46:44 +0100370
371static void __maybe_unused console_devices_set(int file, struct stdio_dev *dev)
372{
373}
374
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200375static inline bool console_needs_start_stop(int file, struct stdio_dev *sdev)
376{
377 return true;
378}
379
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100380static inline int console_getc(int file)
381{
Simon Glass709ea542014-07-23 06:54:59 -0600382 return stdio_devices[file]->getc(stdio_devices[file]);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100383}
384
Patrick Delaunaya17b38c2020-12-18 12:46:46 +0100385static bool console_has_tstc(void)
386{
387 return false;
388}
389
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100390static inline int console_tstc(int file)
391{
Simon Glass709ea542014-07-23 06:54:59 -0600392 return stdio_devices[file]->tstc(stdio_devices[file]);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100393}
394
395static inline void console_putc(int file, const char c)
396{
Simon Glass709ea542014-07-23 06:54:59 -0600397 stdio_devices[file]->putc(stdio_devices[file], c);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100398}
399
Simon Glass493a4c82020-07-02 21:12:13 -0600400void console_puts_select(int file, bool serial_only, const char *s)
Siarhei Siamashka27669662015-01-08 09:02:31 +0200401{
Simon Glass493a4c82020-07-02 21:12:13 -0600402 if (serial_only == console_dev_is_serial(stdio_devices[file]))
Hans de Goedea8552c72015-05-05 13:13:36 +0200403 stdio_devices[file]->puts(stdio_devices[file], s);
Siarhei Siamashka27669662015-01-08 09:02:31 +0200404}
Siarhei Siamashka27669662015-01-08 09:02:31 +0200405
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100406static inline void console_puts(int file, const char *s)
407{
Simon Glass709ea542014-07-23 06:54:59 -0600408 stdio_devices[file]->puts(stdio_devices[file], s);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100409}
410
Tom Rini5e63c962019-10-30 09:18:43 -0400411#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200412static inline void console_doenv(int file, struct stdio_dev *dev)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100413{
414 console_setfile(file, dev);
415}
Tom Rini5e63c962019-10-30 09:18:43 -0400416#endif
Simon Glassb0265422017-01-16 07:03:26 -0700417#endif /* CONIFIG_IS_ENABLED(CONSOLE_MUX) */
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100418
Andy Shevchenko41f668b2020-12-21 14:30:00 +0200419int console_start(int file, struct stdio_dev *sdev)
420{
421 int error;
422
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200423 if (!console_needs_start_stop(file, sdev))
424 return 0;
425
Andy Shevchenko41f668b2020-12-21 14:30:00 +0200426 /* Start new device */
427 if (sdev->start) {
428 error = sdev->start(sdev);
429 /* If it's not started don't use it */
430 if (error < 0)
431 return error;
432 }
433 return 0;
434}
435
436void console_stop(int file, struct stdio_dev *sdev)
437{
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200438 if (!console_needs_start_stop(file, sdev))
439 return;
440
Andy Shevchenko41f668b2020-12-21 14:30:00 +0200441 if (sdev->stop)
442 sdev->stop(sdev);
443}
444
wdenk47d1a6e2002-11-03 00:01:44 +0000445/** U-Boot INITIAL CONSOLE-NOT COMPATIBLE FUNCTIONS *************************/
446
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200447int serial_printf(const char *fmt, ...)
wdenk47d1a6e2002-11-03 00:01:44 +0000448{
449 va_list args;
450 uint i;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200451 char printbuffer[CONFIG_SYS_PBSIZE];
wdenk47d1a6e2002-11-03 00:01:44 +0000452
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100453 va_start(args, fmt);
wdenk47d1a6e2002-11-03 00:01:44 +0000454
455 /* For this to work, printbuffer must be larger than
456 * anything we ever want to print.
457 */
Sonny Rao068af6f2011-10-10 09:22:31 +0000458 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100459 va_end(args);
wdenk47d1a6e2002-11-03 00:01:44 +0000460
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100461 serial_puts(printbuffer);
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200462 return i;
wdenk47d1a6e2002-11-03 00:01:44 +0000463}
464
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100465int fgetc(int file)
wdenk47d1a6e2002-11-03 00:01:44 +0000466{
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100467 if (file < MAX_FILES) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100468 /*
469 * Effectively poll for input wherever it may be available.
470 */
471 for (;;) {
Andreas J. Reichel64407462016-07-13 12:56:51 +0200472 WATCHDOG_RESET();
Patrick Delaunaya17b38c2020-12-18 12:46:46 +0100473 if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
474 /*
475 * Upper layer may have already called tstc() so
476 * check for that first.
477 */
478 if (console_has_tstc())
479 return console_getc(file);
480 console_tstc(file);
481 } else {
482 if (console_tstc(file))
483 return console_getc(file);
484 }
485
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100486 /*
487 * If the watchdog must be rate-limited then it should
488 * already be handled in board-specific code.
489 */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100490 if (IS_ENABLED(CONFIG_WATCHDOG))
491 udelay(1);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100492 }
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100493 }
wdenk47d1a6e2002-11-03 00:01:44 +0000494
495 return -1;
496}
497
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100498int ftstc(int file)
wdenk47d1a6e2002-11-03 00:01:44 +0000499{
500 if (file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100501 return console_tstc(file);
wdenk47d1a6e2002-11-03 00:01:44 +0000502
503 return -1;
504}
505
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100506void fputc(int file, const char c)
wdenk47d1a6e2002-11-03 00:01:44 +0000507{
508 if (file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100509 console_putc(file, c);
wdenk47d1a6e2002-11-03 00:01:44 +0000510}
511
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100512void fputs(int file, const char *s)
wdenk47d1a6e2002-11-03 00:01:44 +0000513{
514 if (file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100515 console_puts(file, s);
wdenk47d1a6e2002-11-03 00:01:44 +0000516}
517
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200518int fprintf(int file, const char *fmt, ...)
wdenk47d1a6e2002-11-03 00:01:44 +0000519{
520 va_list args;
521 uint i;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200522 char printbuffer[CONFIG_SYS_PBSIZE];
wdenk47d1a6e2002-11-03 00:01:44 +0000523
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100524 va_start(args, fmt);
wdenk47d1a6e2002-11-03 00:01:44 +0000525
526 /* For this to work, printbuffer must be larger than
527 * anything we ever want to print.
528 */
Sonny Rao068af6f2011-10-10 09:22:31 +0000529 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100530 va_end(args);
wdenk47d1a6e2002-11-03 00:01:44 +0000531
532 /* Send to desired file */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100533 fputs(file, printbuffer);
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200534 return i;
wdenk47d1a6e2002-11-03 00:01:44 +0000535}
536
537/** U-Boot INITIAL CONSOLE-COMPATIBLE FUNCTION *****************************/
538
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200539int getchar(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000540{
Patrick Delaunay1e993712020-12-18 12:46:45 +0100541 int ch;
542
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100543 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100544 return 0;
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100545
Graeme Russe3e454c2011-08-29 02:14:05 +0000546 if (!gd->have_console)
547 return 0;
548
Patrick Delaunay1e993712020-12-18 12:46:45 +0100549 ch = console_record_getc();
550 if (ch != -1)
551 return ch;
Simon Glass9854a872015-11-08 23:47:48 -0700552
wdenk47d1a6e2002-11-03 00:01:44 +0000553 if (gd->flags & GD_FLG_DEVINIT) {
554 /* Get from the standard input */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100555 return fgetc(stdin);
wdenk47d1a6e2002-11-03 00:01:44 +0000556 }
557
558 /* Send directly to the handler */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100559 return serial_getc();
wdenk47d1a6e2002-11-03 00:01:44 +0000560}
561
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100562int tstc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000563{
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100564 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100565 return 0;
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100566
Graeme Russe3e454c2011-08-29 02:14:05 +0000567 if (!gd->have_console)
568 return 0;
Patrick Delaunay1e993712020-12-18 12:46:45 +0100569
570 if (console_record_tstc())
571 return 1;
572
wdenk47d1a6e2002-11-03 00:01:44 +0000573 if (gd->flags & GD_FLG_DEVINIT) {
574 /* Test the standard input */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100575 return ftstc(stdin);
wdenk47d1a6e2002-11-03 00:01:44 +0000576 }
577
578 /* Send directly to the handler */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100579 return serial_tstc();
wdenk47d1a6e2002-11-03 00:01:44 +0000580}
581
Siarhei Siamashka27669662015-01-08 09:02:31 +0200582#define PRE_CONSOLE_FLUSHPOINT1_SERIAL 0
583#define PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL 1
584
Simon Glass8f925582016-10-17 20:12:36 -0600585#if CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
Graeme Russ9558b482011-09-01 00:48:27 +0000586#define CIRC_BUF_IDX(idx) ((idx) % (unsigned long)CONFIG_PRE_CON_BUF_SZ)
587
588static void pre_console_putc(const char c)
589{
Simon Glass4e6bafa2017-06-15 21:37:52 -0600590 char *buffer;
591
592 buffer = map_sysmem(CONFIG_PRE_CON_BUF_ADDR, CONFIG_PRE_CON_BUF_SZ);
Graeme Russ9558b482011-09-01 00:48:27 +0000593
594 buffer[CIRC_BUF_IDX(gd->precon_buf_idx++)] = c;
Simon Glass4e6bafa2017-06-15 21:37:52 -0600595
596 unmap_sysmem(buffer);
Graeme Russ9558b482011-09-01 00:48:27 +0000597}
598
Soeren Mochbe135cc2017-11-04 16:14:09 +0100599static void pre_console_puts(const char *s)
600{
601 while (*s)
602 pre_console_putc(*s++);
603}
604
Siarhei Siamashka27669662015-01-08 09:02:31 +0200605static void print_pre_console_buffer(int flushpoint)
Graeme Russ9558b482011-09-01 00:48:27 +0000606{
Hans de Goedea8552c72015-05-05 13:13:36 +0200607 unsigned long in = 0, out = 0;
Hans de Goedea8552c72015-05-05 13:13:36 +0200608 char buf_out[CONFIG_PRE_CON_BUF_SZ + 1];
Simon Glass4e6bafa2017-06-15 21:37:52 -0600609 char *buf_in;
Graeme Russ9558b482011-09-01 00:48:27 +0000610
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100611 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT))
Patrick Delaunay13551b92019-08-02 14:58:10 +0200612 return;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200613
Simon Glass4e6bafa2017-06-15 21:37:52 -0600614 buf_in = map_sysmem(CONFIG_PRE_CON_BUF_ADDR, CONFIG_PRE_CON_BUF_SZ);
Graeme Russ9558b482011-09-01 00:48:27 +0000615 if (gd->precon_buf_idx > CONFIG_PRE_CON_BUF_SZ)
Hans de Goedea8552c72015-05-05 13:13:36 +0200616 in = gd->precon_buf_idx - CONFIG_PRE_CON_BUF_SZ;
Graeme Russ9558b482011-09-01 00:48:27 +0000617
Hans de Goedea8552c72015-05-05 13:13:36 +0200618 while (in < gd->precon_buf_idx)
619 buf_out[out++] = buf_in[CIRC_BUF_IDX(in++)];
Simon Glass4e6bafa2017-06-15 21:37:52 -0600620 unmap_sysmem(buf_in);
Hans de Goedea8552c72015-05-05 13:13:36 +0200621
622 buf_out[out] = 0;
623
624 switch (flushpoint) {
625 case PRE_CONSOLE_FLUSHPOINT1_SERIAL:
626 puts(buf_out);
627 break;
628 case PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL:
Simon Glass493a4c82020-07-02 21:12:13 -0600629 console_puts_select(stdout, false, buf_out);
Hans de Goedea8552c72015-05-05 13:13:36 +0200630 break;
631 }
Graeme Russ9558b482011-09-01 00:48:27 +0000632}
633#else
634static inline void pre_console_putc(const char c) {}
Soeren Mochbe135cc2017-11-04 16:14:09 +0100635static inline void pre_console_puts(const char *s) {}
Siarhei Siamashka27669662015-01-08 09:02:31 +0200636static inline void print_pre_console_buffer(int flushpoint) {}
Graeme Russ9558b482011-09-01 00:48:27 +0000637#endif
638
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100639void putc(const char c)
wdenk47d1a6e2002-11-03 00:01:44 +0000640{
Patrick Delaunay93cdb522020-11-27 11:20:56 +0100641 if (!gd)
642 return;
Patrick Delaunay1e993712020-12-18 12:46:45 +0100643
644 console_record_putc(c);
645
Simon Glass64e9b4f2017-12-04 13:48:19 -0700646 /* sandbox can send characters to stdout before it has a console */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100647 if (IS_ENABLED(CONFIG_SANDBOX) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glass64e9b4f2017-12-04 13:48:19 -0700648 os_putc(c);
649 return;
650 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100651
Simon Glassd6ea5302015-06-23 15:38:33 -0600652 /* if we don't have a console yet, use the debug UART */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100653 if (IS_ENABLED(CONFIG_DEBUG_UART) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glassd6ea5302015-06-23 15:38:33 -0600654 printch(c);
655 return;
656 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100657
658 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT)) {
Patrick Delaunay13551b92019-08-02 14:58:10 +0200659 if (!(gd->flags & GD_FLG_DEVINIT))
660 pre_console_putc(c);
wdenkf6e20fc2004-02-08 19:38:38 +0000661 return;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200662 }
wdenka6cccae2004-02-06 21:48:22 +0000663
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100664 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100665 return;
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100666
Graeme Russe3e454c2011-08-29 02:14:05 +0000667 if (!gd->have_console)
Graeme Russ9558b482011-09-01 00:48:27 +0000668 return pre_console_putc(c);
Graeme Russe3e454c2011-08-29 02:14:05 +0000669
wdenk47d1a6e2002-11-03 00:01:44 +0000670 if (gd->flags & GD_FLG_DEVINIT) {
671 /* Send to the standard output */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100672 fputc(stdout, c);
wdenk47d1a6e2002-11-03 00:01:44 +0000673 } else {
674 /* Send directly to the handler */
Siarhei Siamashka27669662015-01-08 09:02:31 +0200675 pre_console_putc(c);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100676 serial_putc(c);
wdenk47d1a6e2002-11-03 00:01:44 +0000677 }
678}
679
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100680void puts(const char *s)
wdenk47d1a6e2002-11-03 00:01:44 +0000681{
Patrick Delaunay93cdb522020-11-27 11:20:56 +0100682 if (!gd)
683 return;
Patrick Delaunay1e993712020-12-18 12:46:45 +0100684
685 console_record_puts(s);
686
Simon Glass36bcea62018-11-15 18:44:04 -0700687 /* sandbox can send characters to stdout before it has a console */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100688 if (IS_ENABLED(CONFIG_SANDBOX) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glass36bcea62018-11-15 18:44:04 -0700689 os_puts(s);
690 return;
691 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100692
693 if (IS_ENABLED(CONFIG_DEBUG_UART) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Soeren Mochbe135cc2017-11-04 16:14:09 +0100694 while (*s) {
695 int ch = *s++;
696
697 printch(ch);
698 }
699 return;
700 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100701
702 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT)) {
Patrick Delaunay13551b92019-08-02 14:58:10 +0200703 if (!(gd->flags & GD_FLG_DEVINIT))
704 pre_console_puts(s);
Soeren Mochbe135cc2017-11-04 16:14:09 +0100705 return;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200706 }
Soeren Mochbe135cc2017-11-04 16:14:09 +0100707
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100708 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Soeren Mochbe135cc2017-11-04 16:14:09 +0100709 return;
Soeren Mochbe135cc2017-11-04 16:14:09 +0100710
711 if (!gd->have_console)
712 return pre_console_puts(s);
713
714 if (gd->flags & GD_FLG_DEVINIT) {
715 /* Send to the standard output */
716 fputs(stdout, s);
717 } else {
718 /* Send directly to the handler */
719 pre_console_puts(s);
720 serial_puts(s);
721 }
wdenk47d1a6e2002-11-03 00:01:44 +0000722}
723
Simon Glass9854a872015-11-08 23:47:48 -0700724#ifdef CONFIG_CONSOLE_RECORD
725int console_record_init(void)
726{
727 int ret;
728
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100729 ret = membuff_new((struct membuff *)&gd->console_out,
730 CONFIG_CONSOLE_RECORD_OUT_SIZE);
Simon Glass9854a872015-11-08 23:47:48 -0700731 if (ret)
732 return ret;
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100733 ret = membuff_new((struct membuff *)&gd->console_in,
734 CONFIG_CONSOLE_RECORD_IN_SIZE);
Simon Glass9854a872015-11-08 23:47:48 -0700735
736 return ret;
737}
738
739void console_record_reset(void)
740{
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100741 membuff_purge((struct membuff *)&gd->console_out);
742 membuff_purge((struct membuff *)&gd->console_in);
Simon Glass9854a872015-11-08 23:47:48 -0700743}
744
Simon Glassbd347152020-07-28 19:41:11 -0600745int console_record_reset_enable(void)
Simon Glass9854a872015-11-08 23:47:48 -0700746{
747 console_record_reset();
748 gd->flags |= GD_FLG_RECORD;
Simon Glassbd347152020-07-28 19:41:11 -0600749
750 return 0;
Simon Glass9854a872015-11-08 23:47:48 -0700751}
Simon Glassb6123122020-01-27 08:49:54 -0700752
753int console_record_readline(char *str, int maxlen)
754{
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100755 return membuff_readline((struct membuff *)&gd->console_out, str,
756 maxlen, ' ');
Simon Glassb6123122020-01-27 08:49:54 -0700757}
758
759int console_record_avail(void)
760{
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100761 return membuff_avail((struct membuff *)&gd->console_out);
Simon Glassb6123122020-01-27 08:49:54 -0700762}
763
Simon Glass9854a872015-11-08 23:47:48 -0700764#endif
765
wdenk47d1a6e2002-11-03 00:01:44 +0000766/* test if ctrl-c was pressed */
767static int ctrlc_disabled = 0; /* see disable_ctrl() */
768static int ctrlc_was_pressed = 0;
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100769int ctrlc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000770{
wdenk47d1a6e2002-11-03 00:01:44 +0000771 if (!ctrlc_disabled && gd->have_console) {
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100772 if (tstc()) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200773 switch (getchar()) {
wdenk47d1a6e2002-11-03 00:01:44 +0000774 case 0x03: /* ^C - Control C */
775 ctrlc_was_pressed = 1;
776 return 1;
777 default:
778 break;
779 }
780 }
781 }
Simon Glass8969ea32014-09-14 12:40:15 -0600782
wdenk47d1a6e2002-11-03 00:01:44 +0000783 return 0;
784}
Pierre Auberta5dffa42014-04-24 10:30:07 +0200785/* Reads user's confirmation.
786 Returns 1 if user's input is "y", "Y", "yes" or "YES"
787*/
788int confirm_yesno(void)
789{
790 int i;
791 char str_input[5];
wdenk47d1a6e2002-11-03 00:01:44 +0000792
Pierre Auberta5dffa42014-04-24 10:30:07 +0200793 /* Flush input */
794 while (tstc())
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200795 getchar();
Pierre Auberta5dffa42014-04-24 10:30:07 +0200796 i = 0;
797 while (i < sizeof(str_input)) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200798 str_input[i] = getchar();
Pierre Auberta5dffa42014-04-24 10:30:07 +0200799 putc(str_input[i]);
800 if (str_input[i] == '\r')
801 break;
802 i++;
803 }
804 putc('\n');
805 if (strncmp(str_input, "y\r", 2) == 0 ||
806 strncmp(str_input, "Y\r", 2) == 0 ||
807 strncmp(str_input, "yes\r", 4) == 0 ||
808 strncmp(str_input, "YES\r", 4) == 0)
809 return 1;
810 return 0;
811}
wdenk47d1a6e2002-11-03 00:01:44 +0000812/* pass 1 to disable ctrlc() checking, 0 to enable.
813 * returns previous state
814 */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100815int disable_ctrlc(int disable)
wdenk47d1a6e2002-11-03 00:01:44 +0000816{
817 int prev = ctrlc_disabled; /* save previous state */
818
819 ctrlc_disabled = disable;
820 return prev;
821}
822
823int had_ctrlc (void)
824{
825 return ctrlc_was_pressed;
826}
827
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100828void clear_ctrlc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000829{
830 ctrlc_was_pressed = 0;
831}
832
wdenk47d1a6e2002-11-03 00:01:44 +0000833/** U-Boot INIT FUNCTIONS *************************************************/
834
Andy Shevchenko32324872020-12-21 14:30:03 +0200835struct stdio_dev *console_search_dev(int flags, const char *name)
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200836{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200837 struct stdio_dev *dev;
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200838
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200839 dev = stdio_get_by_name(name);
Simon Glassa2931b32016-02-06 14:31:37 -0700840#ifdef CONFIG_VIDCONSOLE_AS_LCD
Patrick Delaunay27b5b9e2020-07-01 14:56:10 +0200841 if (!dev && !strcmp(name, CONFIG_VIDCONSOLE_AS_NAME))
Simon Glassa2931b32016-02-06 14:31:37 -0700842 dev = stdio_get_by_name("vidconsole");
843#endif
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200844
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100845 if (dev && (dev->flags & flags))
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200846 return dev;
847
848 return NULL;
849}
850
Mike Frysingerd7be3052010-10-20 07:18:03 -0400851int console_assign(int file, const char *devname)
wdenk47d1a6e2002-11-03 00:01:44 +0000852{
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200853 int flag;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200854 struct stdio_dev *dev;
wdenk47d1a6e2002-11-03 00:01:44 +0000855
856 /* Check for valid file */
857 switch (file) {
858 case stdin:
859 flag = DEV_FLAGS_INPUT;
860 break;
861 case stdout:
862 case stderr:
863 flag = DEV_FLAGS_OUTPUT;
864 break;
865 default:
866 return -1;
867 }
868
869 /* Check for valid device name */
870
Andy Shevchenko32324872020-12-21 14:30:03 +0200871 dev = console_search_dev(flag, devname);
wdenk47d1a6e2002-11-03 00:01:44 +0000872
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100873 if (dev)
874 return console_setfile(file, dev);
wdenk47d1a6e2002-11-03 00:01:44 +0000875
876 return -1;
877}
878
Patrick Delaunay13551b92019-08-02 14:58:10 +0200879/* return true if the 'silent' flag is removed */
880static bool console_update_silent(void)
Chris Packham43e0a3d2016-09-23 15:59:43 +1200881{
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100882 unsigned long flags = gd->flags;
883
884 if (!IS_ENABLED(CONFIG_SILENT_CONSOLE))
885 return false;
886
Patrick Delaunay13551b92019-08-02 14:58:10 +0200887 if (env_get("silent")) {
Chris Packham43e0a3d2016-09-23 15:59:43 +1200888 gd->flags |= GD_FLG_SILENT;
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100889 return false;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200890 }
Patrick Delaunay13551b92019-08-02 14:58:10 +0200891
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100892 gd->flags &= ~GD_FLG_SILENT;
893
894 return !!(flags & GD_FLG_SILENT);
Chris Packham43e0a3d2016-09-23 15:59:43 +1200895}
896
Simon Glassb0895382017-06-15 21:37:50 -0600897int console_announce_r(void)
898{
899#if !CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
900 char buf[DISPLAY_OPTIONS_BANNER_LENGTH];
901
902 display_options_get_banner(false, buf, sizeof(buf));
903
Simon Glass493a4c82020-07-02 21:12:13 -0600904 console_puts_select(stdout, false, buf);
Simon Glassb0895382017-06-15 21:37:50 -0600905#endif
906
907 return 0;
908}
909
wdenk47d1a6e2002-11-03 00:01:44 +0000910/* Called before relocation - use serial functions */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100911int console_init_f(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000912{
wdenk47d1a6e2002-11-03 00:01:44 +0000913 gd->have_console = 1;
wdenkf72da342003-10-10 10:05:42 +0000914
Chris Packham43e0a3d2016-09-23 15:59:43 +1200915 console_update_silent();
wdenkf72da342003-10-10 10:05:42 +0000916
Siarhei Siamashka27669662015-01-08 09:02:31 +0200917 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT1_SERIAL);
Graeme Russ9558b482011-09-01 00:48:27 +0000918
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100919 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +0000920}
921
Jean-Christophe PLAGNIOL-VILLARD7e3be7c2009-05-16 12:14:55 +0200922void stdio_print_current_devices(void)
923{
Jean-Christophe PLAGNIOL-VILLARD7e3be7c2009-05-16 12:14:55 +0200924 /* Print information */
925 puts("In: ");
926 if (stdio_devices[stdin] == NULL) {
927 puts("No input devices available!\n");
928 } else {
929 printf ("%s\n", stdio_devices[stdin]->name);
930 }
931
932 puts("Out: ");
933 if (stdio_devices[stdout] == NULL) {
934 puts("No output devices available!\n");
935 } else {
936 printf ("%s\n", stdio_devices[stdout]->name);
937 }
938
939 puts("Err: ");
940 if (stdio_devices[stderr] == NULL) {
941 puts("No error devices available!\n");
942 } else {
943 printf ("%s\n", stdio_devices[stderr]->name);
944 }
Jean-Christophe PLAGNIOL-VILLARD7e3be7c2009-05-16 12:14:55 +0200945}
946
Simon Glassb0265422017-01-16 07:03:26 -0700947#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
wdenk47d1a6e2002-11-03 00:01:44 +0000948/* Called after the relocation - use desired console functions */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100949int console_init_r(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000950{
951 char *stdinname, *stdoutname, *stderrname;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200952 struct stdio_dev *inputdev = NULL, *outputdev = NULL, *errdev = NULL;
wdenk6e592382004-04-18 17:39:38 +0000953 int i;
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100954 int iomux_err = 0;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200955 int flushpoint;
wdenk47d1a6e2002-11-03 00:01:44 +0000956
Patrick Delaunaybf46be72019-08-02 14:58:09 +0200957 /* update silent for env loaded from flash (initr_env) */
Patrick Delaunay13551b92019-08-02 14:58:10 +0200958 if (console_update_silent())
959 flushpoint = PRE_CONSOLE_FLUSHPOINT1_SERIAL;
960 else
961 flushpoint = PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL;
Patrick Delaunaybf46be72019-08-02 14:58:09 +0200962
wdenk47d1a6e2002-11-03 00:01:44 +0000963 /* set default handlers at first */
Martin Dorwig49cad542015-01-26 15:22:54 -0700964 gd->jt->getc = serial_getc;
965 gd->jt->tstc = serial_tstc;
966 gd->jt->putc = serial_putc;
967 gd->jt->puts = serial_puts;
968 gd->jt->printf = serial_printf;
wdenk47d1a6e2002-11-03 00:01:44 +0000969
970 /* stdin stdout and stderr are in environment */
971 /* scan for it */
Simon Glass00caae62017-08-03 12:22:12 -0600972 stdinname = env_get("stdin");
973 stdoutname = env_get("stdout");
974 stderrname = env_get("stderr");
wdenk47d1a6e2002-11-03 00:01:44 +0000975
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200976 if (OVERWRITE_CONSOLE == 0) { /* if not overwritten by config switch */
Andy Shevchenko32324872020-12-21 14:30:03 +0200977 inputdev = console_search_dev(DEV_FLAGS_INPUT, stdinname);
978 outputdev = console_search_dev(DEV_FLAGS_OUTPUT, stdoutname);
979 errdev = console_search_dev(DEV_FLAGS_OUTPUT, stderrname);
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100980 if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
981 iomux_err = iomux_doenv(stdin, stdinname);
982 iomux_err += iomux_doenv(stdout, stdoutname);
983 iomux_err += iomux_doenv(stderr, stderrname);
984 if (!iomux_err)
985 /* Successful, so skip all the code below. */
986 goto done;
987 }
wdenk47d1a6e2002-11-03 00:01:44 +0000988 }
989 /* if the devices are overwritten or not found, use default device */
990 if (inputdev == NULL) {
Andy Shevchenko32324872020-12-21 14:30:03 +0200991 inputdev = console_search_dev(DEV_FLAGS_INPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +0000992 }
993 if (outputdev == NULL) {
Andy Shevchenko32324872020-12-21 14:30:03 +0200994 outputdev = console_search_dev(DEV_FLAGS_OUTPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +0000995 }
996 if (errdev == NULL) {
Andy Shevchenko32324872020-12-21 14:30:03 +0200997 errdev = console_search_dev(DEV_FLAGS_OUTPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +0000998 }
999 /* Initializes output console first */
1000 if (outputdev != NULL) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001001 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +01001002 console_doenv(stdout, outputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001003 }
1004 if (errdev != NULL) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001005 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +01001006 console_doenv(stderr, errdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001007 }
1008 if (inputdev != NULL) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001009 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +01001010 console_doenv(stdin, inputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001011 }
1012
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001013done:
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001014
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001015 if (!IS_ENABLED(CONFIG_SYS_CONSOLE_INFO_QUIET))
1016 stdio_print_current_devices();
1017
Simon Glassa2931b32016-02-06 14:31:37 -07001018#ifdef CONFIG_VIDCONSOLE_AS_LCD
Patrick Delaunay27b5b9e2020-07-01 14:56:10 +02001019 if (strstr(stdoutname, CONFIG_VIDCONSOLE_AS_NAME))
Anatolij Gustschin22b897a2020-05-23 17:11:20 +02001020 printf("Warning: Please change '%s' to 'vidconsole' in stdout/stderr environment vars\n",
Patrick Delaunay27b5b9e2020-07-01 14:56:10 +02001021 CONFIG_VIDCONSOLE_AS_NAME);
Simon Glassa2931b32016-02-06 14:31:37 -07001022#endif
wdenk47d1a6e2002-11-03 00:01:44 +00001023
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001024 if (IS_ENABLED(CONFIG_SYS_CONSOLE_ENV_OVERWRITE)) {
1025 /* set the environment variables (will overwrite previous env settings) */
1026 for (i = 0; i < MAX_FILES; i++)
1027 env_set(stdio_names[i], stdio_devices[i]->name);
wdenk47d1a6e2002-11-03 00:01:44 +00001028 }
wdenk47d1a6e2002-11-03 00:01:44 +00001029
Joe Hershbergerc4e00572012-12-11 22:16:19 -06001030 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */
1031
Patrick Delaunay13551b92019-08-02 14:58:10 +02001032 print_pre_console_buffer(flushpoint);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001033 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +00001034}
1035
Simon Glassb0265422017-01-16 07:03:26 -07001036#else /* !CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */
wdenk47d1a6e2002-11-03 00:01:44 +00001037
1038/* Called after the relocation - use desired console functions */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001039int console_init_r(void)
wdenk47d1a6e2002-11-03 00:01:44 +00001040{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001041 struct stdio_dev *inputdev = NULL, *outputdev = NULL;
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001042 int i;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001043 struct list_head *list = stdio_get_list();
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001044 struct list_head *pos;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001045 struct stdio_dev *dev;
Patrick Delaunay13551b92019-08-02 14:58:10 +02001046 int flushpoint;
wdenk47d1a6e2002-11-03 00:01:44 +00001047
Patrick Delaunaybf46be72019-08-02 14:58:09 +02001048 /* update silent for env loaded from flash (initr_env) */
Patrick Delaunay13551b92019-08-02 14:58:10 +02001049 if (console_update_silent())
1050 flushpoint = PRE_CONSOLE_FLUSHPOINT1_SERIAL;
1051 else
1052 flushpoint = PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL;
Chris Packham43e0a3d2016-09-23 15:59:43 +12001053
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001054 /*
1055 * suppress all output if splash screen is enabled and we have
Anatolij Gustschina7490812010-03-16 15:29:33 +01001056 * a bmp to display. We redirect the output from frame buffer
1057 * console to serial console in this case or suppress it if
1058 * "silent" mode was requested.
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001059 */
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001060 if (IS_ENABLED(CONFIG_SPLASH_SCREEN) && env_get("splashimage")) {
Anatolij Gustschina7490812010-03-16 15:29:33 +01001061 if (!(gd->flags & GD_FLG_SILENT))
Andy Shevchenko32324872020-12-21 14:30:03 +02001062 outputdev = console_search_dev (DEV_FLAGS_OUTPUT, "serial");
Anatolij Gustschina7490812010-03-16 15:29:33 +01001063 }
wdenkf72da342003-10-10 10:05:42 +00001064
wdenk47d1a6e2002-11-03 00:01:44 +00001065 /* Scan devices looking for input and output devices */
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001066 list_for_each(pos, list) {
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001067 dev = list_entry(pos, struct stdio_dev, list);
wdenk47d1a6e2002-11-03 00:01:44 +00001068
1069 if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
1070 inputdev = dev;
1071 }
1072 if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
1073 outputdev = dev;
1074 }
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001075 if(inputdev && outputdev)
1076 break;
wdenk47d1a6e2002-11-03 00:01:44 +00001077 }
1078
1079 /* Initializes output console first */
1080 if (outputdev != NULL) {
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001081 console_setfile(stdout, outputdev);
1082 console_setfile(stderr, outputdev);
Patrick Delaunay45375ad2020-12-18 12:46:44 +01001083 console_devices_set(stdout, outputdev);
1084 console_devices_set(stderr, outputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001085 }
1086
1087 /* Initializes input console */
1088 if (inputdev != NULL) {
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001089 console_setfile(stdin, inputdev);
Patrick Delaunay45375ad2020-12-18 12:46:44 +01001090 console_devices_set(stdin, inputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001091 }
1092
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001093 if (!IS_ENABLED(CONFIG_SYS_CONSOLE_INFO_QUIET))
1094 stdio_print_current_devices();
wdenk47d1a6e2002-11-03 00:01:44 +00001095
1096 /* Setting environment variables */
Tom Rini27b42252018-05-03 09:12:26 -04001097 for (i = 0; i < MAX_FILES; i++) {
Simon Glass382bee52017-08-03 12:22:09 -06001098 env_set(stdio_names[i], stdio_devices[i]->name);
wdenk47d1a6e2002-11-03 00:01:44 +00001099 }
1100
Joe Hershbergerc4e00572012-12-11 22:16:19 -06001101 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */
1102
Patrick Delaunay13551b92019-08-02 14:58:10 +02001103 print_pre_console_buffer(flushpoint);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001104 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +00001105}
1106
Simon Glassb0265422017-01-16 07:03:26 -07001107#endif /* CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */