Merge branch 'master' of git://git.denx.de/u-boot-imx
[platform/kernel/u-boot.git] / common / stdio.c
1 /*
2  * Copyright (C) 2009 Sergey Kubushyn <ksi@koi8.net>
3  *
4  * Changes for multibus/multiadapter I2C support.
5  *
6  * (C) Copyright 2000
7  * Paolo Scaffardi, AIRVENT SAM s.p.a - RIMINI(ITALY), arsenio@tin.it
8  *
9  * SPDX-License-Identifier:     GPL-2.0+
10  */
11
12 #include <config.h>
13 #include <common.h>
14 #include <dm.h>
15 #include <errno.h>
16 #include <stdarg.h>
17 #include <malloc.h>
18 #include <stdio_dev.h>
19 #include <serial.h>
20 #ifdef CONFIG_LOGBUFFER
21 #include <logbuff.h>
22 #endif
23
24 #if defined(CONFIG_SYS_I2C)
25 #include <i2c.h>
26 #endif
27
28 #include <dm/device-internal.h>
29
30 DECLARE_GLOBAL_DATA_PTR;
31
32 static struct stdio_dev devs;
33 struct stdio_dev *stdio_devices[] = { NULL, NULL, NULL };
34 char *stdio_names[MAX_FILES] = { "stdin", "stdout", "stderr" };
35
36 #if defined(CONFIG_SPLASH_SCREEN) && !defined(CONFIG_SYS_DEVICE_NULLDEV)
37 #define CONFIG_SYS_DEVICE_NULLDEV       1
38 #endif
39
40 #if CONFIG_IS_ENABLED(SYS_STDIO_DEREGISTER)
41 #define CONFIG_SYS_DEVICE_NULLDEV       1
42 #endif
43
44 #ifdef CONFIG_SYS_DEVICE_NULLDEV
45 static void nulldev_putc(struct stdio_dev *dev, const char c)
46 {
47         /* nulldev is empty! */
48 }
49
50 static void nulldev_puts(struct stdio_dev *dev, const char *s)
51 {
52         /* nulldev is empty! */
53 }
54
55 static int nulldev_input(struct stdio_dev *dev)
56 {
57         /* nulldev is empty! */
58         return 0;
59 }
60 #endif
61
62 static void stdio_serial_putc(struct stdio_dev *dev, const char c)
63 {
64         serial_putc(c);
65 }
66
67 static void stdio_serial_puts(struct stdio_dev *dev, const char *s)
68 {
69         serial_puts(s);
70 }
71
72 static int stdio_serial_getc(struct stdio_dev *dev)
73 {
74         return serial_getc();
75 }
76
77 static int stdio_serial_tstc(struct stdio_dev *dev)
78 {
79         return serial_tstc();
80 }
81
82 /**************************************************************************
83  * SYSTEM DRIVERS
84  **************************************************************************
85  */
86
87 static void drv_system_init (void)
88 {
89         struct stdio_dev dev;
90
91         memset (&dev, 0, sizeof (dev));
92
93         strcpy (dev.name, "serial");
94         dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT;
95         dev.putc = stdio_serial_putc;
96         dev.puts = stdio_serial_puts;
97         dev.getc = stdio_serial_getc;
98         dev.tstc = stdio_serial_tstc;
99         stdio_register (&dev);
100
101 #ifdef CONFIG_SYS_DEVICE_NULLDEV
102         memset (&dev, 0, sizeof (dev));
103
104         strcpy (dev.name, "nulldev");
105         dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT;
106         dev.putc = nulldev_putc;
107         dev.puts = nulldev_puts;
108         dev.getc = nulldev_input;
109         dev.tstc = nulldev_input;
110
111         stdio_register (&dev);
112 #endif
113 }
114
115 /**************************************************************************
116  * DEVICES
117  **************************************************************************
118  */
119 struct list_head* stdio_get_list(void)
120 {
121         return &(devs.list);
122 }
123
124 #ifdef CONFIG_DM_VIDEO
125 /**
126  * stdio_probe_device() - Find a device which provides the given stdio device
127  *
128  * This looks for a device of the given uclass which provides a particular
129  * stdio device. It is currently really only useful for UCLASS_VIDEO.
130  *
131  * Ultimately we want to be able to probe a device by its stdio name. At
132  * present devices register in their probe function (for video devices this
133  * is done in vidconsole_post_probe()) and we don't know what name they will
134  * use until they do so.
135  * TODO(sjg@chromium.org): We should be able to determine the name before
136  * probing, and probe the required device.
137  *
138  * @name:       stdio device name (e.g. "vidconsole")
139  * id:          Uclass ID of device to look for (e.g. UCLASS_VIDEO)
140  * @sdevp:      Returns stdout device, if found, else NULL
141  * @return 0 if found, -ENOENT if no device found with that name, other -ve
142  *         on other error
143  */
144 static int stdio_probe_device(const char *name, enum uclass_id id,
145                               struct stdio_dev **sdevp)
146 {
147         struct stdio_dev *sdev;
148         struct udevice *dev;
149         int seq, ret;
150
151         *sdevp = NULL;
152         seq = trailing_strtoln(name, NULL);
153         if (seq == -1)
154                 seq = 0;
155         ret = uclass_get_device_by_seq(id, seq, &dev);
156         if (ret == -ENODEV)
157                 ret = uclass_first_device_err(id, &dev);
158         if (ret) {
159                 debug("No %s device for seq %d (%s)\n", uclass_get_name(id),
160                       seq, name);
161                 return ret;
162         }
163         /* The device should be be the last one registered */
164         sdev = list_empty(&devs.list) ? NULL :
165                         list_last_entry(&devs.list, struct stdio_dev, list);
166         if (!sdev || strcmp(sdev->name, name)) {
167                 debug("Device '%s' did not register with stdio as '%s'\n",
168                       dev->name, name);
169                 return -ENOENT;
170         }
171         *sdevp = sdev;
172
173         return 0;
174 }
175 #endif
176
177 struct stdio_dev *stdio_get_by_name(const char *name)
178 {
179         struct list_head *pos;
180         struct stdio_dev *sdev;
181
182         if (!name)
183                 return NULL;
184
185         list_for_each(pos, &(devs.list)) {
186                 sdev = list_entry(pos, struct stdio_dev, list);
187                 if (strcmp(sdev->name, name) == 0)
188                         return sdev;
189         }
190 #ifdef CONFIG_DM_VIDEO
191         /*
192          * We did not find a suitable stdio device. If there is a video
193          * driver with a name starting with 'vidconsole', we can try probing
194          * that in the hope that it will produce the required stdio device.
195          *
196          * This function is sometimes called with the entire value of
197          * 'stdout', which may include a list of devices separate by commas.
198          * Obviously this is not going to work, so we ignore that case. The
199          * call path in that case is console_init_r() -> search_device() ->
200          * stdio_get_by_name().
201          */
202         if (!strncmp(name, "vidconsole", 10) && !strchr(name, ',') &&
203             !stdio_probe_device(name, UCLASS_VIDEO, &sdev))
204                 return sdev;
205 #endif
206
207         return NULL;
208 }
209
210 struct stdio_dev* stdio_clone(struct stdio_dev *dev)
211 {
212         struct stdio_dev *_dev;
213
214         if(!dev)
215                 return NULL;
216
217         _dev = calloc(1, sizeof(struct stdio_dev));
218
219         if(!_dev)
220                 return NULL;
221
222         memcpy(_dev, dev, sizeof(struct stdio_dev));
223
224         return _dev;
225 }
226
227 int stdio_register_dev(struct stdio_dev *dev, struct stdio_dev **devp)
228 {
229         struct stdio_dev *_dev;
230
231         _dev = stdio_clone(dev);
232         if(!_dev)
233                 return -ENODEV;
234         list_add_tail(&(_dev->list), &(devs.list));
235         if (devp)
236                 *devp = _dev;
237
238         return 0;
239 }
240
241 int stdio_register(struct stdio_dev *dev)
242 {
243         return stdio_register_dev(dev, NULL);
244 }
245
246 /* deregister the device "devname".
247  * returns 0 if success, -1 if device is assigned and 1 if devname not found
248  */
249 #if CONFIG_IS_ENABLED(SYS_STDIO_DEREGISTER)
250 int stdio_deregister_dev(struct stdio_dev *dev, int force)
251 {
252         int l;
253         struct list_head *pos;
254         char temp_names[3][16];
255
256         /* get stdio devices (ListRemoveItem changes the dev list) */
257         for (l=0 ; l< MAX_FILES; l++) {
258                 if (stdio_devices[l] == dev) {
259                         if (force) {
260                                 strcpy(temp_names[l], "nulldev");
261                                 continue;
262                         }
263                         /* Device is assigned -> report error */
264                         return -1;
265                 }
266                 memcpy (&temp_names[l][0],
267                         stdio_devices[l]->name,
268                         sizeof(temp_names[l]));
269         }
270
271         list_del(&(dev->list));
272         free(dev);
273
274         /* reassign Device list */
275         list_for_each(pos, &(devs.list)) {
276                 dev = list_entry(pos, struct stdio_dev, list);
277                 for (l=0 ; l< MAX_FILES; l++) {
278                         if(strcmp(dev->name, temp_names[l]) == 0)
279                                 stdio_devices[l] = dev;
280                 }
281         }
282         return 0;
283 }
284
285 int stdio_deregister(const char *devname, int force)
286 {
287         struct stdio_dev *dev;
288
289         dev = stdio_get_by_name(devname);
290
291         if (!dev) /* device not found */
292                 return -ENODEV;
293
294         return stdio_deregister_dev(dev, force);
295 }
296 #endif /* CONFIG_IS_ENABLED(SYS_STDIO_DEREGISTER) */
297
298 int stdio_init_tables(void)
299 {
300 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
301         /* already relocated for current ARM implementation */
302         ulong relocation_offset = gd->reloc_off;
303         int i;
304
305         /* relocate device name pointers */
306         for (i = 0; i < (sizeof (stdio_names) / sizeof (char *)); ++i) {
307                 stdio_names[i] = (char *) (((ulong) stdio_names[i]) +
308                                                 relocation_offset);
309         }
310 #endif /* CONFIG_NEEDS_MANUAL_RELOC */
311
312         /* Initialize the list */
313         INIT_LIST_HEAD(&(devs.list));
314
315         return 0;
316 }
317
318 int stdio_add_devices(void)
319 {
320 #ifdef CONFIG_DM_KEYBOARD
321         struct udevice *dev;
322         struct uclass *uc;
323         int ret;
324
325         /*
326          * For now we probe all the devices here. At some point this should be
327          * done only when the devices are required - e.g. we have a list of
328          * input devices to start up in the stdin environment variable. That
329          * work probably makes more sense when stdio itself is converted to
330          * driver model.
331          *
332          * TODO(sjg@chromium.org): Convert changing uclass_first_device() etc.
333          * to return the device even on error. Then we could use that here.
334          */
335         ret = uclass_get(UCLASS_KEYBOARD, &uc);
336         if (ret)
337                 return ret;
338
339         /* Don't report errors to the caller - assume that they are non-fatal */
340         uclass_foreach_dev(dev, uc) {
341                 ret = device_probe(dev);
342                 if (ret)
343                         printf("Failed to probe keyboard '%s'\n", dev->name);
344         }
345 #endif
346 #ifdef CONFIG_SYS_I2C
347         i2c_init_all();
348 #else
349 #endif
350 #ifdef CONFIG_DM_VIDEO
351         /*
352          * If the console setting is not in environment variables then
353          * console_init_r() will not be calling iomux_doenv() (which calls
354          * search_device()). So we will not dynamically add devices by
355          * calling stdio_probe_device().
356          *
357          * So just probe all video devices now so that whichever one is
358          * required will be available.
359          */
360 #ifndef CONFIG_SYS_CONSOLE_IS_IN_ENV
361         struct udevice *vdev;
362 # ifndef CONFIG_DM_KEYBOARD
363         int ret;
364 # endif
365
366         for (ret = uclass_first_device(UCLASS_VIDEO, &vdev);
367              vdev;
368              ret = uclass_next_device(&vdev))
369                 ;
370         if (ret)
371                 printf("%s: Video device failed (ret=%d)\n", __func__, ret);
372 #endif /* !CONFIG_SYS_CONSOLE_IS_IN_ENV */
373 #else
374 # if defined(CONFIG_LCD)
375         drv_lcd_init ();
376 # endif
377 # if defined(CONFIG_VIDEO) || defined(CONFIG_CFB_CONSOLE)
378         drv_video_init ();
379 # endif
380 #endif /* CONFIG_DM_VIDEO */
381 #if defined(CONFIG_KEYBOARD) && !defined(CONFIG_DM_KEYBOARD)
382         drv_keyboard_init ();
383 #endif
384 #ifdef CONFIG_LOGBUFFER
385         drv_logbuff_init ();
386 #endif
387         drv_system_init ();
388         serial_stdio_init ();
389 #ifdef CONFIG_USB_TTY
390         drv_usbtty_init ();
391 #endif
392 #ifdef CONFIG_NETCONSOLE
393         drv_nc_init ();
394 #endif
395 #ifdef CONFIG_JTAG_CONSOLE
396         drv_jtag_console_init ();
397 #endif
398 #ifdef CONFIG_CBMEM_CONSOLE
399         cbmemc_init();
400 #endif
401
402         return 0;
403 }
404
405 int stdio_init(void)
406 {
407         stdio_init_tables();
408         stdio_add_devices();
409
410         return 0;
411 }