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 }