blob: 2bccc8ab1032f66b45a2d5f28b95331431ed2ca1 [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{
Simon Glass4057e272021-11-19 13:23:47 -0700351 if (gd->flags & GD_FLG_DEVINIT)
352 console_puts_select(stderr, serial_only, s);
Simon Glass493a4c82020-07-02 21:12:13 -0600353}
354
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100355static void console_puts(int file, const char *s)
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100356{
357 int i;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200358 struct stdio_dev *dev;
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100359
Andy Shevchenko400797c2021-02-11 17:09:42 +0200360 for_each_console_dev(i, file, dev) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100361 if (dev->puts != NULL)
Simon Glass709ea542014-07-23 06:54:59 -0600362 dev->puts(dev, s);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100363 }
364}
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100365
Tom Rini5e63c962019-10-30 09:18:43 -0400366#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200367static inline void console_doenv(int file, struct stdio_dev *dev)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100368{
369 iomux_doenv(file, dev->name);
370}
Tom Rini5e63c962019-10-30 09:18:43 -0400371#endif
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100372#else
Patrick Delaunay45375ad2020-12-18 12:46:44 +0100373
Andy Shevchenko09d8f072021-02-11 17:09:39 +0200374static void console_devices_set(int file, struct stdio_dev *dev)
Patrick Delaunay45375ad2020-12-18 12:46:44 +0100375{
376}
377
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200378static inline bool console_needs_start_stop(int file, struct stdio_dev *sdev)
379{
380 return true;
381}
382
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100383static inline int console_getc(int file)
384{
Simon Glass709ea542014-07-23 06:54:59 -0600385 return stdio_devices[file]->getc(stdio_devices[file]);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100386}
387
Patrick Delaunaya17b38c2020-12-18 12:46:46 +0100388static bool console_has_tstc(void)
389{
390 return false;
391}
392
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100393static inline int console_tstc(int file)
394{
Simon Glass709ea542014-07-23 06:54:59 -0600395 return stdio_devices[file]->tstc(stdio_devices[file]);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100396}
397
398static inline void console_putc(int file, const char c)
399{
Simon Glass709ea542014-07-23 06:54:59 -0600400 stdio_devices[file]->putc(stdio_devices[file], c);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100401}
402
Simon Glass493a4c82020-07-02 21:12:13 -0600403void console_puts_select(int file, bool serial_only, const char *s)
Siarhei Siamashka27669662015-01-08 09:02:31 +0200404{
Simon Glass4057e272021-11-19 13:23:47 -0700405 if ((gd->flags & GD_FLG_DEVINIT) &&
406 serial_only == console_dev_is_serial(stdio_devices[file]))
Hans de Goedea8552c72015-05-05 13:13:36 +0200407 stdio_devices[file]->puts(stdio_devices[file], s);
Siarhei Siamashka27669662015-01-08 09:02:31 +0200408}
Siarhei Siamashka27669662015-01-08 09:02:31 +0200409
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100410static inline void console_puts(int file, const char *s)
411{
Simon Glass709ea542014-07-23 06:54:59 -0600412 stdio_devices[file]->puts(stdio_devices[file], s);
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100413}
414
Tom Rini5e63c962019-10-30 09:18:43 -0400415#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200416static inline void console_doenv(int file, struct stdio_dev *dev)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100417{
418 console_setfile(file, dev);
419}
Tom Rini5e63c962019-10-30 09:18:43 -0400420#endif
Simon Glassb0265422017-01-16 07:03:26 -0700421#endif /* CONIFIG_IS_ENABLED(CONSOLE_MUX) */
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100422
Andy Shevchenko09d8f072021-02-11 17:09:39 +0200423static void __maybe_unused console_setfile_and_devices(int file, struct stdio_dev *dev)
424{
425 console_setfile(file, dev);
426 console_devices_set(file, dev);
427}
428
Andy Shevchenko41f668b2020-12-21 14:30:00 +0200429int console_start(int file, struct stdio_dev *sdev)
430{
431 int error;
432
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200433 if (!console_needs_start_stop(file, sdev))
434 return 0;
435
Andy Shevchenko41f668b2020-12-21 14:30:00 +0200436 /* Start new device */
437 if (sdev->start) {
438 error = sdev->start(sdev);
439 /* If it's not started don't use it */
440 if (error < 0)
441 return error;
442 }
443 return 0;
444}
445
446void console_stop(int file, struct stdio_dev *sdev)
447{
Andy Shevchenko95aaf402020-12-21 14:30:01 +0200448 if (!console_needs_start_stop(file, sdev))
449 return;
450
Andy Shevchenko41f668b2020-12-21 14:30:00 +0200451 if (sdev->stop)
452 sdev->stop(sdev);
453}
454
wdenk47d1a6e2002-11-03 00:01:44 +0000455/** U-Boot INITIAL CONSOLE-NOT COMPATIBLE FUNCTIONS *************************/
456
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200457int serial_printf(const char *fmt, ...)
wdenk47d1a6e2002-11-03 00:01:44 +0000458{
459 va_list args;
460 uint i;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200461 char printbuffer[CONFIG_SYS_PBSIZE];
wdenk47d1a6e2002-11-03 00:01:44 +0000462
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100463 va_start(args, fmt);
wdenk47d1a6e2002-11-03 00:01:44 +0000464
465 /* For this to work, printbuffer must be larger than
466 * anything we ever want to print.
467 */
Sonny Rao068af6f2011-10-10 09:22:31 +0000468 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100469 va_end(args);
wdenk47d1a6e2002-11-03 00:01:44 +0000470
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100471 serial_puts(printbuffer);
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200472 return i;
wdenk47d1a6e2002-11-03 00:01:44 +0000473}
474
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100475int fgetc(int file)
wdenk47d1a6e2002-11-03 00:01:44 +0000476{
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100477 if (file < MAX_FILES) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100478 /*
479 * Effectively poll for input wherever it may be available.
480 */
481 for (;;) {
Andreas J. Reichel64407462016-07-13 12:56:51 +0200482 WATCHDOG_RESET();
Patrick Delaunaya17b38c2020-12-18 12:46:46 +0100483 if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
484 /*
485 * Upper layer may have already called tstc() so
486 * check for that first.
487 */
488 if (console_has_tstc())
489 return console_getc(file);
490 console_tstc(file);
491 } else {
492 if (console_tstc(file))
493 return console_getc(file);
494 }
495
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100496 /*
497 * If the watchdog must be rate-limited then it should
498 * already be handled in board-specific code.
499 */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100500 if (IS_ENABLED(CONFIG_WATCHDOG))
501 udelay(1);
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100502 }
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100503 }
wdenk47d1a6e2002-11-03 00:01:44 +0000504
505 return -1;
506}
507
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100508int ftstc(int file)
wdenk47d1a6e2002-11-03 00:01:44 +0000509{
510 if (file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100511 return console_tstc(file);
wdenk47d1a6e2002-11-03 00:01:44 +0000512
513 return -1;
514}
515
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100516void fputc(int file, const char c)
wdenk47d1a6e2002-11-03 00:01:44 +0000517{
518 if (file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100519 console_putc(file, c);
wdenk47d1a6e2002-11-03 00:01:44 +0000520}
521
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100522void fputs(int file, const char *s)
wdenk47d1a6e2002-11-03 00:01:44 +0000523{
524 if (file < MAX_FILES)
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +0100525 console_puts(file, s);
wdenk47d1a6e2002-11-03 00:01:44 +0000526}
527
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200528int fprintf(int file, const char *fmt, ...)
wdenk47d1a6e2002-11-03 00:01:44 +0000529{
530 va_list args;
531 uint i;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200532 char printbuffer[CONFIG_SYS_PBSIZE];
wdenk47d1a6e2002-11-03 00:01:44 +0000533
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100534 va_start(args, fmt);
wdenk47d1a6e2002-11-03 00:01:44 +0000535
536 /* For this to work, printbuffer must be larger than
537 * anything we ever want to print.
538 */
Sonny Rao068af6f2011-10-10 09:22:31 +0000539 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100540 va_end(args);
wdenk47d1a6e2002-11-03 00:01:44 +0000541
542 /* Send to desired file */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100543 fputs(file, printbuffer);
Wolfgang Denkd9c27252010-06-20 17:14:14 +0200544 return i;
wdenk47d1a6e2002-11-03 00:01:44 +0000545}
546
547/** U-Boot INITIAL CONSOLE-COMPATIBLE FUNCTION *****************************/
548
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200549int getchar(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000550{
Patrick Delaunay1e993712020-12-18 12:46:45 +0100551 int ch;
552
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100553 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100554 return 0;
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100555
Graeme Russe3e454c2011-08-29 02:14:05 +0000556 if (!gd->have_console)
557 return 0;
558
Patrick Delaunay1e993712020-12-18 12:46:45 +0100559 ch = console_record_getc();
560 if (ch != -1)
561 return ch;
Simon Glass9854a872015-11-08 23:47:48 -0700562
wdenk47d1a6e2002-11-03 00:01:44 +0000563 if (gd->flags & GD_FLG_DEVINIT) {
564 /* Get from the standard input */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100565 return fgetc(stdin);
wdenk47d1a6e2002-11-03 00:01:44 +0000566 }
567
568 /* Send directly to the handler */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100569 return serial_getc();
wdenk47d1a6e2002-11-03 00:01:44 +0000570}
571
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100572int tstc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000573{
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100574 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100575 return 0;
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100576
Graeme Russe3e454c2011-08-29 02:14:05 +0000577 if (!gd->have_console)
578 return 0;
Patrick Delaunay1e993712020-12-18 12:46:45 +0100579
580 if (console_record_tstc())
581 return 1;
582
wdenk47d1a6e2002-11-03 00:01:44 +0000583 if (gd->flags & GD_FLG_DEVINIT) {
584 /* Test the standard input */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100585 return ftstc(stdin);
wdenk47d1a6e2002-11-03 00:01:44 +0000586 }
587
588 /* Send directly to the handler */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100589 return serial_tstc();
wdenk47d1a6e2002-11-03 00:01:44 +0000590}
591
Siarhei Siamashka27669662015-01-08 09:02:31 +0200592#define PRE_CONSOLE_FLUSHPOINT1_SERIAL 0
593#define PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL 1
594
Simon Glass8f925582016-10-17 20:12:36 -0600595#if CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
Graeme Russ9558b482011-09-01 00:48:27 +0000596#define CIRC_BUF_IDX(idx) ((idx) % (unsigned long)CONFIG_PRE_CON_BUF_SZ)
597
598static void pre_console_putc(const char c)
599{
Simon Glass4e6bafa2017-06-15 21:37:52 -0600600 char *buffer;
601
602 buffer = map_sysmem(CONFIG_PRE_CON_BUF_ADDR, CONFIG_PRE_CON_BUF_SZ);
Graeme Russ9558b482011-09-01 00:48:27 +0000603
604 buffer[CIRC_BUF_IDX(gd->precon_buf_idx++)] = c;
Simon Glass4e6bafa2017-06-15 21:37:52 -0600605
606 unmap_sysmem(buffer);
Graeme Russ9558b482011-09-01 00:48:27 +0000607}
608
Soeren Mochbe135cc2017-11-04 16:14:09 +0100609static void pre_console_puts(const char *s)
610{
611 while (*s)
612 pre_console_putc(*s++);
613}
614
Siarhei Siamashka27669662015-01-08 09:02:31 +0200615static void print_pre_console_buffer(int flushpoint)
Graeme Russ9558b482011-09-01 00:48:27 +0000616{
Hans de Goedea8552c72015-05-05 13:13:36 +0200617 unsigned long in = 0, out = 0;
Hans de Goedea8552c72015-05-05 13:13:36 +0200618 char buf_out[CONFIG_PRE_CON_BUF_SZ + 1];
Simon Glass4e6bafa2017-06-15 21:37:52 -0600619 char *buf_in;
Graeme Russ9558b482011-09-01 00:48:27 +0000620
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100621 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT))
Patrick Delaunay13551b92019-08-02 14:58:10 +0200622 return;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200623
Simon Glass4e6bafa2017-06-15 21:37:52 -0600624 buf_in = map_sysmem(CONFIG_PRE_CON_BUF_ADDR, CONFIG_PRE_CON_BUF_SZ);
Graeme Russ9558b482011-09-01 00:48:27 +0000625 if (gd->precon_buf_idx > CONFIG_PRE_CON_BUF_SZ)
Hans de Goedea8552c72015-05-05 13:13:36 +0200626 in = gd->precon_buf_idx - CONFIG_PRE_CON_BUF_SZ;
Graeme Russ9558b482011-09-01 00:48:27 +0000627
Hans de Goedea8552c72015-05-05 13:13:36 +0200628 while (in < gd->precon_buf_idx)
629 buf_out[out++] = buf_in[CIRC_BUF_IDX(in++)];
Simon Glass4e6bafa2017-06-15 21:37:52 -0600630 unmap_sysmem(buf_in);
Hans de Goedea8552c72015-05-05 13:13:36 +0200631
632 buf_out[out] = 0;
633
634 switch (flushpoint) {
635 case PRE_CONSOLE_FLUSHPOINT1_SERIAL:
636 puts(buf_out);
637 break;
638 case PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL:
Simon Glass493a4c82020-07-02 21:12:13 -0600639 console_puts_select(stdout, false, buf_out);
Hans de Goedea8552c72015-05-05 13:13:36 +0200640 break;
641 }
Graeme Russ9558b482011-09-01 00:48:27 +0000642}
643#else
644static inline void pre_console_putc(const char c) {}
Soeren Mochbe135cc2017-11-04 16:14:09 +0100645static inline void pre_console_puts(const char *s) {}
Siarhei Siamashka27669662015-01-08 09:02:31 +0200646static inline void print_pre_console_buffer(int flushpoint) {}
Graeme Russ9558b482011-09-01 00:48:27 +0000647#endif
648
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100649void putc(const char c)
wdenk47d1a6e2002-11-03 00:01:44 +0000650{
Patrick Delaunay93cdb522020-11-27 11:20:56 +0100651 if (!gd)
652 return;
Patrick Delaunay1e993712020-12-18 12:46:45 +0100653
654 console_record_putc(c);
655
Simon Glass64e9b4f2017-12-04 13:48:19 -0700656 /* sandbox can send characters to stdout before it has a console */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100657 if (IS_ENABLED(CONFIG_SANDBOX) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glass64e9b4f2017-12-04 13:48:19 -0700658 os_putc(c);
659 return;
660 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100661
Simon Glassd6ea5302015-06-23 15:38:33 -0600662 /* if we don't have a console yet, use the debug UART */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100663 if (IS_ENABLED(CONFIG_DEBUG_UART) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glassd6ea5302015-06-23 15:38:33 -0600664 printch(c);
665 return;
666 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100667
668 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT)) {
Patrick Delaunay13551b92019-08-02 14:58:10 +0200669 if (!(gd->flags & GD_FLG_DEVINIT))
670 pre_console_putc(c);
wdenkf6e20fc2004-02-08 19:38:38 +0000671 return;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200672 }
wdenka6cccae2004-02-06 21:48:22 +0000673
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100674 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100675 return;
Mark Jacksonf5c3ba72008-08-25 19:21:30 +0100676
Graeme Russe3e454c2011-08-29 02:14:05 +0000677 if (!gd->have_console)
Graeme Russ9558b482011-09-01 00:48:27 +0000678 return pre_console_putc(c);
Graeme Russe3e454c2011-08-29 02:14:05 +0000679
wdenk47d1a6e2002-11-03 00:01:44 +0000680 if (gd->flags & GD_FLG_DEVINIT) {
681 /* Send to the standard output */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100682 fputc(stdout, c);
wdenk47d1a6e2002-11-03 00:01:44 +0000683 } else {
684 /* Send directly to the handler */
Siarhei Siamashka27669662015-01-08 09:02:31 +0200685 pre_console_putc(c);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100686 serial_putc(c);
wdenk47d1a6e2002-11-03 00:01:44 +0000687 }
688}
689
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100690void puts(const char *s)
wdenk47d1a6e2002-11-03 00:01:44 +0000691{
Patrick Delaunay93cdb522020-11-27 11:20:56 +0100692 if (!gd)
693 return;
Patrick Delaunay1e993712020-12-18 12:46:45 +0100694
695 console_record_puts(s);
696
Simon Glass36bcea62018-11-15 18:44:04 -0700697 /* sandbox can send characters to stdout before it has a console */
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100698 if (IS_ENABLED(CONFIG_SANDBOX) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Simon Glass36bcea62018-11-15 18:44:04 -0700699 os_puts(s);
700 return;
701 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100702
703 if (IS_ENABLED(CONFIG_DEBUG_UART) && !(gd->flags & GD_FLG_SERIAL_READY)) {
Soeren Mochbe135cc2017-11-04 16:14:09 +0100704 while (*s) {
705 int ch = *s++;
706
707 printch(ch);
708 }
709 return;
710 }
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100711
712 if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT)) {
Patrick Delaunay13551b92019-08-02 14:58:10 +0200713 if (!(gd->flags & GD_FLG_DEVINIT))
714 pre_console_puts(s);
Soeren Mochbe135cc2017-11-04 16:14:09 +0100715 return;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200716 }
Soeren Mochbe135cc2017-11-04 16:14:09 +0100717
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100718 if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
Soeren Mochbe135cc2017-11-04 16:14:09 +0100719 return;
Soeren Mochbe135cc2017-11-04 16:14:09 +0100720
721 if (!gd->have_console)
722 return pre_console_puts(s);
723
724 if (gd->flags & GD_FLG_DEVINIT) {
725 /* Send to the standard output */
726 fputs(stdout, s);
727 } else {
728 /* Send directly to the handler */
729 pre_console_puts(s);
730 serial_puts(s);
731 }
wdenk47d1a6e2002-11-03 00:01:44 +0000732}
733
Simon Glass9854a872015-11-08 23:47:48 -0700734#ifdef CONFIG_CONSOLE_RECORD
735int console_record_init(void)
736{
737 int ret;
738
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100739 ret = membuff_new((struct membuff *)&gd->console_out,
Simon Glass8ce465e2021-10-23 17:26:03 -0600740 gd->flags & GD_FLG_RELOC ?
741 CONFIG_CONSOLE_RECORD_OUT_SIZE :
742 CONFIG_CONSOLE_RECORD_OUT_SIZE_F);
Simon Glass9854a872015-11-08 23:47:48 -0700743 if (ret)
744 return ret;
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100745 ret = membuff_new((struct membuff *)&gd->console_in,
746 CONFIG_CONSOLE_RECORD_IN_SIZE);
Simon Glass9854a872015-11-08 23:47:48 -0700747
748 return ret;
749}
750
751void console_record_reset(void)
752{
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100753 membuff_purge((struct membuff *)&gd->console_out);
754 membuff_purge((struct membuff *)&gd->console_in);
Simon Glassc1a2bb42021-05-08 06:59:56 -0600755 gd->flags &= ~GD_FLG_RECORD_OVF;
Simon Glass9854a872015-11-08 23:47:48 -0700756}
757
Simon Glassbd347152020-07-28 19:41:11 -0600758int console_record_reset_enable(void)
Simon Glass9854a872015-11-08 23:47:48 -0700759{
760 console_record_reset();
761 gd->flags |= GD_FLG_RECORD;
Simon Glassbd347152020-07-28 19:41:11 -0600762
763 return 0;
Simon Glass9854a872015-11-08 23:47:48 -0700764}
Simon Glassb6123122020-01-27 08:49:54 -0700765
766int console_record_readline(char *str, int maxlen)
767{
Simon Glassc1a2bb42021-05-08 06:59:56 -0600768 if (gd->flags & GD_FLG_RECORD_OVF)
769 return -ENOSPC;
770
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100771 return membuff_readline((struct membuff *)&gd->console_out, str,
772 maxlen, ' ');
Simon Glassb6123122020-01-27 08:49:54 -0700773}
774
775int console_record_avail(void)
776{
Heinrich Schuchardta3a9e042020-02-12 18:23:49 +0100777 return membuff_avail((struct membuff *)&gd->console_out);
Simon Glassb6123122020-01-27 08:49:54 -0700778}
779
Steffen Jaeckel25c8b9f2021-07-08 15:57:40 +0200780int console_in_puts(const char *str)
781{
782 return membuff_put((struct membuff *)&gd->console_in, str, strlen(str));
783}
784
Simon Glass9854a872015-11-08 23:47:48 -0700785#endif
786
wdenk47d1a6e2002-11-03 00:01:44 +0000787/* test if ctrl-c was pressed */
788static int ctrlc_disabled = 0; /* see disable_ctrl() */
789static int ctrlc_was_pressed = 0;
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100790int ctrlc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000791{
wdenk47d1a6e2002-11-03 00:01:44 +0000792 if (!ctrlc_disabled && gd->have_console) {
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100793 if (tstc()) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200794 switch (getchar()) {
wdenk47d1a6e2002-11-03 00:01:44 +0000795 case 0x03: /* ^C - Control C */
796 ctrlc_was_pressed = 1;
797 return 1;
798 default:
799 break;
800 }
801 }
802 }
Simon Glass8969ea32014-09-14 12:40:15 -0600803
wdenk47d1a6e2002-11-03 00:01:44 +0000804 return 0;
805}
Pierre Auberta5dffa42014-04-24 10:30:07 +0200806/* Reads user's confirmation.
807 Returns 1 if user's input is "y", "Y", "yes" or "YES"
808*/
809int confirm_yesno(void)
810{
811 int i;
812 char str_input[5];
wdenk47d1a6e2002-11-03 00:01:44 +0000813
Pierre Auberta5dffa42014-04-24 10:30:07 +0200814 /* Flush input */
815 while (tstc())
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200816 getchar();
Pierre Auberta5dffa42014-04-24 10:30:07 +0200817 i = 0;
818 while (i < sizeof(str_input)) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200819 str_input[i] = getchar();
Pierre Auberta5dffa42014-04-24 10:30:07 +0200820 putc(str_input[i]);
821 if (str_input[i] == '\r')
822 break;
823 i++;
824 }
825 putc('\n');
826 if (strncmp(str_input, "y\r", 2) == 0 ||
827 strncmp(str_input, "Y\r", 2) == 0 ||
828 strncmp(str_input, "yes\r", 4) == 0 ||
829 strncmp(str_input, "YES\r", 4) == 0)
830 return 1;
831 return 0;
832}
wdenk47d1a6e2002-11-03 00:01:44 +0000833/* pass 1 to disable ctrlc() checking, 0 to enable.
834 * returns previous state
835 */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100836int disable_ctrlc(int disable)
wdenk47d1a6e2002-11-03 00:01:44 +0000837{
838 int prev = ctrlc_disabled; /* save previous state */
839
840 ctrlc_disabled = disable;
841 return prev;
842}
843
844int had_ctrlc (void)
845{
846 return ctrlc_was_pressed;
847}
848
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100849void clear_ctrlc(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000850{
851 ctrlc_was_pressed = 0;
852}
853
wdenk47d1a6e2002-11-03 00:01:44 +0000854/** U-Boot INIT FUNCTIONS *************************************************/
855
Andy Shevchenko32324872020-12-21 14:30:03 +0200856struct stdio_dev *console_search_dev(int flags, const char *name)
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200857{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200858 struct stdio_dev *dev;
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200859
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200860 dev = stdio_get_by_name(name);
Simon Glassa2931b32016-02-06 14:31:37 -0700861#ifdef CONFIG_VIDCONSOLE_AS_LCD
Patrick Delaunay27b5b9e2020-07-01 14:56:10 +0200862 if (!dev && !strcmp(name, CONFIG_VIDCONSOLE_AS_NAME))
Simon Glassa2931b32016-02-06 14:31:37 -0700863 dev = stdio_get_by_name("vidconsole");
864#endif
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200865
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100866 if (dev && (dev->flags & flags))
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200867 return dev;
868
869 return NULL;
870}
871
Mike Frysingerd7be3052010-10-20 07:18:03 -0400872int console_assign(int file, const char *devname)
wdenk47d1a6e2002-11-03 00:01:44 +0000873{
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200874 int flag;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200875 struct stdio_dev *dev;
wdenk47d1a6e2002-11-03 00:01:44 +0000876
877 /* Check for valid file */
Andy Shevchenko7b9ca3f2021-02-11 17:09:37 +0200878 flag = stdio_file_to_flags(file);
879 if (flag < 0)
880 return flag;
wdenk47d1a6e2002-11-03 00:01:44 +0000881
882 /* Check for valid device name */
883
Andy Shevchenko32324872020-12-21 14:30:03 +0200884 dev = console_search_dev(flag, devname);
wdenk47d1a6e2002-11-03 00:01:44 +0000885
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100886 if (dev)
887 return console_setfile(file, dev);
wdenk47d1a6e2002-11-03 00:01:44 +0000888
889 return -1;
890}
891
Patrick Delaunay13551b92019-08-02 14:58:10 +0200892/* return true if the 'silent' flag is removed */
893static bool console_update_silent(void)
Chris Packham43e0a3d2016-09-23 15:59:43 +1200894{
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100895 unsigned long flags = gd->flags;
896
897 if (!IS_ENABLED(CONFIG_SILENT_CONSOLE))
898 return false;
899
Patrick Delaunay13551b92019-08-02 14:58:10 +0200900 if (env_get("silent")) {
Chris Packham43e0a3d2016-09-23 15:59:43 +1200901 gd->flags |= GD_FLG_SILENT;
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100902 return false;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200903 }
Patrick Delaunay13551b92019-08-02 14:58:10 +0200904
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100905 gd->flags &= ~GD_FLG_SILENT;
906
907 return !!(flags & GD_FLG_SILENT);
Chris Packham43e0a3d2016-09-23 15:59:43 +1200908}
909
Simon Glassb0895382017-06-15 21:37:50 -0600910int console_announce_r(void)
911{
912#if !CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
913 char buf[DISPLAY_OPTIONS_BANNER_LENGTH];
914
915 display_options_get_banner(false, buf, sizeof(buf));
916
Simon Glass493a4c82020-07-02 21:12:13 -0600917 console_puts_select(stdout, false, buf);
Simon Glassb0895382017-06-15 21:37:50 -0600918#endif
919
920 return 0;
921}
922
wdenk47d1a6e2002-11-03 00:01:44 +0000923/* Called before relocation - use serial functions */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100924int console_init_f(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000925{
wdenk47d1a6e2002-11-03 00:01:44 +0000926 gd->have_console = 1;
wdenkf72da342003-10-10 10:05:42 +0000927
Chris Packham43e0a3d2016-09-23 15:59:43 +1200928 console_update_silent();
wdenkf72da342003-10-10 10:05:42 +0000929
Siarhei Siamashka27669662015-01-08 09:02:31 +0200930 print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT1_SERIAL);
Graeme Russ9558b482011-09-01 00:48:27 +0000931
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100932 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +0000933}
934
Jean-Christophe PLAGNIOL-VILLARD7e3be7c2009-05-16 12:14:55 +0200935void stdio_print_current_devices(void)
936{
Jean-Christophe PLAGNIOL-VILLARD7e3be7c2009-05-16 12:14:55 +0200937 /* Print information */
938 puts("In: ");
939 if (stdio_devices[stdin] == NULL) {
940 puts("No input devices available!\n");
941 } else {
942 printf ("%s\n", stdio_devices[stdin]->name);
943 }
944
945 puts("Out: ");
946 if (stdio_devices[stdout] == NULL) {
947 puts("No output devices available!\n");
948 } else {
949 printf ("%s\n", stdio_devices[stdout]->name);
950 }
951
952 puts("Err: ");
953 if (stdio_devices[stderr] == NULL) {
954 puts("No error devices available!\n");
955 } else {
956 printf ("%s\n", stdio_devices[stderr]->name);
957 }
Jean-Christophe PLAGNIOL-VILLARD7e3be7c2009-05-16 12:14:55 +0200958}
959
Simon Glassb0265422017-01-16 07:03:26 -0700960#if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
wdenk47d1a6e2002-11-03 00:01:44 +0000961/* Called after the relocation - use desired console functions */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +0100962int console_init_r(void)
wdenk47d1a6e2002-11-03 00:01:44 +0000963{
964 char *stdinname, *stdoutname, *stderrname;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200965 struct stdio_dev *inputdev = NULL, *outputdev = NULL, *errdev = NULL;
wdenk6e592382004-04-18 17:39:38 +0000966 int i;
Gary Jennejohn16a28ef2008-11-06 15:04:23 +0100967 int iomux_err = 0;
Patrick Delaunay13551b92019-08-02 14:58:10 +0200968 int flushpoint;
wdenk47d1a6e2002-11-03 00:01:44 +0000969
Patrick Delaunaybf46be72019-08-02 14:58:09 +0200970 /* update silent for env loaded from flash (initr_env) */
Patrick Delaunay13551b92019-08-02 14:58:10 +0200971 if (console_update_silent())
972 flushpoint = PRE_CONSOLE_FLUSHPOINT1_SERIAL;
973 else
974 flushpoint = PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL;
Patrick Delaunaybf46be72019-08-02 14:58:09 +0200975
wdenk47d1a6e2002-11-03 00:01:44 +0000976 /* set default handlers at first */
Martin Dorwig49cad542015-01-26 15:22:54 -0700977 gd->jt->getc = serial_getc;
978 gd->jt->tstc = serial_tstc;
979 gd->jt->putc = serial_putc;
980 gd->jt->puts = serial_puts;
981 gd->jt->printf = serial_printf;
wdenk47d1a6e2002-11-03 00:01:44 +0000982
983 /* stdin stdout and stderr are in environment */
984 /* scan for it */
Simon Glass00caae62017-08-03 12:22:12 -0600985 stdinname = env_get("stdin");
986 stdoutname = env_get("stdout");
987 stderrname = env_get("stderr");
wdenk47d1a6e2002-11-03 00:01:44 +0000988
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200989 if (OVERWRITE_CONSOLE == 0) { /* if not overwritten by config switch */
Andy Shevchenko32324872020-12-21 14:30:03 +0200990 inputdev = console_search_dev(DEV_FLAGS_INPUT, stdinname);
991 outputdev = console_search_dev(DEV_FLAGS_OUTPUT, stdoutname);
992 errdev = console_search_dev(DEV_FLAGS_OUTPUT, stderrname);
Patrick Delaunayc04f8562020-12-18 12:46:43 +0100993 if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
994 iomux_err = iomux_doenv(stdin, stdinname);
995 iomux_err += iomux_doenv(stdout, stdoutname);
996 iomux_err += iomux_doenv(stderr, stderrname);
997 if (!iomux_err)
998 /* Successful, so skip all the code below. */
999 goto done;
1000 }
wdenk47d1a6e2002-11-03 00:01:44 +00001001 }
1002 /* if the devices are overwritten or not found, use default device */
1003 if (inputdev == NULL) {
Andy Shevchenko32324872020-12-21 14:30:03 +02001004 inputdev = console_search_dev(DEV_FLAGS_INPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +00001005 }
1006 if (outputdev == NULL) {
Andy Shevchenko32324872020-12-21 14:30:03 +02001007 outputdev = console_search_dev(DEV_FLAGS_OUTPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +00001008 }
1009 if (errdev == NULL) {
Andy Shevchenko32324872020-12-21 14:30:03 +02001010 errdev = console_search_dev(DEV_FLAGS_OUTPUT, "serial");
wdenk47d1a6e2002-11-03 00:01:44 +00001011 }
1012 /* Initializes output console first */
1013 if (outputdev != NULL) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001014 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +01001015 console_doenv(stdout, outputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001016 }
1017 if (errdev != NULL) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001018 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +01001019 console_doenv(stderr, errdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001020 }
1021 if (inputdev != NULL) {
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001022 /* need to set a console if not done above. */
Jean-Christophe PLAGNIOL-VILLARD5f032012009-02-01 17:07:52 +01001023 console_doenv(stdin, inputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001024 }
1025
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001026done:
Gary Jennejohn16a28ef2008-11-06 15:04:23 +01001027
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001028 if (!IS_ENABLED(CONFIG_SYS_CONSOLE_INFO_QUIET))
1029 stdio_print_current_devices();
1030
Simon Glassa2931b32016-02-06 14:31:37 -07001031#ifdef CONFIG_VIDCONSOLE_AS_LCD
Patrick Delaunay27b5b9e2020-07-01 14:56:10 +02001032 if (strstr(stdoutname, CONFIG_VIDCONSOLE_AS_NAME))
Anatolij Gustschin22b897a2020-05-23 17:11:20 +02001033 printf("Warning: Please change '%s' to 'vidconsole' in stdout/stderr environment vars\n",
Patrick Delaunay27b5b9e2020-07-01 14:56:10 +02001034 CONFIG_VIDCONSOLE_AS_NAME);
Simon Glassa2931b32016-02-06 14:31:37 -07001035#endif
wdenk47d1a6e2002-11-03 00:01:44 +00001036
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001037 if (IS_ENABLED(CONFIG_SYS_CONSOLE_ENV_OVERWRITE)) {
1038 /* set the environment variables (will overwrite previous env settings) */
1039 for (i = 0; i < MAX_FILES; i++)
1040 env_set(stdio_names[i], stdio_devices[i]->name);
wdenk47d1a6e2002-11-03 00:01:44 +00001041 }
wdenk47d1a6e2002-11-03 00:01:44 +00001042
Joe Hershbergerc4e00572012-12-11 22:16:19 -06001043 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */
1044
Patrick Delaunay13551b92019-08-02 14:58:10 +02001045 print_pre_console_buffer(flushpoint);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001046 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +00001047}
1048
Simon Glassb0265422017-01-16 07:03:26 -07001049#else /* !CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */
wdenk47d1a6e2002-11-03 00:01:44 +00001050
1051/* Called after the relocation - use desired console functions */
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001052int console_init_r(void)
wdenk47d1a6e2002-11-03 00:01:44 +00001053{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001054 struct stdio_dev *inputdev = NULL, *outputdev = NULL;
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001055 int i;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001056 struct list_head *list = stdio_get_list();
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001057 struct list_head *pos;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001058 struct stdio_dev *dev;
Patrick Delaunay13551b92019-08-02 14:58:10 +02001059 int flushpoint;
wdenk47d1a6e2002-11-03 00:01:44 +00001060
Patrick Delaunaybf46be72019-08-02 14:58:09 +02001061 /* update silent for env loaded from flash (initr_env) */
Patrick Delaunay13551b92019-08-02 14:58:10 +02001062 if (console_update_silent())
1063 flushpoint = PRE_CONSOLE_FLUSHPOINT1_SERIAL;
1064 else
1065 flushpoint = PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL;
Chris Packham43e0a3d2016-09-23 15:59:43 +12001066
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001067 /*
1068 * suppress all output if splash screen is enabled and we have
Anatolij Gustschina7490812010-03-16 15:29:33 +01001069 * a bmp to display. We redirect the output from frame buffer
1070 * console to serial console in this case or suppress it if
1071 * "silent" mode was requested.
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001072 */
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001073 if (IS_ENABLED(CONFIG_SPLASH_SCREEN) && env_get("splashimage")) {
Anatolij Gustschina7490812010-03-16 15:29:33 +01001074 if (!(gd->flags & GD_FLG_SILENT))
Andy Shevchenko32324872020-12-21 14:30:03 +02001075 outputdev = console_search_dev (DEV_FLAGS_OUTPUT, "serial");
Anatolij Gustschina7490812010-03-16 15:29:33 +01001076 }
wdenkf72da342003-10-10 10:05:42 +00001077
wdenk47d1a6e2002-11-03 00:01:44 +00001078 /* Scan devices looking for input and output devices */
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001079 list_for_each(pos, list) {
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +02001080 dev = list_entry(pos, struct stdio_dev, list);
wdenk47d1a6e2002-11-03 00:01:44 +00001081
1082 if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
1083 inputdev = dev;
1084 }
1085 if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
1086 outputdev = dev;
1087 }
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +02001088 if(inputdev && outputdev)
1089 break;
wdenk47d1a6e2002-11-03 00:01:44 +00001090 }
1091
1092 /* Initializes output console first */
1093 if (outputdev != NULL) {
Andy Shevchenko09d8f072021-02-11 17:09:39 +02001094 console_setfile_and_devices(stdout, outputdev);
1095 console_setfile_and_devices(stderr, outputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001096 }
1097
1098 /* Initializes input console */
Andy Shevchenko09d8f072021-02-11 17:09:39 +02001099 if (inputdev != NULL)
1100 console_setfile_and_devices(stdin, inputdev);
wdenk47d1a6e2002-11-03 00:01:44 +00001101
Patrick Delaunayc04f8562020-12-18 12:46:43 +01001102 if (!IS_ENABLED(CONFIG_SYS_CONSOLE_INFO_QUIET))
1103 stdio_print_current_devices();
wdenk47d1a6e2002-11-03 00:01:44 +00001104
1105 /* Setting environment variables */
Tom Rini27b42252018-05-03 09:12:26 -04001106 for (i = 0; i < MAX_FILES; i++) {
Simon Glass382bee52017-08-03 12:22:09 -06001107 env_set(stdio_names[i], stdio_devices[i]->name);
wdenk47d1a6e2002-11-03 00:01:44 +00001108 }
1109
Joe Hershbergerc4e00572012-12-11 22:16:19 -06001110 gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */
1111
Patrick Delaunay13551b92019-08-02 14:58:10 +02001112 print_pre_console_buffer(flushpoint);
Jean-Christophe PLAGNIOL-VILLARDec6f1492009-02-01 17:07:51 +01001113 return 0;
wdenk47d1a6e2002-11-03 00:01:44 +00001114}
1115
Simon Glassb0265422017-01-16 07:03:26 -07001116#endif /* CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */