blob: cad65891fc9f1932e5f490ecc87bb63aa8e30269 [file] [log] [blame]
Tom Rini10e47792018-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 Glassa73bda42015-11-08 23:47:45 -07008#include <console.h>
Simon Glass7dd27e02015-06-23 15:38:33 -06009#include <debug_uart.h>
Simon Glass1ab16922022-07-31 12:28:48 -060010#include <display_options.h>
Simon Glass10a7fe92017-07-27 09:31:04 -060011#include <dm.h>
Simon Glass5e6201b2019-08-01 09:46:51 -060012#include <env.h>
wdenk47d1a6e2002-11-03 00:01:44 +000013#include <stdarg.h>
Jeroen Hofstee3b46b3b2014-10-08 22:57:48 +020014#include <iomux.h>
wdenk47d1a6e2002-11-03 00:01:44 +000015#include <malloc.h>
Simon Glass46aaad02017-06-15 21:37:52 -060016#include <mapmem.h>
Simon Glass3e9fd242013-11-10 10:27:01 -070017#include <os.h>
Joe Hershberger5c89d6d2012-12-11 22:16:29 -060018#include <serial.h>
Jean-Christophe PLAGNIOL-VILLARD2a7a0312009-05-16 12:14:54 +020019#include <stdio_dev.h>
wdenk874ac262003-07-24 23:38:38 +000020#include <exports.h>
Simon Glass9d1f6192019-08-02 09:44:25 -060021#include <env_internal.h>
Simon Glassffafbe32023-10-01 19:15:23 -060022#include <video_console.h>
Andreas J. Reichel982ca462016-07-13 12:56:51 +020023#include <watchdog.h>
Simon Glass3ba929a2020-10-30 21:38:53 -060024#include <asm/global_data.h>
Simon Glassdbd79542020-05-10 11:40:11 -060025#include <linux/delay.h>
wdenk47d1a6e2002-11-03 00:01:44 +000026
Wolfgang Denk6405a152006-03-31 18:32:53 +020027DECLARE_GLOBAL_DATA_PTR;
28
Simon Glassffafbe32023-10-01 19:15:23 -060029#define CSI "\x1b["
30
Joe Hershberger5c89d6d2012-12-11 22:16:29 -060031static int on_console(const char *name, const char *value, enum env_op op,
32 int flags)
33{
34 int console = -1;
35
36 /* Check for console redirection */
37 if (strcmp(name, "stdin") == 0)
38 console = stdin;
39 else if (strcmp(name, "stdout") == 0)
40 console = stdout;
41 else if (strcmp(name, "stderr") == 0)
42 console = stderr;
43
44 /* if not actually setting a console variable, we don't care */
45 if (console == -1 || (gd->flags & GD_FLG_DEVINIT) == 0)
46 return 0;
47
48 switch (op) {
49 case env_op_create:
50 case env_op_overwrite:
51
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +010052 if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
53 if (iomux_doenv(console, value))
54 return 1;
55 } else {
56 /* Try assigning specified device */
57 if (console_assign(console, value) < 0)
58 return 1;
59 }
60
Joe Hershberger5c89d6d2012-12-11 22:16:29 -060061 return 0;
62
63 case env_op_delete:
64 if ((flags & H_FORCE) == 0)
65 printf("Can't delete \"%s\"\n", name);
66 return 1;
67
68 default:
69 return 0;
70 }
71}
72U_BOOT_ENV_CALLBACK(console, on_console);
73
Joe Hershberger03ddaba2012-12-11 22:16:30 -060074#ifdef CONFIG_SILENT_CONSOLE
75static int on_silent(const char *name, const char *value, enum env_op op,
76 int flags)
77{
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +010078 if (!CONFIG_IS_ENABLED(SILENT_CONSOLE_UPDATE_ON_SET))
79 if (flags & H_INTERACTIVE)
80 return 0;
81
82 if (!CONFIG_IS_ENABLED(SILENT_CONSOLE_UPDATE_ON_RELOC))
83 if ((flags & H_INTERACTIVE) == 0)
84 return 0;
Joe Hershberger03ddaba2012-12-11 22:16:30 -060085
86 if (value != NULL)
87 gd->flags |= GD_FLG_SILENT;
88 else
89 gd->flags &= ~GD_FLG_SILENT;
90
91 return 0;
92}
93U_BOOT_ENV_CALLBACK(silent, on_silent);
94#endif
95
Patrick Delaunayc20847f2020-12-18 12:46:45 +010096#ifdef CONFIG_CONSOLE_RECORD
97/* helper function: access to gd->console_out and gd->console_in */
98static void console_record_putc(const char c)
99{
100 if (!(gd->flags & GD_FLG_RECORD))
101 return;
Simon Glassd6ed4af2021-05-08 06:59:56 -0600102 if (gd->console_out.start &&
103 !membuff_putbyte((struct membuff *)&gd->console_out, c))
104 gd->flags |= GD_FLG_RECORD_OVF;
Patrick Delaunayc20847f2020-12-18 12:46:45 +0100105}
106
107static void console_record_puts(const char *s)
108{
109 if (!(gd->flags & GD_FLG_RECORD))
110 return;
Simon Glassd6ed4af2021-05-08 06:59:56 -0600111 if (gd->console_out.start) {
112 int len = strlen(s);
113
114 if (membuff_put((struct membuff *)&gd->console_out, s, len) !=
115 len)
116 gd->flags |= GD_FLG_RECORD_OVF;
117 }
Patrick Delaunayc20847f2020-12-18 12:46:45 +0100118}
119
120static int console_record_getc(void)
121{
122 if (!(gd->flags & GD_FLG_RECORD))
123 return -1;
124 if (!gd->console_in.start)
125 return -1;
126
127 return membuff_getbyte((struct membuff *)&gd->console_in);
128}
129
130static int console_record_tstc(void)
131{
132 if (!(gd->flags & GD_FLG_RECORD))
133 return 0;
134 if (gd->console_in.start) {
135 if (membuff_peekbyte((struct membuff *)&gd->console_in) != -1)
136 return 1;
137 }
138 return 0;
139}
140#else
141static void console_record_putc(char c)
142{
143}
144
145static void console_record_puts(const char *s)
146{
147}
148
149static int console_record_getc(void)
150{
151 return -1;
152}
153
154static int console_record_tstc(void)
155{
156 return 0;
157}
158#endif
159
Simon Glassdfc25352017-01-16 07:03:26 -0700160#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
wdenk47d1a6e2002-11-03 00:01:44 +0000161/*
162 * if overwrite_console returns 1, the stdin, stderr and stdout
163 * are switched to the serial port, else the settings in the
164 * environment are used
165 */
Jean-Christophe PLAGNIOL-VILLARD03836942008-10-16 15:01:15 +0200166#ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100167extern int overwrite_console(void);
168#define OVERWRITE_CONSOLE overwrite_console()
wdenk47d1a6e2002-11-03 00:01:44 +0000169#else
wdenk61c636e2005-03-31 18:42:15 +0000170#define OVERWRITE_CONSOLE 0
Jean-Christophe PLAGNIOL-VILLARD03836942008-10-16 15:01:15 +0200171#endif /* CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE */
wdenk47d1a6e2002-11-03 00:01:44 +0000172
Simon Glassdfc25352017-01-16 07:03:26 -0700173#endif /* CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */
wdenk47d1a6e2002-11-03 00:01:44 +0000174
Jean-Christophe PLAGNIOL-VILLARD2a7a0312009-05-16 12:14:54 +0200175static int console_setfile(int file, struct stdio_dev * dev)
wdenk47d1a6e2002-11-03 00:01:44 +0000176{
177 int error = 0;
178
179 if (dev == NULL)
180 return -1;
181
182 switch (file) {
183 case stdin:
184 case stdout:
185 case stderr:
Andy Shevchenko2bce0212020-12-21 14:30:00 +0200186 error = console_start(file, dev);
187 if (error)
188 break;
wdenk47d1a6e2002-11-03 00:01:44 +0000189
190 /* Assign the new device (leaving the existing one started) */
191 stdio_devices[file] = dev;
192
193 /*
194 * Update monitor functions
195 * (to use the console stuff by other applications)
196 */
197 switch (file) {
198 case stdin:
Heinrich Schuchardtc4954fb2020-10-07 18:11:48 +0200199 gd->jt->getc = getchar;
Martin Dorwigcb2c2862015-01-26 15:22:54 -0700200 gd->jt->tstc = tstc;
wdenk47d1a6e2002-11-03 00:01:44 +0000201 break;
202 case stdout:
Martin Dorwigcb2c2862015-01-26 15:22:54 -0700203 gd->jt->putc = putc;
204 gd->jt->puts = puts;
Pali Rohár5aceb262022-09-05 11:31:17 +0200205 STDIO_DEV_ASSIGN_FLUSH(gd->jt, flush);
Martin Dorwigcb2c2862015-01-26 15:22:54 -0700206 gd->jt->printf = printf;
wdenk47d1a6e2002-11-03 00:01:44 +0000207 break;
208 }
209 break;
210
211 default: /* Invalid file ID */
212 error = -1;
213 }
214 return error;
215}
216
Simon Glass045e4b52017-07-27 09:31:03 -0600217/**
218 * console_dev_is_serial() - Check if a stdio device is a serial device
219 *
220 * @sdev: Device to check
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100221 * Return: true if this device is in the serial uclass (or for pre-driver-model,
Simon Glass10a7fe92017-07-27 09:31:04 -0600222 * whether it is called "serial".
Simon Glass045e4b52017-07-27 09:31:03 -0600223 */
224static bool console_dev_is_serial(struct stdio_dev *sdev)
225{
226 bool is_serial;
227
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100228 if (IS_ENABLED(CONFIG_DM_SERIAL) && (sdev->flags & DEV_FLAGS_DM)) {
Simon Glass10a7fe92017-07-27 09:31:04 -0600229 struct udevice *dev = sdev->priv;
230
231 is_serial = device_get_uclass_id(dev) == UCLASS_SERIAL;
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100232 } else {
233 is_serial = !strcmp(sdev->name, "serial");
234 }
Simon Glass045e4b52017-07-27 09:31:03 -0600235
236 return is_serial;
237}
238
Simon Glassdfc25352017-01-16 07:03:26 -0700239#if CONFIG_IS_ENABLED(CONSOLE_MUX)
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100240/** Console I/O multiplexing *******************************************/
241
Patrick Delaunay4e8d61f2020-12-18 12:46:46 +0100242/* tstcdev: save the last stdio device with pending characters, with tstc != 0 */
Jean-Christophe PLAGNIOL-VILLARD2a7a0312009-05-16 12:14:54 +0200243static struct stdio_dev *tstcdev;
244struct stdio_dev **console_devices[MAX_FILES];
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100245int cd_count[MAX_FILES];
246
Andy Shevchenkoba69b2c2021-02-11 17:09:39 +0200247static void console_devices_set(int file, struct stdio_dev *dev)
Patrick Delaunay7c5f6ed2020-12-18 12:46:44 +0100248{
249 console_devices[file][0] = dev;
Andy Shevchenkof1a852a2021-02-11 17:09:38 +0200250 cd_count[file] = 1;
Patrick Delaunay7c5f6ed2020-12-18 12:46:44 +0100251}
252
Andy Shevchenkobdb0d4c2020-12-21 14:30:01 +0200253/**
254 * console_needs_start_stop() - check if we need to start or stop the STDIO device
255 * @file: STDIO file
256 * @sdev: STDIO device in question
257 *
258 * This function checks if we need to start or stop the stdio device used for
259 * a console. For IOMUX case it simply enforces one time start and one time
260 * stop of the device independently of how many STDIO files are using it. In
261 * other words, we start console once before first STDIO device wants it and
262 * stop after the last is gone.
263 */
264static bool console_needs_start_stop(int file, struct stdio_dev *sdev)
265{
Andy Shevchenko75039f52021-02-11 17:09:41 +0200266 int i;
Andy Shevchenkobdb0d4c2020-12-21 14:30:01 +0200267
268 for (i = 0; i < ARRAY_SIZE(cd_count); i++) {
269 if (i == file)
270 continue;
271
Andy Shevchenko75039f52021-02-11 17:09:41 +0200272 if (iomux_match_device(console_devices[i], cd_count[i], sdev) >= 0)
273 return false;
Andy Shevchenkobdb0d4c2020-12-21 14:30:01 +0200274 }
275 return true;
276}
277
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100278/*
Heinrich Schuchardtc4954fb2020-10-07 18:11:48 +0200279 * This depends on tstc() always being called before getchar().
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100280 * This is guaranteed to be true because this routine is called
281 * only from fgetc() which assures it.
282 * No attempt is made to demultiplex multiple input sources.
283 */
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100284static int console_getc(int file)
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100285{
286 unsigned char ret;
287
288 /* This is never called with testcdev == NULL */
Simon Glass0d1e1f72014-07-23 06:54:59 -0600289 ret = tstcdev->getc(tstcdev);
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100290 tstcdev = NULL;
291 return ret;
292}
293
Patrick Delaunay4e8d61f2020-12-18 12:46:46 +0100294/* Upper layer may have already called tstc(): check the saved result */
295static bool console_has_tstc(void)
296{
297 return !!tstcdev;
298}
299
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100300static int console_tstc(int file)
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100301{
302 int i, ret;
Jean-Christophe PLAGNIOL-VILLARD2a7a0312009-05-16 12:14:54 +0200303 struct stdio_dev *dev;
Joe Hershbergerc2f39542018-07-02 20:06:48 -0500304 int prev;
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100305
Joe Hershbergerc2f39542018-07-02 20:06:48 -0500306 prev = disable_ctrlc(1);
Andy Shevchenkoe29d0192021-02-11 17:09:42 +0200307 for_each_console_dev(i, file, dev) {
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100308 if (dev->tstc != NULL) {
Simon Glass0d1e1f72014-07-23 06:54:59 -0600309 ret = dev->tstc(dev);
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100310 if (ret > 0) {
311 tstcdev = dev;
Joe Hershbergerc2f39542018-07-02 20:06:48 -0500312 disable_ctrlc(prev);
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100313 return ret;
314 }
315 }
316 }
Joe Hershbergerc2f39542018-07-02 20:06:48 -0500317 disable_ctrlc(prev);
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100318
319 return 0;
320}
321
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100322static void console_putc(int file, const char c)
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100323{
324 int i;
Jean-Christophe PLAGNIOL-VILLARD2a7a0312009-05-16 12:14:54 +0200325 struct stdio_dev *dev;
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100326
Andy Shevchenkoe29d0192021-02-11 17:09:42 +0200327 for_each_console_dev(i, file, dev) {
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100328 if (dev->putc != NULL)
Simon Glass0d1e1f72014-07-23 06:54:59 -0600329 dev->putc(dev, c);
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100330 }
331}
332
Simon Glass66ee8172020-07-02 21:12:13 -0600333/**
334 * console_puts_select() - Output a string to all console devices
335 *
336 * @file: File number to output to (e,g, stdout, see stdio.h)
337 * @serial_only: true to output only to serial, false to output to everything
338 * else
339 * @s: String to output
340 */
341static void console_puts_select(int file, bool serial_only, const char *s)
Siarhei Siamashka616d03e2015-01-08 09:02:31 +0200342{
343 int i;
344 struct stdio_dev *dev;
345
Andy Shevchenkoe29d0192021-02-11 17:09:42 +0200346 for_each_console_dev(i, file, dev) {
347 bool is_serial = console_dev_is_serial(dev);
Simon Glass66ee8172020-07-02 21:12:13 -0600348
Simon Glass66ee8172020-07-02 21:12:13 -0600349 if (dev->puts && serial_only == is_serial)
Hans de Goedee355da02015-05-05 13:13:36 +0200350 dev->puts(dev, s);
Siarhei Siamashka616d03e2015-01-08 09:02:31 +0200351 }
352}
Siarhei Siamashka616d03e2015-01-08 09:02:31 +0200353
Simon Glass66ee8172020-07-02 21:12:13 -0600354void console_puts_select_stderr(bool serial_only, const char *s)
355{
Simon Glassc7ba6c82021-11-19 13:23:47 -0700356 if (gd->flags & GD_FLG_DEVINIT)
357 console_puts_select(stderr, serial_only, s);
Simon Glass66ee8172020-07-02 21:12:13 -0600358}
359
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100360static void console_puts(int file, const char *s)
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100361{
362 int i;
Jean-Christophe PLAGNIOL-VILLARD2a7a0312009-05-16 12:14:54 +0200363 struct stdio_dev *dev;
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100364
Andy Shevchenkoe29d0192021-02-11 17:09:42 +0200365 for_each_console_dev(i, file, dev) {
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100366 if (dev->puts != NULL)
Simon Glass0d1e1f72014-07-23 06:54:59 -0600367 dev->puts(dev, s);
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100368 }
369}
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100370
Pali Rohár5aceb262022-09-05 11:31:17 +0200371#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
372static void console_flush(int file)
373{
374 int i;
375 struct stdio_dev *dev;
376
377 for_each_console_dev(i, file, dev) {
378 if (dev->flush != NULL)
379 dev->flush(dev);
380 }
381}
382#endif
383
Tom Rinid30aeb12019-10-30 09:18:43 -0400384#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
Jean-Christophe PLAGNIOL-VILLARD2a7a0312009-05-16 12:14:54 +0200385static inline void console_doenv(int file, struct stdio_dev *dev)
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100386{
387 iomux_doenv(file, dev->name);
388}
Tom Rinid30aeb12019-10-30 09:18:43 -0400389#endif
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100390#else
Patrick Delaunay7c5f6ed2020-12-18 12:46:44 +0100391
Andy Shevchenkoba69b2c2021-02-11 17:09:39 +0200392static void console_devices_set(int file, struct stdio_dev *dev)
Patrick Delaunay7c5f6ed2020-12-18 12:46:44 +0100393{
394}
395
Andy Shevchenkobdb0d4c2020-12-21 14:30:01 +0200396static inline bool console_needs_start_stop(int file, struct stdio_dev *sdev)
397{
398 return true;
399}
400
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100401static inline int console_getc(int file)
402{
Simon Glass0d1e1f72014-07-23 06:54:59 -0600403 return stdio_devices[file]->getc(stdio_devices[file]);
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100404}
405
Patrick Delaunay4e8d61f2020-12-18 12:46:46 +0100406static bool console_has_tstc(void)
407{
408 return false;
409}
410
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100411static inline int console_tstc(int file)
412{
Simon Glass0d1e1f72014-07-23 06:54:59 -0600413 return stdio_devices[file]->tstc(stdio_devices[file]);
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100414}
415
416static inline void console_putc(int file, const char c)
417{
Simon Glass0d1e1f72014-07-23 06:54:59 -0600418 stdio_devices[file]->putc(stdio_devices[file], c);
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100419}
420
Simon Glass66ee8172020-07-02 21:12:13 -0600421void console_puts_select(int file, bool serial_only, const char *s)
Siarhei Siamashka616d03e2015-01-08 09:02:31 +0200422{
Simon Glassc7ba6c82021-11-19 13:23:47 -0700423 if ((gd->flags & GD_FLG_DEVINIT) &&
424 serial_only == console_dev_is_serial(stdio_devices[file]))
Hans de Goedee355da02015-05-05 13:13:36 +0200425 stdio_devices[file]->puts(stdio_devices[file], s);
Siarhei Siamashka616d03e2015-01-08 09:02:31 +0200426}
Siarhei Siamashka616d03e2015-01-08 09:02:31 +0200427
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100428static inline void console_puts(int file, const char *s)
429{
Simon Glass0d1e1f72014-07-23 06:54:59 -0600430 stdio_devices[file]->puts(stdio_devices[file], s);
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100431}
Pali Rohár5aceb262022-09-05 11:31:17 +0200432
433#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
434static inline void console_flush(int file)
435{
436 if (stdio_devices[file]->flush)
437 stdio_devices[file]->flush(stdio_devices[file]);
438}
439#endif
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100440
Tom Rinid30aeb12019-10-30 09:18:43 -0400441#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
Jean-Christophe PLAGNIOL-VILLARD2a7a0312009-05-16 12:14:54 +0200442static inline void console_doenv(int file, struct stdio_dev *dev)
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100443{
444 console_setfile(file, dev);
445}
Tom Rinid30aeb12019-10-30 09:18:43 -0400446#endif
Simon Glassdfc25352017-01-16 07:03:26 -0700447#endif /* CONIFIG_IS_ENABLED(CONSOLE_MUX) */
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100448
Andy Shevchenkoba69b2c2021-02-11 17:09:39 +0200449static void __maybe_unused console_setfile_and_devices(int file, struct stdio_dev *dev)
450{
451 console_setfile(file, dev);
452 console_devices_set(file, dev);
453}
454
Andy Shevchenko2bce0212020-12-21 14:30:00 +0200455int console_start(int file, struct stdio_dev *sdev)
456{
457 int error;
458
Andy Shevchenkobdb0d4c2020-12-21 14:30:01 +0200459 if (!console_needs_start_stop(file, sdev))
460 return 0;
461
Andy Shevchenko2bce0212020-12-21 14:30:00 +0200462 /* Start new device */
463 if (sdev->start) {
464 error = sdev->start(sdev);
465 /* If it's not started don't use it */
466 if (error < 0)
467 return error;
468 }
469 return 0;
470}
471
472void console_stop(int file, struct stdio_dev *sdev)
473{
Andy Shevchenkobdb0d4c2020-12-21 14:30:01 +0200474 if (!console_needs_start_stop(file, sdev))
475 return;
476
Andy Shevchenko2bce0212020-12-21 14:30:00 +0200477 if (sdev->stop)
478 sdev->stop(sdev);
479}
480
wdenk47d1a6e2002-11-03 00:01:44 +0000481/** U-Boot INITIAL CONSOLE-NOT COMPATIBLE FUNCTIONS *************************/
482
Wolfgang Denk318ef5c2010-06-20 17:14:14 +0200483int serial_printf(const char *fmt, ...)
wdenk47d1a6e2002-11-03 00:01:44 +0000484{
485 va_list args;
486 uint i;
Jean-Christophe PLAGNIOL-VILLARD03836942008-10-16 15:01:15 +0200487 char printbuffer[CONFIG_SYS_PBSIZE];
wdenk47d1a6e2002-11-03 00:01:44 +0000488
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100489 va_start(args, fmt);
wdenk47d1a6e2002-11-03 00:01:44 +0000490
491 /* For this to work, printbuffer must be larger than
492 * anything we ever want to print.
493 */
Sonny Rao2813a212011-10-10 09:22:31 +0000494 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100495 va_end(args);
wdenk47d1a6e2002-11-03 00:01:44 +0000496
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100497 serial_puts(printbuffer);
Wolfgang Denk318ef5c2010-06-20 17:14:14 +0200498 return i;
wdenk47d1a6e2002-11-03 00:01:44 +0000499}
500
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100501int fgetc(int file)
wdenk47d1a6e2002-11-03 00:01:44 +0000502{
Heinrich Schuchardt1bc421b2022-10-22 11:32:34 +0200503 if ((unsigned int)file < MAX_FILES) {
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100504 /*
505 * Effectively poll for input wherever it may be available.
506 */
507 for (;;) {
Stefan Roese80877fa2022-09-02 14:10:46 +0200508 schedule();
Patrick Delaunay4e8d61f2020-12-18 12:46:46 +0100509 if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
510 /*
511 * Upper layer may have already called tstc() so
512 * check for that first.
513 */
514 if (console_has_tstc())
515 return console_getc(file);
516 console_tstc(file);
517 } else {
518 if (console_tstc(file))
519 return console_getc(file);
520 }
521
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100522 /*
523 * If the watchdog must be rate-limited then it should
524 * already be handled in board-specific code.
525 */
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100526 if (IS_ENABLED(CONFIG_WATCHDOG))
527 udelay(1);
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100528 }
Gary Jennejohnc6dc7552008-11-06 15:04:23 +0100529 }
wdenk47d1a6e2002-11-03 00:01:44 +0000530
531 return -1;
532}
533
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100534int ftstc(int file)
wdenk47d1a6e2002-11-03 00:01:44 +0000535{
Heinrich Schuchardt1bc421b2022-10-22 11:32:34 +0200536 if ((unsigned int)file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100537 return console_tstc(file);
wdenk47d1a6e2002-11-03 00:01:44 +0000538
539 return -1;
540}
541
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100542void fputc(int file, const char c)
wdenk47d1a6e2002-11-03 00:01:44 +0000543{
Heinrich Schuchardt1bc421b2022-10-22 11:32:34 +0200544 if ((unsigned int)file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100545 console_putc(file, c);
wdenk47d1a6e2002-11-03 00:01:44 +0000546}
547
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100548void fputs(int file, const char *s)
wdenk47d1a6e2002-11-03 00:01:44 +0000549{
Heinrich Schuchardt1bc421b2022-10-22 11:32:34 +0200550 if ((unsigned int)file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +0100551 console_puts(file, s);
wdenk47d1a6e2002-11-03 00:01:44 +0000552}
553
Pali Rohár5aceb262022-09-05 11:31:17 +0200554#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
555void fflush(int file)
556{
Heinrich Schuchardt1bc421b2022-10-22 11:32:34 +0200557 if ((unsigned int)file < MAX_FILES)
Pali Rohár5aceb262022-09-05 11:31:17 +0200558 console_flush(file);
559}
560#endif
561
Wolfgang Denk318ef5c2010-06-20 17:14:14 +0200562int fprintf(int file, const char *fmt, ...)
wdenk47d1a6e2002-11-03 00:01:44 +0000563{
564 va_list args;
565 uint i;
Jean-Christophe PLAGNIOL-VILLARD03836942008-10-16 15:01:15 +0200566 char printbuffer[CONFIG_SYS_PBSIZE];
wdenk47d1a6e2002-11-03 00:01:44 +0000567
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100568 va_start(args, fmt);
wdenk47d1a6e2002-11-03 00:01:44 +0000569
570 /* For this to work, printbuffer must be larger than
571 * anything we ever want to print.
572 */
Sonny Rao2813a212011-10-10 09:22:31 +0000573 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100574 va_end(args);
wdenk47d1a6e2002-11-03 00:01:44 +0000575
576 /* Send to desired file */
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100577 fputs(file, printbuffer);
Wolfgang Denk318ef5c2010-06-20 17:14:14 +0200578 return i;
wdenk47d1a6e2002-11-03 00:01:44 +0000579}
580
581/** U-Boot INITIAL CONSOLE-COMPATIBLE FUNCTION *****************************/
582
Heinrich Schuchardtc4954fb2020-10-07 18:11:48 +0200583int getchar(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000584{
Patrick Delaunayc20847f2020-12-18 12:46:45 +0100585 int ch;
586
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100587 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jackson5de56212008-08-25 19:21:30 +0100588 return 0;
Mark Jackson5de56212008-08-25 19:21:30 +0100589
Graeme Russ70600b02011-08-29 02:14:05 +0000590 if (!gd->have_console)
591 return 0;
592
Patrick Delaunayc20847f2020-12-18 12:46:45 +0100593 ch = console_record_getc();
594 if (ch != -1)
595 return ch;
Simon Glass1bb49232015-11-08 23:47:48 -0700596
wdenk47d1a6e2002-11-03 00:01:44 +0000597 if (gd->flags & GD_FLG_DEVINIT) {
598 /* Get from the standard input */
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100599 return fgetc(stdin);
wdenk47d1a6e2002-11-03 00:01:44 +0000600 }
601
602 /* Send directly to the handler */
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100603 return serial_getc();
wdenk47d1a6e2002-11-03 00:01:44 +0000604}
605
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100606int tstc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000607{
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100608 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jackson5de56212008-08-25 19:21:30 +0100609 return 0;
Mark Jackson5de56212008-08-25 19:21:30 +0100610
Graeme Russ70600b02011-08-29 02:14:05 +0000611 if (!gd->have_console)
612 return 0;
Patrick Delaunayc20847f2020-12-18 12:46:45 +0100613
614 if (console_record_tstc())
615 return 1;
616
wdenk47d1a6e2002-11-03 00:01:44 +0000617 if (gd->flags & GD_FLG_DEVINIT) {
618 /* Test the standard input */
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100619 return ftstc(stdin);
wdenk47d1a6e2002-11-03 00:01:44 +0000620 }
621
622 /* Send directly to the handler */
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100623 return serial_tstc();
wdenk47d1a6e2002-11-03 00:01:44 +0000624}
625
Siarhei Siamashka616d03e2015-01-08 09:02:31 +0200626#define PRE_CONSOLE_FLUSHPOINT1_SERIAL 0
627#define PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL 1
628
Simon Glasse304a5e2016-10-17 20:12:36 -0600629#if CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
Rasmus Villemoesfb35fff2022-05-03 14:37:39 +0200630#define CIRC_BUF_IDX(idx) ((idx) % (unsigned long)CONFIG_VAL(PRE_CON_BUF_SZ))
Graeme Russ3c28f482011-09-01 00:48:27 +0000631
632static void pre_console_putc(const char c)
633{
Simon Glass46aaad02017-06-15 21:37:52 -0600634 char *buffer;
635
Rasmus Villemoese406a612022-05-03 15:13:27 +0200636 if (gd->precon_buf_idx < 0)
637 return;
638
Rasmus Villemoesfb35fff2022-05-03 14:37:39 +0200639 buffer = map_sysmem(CONFIG_VAL(PRE_CON_BUF_ADDR), CONFIG_VAL(PRE_CON_BUF_SZ));
Graeme Russ3c28f482011-09-01 00:48:27 +0000640
641 buffer[CIRC_BUF_IDX(gd->precon_buf_idx++)] = c;
Simon Glass46aaad02017-06-15 21:37:52 -0600642
643 unmap_sysmem(buffer);
Graeme Russ3c28f482011-09-01 00:48:27 +0000644}
645
Soeren Moch54619bb2017-11-04 16:14:09 +0100646static void pre_console_puts(const char *s)
647{
Rasmus Villemoese406a612022-05-03 15:13:27 +0200648 if (gd->precon_buf_idx < 0)
649 return;
650
Soeren Moch54619bb2017-11-04 16:14:09 +0100651 while (*s)
652 pre_console_putc(*s++);
653}
654
Siarhei Siamashka616d03e2015-01-08 09:02:31 +0200655static void print_pre_console_buffer(int flushpoint)
Graeme Russ3c28f482011-09-01 00:48:27 +0000656{
Rasmus Villemoese406a612022-05-03 15:13:27 +0200657 long in = 0, out = 0;
Rasmus Villemoesfb35fff2022-05-03 14:37:39 +0200658 char buf_out[CONFIG_VAL(PRE_CON_BUF_SZ) + 1];
Simon Glass46aaad02017-06-15 21:37:52 -0600659 char *buf_in;
Graeme Russ3c28f482011-09-01 00:48:27 +0000660
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100661 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT))
Patrick Delaunayb39862f2019-08-02 14:58:10 +0200662 return;
Patrick Delaunayb39862f2019-08-02 14:58:10 +0200663
Rasmus Villemoesfb35fff2022-05-03 14:37:39 +0200664 buf_in = map_sysmem(CONFIG_VAL(PRE_CON_BUF_ADDR), CONFIG_VAL(PRE_CON_BUF_SZ));
665 if (gd->precon_buf_idx > CONFIG_VAL(PRE_CON_BUF_SZ))
666 in = gd->precon_buf_idx - CONFIG_VAL(PRE_CON_BUF_SZ);
Graeme Russ3c28f482011-09-01 00:48:27 +0000667
Hans de Goedee355da02015-05-05 13:13:36 +0200668 while (in < gd->precon_buf_idx)
669 buf_out[out++] = buf_in[CIRC_BUF_IDX(in++)];
Simon Glass46aaad02017-06-15 21:37:52 -0600670 unmap_sysmem(buf_in);
Hans de Goedee355da02015-05-05 13:13:36 +0200671
672 buf_out[out] = 0;
673
Rasmus Villemoese406a612022-05-03 15:13:27 +0200674 gd->precon_buf_idx = -1;
Hans de Goedee355da02015-05-05 13:13:36 +0200675 switch (flushpoint) {
676 case PRE_CONSOLE_FLUSHPOINT1_SERIAL:
677 puts(buf_out);
678 break;
679 case PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL:
Simon Glass66ee8172020-07-02 21:12:13 -0600680 console_puts_select(stdout, false, buf_out);
Hans de Goedee355da02015-05-05 13:13:36 +0200681 break;
682 }
Rasmus Villemoese406a612022-05-03 15:13:27 +0200683 gd->precon_buf_idx = in;
Graeme Russ3c28f482011-09-01 00:48:27 +0000684}
685#else
686static inline void pre_console_putc(const char c) {}
Soeren Moch54619bb2017-11-04 16:14:09 +0100687static inline void pre_console_puts(const char *s) {}
Siarhei Siamashka616d03e2015-01-08 09:02:31 +0200688static inline void print_pre_console_buffer(int flushpoint) {}
Graeme Russ3c28f482011-09-01 00:48:27 +0000689#endif
690
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100691void putc(const char c)
wdenk47d1a6e2002-11-03 00:01:44 +0000692{
Patrick Delaunay8f14b402020-11-27 11:20:56 +0100693 if (!gd)
694 return;
Patrick Delaunayc20847f2020-12-18 12:46:45 +0100695
696 console_record_putc(c);
697
Simon Glass16e3d7c2017-12-04 13:48:19 -0700698 /* sandbox can send characters to stdout before it has a console */
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100699 if (IS_ENABLED(CONFIG_SANDBOX) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glass16e3d7c2017-12-04 13:48:19 -0700700 os_putc(c);
701 return;
702 }
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100703
Simon Glass7dd27e02015-06-23 15:38:33 -0600704 /* if we don't have a console yet, use the debug UART */
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100705 if (IS_ENABLED(CONFIG_DEBUG_UART) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glass7dd27e02015-06-23 15:38:33 -0600706 printch(c);
707 return;
708 }
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100709
710 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT)) {
Patrick Delaunayb39862f2019-08-02 14:58:10 +0200711 if (!(gd->flags & GD_FLG_DEVINIT))
712 pre_console_putc(c);
wdenk927034e2004-02-08 19:38:38 +0000713 return;
Patrick Delaunayb39862f2019-08-02 14:58:10 +0200714 }
wdenk4b6e9052004-02-06 21:48:22 +0000715
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100716 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jackson5de56212008-08-25 19:21:30 +0100717 return;
Mark Jackson5de56212008-08-25 19:21:30 +0100718
Graeme Russ70600b02011-08-29 02:14:05 +0000719 if (!gd->have_console)
Graeme Russ3c28f482011-09-01 00:48:27 +0000720 return pre_console_putc(c);
Graeme Russ70600b02011-08-29 02:14:05 +0000721
wdenk47d1a6e2002-11-03 00:01:44 +0000722 if (gd->flags & GD_FLG_DEVINIT) {
723 /* Send to the standard output */
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100724 fputc(stdout, c);
wdenk47d1a6e2002-11-03 00:01:44 +0000725 } else {
726 /* Send directly to the handler */
Siarhei Siamashka616d03e2015-01-08 09:02:31 +0200727 pre_console_putc(c);
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100728 serial_putc(c);
wdenk47d1a6e2002-11-03 00:01:44 +0000729 }
730}
731
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100732void puts(const char *s)
wdenk47d1a6e2002-11-03 00:01:44 +0000733{
Patrick Delaunay8f14b402020-11-27 11:20:56 +0100734 if (!gd)
735 return;
Patrick Delaunayc20847f2020-12-18 12:46:45 +0100736
737 console_record_puts(s);
738
Simon Glassbf5c4862018-11-15 18:44:04 -0700739 /* sandbox can send characters to stdout before it has a console */
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100740 if (IS_ENABLED(CONFIG_SANDBOX) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glassbf5c4862018-11-15 18:44:04 -0700741 os_puts(s);
742 return;
743 }
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100744
745 if (IS_ENABLED(CONFIG_DEBUG_UART) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Soeren Moch54619bb2017-11-04 16:14:09 +0100746 while (*s) {
747 int ch = *s++;
748
749 printch(ch);
750 }
751 return;
752 }
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100753
754 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT)) {
Patrick Delaunayb39862f2019-08-02 14:58:10 +0200755 if (!(gd->flags & GD_FLG_DEVINIT))
756 pre_console_puts(s);
Soeren Moch54619bb2017-11-04 16:14:09 +0100757 return;
Patrick Delaunayb39862f2019-08-02 14:58:10 +0200758 }
Soeren Moch54619bb2017-11-04 16:14:09 +0100759
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100760 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Soeren Moch54619bb2017-11-04 16:14:09 +0100761 return;
Soeren Moch54619bb2017-11-04 16:14:09 +0100762
763 if (!gd->have_console)
764 return pre_console_puts(s);
765
766 if (gd->flags & GD_FLG_DEVINIT) {
767 /* Send to the standard output */
768 fputs(stdout, s);
769 } else {
770 /* Send directly to the handler */
771 pre_console_puts(s);
772 serial_puts(s);
773 }
wdenk47d1a6e2002-11-03 00:01:44 +0000774}
Pali Rohár5aceb262022-09-05 11:31:17 +0200775
776#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
777void flush(void)
778{
779 if (!gd)
780 return;
781
782 /* sandbox can send characters to stdout before it has a console */
783 if (IS_ENABLED(CONFIG_SANDBOX) && !(gd->flags & GD_FLG_SERIAL_READY)) {
784 os_flush();
785 return;
786 }
787
788 if (IS_ENABLED(CONFIG_DEBUG_UART) && !(gd->flags & GD_FLG_SERIAL_READY))
789 return;
790
791 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT))
792 return;
793
794 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
795 return;
796
797 if (!gd->have_console)
798 return;
799
800 if (gd->flags & GD_FLG_DEVINIT) {
801 /* Send to the standard output */
802 fflush(stdout);
Pali Rohára48a24f2022-09-05 11:31:19 +0200803 } else {
804 /* Send directly to the handler */
805 serial_flush();
Pali Rohár5aceb262022-09-05 11:31:17 +0200806 }
807}
808#endif
wdenk47d1a6e2002-11-03 00:01:44 +0000809
Simon Glass1bb49232015-11-08 23:47:48 -0700810#ifdef CONFIG_CONSOLE_RECORD
811int console_record_init(void)
812{
813 int ret;
814
Heinrich Schuchardt3b05a262020-02-12 18:23:49 +0100815 ret = membuff_new((struct membuff *)&gd->console_out,
Simon Glass9803ddf2021-10-23 17:26:03 -0600816 gd->flags & GD_FLG_RELOC ?
817 CONFIG_CONSOLE_RECORD_OUT_SIZE :
818 CONFIG_CONSOLE_RECORD_OUT_SIZE_F);
Simon Glass1bb49232015-11-08 23:47:48 -0700819 if (ret)
820 return ret;
Heinrich Schuchardt3b05a262020-02-12 18:23:49 +0100821 ret = membuff_new((struct membuff *)&gd->console_in,
822 CONFIG_CONSOLE_RECORD_IN_SIZE);
Simon Glass1bb49232015-11-08 23:47:48 -0700823
Ion Agorriac0b0de42024-01-05 09:22:09 +0200824 /* Start recording from the beginning */
825 gd->flags |= GD_FLG_RECORD;
826
Simon Glass1bb49232015-11-08 23:47:48 -0700827 return ret;
828}
829
830void console_record_reset(void)
831{
Heinrich Schuchardt3b05a262020-02-12 18:23:49 +0100832 membuff_purge((struct membuff *)&gd->console_out);
833 membuff_purge((struct membuff *)&gd->console_in);
Simon Glassd6ed4af2021-05-08 06:59:56 -0600834 gd->flags &= ~GD_FLG_RECORD_OVF;
Simon Glass1bb49232015-11-08 23:47:48 -0700835}
836
Simon Glassdc357ef2020-07-28 19:41:11 -0600837int console_record_reset_enable(void)
Simon Glass1bb49232015-11-08 23:47:48 -0700838{
839 console_record_reset();
840 gd->flags |= GD_FLG_RECORD;
Simon Glassdc357ef2020-07-28 19:41:11 -0600841
842 return 0;
Simon Glass1bb49232015-11-08 23:47:48 -0700843}
Simon Glassb17c1582020-01-27 08:49:54 -0700844
845int console_record_readline(char *str, int maxlen)
846{
Simon Glassd6ed4af2021-05-08 06:59:56 -0600847 if (gd->flags & GD_FLG_RECORD_OVF)
848 return -ENOSPC;
849
Heinrich Schuchardt3b05a262020-02-12 18:23:49 +0100850 return membuff_readline((struct membuff *)&gd->console_out, str,
Ion Agorria7e06c1f2024-01-05 09:22:10 +0200851 maxlen, '\0', false);
Simon Glassb17c1582020-01-27 08:49:54 -0700852}
853
854int console_record_avail(void)
855{
Heinrich Schuchardt3b05a262020-02-12 18:23:49 +0100856 return membuff_avail((struct membuff *)&gd->console_out);
Simon Glassb17c1582020-01-27 08:49:54 -0700857}
858
Ion Agorria15f6d6a2024-01-05 09:22:08 +0200859bool console_record_isempty(void)
860{
861 return membuff_isempty((struct membuff *)&gd->console_out);
862}
863
Steffen Jaeckele1788f92021-07-08 15:57:40 +0200864int console_in_puts(const char *str)
865{
866 return membuff_put((struct membuff *)&gd->console_in, str, strlen(str));
867}
868
Simon Glass1bb49232015-11-08 23:47:48 -0700869#endif
870
wdenk47d1a6e2002-11-03 00:01:44 +0000871/* test if ctrl-c was pressed */
872static int ctrlc_disabled = 0; /* see disable_ctrl() */
873static int ctrlc_was_pressed = 0;
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100874int ctrlc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000875{
wdenk47d1a6e2002-11-03 00:01:44 +0000876 if (!ctrlc_disabled && gd->have_console) {
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100877 if (tstc()) {
Heinrich Schuchardtc4954fb2020-10-07 18:11:48 +0200878 switch (getchar()) {
wdenk47d1a6e2002-11-03 00:01:44 +0000879 case 0x03: /* ^C - Control C */
880 ctrlc_was_pressed = 1;
881 return 1;
882 default:
883 break;
884 }
885 }
886 }
Simon Glass28c5ce72014-09-14 12:40:15 -0600887
wdenk47d1a6e2002-11-03 00:01:44 +0000888 return 0;
889}
Pierre Aubert5fef9d32014-04-24 10:30:07 +0200890/* Reads user's confirmation.
891 Returns 1 if user's input is "y", "Y", "yes" or "YES"
892*/
893int confirm_yesno(void)
894{
895 int i;
896 char str_input[5];
wdenk47d1a6e2002-11-03 00:01:44 +0000897
Pierre Aubert5fef9d32014-04-24 10:30:07 +0200898 /* Flush input */
899 while (tstc())
Heinrich Schuchardtc4954fb2020-10-07 18:11:48 +0200900 getchar();
Pierre Aubert5fef9d32014-04-24 10:30:07 +0200901 i = 0;
902 while (i < sizeof(str_input)) {
Heinrich Schuchardtc4954fb2020-10-07 18:11:48 +0200903 str_input[i] = getchar();
Pierre Aubert5fef9d32014-04-24 10:30:07 +0200904 putc(str_input[i]);
905 if (str_input[i] == '\r')
906 break;
907 i++;
908 }
909 putc('\n');
910 if (strncmp(str_input, "y\r", 2) == 0 ||
911 strncmp(str_input, "Y\r", 2) == 0 ||
912 strncmp(str_input, "yes\r", 4) == 0 ||
913 strncmp(str_input, "YES\r", 4) == 0)
914 return 1;
915 return 0;
916}
wdenk47d1a6e2002-11-03 00:01:44 +0000917/* pass 1 to disable ctrlc() checking, 0 to enable.
918 * returns previous state
919 */
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100920int disable_ctrlc(int disable)
wdenk47d1a6e2002-11-03 00:01:44 +0000921{
922 int prev = ctrlc_disabled; /* save previous state */
923
924 ctrlc_disabled = disable;
925 return prev;
926}
927
928int had_ctrlc (void)
929{
930 return ctrlc_was_pressed;
931}
932
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100933void clear_ctrlc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000934{
935 ctrlc_was_pressed = 0;
936}
937
wdenk47d1a6e2002-11-03 00:01:44 +0000938/** U-Boot INIT FUNCTIONS *************************************************/
939
Andy Shevchenkocfaed7f2020-12-21 14:30:03 +0200940struct stdio_dev *console_search_dev(int flags, const char *name)
Jean-Christophe PLAGNIOL-VILLARD8a4a7842008-08-31 04:24:55 +0200941{
Jean-Christophe PLAGNIOL-VILLARD2a7a0312009-05-16 12:14:54 +0200942 struct stdio_dev *dev;
Jean-Christophe PLAGNIOL-VILLARD8a4a7842008-08-31 04:24:55 +0200943
Jean-Christophe PLAGNIOL-VILLARD2a7a0312009-05-16 12:14:54 +0200944 dev = stdio_get_by_name(name);
Simon Glass86f07462016-02-06 14:31:37 -0700945#ifdef CONFIG_VIDCONSOLE_AS_LCD
Patrick Delaunay60b92242020-07-01 14:56:10 +0200946 if (!dev && !strcmp(name, CONFIG_VIDCONSOLE_AS_NAME))
Simon Glass86f07462016-02-06 14:31:37 -0700947 dev = stdio_get_by_name("vidconsole");
948#endif
Jean-Christophe PLAGNIOL-VILLARD8a4a7842008-08-31 04:24:55 +0200949
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100950 if (dev && (dev->flags & flags))
Jean-Christophe PLAGNIOL-VILLARD8a4a7842008-08-31 04:24:55 +0200951 return dev;
952
953 return NULL;
954}
955
Mike Frysingere3d55722010-10-20 07:18:03 -0400956int console_assign(int file, const char *devname)
wdenk47d1a6e2002-11-03 00:01:44 +0000957{
Jean-Christophe PLAGNIOL-VILLARD8a4a7842008-08-31 04:24:55 +0200958 int flag;
Jean-Christophe PLAGNIOL-VILLARD2a7a0312009-05-16 12:14:54 +0200959 struct stdio_dev *dev;
wdenk47d1a6e2002-11-03 00:01:44 +0000960
961 /* Check for valid file */
Andy Shevchenko59f324c2021-02-11 17:09:37 +0200962 flag = stdio_file_to_flags(file);
963 if (flag < 0)
964 return flag;
wdenk47d1a6e2002-11-03 00:01:44 +0000965
966 /* Check for valid device name */
967
Andy Shevchenkocfaed7f2020-12-21 14:30:03 +0200968 dev = console_search_dev(flag, devname);
wdenk47d1a6e2002-11-03 00:01:44 +0000969
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +0100970 if (dev)
971 return console_setfile(file, dev);
wdenk47d1a6e2002-11-03 00:01:44 +0000972
973 return -1;
974}
975
Patrick Delaunayb39862f2019-08-02 14:58:10 +0200976/* return true if the 'silent' flag is removed */
977static bool console_update_silent(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000978{
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100979 unsigned long flags = gd->flags;
Patrick Delaunayb39862f2019-08-02 14:58:10 +0200980
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100981 if (!IS_ENABLED(CONFIG_SILENT_CONSOLE))
982 return false;
Patrick Delaunayb39862f2019-08-02 14:58:10 +0200983
Harald Seiler6d09df82022-07-06 13:19:10 +0200984 if (IS_ENABLED(CONFIG_SILENT_CONSOLE_UNTIL_ENV) && !(gd->flags & GD_FLG_ENV_READY)) {
985 gd->flags |= GD_FLG_SILENT;
986 return false;
987 }
988
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100989 if (env_get("silent")) {
990 gd->flags |= GD_FLG_SILENT;
991 return false;
Patrick Delaunayb39862f2019-08-02 14:58:10 +0200992 }
Patrick Delaunayb39862f2019-08-02 14:58:10 +0200993
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +0100994 gd->flags &= ~GD_FLG_SILENT;
995
996 return !!(flags & GD_FLG_SILENT);
Simon Glassc9c5c9f2017-06-15 21:37:50 -0600997}
998
999int console_announce_r(void)
1000{
1001#if !CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
1002 char buf[DISPLAY_OPTIONS_BANNER_LENGTH];
1003
1004 display_options_get_banner(false, buf, sizeof(buf));
1005
Simon Glass66ee8172020-07-02 21:12:13 -06001006 console_puts_select(stdout, false, buf);
Simon Glassc9c5c9f2017-06-15 21:37:50 -06001007#endif
1008
1009 return 0;
Chris Packhamfab806d2016-09-23 15:59:43 +12001010}
1011
1012/* Called before relocation - use serial functions */
1013int console_init_f(void)
1014{
1015 gd->have_console = 1;
1016
1017 console_update_silent();
wdenk808532a2003-10-10 10:05:42 +00001018
Siarhei Siamashka616d03e2015-01-08 09:02:31 +02001019 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT1_SERIAL);
Graeme Russ3c28f482011-09-01 00:48:27 +00001020
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +01001021 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +00001022}
1023
Simon Glassffafbe32023-10-01 19:15:23 -06001024int console_clear(void)
1025{
1026 /*
1027 * Send clear screen and home
1028 *
1029 * FIXME(Heinrich Schuchardt <xypron.glpk@gmx.de>): This should go
1030 * through an API and only be written to serial terminals, not video
1031 * displays
1032 */
1033 printf(CSI "2J" CSI "1;1H");
1034 if (IS_ENABLED(CONFIG_VIDEO_ANSI))
1035 return 0;
1036
1037 if (IS_ENABLED(CONFIG_VIDEO)) {
1038 struct udevice *dev;
1039 int ret;
1040
1041 ret = uclass_first_device_err(UCLASS_VIDEO_CONSOLE, &dev);
1042 if (ret)
1043 return ret;
1044 ret = vidconsole_clear_and_reset(dev);
1045 if (ret)
1046 return ret;
1047 }
1048
1049 return 0;
1050}
1051
Bin Meng13186892023-07-23 12:40:35 +08001052static void stdio_print_current_devices(void)
Jean-Christophe PLAGNIOL-VILLARD5a309362009-05-16 12:14:55 +02001053{
Bin Menga6a83502023-07-23 12:40:36 +08001054 char *stdinname, *stdoutname, *stderrname;
1055
Bin Mengd61be5b2023-07-23 12:40:37 +08001056 if (CONFIG_IS_ENABLED(CONSOLE_MUX) &&
1057 CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)) {
1058 /* stdin stdout and stderr are in environment */
1059 stdinname = env_get("stdin");
1060 stdoutname = env_get("stdout");
1061 stderrname = env_get("stderr");
1062
1063 stdinname = stdinname ? : "No input devices available!";
1064 stdoutname = stdoutname ? : "No output devices available!";
1065 stderrname = stderrname ? : "No error devices available!";
1066 } else {
1067 stdinname = stdio_devices[stdin] ?
1068 stdio_devices[stdin]->name :
1069 "No input devices available!";
1070 stdoutname = stdio_devices[stdout] ?
1071 stdio_devices[stdout]->name :
1072 "No output devices available!";
1073 stderrname = stdio_devices[stderr] ?
1074 stdio_devices[stderr]->name :
1075 "No error devices available!";
1076 }
Bin Menga6a83502023-07-23 12:40:36 +08001077
Jean-Christophe PLAGNIOL-VILLARD5a309362009-05-16 12:14:55 +02001078 /* Print information */
1079 puts("In: ");
Bin Menga6a83502023-07-23 12:40:36 +08001080 printf("%s\n", stdinname);
Jean-Christophe PLAGNIOL-VILLARD5a309362009-05-16 12:14:55 +02001081
1082 puts("Out: ");
Bin Menga6a83502023-07-23 12:40:36 +08001083 printf("%s\n", stdoutname);
Jean-Christophe PLAGNIOL-VILLARD5a309362009-05-16 12:14:55 +02001084
1085 puts("Err: ");
Bin Menga6a83502023-07-23 12:40:36 +08001086 printf("%s\n", stderrname);
Jean-Christophe PLAGNIOL-VILLARD5a309362009-05-16 12:14:55 +02001087}
1088
Simon Glassdfc25352017-01-16 07:03:26 -07001089#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
wdenk47d1a6e2002-11-03 00:01:44 +00001090/* Called after the relocation - use desired console functions */
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +01001091int console_init_r(void)
wdenk47d1a6e2002-11-03 00:01:44 +00001092{
1093 char *stdinname, *stdoutname, *stderrname;
Jean-Christophe PLAGNIOL-VILLARD2a7a0312009-05-16 12:14:54 +02001094 struct stdio_dev *inputdev = NULL, *outputdev = NULL, *errdev = NULL;
wdenk05939202004-04-18 17:39:38 +00001095 int i;
Gary Jennejohnc6dc7552008-11-06 15:04:23 +01001096 int iomux_err = 0;
Patrick Delaunayb39862f2019-08-02 14:58:10 +02001097 int flushpoint;
wdenk47d1a6e2002-11-03 00:01:44 +00001098
Patrick Delaunay46b610d2019-08-02 14:58:09 +02001099 /* update silent for env loaded from flash (initr_env) */
Patrick Delaunayb39862f2019-08-02 14:58:10 +02001100 if (console_update_silent())
1101 flushpoint = PRE_CONSOLE_FLUSHPOINT1_SERIAL;
1102 else
1103 flushpoint = PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL;
Patrick Delaunay46b610d2019-08-02 14:58:09 +02001104
wdenk47d1a6e2002-11-03 00:01:44 +00001105 /* set default handlers at first */
Martin Dorwigcb2c2862015-01-26 15:22:54 -07001106 gd->jt->getc = serial_getc;
1107 gd->jt->tstc = serial_tstc;
1108 gd->jt->putc = serial_putc;
1109 gd->jt->puts = serial_puts;
1110 gd->jt->printf = serial_printf;
wdenk47d1a6e2002-11-03 00:01:44 +00001111
1112 /* stdin stdout and stderr are in environment */
1113 /* scan for it */
Simon Glass64b723f2017-08-03 12:22:12 -06001114 stdinname = env_get("stdin");
1115 stdoutname = env_get("stdout");
1116 stderrname = env_get("stderr");
wdenk47d1a6e2002-11-03 00:01:44 +00001117
Wolfgang Denka1be4762008-05-20 16:00:29 +02001118 if (OVERWRITE_CONSOLE == 0) { /* if not overwritten by config switch */
Andy Shevchenkocfaed7f2020-12-21 14:30:03 +02001119 inputdev = console_search_dev(DEV_FLAGS_INPUT, stdinname);
1120 outputdev = console_search_dev(DEV_FLAGS_OUTPUT, stdoutname);
1121 errdev = console_search_dev(DEV_FLAGS_OUTPUT, stderrname);
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +01001122 if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
1123 iomux_err = iomux_doenv(stdin, stdinname);
1124 iomux_err += iomux_doenv(stdout, stdoutname);
1125 iomux_err += iomux_doenv(stderr, stderrname);
1126 if (!iomux_err)
1127 /* Successful, so skip all the code below. */
1128 goto done;
1129 }
wdenk47d1a6e2002-11-03 00:01:44 +00001130 }
1131 /* if the devices are overwritten or not found, use default device */
1132 if (inputdev == NULL) {
Andy Shevchenkocfaed7f2020-12-21 14:30:03 +02001133 inputdev = console_search_dev(DEV_FLAGS_INPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +00001134 }
1135 if (outputdev == NULL) {
Andy Shevchenkocfaed7f2020-12-21 14:30:03 +02001136 outputdev = console_search_dev(DEV_FLAGS_OUTPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +00001137 }
1138 if (errdev == NULL) {
Andy Shevchenkocfaed7f2020-12-21 14:30:03 +02001139 errdev = console_search_dev(DEV_FLAGS_OUTPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +00001140 }
1141 /* Initializes output console first */
1142 if (outputdev != NULL) {
Gary Jennejohnc6dc7552008-11-06 15:04:23 +01001143 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +01001144 console_doenv(stdout, outputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001145 }
1146 if (errdev != NULL) {
Gary Jennejohnc6dc7552008-11-06 15:04:23 +01001147 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +01001148 console_doenv(stderr, errdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001149 }
1150 if (inputdev != NULL) {
Gary Jennejohnc6dc7552008-11-06 15:04:23 +01001151 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD63331a02009-02-01 17:07:52 +01001152 console_doenv(stdin, inputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001153 }
1154
Gary Jennejohnc6dc7552008-11-06 15:04:23 +01001155done:
Gary Jennejohnc6dc7552008-11-06 15:04:23 +01001156
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +01001157 if (!IS_ENABLED(CONFIG_SYS_CONSOLE_INFO_QUIET))
1158 stdio_print_current_devices();
1159
Simon Glass86f07462016-02-06 14:31:37 -07001160#ifdef CONFIG_VIDCONSOLE_AS_LCD
Patrick Delaunay60b92242020-07-01 14:56:10 +02001161 if (strstr(stdoutname, CONFIG_VIDCONSOLE_AS_NAME))
Anatolij Gustschin47020642020-05-23 17:11:20 +02001162 printf("Warning: Please change '%s' to 'vidconsole' in stdout/stderr environment vars\n",
Patrick Delaunay60b92242020-07-01 14:56:10 +02001163 CONFIG_VIDCONSOLE_AS_NAME);
Simon Glass86f07462016-02-06 14:31:37 -07001164#endif
wdenk47d1a6e2002-11-03 00:01:44 +00001165
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +01001166 if (IS_ENABLED(CONFIG_SYS_CONSOLE_ENV_OVERWRITE)) {
1167 /* set the environment variables (will overwrite previous env settings) */
1168 for (i = 0; i < MAX_FILES; i++)
1169 env_set(stdio_names[i], stdio_devices[i]->name);
wdenk47d1a6e2002-11-03 00:01:44 +00001170 }
wdenk47d1a6e2002-11-03 00:01:44 +00001171
Joe Hershbergera46f7702012-12-11 22:16:19 -06001172 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */
1173
Patrick Delaunayb39862f2019-08-02 14:58:10 +02001174 print_pre_console_buffer(flushpoint);
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +01001175 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +00001176}
1177
Simon Glassdfc25352017-01-16 07:03:26 -07001178#else /* !CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */
wdenk47d1a6e2002-11-03 00:01:44 +00001179
1180/* Called after the relocation - use desired console functions */
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +01001181int console_init_r(void)
wdenk47d1a6e2002-11-03 00:01:44 +00001182{
Jean-Christophe PLAGNIOL-VILLARD2a7a0312009-05-16 12:14:54 +02001183 struct stdio_dev *inputdev = NULL, *outputdev = NULL;
Jean-Christophe PLAGNIOL-VILLARD8a4a7842008-08-31 04:24:55 +02001184 int i;
Jean-Christophe PLAGNIOL-VILLARD2a7a0312009-05-16 12:14:54 +02001185 struct list_head *list = stdio_get_list();
Jean-Christophe PLAGNIOL-VILLARD8a4a7842008-08-31 04:24:55 +02001186 struct list_head *pos;
Jean-Christophe PLAGNIOL-VILLARD2a7a0312009-05-16 12:14:54 +02001187 struct stdio_dev *dev;
Patrick Delaunayb39862f2019-08-02 14:58:10 +02001188 int flushpoint;
wdenk47d1a6e2002-11-03 00:01:44 +00001189
Patrick Delaunay46b610d2019-08-02 14:58:09 +02001190 /* update silent for env loaded from flash (initr_env) */
Patrick Delaunayb39862f2019-08-02 14:58:10 +02001191 if (console_update_silent())
1192 flushpoint = PRE_CONSOLE_FLUSHPOINT1_SERIAL;
1193 else
1194 flushpoint = PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL;
Chris Packhamfab806d2016-09-23 15:59:43 +12001195
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +01001196 /*
1197 * suppress all output if splash screen is enabled and we have
Anatolij Gustschinec8744a2010-03-16 15:29:33 +01001198 * a bmp to display. We redirect the output from frame buffer
1199 * console to serial console in this case or suppress it if
1200 * "silent" mode was requested.
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +01001201 */
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +01001202 if (IS_ENABLED(CONFIG_SPLASH_SCREEN) && env_get("splashimage")) {
Anatolij Gustschinec8744a2010-03-16 15:29:33 +01001203 if (!(gd->flags & GD_FLG_SILENT))
Andy Shevchenkocfaed7f2020-12-21 14:30:03 +02001204 outputdev = console_search_dev (DEV_FLAGS_OUTPUT, "serial");
Anatolij Gustschinec8744a2010-03-16 15:29:33 +01001205 }
wdenk808532a2003-10-10 10:05:42 +00001206
wdenk47d1a6e2002-11-03 00:01:44 +00001207 /* Scan devices looking for input and output devices */
Jean-Christophe PLAGNIOL-VILLARD8a4a7842008-08-31 04:24:55 +02001208 list_for_each(pos, list) {
Jean-Christophe PLAGNIOL-VILLARD2a7a0312009-05-16 12:14:54 +02001209 dev = list_entry(pos, struct stdio_dev, list);
wdenk47d1a6e2002-11-03 00:01:44 +00001210
1211 if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
1212 inputdev = dev;
1213 }
1214 if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
1215 outputdev = dev;
1216 }
Jean-Christophe PLAGNIOL-VILLARD8a4a7842008-08-31 04:24:55 +02001217 if(inputdev && outputdev)
1218 break;
wdenk47d1a6e2002-11-03 00:01:44 +00001219 }
1220
1221 /* Initializes output console first */
1222 if (outputdev != NULL) {
Andy Shevchenkoba69b2c2021-02-11 17:09:39 +02001223 console_setfile_and_devices(stdout, outputdev);
1224 console_setfile_and_devices(stderr, outputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001225 }
1226
1227 /* Initializes input console */
Andy Shevchenkoba69b2c2021-02-11 17:09:39 +02001228 if (inputdev != NULL)
1229 console_setfile_and_devices(stdin, inputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001230
Patrick Delaunay4b0b56f2020-12-18 12:46:43 +01001231 if (!IS_ENABLED(CONFIG_SYS_CONSOLE_INFO_QUIET))
1232 stdio_print_current_devices();
wdenk47d1a6e2002-11-03 00:01:44 +00001233
1234 /* Setting environment variables */
Tom Rini66c4d712018-05-03 09:12:26 -04001235 for (i = 0; i < MAX_FILES; i++) {
Simon Glass6a38e412017-08-03 12:22:09 -06001236 env_set(stdio_names[i], stdio_devices[i]->name);
wdenk47d1a6e2002-11-03 00:01:44 +00001237 }
1238
Joe Hershbergera46f7702012-12-11 22:16:19 -06001239 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */
1240
Patrick Delaunayb39862f2019-08-02 14:58:10 +02001241 print_pre_console_buffer(flushpoint);
Jean-Christophe PLAGNIOL-VILLARDc7dc6722009-02-01 17:07:51 +01001242 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +00001243}
1244
Simon Glassdfc25352017-01-16 07:03:26 -07001245#endif /* CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */