blob: 73edb28799201c3f4a86c3777e63d82a914aa5a6 [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;
Simon Glassc1a2bb42021-05-08 06:59:56 -060098 if (gd->console_out.start &&
99 !membuff_putbyte((struct membuff *)&gd->console_out, c))
100 gd->flags |= GD_FLG_RECORD_OVF;
Patrick Delaunay1e993712020-12-18 12:46:45 +0100101}
102
103static void console_record_puts(const char *s)
104{
105 if (!(gd->flags & GD_FLG_RECORD))
106 return;
Simon Glassc1a2bb42021-05-08 06:59:56 -0600107 if (gd->console_out.start) {
108 int len = strlen(s);
109
110 if (membuff_put((struct membuff *)&gd->console_out, s, len) !=
111 len)
112 gd->flags |= GD_FLG_RECORD_OVF;
113 }
Patrick Delaunay1e993712020-12-18 12:46:45 +0100114}
115
116static int console_record_getc(void)
117{
118 if (!(gd->flags & GD_FLG_RECORD))
119 return -1;
120 if (!gd->console_in.start)
121 return -1;
122
123 return membuff_getbyte((struct membuff *)&gd->console_in);
124}
125
126static int console_record_tstc(void)
127{
128 if (!(gd->flags & GD_FLG_RECORD))
129 return 0;
130 if (gd->console_in.start) {
131 if (membuff_peekbyte((struct membuff *)&gd->console_in) != -1)
132 return 1;
133 }
134 return 0;
135}
136#else
137static void console_record_putc(char c)
138{
139}
140
141static void console_record_puts(const char *s)
142{
143}
144
145static int console_record_getc(void)
146{
147 return -1;
148}
149
150static int console_record_tstc(void)
151{
152 return 0;
153}
154#endif
155
Simon Glassb0265422017-01-16 07:03:26 -0700156#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
wdenk47d1a6e2002-11-03 00:01:44 +0000157/*
158 * if overwrite_console returns 1, the stdin, stderr and stdout
159 * are switched to the serial port, else the settings in the
160 * environment are used
161 */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200162#ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100163extern int overwrite_console(void);
164#define OVERWRITE_CONSOLE overwrite_console()
wdenk47d1a6e2002-11-03 00:01:44 +0000165#else
wdenk83e40ba2005-03-31 18:42:15 +0000166#define OVERWRITE_CONSOLE 0
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200167#endif /* CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE */
wdenk47d1a6e2002-11-03 00:01:44 +0000168
Simon Glassb0265422017-01-16 07:03:26 -0700169#endif /* CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */
wdenk47d1a6e2002-11-03 00:01:44 +0000170
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200171static int console_setfile(int file, struct stdio_dev * dev)
wdenk47d1a6e2002-11-03 00:01:44 +0000172{
173 int error = 0;
174
175 if (dev == NULL)
176 return -1;
177
178 switch (file) {
179 case stdin:
180 case stdout:
181 case stderr:
Andy Shevchenko41f668b2020-12-21 14:30:00 +0200182 error = console_start(file, dev);
183 if (error)
184 break;
wdenk47d1a6e2002-11-03 00:01:44 +0000185
186 /* Assign the new device (leaving the existing one started) */
187 stdio_devices[file] = dev;
188
189 /*
190 * Update monitor functions
191 * (to use the console stuff by other applications)
192 */
193 switch (file) {
194 case stdin:
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200195 gd->jt->getc = getchar;
Martin Dorwig49cad542015-01-26 15:22:54 -0700196 gd->jt->tstc = tstc;
wdenk47d1a6e2002-11-03 00:01:44 +0000197 break;
198 case stdout:
Martin Dorwig49cad542015-01-26 15:22:54 -0700199 gd->jt->putc = putc;
200 gd->jt->puts = puts;
201 gd->jt->printf = printf;
wdenk47d1a6e2002-11-03 00:01:44 +0000202 break;
203 }
204 break;
205
206 default: /* Invalid file ID */
207 error = -1;
208 }
209 return error;
210}
211
Simon Glass42f9f912017-07-27 09:31:03 -0600212/**
213 * console_dev_is_serial() - Check if a stdio device is a serial device
214 *
215 * @sdev: Device to check
Simon Glass7b3c4c32017-07-27 09:31:04 -0600216 * @return true if this device is in the serial uclass (or for pre-driver-model,
217 * whether it is called "serial".
Simon Glass42f9f912017-07-27 09:31:03 -0600218 */
219static bool console_dev_is_serial(struct stdio_dev *sdev)
220{
221 bool is_serial;
222
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100223 if (IS_ENABLED(CONFIG_DM_SERIAL) && (sdev->flags & DEV_FLAGS_DM)) {
Simon Glass7b3c4c32017-07-27 09:31:04 -0600224 struct udevice *dev = sdev->priv;
225
226 is_serial = device_get_uclass_id(dev) == UCLASS_SERIAL;
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100227 } else {
228 is_serial = !strcmp(sdev->name, "serial");
229 }
Simon Glass42f9f912017-07-27 09:31:03 -0600230
231 return is_serial;
232}
233
Simon Glassb0265422017-01-16 07:03:26 -0700234#if CONFIG_IS_ENABLED(CONSOLE_MUX)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100235/** Console I/O multiplexing *******************************************/
236
Patrick Delaunaya17b38c2020-12-18 12:46:46 +0100237/* tstcdev: save the last stdio device with pending characters, with tstc != 0 */
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200238static struct stdio_dev *tstcdev;
239struct stdio_dev **console_devices[MAX_FILES];
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100240int cd_count[MAX_FILES];
241
Andy Shevchenko09d8f072021-02-11 17:09:39 +0200242static void console_devices_set(int file, struct stdio_dev *dev)
Patrick Delaunay45375ad2020-12-18 12:46:44 +0100243{
244 console_devices[file][0] = dev;
Andy Shevchenko20a7d352021-02-11 17:09:38 +0200245 cd_count[file] = 1;
Patrick Delaunay45375ad2020-12-18 12:46:44 +0100246}
247
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200248/**
249 * console_needs_start_stop() - check if we need to start or stop the STDIO device
250 * @file: STDIO file
251 * @sdev: STDIO device in question
252 *
253 * This function checks if we need to start or stop the stdio device used for
254 * a console. For IOMUX case it simply enforces one time start and one time
255 * stop of the device independently of how many STDIO files are using it. In
256 * other words, we start console once before first STDIO device wants it and
257 * stop after the last is gone.
258 */
259static bool console_needs_start_stop(int file, struct stdio_dev *sdev)
260{
Andy Shevchenkob672c162021-02-11 17:09:41 +0200261 int i;
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200262
263 for (i = 0; i < ARRAY_SIZE(cd_count); i++) {
264 if (i == file)
265 continue;
266
Andy Shevchenkob672c162021-02-11 17:09:41 +0200267 if (iomux_match_device(console_devices[i], cd_count[i], sdev) >= 0)
268 return false;
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200269 }
270 return true;
271}
272
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100273/*
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200274 * This depends on tstc() always being called before getchar().
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100275 * This is guaranteed to be true because this routine is called
276 * only from fgetc() which assures it.
277 * No attempt is made to demultiplex multiple input sources.
278 */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100279static int console_getc(int file)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100280{
281 unsigned char ret;
282
283 /* This is never called with testcdev == NULL */
Simon Glass709ea542014-07-23 06:54:59 -0600284 ret = tstcdev->getc(tstcdev);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100285 tstcdev = NULL;
286 return ret;
287}
288
Patrick Delaunaya17b38c2020-12-18 12:46:46 +0100289/* Upper layer may have already called tstc(): check the saved result */
290static bool console_has_tstc(void)
291{
292 return !!tstcdev;
293}
294
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100295static int console_tstc(int file)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100296{
297 int i, ret;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200298 struct stdio_dev *dev;
Joe Hershbergerb2f58d82018-07-02 20:06:48 -0500299 int prev;
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100300
Joe Hershbergerb2f58d82018-07-02 20:06:48 -0500301 prev = disable_ctrlc(1);
Andy Shevchenko400797c2021-02-11 17:09:42 +0200302 for_each_console_dev(i, file, dev) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100303 if (dev->tstc != NULL) {
Simon Glass709ea542014-07-23 06:54:59 -0600304 ret = dev->tstc(dev);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100305 if (ret > 0) {
306 tstcdev = dev;
Joe Hershbergerb2f58d82018-07-02 20:06:48 -0500307 disable_ctrlc(prev);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100308 return ret;
309 }
310 }
311 }
Joe Hershbergerb2f58d82018-07-02 20:06:48 -0500312 disable_ctrlc(prev);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100313
314 return 0;
315}
316
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100317static void console_putc(int file, const char c)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100318{
319 int i;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200320 struct stdio_dev *dev;
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100321
Andy Shevchenko400797c2021-02-11 17:09:42 +0200322 for_each_console_dev(i, file, dev) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100323 if (dev->putc != NULL)
Simon Glass709ea542014-07-23 06:54:59 -0600324 dev->putc(dev, c);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100325 }
326}
327
Simon Glass493a4c82020-07-02 21:12:13 -0600328/**
329 * console_puts_select() - Output a string to all console devices
330 *
331 * @file: File number to output to (e,g, stdout, see stdio.h)
332 * @serial_only: true to output only to serial, false to output to everything
333 * else
334 * @s: String to output
335 */
336static void console_puts_select(int file, bool serial_only, const char *s)
Siarhei Siamashka27669662015-01-08 09:02:31 +0200337{
338 int i;
339 struct stdio_dev *dev;
340
Andy Shevchenko400797c2021-02-11 17:09:42 +0200341 for_each_console_dev(i, file, dev) {
342 bool is_serial = console_dev_is_serial(dev);
Simon Glass493a4c82020-07-02 21:12:13 -0600343
Simon Glass493a4c82020-07-02 21:12:13 -0600344 if (dev->puts && serial_only == is_serial)
Hans de Goedea8552c72015-05-05 13:13:36 +0200345 dev->puts(dev, s);
Siarhei Siamashka27669662015-01-08 09:02:31 +0200346 }
347}
Siarhei Siamashka27669662015-01-08 09:02:31 +0200348
Simon Glass493a4c82020-07-02 21:12:13 -0600349void console_puts_select_stderr(bool serial_only, const char *s)
350{
351 console_puts_select(stderr, serial_only, s);
352}
353
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100354static void console_puts(int file, const char *s)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100355{
356 int i;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200357 struct stdio_dev *dev;
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100358
Andy Shevchenko400797c2021-02-11 17:09:42 +0200359 for_each_console_dev(i, file, dev) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100360 if (dev->puts != NULL)
Simon Glass709ea542014-07-23 06:54:59 -0600361 dev->puts(dev, s);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100362 }
363}
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100364
Tom Rini5e63c962019-10-30 09:18:43 -0400365#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200366static inline void console_doenv(int file, struct stdio_dev *dev)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100367{
368 iomux_doenv(file, dev->name);
369}
Tom Rini5e63c962019-10-30 09:18:43 -0400370#endif
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100371#else
Patrick Delaunay45375ad2020-12-18 12:46:44 +0100372
Andy Shevchenko09d8f072021-02-11 17:09:39 +0200373static void console_devices_set(int file, struct stdio_dev *dev)
Patrick Delaunay45375ad2020-12-18 12:46:44 +0100374{
375}
376
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200377static inline bool console_needs_start_stop(int file, struct stdio_dev *sdev)
378{
379 return true;
380}
381
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100382static inline int console_getc(int file)
383{
Simon Glass709ea542014-07-23 06:54:59 -0600384 return stdio_devices[file]->getc(stdio_devices[file]);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100385}
386
Patrick Delaunaya17b38c2020-12-18 12:46:46 +0100387static bool console_has_tstc(void)
388{
389 return false;
390}
391
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100392static inline int console_tstc(int file)
393{
Simon Glass709ea542014-07-23 06:54:59 -0600394 return stdio_devices[file]->tstc(stdio_devices[file]);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100395}
396
397static inline void console_putc(int file, const char c)
398{
Simon Glass709ea542014-07-23 06:54:59 -0600399 stdio_devices[file]->putc(stdio_devices[file], c);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100400}
401
Simon Glass493a4c82020-07-02 21:12:13 -0600402void console_puts_select(int file, bool serial_only, const char *s)
Siarhei Siamashka27669662015-01-08 09:02:31 +0200403{
Simon Glass493a4c82020-07-02 21:12:13 -0600404 if (serial_only == console_dev_is_serial(stdio_devices[file]))
Hans de Goedea8552c72015-05-05 13:13:36 +0200405 stdio_devices[file]->puts(stdio_devices[file], s);
Siarhei Siamashka27669662015-01-08 09:02:31 +0200406}
Siarhei Siamashka27669662015-01-08 09:02:31 +0200407
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100408static inline void console_puts(int file, const char *s)
409{
Simon Glass709ea542014-07-23 06:54:59 -0600410 stdio_devices[file]->puts(stdio_devices[file], s);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100411}
412
Tom Rini5e63c962019-10-30 09:18:43 -0400413#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200414static inline void console_doenv(int file, struct stdio_dev *dev)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100415{
416 console_setfile(file, dev);
417}
Tom Rini5e63c962019-10-30 09:18:43 -0400418#endif
Simon Glassb0265422017-01-16 07:03:26 -0700419#endif /* CONIFIG_IS_ENABLED(CONSOLE_MUX) */
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100420
Andy Shevchenko09d8f072021-02-11 17:09:39 +0200421static void __maybe_unused console_setfile_and_devices(int file, struct stdio_dev *dev)
422{
423 console_setfile(file, dev);
424 console_devices_set(file, dev);
425}
426
Andy Shevchenko41f668b2020-12-21 14:30:00 +0200427int console_start(int file, struct stdio_dev *sdev)
428{
429 int error;
430
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200431 if (!console_needs_start_stop(file, sdev))
432 return 0;
433
Andy Shevchenko41f668b2020-12-21 14:30:00 +0200434 /* Start new device */
435 if (sdev->start) {
436 error = sdev->start(sdev);
437 /* If it's not started don't use it */
438 if (error < 0)
439 return error;
440 }
441 return 0;
442}
443
444void console_stop(int file, struct stdio_dev *sdev)
445{
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200446 if (!console_needs_start_stop(file, sdev))
447 return;
448
Andy Shevchenko41f668b2020-12-21 14:30:00 +0200449 if (sdev->stop)
450 sdev->stop(sdev);
451}
452
wdenk47d1a6e2002-11-03 00:01:44 +0000453/** U-Boot INITIAL CONSOLE-NOT COMPATIBLE FUNCTIONS *************************/
454
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200455int serial_printf(const char *fmt, ...)
wdenk47d1a6e2002-11-03 00:01:44 +0000456{
457 va_list args;
458 uint i;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200459 char printbuffer[CONFIG_SYS_PBSIZE];
wdenk47d1a6e2002-11-03 00:01:44 +0000460
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100461 va_start(args, fmt);
wdenk47d1a6e2002-11-03 00:01:44 +0000462
463 /* For this to work, printbuffer must be larger than
464 * anything we ever want to print.
465 */
Sonny Rao068af6f2011-10-10 09:22:31 +0000466 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100467 va_end(args);
wdenk47d1a6e2002-11-03 00:01:44 +0000468
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100469 serial_puts(printbuffer);
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200470 return i;
wdenk47d1a6e2002-11-03 00:01:44 +0000471}
472
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100473int fgetc(int file)
wdenk47d1a6e2002-11-03 00:01:44 +0000474{
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100475 if (file < MAX_FILES) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100476 /*
477 * Effectively poll for input wherever it may be available.
478 */
479 for (;;) {
Andreas J. Reichel64407462016-07-13 12:56:51 +0200480 WATCHDOG_RESET();
Patrick Delaunaya17b38c2020-12-18 12:46:46 +0100481 if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
482 /*
483 * Upper layer may have already called tstc() so
484 * check for that first.
485 */
486 if (console_has_tstc())
487 return console_getc(file);
488 console_tstc(file);
489 } else {
490 if (console_tstc(file))
491 return console_getc(file);
492 }
493
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100494 /*
495 * If the watchdog must be rate-limited then it should
496 * already be handled in board-specific code.
497 */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100498 if (IS_ENABLED(CONFIG_WATCHDOG))
499 udelay(1);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100500 }
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100501 }
wdenk47d1a6e2002-11-03 00:01:44 +0000502
503 return -1;
504}
505
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100506int ftstc(int file)
wdenk47d1a6e2002-11-03 00:01:44 +0000507{
508 if (file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100509 return console_tstc(file);
wdenk47d1a6e2002-11-03 00:01:44 +0000510
511 return -1;
512}
513
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100514void fputc(int file, const char c)
wdenk47d1a6e2002-11-03 00:01:44 +0000515{
516 if (file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100517 console_putc(file, c);
wdenk47d1a6e2002-11-03 00:01:44 +0000518}
519
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100520void fputs(int file, const char *s)
wdenk47d1a6e2002-11-03 00:01:44 +0000521{
522 if (file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100523 console_puts(file, s);
wdenk47d1a6e2002-11-03 00:01:44 +0000524}
525
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200526int fprintf(int file, const char *fmt, ...)
wdenk47d1a6e2002-11-03 00:01:44 +0000527{
528 va_list args;
529 uint i;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200530 char printbuffer[CONFIG_SYS_PBSIZE];
wdenk47d1a6e2002-11-03 00:01:44 +0000531
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100532 va_start(args, fmt);
wdenk47d1a6e2002-11-03 00:01:44 +0000533
534 /* For this to work, printbuffer must be larger than
535 * anything we ever want to print.
536 */
Sonny Rao068af6f2011-10-10 09:22:31 +0000537 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100538 va_end(args);
wdenk47d1a6e2002-11-03 00:01:44 +0000539
540 /* Send to desired file */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100541 fputs(file, printbuffer);
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200542 return i;
wdenk47d1a6e2002-11-03 00:01:44 +0000543}
544
545/** U-Boot INITIAL CONSOLE-COMPATIBLE FUNCTION *****************************/
546
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200547int getchar(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000548{
Patrick Delaunay1e993712020-12-18 12:46:45 +0100549 int ch;
550
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100551 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100552 return 0;
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100553
Graeme Russe3e454c2011-08-29 02:14:05 +0000554 if (!gd->have_console)
555 return 0;
556
Patrick Delaunay1e993712020-12-18 12:46:45 +0100557 ch = console_record_getc();
558 if (ch != -1)
559 return ch;
Simon Glass9854a872015-11-08 23:47:48 -0700560
wdenk47d1a6e2002-11-03 00:01:44 +0000561 if (gd->flags & GD_FLG_DEVINIT) {
562 /* Get from the standard input */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100563 return fgetc(stdin);
wdenk47d1a6e2002-11-03 00:01:44 +0000564 }
565
566 /* Send directly to the handler */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100567 return serial_getc();
wdenk47d1a6e2002-11-03 00:01:44 +0000568}
569
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100570int tstc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000571{
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100572 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100573 return 0;
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100574
Graeme Russe3e454c2011-08-29 02:14:05 +0000575 if (!gd->have_console)
576 return 0;
Patrick Delaunay1e993712020-12-18 12:46:45 +0100577
578 if (console_record_tstc())
579 return 1;
580
wdenk47d1a6e2002-11-03 00:01:44 +0000581 if (gd->flags & GD_FLG_DEVINIT) {
582 /* Test the standard input */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100583 return ftstc(stdin);
wdenk47d1a6e2002-11-03 00:01:44 +0000584 }
585
586 /* Send directly to the handler */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100587 return serial_tstc();
wdenk47d1a6e2002-11-03 00:01:44 +0000588}
589
Siarhei Siamashka27669662015-01-08 09:02:31 +0200590#define PRE_CONSOLE_FLUSHPOINT1_SERIAL 0
591#define PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL 1
592
Simon Glass8f925582016-10-17 20:12:36 -0600593#if CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
Graeme Russ9558b482011-09-01 00:48:27 +0000594#define CIRC_BUF_IDX(idx) ((idx) % (unsigned long)CONFIG_PRE_CON_BUF_SZ)
595
596static void pre_console_putc(const char c)
597{
Simon Glass4e6bafa2017-06-15 21:37:52 -0600598 char *buffer;
599
600 buffer = map_sysmem(CONFIG_PRE_CON_BUF_ADDR, CONFIG_PRE_CON_BUF_SZ);
Graeme Russ9558b482011-09-01 00:48:27 +0000601
602 buffer[CIRC_BUF_IDX(gd->precon_buf_idx++)] = c;
Simon Glass4e6bafa2017-06-15 21:37:52 -0600603
604 unmap_sysmem(buffer);
Graeme Russ9558b482011-09-01 00:48:27 +0000605}
606
Soeren Mochbe135cc2017-11-04 16:14:09 +0100607static void pre_console_puts(const char *s)
608{
609 while (*s)
610 pre_console_putc(*s++);
611}
612
Siarhei Siamashka27669662015-01-08 09:02:31 +0200613static void print_pre_console_buffer(int flushpoint)
Graeme Russ9558b482011-09-01 00:48:27 +0000614{
Hans de Goedea8552c72015-05-05 13:13:36 +0200615 unsigned long in = 0, out = 0;
Hans de Goedea8552c72015-05-05 13:13:36 +0200616 char buf_out[CONFIG_PRE_CON_BUF_SZ + 1];
Simon Glass4e6bafa2017-06-15 21:37:52 -0600617 char *buf_in;
Graeme Russ9558b482011-09-01 00:48:27 +0000618
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100619 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT))
Patrick Delaunay13551b92019-08-02 14:58:10 +0200620 return;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200621
Simon Glass4e6bafa2017-06-15 21:37:52 -0600622 buf_in = map_sysmem(CONFIG_PRE_CON_BUF_ADDR, CONFIG_PRE_CON_BUF_SZ);
Graeme Russ9558b482011-09-01 00:48:27 +0000623 if (gd->precon_buf_idx > CONFIG_PRE_CON_BUF_SZ)
Hans de Goedea8552c72015-05-05 13:13:36 +0200624 in = gd->precon_buf_idx - CONFIG_PRE_CON_BUF_SZ;
Graeme Russ9558b482011-09-01 00:48:27 +0000625
Hans de Goedea8552c72015-05-05 13:13:36 +0200626 while (in < gd->precon_buf_idx)
627 buf_out[out++] = buf_in[CIRC_BUF_IDX(in++)];
Simon Glass4e6bafa2017-06-15 21:37:52 -0600628 unmap_sysmem(buf_in);
Hans de Goedea8552c72015-05-05 13:13:36 +0200629
630 buf_out[out] = 0;
631
632 switch (flushpoint) {
633 case PRE_CONSOLE_FLUSHPOINT1_SERIAL:
634 puts(buf_out);
635 break;
636 case PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL:
Simon Glass493a4c82020-07-02 21:12:13 -0600637 console_puts_select(stdout, false, buf_out);
Hans de Goedea8552c72015-05-05 13:13:36 +0200638 break;
639 }
Graeme Russ9558b482011-09-01 00:48:27 +0000640}
641#else
642static inline void pre_console_putc(const char c) {}
Soeren Mochbe135cc2017-11-04 16:14:09 +0100643static inline void pre_console_puts(const char *s) {}
Siarhei Siamashka27669662015-01-08 09:02:31 +0200644static inline void print_pre_console_buffer(int flushpoint) {}
Graeme Russ9558b482011-09-01 00:48:27 +0000645#endif
646
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100647void putc(const char c)
wdenk47d1a6e2002-11-03 00:01:44 +0000648{
Patrick Delaunay93cdb522020-11-27 11:20:56 +0100649 if (!gd)
650 return;
Patrick Delaunay1e993712020-12-18 12:46:45 +0100651
652 console_record_putc(c);
653
Simon Glass64e9b4f2017-12-04 13:48:19 -0700654 /* sandbox can send characters to stdout before it has a console */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100655 if (IS_ENABLED(CONFIG_SANDBOX) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glass64e9b4f2017-12-04 13:48:19 -0700656 os_putc(c);
657 return;
658 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100659
Simon Glassd6ea5302015-06-23 15:38:33 -0600660 /* if we don't have a console yet, use the debug UART */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100661 if (IS_ENABLED(CONFIG_DEBUG_UART) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glassd6ea5302015-06-23 15:38:33 -0600662 printch(c);
663 return;
664 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100665
666 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT)) {
Patrick Delaunay13551b92019-08-02 14:58:10 +0200667 if (!(gd->flags & GD_FLG_DEVINIT))
668 pre_console_putc(c);
wdenkf6e20fc2004-02-08 19:38:38 +0000669 return;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200670 }
wdenka6cccae2004-02-06 21:48:22 +0000671
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100672 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100673 return;
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100674
Graeme Russe3e454c2011-08-29 02:14:05 +0000675 if (!gd->have_console)
Graeme Russ9558b482011-09-01 00:48:27 +0000676 return pre_console_putc(c);
Graeme Russe3e454c2011-08-29 02:14:05 +0000677
wdenk47d1a6e2002-11-03 00:01:44 +0000678 if (gd->flags & GD_FLG_DEVINIT) {
679 /* Send to the standard output */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100680 fputc(stdout, c);
wdenk47d1a6e2002-11-03 00:01:44 +0000681 } else {
682 /* Send directly to the handler */
Siarhei Siamashka27669662015-01-08 09:02:31 +0200683 pre_console_putc(c);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100684 serial_putc(c);
wdenk47d1a6e2002-11-03 00:01:44 +0000685 }
686}
687
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100688void puts(const char *s)
wdenk47d1a6e2002-11-03 00:01:44 +0000689{
Patrick Delaunay93cdb522020-11-27 11:20:56 +0100690 if (!gd)
691 return;
Patrick Delaunay1e993712020-12-18 12:46:45 +0100692
693 console_record_puts(s);
694
Simon Glass36bcea62018-11-15 18:44:04 -0700695 /* sandbox can send characters to stdout before it has a console */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100696 if (IS_ENABLED(CONFIG_SANDBOX) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glass36bcea62018-11-15 18:44:04 -0700697 os_puts(s);
698 return;
699 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100700
701 if (IS_ENABLED(CONFIG_DEBUG_UART) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Soeren Mochbe135cc2017-11-04 16:14:09 +0100702 while (*s) {
703 int ch = *s++;
704
705 printch(ch);
706 }
707 return;
708 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100709
710 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT)) {
Patrick Delaunay13551b92019-08-02 14:58:10 +0200711 if (!(gd->flags & GD_FLG_DEVINIT))
712 pre_console_puts(s);
Soeren Mochbe135cc2017-11-04 16:14:09 +0100713 return;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200714 }
Soeren Mochbe135cc2017-11-04 16:14:09 +0100715
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100716 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Soeren Mochbe135cc2017-11-04 16:14:09 +0100717 return;
Soeren Mochbe135cc2017-11-04 16:14:09 +0100718
719 if (!gd->have_console)
720 return pre_console_puts(s);
721
722 if (gd->flags & GD_FLG_DEVINIT) {
723 /* Send to the standard output */
724 fputs(stdout, s);
725 } else {
726 /* Send directly to the handler */
727 pre_console_puts(s);
728 serial_puts(s);
729 }
wdenk47d1a6e2002-11-03 00:01:44 +0000730}
731
Simon Glass9854a872015-11-08 23:47:48 -0700732#ifdef CONFIG_CONSOLE_RECORD
733int console_record_init(void)
734{
735 int ret;
736
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100737 ret = membuff_new((struct membuff *)&gd->console_out,
738 CONFIG_CONSOLE_RECORD_OUT_SIZE);
Simon Glass9854a872015-11-08 23:47:48 -0700739 if (ret)
740 return ret;
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100741 ret = membuff_new((struct membuff *)&gd->console_in,
742 CONFIG_CONSOLE_RECORD_IN_SIZE);
Simon Glass9854a872015-11-08 23:47:48 -0700743
744 return ret;
745}
746
747void console_record_reset(void)
748{
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100749 membuff_purge((struct membuff *)&gd->console_out);
750 membuff_purge((struct membuff *)&gd->console_in);
Simon Glassc1a2bb42021-05-08 06:59:56 -0600751 gd->flags &= ~GD_FLG_RECORD_OVF;
Simon Glass9854a872015-11-08 23:47:48 -0700752}
753
Simon Glassbd347152020-07-28 19:41:11 -0600754int console_record_reset_enable(void)
Simon Glass9854a872015-11-08 23:47:48 -0700755{
756 console_record_reset();
757 gd->flags |= GD_FLG_RECORD;
Simon Glassbd347152020-07-28 19:41:11 -0600758
759 return 0;
Simon Glass9854a872015-11-08 23:47:48 -0700760}
Simon Glassb6123122020-01-27 08:49:54 -0700761
762int console_record_readline(char *str, int maxlen)
763{
Simon Glassc1a2bb42021-05-08 06:59:56 -0600764 if (gd->flags & GD_FLG_RECORD_OVF)
765 return -ENOSPC;
766
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100767 return membuff_readline((struct membuff *)&gd->console_out, str,
768 maxlen, ' ');
Simon Glassb6123122020-01-27 08:49:54 -0700769}
770
771int console_record_avail(void)
772{
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100773 return membuff_avail((struct membuff *)&gd->console_out);
Simon Glassb6123122020-01-27 08:49:54 -0700774}
775
Simon Glass9854a872015-11-08 23:47:48 -0700776#endif
777
wdenk47d1a6e2002-11-03 00:01:44 +0000778/* test if ctrl-c was pressed */
779static int ctrlc_disabled = 0; /* see disable_ctrl() */
780static int ctrlc_was_pressed = 0;
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100781int ctrlc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000782{
wdenk47d1a6e2002-11-03 00:01:44 +0000783 if (!ctrlc_disabled && gd->have_console) {
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100784 if (tstc()) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200785 switch (getchar()) {
wdenk47d1a6e2002-11-03 00:01:44 +0000786 case 0x03: /* ^C - Control C */
787 ctrlc_was_pressed = 1;
788 return 1;
789 default:
790 break;
791 }
792 }
793 }
Simon Glass8969ea32014-09-14 12:40:15 -0600794
wdenk47d1a6e2002-11-03 00:01:44 +0000795 return 0;
796}
Pierre Auberta5dffa42014-04-24 10:30:07 +0200797/* Reads user's confirmation.
798 Returns 1 if user's input is "y", "Y", "yes" or "YES"
799*/
800int confirm_yesno(void)
801{
802 int i;
803 char str_input[5];
wdenk47d1a6e2002-11-03 00:01:44 +0000804
Pierre Auberta5dffa42014-04-24 10:30:07 +0200805 /* Flush input */
806 while (tstc())
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200807 getchar();
Pierre Auberta5dffa42014-04-24 10:30:07 +0200808 i = 0;
809 while (i < sizeof(str_input)) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200810 str_input[i] = getchar();
Pierre Auberta5dffa42014-04-24 10:30:07 +0200811 putc(str_input[i]);
812 if (str_input[i] == '\r')
813 break;
814 i++;
815 }
816 putc('\n');
817 if (strncmp(str_input, "y\r", 2) == 0 ||
818 strncmp(str_input, "Y\r", 2) == 0 ||
819 strncmp(str_input, "yes\r", 4) == 0 ||
820 strncmp(str_input, "YES\r", 4) == 0)
821 return 1;
822 return 0;
823}
wdenk47d1a6e2002-11-03 00:01:44 +0000824/* pass 1 to disable ctrlc() checking, 0 to enable.
825 * returns previous state
826 */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100827int disable_ctrlc(int disable)
wdenk47d1a6e2002-11-03 00:01:44 +0000828{
829 int prev = ctrlc_disabled; /* save previous state */
830
831 ctrlc_disabled = disable;
832 return prev;
833}
834
835int had_ctrlc (void)
836{
837 return ctrlc_was_pressed;
838}
839
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100840void clear_ctrlc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000841{
842 ctrlc_was_pressed = 0;
843}
844
wdenk47d1a6e2002-11-03 00:01:44 +0000845/** U-Boot INIT FUNCTIONS *************************************************/
846
Andy Shevchenko32324872020-12-21 14:30:03 +0200847struct stdio_dev *console_search_dev(int flags, const char *name)
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200848{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200849 struct stdio_dev *dev;
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200850
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200851 dev = stdio_get_by_name(name);
Simon Glassa2931b32016-02-06 14:31:37 -0700852#ifdef CONFIG_VIDCONSOLE_AS_LCD
Patrick Delaunay27b5b9e2020-07-01 14:56:10 +0200853 if (!dev && !strcmp(name, CONFIG_VIDCONSOLE_AS_NAME))
Simon Glassa2931b32016-02-06 14:31:37 -0700854 dev = stdio_get_by_name("vidconsole");
855#endif
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200856
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100857 if (dev && (dev->flags & flags))
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200858 return dev;
859
860 return NULL;
861}
862
Mike Frysingerd7be3052010-10-20 07:18:03 -0400863int console_assign(int file, const char *devname)
wdenk47d1a6e2002-11-03 00:01:44 +0000864{
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200865 int flag;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200866 struct stdio_dev *dev;
wdenk47d1a6e2002-11-03 00:01:44 +0000867
868 /* Check for valid file */
Andy Shevchenko7b9ca3f2021-02-11 17:09:37 +0200869 flag = stdio_file_to_flags(file);
870 if (flag < 0)
871 return flag;
wdenk47d1a6e2002-11-03 00:01:44 +0000872
873 /* Check for valid device name */
874
Andy Shevchenko32324872020-12-21 14:30:03 +0200875 dev = console_search_dev(flag, devname);
wdenk47d1a6e2002-11-03 00:01:44 +0000876
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100877 if (dev)
878 return console_setfile(file, dev);
wdenk47d1a6e2002-11-03 00:01:44 +0000879
880 return -1;
881}
882
Patrick Delaunay13551b92019-08-02 14:58:10 +0200883/* return true if the 'silent' flag is removed */
884static bool console_update_silent(void)
Chris Packham43e0a3d2016-09-23 15:59:43 +1200885{
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100886 unsigned long flags = gd->flags;
887
888 if (!IS_ENABLED(CONFIG_SILENT_CONSOLE))
889 return false;
890
Patrick Delaunay13551b92019-08-02 14:58:10 +0200891 if (env_get("silent")) {
Chris Packham43e0a3d2016-09-23 15:59:43 +1200892 gd->flags |= GD_FLG_SILENT;
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100893 return false;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200894 }
Patrick Delaunay13551b92019-08-02 14:58:10 +0200895
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100896 gd->flags &= ~GD_FLG_SILENT;
897
898 return !!(flags & GD_FLG_SILENT);
Chris Packham43e0a3d2016-09-23 15:59:43 +1200899}
900
Simon Glassb0895382017-06-15 21:37:50 -0600901int console_announce_r(void)
902{
903#if !CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
904 char buf[DISPLAY_OPTIONS_BANNER_LENGTH];
905
906 display_options_get_banner(false, buf, sizeof(buf));
907
Simon Glass493a4c82020-07-02 21:12:13 -0600908 console_puts_select(stdout, false, buf);
Simon Glassb0895382017-06-15 21:37:50 -0600909#endif
910
911 return 0;
912}
913
wdenk47d1a6e2002-11-03 00:01:44 +0000914/* Called before relocation - use serial functions */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100915int console_init_f(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000916{
wdenk47d1a6e2002-11-03 00:01:44 +0000917 gd->have_console = 1;
wdenkf72da342003-10-10 10:05:42 +0000918
Chris Packham43e0a3d2016-09-23 15:59:43 +1200919 console_update_silent();
wdenkf72da342003-10-10 10:05:42 +0000920
Siarhei Siamashka27669662015-01-08 09:02:31 +0200921 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT1_SERIAL);
Graeme Russ9558b482011-09-01 00:48:27 +0000922
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100923 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +0000924}
925
Jean-Christophe PLAGNIOL-VILLARD7e3be7c2009-05-16 12:14:55 +0200926void stdio_print_current_devices(void)
927{
Jean-Christophe PLAGNIOL-VILLARD7e3be7c2009-05-16 12:14:55 +0200928 /* Print information */
929 puts("In: ");
930 if (stdio_devices[stdin] == NULL) {
931 puts("No input devices available!\n");
932 } else {
933 printf ("%s\n", stdio_devices[stdin]->name);
934 }
935
936 puts("Out: ");
937 if (stdio_devices[stdout] == NULL) {
938 puts("No output devices available!\n");
939 } else {
940 printf ("%s\n", stdio_devices[stdout]->name);
941 }
942
943 puts("Err: ");
944 if (stdio_devices[stderr] == NULL) {
945 puts("No error devices available!\n");
946 } else {
947 printf ("%s\n", stdio_devices[stderr]->name);
948 }
Jean-Christophe PLAGNIOL-VILLARD7e3be7c2009-05-16 12:14:55 +0200949}
950
Simon Glassb0265422017-01-16 07:03:26 -0700951#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
wdenk47d1a6e2002-11-03 00:01:44 +0000952/* Called after the relocation - use desired console functions */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100953int console_init_r(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000954{
955 char *stdinname, *stdoutname, *stderrname;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200956 struct stdio_dev *inputdev = NULL, *outputdev = NULL, *errdev = NULL;
wdenk6e592382004-04-18 17:39:38 +0000957 int i;
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100958 int iomux_err = 0;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200959 int flushpoint;
wdenk47d1a6e2002-11-03 00:01:44 +0000960
Patrick Delaunaybf46be72019-08-02 14:58:09 +0200961 /* update silent for env loaded from flash (initr_env) */
Patrick Delaunay13551b92019-08-02 14:58:10 +0200962 if (console_update_silent())
963 flushpoint = PRE_CONSOLE_FLUSHPOINT1_SERIAL;
964 else
965 flushpoint = PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL;
Patrick Delaunaybf46be72019-08-02 14:58:09 +0200966
wdenk47d1a6e2002-11-03 00:01:44 +0000967 /* set default handlers at first */
Martin Dorwig49cad542015-01-26 15:22:54 -0700968 gd->jt->getc = serial_getc;
969 gd->jt->tstc = serial_tstc;
970 gd->jt->putc = serial_putc;
971 gd->jt->puts = serial_puts;
972 gd->jt->printf = serial_printf;
wdenk47d1a6e2002-11-03 00:01:44 +0000973
974 /* stdin stdout and stderr are in environment */
975 /* scan for it */
Simon Glass00caae62017-08-03 12:22:12 -0600976 stdinname = env_get("stdin");
977 stdoutname = env_get("stdout");
978 stderrname = env_get("stderr");
wdenk47d1a6e2002-11-03 00:01:44 +0000979
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200980 if (OVERWRITE_CONSOLE == 0) { /* if not overwritten by config switch */
Andy Shevchenko32324872020-12-21 14:30:03 +0200981 inputdev = console_search_dev(DEV_FLAGS_INPUT, stdinname);
982 outputdev = console_search_dev(DEV_FLAGS_OUTPUT, stdoutname);
983 errdev = console_search_dev(DEV_FLAGS_OUTPUT, stderrname);
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100984 if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
985 iomux_err = iomux_doenv(stdin, stdinname);
986 iomux_err += iomux_doenv(stdout, stdoutname);
987 iomux_err += iomux_doenv(stderr, stderrname);
988 if (!iomux_err)
989 /* Successful, so skip all the code below. */
990 goto done;
991 }
wdenk47d1a6e2002-11-03 00:01:44 +0000992 }
993 /* if the devices are overwritten or not found, use default device */
994 if (inputdev == NULL) {
Andy Shevchenko32324872020-12-21 14:30:03 +0200995 inputdev = console_search_dev(DEV_FLAGS_INPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +0000996 }
997 if (outputdev == NULL) {
Andy Shevchenko32324872020-12-21 14:30:03 +0200998 outputdev = console_search_dev(DEV_FLAGS_OUTPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +0000999 }
1000 if (errdev == NULL) {
Andy Shevchenko32324872020-12-21 14:30:03 +02001001 errdev = console_search_dev(DEV_FLAGS_OUTPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +00001002 }
1003 /* Initializes output console first */
1004 if (outputdev != NULL) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001005 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +01001006 console_doenv(stdout, outputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001007 }
1008 if (errdev != NULL) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001009 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +01001010 console_doenv(stderr, errdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001011 }
1012 if (inputdev != NULL) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001013 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +01001014 console_doenv(stdin, inputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001015 }
1016
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001017done:
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001018
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001019 if (!IS_ENABLED(CONFIG_SYS_CONSOLE_INFO_QUIET))
1020 stdio_print_current_devices();
1021
Simon Glassa2931b32016-02-06 14:31:37 -07001022#ifdef CONFIG_VIDCONSOLE_AS_LCD
Patrick Delaunay27b5b9e2020-07-01 14:56:10 +02001023 if (strstr(stdoutname, CONFIG_VIDCONSOLE_AS_NAME))
Anatolij Gustschin22b897a2020-05-23 17:11:20 +02001024 printf("Warning: Please change '%s' to 'vidconsole' in stdout/stderr environment vars\n",
Patrick Delaunay27b5b9e2020-07-01 14:56:10 +02001025 CONFIG_VIDCONSOLE_AS_NAME);
Simon Glassa2931b32016-02-06 14:31:37 -07001026#endif
wdenk47d1a6e2002-11-03 00:01:44 +00001027
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001028 if (IS_ENABLED(CONFIG_SYS_CONSOLE_ENV_OVERWRITE)) {
1029 /* set the environment variables (will overwrite previous env settings) */
1030 for (i = 0; i < MAX_FILES; i++)
1031 env_set(stdio_names[i], stdio_devices[i]->name);
wdenk47d1a6e2002-11-03 00:01:44 +00001032 }
wdenk47d1a6e2002-11-03 00:01:44 +00001033
Joe Hershbergerc4e00572012-12-11 22:16:19 -06001034 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */
1035
Patrick Delaunay13551b92019-08-02 14:58:10 +02001036 print_pre_console_buffer(flushpoint);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001037 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +00001038}
1039
Simon Glassb0265422017-01-16 07:03:26 -07001040#else /* !CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */
wdenk47d1a6e2002-11-03 00:01:44 +00001041
1042/* Called after the relocation - use desired console functions */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001043int console_init_r(void)
wdenk47d1a6e2002-11-03 00:01:44 +00001044{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001045 struct stdio_dev *inputdev = NULL, *outputdev = NULL;
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001046 int i;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001047 struct list_head *list = stdio_get_list();
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001048 struct list_head *pos;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001049 struct stdio_dev *dev;
Patrick Delaunay13551b92019-08-02 14:58:10 +02001050 int flushpoint;
wdenk47d1a6e2002-11-03 00:01:44 +00001051
Patrick Delaunaybf46be72019-08-02 14:58:09 +02001052 /* update silent for env loaded from flash (initr_env) */
Patrick Delaunay13551b92019-08-02 14:58:10 +02001053 if (console_update_silent())
1054 flushpoint = PRE_CONSOLE_FLUSHPOINT1_SERIAL;
1055 else
1056 flushpoint = PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL;
Chris Packham43e0a3d2016-09-23 15:59:43 +12001057
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001058 /*
1059 * suppress all output if splash screen is enabled and we have
Anatolij Gustschina7490812010-03-16 15:29:33 +01001060 * a bmp to display. We redirect the output from frame buffer
1061 * console to serial console in this case or suppress it if
1062 * "silent" mode was requested.
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001063 */
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001064 if (IS_ENABLED(CONFIG_SPLASH_SCREEN) && env_get("splashimage")) {
Anatolij Gustschina7490812010-03-16 15:29:33 +01001065 if (!(gd->flags & GD_FLG_SILENT))
Andy Shevchenko32324872020-12-21 14:30:03 +02001066 outputdev = console_search_dev (DEV_FLAGS_OUTPUT, "serial");
Anatolij Gustschina7490812010-03-16 15:29:33 +01001067 }
wdenkf72da342003-10-10 10:05:42 +00001068
wdenk47d1a6e2002-11-03 00:01:44 +00001069 /* Scan devices looking for input and output devices */
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001070 list_for_each(pos, list) {
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001071 dev = list_entry(pos, struct stdio_dev, list);
wdenk47d1a6e2002-11-03 00:01:44 +00001072
1073 if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
1074 inputdev = dev;
1075 }
1076 if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
1077 outputdev = dev;
1078 }
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001079 if(inputdev && outputdev)
1080 break;
wdenk47d1a6e2002-11-03 00:01:44 +00001081 }
1082
1083 /* Initializes output console first */
1084 if (outputdev != NULL) {
Andy Shevchenko09d8f072021-02-11 17:09:39 +02001085 console_setfile_and_devices(stdout, outputdev);
1086 console_setfile_and_devices(stderr, outputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001087 }
1088
1089 /* Initializes input console */
Andy Shevchenko09d8f072021-02-11 17:09:39 +02001090 if (inputdev != NULL)
1091 console_setfile_and_devices(stdin, inputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001092
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001093 if (!IS_ENABLED(CONFIG_SYS_CONSOLE_INFO_QUIET))
1094 stdio_print_current_devices();
wdenk47d1a6e2002-11-03 00:01:44 +00001095
1096 /* Setting environment variables */
Tom Rini27b42252018-05-03 09:12:26 -04001097 for (i = 0; i < MAX_FILES; i++) {
Simon Glass382bee52017-08-03 12:22:09 -06001098 env_set(stdio_names[i], stdio_devices[i]->name);
wdenk47d1a6e2002-11-03 00:01:44 +00001099 }
1100
Joe Hershbergerc4e00572012-12-11 22:16:19 -06001101 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */
1102
Patrick Delaunay13551b92019-08-02 14:58:10 +02001103 print_pre_console_buffer(flushpoint);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001104 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +00001105}
1106
Simon Glassb0265422017-01-16 07:03:26 -07001107#endif /* CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */