drivers/serial/serial-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2014 The Chromium OS Authors.
   4  */
   5
   6 #define LOG_CATEGORY UCLASS_SERIAL
   7
   8 #include <common.h>
   9 #include <dm.h>
  10 #include <env_internal.h>
  11 #include <errno.h>
  12 #include <malloc.h>
  13 #include <os.h>
  14 #include <serial.h>
  15 #include <stdio_dev.h>
  16 #include <watchdog.h>
  17 #include <asm/global_data.h>
  18 #include <dm/lists.h>
  19 #include <dm/device-internal.h>
  20 #include <dm/of_access.h>
  21 #include <linux/delay.h>
  22
  23 DECLARE_GLOBAL_DATA_PTR;
  24
  25 /*
  26  * Table with supported baudrates (defined in config_xyz.h)
  27  */
  28 static const unsigned long baudrate_table[] = CFG_SYS_BAUDRATE_TABLE;
  29
  30 #if CONFIG_IS_ENABLED(SERIAL_PRESENT)
  31 static int serial_check_stdout(const void *blob, struct udevice **devp)
  32 {
  33         int node = -1;
  34         const char *str, *p;
  35         int namelen;
  36
  37         /* Check for a chosen console */
  38         str = fdtdec_get_chosen_prop(blob, "stdout-path");
  39         if (str) {
  40                 p = strchr(str, ':');
  41                 namelen = p ? p - str : strlen(str);
  42                 /*
  43                  * This also deals with things like
  44                  *
  45                  *      stdout-path = "serial0:115200n8";
  46                  *
  47                  * since fdt_path_offset_namelen() treats a str not
  48                  * beginning with '/' as an alias and thus applies
  49                  * fdt_get_alias_namelen() to it.
  50                  */
  51                 node = fdt_path_offset_namelen(blob, str, namelen);
  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, NULL, false)) {
  65                 if (device_get_uclass_id(*devp) == UCLASS_SERIAL &&
  66                     !device_probe(*devp))
  67                         return 0;
  68         }
  69
  70         return -ENODEV;
  71 }
  72
  73 static void serial_find_console_or_panic(void)
  74 {
  75         const void *blob = gd->fdt_blob;
  76         struct udevice *dev;
  77 #ifdef CONFIG_SERIAL_SEARCH_ALL
  78         int ret;
  79 #endif
  80
  81         if (CONFIG_IS_ENABLED(OF_PLATDATA)) {
  82                 uclass_first_device(UCLASS_SERIAL, &dev);
  83                 if (dev) {
  84                         gd->cur_serial_dev = dev;
  85                         return;
  86                 }
  87         } else if (CONFIG_IS_ENABLED(OF_CONTROL) && blob) {
  88                 /* Live tree has support for stdout */
  89                 if (of_live_active()) {
  90                         struct device_node *np = of_get_stdout();
  91
  92                         if (np && !uclass_get_device_by_ofnode(UCLASS_SERIAL,
  93                                         np_to_ofnode(np), &dev)) {
  94                                 gd->cur_serial_dev = dev;
  95                                 return;
  96                         }
  97                 } else {
  98                         if (!serial_check_stdout(blob, &dev)) {
  99                                 gd->cur_serial_dev = dev;
 100                                 return;
 101                         }
 102                 }
 103         }
 104         if (!IS_ENABLED(CONFIG_SPL_BUILD) || !CONFIG_IS_ENABLED(OF_CONTROL) ||
 105             !blob) {
 106                 /*
 107                  * Try to use CONFIG_CONS_INDEX if available (it is numbered
 108                  * from 1!).
 109                  *
 110                  * Failing that, get the device with sequence number 0, or in
 111                  * extremis just the first working serial device we can find.
 112                  * But we insist on having a console (even if it is silent).
 113                  */
 114 #ifdef CONFIG_CONS_INDEX
 115 #define INDEX (CONFIG_CONS_INDEX - 1)
 116 #else
 117 #define INDEX 0
 118 #endif
 119
 120 #ifdef CONFIG_SERIAL_SEARCH_ALL
 121                 if (!uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &dev) ||
 122                     !uclass_get_device(UCLASS_SERIAL, INDEX, &dev)) {
 123                         if (dev_get_flags(dev) & DM_FLAG_ACTIVATED) {
 124                                 gd->cur_serial_dev = dev;
 125                                 return;
 126                         }
 127                 }
 128
 129                 /* Search for any working device */
 130                 for (ret = uclass_first_device_check(UCLASS_SERIAL, &dev);
 131                      dev;
 132                      ret = uclass_next_device_check(&dev)) {
 133                         if (!ret) {
 134                                 /* Device did succeed probing */
 135                                 gd->cur_serial_dev = dev;
 136                                 return;
 137                         }
 138                 }
 139 #else
 140                 if (!uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &dev) ||
 141                     !uclass_get_device(UCLASS_SERIAL, INDEX, &dev) ||
 142                     !uclass_first_device_err(UCLASS_SERIAL, &dev)) {
 143                         gd->cur_serial_dev = dev;
 144                         return;
 145                 }
 146 #endif
 147
 148 #undef INDEX
 149         }
 150
 151 #ifdef CONFIG_REQUIRE_SERIAL_CONSOLE
 152         panic_str("No serial driver found");
 153 #endif
 154 }
 155 #endif /* CONFIG_SERIAL_PRESENT */
 156
 157 /* Called prior to relocation */
 158 int serial_init(void)
 159 {
 160 #if CONFIG_IS_ENABLED(SERIAL_PRESENT)
 161         serial_find_console_or_panic();
 162         gd->flags |= GD_FLG_SERIAL_READY;
 163         serial_setbrg();
 164 #endif
 165
 166         return 0;
 167 }
 168
 169 /* Called after relocation */
 170 int serial_initialize(void)
 171 {
 172         /* Scanning uclass to probe devices */
 173         if (IS_ENABLED(CONFIG_SERIAL_PROBE_ALL)) {
 174                 int ret;
 175
 176                 ret  = uclass_probe_all(UCLASS_SERIAL);
 177                 if (ret)
 178                         return ret;
 179         }
 180
 181         return serial_init();
 182 }
 183
 184 static void _serial_putc(struct udevice *dev, char ch)
 185 {
 186         struct dm_serial_ops *ops = serial_get_ops(dev);
 187         int err;
 188
 189         if (ch == '\n')
 190                 _serial_putc(dev, '\r');
 191
 192         do {
 193                 err = ops->putc(dev, ch);
 194         } while (err == -EAGAIN);
 195 }
 196
 197 static int __serial_puts(struct udevice *dev, const char *str, size_t len)
 198 {
 199         struct dm_serial_ops *ops = serial_get_ops(dev);
 200
 201         do {
 202                 ssize_t written = ops->puts(dev, str, len);
 203
 204                 if (written < 0)
 205                         return written;
 206                 str += written;
 207                 len -= written;
 208         } while (len);
 209
 210         return 0;
 211 }
 212
 213 static void _serial_puts(struct udevice *dev, const char *str)
 214 {
 215         struct dm_serial_ops *ops = serial_get_ops(dev);
 216
 217         if (!CONFIG_IS_ENABLED(SERIAL_PUTS) || !ops->puts) {
 218                 while (*str)
 219                         _serial_putc(dev, *str++);
 220                 return;
 221         }
 222
 223         do {
 224                 const char *newline = strchrnul(str, '\n');
 225                 size_t len = newline - str;
 226
 227                 if (__serial_puts(dev, str, len))
 228                         return;
 229
 230                 if (*newline && __serial_puts(dev, "\r\n", 2))
 231                         return;
 232
 233                 str += len + !!*newline;
 234         } while (*str);
 235 }
 236
 237 #ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
 238 static void _serial_flush(struct udevice *dev)
 239 {
 240         struct dm_serial_ops *ops = serial_get_ops(dev);
 241
 242         if (!ops->pending)
 243                 return;
 244         while (ops->pending(dev, false) > 0)
 245                 ;
 246 }
 247 #endif
 248
 249 static int __serial_getc(struct udevice *dev)
 250 {
 251         struct dm_serial_ops *ops = serial_get_ops(dev);
 252         int err;
 253
 254         do {
 255                 err = ops->getc(dev);
 256                 if (err == -EAGAIN)
 257                         schedule();
 258         } while (err == -EAGAIN);
 259
 260         return err >= 0 ? err : 0;
 261 }
 262
 263 static int __serial_tstc(struct udevice *dev)
 264 {
 265         struct dm_serial_ops *ops = serial_get_ops(dev);
 266
 267         if (ops->pending)
 268                 return ops->pending(dev, true);
 269
 270         return 1;
 271 }
 272
 273 #if CONFIG_IS_ENABLED(SERIAL_RX_BUFFER)
 274 static int _serial_tstc(struct udevice *dev)
 275 {
 276         struct serial_dev_priv *upriv = dev_get_uclass_priv(dev);
 277
 278         /* Read all available chars into the RX buffer */
 279         while (__serial_tstc(dev)) {
 280                 upriv->buf[upriv->wr_ptr++] = __serial_getc(dev);
 281                 upriv->wr_ptr %= CONFIG_SERIAL_RX_BUFFER_SIZE;
 282         }
 283
 284         return upriv->rd_ptr != upriv->wr_ptr ? 1 : 0;
 285 }
 286
 287 static int _serial_getc(struct udevice *dev)
 288 {
 289         struct serial_dev_priv *upriv = dev_get_uclass_priv(dev);
 290         char val;
 291
 292         if (upriv->rd_ptr == upriv->wr_ptr)
 293                 return __serial_getc(dev);
 294
 295         val = upriv->buf[upriv->rd_ptr++];
 296         upriv->rd_ptr %= CONFIG_SERIAL_RX_BUFFER_SIZE;
 297
 298         return val;
 299 }
 300
 301 #else /* CONFIG_IS_ENABLED(SERIAL_RX_BUFFER) */
 302
 303 static int _serial_getc(struct udevice *dev)
 304 {
 305         return __serial_getc(dev);
 306 }
 307
 308 static int _serial_tstc(struct udevice *dev)
 309 {
 310         return __serial_tstc(dev);
 311 }
 312 #endif /* CONFIG_IS_ENABLED(SERIAL_RX_BUFFER) */
 313
 314 void serial_putc(char ch)
 315 {
 316         if (gd->cur_serial_dev)
 317                 _serial_putc(gd->cur_serial_dev, ch);
 318 }
 319
 320 void serial_puts(const char *str)
 321 {
 322         if (gd->cur_serial_dev)
 323                 _serial_puts(gd->cur_serial_dev, str);
 324 }
 325
 326 #ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
 327 void serial_flush(void)
 328 {
 329         if (!gd->cur_serial_dev)
 330                 return;
 331
 332         _serial_flush(gd->cur_serial_dev);
 333 }
 334 #endif
 335
 336 int serial_getc(void)
 337 {
 338         if (!gd->cur_serial_dev)
 339                 return 0;
 340
 341         return _serial_getc(gd->cur_serial_dev);
 342 }
 343
 344 int serial_tstc(void)
 345 {
 346         if (!gd->cur_serial_dev)
 347                 return 0;
 348
 349         return _serial_tstc(gd->cur_serial_dev);
 350 }
 351
 352 void serial_setbrg(void)
 353 {
 354         struct dm_serial_ops *ops;
 355
 356         if (!gd->cur_serial_dev)
 357                 return;
 358
 359         ops = serial_get_ops(gd->cur_serial_dev);
 360         if (ops->setbrg)
 361                 ops->setbrg(gd->cur_serial_dev, gd->baudrate);
 362 }
 363
 364 int serial_getconfig(struct udevice *dev, uint *config)
 365 {
 366         struct dm_serial_ops *ops;
 367
 368         ops = serial_get_ops(dev);
 369         if (ops->getconfig)
 370                 return ops->getconfig(dev, config);
 371
 372         return 0;
 373 }
 374
 375 int serial_setconfig(struct udevice *dev, uint config)
 376 {
 377         struct dm_serial_ops *ops;
 378
 379         ops = serial_get_ops(dev);
 380         if (ops->setconfig)
 381                 return ops->setconfig(dev, config);
 382
 383         return 0;
 384 }
 385
 386 int serial_getinfo(struct udevice *dev, struct serial_device_info *info)
 387 {
 388         struct dm_serial_ops *ops;
 389
 390         if (!info)
 391                 return -EINVAL;
 392
 393         info->baudrate = gd->baudrate;
 394
 395         ops = serial_get_ops(dev);
 396         if (ops->getinfo)
 397                 return ops->getinfo(dev, info);
 398
 399         return -EINVAL;
 400 }
 401
 402 void serial_stdio_init(void)
 403 {
 404 }
 405
 406 #if CONFIG_IS_ENABLED(DM_STDIO)
 407
 408 #if CONFIG_IS_ENABLED(SERIAL_PRESENT)
 409 static void serial_stub_putc(struct stdio_dev *sdev, const char ch)
 410 {
 411         _serial_putc(sdev->priv, ch);
 412 }
 413
 414 static void serial_stub_puts(struct stdio_dev *sdev, const char *str)
 415 {
 416         _serial_puts(sdev->priv, str);
 417 }
 418
 419 #ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
 420 static void serial_stub_flush(struct stdio_dev *sdev)
 421 {
 422         _serial_flush(sdev->priv);
 423 }
 424 #endif
 425
 426 static int serial_stub_getc(struct stdio_dev *sdev)
 427 {
 428         return _serial_getc(sdev->priv);
 429 }
 430
 431 static int serial_stub_tstc(struct stdio_dev *sdev)
 432 {
 433         return _serial_tstc(sdev->priv);
 434 }
 435 #endif
 436 #endif
 437
 438 /**
 439  * on_baudrate() - Update the actual baudrate when the env var changes
 440  *
 441  * This will check for a valid baudrate and only apply it if valid.
 442  */
 443 static int on_baudrate(const char *name, const char *value, enum env_op op,
 444         int flags)
 445 {
 446         int i;
 447         int baudrate;
 448
 449         switch (op) {
 450         case env_op_create:
 451         case env_op_overwrite:
 452                 /*
 453                  * Switch to new baudrate if new baudrate is supported
 454                  */
 455                 baudrate = dectoul(value, NULL);
 456
 457                 /* Not actually changing */
 458                 if (gd->baudrate == baudrate)
 459                         return 0;
 460
 461                 for (i = 0; i < ARRAY_SIZE(baudrate_table); ++i) {
 462                         if (baudrate == baudrate_table[i])
 463                                 break;
 464                 }
 465                 if (i == ARRAY_SIZE(baudrate_table)) {
 466                         if ((flags & H_FORCE) == 0)
 467                                 printf("## Baudrate %d bps not supported\n",
 468                                        baudrate);
 469                         return 1;
 470                 }
 471                 if ((flags & H_INTERACTIVE) != 0) {
 472                         printf("## Switch baudrate to %d bps and press ENTER ...\n",
 473                                baudrate);
 474                         udelay(50000);
 475                         flush();
 476                 }
 477
 478                 gd->baudrate = baudrate;
 479
 480                 serial_setbrg();
 481
 482                 udelay(50000);
 483
 484                 if ((flags & H_INTERACTIVE) != 0)
 485                         while (1) {
 486                                 if (getchar() == '\r')
 487                                         break;
 488                         }
 489
 490                 return 0;
 491         case env_op_delete:
 492                 printf("## Baudrate may not be deleted\n");
 493                 return 1;
 494         default:
 495                 return 0;
 496         }
 497 }
 498 U_BOOT_ENV_CALLBACK(baudrate, on_baudrate);
 499
 500 #if CONFIG_IS_ENABLED(SERIAL_PRESENT)
 501 static int serial_post_probe(struct udevice *dev)
 502 {
 503         struct dm_serial_ops *ops = serial_get_ops(dev);
 504 #if CONFIG_IS_ENABLED(DM_STDIO)
 505         struct serial_dev_priv *upriv = dev_get_uclass_priv(dev);
 506         struct stdio_dev sdev;
 507 #endif
 508         int ret;
 509
 510 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
 511         if (ops->setbrg)
 512                 ops->setbrg += gd->reloc_off;
 513         if (ops->getc)
 514                 ops->getc += gd->reloc_off;
 515         if (ops->putc)
 516                 ops->putc += gd->reloc_off;
 517         if (ops->pending)
 518                 ops->pending += gd->reloc_off;
 519         if (ops->clear)
 520                 ops->clear += gd->reloc_off;
 521         if (ops->getconfig)
 522                 ops->getconfig += gd->reloc_off;
 523         if (ops->setconfig)
 524                 ops->setconfig += gd->reloc_off;
 525 #if CFG_POST & CFG_SYS_POST_UART
 526         if (ops->loop)
 527                 ops->loop += gd->reloc_off;
 528 #endif
 529         if (ops->getinfo)
 530                 ops->getinfo += gd->reloc_off;
 531 #endif
 532         /* Set the baud rate */
 533         if (ops->setbrg) {
 534                 ret = ops->setbrg(dev, gd->baudrate);
 535                 if (ret)
 536                         return ret;
 537         }
 538
 539 #if CONFIG_IS_ENABLED(DM_STDIO)
 540         if (!(gd->flags & GD_FLG_RELOC))
 541                 return 0;
 542         memset(&sdev, '\0', sizeof(sdev));
 543
 544         strncpy(sdev.name, dev->name, sizeof(sdev.name));
 545         sdev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT | DEV_FLAGS_DM;
 546         sdev.priv = dev;
 547         sdev.putc = serial_stub_putc;
 548         sdev.puts = serial_stub_puts;
 549         STDIO_DEV_ASSIGN_FLUSH(&sdev, serial_stub_flush);
 550         sdev.getc = serial_stub_getc;
 551         sdev.tstc = serial_stub_tstc;
 552
 553 #if CONFIG_IS_ENABLED(SERIAL_RX_BUFFER)
 554         /* Allocate the RX buffer */
 555         upriv->buf = malloc(CONFIG_SERIAL_RX_BUFFER_SIZE);
 556 #endif
 557
 558         stdio_register_dev(&sdev, &upriv->sdev);
 559 #endif
 560         return 0;
 561 }
 562
 563 static int serial_pre_remove(struct udevice *dev)
 564 {
 565 #if CONFIG_IS_ENABLED(SYS_STDIO_DEREGISTER)
 566         struct serial_dev_priv *upriv = dev_get_uclass_priv(dev);
 567
 568         if (stdio_deregister_dev(upriv->sdev, true))
 569                 return -EPERM;
 570 #endif
 571
 572         return 0;
 573 }
 574
 575 UCLASS_DRIVER(serial) = {
 576         .id             = UCLASS_SERIAL,
 577         .name           = "serial",
 578         .flags          = DM_UC_FLAG_SEQ_ALIAS,
 579         .post_probe     = serial_post_probe,
 580         .pre_remove     = serial_pre_remove,
 581         .per_device_auto        = sizeof(struct serial_dev_priv),
 582 };
 583 #endif