blob: a0af0e6bfde265952e2126c7087f4b9053c9417b [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glass57d92752014-09-04 16:27:26 -06002/*
3 * Copyright (c) 2014 The Chromium OS Authors.
Simon Glass57d92752014-09-04 16:27:26 -06004 */
5
6#include <common.h>
7#include <dm.h>
Simon Glassf3998fd2019-08-02 09:44:25 -06008#include <env_internal.h>
Simon Glass57d92752014-09-04 16:27:26 -06009#include <errno.h>
Simon Glass336d4612020-02-03 07:36:16 -070010#include <malloc.h>
Simon Glass57d92752014-09-04 16:27:26 -060011#include <os.h>
12#include <serial.h>
13#include <stdio_dev.h>
Simon Glassc487fd42014-10-22 21:37:02 -060014#include <watchdog.h>
Simon Glass57d92752014-09-04 16:27:26 -060015#include <dm/lists.h>
16#include <dm/device-internal.h>
Simon Glassf93472a2017-06-12 06:21:58 -060017#include <dm/of_access.h>
Simon Glassc05ed002020-05-10 11:40:11 -060018#include <linux/delay.h>
Simon Glass57d92752014-09-04 16:27:26 -060019
20DECLARE_GLOBAL_DATA_PTR;
21
Simon Glassad1b81c2014-10-29 13:09:03 -060022/*
23 * Table with supported baudrates (defined in config_xyz.h)
24 */
25static const unsigned long baudrate_table[] = CONFIG_SYS_BAUDRATE_TABLE;
26
Andy Yanf1896c42017-07-24 17:43:34 +080027#if !CONFIG_VAL(SYS_MALLOC_F_LEN)
28#error "Serial is required before relocation - define CONFIG_$(SPL_)SYS_MALLOC_F_LEN to make this work"
Simon Glass57d92752014-09-04 16:27:26 -060029#endif
30
Simon Glassaa0ffe82018-10-01 12:22:20 -060031#if CONFIG_IS_ENABLED(SERIAL_PRESENT)
Simon Glassd0960852017-06-12 06:21:57 -060032static int serial_check_stdout(const void *blob, struct udevice **devp)
33{
Bin Meng151f2752019-11-25 05:52:36 -080034 int node = -1;
35 const char *str, *p, *name;
36 int namelen;
Simon Glassd0960852017-06-12 06:21:57 -060037
38 /* Check for a chosen console */
Bin Meng151f2752019-11-25 05:52:36 -080039 str = fdtdec_get_chosen_prop(blob, "stdout-path");
40 if (str) {
41 p = strchr(str, ':');
42 namelen = p ? p - str : strlen(str);
43 node = fdt_path_offset_namelen(blob, str, namelen);
Simon Glassd0960852017-06-12 06:21:57 -060044
Bin Meng151f2752019-11-25 05:52:36 -080045 if (node < 0) {
46 /*
47 * Deal with things like
48 * stdout-path = "serial0:115200n8";
49 *
50 * We need to look up the alias and then follow it to
51 * the correct node.
52 */
53 name = fdt_get_alias_namelen(blob, str, namelen);
Simon Glassd0960852017-06-12 06:21:57 -060054 if (name)
55 node = fdt_path_offset(blob, name);
56 }
57 }
Bin Meng151f2752019-11-25 05:52:36 -080058
Simon Glassd0960852017-06-12 06:21:57 -060059 if (node < 0)
60 node = fdt_path_offset(blob, "console");
61 if (!uclass_get_device_by_of_offset(UCLASS_SERIAL, node, devp))
62 return 0;
63
64 /*
65 * If the console is not marked to be bound before relocation, bind it
66 * anyway.
67 */
68 if (node > 0 && !lists_bind_fdt(gd->dm_root, offset_to_ofnode(node),
Bin Meng8d773c42018-10-10 22:06:58 -070069 devp, false)) {
Simon Glassd0960852017-06-12 06:21:57 -060070 if (!device_probe(*devp))
71 return 0;
72 }
73
74 return -ENODEV;
75}
76
Simon Glass57d92752014-09-04 16:27:26 -060077static void serial_find_console_or_panic(void)
78{
Simon Glass6bdc5932015-10-17 19:41:17 -060079 const void *blob = gd->fdt_blob;
Simon Glass469a5792014-11-10 18:00:20 -070080 struct udevice *dev;
Alexander Grafae5326a2018-01-29 13:57:20 +010081#ifdef CONFIG_SERIAL_SEARCH_ALL
Alexander Graf608b0c42018-01-25 12:05:42 +010082 int ret;
Alexander Grafae5326a2018-01-29 13:57:20 +010083#endif
Simon Glass57d92752014-09-04 16:27:26 -060084
Simon Glassb484b0d2016-07-04 11:58:04 -060085 if (CONFIG_IS_ENABLED(OF_PLATDATA)) {
86 uclass_first_device(UCLASS_SERIAL, &dev);
87 if (dev) {
88 gd->cur_serial_dev = dev;
89 return;
90 }
91 } else if (CONFIG_IS_ENABLED(OF_CONTROL) && blob) {
Simon Glassf93472a2017-06-12 06:21:58 -060092 /* Live tree has support for stdout */
93 if (of_live_active()) {
94 struct device_node *np = of_get_stdout();
95
96 if (np && !uclass_get_device_by_ofnode(UCLASS_SERIAL,
97 np_to_ofnode(np), &dev)) {
98 gd->cur_serial_dev = dev;
99 return;
100 }
101 } else {
102 if (!serial_check_stdout(blob, &dev)) {
103 gd->cur_serial_dev = dev;
104 return;
105 }
Simon Glass469a5792014-11-10 18:00:20 -0700106 }
Simon Glassaf282242015-03-06 13:19:03 -0700107 }
Simon Glass6bdc5932015-10-17 19:41:17 -0600108 if (!SPL_BUILD || !CONFIG_IS_ENABLED(OF_CONTROL) || !blob) {
Simon Glasse9fc0582015-05-12 14:55:05 -0600109 /*
Stefan Roeseeb623b92015-11-26 13:38:43 +0100110 * Try to use CONFIG_CONS_INDEX if available (it is numbered
111 * from 1!).
112 *
113 * Failing that, get the device with sequence number 0, or in
Alexander Graf608b0c42018-01-25 12:05:42 +0100114 * extremis just the first working serial device we can find.
115 * But we insist on having a console (even if it is silent).
Stefan Roeseeb623b92015-11-26 13:38:43 +0100116 */
Simon Glass91155c62014-10-22 21:37:06 -0600117#ifdef CONFIG_CONS_INDEX
118#define INDEX (CONFIG_CONS_INDEX - 1)
119#else
120#define INDEX 0
121#endif
Alexander Grafae5326a2018-01-29 13:57:20 +0100122
123#ifdef CONFIG_SERIAL_SEARCH_ALL
Simon Glasse9fc0582015-05-12 14:55:05 -0600124 if (!uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &dev) ||
Alexander Graf608b0c42018-01-25 12:05:42 +0100125 !uclass_get_device(UCLASS_SERIAL, INDEX, &dev)) {
126 if (dev->flags & DM_FLAG_ACTIVATED) {
127 gd->cur_serial_dev = dev;
128 return;
129 }
130 }
131
132 /* Search for any working device */
133 for (ret = uclass_first_device_check(UCLASS_SERIAL, &dev);
134 dev;
135 ret = uclass_next_device_check(&dev)) {
136 if (!ret) {
137 /* Device did succeed probing */
138 gd->cur_serial_dev = dev;
139 return;
140 }
Simon Glasse9fc0582015-05-12 14:55:05 -0600141 }
Alexander Grafae5326a2018-01-29 13:57:20 +0100142#else
143 if (!uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &dev) ||
144 !uclass_get_device(UCLASS_SERIAL, INDEX, &dev) ||
145 (!uclass_first_device(UCLASS_SERIAL, &dev) && dev)) {
146 gd->cur_serial_dev = dev;
147 return;
148 }
149#endif
150
Simon Glass91155c62014-10-22 21:37:06 -0600151#undef INDEX
Simon Glasse9fc0582015-05-12 14:55:05 -0600152 }
153
Hans de Goede8c458582015-08-08 17:45:18 +0200154#ifdef CONFIG_REQUIRE_SERIAL_CONSOLE
Simon Glasse9fc0582015-05-12 14:55:05 -0600155 panic_str("No serial driver found");
Hans de Goede8c458582015-08-08 17:45:18 +0200156#endif
Simon Glass57d92752014-09-04 16:27:26 -0600157}
Simon Glassaa0ffe82018-10-01 12:22:20 -0600158#endif /* CONFIG_SERIAL_PRESENT */
Simon Glass57d92752014-09-04 16:27:26 -0600159
160/* Called prior to relocation */
161int serial_init(void)
162{
Simon Glassaa0ffe82018-10-01 12:22:20 -0600163#if CONFIG_IS_ENABLED(SERIAL_PRESENT)
Simon Glass57d92752014-09-04 16:27:26 -0600164 serial_find_console_or_panic();
165 gd->flags |= GD_FLG_SERIAL_READY;
Sean Andersonb41d4b82020-02-02 13:15:17 -0500166 serial_setbrg();
Simon Glassaa0ffe82018-10-01 12:22:20 -0600167#endif
Simon Glass57d92752014-09-04 16:27:26 -0600168
169 return 0;
170}
171
172/* Called after relocation */
173void serial_initialize(void)
174{
Simon Glasse4d6ab02016-03-11 22:06:51 -0700175 serial_init();
Simon Glass57d92752014-09-04 16:27:26 -0600176}
177
Masahiro Yamadaeea5a4c2014-10-23 22:26:08 +0900178static void _serial_putc(struct udevice *dev, char ch)
Simon Glass57d92752014-09-04 16:27:26 -0600179{
Masahiro Yamadabac64462014-10-23 22:26:06 +0900180 struct dm_serial_ops *ops = serial_get_ops(dev);
Simon Glass57d92752014-09-04 16:27:26 -0600181 int err;
182
Alison Wangc5917b42016-03-02 11:00:36 +0800183 if (ch == '\n')
184 _serial_putc(dev, '\r');
185
Simon Glass57d92752014-09-04 16:27:26 -0600186 do {
Masahiro Yamadabac64462014-10-23 22:26:06 +0900187 err = ops->putc(dev, ch);
Simon Glass57d92752014-09-04 16:27:26 -0600188 } while (err == -EAGAIN);
Simon Glass57d92752014-09-04 16:27:26 -0600189}
190
Masahiro Yamadaeea5a4c2014-10-23 22:26:08 +0900191static void _serial_puts(struct udevice *dev, const char *str)
Simon Glass57d92752014-09-04 16:27:26 -0600192{
193 while (*str)
Masahiro Yamadaeea5a4c2014-10-23 22:26:08 +0900194 _serial_putc(dev, *str++);
Simon Glass57d92752014-09-04 16:27:26 -0600195}
196
Stefan Roese3ca7a062017-08-16 17:37:16 +0200197static int __serial_getc(struct udevice *dev)
Simon Glass57d92752014-09-04 16:27:26 -0600198{
Simon Glassb8893322014-10-01 19:57:23 -0600199 struct dm_serial_ops *ops = serial_get_ops(dev);
Simon Glass57d92752014-09-04 16:27:26 -0600200 int err;
201
202 do {
Simon Glassb8893322014-10-01 19:57:23 -0600203 err = ops->getc(dev);
Simon Glassc487fd42014-10-22 21:37:02 -0600204 if (err == -EAGAIN)
205 WATCHDOG_RESET();
Simon Glass57d92752014-09-04 16:27:26 -0600206 } while (err == -EAGAIN);
207
208 return err >= 0 ? err : 0;
209}
210
Stefan Roese3ca7a062017-08-16 17:37:16 +0200211static int __serial_tstc(struct udevice *dev)
Masahiro Yamadaeea5a4c2014-10-23 22:26:08 +0900212{
213 struct dm_serial_ops *ops = serial_get_ops(dev);
214
215 if (ops->pending)
216 return ops->pending(dev, true);
217
218 return 1;
219}
220
Stefan Roese3ca7a062017-08-16 17:37:16 +0200221#if CONFIG_IS_ENABLED(SERIAL_RX_BUFFER)
222static int _serial_tstc(struct udevice *dev)
223{
224 struct serial_dev_priv *upriv = dev_get_uclass_priv(dev);
225
226 /* Read all available chars into the RX buffer */
227 while (__serial_tstc(dev)) {
228 upriv->buf[upriv->wr_ptr++] = __serial_getc(dev);
229 upriv->wr_ptr %= CONFIG_SERIAL_RX_BUFFER_SIZE;
230 }
231
232 return upriv->rd_ptr != upriv->wr_ptr ? 1 : 0;
233}
234
235static int _serial_getc(struct udevice *dev)
236{
237 struct serial_dev_priv *upriv = dev_get_uclass_priv(dev);
238 char val;
239
Patrick Delaunayd3bb7852018-08-03 13:38:43 +0200240 if (upriv->rd_ptr == upriv->wr_ptr)
241 return __serial_getc(dev);
242
Stefan Roese3ca7a062017-08-16 17:37:16 +0200243 val = upriv->buf[upriv->rd_ptr++];
244 upriv->rd_ptr %= CONFIG_SERIAL_RX_BUFFER_SIZE;
245
246 return val;
247}
248
249#else /* CONFIG_IS_ENABLED(SERIAL_RX_BUFFER) */
250
251static int _serial_getc(struct udevice *dev)
252{
253 return __serial_getc(dev);
254}
255
256static int _serial_tstc(struct udevice *dev)
257{
258 return __serial_tstc(dev);
259}
260#endif /* CONFIG_IS_ENABLED(SERIAL_RX_BUFFER) */
261
Masahiro Yamadaeea5a4c2014-10-23 22:26:08 +0900262void serial_putc(char ch)
263{
Hans de Goede8c458582015-08-08 17:45:18 +0200264 if (gd->cur_serial_dev)
265 _serial_putc(gd->cur_serial_dev, ch);
Masahiro Yamadaeea5a4c2014-10-23 22:26:08 +0900266}
267
268void serial_puts(const char *str)
269{
Hans de Goede8c458582015-08-08 17:45:18 +0200270 if (gd->cur_serial_dev)
271 _serial_puts(gd->cur_serial_dev, str);
Masahiro Yamadaeea5a4c2014-10-23 22:26:08 +0900272}
273
Simon Glassb8893322014-10-01 19:57:23 -0600274int serial_getc(void)
275{
Hans de Goede8c458582015-08-08 17:45:18 +0200276 if (!gd->cur_serial_dev)
277 return 0;
278
Simon Glass469a5792014-11-10 18:00:20 -0700279 return _serial_getc(gd->cur_serial_dev);
Masahiro Yamadaeea5a4c2014-10-23 22:26:08 +0900280}
281
282int serial_tstc(void)
283{
Hans de Goede8c458582015-08-08 17:45:18 +0200284 if (!gd->cur_serial_dev)
285 return 0;
286
Simon Glass469a5792014-11-10 18:00:20 -0700287 return _serial_tstc(gd->cur_serial_dev);
Masahiro Yamadaeea5a4c2014-10-23 22:26:08 +0900288}
289
290void serial_setbrg(void)
291{
Hans de Goede8c458582015-08-08 17:45:18 +0200292 struct dm_serial_ops *ops;
Masahiro Yamadaeea5a4c2014-10-23 22:26:08 +0900293
Hans de Goede8c458582015-08-08 17:45:18 +0200294 if (!gd->cur_serial_dev)
295 return;
296
297 ops = serial_get_ops(gd->cur_serial_dev);
Masahiro Yamadaeea5a4c2014-10-23 22:26:08 +0900298 if (ops->setbrg)
Simon Glass469a5792014-11-10 18:00:20 -0700299 ops->setbrg(gd->cur_serial_dev, gd->baudrate);
Simon Glassb8893322014-10-01 19:57:23 -0600300}
301
Simon Glass67d1b052018-12-28 14:23:08 -0700302int serial_getconfig(struct udevice *dev, uint *config)
Andy Shevchenkoac7f5db2018-11-20 23:52:32 +0200303{
304 struct dm_serial_ops *ops;
305
Simon Glass67d1b052018-12-28 14:23:08 -0700306 ops = serial_get_ops(dev);
Andy Shevchenkoac7f5db2018-11-20 23:52:32 +0200307 if (ops->getconfig)
Simon Glass67d1b052018-12-28 14:23:08 -0700308 return ops->getconfig(dev, config);
Andy Shevchenkoac7f5db2018-11-20 23:52:32 +0200309
310 return 0;
311}
312
Simon Glass3de04e72018-12-28 14:23:09 -0700313int serial_setconfig(struct udevice *dev, uint config)
Patrice Chotardcbf53882018-08-03 15:07:38 +0200314{
315 struct dm_serial_ops *ops;
316
Simon Glass3de04e72018-12-28 14:23:09 -0700317 ops = serial_get_ops(dev);
Patrice Chotardcbf53882018-08-03 15:07:38 +0200318 if (ops->setconfig)
Simon Glass3de04e72018-12-28 14:23:09 -0700319 return ops->setconfig(dev, config);
Patrice Chotardcbf53882018-08-03 15:07:38 +0200320
321 return 0;
322}
323
Simon Glassa61cbad2018-12-28 14:23:10 -0700324int serial_getinfo(struct udevice *dev, struct serial_device_info *info)
Andy Shevchenkod5bb4f82018-11-20 23:52:33 +0200325{
326 struct dm_serial_ops *ops;
327
Andy Shevchenkod5bb4f82018-11-20 23:52:33 +0200328 if (!info)
329 return -EINVAL;
330
331 info->baudrate = gd->baudrate;
332
Simon Glassa61cbad2018-12-28 14:23:10 -0700333 ops = serial_get_ops(dev);
Andy Shevchenkod5bb4f82018-11-20 23:52:33 +0200334 if (ops->getinfo)
Simon Glassa61cbad2018-12-28 14:23:10 -0700335 return ops->getinfo(dev, info);
Andy Shevchenkod5bb4f82018-11-20 23:52:33 +0200336
337 return -EINVAL;
338}
339
Simon Glass57d92752014-09-04 16:27:26 -0600340void serial_stdio_init(void)
341{
342}
343
Masahiro Yamada49ddcf32017-06-22 16:48:49 +0900344#if defined(CONFIG_DM_STDIO)
345
346#if CONFIG_IS_ENABLED(SERIAL_PRESENT)
Simon Glassb8893322014-10-01 19:57:23 -0600347static void serial_stub_putc(struct stdio_dev *sdev, const char ch)
Simon Glass57d92752014-09-04 16:27:26 -0600348{
Masahiro Yamadaeea5a4c2014-10-23 22:26:08 +0900349 _serial_putc(sdev->priv, ch);
Simon Glass57d92752014-09-04 16:27:26 -0600350}
Simon Glass236f2bd2014-11-10 17:16:48 -0700351#endif
Simon Glass57d92752014-09-04 16:27:26 -0600352
Masahiro Yamada49ddcf32017-06-22 16:48:49 +0900353static void serial_stub_puts(struct stdio_dev *sdev, const char *str)
Simon Glass57d92752014-09-04 16:27:26 -0600354{
Masahiro Yamadaeea5a4c2014-10-23 22:26:08 +0900355 _serial_puts(sdev->priv, str);
Simon Glass57d92752014-09-04 16:27:26 -0600356}
357
Masahiro Yamada49ddcf32017-06-22 16:48:49 +0900358static int serial_stub_getc(struct stdio_dev *sdev)
Simon Glass57d92752014-09-04 16:27:26 -0600359{
Masahiro Yamadaeea5a4c2014-10-23 22:26:08 +0900360 return _serial_getc(sdev->priv);
Simon Glass57d92752014-09-04 16:27:26 -0600361}
362
Masahiro Yamada49ddcf32017-06-22 16:48:49 +0900363static int serial_stub_tstc(struct stdio_dev *sdev)
Simon Glass57d92752014-09-04 16:27:26 -0600364{
Masahiro Yamadaeea5a4c2014-10-23 22:26:08 +0900365 return _serial_tstc(sdev->priv);
Simon Glass57d92752014-09-04 16:27:26 -0600366}
Masahiro Yamada49ddcf32017-06-22 16:48:49 +0900367#endif
Simon Glass57d92752014-09-04 16:27:26 -0600368
Simon Glassad1b81c2014-10-29 13:09:03 -0600369/**
370 * on_baudrate() - Update the actual baudrate when the env var changes
371 *
372 * This will check for a valid baudrate and only apply it if valid.
373 */
374static int on_baudrate(const char *name, const char *value, enum env_op op,
375 int flags)
376{
377 int i;
378 int baudrate;
379
380 switch (op) {
381 case env_op_create:
382 case env_op_overwrite:
383 /*
384 * Switch to new baudrate if new baudrate is supported
385 */
386 baudrate = simple_strtoul(value, NULL, 10);
387
388 /* Not actually changing */
389 if (gd->baudrate == baudrate)
390 return 0;
391
392 for (i = 0; i < ARRAY_SIZE(baudrate_table); ++i) {
393 if (baudrate == baudrate_table[i])
394 break;
395 }
396 if (i == ARRAY_SIZE(baudrate_table)) {
397 if ((flags & H_FORCE) == 0)
398 printf("## Baudrate %d bps not supported\n",
399 baudrate);
400 return 1;
401 }
402 if ((flags & H_INTERACTIVE) != 0) {
403 printf("## Switch baudrate to %d bps and press ENTER ...\n",
404 baudrate);
405 udelay(50000);
406 }
407
408 gd->baudrate = baudrate;
409
410 serial_setbrg();
411
412 udelay(50000);
413
414 if ((flags & H_INTERACTIVE) != 0)
415 while (1) {
416 if (getc() == '\r')
417 break;
418 }
419
420 return 0;
421 case env_op_delete:
422 printf("## Baudrate may not be deleted\n");
423 return 1;
424 default:
425 return 0;
426 }
427}
428U_BOOT_ENV_CALLBACK(baudrate, on_baudrate);
429
Simon Glass92c55b62015-12-13 21:36:58 -0700430#if CONFIG_IS_ENABLED(SERIAL_PRESENT)
Simon Glass57d92752014-09-04 16:27:26 -0600431static int serial_post_probe(struct udevice *dev)
432{
Simon Glass57d92752014-09-04 16:27:26 -0600433 struct dm_serial_ops *ops = serial_get_ops(dev);
Simon Glass236f2bd2014-11-10 17:16:48 -0700434#ifdef CONFIG_DM_STDIO
Simon Glasse564f052015-03-05 12:25:20 -0700435 struct serial_dev_priv *upriv = dev_get_uclass_priv(dev);
Simon Glass236f2bd2014-11-10 17:16:48 -0700436 struct stdio_dev sdev;
437#endif
Simon Glass57d92752014-09-04 16:27:26 -0600438 int ret;
439
Michal Simek484fdf52015-02-02 16:31:59 +0100440#if defined(CONFIG_NEEDS_MANUAL_RELOC)
441 if (ops->setbrg)
442 ops->setbrg += gd->reloc_off;
443 if (ops->getc)
444 ops->getc += gd->reloc_off;
445 if (ops->putc)
446 ops->putc += gd->reloc_off;
447 if (ops->pending)
448 ops->pending += gd->reloc_off;
449 if (ops->clear)
450 ops->clear += gd->reloc_off;
Andy Shevchenkoac7f5db2018-11-20 23:52:32 +0200451 if (ops->getconfig)
452 ops->getconfig += gd->reloc_off;
Patrice Chotardcbf53882018-08-03 15:07:38 +0200453 if (ops->setconfig)
454 ops->setconfig += gd->reloc_off;
Michal Simek484fdf52015-02-02 16:31:59 +0100455#if CONFIG_POST & CONFIG_SYS_POST_UART
456 if (ops->loop)
Andy Shevchenkocdef6bb2018-11-05 18:24:03 +0200457 ops->loop += gd->reloc_off;
Michal Simek484fdf52015-02-02 16:31:59 +0100458#endif
Andy Shevchenkod5bb4f82018-11-20 23:52:33 +0200459 if (ops->getinfo)
460 ops->getinfo += gd->reloc_off;
Michal Simek484fdf52015-02-02 16:31:59 +0100461#endif
Simon Glass57d92752014-09-04 16:27:26 -0600462 /* Set the baud rate */
463 if (ops->setbrg) {
464 ret = ops->setbrg(dev, gd->baudrate);
465 if (ret)
466 return ret;
467 }
468
Simon Glass236f2bd2014-11-10 17:16:48 -0700469#ifdef CONFIG_DM_STDIO
Simon Glass57d92752014-09-04 16:27:26 -0600470 if (!(gd->flags & GD_FLG_RELOC))
471 return 0;
Simon Glass57d92752014-09-04 16:27:26 -0600472 memset(&sdev, '\0', sizeof(sdev));
473
474 strncpy(sdev.name, dev->name, sizeof(sdev.name));
Simon Glass7b3c4c32017-07-27 09:31:04 -0600475 sdev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT | DEV_FLAGS_DM;
Simon Glass57d92752014-09-04 16:27:26 -0600476 sdev.priv = dev;
477 sdev.putc = serial_stub_putc;
478 sdev.puts = serial_stub_puts;
479 sdev.getc = serial_stub_getc;
480 sdev.tstc = serial_stub_tstc;
Stefan Roese3ca7a062017-08-16 17:37:16 +0200481
482#if CONFIG_IS_ENABLED(SERIAL_RX_BUFFER)
483 /* Allocate the RX buffer */
484 upriv->buf = malloc(CONFIG_SERIAL_RX_BUFFER_SIZE);
485#endif
486
Simon Glass57d92752014-09-04 16:27:26 -0600487 stdio_register_dev(&sdev, &upriv->sdev);
Simon Glass236f2bd2014-11-10 17:16:48 -0700488#endif
Simon Glass57d92752014-09-04 16:27:26 -0600489 return 0;
490}
491
492static int serial_pre_remove(struct udevice *dev)
493{
Simon Glass869588d2016-10-17 20:13:02 -0600494#if CONFIG_IS_ENABLED(SYS_STDIO_DEREGISTER)
Simon Glasse564f052015-03-05 12:25:20 -0700495 struct serial_dev_priv *upriv = dev_get_uclass_priv(dev);
Simon Glass57d92752014-09-04 16:27:26 -0600496
Stefan Roesee98856f2017-04-24 09:48:01 +0200497 if (stdio_deregister_dev(upriv->sdev, true))
Simon Glass57d92752014-09-04 16:27:26 -0600498 return -EPERM;
499#endif
500
501 return 0;
502}
503
504UCLASS_DRIVER(serial) = {
505 .id = UCLASS_SERIAL,
506 .name = "serial",
Simon Glass9cc36a22015-01-25 08:27:05 -0700507 .flags = DM_UC_FLAG_SEQ_ALIAS,
Simon Glass57d92752014-09-04 16:27:26 -0600508 .post_probe = serial_post_probe,
509 .pre_remove = serial_pre_remove,
510 .per_device_auto_alloc_size = sizeof(struct serial_dev_priv),
511};
Simon Glass92c55b62015-12-13 21:36:58 -0700512#endif