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