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_HARD_I2C) || 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                 ret = uclass_first_device_err(id, &dev);
 155         else
 156                 ret = uclass_get_device_by_seq(id, seq, &dev);
 157         if (ret) {
 158                 debug("No %s device for seq %d (%s)\n", uclass_get_name(id),
 159                       seq, name);
 160                 return ret;
 161         }
 162         /* The device should be be the last one registered */
 163         sdev = list_empty(&devs.list) ? NULL :
 164                         list_last_entry(&devs.list, struct stdio_dev, list);
 165         if (!sdev || strcmp(sdev->name, name)) {
 166                 debug("Device '%s' did not register with stdio as '%s'\n",
 167                       dev->name, name);
 168                 return -ENOENT;
 169         }
 170         *sdevp = sdev;
 171
 172         return 0;
 173 }
 174 #endif
 175
 176 struct stdio_dev* stdio_get_by_name(const char *name)
 177 {
 178         struct list_head *pos;
 179         struct stdio_dev *sdev;
 180
 181         if(!name)
 182                 return NULL;
 183
 184         list_for_each(pos, &(devs.list)) {
 185                 sdev = list_entry(pos, struct stdio_dev, list);
 186                 if (strcmp(sdev->name, name) == 0)
 187                         return sdev;
 188         }
 189 #ifdef CONFIG_DM_VIDEO
 190         /*
 191          * We did not find a suitable stdio device. If there is a video
 192          * driver with a name starting with 'vidconsole', we can try probing
 193          * that in the hope that it will produce the required stdio device.
 194          *
 195          * This function is sometimes called with the entire value of
 196          * 'stdout', which may include a list of devices separate by commas.
 197          * Obviously this is not going to work, so we ignore that case. The
 198          * call path in that case is console_init_r() -> search_device() ->
 199          * stdio_get_by_name().
 200          */
 201         if (!strncmp(name, "vidconsole", 10) && !strchr(name, ',') &&
 202             !stdio_probe_device(name, UCLASS_VIDEO, &sdev))
 203                 return sdev;
 204 #endif
 205
 206         return NULL;
 207 }
 208
 209 struct stdio_dev* stdio_clone(struct stdio_dev *dev)
 210 {
 211         struct stdio_dev *_dev;
 212
 213         if(!dev)
 214                 return NULL;
 215
 216         _dev = calloc(1, sizeof(struct stdio_dev));
 217
 218         if(!_dev)
 219                 return NULL;
 220
 221         memcpy(_dev, dev, sizeof(struct stdio_dev));
 222
 223         return _dev;
 224 }
 225
 226 int stdio_register_dev(struct stdio_dev *dev, struct stdio_dev **devp)
 227 {
 228         struct stdio_dev *_dev;
 229
 230         _dev = stdio_clone(dev);
 231         if(!_dev)
 232                 return -ENODEV;
 233         list_add_tail(&(_dev->list), &(devs.list));
 234         if (devp)
 235                 *devp = _dev;
 236
 237         return 0;
 238 }
 239
 240 int stdio_register(struct stdio_dev *dev)
 241 {
 242         return stdio_register_dev(dev, NULL);
 243 }
 244
 245 /* deregister the device "devname".
 246  * returns 0 if success, -1 if device is assigned and 1 if devname not found
 247  */
 248 #if CONFIG_IS_ENABLED(SYS_STDIO_DEREGISTER)
 249 int stdio_deregister_dev(struct stdio_dev *dev, int force)
 250 {
 251         int l;
 252         struct list_head *pos;
 253         char temp_names[3][16];
 254
 255         /* get stdio devices (ListRemoveItem changes the dev list) */
 256         for (l=0 ; l< MAX_FILES; l++) {
 257                 if (stdio_devices[l] == dev) {
 258                         if (force) {
 259                                 strcpy(temp_names[l], "nulldev");
 260                                 continue;
 261                         }
 262                         /* Device is assigned -> report error */
 263                         return -1;
 264                 }
 265                 memcpy (&temp_names[l][0],
 266                         stdio_devices[l]->name,
 267                         sizeof(temp_names[l]));
 268         }
 269
 270         list_del(&(dev->list));
 271         free(dev);
 272
 273         /* reassign Device list */
 274         list_for_each(pos, &(devs.list)) {
 275                 dev = list_entry(pos, struct stdio_dev, list);
 276                 for (l=0 ; l< MAX_FILES; l++) {
 277                         if(strcmp(dev->name, temp_names[l]) == 0)
 278                                 stdio_devices[l] = dev;
 279                 }
 280         }
 281         return 0;
 282 }
 283
 284 int stdio_deregister(const char *devname, int force)
 285 {
 286         struct stdio_dev *dev;
 287
 288         dev = stdio_get_by_name(devname);
 289
 290         if (!dev) /* device not found */
 291                 return -ENODEV;
 292
 293         return stdio_deregister_dev(dev, force);
 294 }
 295 #endif /* CONFIG_IS_ENABLED(SYS_STDIO_DEREGISTER) */
 296
 297 int stdio_init_tables(void)
 298 {
 299 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
 300         /* already relocated for current ARM implementation */
 301         ulong relocation_offset = gd->reloc_off;
 302         int i;
 303
 304         /* relocate device name pointers */
 305         for (i = 0; i < (sizeof (stdio_names) / sizeof (char *)); ++i) {
 306                 stdio_names[i] = (char *) (((ulong) stdio_names[i]) +
 307                                                 relocation_offset);
 308         }
 309 #endif /* CONFIG_NEEDS_MANUAL_RELOC */
 310
 311         /* Initialize the list */
 312         INIT_LIST_HEAD(&(devs.list));
 313
 314         return 0;
 315 }
 316
 317 int stdio_add_devices(void)
 318 {
 319 #ifdef CONFIG_DM_KEYBOARD
 320         struct udevice *dev;
 321         struct uclass *uc;
 322         int ret;
 323
 324         /*
 325          * For now we probe all the devices here. At some point this should be
 326          * done only when the devices are required - e.g. we have a list of
 327          * input devices to start up in the stdin environment variable. That
 328          * work probably makes more sense when stdio itself is converted to
 329          * driver model.
 330          *
 331          * TODO(sjg@chromium.org): Convert changing uclass_first_device() etc.
 332          * to return the device even on error. Then we could use that here.
 333          */
 334         ret = uclass_get(UCLASS_KEYBOARD, &uc);
 335         if (ret)
 336                 return ret;
 337
 338         /* Don't report errors to the caller - assume that they are non-fatal */
 339         uclass_foreach_dev(dev, uc) {
 340                 ret = device_probe(dev);
 341                 if (ret)
 342                         printf("Failed to probe keyboard '%s'\n", dev->name);
 343         }
 344 #endif
 345 #ifdef CONFIG_SYS_I2C
 346         i2c_init_all();
 347 #else
 348 #if defined(CONFIG_HARD_I2C)
 349         i2c_init (CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
 350 #endif
 351 #endif
 352 #ifdef CONFIG_DM_VIDEO
 353         /*
 354          * If the console setting is not in environment variables then
 355          * console_init_r() will not be calling iomux_doenv() (which calls
 356          * search_device()). So we will not dynamically add devices by
 357          * calling stdio_probe_device().
 358          *
 359          * So just probe all video devices now so that whichever one is
 360          * required will be available.
 361          */
 362 #ifndef CONFIG_SYS_CONSOLE_IS_IN_ENV
 363         struct udevice *vdev;
 364 # ifndef CONFIG_DM_KEYBOARD
 365         int ret;
 366 # endif
 367
 368         for (ret = uclass_first_device(UCLASS_VIDEO, &vdev);
 369              vdev;
 370              ret = uclass_next_device(&vdev))
 371                 ;
 372         if (ret)
 373                 printf("%s: Video device failed (ret=%d)\n", __func__, ret);
 374 #endif /* !CONFIG_SYS_CONSOLE_IS_IN_ENV */
 375 #else
 376 # if defined(CONFIG_LCD)
 377         drv_lcd_init ();
 378 # endif
 379 # if defined(CONFIG_VIDEO) || defined(CONFIG_CFB_CONSOLE)
 380         drv_video_init ();
 381 # endif
 382 #endif /* CONFIG_DM_VIDEO */
 383 #if defined(CONFIG_KEYBOARD) && !defined(CONFIG_DM_KEYBOARD)
 384         drv_keyboard_init ();
 385 #endif
 386 #ifdef CONFIG_LOGBUFFER
 387         drv_logbuff_init ();
 388 #endif
 389         drv_system_init ();
 390         serial_stdio_init ();
 391 #ifdef CONFIG_USB_TTY
 392         drv_usbtty_init ();
 393 #endif
 394 #ifdef CONFIG_NETCONSOLE
 395         drv_nc_init ();
 396 #endif
 397 #ifdef CONFIG_JTAG_CONSOLE
 398         drv_jtag_console_init ();
 399 #endif
 400 #ifdef CONFIG_CBMEM_CONSOLE
 401         cbmemc_init();
 402 #endif
 403
 404         return 0;
 405 }
 406
 407 int stdio_init(void)
 408 {
 409         stdio_init_tables();
 410         stdio_add_devices();
 411
 412         return 0;
 413 }