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 #if CONFIG_IS_ENABLED(SERIAL_PRESENT) 30 static int serial_check_stdout(const void *blob, struct udevice **devp) 31 { 32 int node; 33 34 /* Check for a chosen console */ 35 node = fdtdec_get_chosen_node(blob, "stdout-path"); 36 if (node < 0) { 37 const char *str, *p, *name; 38 39 /* 40 * Deal with things like 41 * stdout-path = "serial0:115200n8"; 42 * 43 * We need to look up the alias and then follow it to the 44 * correct node. 45 */ 46 str = fdtdec_get_chosen_prop(blob, "stdout-path"); 47 if (str) { 48 p = strchr(str, ':'); 49 name = fdt_get_alias_namelen(blob, str, 50 p ? p - str : strlen(str)); 51 if (name) 52 node = fdt_path_offset(blob, name); 53 } 54 } 55 if (node < 0) 56 node = fdt_path_offset(blob, "console"); 57 if (!uclass_get_device_by_of_offset(UCLASS_SERIAL, node, devp)) 58 return 0; 59 60 /* 61 * If the console is not marked to be bound before relocation, bind it 62 * anyway. 63 */ 64 if (node > 0 && !lists_bind_fdt(gd->dm_root, offset_to_ofnode(node), 65 devp, false)) { 66 if (!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 (!SPL_BUILD || !CONFIG_IS_ENABLED(OF_CONTROL) || !blob) { 105 /* 106 * Try to use CONFIG_CONS_INDEX if available (it is numbered 107 * from 1!). 108 * 109 * Failing that, get the device with sequence number 0, or in 110 * extremis just the first working serial device we can find. 111 * But we insist on having a console (even if it is silent). 112 */ 113 #ifdef CONFIG_CONS_INDEX 114 #define INDEX (CONFIG_CONS_INDEX - 1) 115 #else 116 #define INDEX 0 117 #endif 118 119 #ifdef CONFIG_SERIAL_SEARCH_ALL 120 if (!uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &dev) || 121 !uclass_get_device(UCLASS_SERIAL, INDEX, &dev)) { 122 if (dev->flags & DM_FLAG_ACTIVATED) { 123 gd->cur_serial_dev = dev; 124 return; 125 } 126 } 127 128 /* Search for any working device */ 129 for (ret = uclass_first_device_check(UCLASS_SERIAL, &dev); 130 dev; 131 ret = uclass_next_device_check(&dev)) { 132 if (!ret) { 133 /* Device did succeed probing */ 134 gd->cur_serial_dev = dev; 135 return; 136 } 137 } 138 #else 139 if (!uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &dev) || 140 !uclass_get_device(UCLASS_SERIAL, INDEX, &dev) || 141 (!uclass_first_device(UCLASS_SERIAL, &dev) && dev)) { 142 gd->cur_serial_dev = dev; 143 return; 144 } 145 #endif 146 147 #undef INDEX 148 } 149 150 #ifdef CONFIG_REQUIRE_SERIAL_CONSOLE 151 panic_str("No serial driver found"); 152 #endif 153 } 154 #endif /* CONFIG_SERIAL_PRESENT */ 155 156 /* Called prior to relocation */ 157 int serial_init(void) 158 { 159 #if CONFIG_IS_ENABLED(SERIAL_PRESENT) 160 serial_find_console_or_panic(); 161 gd->flags |= GD_FLG_SERIAL_READY; 162 #endif 163 164 return 0; 165 } 166 167 /* Called after relocation */ 168 void serial_initialize(void) 169 { 170 serial_init(); 171 } 172 173 static void _serial_putc(struct udevice *dev, char ch) 174 { 175 struct dm_serial_ops *ops = serial_get_ops(dev); 176 int err; 177 178 if (ch == '\n') 179 _serial_putc(dev, '\r'); 180 181 do { 182 err = ops->putc(dev, ch); 183 } while (err == -EAGAIN); 184 } 185 186 static void _serial_puts(struct udevice *dev, const char *str) 187 { 188 while (*str) 189 _serial_putc(dev, *str++); 190 } 191 192 static int __serial_getc(struct udevice *dev) 193 { 194 struct dm_serial_ops *ops = serial_get_ops(dev); 195 int err; 196 197 do { 198 err = ops->getc(dev); 199 if (err == -EAGAIN) 200 WATCHDOG_RESET(); 201 } while (err == -EAGAIN); 202 203 return err >= 0 ? err : 0; 204 } 205 206 static int __serial_tstc(struct udevice *dev) 207 { 208 struct dm_serial_ops *ops = serial_get_ops(dev); 209 210 if (ops->pending) 211 return ops->pending(dev, true); 212 213 return 1; 214 } 215 216 #if CONFIG_IS_ENABLED(SERIAL_RX_BUFFER) 217 static int _serial_tstc(struct udevice *dev) 218 { 219 struct serial_dev_priv *upriv = dev_get_uclass_priv(dev); 220 221 /* Read all available chars into the RX buffer */ 222 while (__serial_tstc(dev)) { 223 upriv->buf[upriv->wr_ptr++] = __serial_getc(dev); 224 upriv->wr_ptr %= CONFIG_SERIAL_RX_BUFFER_SIZE; 225 } 226 227 return upriv->rd_ptr != upriv->wr_ptr ? 1 : 0; 228 } 229 230 static int _serial_getc(struct udevice *dev) 231 { 232 struct serial_dev_priv *upriv = dev_get_uclass_priv(dev); 233 char val; 234 235 if (upriv->rd_ptr == upriv->wr_ptr) 236 return __serial_getc(dev); 237 238 val = upriv->buf[upriv->rd_ptr++]; 239 upriv->rd_ptr %= CONFIG_SERIAL_RX_BUFFER_SIZE; 240 241 return val; 242 } 243 244 #else /* CONFIG_IS_ENABLED(SERIAL_RX_BUFFER) */ 245 246 static int _serial_getc(struct udevice *dev) 247 { 248 return __serial_getc(dev); 249 } 250 251 static int _serial_tstc(struct udevice *dev) 252 { 253 return __serial_tstc(dev); 254 } 255 #endif /* CONFIG_IS_ENABLED(SERIAL_RX_BUFFER) */ 256 257 void serial_putc(char ch) 258 { 259 if (gd->cur_serial_dev) 260 _serial_putc(gd->cur_serial_dev, ch); 261 } 262 263 void serial_puts(const char *str) 264 { 265 if (gd->cur_serial_dev) 266 _serial_puts(gd->cur_serial_dev, str); 267 } 268 269 int serial_getc(void) 270 { 271 if (!gd->cur_serial_dev) 272 return 0; 273 274 return _serial_getc(gd->cur_serial_dev); 275 } 276 277 int serial_tstc(void) 278 { 279 if (!gd->cur_serial_dev) 280 return 0; 281 282 return _serial_tstc(gd->cur_serial_dev); 283 } 284 285 void serial_setbrg(void) 286 { 287 struct dm_serial_ops *ops; 288 289 if (!gd->cur_serial_dev) 290 return; 291 292 ops = serial_get_ops(gd->cur_serial_dev); 293 if (ops->setbrg) 294 ops->setbrg(gd->cur_serial_dev, gd->baudrate); 295 } 296 297 int serial_getconfig(uint *config) 298 { 299 struct dm_serial_ops *ops; 300 301 if (!gd->cur_serial_dev) 302 return 0; 303 304 ops = serial_get_ops(gd->cur_serial_dev); 305 if (ops->getconfig) 306 return ops->getconfig(gd->cur_serial_dev, config); 307 308 return 0; 309 } 310 311 int serial_setconfig(uint config) 312 { 313 struct dm_serial_ops *ops; 314 315 if (!gd->cur_serial_dev) 316 return 0; 317 318 ops = serial_get_ops(gd->cur_serial_dev); 319 if (ops->setconfig) 320 return ops->setconfig(gd->cur_serial_dev, config); 321 322 return 0; 323 } 324 325 int serial_getinfo(struct serial_device_info *info) 326 { 327 struct dm_serial_ops *ops; 328 329 if (!gd->cur_serial_dev) 330 return -ENODEV; 331 332 if (!info) 333 return -EINVAL; 334 335 info->baudrate = gd->baudrate; 336 337 ops = serial_get_ops(gd->cur_serial_dev); 338 if (ops->getinfo) 339 return ops->getinfo(gd->cur_serial_dev, info); 340 341 return -EINVAL; 342 } 343 344 void serial_stdio_init(void) 345 { 346 } 347 348 #if defined(CONFIG_DM_STDIO) 349 350 #if CONFIG_IS_ENABLED(SERIAL_PRESENT) 351 static void serial_stub_putc(struct stdio_dev *sdev, const char ch) 352 { 353 _serial_putc(sdev->priv, ch); 354 } 355 #endif 356 357 static void serial_stub_puts(struct stdio_dev *sdev, const char *str) 358 { 359 _serial_puts(sdev->priv, str); 360 } 361 362 static int serial_stub_getc(struct stdio_dev *sdev) 363 { 364 return _serial_getc(sdev->priv); 365 } 366 367 static int serial_stub_tstc(struct stdio_dev *sdev) 368 { 369 return _serial_tstc(sdev->priv); 370 } 371 #endif 372 373 /** 374 * on_baudrate() - Update the actual baudrate when the env var changes 375 * 376 * This will check for a valid baudrate and only apply it if valid. 377 */ 378 static int on_baudrate(const char *name, const char *value, enum env_op op, 379 int flags) 380 { 381 int i; 382 int baudrate; 383 384 switch (op) { 385 case env_op_create: 386 case env_op_overwrite: 387 /* 388 * Switch to new baudrate if new baudrate is supported 389 */ 390 baudrate = simple_strtoul(value, NULL, 10); 391 392 /* Not actually changing */ 393 if (gd->baudrate == baudrate) 394 return 0; 395 396 for (i = 0; i < ARRAY_SIZE(baudrate_table); ++i) { 397 if (baudrate == baudrate_table[i]) 398 break; 399 } 400 if (i == ARRAY_SIZE(baudrate_table)) { 401 if ((flags & H_FORCE) == 0) 402 printf("## Baudrate %d bps not supported\n", 403 baudrate); 404 return 1; 405 } 406 if ((flags & H_INTERACTIVE) != 0) { 407 printf("## Switch baudrate to %d bps and press ENTER ...\n", 408 baudrate); 409 udelay(50000); 410 } 411 412 gd->baudrate = baudrate; 413 414 serial_setbrg(); 415 416 udelay(50000); 417 418 if ((flags & H_INTERACTIVE) != 0) 419 while (1) { 420 if (getc() == '\r') 421 break; 422 } 423 424 return 0; 425 case env_op_delete: 426 printf("## Baudrate may not be deleted\n"); 427 return 1; 428 default: 429 return 0; 430 } 431 } 432 U_BOOT_ENV_CALLBACK(baudrate, on_baudrate); 433 434 #if CONFIG_IS_ENABLED(SERIAL_PRESENT) 435 static int serial_post_probe(struct udevice *dev) 436 { 437 struct dm_serial_ops *ops = serial_get_ops(dev); 438 #ifdef CONFIG_DM_STDIO 439 struct serial_dev_priv *upriv = dev_get_uclass_priv(dev); 440 struct stdio_dev sdev; 441 #endif 442 int ret; 443 444 #if defined(CONFIG_NEEDS_MANUAL_RELOC) 445 if (ops->setbrg) 446 ops->setbrg += gd->reloc_off; 447 if (ops->getc) 448 ops->getc += gd->reloc_off; 449 if (ops->putc) 450 ops->putc += gd->reloc_off; 451 if (ops->pending) 452 ops->pending += gd->reloc_off; 453 if (ops->clear) 454 ops->clear += gd->reloc_off; 455 if (ops->getconfig) 456 ops->getconfig += gd->reloc_off; 457 if (ops->setconfig) 458 ops->setconfig += gd->reloc_off; 459 #if CONFIG_POST & CONFIG_SYS_POST_UART 460 if (ops->loop) 461 ops->loop += gd->reloc_off; 462 #endif 463 if (ops->getinfo) 464 ops->getinfo += gd->reloc_off; 465 #endif 466 /* Set the baud rate */ 467 if (ops->setbrg) { 468 ret = ops->setbrg(dev, gd->baudrate); 469 if (ret) 470 return ret; 471 } 472 473 #ifdef CONFIG_DM_STDIO 474 if (!(gd->flags & GD_FLG_RELOC)) 475 return 0; 476 memset(&sdev, '\0', sizeof(sdev)); 477 478 strncpy(sdev.name, dev->name, sizeof(sdev.name)); 479 sdev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT | DEV_FLAGS_DM; 480 sdev.priv = dev; 481 sdev.putc = serial_stub_putc; 482 sdev.puts = serial_stub_puts; 483 sdev.getc = serial_stub_getc; 484 sdev.tstc = serial_stub_tstc; 485 486 #if CONFIG_IS_ENABLED(SERIAL_RX_BUFFER) 487 /* Allocate the RX buffer */ 488 upriv->buf = malloc(CONFIG_SERIAL_RX_BUFFER_SIZE); 489 #endif 490 491 stdio_register_dev(&sdev, &upriv->sdev); 492 #endif 493 return 0; 494 } 495 496 static int serial_pre_remove(struct udevice *dev) 497 { 498 #if CONFIG_IS_ENABLED(SYS_STDIO_DEREGISTER) 499 struct serial_dev_priv *upriv = dev_get_uclass_priv(dev); 500 501 if (stdio_deregister_dev(upriv->sdev, true)) 502 return -EPERM; 503 #endif 504 505 return 0; 506 } 507 508 UCLASS_DRIVER(serial) = { 509 .id = UCLASS_SERIAL, 510 .name = "serial", 511 .flags = DM_UC_FLAG_SEQ_ALIAS, 512 .post_probe = serial_post_probe, 513 .pre_remove = serial_pre_remove, 514 .per_device_auto_alloc_size = sizeof(struct serial_dev_priv), 515 }; 516 #endif 517