1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright (C) 2009 Sergey Kubushyn <ksi@koi8.net>
4 *
5 * Changes for multibus/multiadapter I2C support.
6 *
7 * (C) Copyright 2000
8 * Paolo Scaffardi, AIRVENT SAM s.p.a - RIMINI(ITALY), arsenio@tin.it
9 */
10
11#include <config.h>
12#include <common.h>
13#include <dm.h>
14#include <errno.h>
15#include <log.h>
16#include <stdarg.h>
17#include <malloc.h>
18#include <stdio_dev.h>
19#include <serial.h>
20#include <splash.h>
21#include <i2c.h>
22#include <asm/global_data.h>
23#include <dm/device-internal.h>
24
25DECLARE_GLOBAL_DATA_PTR;
26
27static struct stdio_dev devs;
28struct stdio_dev *stdio_devices[] = { NULL, NULL, NULL };
29char *stdio_names[MAX_FILES] = { "stdin", "stdout", "stderr" };
30
31int 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
44#if CONFIG_IS_ENABLED(SYS_DEVICE_NULLDEV)
45static void nulldev_putc(struct stdio_dev *dev, const char c)
46{
47	/* nulldev is empty! */
48}
49
50static void nulldev_puts(struct stdio_dev *dev, const char *s)
51{
52	/* nulldev is empty! */
53}
54
55static int nulldev_input(struct stdio_dev *dev)
56{
57	/* nulldev is empty! */
58	return 0;
59}
60
61static 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
80static void stdio_serial_putc(struct stdio_dev *dev, const char c)
81{
82	serial_putc(c);
83}
84
85static void stdio_serial_puts(struct stdio_dev *dev, const char *s)
86{
87	serial_puts(s);
88}
89
90#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
91static void stdio_serial_flush(struct stdio_dev *dev)
92{
93	serial_flush();
94}
95#endif
96
97static int stdio_serial_getc(struct stdio_dev *dev)
98{
99	return serial_getc();
100}
101
102static int stdio_serial_tstc(struct stdio_dev *dev)
103{
104	return serial_tstc();
105}
106
107/**************************************************************************
108 * SYSTEM DRIVERS
109 **************************************************************************
110 */
111
112static void drv_system_init (void)
113{
114	struct stdio_dev dev;
115
116	memset (&dev, 0, sizeof (dev));
117
118	strcpy (dev.name, "serial");
119	dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT;
120	dev.putc = stdio_serial_putc;
121	dev.puts = stdio_serial_puts;
122	STDIO_DEV_ASSIGN_FLUSH(&dev, stdio_serial_flush);
123	dev.getc = stdio_serial_getc;
124	dev.tstc = stdio_serial_tstc;
125	stdio_register (&dev);
126
127	nulldev_register();
128}
129
130/**************************************************************************
131 * DEVICES
132 **************************************************************************
133 */
134struct list_head* stdio_get_list(void)
135{
136	return &devs.list;
137}
138
139/**
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
155 * Return: 0 if found, -ENOENT if no device found with that name, other -ve
156 *	   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)
168		seq = 0;
169	ret = uclass_get_device_by_seq(id, seq, &dev);
170	if (ret == -ENODEV)
171		ret = uclass_first_device_err(id, &dev);
172	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}
189
190struct stdio_dev *stdio_get_by_name(const char *name)
191{
192	struct list_head *pos;
193	struct stdio_dev *sdev;
194
195	if (!name)
196		return NULL;
197
198	list_for_each(pos, &devs.list) {
199		sdev = list_entry(pos, struct stdio_dev, list);
200		if (strcmp(sdev->name, name) == 0)
201			return sdev;
202	}
203	if (IS_ENABLED(CONFIG_VIDEO)) {
204		/*
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
214		 * console_init_r() -> console_search_dev() -> stdio_get_by_name()
215		 */
216		if (!strncmp(name, "vidconsole", 10) && !strchr(name, ',') &&
217		    !stdio_probe_device(name, UCLASS_VIDEO, &sdev))
218			return sdev;
219	}
220
221	return NULL;
222}
223
224struct stdio_dev *stdio_clone(struct stdio_dev *dev)
225{
226	struct stdio_dev *_dev;
227
228	if (!dev)
229		return NULL;
230
231	_dev = calloc(1, sizeof(struct stdio_dev));
232	if (!_dev)
233		return NULL;
234
235	memcpy(_dev, dev, sizeof(struct stdio_dev));
236
237	return _dev;
238}
239
240int stdio_register_dev(struct stdio_dev *dev, struct stdio_dev **devp)
241{
242	struct stdio_dev *_dev;
243
244	_dev = stdio_clone(dev);
245	if (!_dev)
246		return -ENODEV;
247	list_add_tail(&_dev->list, &devs.list);
248	if (devp)
249		*devp = _dev;
250
251	return 0;
252}
253
254int stdio_register(struct stdio_dev *dev)
255{
256	return stdio_register_dev(dev, NULL);
257}
258
259int stdio_deregister_dev(struct stdio_dev *dev, int force)
260{
261	struct list_head *pos;
262	char temp_names[3][STDIO_NAME_LEN];
263	int i;
264
265	/* get stdio devices (ListRemoveItem changes the dev list) */
266	for (i = 0 ; i < MAX_FILES; i++) {
267		if (stdio_devices[i] == dev) {
268			if (force) {
269				strcpy(temp_names[i], "nulldev");
270				continue;
271			}
272			/* Device is assigned -> report error */
273			return -EBUSY;
274		}
275		strlcpy(&temp_names[i][0], stdio_devices[i]->name,
276			sizeof(temp_names[i]));
277	}
278
279	list_del(&dev->list);
280	free(dev);
281
282	/* reassign device list */
283	list_for_each(pos, &devs.list) {
284		dev = list_entry(pos, struct stdio_dev, list);
285		for (i = 0 ; i < MAX_FILES; i++) {
286			if (strcmp(dev->name, temp_names[i]) == 0)
287				stdio_devices[i] = dev;
288		}
289	}
290
291	return 0;
292}
293
294int stdio_init_tables(void)
295{
296	/* Initialize the list */
297	INIT_LIST_HEAD(&devs.list);
298
299	return 0;
300}
301
302int stdio_add_devices(void)
303{
304	struct udevice *dev;
305	int ret;
306
307	if (IS_ENABLED(CONFIG_DM_KEYBOARD)) {
308		/*
309		 * For now we probe all the devices here. At some point this
310		 * should be done only when the devices are required - e.g. we
311		 * have a list of input devices to start up in the stdin
312		 * environment variable. That work probably makes more sense
313		 * when stdio itself is converted to driver model.
314		 */
315
316		/*
317		 * Don't report errors to the caller - assume that they are
318		 * non-fatal
319		 */
320		for (ret = uclass_first_device_check(UCLASS_KEYBOARD, &dev);
321				dev;
322				ret = uclass_next_device_check(&dev)) {
323			if (ret)
324				printf("%s: Failed to probe keyboard '%s' (ret=%d)\n",
325				       __func__, dev->name, ret);
326		}
327	}
328#if CONFIG_IS_ENABLED(SYS_I2C_LEGACY)
329	i2c_init_all();
330#endif
331	if (IS_ENABLED(CONFIG_VIDEO)) {
332		/*
333		 * If the console setting is not in environment variables then
334		 * console_init_r() will not be calling iomux_doenv() (which
335		 * calls console_search_dev()). So we will not dynamically add
336		 * devices by calling stdio_probe_device().
337		 *
338		 * So just probe all video devices now so that whichever one is
339		 * required will be available.
340		 */
341		struct udevice *vdev;
342		int ret;
343
344		if (!IS_ENABLED(CONFIG_SYS_CONSOLE_IS_IN_ENV)) {
345			for (ret = uclass_first_device_check(UCLASS_VIDEO,
346							     &vdev);
347					vdev;
348					ret = uclass_next_device_check(&vdev)) {
349				if (ret)
350					printf("%s: Failed to probe video device '%s' (ret=%d)\n",
351					       __func__, vdev->name, ret);
352			}
353		}
354		if (IS_ENABLED(CONFIG_SPLASH_SCREEN) &&
355		    IS_ENABLED(CONFIG_CMD_BMP))
356			splash_display();
357	}
358
359	drv_system_init();
360	serial_stdio_init();
361#ifdef CONFIG_USB_TTY
362	drv_usbtty_init();
363#endif
364#ifdef CONFIG_USB_FUNCTION_ACM
365	drv_usbacm_init ();
366#endif
367	if (IS_ENABLED(CONFIG_NETCONSOLE))
368		drv_nc_init();
369#ifdef CONFIG_JTAG_CONSOLE
370	drv_jtag_console_init();
371#endif
372	if (IS_ENABLED(CONFIG_CBMEM_CONSOLE))
373		cbmemc_init();
374
375	return 0;
376}
377