blob: 561cdf36a747983c4f4895fc9d64c26b69693381 [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 Glass401d1c42020-10-30 21:38:53 -060022#include <asm/global_data.h>
Simon Glassc05ed002020-05-10 11:40:11 -060023#include <linux/delay.h>
wdenk47d1a6e2002-11-03 00:01:44 +000024
Wolfgang Denkd87080b2006-03-31 18:32:53 +020025DECLARE_GLOBAL_DATA_PTR;
26
Joe Hershberger849d5d92012-12-11 22:16:29 -060027static int on_console(const char *name, const char *value, enum env_op op,
28 int flags)
29{
30 int console = -1;
31
32 /* Check for console redirection */
33 if (strcmp(name, "stdin") == 0)
34 console = stdin;
35 else if (strcmp(name, "stdout") == 0)
36 console = stdout;
37 else if (strcmp(name, "stderr") == 0)
38 console = stderr;
39
40 /* if not actually setting a console variable, we don't care */
41 if (console == -1 || (gd->flags & GD_FLG_DEVINIT) == 0)
42 return 0;
43
44 switch (op) {
45 case env_op_create:
46 case env_op_overwrite:
47
Patrick Delaunayc04f8562020-12-18 12:46:43 +010048 if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
49 if (iomux_doenv(console, value))
50 return 1;
51 } else {
52 /* Try assigning specified device */
53 if (console_assign(console, value) < 0)
54 return 1;
55 }
56
Joe Hershberger849d5d92012-12-11 22:16:29 -060057 return 0;
58
59 case env_op_delete:
60 if ((flags & H_FORCE) == 0)
61 printf("Can't delete \"%s\"\n", name);
62 return 1;
63
64 default:
65 return 0;
66 }
67}
68U_BOOT_ENV_CALLBACK(console, on_console);
69
Joe Hershbergere080d542012-12-11 22:16:30 -060070#ifdef CONFIG_SILENT_CONSOLE
71static int on_silent(const char *name, const char *value, enum env_op op,
72 int flags)
73{
Patrick Delaunayc04f8562020-12-18 12:46:43 +010074 if (!CONFIG_IS_ENABLED(SILENT_CONSOLE_UPDATE_ON_SET))
75 if (flags & H_INTERACTIVE)
76 return 0;
77
78 if (!CONFIG_IS_ENABLED(SILENT_CONSOLE_UPDATE_ON_RELOC))
79 if ((flags & H_INTERACTIVE) == 0)
80 return 0;
Joe Hershbergere080d542012-12-11 22:16:30 -060081
82 if (value != NULL)
83 gd->flags |= GD_FLG_SILENT;
84 else
85 gd->flags &= ~GD_FLG_SILENT;
86
87 return 0;
88}
89U_BOOT_ENV_CALLBACK(silent, on_silent);
90#endif
91
Patrick Delaunay1e993712020-12-18 12:46:45 +010092#ifdef CONFIG_CONSOLE_RECORD
93/* helper function: access to gd->console_out and gd->console_in */
94static void console_record_putc(const char c)
95{
96 if (!(gd->flags & GD_FLG_RECORD))
97 return;
98 if (gd->console_out.start)
99 membuff_putbyte((struct membuff *)&gd->console_out, c);
100}
101
102static void console_record_puts(const char *s)
103{
104 if (!(gd->flags & GD_FLG_RECORD))
105 return;
106 if (gd->console_out.start)
107 membuff_put((struct membuff *)&gd->console_out, s, strlen(s));
108}
109
110static int console_record_getc(void)
111{
112 if (!(gd->flags & GD_FLG_RECORD))
113 return -1;
114 if (!gd->console_in.start)
115 return -1;
116
117 return membuff_getbyte((struct membuff *)&gd->console_in);
118}
119
120static int console_record_tstc(void)
121{
122 if (!(gd->flags & GD_FLG_RECORD))
123 return 0;
124 if (gd->console_in.start) {
125 if (membuff_peekbyte((struct membuff *)&gd->console_in) != -1)
126 return 1;
127 }
128 return 0;
129}
130#else
131static void console_record_putc(char c)
132{
133}
134
135static void console_record_puts(const char *s)
136{
137}
138
139static int console_record_getc(void)
140{
141 return -1;
142}
143
144static int console_record_tstc(void)
145{
146 return 0;
147}
148#endif
149
Simon Glassb0265422017-01-16 07:03:26 -0700150#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
wdenk47d1a6e2002-11-03 00:01:44 +0000151/*
152 * if overwrite_console returns 1, the stdin, stderr and stdout
153 * are switched to the serial port, else the settings in the
154 * environment are used
155 */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200156#ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100157extern int overwrite_console(void);
158#define OVERWRITE_CONSOLE overwrite_console()
wdenk47d1a6e2002-11-03 00:01:44 +0000159#else
wdenk83e40ba2005-03-31 18:42:15 +0000160#define OVERWRITE_CONSOLE 0
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200161#endif /* CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE */
wdenk47d1a6e2002-11-03 00:01:44 +0000162
Simon Glassb0265422017-01-16 07:03:26 -0700163#endif /* CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */
wdenk47d1a6e2002-11-03 00:01:44 +0000164
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200165static int console_setfile(int file, struct stdio_dev * dev)
wdenk47d1a6e2002-11-03 00:01:44 +0000166{
167 int error = 0;
168
169 if (dev == NULL)
170 return -1;
171
172 switch (file) {
173 case stdin:
174 case stdout:
175 case stderr:
Andy Shevchenko41f668b2020-12-21 14:30:00 +0200176 error = console_start(file, dev);
177 if (error)
178 break;
wdenk47d1a6e2002-11-03 00:01:44 +0000179
180 /* Assign the new device (leaving the existing one started) */
181 stdio_devices[file] = dev;
182
183 /*
184 * Update monitor functions
185 * (to use the console stuff by other applications)
186 */
187 switch (file) {
188 case stdin:
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200189 gd->jt->getc = getchar;
Martin Dorwig49cad542015-01-26 15:22:54 -0700190 gd->jt->tstc = tstc;
wdenk47d1a6e2002-11-03 00:01:44 +0000191 break;
192 case stdout:
Martin Dorwig49cad542015-01-26 15:22:54 -0700193 gd->jt->putc = putc;
194 gd->jt->puts = puts;
195 gd->jt->printf = printf;
wdenk47d1a6e2002-11-03 00:01:44 +0000196 break;
197 }
198 break;
199
200 default: /* Invalid file ID */
201 error = -1;
202 }
203 return error;
204}
205
Simon Glass42f9f912017-07-27 09:31:03 -0600206/**
207 * console_dev_is_serial() - Check if a stdio device is a serial device
208 *
209 * @sdev: Device to check
Simon Glass7b3c4c32017-07-27 09:31:04 -0600210 * @return true if this device is in the serial uclass (or for pre-driver-model,
211 * whether it is called "serial".
Simon Glass42f9f912017-07-27 09:31:03 -0600212 */
213static bool console_dev_is_serial(struct stdio_dev *sdev)
214{
215 bool is_serial;
216
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100217 if (IS_ENABLED(CONFIG_DM_SERIAL) && (sdev->flags & DEV_FLAGS_DM)) {
Simon Glass7b3c4c32017-07-27 09:31:04 -0600218 struct udevice *dev = sdev->priv;
219
220 is_serial = device_get_uclass_id(dev) == UCLASS_SERIAL;
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100221 } else {
222 is_serial = !strcmp(sdev->name, "serial");
223 }
Simon Glass42f9f912017-07-27 09:31:03 -0600224
225 return is_serial;
226}
227
Simon Glassb0265422017-01-16 07:03:26 -0700228#if CONFIG_IS_ENABLED(CONSOLE_MUX)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100229/** Console I/O multiplexing *******************************************/
230
Patrick Delaunaya17b38c2020-12-18 12:46:46 +0100231/* tstcdev: save the last stdio device with pending characters, with tstc != 0 */
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200232static struct stdio_dev *tstcdev;
233struct stdio_dev **console_devices[MAX_FILES];
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100234int cd_count[MAX_FILES];
235
Andy Shevchenko09d8f072021-02-11 17:09:39 +0200236static void console_devices_set(int file, struct stdio_dev *dev)
Patrick Delaunay45375ad2020-12-18 12:46:44 +0100237{
238 console_devices[file][0] = dev;
Andy Shevchenko20a7d352021-02-11 17:09:38 +0200239 cd_count[file] = 1;
Patrick Delaunay45375ad2020-12-18 12:46:44 +0100240}
241
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200242/**
243 * console_needs_start_stop() - check if we need to start or stop the STDIO device
244 * @file: STDIO file
245 * @sdev: STDIO device in question
246 *
247 * This function checks if we need to start or stop the stdio device used for
248 * a console. For IOMUX case it simply enforces one time start and one time
249 * stop of the device independently of how many STDIO files are using it. In
250 * other words, we start console once before first STDIO device wants it and
251 * stop after the last is gone.
252 */
253static bool console_needs_start_stop(int file, struct stdio_dev *sdev)
254{
Andy Shevchenkob672c162021-02-11 17:09:41 +0200255 int i;
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200256
257 for (i = 0; i < ARRAY_SIZE(cd_count); i++) {
258 if (i == file)
259 continue;
260
Andy Shevchenkob672c162021-02-11 17:09:41 +0200261 if (iomux_match_device(console_devices[i], cd_count[i], sdev) >= 0)
262 return false;
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200263 }
264 return true;
265}
266
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100267/*
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200268 * This depends on tstc() always being called before getchar().
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100269 * This is guaranteed to be true because this routine is called
270 * only from fgetc() which assures it.
271 * No attempt is made to demultiplex multiple input sources.
272 */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100273static int console_getc(int file)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100274{
275 unsigned char ret;
276
277 /* This is never called with testcdev == NULL */
Simon Glass709ea542014-07-23 06:54:59 -0600278 ret = tstcdev->getc(tstcdev);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100279 tstcdev = NULL;
280 return ret;
281}
282
Patrick Delaunaya17b38c2020-12-18 12:46:46 +0100283/* Upper layer may have already called tstc(): check the saved result */
284static bool console_has_tstc(void)
285{
286 return !!tstcdev;
287}
288
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100289static int console_tstc(int file)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100290{
291 int i, ret;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200292 struct stdio_dev *dev;
Joe Hershbergerb2f58d82018-07-02 20:06:48 -0500293 int prev;
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100294
Joe Hershbergerb2f58d82018-07-02 20:06:48 -0500295 prev = disable_ctrlc(1);
Andy Shevchenko400797c2021-02-11 17:09:42 +0200296 for_each_console_dev(i, file, dev) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100297 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
Andy Shevchenko400797c2021-02-11 17:09:42 +0200316 for_each_console_dev(i, file, dev) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100317 if (dev->putc != NULL)
Simon Glass709ea542014-07-23 06:54:59 -0600318 dev->putc(dev, c);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100319 }
320}
321
Simon Glass493a4c82020-07-02 21:12:13 -0600322/**
323 * console_puts_select() - Output a string to all console devices
324 *
325 * @file: File number to output to (e,g, stdout, see stdio.h)
326 * @serial_only: true to output only to serial, false to output to everything
327 * else
328 * @s: String to output
329 */
330static void console_puts_select(int file, bool serial_only, const char *s)
Siarhei Siamashka27669662015-01-08 09:02:31 +0200331{
332 int i;
333 struct stdio_dev *dev;
334
Andy Shevchenko400797c2021-02-11 17:09:42 +0200335 for_each_console_dev(i, file, dev) {
336 bool is_serial = console_dev_is_serial(dev);
Simon Glass493a4c82020-07-02 21:12:13 -0600337
Simon Glass493a4c82020-07-02 21:12:13 -0600338 if (dev->puts && serial_only == is_serial)
Hans de Goedea8552c72015-05-05 13:13:36 +0200339 dev->puts(dev, s);
Siarhei Siamashka27669662015-01-08 09:02:31 +0200340 }
341}
Siarhei Siamashka27669662015-01-08 09:02:31 +0200342
Simon Glass493a4c82020-07-02 21:12:13 -0600343void console_puts_select_stderr(bool serial_only, const char *s)
344{
345 console_puts_select(stderr, serial_only, s);
346}
347
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100348static void console_puts(int file, const char *s)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100349{
350 int i;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200351 struct stdio_dev *dev;
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100352
Andy Shevchenko400797c2021-02-11 17:09:42 +0200353 for_each_console_dev(i, file, dev) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100354 if (dev->puts != NULL)
Simon Glass709ea542014-07-23 06:54:59 -0600355 dev->puts(dev, s);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100356 }
357}
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100358
Tom Rini5e63c962019-10-30 09:18:43 -0400359#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200360static inline void console_doenv(int file, struct stdio_dev *dev)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100361{
362 iomux_doenv(file, dev->name);
363}
Tom Rini5e63c962019-10-30 09:18:43 -0400364#endif
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100365#else
Patrick Delaunay45375ad2020-12-18 12:46:44 +0100366
Andy Shevchenko09d8f072021-02-11 17:09:39 +0200367static void console_devices_set(int file, struct stdio_dev *dev)
Patrick Delaunay45375ad2020-12-18 12:46:44 +0100368{
369}
370
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200371static inline bool console_needs_start_stop(int file, struct stdio_dev *sdev)
372{
373 return true;
374}
375
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100376static inline int console_getc(int file)
377{
Simon Glass709ea542014-07-23 06:54:59 -0600378 return stdio_devices[file]->getc(stdio_devices[file]);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100379}
380
Patrick Delaunaya17b38c2020-12-18 12:46:46 +0100381static bool console_has_tstc(void)
382{
383 return false;
384}
385
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100386static inline int console_tstc(int file)
387{
Simon Glass709ea542014-07-23 06:54:59 -0600388 return stdio_devices[file]->tstc(stdio_devices[file]);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100389}
390
391static inline void console_putc(int file, const char c)
392{
Simon Glass709ea542014-07-23 06:54:59 -0600393 stdio_devices[file]->putc(stdio_devices[file], c);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100394}
395
Simon Glass493a4c82020-07-02 21:12:13 -0600396void console_puts_select(int file, bool serial_only, const char *s)
Siarhei Siamashka27669662015-01-08 09:02:31 +0200397{
Simon Glass493a4c82020-07-02 21:12:13 -0600398 if (serial_only == console_dev_is_serial(stdio_devices[file]))
Hans de Goedea8552c72015-05-05 13:13:36 +0200399 stdio_devices[file]->puts(stdio_devices[file], s);
Siarhei Siamashka27669662015-01-08 09:02:31 +0200400}
Siarhei Siamashka27669662015-01-08 09:02:31 +0200401
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100402static inline void console_puts(int file, const char *s)
403{
Simon Glass709ea542014-07-23 06:54:59 -0600404 stdio_devices[file]->puts(stdio_devices[file], s);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100405}
406
Tom Rini5e63c962019-10-30 09:18:43 -0400407#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200408static inline void console_doenv(int file, struct stdio_dev *dev)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100409{
410 console_setfile(file, dev);
411}
Tom Rini5e63c962019-10-30 09:18:43 -0400412#endif
Simon Glassb0265422017-01-16 07:03:26 -0700413#endif /* CONIFIG_IS_ENABLED(CONSOLE_MUX) */
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100414
Andy Shevchenko09d8f072021-02-11 17:09:39 +0200415static void __maybe_unused console_setfile_and_devices(int file, struct stdio_dev *dev)
416{
417 console_setfile(file, dev);
418 console_devices_set(file, dev);
419}
420
Andy Shevchenko41f668b2020-12-21 14:30:00 +0200421int console_start(int file, struct stdio_dev *sdev)
422{
423 int error;
424
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200425 if (!console_needs_start_stop(file, sdev))
426 return 0;
427
Andy Shevchenko41f668b2020-12-21 14:30:00 +0200428 /* Start new device */
429 if (sdev->start) {
430 error = sdev->start(sdev);
431 /* If it's not started don't use it */
432 if (error < 0)
433 return error;
434 }
435 return 0;
436}
437
438void console_stop(int file, struct stdio_dev *sdev)
439{
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200440 if (!console_needs_start_stop(file, sdev))
441 return;
442
Andy Shevchenko41f668b2020-12-21 14:30:00 +0200443 if (sdev->stop)
444 sdev->stop(sdev);
445}
446
wdenk47d1a6e2002-11-03 00:01:44 +0000447/** U-Boot INITIAL CONSOLE-NOT COMPATIBLE FUNCTIONS *************************/
448
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200449int serial_printf(const char *fmt, ...)
wdenk47d1a6e2002-11-03 00:01:44 +0000450{
451 va_list args;
452 uint i;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200453 char printbuffer[CONFIG_SYS_PBSIZE];
wdenk47d1a6e2002-11-03 00:01:44 +0000454
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100455 va_start(args, fmt);
wdenk47d1a6e2002-11-03 00:01:44 +0000456
457 /* For this to work, printbuffer must be larger than
458 * anything we ever want to print.
459 */
Sonny Rao068af6f2011-10-10 09:22:31 +0000460 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100461 va_end(args);
wdenk47d1a6e2002-11-03 00:01:44 +0000462
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100463 serial_puts(printbuffer);
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200464 return i;
wdenk47d1a6e2002-11-03 00:01:44 +0000465}
466
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100467int fgetc(int file)
wdenk47d1a6e2002-11-03 00:01:44 +0000468{
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100469 if (file < MAX_FILES) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100470 /*
471 * Effectively poll for input wherever it may be available.
472 */
473 for (;;) {
Andreas J. Reichel64407462016-07-13 12:56:51 +0200474 WATCHDOG_RESET();
Patrick Delaunaya17b38c2020-12-18 12:46:46 +0100475 if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
476 /*
477 * Upper layer may have already called tstc() so
478 * check for that first.
479 */
480 if (console_has_tstc())
481 return console_getc(file);
482 console_tstc(file);
483 } else {
484 if (console_tstc(file))
485 return console_getc(file);
486 }
487
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100488 /*
489 * If the watchdog must be rate-limited then it should
490 * already be handled in board-specific code.
491 */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100492 if (IS_ENABLED(CONFIG_WATCHDOG))
493 udelay(1);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100494 }
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100495 }
wdenk47d1a6e2002-11-03 00:01:44 +0000496
497 return -1;
498}
499
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100500int ftstc(int file)
wdenk47d1a6e2002-11-03 00:01:44 +0000501{
502 if (file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100503 return console_tstc(file);
wdenk47d1a6e2002-11-03 00:01:44 +0000504
505 return -1;
506}
507
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100508void fputc(int file, const char c)
wdenk47d1a6e2002-11-03 00:01:44 +0000509{
510 if (file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100511 console_putc(file, c);
wdenk47d1a6e2002-11-03 00:01:44 +0000512}
513
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100514void fputs(int file, const char *s)
wdenk47d1a6e2002-11-03 00:01:44 +0000515{
516 if (file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100517 console_puts(file, s);
wdenk47d1a6e2002-11-03 00:01:44 +0000518}
519
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200520int fprintf(int file, const char *fmt, ...)
wdenk47d1a6e2002-11-03 00:01:44 +0000521{
522 va_list args;
523 uint i;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200524 char printbuffer[CONFIG_SYS_PBSIZE];
wdenk47d1a6e2002-11-03 00:01:44 +0000525
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100526 va_start(args, fmt);
wdenk47d1a6e2002-11-03 00:01:44 +0000527
528 /* For this to work, printbuffer must be larger than
529 * anything we ever want to print.
530 */
Sonny Rao068af6f2011-10-10 09:22:31 +0000531 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100532 va_end(args);
wdenk47d1a6e2002-11-03 00:01:44 +0000533
534 /* Send to desired file */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100535 fputs(file, printbuffer);
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200536 return i;
wdenk47d1a6e2002-11-03 00:01:44 +0000537}
538
539/** U-Boot INITIAL CONSOLE-COMPATIBLE FUNCTION *****************************/
540
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200541int getchar(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000542{
Patrick Delaunay1e993712020-12-18 12:46:45 +0100543 int ch;
544
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100545 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100546 return 0;
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100547
Graeme Russe3e454c2011-08-29 02:14:05 +0000548 if (!gd->have_console)
549 return 0;
550
Patrick Delaunay1e993712020-12-18 12:46:45 +0100551 ch = console_record_getc();
552 if (ch != -1)
553 return ch;
Simon Glass9854a872015-11-08 23:47:48 -0700554
wdenk47d1a6e2002-11-03 00:01:44 +0000555 if (gd->flags & GD_FLG_DEVINIT) {
556 /* Get from the standard input */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100557 return fgetc(stdin);
wdenk47d1a6e2002-11-03 00:01:44 +0000558 }
559
560 /* Send directly to the handler */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100561 return serial_getc();
wdenk47d1a6e2002-11-03 00:01:44 +0000562}
563
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100564int tstc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000565{
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100566 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100567 return 0;
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100568
Graeme Russe3e454c2011-08-29 02:14:05 +0000569 if (!gd->have_console)
570 return 0;
Patrick Delaunay1e993712020-12-18 12:46:45 +0100571
572 if (console_record_tstc())
573 return 1;
574
wdenk47d1a6e2002-11-03 00:01:44 +0000575 if (gd->flags & GD_FLG_DEVINIT) {
576 /* Test the standard input */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100577 return ftstc(stdin);
wdenk47d1a6e2002-11-03 00:01:44 +0000578 }
579
580 /* Send directly to the handler */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100581 return serial_tstc();
wdenk47d1a6e2002-11-03 00:01:44 +0000582}
583
Siarhei Siamashka27669662015-01-08 09:02:31 +0200584#define PRE_CONSOLE_FLUSHPOINT1_SERIAL 0
585#define PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL 1
586
Simon Glass8f925582016-10-17 20:12:36 -0600587#if CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
Graeme Russ9558b482011-09-01 00:48:27 +0000588#define CIRC_BUF_IDX(idx) ((idx) % (unsigned long)CONFIG_PRE_CON_BUF_SZ)
589
590static void pre_console_putc(const char c)
591{
Simon Glass4e6bafa2017-06-15 21:37:52 -0600592 char *buffer;
593
594 buffer = map_sysmem(CONFIG_PRE_CON_BUF_ADDR, CONFIG_PRE_CON_BUF_SZ);
Graeme Russ9558b482011-09-01 00:48:27 +0000595
596 buffer[CIRC_BUF_IDX(gd->precon_buf_idx++)] = c;
Simon Glass4e6bafa2017-06-15 21:37:52 -0600597
598 unmap_sysmem(buffer);
Graeme Russ9558b482011-09-01 00:48:27 +0000599}
600
Soeren Mochbe135cc2017-11-04 16:14:09 +0100601static void pre_console_puts(const char *s)
602{
603 while (*s)
604 pre_console_putc(*s++);
605}
606
Siarhei Siamashka27669662015-01-08 09:02:31 +0200607static void print_pre_console_buffer(int flushpoint)
Graeme Russ9558b482011-09-01 00:48:27 +0000608{
Hans de Goedea8552c72015-05-05 13:13:36 +0200609 unsigned long in = 0, out = 0;
Hans de Goedea8552c72015-05-05 13:13:36 +0200610 char buf_out[CONFIG_PRE_CON_BUF_SZ + 1];
Simon Glass4e6bafa2017-06-15 21:37:52 -0600611 char *buf_in;
Graeme Russ9558b482011-09-01 00:48:27 +0000612
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100613 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT))
Patrick Delaunay13551b92019-08-02 14:58:10 +0200614 return;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200615
Simon Glass4e6bafa2017-06-15 21:37:52 -0600616 buf_in = map_sysmem(CONFIG_PRE_CON_BUF_ADDR, CONFIG_PRE_CON_BUF_SZ);
Graeme Russ9558b482011-09-01 00:48:27 +0000617 if (gd->precon_buf_idx > CONFIG_PRE_CON_BUF_SZ)
Hans de Goedea8552c72015-05-05 13:13:36 +0200618 in = gd->precon_buf_idx - CONFIG_PRE_CON_BUF_SZ;
Graeme Russ9558b482011-09-01 00:48:27 +0000619
Hans de Goedea8552c72015-05-05 13:13:36 +0200620 while (in < gd->precon_buf_idx)
621 buf_out[out++] = buf_in[CIRC_BUF_IDX(in++)];
Simon Glass4e6bafa2017-06-15 21:37:52 -0600622 unmap_sysmem(buf_in);
Hans de Goedea8552c72015-05-05 13:13:36 +0200623
624 buf_out[out] = 0;
625
626 switch (flushpoint) {
627 case PRE_CONSOLE_FLUSHPOINT1_SERIAL:
628 puts(buf_out);
629 break;
630 case PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL:
Simon Glass493a4c82020-07-02 21:12:13 -0600631 console_puts_select(stdout, false, buf_out);
Hans de Goedea8552c72015-05-05 13:13:36 +0200632 break;
633 }
Graeme Russ9558b482011-09-01 00:48:27 +0000634}
635#else
636static inline void pre_console_putc(const char c) {}
Soeren Mochbe135cc2017-11-04 16:14:09 +0100637static inline void pre_console_puts(const char *s) {}
Siarhei Siamashka27669662015-01-08 09:02:31 +0200638static inline void print_pre_console_buffer(int flushpoint) {}
Graeme Russ9558b482011-09-01 00:48:27 +0000639#endif
640
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100641void putc(const char c)
wdenk47d1a6e2002-11-03 00:01:44 +0000642{
Patrick Delaunay93cdb522020-11-27 11:20:56 +0100643 if (!gd)
644 return;
Patrick Delaunay1e993712020-12-18 12:46:45 +0100645
646 console_record_putc(c);
647
Simon Glass64e9b4f2017-12-04 13:48:19 -0700648 /* sandbox can send characters to stdout before it has a console */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100649 if (IS_ENABLED(CONFIG_SANDBOX) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glass64e9b4f2017-12-04 13:48:19 -0700650 os_putc(c);
651 return;
652 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100653
Simon Glassd6ea5302015-06-23 15:38:33 -0600654 /* if we don't have a console yet, use the debug UART */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100655 if (IS_ENABLED(CONFIG_DEBUG_UART) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glassd6ea5302015-06-23 15:38:33 -0600656 printch(c);
657 return;
658 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100659
660 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT)) {
Patrick Delaunay13551b92019-08-02 14:58:10 +0200661 if (!(gd->flags & GD_FLG_DEVINIT))
662 pre_console_putc(c);
wdenkf6e20fc2004-02-08 19:38:38 +0000663 return;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200664 }
wdenka6cccae2004-02-06 21:48:22 +0000665
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100666 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100667 return;
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100668
Graeme Russe3e454c2011-08-29 02:14:05 +0000669 if (!gd->have_console)
Graeme Russ9558b482011-09-01 00:48:27 +0000670 return pre_console_putc(c);
Graeme Russe3e454c2011-08-29 02:14:05 +0000671
wdenk47d1a6e2002-11-03 00:01:44 +0000672 if (gd->flags & GD_FLG_DEVINIT) {
673 /* Send to the standard output */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100674 fputc(stdout, c);
wdenk47d1a6e2002-11-03 00:01:44 +0000675 } else {
676 /* Send directly to the handler */
Siarhei Siamashka27669662015-01-08 09:02:31 +0200677 pre_console_putc(c);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100678 serial_putc(c);
wdenk47d1a6e2002-11-03 00:01:44 +0000679 }
680}
681
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100682void puts(const char *s)
wdenk47d1a6e2002-11-03 00:01:44 +0000683{
Patrick Delaunay93cdb522020-11-27 11:20:56 +0100684 if (!gd)
685 return;
Patrick Delaunay1e993712020-12-18 12:46:45 +0100686
687 console_record_puts(s);
688
Simon Glass36bcea62018-11-15 18:44:04 -0700689 /* sandbox can send characters to stdout before it has a console */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100690 if (IS_ENABLED(CONFIG_SANDBOX) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glass36bcea62018-11-15 18:44:04 -0700691 os_puts(s);
692 return;
693 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100694
695 if (IS_ENABLED(CONFIG_DEBUG_UART) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Soeren Mochbe135cc2017-11-04 16:14:09 +0100696 while (*s) {
697 int ch = *s++;
698
699 printch(ch);
700 }
701 return;
702 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100703
704 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT)) {
Patrick Delaunay13551b92019-08-02 14:58:10 +0200705 if (!(gd->flags & GD_FLG_DEVINIT))
706 pre_console_puts(s);
Soeren Mochbe135cc2017-11-04 16:14:09 +0100707 return;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200708 }
Soeren Mochbe135cc2017-11-04 16:14:09 +0100709
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100710 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Soeren Mochbe135cc2017-11-04 16:14:09 +0100711 return;
Soeren Mochbe135cc2017-11-04 16:14:09 +0100712
713 if (!gd->have_console)
714 return pre_console_puts(s);
715
716 if (gd->flags & GD_FLG_DEVINIT) {
717 /* Send to the standard output */
718 fputs(stdout, s);
719 } else {
720 /* Send directly to the handler */
721 pre_console_puts(s);
722 serial_puts(s);
723 }
wdenk47d1a6e2002-11-03 00:01:44 +0000724}
725
Simon Glass9854a872015-11-08 23:47:48 -0700726#ifdef CONFIG_CONSOLE_RECORD
727int console_record_init(void)
728{
729 int ret;
730
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100731 ret = membuff_new((struct membuff *)&gd->console_out,
732 CONFIG_CONSOLE_RECORD_OUT_SIZE);
Simon Glass9854a872015-11-08 23:47:48 -0700733 if (ret)
734 return ret;
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100735 ret = membuff_new((struct membuff *)&gd->console_in,
736 CONFIG_CONSOLE_RECORD_IN_SIZE);
Simon Glass9854a872015-11-08 23:47:48 -0700737
738 return ret;
739}
740
741void console_record_reset(void)
742{
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100743 membuff_purge((struct membuff *)&gd->console_out);
744 membuff_purge((struct membuff *)&gd->console_in);
Simon Glass9854a872015-11-08 23:47:48 -0700745}
746
Simon Glassbd347152020-07-28 19:41:11 -0600747int console_record_reset_enable(void)
Simon Glass9854a872015-11-08 23:47:48 -0700748{
749 console_record_reset();
750 gd->flags |= GD_FLG_RECORD;
Simon Glassbd347152020-07-28 19:41:11 -0600751
752 return 0;
Simon Glass9854a872015-11-08 23:47:48 -0700753}
Simon Glassb6123122020-01-27 08:49:54 -0700754
755int console_record_readline(char *str, int maxlen)
756{
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100757 return membuff_readline((struct membuff *)&gd->console_out, str,
758 maxlen, ' ');
Simon Glassb6123122020-01-27 08:49:54 -0700759}
760
761int console_record_avail(void)
762{
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100763 return membuff_avail((struct membuff *)&gd->console_out);
Simon Glassb6123122020-01-27 08:49:54 -0700764}
765
Simon Glass9854a872015-11-08 23:47:48 -0700766#endif
767
wdenk47d1a6e2002-11-03 00:01:44 +0000768/* test if ctrl-c was pressed */
769static int ctrlc_disabled = 0; /* see disable_ctrl() */
770static int ctrlc_was_pressed = 0;
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100771int ctrlc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000772{
wdenk47d1a6e2002-11-03 00:01:44 +0000773 if (!ctrlc_disabled && gd->have_console) {
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100774 if (tstc()) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200775 switch (getchar()) {
wdenk47d1a6e2002-11-03 00:01:44 +0000776 case 0x03: /* ^C - Control C */
777 ctrlc_was_pressed = 1;
778 return 1;
779 default:
780 break;
781 }
782 }
783 }
Simon Glass8969ea32014-09-14 12:40:15 -0600784
wdenk47d1a6e2002-11-03 00:01:44 +0000785 return 0;
786}
Pierre Auberta5dffa42014-04-24 10:30:07 +0200787/* Reads user's confirmation.
788 Returns 1 if user's input is "y", "Y", "yes" or "YES"
789*/
790int confirm_yesno(void)
791{
792 int i;
793 char str_input[5];
wdenk47d1a6e2002-11-03 00:01:44 +0000794
Pierre Auberta5dffa42014-04-24 10:30:07 +0200795 /* Flush input */
796 while (tstc())
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200797 getchar();
Pierre Auberta5dffa42014-04-24 10:30:07 +0200798 i = 0;
799 while (i < sizeof(str_input)) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200800 str_input[i] = getchar();
Pierre Auberta5dffa42014-04-24 10:30:07 +0200801 putc(str_input[i]);
802 if (str_input[i] == '\r')
803 break;
804 i++;
805 }
806 putc('\n');
807 if (strncmp(str_input, "y\r", 2) == 0 ||
808 strncmp(str_input, "Y\r", 2) == 0 ||
809 strncmp(str_input, "yes\r", 4) == 0 ||
810 strncmp(str_input, "YES\r", 4) == 0)
811 return 1;
812 return 0;
813}
wdenk47d1a6e2002-11-03 00:01:44 +0000814/* pass 1 to disable ctrlc() checking, 0 to enable.
815 * returns previous state
816 */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100817int disable_ctrlc(int disable)
wdenk47d1a6e2002-11-03 00:01:44 +0000818{
819 int prev = ctrlc_disabled; /* save previous state */
820
821 ctrlc_disabled = disable;
822 return prev;
823}
824
825int had_ctrlc (void)
826{
827 return ctrlc_was_pressed;
828}
829
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100830void clear_ctrlc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000831{
832 ctrlc_was_pressed = 0;
833}
834
wdenk47d1a6e2002-11-03 00:01:44 +0000835/** U-Boot INIT FUNCTIONS *************************************************/
836
Andy Shevchenko32324872020-12-21 14:30:03 +0200837struct stdio_dev *console_search_dev(int flags, const char *name)
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200838{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200839 struct stdio_dev *dev;
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200840
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200841 dev = stdio_get_by_name(name);
Simon Glassa2931b32016-02-06 14:31:37 -0700842#ifdef CONFIG_VIDCONSOLE_AS_LCD
Patrick Delaunay27b5b9e2020-07-01 14:56:10 +0200843 if (!dev && !strcmp(name, CONFIG_VIDCONSOLE_AS_NAME))
Simon Glassa2931b32016-02-06 14:31:37 -0700844 dev = stdio_get_by_name("vidconsole");
845#endif
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200846
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100847 if (dev && (dev->flags & flags))
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200848 return dev;
849
850 return NULL;
851}
852
Mike Frysingerd7be3052010-10-20 07:18:03 -0400853int console_assign(int file, const char *devname)
wdenk47d1a6e2002-11-03 00:01:44 +0000854{
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200855 int flag;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200856 struct stdio_dev *dev;
wdenk47d1a6e2002-11-03 00:01:44 +0000857
858 /* Check for valid file */
Andy Shevchenko7b9ca3f2021-02-11 17:09:37 +0200859 flag = stdio_file_to_flags(file);
860 if (flag < 0)
861 return flag;
wdenk47d1a6e2002-11-03 00:01:44 +0000862
863 /* Check for valid device name */
864
Andy Shevchenko32324872020-12-21 14:30:03 +0200865 dev = console_search_dev(flag, devname);
wdenk47d1a6e2002-11-03 00:01:44 +0000866
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100867 if (dev)
868 return console_setfile(file, dev);
wdenk47d1a6e2002-11-03 00:01:44 +0000869
870 return -1;
871}
872
Patrick Delaunay13551b92019-08-02 14:58:10 +0200873/* return true if the 'silent' flag is removed */
874static bool console_update_silent(void)
Chris Packham43e0a3d2016-09-23 15:59:43 +1200875{
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100876 unsigned long flags = gd->flags;
877
878 if (!IS_ENABLED(CONFIG_SILENT_CONSOLE))
879 return false;
880
Patrick Delaunay13551b92019-08-02 14:58:10 +0200881 if (env_get("silent")) {
Chris Packham43e0a3d2016-09-23 15:59:43 +1200882 gd->flags |= GD_FLG_SILENT;
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100883 return false;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200884 }
Patrick Delaunay13551b92019-08-02 14:58:10 +0200885
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100886 gd->flags &= ~GD_FLG_SILENT;
887
888 return !!(flags & GD_FLG_SILENT);
Chris Packham43e0a3d2016-09-23 15:59:43 +1200889}
890
Simon Glassb0895382017-06-15 21:37:50 -0600891int console_announce_r(void)
892{
893#if !CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
894 char buf[DISPLAY_OPTIONS_BANNER_LENGTH];
895
896 display_options_get_banner(false, buf, sizeof(buf));
897
Simon Glass493a4c82020-07-02 21:12:13 -0600898 console_puts_select(stdout, false, buf);
Simon Glassb0895382017-06-15 21:37:50 -0600899#endif
900
901 return 0;
902}
903
wdenk47d1a6e2002-11-03 00:01:44 +0000904/* Called before relocation - use serial functions */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100905int console_init_f(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000906{
wdenk47d1a6e2002-11-03 00:01:44 +0000907 gd->have_console = 1;
wdenkf72da342003-10-10 10:05:42 +0000908
Chris Packham43e0a3d2016-09-23 15:59:43 +1200909 console_update_silent();
wdenkf72da342003-10-10 10:05:42 +0000910
Siarhei Siamashka27669662015-01-08 09:02:31 +0200911 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT1_SERIAL);
Graeme Russ9558b482011-09-01 00:48:27 +0000912
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100913 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +0000914}
915
Jean-Christophe PLAGNIOL-VILLARD7e3be7c2009-05-16 12:14:55 +0200916void stdio_print_current_devices(void)
917{
Jean-Christophe PLAGNIOL-VILLARD7e3be7c2009-05-16 12:14:55 +0200918 /* Print information */
919 puts("In: ");
920 if (stdio_devices[stdin] == NULL) {
921 puts("No input devices available!\n");
922 } else {
923 printf ("%s\n", stdio_devices[stdin]->name);
924 }
925
926 puts("Out: ");
927 if (stdio_devices[stdout] == NULL) {
928 puts("No output devices available!\n");
929 } else {
930 printf ("%s\n", stdio_devices[stdout]->name);
931 }
932
933 puts("Err: ");
934 if (stdio_devices[stderr] == NULL) {
935 puts("No error devices available!\n");
936 } else {
937 printf ("%s\n", stdio_devices[stderr]->name);
938 }
Jean-Christophe PLAGNIOL-VILLARD7e3be7c2009-05-16 12:14:55 +0200939}
940
Simon Glassb0265422017-01-16 07:03:26 -0700941#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
wdenk47d1a6e2002-11-03 00:01:44 +0000942/* Called after the relocation - use desired console functions */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100943int console_init_r(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000944{
945 char *stdinname, *stdoutname, *stderrname;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200946 struct stdio_dev *inputdev = NULL, *outputdev = NULL, *errdev = NULL;
wdenk6e592382004-04-18 17:39:38 +0000947 int i;
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100948 int iomux_err = 0;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200949 int flushpoint;
wdenk47d1a6e2002-11-03 00:01:44 +0000950
Patrick Delaunaybf46be72019-08-02 14:58:09 +0200951 /* update silent for env loaded from flash (initr_env) */
Patrick Delaunay13551b92019-08-02 14:58:10 +0200952 if (console_update_silent())
953 flushpoint = PRE_CONSOLE_FLUSHPOINT1_SERIAL;
954 else
955 flushpoint = PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL;
Patrick Delaunaybf46be72019-08-02 14:58:09 +0200956
wdenk47d1a6e2002-11-03 00:01:44 +0000957 /* set default handlers at first */
Martin Dorwig49cad542015-01-26 15:22:54 -0700958 gd->jt->getc = serial_getc;
959 gd->jt->tstc = serial_tstc;
960 gd->jt->putc = serial_putc;
961 gd->jt->puts = serial_puts;
962 gd->jt->printf = serial_printf;
wdenk47d1a6e2002-11-03 00:01:44 +0000963
964 /* stdin stdout and stderr are in environment */
965 /* scan for it */
Simon Glass00caae62017-08-03 12:22:12 -0600966 stdinname = env_get("stdin");
967 stdoutname = env_get("stdout");
968 stderrname = env_get("stderr");
wdenk47d1a6e2002-11-03 00:01:44 +0000969
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200970 if (OVERWRITE_CONSOLE == 0) { /* if not overwritten by config switch */
Andy Shevchenko32324872020-12-21 14:30:03 +0200971 inputdev = console_search_dev(DEV_FLAGS_INPUT, stdinname);
972 outputdev = console_search_dev(DEV_FLAGS_OUTPUT, stdoutname);
973 errdev = console_search_dev(DEV_FLAGS_OUTPUT, stderrname);
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100974 if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
975 iomux_err = iomux_doenv(stdin, stdinname);
976 iomux_err += iomux_doenv(stdout, stdoutname);
977 iomux_err += iomux_doenv(stderr, stderrname);
978 if (!iomux_err)
979 /* Successful, so skip all the code below. */
980 goto done;
981 }
wdenk47d1a6e2002-11-03 00:01:44 +0000982 }
983 /* if the devices are overwritten or not found, use default device */
984 if (inputdev == NULL) {
Andy Shevchenko32324872020-12-21 14:30:03 +0200985 inputdev = console_search_dev(DEV_FLAGS_INPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +0000986 }
987 if (outputdev == NULL) {
Andy Shevchenko32324872020-12-21 14:30:03 +0200988 outputdev = console_search_dev(DEV_FLAGS_OUTPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +0000989 }
990 if (errdev == NULL) {
Andy Shevchenko32324872020-12-21 14:30:03 +0200991 errdev = console_search_dev(DEV_FLAGS_OUTPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +0000992 }
993 /* Initializes output console first */
994 if (outputdev != NULL) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100995 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100996 console_doenv(stdout, outputdev);
wdenk47d1a6e2002-11-03 00:01:44 +0000997 }
998 if (errdev != NULL) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100999 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +01001000 console_doenv(stderr, errdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001001 }
1002 if (inputdev != NULL) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001003 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +01001004 console_doenv(stdin, inputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001005 }
1006
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001007done:
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001008
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001009 if (!IS_ENABLED(CONFIG_SYS_CONSOLE_INFO_QUIET))
1010 stdio_print_current_devices();
1011
Simon Glassa2931b32016-02-06 14:31:37 -07001012#ifdef CONFIG_VIDCONSOLE_AS_LCD
Patrick Delaunay27b5b9e2020-07-01 14:56:10 +02001013 if (strstr(stdoutname, CONFIG_VIDCONSOLE_AS_NAME))
Anatolij Gustschin22b897a2020-05-23 17:11:20 +02001014 printf("Warning: Please change '%s' to 'vidconsole' in stdout/stderr environment vars\n",
Patrick Delaunay27b5b9e2020-07-01 14:56:10 +02001015 CONFIG_VIDCONSOLE_AS_NAME);
Simon Glassa2931b32016-02-06 14:31:37 -07001016#endif
wdenk47d1a6e2002-11-03 00:01:44 +00001017
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001018 if (IS_ENABLED(CONFIG_SYS_CONSOLE_ENV_OVERWRITE)) {
1019 /* set the environment variables (will overwrite previous env settings) */
1020 for (i = 0; i < MAX_FILES; i++)
1021 env_set(stdio_names[i], stdio_devices[i]->name);
wdenk47d1a6e2002-11-03 00:01:44 +00001022 }
wdenk47d1a6e2002-11-03 00:01:44 +00001023
Joe Hershbergerc4e00572012-12-11 22:16:19 -06001024 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */
1025
Patrick Delaunay13551b92019-08-02 14:58:10 +02001026 print_pre_console_buffer(flushpoint);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001027 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +00001028}
1029
Simon Glassb0265422017-01-16 07:03:26 -07001030#else /* !CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */
wdenk47d1a6e2002-11-03 00:01:44 +00001031
1032/* Called after the relocation - use desired console functions */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001033int console_init_r(void)
wdenk47d1a6e2002-11-03 00:01:44 +00001034{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001035 struct stdio_dev *inputdev = NULL, *outputdev = NULL;
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001036 int i;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001037 struct list_head *list = stdio_get_list();
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001038 struct list_head *pos;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001039 struct stdio_dev *dev;
Patrick Delaunay13551b92019-08-02 14:58:10 +02001040 int flushpoint;
wdenk47d1a6e2002-11-03 00:01:44 +00001041
Patrick Delaunaybf46be72019-08-02 14:58:09 +02001042 /* update silent for env loaded from flash (initr_env) */
Patrick Delaunay13551b92019-08-02 14:58:10 +02001043 if (console_update_silent())
1044 flushpoint = PRE_CONSOLE_FLUSHPOINT1_SERIAL;
1045 else
1046 flushpoint = PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL;
Chris Packham43e0a3d2016-09-23 15:59:43 +12001047
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001048 /*
1049 * suppress all output if splash screen is enabled and we have
Anatolij Gustschina7490812010-03-16 15:29:33 +01001050 * a bmp to display. We redirect the output from frame buffer
1051 * console to serial console in this case or suppress it if
1052 * "silent" mode was requested.
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001053 */
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001054 if (IS_ENABLED(CONFIG_SPLASH_SCREEN) && env_get("splashimage")) {
Anatolij Gustschina7490812010-03-16 15:29:33 +01001055 if (!(gd->flags & GD_FLG_SILENT))
Andy Shevchenko32324872020-12-21 14:30:03 +02001056 outputdev = console_search_dev (DEV_FLAGS_OUTPUT, "serial");
Anatolij Gustschina7490812010-03-16 15:29:33 +01001057 }
wdenkf72da342003-10-10 10:05:42 +00001058
wdenk47d1a6e2002-11-03 00:01:44 +00001059 /* Scan devices looking for input and output devices */
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001060 list_for_each(pos, list) {
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001061 dev = list_entry(pos, struct stdio_dev, list);
wdenk47d1a6e2002-11-03 00:01:44 +00001062
1063 if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
1064 inputdev = dev;
1065 }
1066 if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
1067 outputdev = dev;
1068 }
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001069 if(inputdev && outputdev)
1070 break;
wdenk47d1a6e2002-11-03 00:01:44 +00001071 }
1072
1073 /* Initializes output console first */
1074 if (outputdev != NULL) {
Andy Shevchenko09d8f072021-02-11 17:09:39 +02001075 console_setfile_and_devices(stdout, outputdev);
1076 console_setfile_and_devices(stderr, outputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001077 }
1078
1079 /* Initializes input console */
Andy Shevchenko09d8f072021-02-11 17:09:39 +02001080 if (inputdev != NULL)
1081 console_setfile_and_devices(stdin, inputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001082
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001083 if (!IS_ENABLED(CONFIG_SYS_CONSOLE_INFO_QUIET))
1084 stdio_print_current_devices();
wdenk47d1a6e2002-11-03 00:01:44 +00001085
1086 /* Setting environment variables */
Tom Rini27b42252018-05-03 09:12:26 -04001087 for (i = 0; i < MAX_FILES; i++) {
Simon Glass382bee52017-08-03 12:22:09 -06001088 env_set(stdio_names[i], stdio_devices[i]->name);
wdenk47d1a6e2002-11-03 00:01:44 +00001089 }
1090
Joe Hershbergerc4e00572012-12-11 22:16:19 -06001091 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */
1092
Patrick Delaunay13551b92019-08-02 14:58:10 +02001093 print_pre_console_buffer(flushpoint);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001094 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +00001095}
1096
Simon Glassb0265422017-01-16 07:03:26 -07001097#endif /* CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */