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         if (upriv->rd_ptr == upriv->wr_ptr)
 232                 return __serial_getc(dev);
 233
 234         val = upriv->buf[upriv->rd_ptr++];
 235         upriv->rd_ptr %= CONFIG_SERIAL_RX_BUFFER_SIZE;
 236
 237         return val;
 238 }
 239
 240 #else /* CONFIG_IS_ENABLED(SERIAL_RX_BUFFER) */
 241
 242 static int _serial_getc(struct udevice *dev)
 243 {
 244         return __serial_getc(dev);
 245 }
 246
 247 static int _serial_tstc(struct udevice *dev)
 248 {
 249         return __serial_tstc(dev);
 250 }
 251 #endif /* CONFIG_IS_ENABLED(SERIAL_RX_BUFFER) */
 252
 253 void serial_putc(char ch)
 254 {
 255         if (gd->cur_serial_dev)
 256                 _serial_putc(gd->cur_serial_dev, ch);
 257 }
 258
 259 void serial_puts(const char *str)
 260 {
 261         if (gd->cur_serial_dev)
 262                 _serial_puts(gd->cur_serial_dev, str);
 263 }
 264
 265 int serial_getc(void)
 266 {
 267         if (!gd->cur_serial_dev)
 268                 return 0;
 269
 270         return _serial_getc(gd->cur_serial_dev);
 271 }
 272
 273 int serial_tstc(void)
 274 {
 275         if (!gd->cur_serial_dev)
 276                 return 0;
 277
 278         return _serial_tstc(gd->cur_serial_dev);
 279 }
 280
 281 void serial_setbrg(void)
 282 {
 283         struct dm_serial_ops *ops;
 284
 285         if (!gd->cur_serial_dev)
 286                 return;
 287
 288         ops = serial_get_ops(gd->cur_serial_dev);
 289         if (ops->setbrg)
 290                 ops->setbrg(gd->cur_serial_dev, gd->baudrate);
 291 }
 292
 293 int serial_setconfig(uint config)
 294 {
 295         struct dm_serial_ops *ops;
 296
 297         if (!gd->cur_serial_dev)
 298                 return 0;
 299
 300         ops = serial_get_ops(gd->cur_serial_dev);
 301         if (ops->setconfig)
 302                 return ops->setconfig(gd->cur_serial_dev, config);
 303
 304         return 0;
 305 }
 306
 307 void serial_stdio_init(void)
 308 {
 309 }
 310
 311 #if defined(CONFIG_DM_STDIO)
 312
 313 #if CONFIG_IS_ENABLED(SERIAL_PRESENT)
 314 static void serial_stub_putc(struct stdio_dev *sdev, const char ch)
 315 {
 316         _serial_putc(sdev->priv, ch);
 317 }
 318 #endif
 319
 320 static void serial_stub_puts(struct stdio_dev *sdev, const char *str)
 321 {
 322         _serial_puts(sdev->priv, str);
 323 }
 324
 325 static int serial_stub_getc(struct stdio_dev *sdev)
 326 {
 327         return _serial_getc(sdev->priv);
 328 }
 329
 330 static int serial_stub_tstc(struct stdio_dev *sdev)
 331 {
 332         return _serial_tstc(sdev->priv);
 333 }
 334 #endif
 335
 336 /**
 337  * on_baudrate() - Update the actual baudrate when the env var changes
 338  *
 339  * This will check for a valid baudrate and only apply it if valid.
 340  */
 341 static int on_baudrate(const char *name, const char *value, enum env_op op,
 342         int flags)
 343 {
 344         int i;
 345         int baudrate;
 346
 347         switch (op) {
 348         case env_op_create:
 349         case env_op_overwrite:
 350                 /*
 351                  * Switch to new baudrate if new baudrate is supported
 352                  */
 353                 baudrate = simple_strtoul(value, NULL, 10);
 354
 355                 /* Not actually changing */
 356                 if (gd->baudrate == baudrate)
 357                         return 0;
 358
 359                 for (i = 0; i < ARRAY_SIZE(baudrate_table); ++i) {
 360                         if (baudrate == baudrate_table[i])
 361                                 break;
 362                 }
 363                 if (i == ARRAY_SIZE(baudrate_table)) {
 364                         if ((flags & H_FORCE) == 0)
 365                                 printf("## Baudrate %d bps not supported\n",
 366                                        baudrate);
 367                         return 1;
 368                 }
 369                 if ((flags & H_INTERACTIVE) != 0) {
 370                         printf("## Switch baudrate to %d bps and press ENTER ...\n",
 371                                baudrate);
 372                         udelay(50000);
 373                 }
 374
 375                 gd->baudrate = baudrate;
 376
 377                 serial_setbrg();
 378
 379                 udelay(50000);
 380
 381                 if ((flags & H_INTERACTIVE) != 0)
 382                         while (1) {
 383                                 if (getc() == '\r')
 384                                         break;
 385                         }
 386
 387                 return 0;
 388         case env_op_delete:
 389                 printf("## Baudrate may not be deleted\n");
 390                 return 1;
 391         default:
 392                 return 0;
 393         }
 394 }
 395 U_BOOT_ENV_CALLBACK(baudrate, on_baudrate);
 396
 397 #if CONFIG_IS_ENABLED(SERIAL_PRESENT)
 398 static int serial_post_probe(struct udevice *dev)
 399 {
 400         struct dm_serial_ops *ops = serial_get_ops(dev);
 401 #ifdef CONFIG_DM_STDIO
 402         struct serial_dev_priv *upriv = dev_get_uclass_priv(dev);
 403         struct stdio_dev sdev;
 404 #endif
 405         int ret;
 406
 407 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
 408         if (ops->setbrg)
 409                 ops->setbrg += gd->reloc_off;
 410         if (ops->getc)
 411                 ops->getc += gd->reloc_off;
 412         if (ops->putc)
 413                 ops->putc += gd->reloc_off;
 414         if (ops->pending)
 415                 ops->pending += gd->reloc_off;
 416         if (ops->clear)
 417                 ops->clear += gd->reloc_off;
 418         if (ops->setconfig)
 419                 ops->setconfig += gd->reloc_off;
 420 #if CONFIG_POST & CONFIG_SYS_POST_UART
 421         if (ops->loop)
 422                 ops->loop += gd->reloc_off
 423 #endif
 424 #endif
 425         /* Set the baud rate */
 426         if (ops->setbrg) {
 427                 ret = ops->setbrg(dev, gd->baudrate);
 428                 if (ret)
 429                         return ret;
 430         }
 431
 432 #ifdef CONFIG_DM_STDIO
 433         if (!(gd->flags & GD_FLG_RELOC))
 434                 return 0;
 435         memset(&sdev, '\0', sizeof(sdev));
 436
 437         strncpy(sdev.name, dev->name, sizeof(sdev.name));
 438         sdev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT | DEV_FLAGS_DM;
 439         sdev.priv = dev;
 440         sdev.putc = serial_stub_putc;
 441         sdev.puts = serial_stub_puts;
 442         sdev.getc = serial_stub_getc;
 443         sdev.tstc = serial_stub_tstc;
 444
 445 #if CONFIG_IS_ENABLED(SERIAL_RX_BUFFER)
 446         /* Allocate the RX buffer */
 447         upriv->buf = malloc(CONFIG_SERIAL_RX_BUFFER_SIZE);
 448 #endif
 449
 450         stdio_register_dev(&sdev, &upriv->sdev);
 451 #endif
 452         return 0;
 453 }
 454
 455 static int serial_pre_remove(struct udevice *dev)
 456 {
 457 #if CONFIG_IS_ENABLED(SYS_STDIO_DEREGISTER)
 458         struct serial_dev_priv *upriv = dev_get_uclass_priv(dev);
 459
 460         if (stdio_deregister_dev(upriv->sdev, true))
 461                 return -EPERM;
 462 #endif
 463
 464         return 0;
 465 }
 466
 467 UCLASS_DRIVER(serial) = {
 468         .id             = UCLASS_SERIAL,
 469         .name           = "serial",
 470         .flags          = DM_UC_FLAG_SEQ_ALIAS,
 471         .post_probe     = serial_post_probe,
 472         .pre_remove     = serial_pre_remove,
 473         .per_device_auto_alloc_size = sizeof(struct serial_dev_priv),
 474 };
 475 #endif