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