drivers/serial/serial-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2014 The Chromium OS Authors.
   4  */
   5
   6 #include <common.h>
   7 #include <dm.h>
   8 #include <environment.h>
   9 #include <errno.h>
  10 #include <os.h>
  11 #include <serial.h>
  12 #include <stdio_dev.h>
  13 #include <watchdog.h>
  14 #include <dm/lists.h>
  15 #include <dm/device-internal.h>
  16 #include <dm/of_access.h>
  17
  18 DECLARE_GLOBAL_DATA_PTR;
  19
  20 /*
  21  * Table with supported baudrates (defined in config_xyz.h)
  22  */
  23 static const unsigned long baudrate_table[] = CONFIG_SYS_BAUDRATE_TABLE;
  24
  25 #if !CONFIG_VAL(SYS_MALLOC_F_LEN)
  26 #error "Serial is required before relocation - define CONFIG_$(SPL_)SYS_MALLOC_F_LEN to make this work"
  27 #endif
  28
  29 static int serial_check_stdout(const void *blob, struct udevice **devp)
  30 {
  31         int node;
  32
  33         /* Check for a chosen console */
  34         node = fdtdec_get_chosen_node(blob, "stdout-path");
  35         if (node < 0) {
  36                 const char *str, *p, *name;
  37
  38                 /*
  39                  * Deal with things like
  40                  *      stdout-path = "serial0:115200n8";
  41                  *
  42                  * We need to look up the alias and then follow it to the
  43                  * correct node.
  44                  */
  45                 str = fdtdec_get_chosen_prop(blob, "stdout-path");
  46                 if (str) {
  47                         p = strchr(str, ':');
  48                         name = fdt_get_alias_namelen(blob, str,
  49                                         p ? p - str : strlen(str));
  50                         if (name)
  51                                 node = fdt_path_offset(blob, name);
  52                 }
  53         }
  54         if (node < 0)
  55                 node = fdt_path_offset(blob, "console");
  56         if (!uclass_get_device_by_of_offset(UCLASS_SERIAL, node, devp))
  57                 return 0;
  58
  59         /*
  60          * If the console is not marked to be bound before relocation, bind it
  61          * anyway.
  62          */
  63         if (node > 0 && !lists_bind_fdt(gd->dm_root, offset_to_ofnode(node),
  64                                         devp)) {
  65                 if (!device_probe(*devp))
  66                         return 0;
  67         }
  68
  69         return -ENODEV;
  70 }
  71
  72 static void serial_find_console_or_panic(void)
  73 {
  74         const void *blob = gd->fdt_blob;
  75         struct udevice *dev;
  76 #ifdef CONFIG_SERIAL_SEARCH_ALL
  77         int ret;
  78 #endif
  79
  80         if (CONFIG_IS_ENABLED(OF_PLATDATA)) {
  81                 uclass_first_device(UCLASS_SERIAL, &dev);
  82                 if (dev) {
  83                         gd->cur_serial_dev = dev;
  84                         return;
  85                 }
  86         } else if (CONFIG_IS_ENABLED(OF_CONTROL) && blob) {
  87                 /* Live tree has support for stdout */
  88                 if (of_live_active()) {
  89                         struct device_node *np = of_get_stdout();
  90
  91                         if (np && !uclass_get_device_by_ofnode(UCLASS_SERIAL,
  92                                         np_to_ofnode(np), &dev)) {
  93                                 gd->cur_serial_dev = dev;
  94                                 return;
  95                         }
  96                 } else {
  97                         if (!serial_check_stdout(blob, &dev)) {
  98                                 gd->cur_serial_dev = dev;
  99                                 return;
 100                         }
 101                 }
 102         }
 103         if (!SPL_BUILD || !CONFIG_IS_ENABLED(OF_CONTROL) || !blob) {
 104                 /*
 105                  * Try to use CONFIG_CONS_INDEX if available (it is numbered
 106                  * from 1!).
 107                  *
 108                  * Failing that, get the device with sequence number 0, or in
 109                  * extremis just the first working serial device we can find.
 110                  * But we insist on having a console (even if it is silent).
 111                  */
 112 #ifdef CONFIG_CONS_INDEX
 113 #define INDEX (CONFIG_CONS_INDEX - 1)
 114 #else
 115 #define INDEX 0
 116 #endif
 117
 118 #ifdef CONFIG_SERIAL_SEARCH_ALL
 119                 if (!uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &dev) ||
 120                     !uclass_get_device(UCLASS_SERIAL, INDEX, &dev)) {
 121                         if (dev->flags & DM_FLAG_ACTIVATED) {
 122                                 gd->cur_serial_dev = dev;
 123                                 return;
 124                         }
 125                 }
 126
 127                 /* Search for any working device */
 128                 for (ret = uclass_first_device_check(UCLASS_SERIAL, &dev);
 129                      dev;
 130                      ret = uclass_next_device_check(&dev)) {
 131                         if (!ret) {
 132                                 /* Device did succeed probing */
 133                                 gd->cur_serial_dev = dev;
 134                                 return;
 135                         }
 136                 }
 137 #else
 138                 if (!uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &dev) ||
 139                     !uclass_get_device(UCLASS_SERIAL, INDEX, &dev) ||
 140                     (!uclass_first_device(UCLASS_SERIAL, &dev) && dev)) {
 141                         gd->cur_serial_dev = dev;
 142                         return;
 143                 }
 144 #endif
 145
 146 #undef INDEX
 147         }
 148
 149 #ifdef CONFIG_REQUIRE_SERIAL_CONSOLE
 150         panic_str("No serial driver found");
 151 #endif
 152 }
 153
 154 /* Called prior to relocation */
 155 int serial_init(void)
 156 {
 157         serial_find_console_or_panic();
 158         gd->flags |= GD_FLG_SERIAL_READY;
 159
 160         return 0;
 161 }
 162
 163 /* Called after relocation */
 164 void serial_initialize(void)
 165 {
 166         serial_init();
 167 }
 168
 169 static void _serial_putc(struct udevice *dev, char ch)
 170 {
 171         struct dm_serial_ops *ops = serial_get_ops(dev);
 172         int err;
 173
 174         if (ch == '\n')
 175                 _serial_putc(dev, '\r');
 176
 177         do {
 178                 err = ops->putc(dev, ch);
 179         } while (err == -EAGAIN);
 180 }
 181
 182 static void _serial_puts(struct udevice *dev, const char *str)
 183 {
 184         while (*str)
 185                 _serial_putc(dev, *str++);
 186 }
 187
 188 static int __serial_getc(struct udevice *dev)
 189 {
 190         struct dm_serial_ops *ops = serial_get_ops(dev);
 191         int err;
 192
 193         do {
 194                 err = ops->getc(dev);
 195                 if (err == -EAGAIN)
 196                         WATCHDOG_RESET();
 197         } while (err == -EAGAIN);
 198
 199         return err >= 0 ? err : 0;
 200 }
 201
 202 static int __serial_tstc(struct udevice *dev)
 203 {
 204         struct dm_serial_ops *ops = serial_get_ops(dev);
 205
 206         if (ops->pending)
 207                 return ops->pending(dev, true);
 208
 209         return 1;
 210 }
 211
 212 #if CONFIG_IS_ENABLED(SERIAL_RX_BUFFER)
 213 static int _serial_tstc(struct udevice *dev)
 214 {
 215         struct serial_dev_priv *upriv = dev_get_uclass_priv(dev);
 216
 217         /* Read all available chars into the RX buffer */
 218         while (__serial_tstc(dev)) {
 219                 upriv->buf[upriv->wr_ptr++] = __serial_getc(dev);
 220                 upriv->wr_ptr %= CONFIG_SERIAL_RX_BUFFER_SIZE;
 221         }
 222
 223         return upriv->rd_ptr != upriv->wr_ptr ? 1 : 0;
 224 }
 225
 226 static int _serial_getc(struct udevice *dev)
 227 {
 228         struct serial_dev_priv *upriv = dev_get_uclass_priv(dev);
 229         char val;
 230
 231         val = upriv->buf[upriv->rd_ptr++];
 232         upriv->rd_ptr %= CONFIG_SERIAL_RX_BUFFER_SIZE;
 233
 234         return val;
 235 }
 236
 237 #else /* CONFIG_IS_ENABLED(SERIAL_RX_BUFFER) */
 238
 239 static int _serial_getc(struct udevice *dev)
 240 {
 241         return __serial_getc(dev);
 242 }
 243
 244 static int _serial_tstc(struct udevice *dev)
 245 {
 246         return __serial_tstc(dev);
 247 }
 248 #endif /* CONFIG_IS_ENABLED(SERIAL_RX_BUFFER) */
 249
 250 void serial_putc(char ch)
 251 {
 252         if (gd->cur_serial_dev)
 253                 _serial_putc(gd->cur_serial_dev, ch);
 254 }
 255
 256 void serial_puts(const char *str)
 257 {
 258         if (gd->cur_serial_dev)
 259                 _serial_puts(gd->cur_serial_dev, str);
 260 }
 261
 262 int serial_getc(void)
 263 {
 264         if (!gd->cur_serial_dev)
 265                 return 0;
 266
 267         return _serial_getc(gd->cur_serial_dev);
 268 }
 269
 270 int serial_tstc(void)
 271 {
 272         if (!gd->cur_serial_dev)
 273                 return 0;
 274
 275         return _serial_tstc(gd->cur_serial_dev);
 276 }
 277
 278 void serial_setbrg(void)
 279 {
 280         struct dm_serial_ops *ops;
 281
 282         if (!gd->cur_serial_dev)
 283                 return;
 284
 285         ops = serial_get_ops(gd->cur_serial_dev);
 286         if (ops->setbrg)
 287                 ops->setbrg(gd->cur_serial_dev, gd->baudrate);
 288 }
 289
 290 void serial_stdio_init(void)
 291 {
 292 }
 293
 294 #if defined(CONFIG_DM_STDIO)
 295
 296 #if CONFIG_IS_ENABLED(SERIAL_PRESENT)
 297 static void serial_stub_putc(struct stdio_dev *sdev, const char ch)
 298 {
 299         _serial_putc(sdev->priv, ch);
 300 }
 301 #endif
 302
 303 static void serial_stub_puts(struct stdio_dev *sdev, const char *str)
 304 {
 305         _serial_puts(sdev->priv, str);
 306 }
 307
 308 static int serial_stub_getc(struct stdio_dev *sdev)
 309 {
 310         return _serial_getc(sdev->priv);
 311 }
 312
 313 static int serial_stub_tstc(struct stdio_dev *sdev)
 314 {
 315         return _serial_tstc(sdev->priv);
 316 }
 317 #endif
 318
 319 /**
 320  * on_baudrate() - Update the actual baudrate when the env var changes
 321  *
 322  * This will check for a valid baudrate and only apply it if valid.
 323  */
 324 static int on_baudrate(const char *name, const char *value, enum env_op op,
 325         int flags)
 326 {
 327         int i;
 328         int baudrate;
 329
 330         switch (op) {
 331         case env_op_create:
 332         case env_op_overwrite:
 333                 /*
 334                  * Switch to new baudrate if new baudrate is supported
 335                  */
 336                 baudrate = simple_strtoul(value, NULL, 10);
 337
 338                 /* Not actually changing */
 339                 if (gd->baudrate == baudrate)
 340                         return 0;
 341
 342                 for (i = 0; i < ARRAY_SIZE(baudrate_table); ++i) {
 343                         if (baudrate == baudrate_table[i])
 344                                 break;
 345                 }
 346                 if (i == ARRAY_SIZE(baudrate_table)) {
 347                         if ((flags & H_FORCE) == 0)
 348                                 printf("## Baudrate %d bps not supported\n",
 349                                        baudrate);
 350                         return 1;
 351                 }
 352                 if ((flags & H_INTERACTIVE) != 0) {
 353                         printf("## Switch baudrate to %d bps and press ENTER ...\n",
 354                                baudrate);
 355                         udelay(50000);
 356                 }
 357
 358                 gd->baudrate = baudrate;
 359
 360                 serial_setbrg();
 361
 362                 udelay(50000);
 363
 364                 if ((flags & H_INTERACTIVE) != 0)
 365                         while (1) {
 366                                 if (getc() == '\r')
 367                                         break;
 368                         }
 369
 370                 return 0;
 371         case env_op_delete:
 372                 printf("## Baudrate may not be deleted\n");
 373                 return 1;
 374         default:
 375                 return 0;
 376         }
 377 }
 378 U_BOOT_ENV_CALLBACK(baudrate, on_baudrate);
 379
 380 #if CONFIG_IS_ENABLED(SERIAL_PRESENT)
 381 static int serial_post_probe(struct udevice *dev)
 382 {
 383         struct dm_serial_ops *ops = serial_get_ops(dev);
 384 #ifdef CONFIG_DM_STDIO
 385         struct serial_dev_priv *upriv = dev_get_uclass_priv(dev);
 386         struct stdio_dev sdev;
 387 #endif
 388         int ret;
 389
 390 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
 391         if (ops->setbrg)
 392                 ops->setbrg += gd->reloc_off;
 393         if (ops->getc)
 394                 ops->getc += gd->reloc_off;
 395         if (ops->putc)
 396                 ops->putc += gd->reloc_off;
 397         if (ops->pending)
 398                 ops->pending += gd->reloc_off;
 399         if (ops->clear)
 400                 ops->clear += gd->reloc_off;
 401 #if CONFIG_POST & CONFIG_SYS_POST_UART
 402         if (ops->loop)
 403                 ops->loop += gd->reloc_off
 404 #endif
 405 #endif
 406         /* Set the baud rate */
 407         if (ops->setbrg) {
 408                 ret = ops->setbrg(dev, gd->baudrate);
 409                 if (ret)
 410                         return ret;
 411         }
 412
 413 #ifdef CONFIG_DM_STDIO
 414         if (!(gd->flags & GD_FLG_RELOC))
 415                 return 0;
 416         memset(&sdev, '\0', sizeof(sdev));
 417
 418         strncpy(sdev.name, dev->name, sizeof(sdev.name));
 419         sdev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT | DEV_FLAGS_DM;
 420         sdev.priv = dev;
 421         sdev.putc = serial_stub_putc;
 422         sdev.puts = serial_stub_puts;
 423         sdev.getc = serial_stub_getc;
 424         sdev.tstc = serial_stub_tstc;
 425
 426 #if CONFIG_IS_ENABLED(SERIAL_RX_BUFFER)
 427         /* Allocate the RX buffer */
 428         upriv->buf = malloc(CONFIG_SERIAL_RX_BUFFER_SIZE);
 429 #endif
 430
 431         stdio_register_dev(&sdev, &upriv->sdev);
 432 #endif
 433         return 0;
 434 }
 435
 436 static int serial_pre_remove(struct udevice *dev)
 437 {
 438 #if CONFIG_IS_ENABLED(SYS_STDIO_DEREGISTER)
 439         struct serial_dev_priv *upriv = dev_get_uclass_priv(dev);
 440
 441         if (stdio_deregister_dev(upriv->sdev, true))
 442                 return -EPERM;
 443 #endif
 444
 445         return 0;
 446 }
 447
 448 UCLASS_DRIVER(serial) = {
 449         .id             = UCLASS_SERIAL,
 450         .name           = "serial",
 451         .flags          = DM_UC_FLAG_SEQ_ALIAS,
 452         .post_probe     = serial_post_probe,
 453         .pre_remove     = serial_pre_remove,
 454         .per_device_auto_alloc_size = sizeof(struct serial_dev_priv),
 455 };
 456 #endif