blob: 894cbd3fb448f08c9e03a656df672fd5c35a0f85 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
wdenk91d32562002-09-18 21:21:13 +00002/*
Heiko Schocher3f4978c2012-01-16 21:12:24 +00003 * Copyright (C) 2009 Sergey Kubushyn <ksi@koi8.net>
4 *
5 * Changes for multibus/multiadapter I2C support.
6 *
wdenk91d32562002-09-18 21:21:13 +00007 * (C) Copyright 2000
8 * Paolo Scaffardi, AIRVENT SAM s.p.a - RIMINI(ITALY), arsenio@tin.it
wdenk91d32562002-09-18 21:21:13 +00009 */
10
11#include <config.h>
12#include <common.h>
Simon Glassb206cd72015-10-18 21:17:15 -060013#include <dm.h>
Simon Glassd97143a2014-07-23 06:55:05 -060014#include <errno.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060015#include <log.h>
wdenk91d32562002-09-18 21:21:13 +000016#include <stdarg.h>
17#include <malloc.h>
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +020018#include <stdio_dev.h>
wdenk281e00a2004-08-01 22:48:16 +000019#include <serial.h>
Igor Opaniuk5eb83c02019-05-29 09:01:43 +000020#include <splash.h>
wdenk91d32562002-09-18 21:21:13 +000021#include <i2c.h>
Simon Glass401d1c42020-10-30 21:38:53 -060022#include <asm/global_data.h>
Simon Glassb206cd72015-10-18 21:17:15 -060023#include <dm/device-internal.h>
24
Wolfgang Denkd87080b2006-03-31 18:32:53 +020025DECLARE_GLOBAL_DATA_PTR;
26
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +020027static struct stdio_dev devs;
28struct stdio_dev *stdio_devices[] = { NULL, NULL, NULL };
wdenk91d32562002-09-18 21:21:13 +000029char *stdio_names[MAX_FILES] = { "stdin", "stdout", "stderr" };
30
Andy Shevchenkod9b0ac92021-02-11 17:09:36 +020031int stdio_file_to_flags(const int file)
32{
33 switch (file) {
34 case stdin:
35 return DEV_FLAGS_INPUT;
36 case stdout:
37 case stderr:
38 return DEV_FLAGS_OUTPUT;
39 default:
40 return -EINVAL;
41 }
42}
43
Andy Shevchenko99cb2b92021-02-11 17:09:35 +020044#if CONFIG_IS_ENABLED(SYS_DEVICE_NULLDEV)
Jeroen Hofstee654f8d02014-10-08 22:57:44 +020045static void nulldev_putc(struct stdio_dev *dev, const char c)
wdenk91d32562002-09-18 21:21:13 +000046{
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +020047 /* nulldev is empty! */
wdenk91d32562002-09-18 21:21:13 +000048}
49
Jeroen Hofstee654f8d02014-10-08 22:57:44 +020050static void nulldev_puts(struct stdio_dev *dev, const char *s)
wdenk91d32562002-09-18 21:21:13 +000051{
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +020052 /* nulldev is empty! */
wdenk91d32562002-09-18 21:21:13 +000053}
54
Jeroen Hofstee654f8d02014-10-08 22:57:44 +020055static int nulldev_input(struct stdio_dev *dev)
wdenk91d32562002-09-18 21:21:13 +000056{
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +020057 /* nulldev is empty! */
58 return 0;
wdenk91d32562002-09-18 21:21:13 +000059}
wdenk91d32562002-09-18 21:21:13 +000060
Andy Shevchenko99cb2b92021-02-11 17:09:35 +020061static void nulldev_register(void)
62{
63 struct stdio_dev dev;
64
65 memset(&dev, '\0', sizeof(dev));
66
67 strcpy(dev.name, "nulldev");
68 dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT;
69 dev.putc = nulldev_putc;
70 dev.puts = nulldev_puts;
71 dev.getc = nulldev_input;
72 dev.tstc = nulldev_input;
73
74 stdio_register(&dev);
75}
76#else
77static inline void nulldev_register(void) {}
78#endif /* SYS_DEVICE_NULLDEV */
79
Jeroen Hofstee654f8d02014-10-08 22:57:44 +020080static void stdio_serial_putc(struct stdio_dev *dev, const char c)
Simon Glass709ea542014-07-23 06:54:59 -060081{
82 serial_putc(c);
83}
84
Jeroen Hofstee654f8d02014-10-08 22:57:44 +020085static void stdio_serial_puts(struct stdio_dev *dev, const char *s)
Simon Glass709ea542014-07-23 06:54:59 -060086{
87 serial_puts(s);
88}
89
Pali Rohár78b52432022-09-05 11:31:19 +020090#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
91static void stdio_serial_flush(struct stdio_dev *dev)
92{
93 serial_flush();
94}
95#endif
96
Jeroen Hofstee654f8d02014-10-08 22:57:44 +020097static int stdio_serial_getc(struct stdio_dev *dev)
Simon Glass709ea542014-07-23 06:54:59 -060098{
99 return serial_getc();
100}
101
Jeroen Hofstee654f8d02014-10-08 22:57:44 +0200102static int stdio_serial_tstc(struct stdio_dev *dev)
Simon Glass709ea542014-07-23 06:54:59 -0600103{
104 return serial_tstc();
105}
106
wdenk91d32562002-09-18 21:21:13 +0000107/**************************************************************************
108 * SYSTEM DRIVERS
109 **************************************************************************
110 */
111
112static void drv_system_init (void)
113{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200114 struct stdio_dev dev;
wdenk91d32562002-09-18 21:21:13 +0000115
116 memset (&dev, 0, sizeof (dev));
117
118 strcpy (dev.name, "serial");
Bin Meng1caf9342015-11-03 23:23:37 -0800119 dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT;
Simon Glass709ea542014-07-23 06:54:59 -0600120 dev.putc = stdio_serial_putc;
121 dev.puts = stdio_serial_puts;
Pali Rohár78b52432022-09-05 11:31:19 +0200122 STDIO_DEV_ASSIGN_FLUSH(&dev, stdio_serial_flush);
Simon Glass709ea542014-07-23 06:54:59 -0600123 dev.getc = stdio_serial_getc;
124 dev.tstc = stdio_serial_tstc;
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200125 stdio_register (&dev);
wdenk91d32562002-09-18 21:21:13 +0000126
Andy Shevchenko99cb2b92021-02-11 17:09:35 +0200127 nulldev_register();
wdenk91d32562002-09-18 21:21:13 +0000128}
129
130/**************************************************************************
131 * DEVICES
132 **************************************************************************
133 */
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200134struct list_head* stdio_get_list(void)
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200135{
Simon Glass18c587d2020-08-11 11:23:40 -0600136 return &devs.list;
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200137}
138
Simon Glassd8441ea2016-10-05 20:42:16 -0600139/**
140 * stdio_probe_device() - Find a device which provides the given stdio device
141 *
142 * This looks for a device of the given uclass which provides a particular
143 * stdio device. It is currently really only useful for UCLASS_VIDEO.
144 *
145 * Ultimately we want to be able to probe a device by its stdio name. At
146 * present devices register in their probe function (for video devices this
147 * is done in vidconsole_post_probe()) and we don't know what name they will
148 * use until they do so.
149 * TODO(sjg@chromium.org): We should be able to determine the name before
150 * probing, and probe the required device.
151 *
152 * @name: stdio device name (e.g. "vidconsole")
153 * id: Uclass ID of device to look for (e.g. UCLASS_VIDEO)
154 * @sdevp: Returns stdout device, if found, else NULL
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100155 * Return: 0 if found, -ENOENT if no device found with that name, other -ve
Simon Glassd8441ea2016-10-05 20:42:16 -0600156 * on other error
157 */
158static int stdio_probe_device(const char *name, enum uclass_id id,
159 struct stdio_dev **sdevp)
160{
161 struct stdio_dev *sdev;
162 struct udevice *dev;
163 int seq, ret;
164
165 *sdevp = NULL;
166 seq = trailing_strtoln(name, NULL);
167 if (seq == -1)
Simon Glassd844efe2016-11-13 14:22:00 -0700168 seq = 0;
169 ret = uclass_get_device_by_seq(id, seq, &dev);
170 if (ret == -ENODEV)
Simon Glassd8441ea2016-10-05 20:42:16 -0600171 ret = uclass_first_device_err(id, &dev);
Simon Glassd8441ea2016-10-05 20:42:16 -0600172 if (ret) {
173 debug("No %s device for seq %d (%s)\n", uclass_get_name(id),
174 seq, name);
175 return ret;
176 }
177 /* The device should be be the last one registered */
178 sdev = list_empty(&devs.list) ? NULL :
179 list_last_entry(&devs.list, struct stdio_dev, list);
180 if (!sdev || strcmp(sdev->name, name)) {
181 debug("Device '%s' did not register with stdio as '%s'\n",
182 dev->name, name);
183 return -ENOENT;
184 }
185 *sdevp = sdev;
186
187 return 0;
188}
Simon Glassd8441ea2016-10-05 20:42:16 -0600189
Simon Glassab29a342016-11-13 14:21:59 -0700190struct stdio_dev *stdio_get_by_name(const char *name)
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200191{
192 struct list_head *pos;
Simon Glassd8441ea2016-10-05 20:42:16 -0600193 struct stdio_dev *sdev;
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200194
Simon Glassab29a342016-11-13 14:21:59 -0700195 if (!name)
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200196 return NULL;
197
Simon Glass18c587d2020-08-11 11:23:40 -0600198 list_for_each(pos, &devs.list) {
Simon Glassd8441ea2016-10-05 20:42:16 -0600199 sdev = list_entry(pos, struct stdio_dev, list);
200 if (strcmp(sdev->name, name) == 0)
201 return sdev;
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200202 }
Simon Glassb86986c2022-10-18 07:46:31 -0600203 if (IS_ENABLED(CONFIG_VIDEO)) {
Simon Glass5d4b6b12020-08-11 11:23:39 -0600204 /*
205 * We did not find a suitable stdio device. If there is a video
206 * driver with a name starting with 'vidconsole', we can try
207 * probing that in the hope that it will produce the required
208 * stdio device.
209 *
210 * This function is sometimes called with the entire value of
211 * 'stdout', which may include a list of devices separate by
212 * commas. Obviously this is not going to work, so we ignore
213 * that case. The call path in that case is
Andy Shevchenko32324872020-12-21 14:30:03 +0200214 * console_init_r() -> console_search_dev() -> stdio_get_by_name()
Simon Glass5d4b6b12020-08-11 11:23:39 -0600215 */
216 if (!strncmp(name, "vidconsole", 10) && !strchr(name, ',') &&
217 !stdio_probe_device(name, UCLASS_VIDEO, &sdev))
218 return sdev;
219 }
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200220
221 return NULL;
222}
223
Simon Glass4225f2f2020-08-11 11:23:41 -0600224struct stdio_dev *stdio_clone(struct stdio_dev *dev)
Jean-Christophe PLAGNIOL-VILLARD628ffd72008-09-01 17:11:26 +0200225{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200226 struct stdio_dev *_dev;
Jean-Christophe PLAGNIOL-VILLARD628ffd72008-09-01 17:11:26 +0200227
Simon Glass4225f2f2020-08-11 11:23:41 -0600228 if (!dev)
Jean-Christophe PLAGNIOL-VILLARD628ffd72008-09-01 17:11:26 +0200229 return NULL;
230
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200231 _dev = calloc(1, sizeof(struct stdio_dev));
Simon Glass4225f2f2020-08-11 11:23:41 -0600232 if (!_dev)
Jean-Christophe PLAGNIOL-VILLARD628ffd72008-09-01 17:11:26 +0200233 return NULL;
234
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200235 memcpy(_dev, dev, sizeof(struct stdio_dev));
Jean-Christophe PLAGNIOL-VILLARD628ffd72008-09-01 17:11:26 +0200236
237 return _dev;
238}
wdenk91d32562002-09-18 21:21:13 +0000239
Simon Glassd97143a2014-07-23 06:55:05 -0600240int stdio_register_dev(struct stdio_dev *dev, struct stdio_dev **devp)
wdenk91d32562002-09-18 21:21:13 +0000241{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200242 struct stdio_dev *_dev;
Jean-Christophe PLAGNIOL-VILLARD628ffd72008-09-01 17:11:26 +0200243
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200244 _dev = stdio_clone(dev);
Simon Glass4225f2f2020-08-11 11:23:41 -0600245 if (!_dev)
Simon Glassd97143a2014-07-23 06:55:05 -0600246 return -ENODEV;
Simon Glass18c587d2020-08-11 11:23:40 -0600247 list_add_tail(&_dev->list, &devs.list);
Simon Glassd97143a2014-07-23 06:55:05 -0600248 if (devp)
249 *devp = _dev;
250
wdenk91d32562002-09-18 21:21:13 +0000251 return 0;
252}
253
Simon Glassd97143a2014-07-23 06:55:05 -0600254int stdio_register(struct stdio_dev *dev)
255{
256 return stdio_register_dev(dev, NULL);
257}
258
Hans de Goede32d01922014-09-20 16:54:37 +0200259int stdio_deregister_dev(struct stdio_dev *dev, int force)
wdenk91d32562002-09-18 21:21:13 +0000260{
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200261 struct list_head *pos;
Bradley Bolen03bf22f2011-08-22 11:48:05 +0000262 char temp_names[3][16];
Simon Glass4225f2f2020-08-11 11:23:41 -0600263 int i;
wdenk91d32562002-09-18 21:21:13 +0000264
wdenk91d32562002-09-18 21:21:13 +0000265 /* get stdio devices (ListRemoveItem changes the dev list) */
Simon Glass4225f2f2020-08-11 11:23:41 -0600266 for (i = 0 ; i < MAX_FILES; i++) {
267 if (stdio_devices[i] == dev) {
Hans de Goede32d01922014-09-20 16:54:37 +0200268 if (force) {
Simon Glass4225f2f2020-08-11 11:23:41 -0600269 strcpy(temp_names[i], "nulldev");
Hans de Goede32d01922014-09-20 16:54:37 +0200270 continue;
271 }
wdenk91d32562002-09-18 21:21:13 +0000272 /* Device is assigned -> report error */
Simon Glass4225f2f2020-08-11 11:23:41 -0600273 return -EBUSY;
wdenk91d32562002-09-18 21:21:13 +0000274 }
Simon Glass4225f2f2020-08-11 11:23:41 -0600275 memcpy(&temp_names[i][0], stdio_devices[i]->name,
276 sizeof(temp_names[i]));
wdenk91d32562002-09-18 21:21:13 +0000277 }
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200278
Simon Glass18c587d2020-08-11 11:23:40 -0600279 list_del(&dev->list);
Hans de Goede88274b62014-09-24 14:06:09 +0200280 free(dev);
Jean-Christophe PLAGNIOL-VILLARDc1de7a62008-08-31 04:24:55 +0200281
Simon Glass4225f2f2020-08-11 11:23:41 -0600282 /* reassign device list */
Simon Glass18c587d2020-08-11 11:23:40 -0600283 list_for_each(pos, &devs.list) {
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200284 dev = list_entry(pos, struct stdio_dev, list);
Simon Glass4225f2f2020-08-11 11:23:41 -0600285 for (i = 0 ; i < MAX_FILES; i++) {
286 if (strcmp(dev->name, temp_names[i]) == 0)
287 stdio_devices[i] = dev;
wdenk91d32562002-09-18 21:21:13 +0000288 }
289 }
Simon Glass4225f2f2020-08-11 11:23:41 -0600290
wdenk91d32562002-09-18 21:21:13 +0000291 return 0;
292}
Simon Glassd97143a2014-07-23 06:55:05 -0600293
Simon Glass9fb02492014-09-03 17:37:01 -0600294int stdio_init_tables(void)
wdenk91d32562002-09-18 21:21:13 +0000295{
Wolfgang Denk2e5167c2010-10-28 20:00:11 +0200296#if defined(CONFIG_NEEDS_MANUAL_RELOC)
Peter Tyser521af042009-09-21 11:20:36 -0500297 /* already relocated for current ARM implementation */
wdenk91d32562002-09-18 21:21:13 +0000298 ulong relocation_offset = gd->reloc_off;
wdenk3595ac42003-06-22 17:18:28 +0000299 int i;
wdenk91d32562002-09-18 21:21:13 +0000300
301 /* relocate device name pointers */
302 for (i = 0; i < (sizeof (stdio_names) / sizeof (char *)); ++i) {
303 stdio_names[i] = (char *) (((ulong) stdio_names[i]) +
304 relocation_offset);
305 }
Wolfgang Denk2e5167c2010-10-28 20:00:11 +0200306#endif /* CONFIG_NEEDS_MANUAL_RELOC */
wdenk91d32562002-09-18 21:21:13 +0000307
308 /* Initialize the list */
Simon Glass18c587d2020-08-11 11:23:40 -0600309 INIT_LIST_HEAD(&devs.list);
wdenk91d32562002-09-18 21:21:13 +0000310
Simon Glass9fb02492014-09-03 17:37:01 -0600311 return 0;
312}
313
314int stdio_add_devices(void)
315{
Simon Glassb206cd72015-10-18 21:17:15 -0600316 struct udevice *dev;
Simon Glassb206cd72015-10-18 21:17:15 -0600317 int ret;
318
Simon Glass5d4b6b12020-08-11 11:23:39 -0600319 if (IS_ENABLED(CONFIG_DM_KEYBOARD)) {
320 /*
321 * For now we probe all the devices here. At some point this
322 * should be done only when the devices are required - e.g. we
323 * have a list of input devices to start up in the stdin
324 * environment variable. That work probably makes more sense
325 * when stdio itself is converted to driver model.
Simon Glass5d4b6b12020-08-11 11:23:39 -0600326 */
Simon Glass5d4b6b12020-08-11 11:23:39 -0600327
328 /*
329 * Don't report errors to the caller - assume that they are
330 * non-fatal
331 */
Michal Suchanek7ff12632022-10-12 21:57:55 +0200332 for (ret = uclass_first_device_check(UCLASS_KEYBOARD, &dev);
333 dev;
334 ret = uclass_next_device_check(&dev)) {
Simon Glass5d4b6b12020-08-11 11:23:39 -0600335 if (ret)
Michal Suchanek7ff12632022-10-12 21:57:55 +0200336 printf("%s: Failed to probe keyboard '%s' (ret=%d)\n",
337 __func__, dev->name, ret);
Simon Glass5d4b6b12020-08-11 11:23:39 -0600338 }
Simon Glassb206cd72015-10-18 21:17:15 -0600339 }
Tom Rini55dabcc2021-08-18 23:12:24 -0400340#if CONFIG_IS_ENABLED(SYS_I2C_LEGACY)
Heiko Schocher3f4978c2012-01-16 21:12:24 +0000341 i2c_init_all();
Heiko Schocher3f4978c2012-01-16 21:12:24 +0000342#endif
Simon Glassb86986c2022-10-18 07:46:31 -0600343 if (IS_ENABLED(CONFIG_VIDEO)) {
Simon Glass5d4b6b12020-08-11 11:23:39 -0600344 /*
345 * If the console setting is not in environment variables then
346 * console_init_r() will not be calling iomux_doenv() (which
Andy Shevchenko32324872020-12-21 14:30:03 +0200347 * calls console_search_dev()). So we will not dynamically add
Simon Glass5d4b6b12020-08-11 11:23:39 -0600348 * devices by calling stdio_probe_device().
349 *
350 * So just probe all video devices now so that whichever one is
351 * required will be available.
352 */
353 struct udevice *vdev;
354 int ret;
Simon Glasse3b81c12016-01-18 19:52:23 -0700355
Simon Glass5d4b6b12020-08-11 11:23:39 -0600356 if (!IS_ENABLED(CONFIG_SYS_CONSOLE_IS_IN_ENV)) {
Michal Suchanek7ff12632022-10-12 21:57:55 +0200357 for (ret = uclass_first_device_check(UCLASS_VIDEO,
358 &vdev);
359 vdev;
360 ret = uclass_next_device_check(&vdev)) {
361 if (ret)
362 printf("%s: Failed to probe video device '%s' (ret=%d)\n",
363 __func__, vdev->name, ret);
364 }
Simon Glass5d4b6b12020-08-11 11:23:39 -0600365 }
366 if (IS_ENABLED(CONFIG_SPLASH_SCREEN) &&
367 IS_ENABLED(CONFIG_CMD_BMP))
368 splash_display();
Simon Glass5d4b6b12020-08-11 11:23:39 -0600369 }
370
Simon Glass5d4b6b12020-08-11 11:23:39 -0600371 drv_system_init();
372 serial_stdio_init();
wdenk232c1502004-03-12 00:14:09 +0000373#ifdef CONFIG_USB_TTY
Simon Glass5d4b6b12020-08-11 11:23:39 -0600374 drv_usbtty_init();
wdenk232c1502004-03-12 00:14:09 +0000375#endif
Loic Poulainfc2b3992021-11-25 18:16:15 +0100376#ifdef CONFIG_USB_FUNCTION_ACM
377 drv_usbacm_init ();
378#endif
Simon Glass5d4b6b12020-08-11 11:23:39 -0600379 if (IS_ENABLED(CONFIG_NETCONSOLE))
380 drv_nc_init();
Mike Frysinger36ea8e92008-10-11 21:51:20 -0400381#ifdef CONFIG_JTAG_CONSOLE
Simon Glass5d4b6b12020-08-11 11:23:39 -0600382 drv_jtag_console_init();
Mike Frysinger36ea8e92008-10-11 21:51:20 -0400383#endif
Simon Glass5d4b6b12020-08-11 11:23:39 -0600384 if (IS_ENABLED(CONFIG_CBMEM_CONSOLE))
385 cbmemc_init();
Simon Glass9fb02492014-09-03 17:37:01 -0600386
387 return 0;
388}