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