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 <fdtdec.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 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 #ifndef CONFIG_SYS_MALLOC_F_LEN 27 #error "Serial is required before relocation - define CONFIG_SYS_MALLOC_F_LEN to make this work" 28 #endif 29 30 static void serial_find_console_or_panic(void) 31 { 32 struct udevice *dev; 33 int node; 34 35 if (CONFIG_IS_ENABLED(OF_CONTROL) && gd->fdt_blob) { 36 /* Check for a chosen console */ 37 node = fdtdec_get_chosen_node(gd->fdt_blob, "stdout-path"); 38 if (node < 0) 39 node = fdt_path_offset(gd->fdt_blob, "console"); 40 if (!uclass_get_device_by_of_offset(UCLASS_SERIAL, node, 41 &dev)) { 42 gd->cur_serial_dev = dev; 43 return; 44 } 45 46 /* 47 * If the console is not marked to be bound before relocation, 48 * bind it anyway. 49 */ 50 if (node > 0 && 51 !lists_bind_fdt(gd->dm_root, gd->fdt_blob, node, &dev)) { 52 if (!device_probe(dev)) { 53 gd->cur_serial_dev = dev; 54 return; 55 } 56 } 57 } 58 if (!SPL_BUILD || !CONFIG_IS_ENABLED(OF_CONTROL) || !gd->fdt_blob) { 59 /* 60 * Try to use CONFIG_CONS_INDEX if available (it is numbered 61 * from 1!). 62 * 63 * Failing that, get the device with sequence number 0, or in 64 * extremis just the first serial device we can find. But we 65 * insist on having a console (even if it is silent). 66 */ 67 #ifdef CONFIG_CONS_INDEX 68 #define INDEX (CONFIG_CONS_INDEX - 1) 69 #else 70 #define INDEX 0 71 #endif 72 if (!uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &dev) || 73 !uclass_get_device(UCLASS_SERIAL, INDEX, &dev) || 74 (!uclass_first_device(UCLASS_SERIAL, &dev) && dev)) { 75 gd->cur_serial_dev = dev; 76 return; 77 } 78 #undef INDEX 79 } 80 81 #ifdef CONFIG_REQUIRE_SERIAL_CONSOLE 82 panic_str("No serial driver found"); 83 #endif 84 } 85 86 /* Called prior to relocation */ 87 int serial_init(void) 88 { 89 serial_find_console_or_panic(); 90 gd->flags |= GD_FLG_SERIAL_READY; 91 92 return 0; 93 } 94 95 /* Called after relocation */ 96 void serial_initialize(void) 97 { 98 serial_find_console_or_panic(); 99 } 100 101 static void _serial_putc(struct udevice *dev, char ch) 102 { 103 struct dm_serial_ops *ops = serial_get_ops(dev); 104 int err; 105 106 do { 107 err = ops->putc(dev, ch); 108 } while (err == -EAGAIN); 109 if (ch == '\n') 110 _serial_putc(dev, '\r'); 111 } 112 113 static void _serial_puts(struct udevice *dev, const char *str) 114 { 115 while (*str) 116 _serial_putc(dev, *str++); 117 } 118 119 static int _serial_getc(struct udevice *dev) 120 { 121 struct dm_serial_ops *ops = serial_get_ops(dev); 122 int err; 123 124 do { 125 err = ops->getc(dev); 126 if (err == -EAGAIN) 127 WATCHDOG_RESET(); 128 } while (err == -EAGAIN); 129 130 return err >= 0 ? err : 0; 131 } 132 133 static int _serial_tstc(struct udevice *dev) 134 { 135 struct dm_serial_ops *ops = serial_get_ops(dev); 136 137 if (ops->pending) 138 return ops->pending(dev, true); 139 140 return 1; 141 } 142 143 void serial_putc(char ch) 144 { 145 if (gd->cur_serial_dev) 146 _serial_putc(gd->cur_serial_dev, ch); 147 } 148 149 void serial_puts(const char *str) 150 { 151 if (gd->cur_serial_dev) 152 _serial_puts(gd->cur_serial_dev, str); 153 } 154 155 int serial_getc(void) 156 { 157 if (!gd->cur_serial_dev) 158 return 0; 159 160 return _serial_getc(gd->cur_serial_dev); 161 } 162 163 int serial_tstc(void) 164 { 165 if (!gd->cur_serial_dev) 166 return 0; 167 168 return _serial_tstc(gd->cur_serial_dev); 169 } 170 171 void serial_setbrg(void) 172 { 173 struct dm_serial_ops *ops; 174 175 if (!gd->cur_serial_dev) 176 return; 177 178 ops = serial_get_ops(gd->cur_serial_dev); 179 if (ops->setbrg) 180 ops->setbrg(gd->cur_serial_dev, gd->baudrate); 181 } 182 183 void serial_stdio_init(void) 184 { 185 } 186 187 #ifdef CONFIG_DM_STDIO 188 static void serial_stub_putc(struct stdio_dev *sdev, const char ch) 189 { 190 _serial_putc(sdev->priv, ch); 191 } 192 #endif 193 194 void serial_stub_puts(struct stdio_dev *sdev, const char *str) 195 { 196 _serial_puts(sdev->priv, str); 197 } 198 199 int serial_stub_getc(struct stdio_dev *sdev) 200 { 201 return _serial_getc(sdev->priv); 202 } 203 204 int serial_stub_tstc(struct stdio_dev *sdev) 205 { 206 return _serial_tstc(sdev->priv); 207 } 208 209 /** 210 * on_baudrate() - Update the actual baudrate when the env var changes 211 * 212 * This will check for a valid baudrate and only apply it if valid. 213 */ 214 static int on_baudrate(const char *name, const char *value, enum env_op op, 215 int flags) 216 { 217 int i; 218 int baudrate; 219 220 switch (op) { 221 case env_op_create: 222 case env_op_overwrite: 223 /* 224 * Switch to new baudrate if new baudrate is supported 225 */ 226 baudrate = simple_strtoul(value, NULL, 10); 227 228 /* Not actually changing */ 229 if (gd->baudrate == baudrate) 230 return 0; 231 232 for (i = 0; i < ARRAY_SIZE(baudrate_table); ++i) { 233 if (baudrate == baudrate_table[i]) 234 break; 235 } 236 if (i == ARRAY_SIZE(baudrate_table)) { 237 if ((flags & H_FORCE) == 0) 238 printf("## Baudrate %d bps not supported\n", 239 baudrate); 240 return 1; 241 } 242 if ((flags & H_INTERACTIVE) != 0) { 243 printf("## Switch baudrate to %d bps and press ENTER ...\n", 244 baudrate); 245 udelay(50000); 246 } 247 248 gd->baudrate = baudrate; 249 250 serial_setbrg(); 251 252 udelay(50000); 253 254 if ((flags & H_INTERACTIVE) != 0) 255 while (1) { 256 if (getc() == '\r') 257 break; 258 } 259 260 return 0; 261 case env_op_delete: 262 printf("## Baudrate may not be deleted\n"); 263 return 1; 264 default: 265 return 0; 266 } 267 } 268 U_BOOT_ENV_CALLBACK(baudrate, on_baudrate); 269 270 static int serial_post_probe(struct udevice *dev) 271 { 272 struct dm_serial_ops *ops = serial_get_ops(dev); 273 #ifdef CONFIG_DM_STDIO 274 struct serial_dev_priv *upriv = dev_get_uclass_priv(dev); 275 struct stdio_dev sdev; 276 #endif 277 int ret; 278 279 #if defined(CONFIG_NEEDS_MANUAL_RELOC) 280 if (ops->setbrg) 281 ops->setbrg += gd->reloc_off; 282 if (ops->getc) 283 ops->getc += gd->reloc_off; 284 if (ops->putc) 285 ops->putc += gd->reloc_off; 286 if (ops->pending) 287 ops->pending += gd->reloc_off; 288 if (ops->clear) 289 ops->clear += gd->reloc_off; 290 #if CONFIG_POST & CONFIG_SYS_POST_UART 291 if (ops->loop) 292 ops->loop += gd->reloc_off 293 #endif 294 #endif 295 /* Set the baud rate */ 296 if (ops->setbrg) { 297 ret = ops->setbrg(dev, gd->baudrate); 298 if (ret) 299 return ret; 300 } 301 302 #ifdef CONFIG_DM_STDIO 303 if (!(gd->flags & GD_FLG_RELOC)) 304 return 0; 305 memset(&sdev, '\0', sizeof(sdev)); 306 307 strncpy(sdev.name, dev->name, sizeof(sdev.name)); 308 sdev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT; 309 sdev.priv = dev; 310 sdev.putc = serial_stub_putc; 311 sdev.puts = serial_stub_puts; 312 sdev.getc = serial_stub_getc; 313 sdev.tstc = serial_stub_tstc; 314 stdio_register_dev(&sdev, &upriv->sdev); 315 #endif 316 return 0; 317 } 318 319 static int serial_pre_remove(struct udevice *dev) 320 { 321 #ifdef CONFIG_SYS_STDIO_DEREGISTER 322 struct serial_dev_priv *upriv = dev_get_uclass_priv(dev); 323 324 if (stdio_deregister_dev(upriv->sdev, 0)) 325 return -EPERM; 326 #endif 327 328 return 0; 329 } 330 331 UCLASS_DRIVER(serial) = { 332 .id = UCLASS_SERIAL, 333 .name = "serial", 334 .flags = DM_UC_FLAG_SEQ_ALIAS, 335 .post_probe = serial_post_probe, 336 .pre_remove = serial_pre_remove, 337 .per_device_auto_alloc_size = sizeof(struct serial_dev_priv), 338 }; 339