common/stdio.c

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