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