blob: 422d3aedc3105a992f9d39b9233b8aa187435ac7 [file] [log] [blame]
wdenk281e00a2004-08-01 22:48:16 +00001/*
2 * (C) Copyright 2004
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
Wolfgang Denk1a459662013-07-08 09:37:19 +02005 * SPDX-License-Identifier: GPL-2.0+
wdenk281e00a2004-08-01 22:48:16 +00006 */
7
8#include <common.h>
Joe Hershberger32057712012-12-11 22:16:27 -06009#include <environment.h>
wdenk281e00a2004-08-01 22:48:16 +000010#include <serial.h>
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +020011#include <stdio_dev.h>
Mike Frysinger7b826c22011-05-14 06:56:15 +000012#include <post.h>
13#include <linux/compiler.h>
Marek Vasut6d93e252012-10-06 14:07:03 +000014#include <errno.h>
wdenk281e00a2004-08-01 22:48:16 +000015
Wolfgang Denkd87080b2006-03-31 18:32:53 +020016DECLARE_GLOBAL_DATA_PTR;
17
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +000018static struct serial_device *serial_devices;
19static struct serial_device *serial_current;
Joe Hershberger32057712012-12-11 22:16:27 -060020/*
21 * Table with supported baudrates (defined in config_xyz.h)
22 */
23static const unsigned long baudrate_table[] = CONFIG_SYS_BAUDRATE_TABLE;
wdenk281e00a2004-08-01 22:48:16 +000024
Marek Vasut9cd2b9e2012-10-08 11:36:39 +000025/**
26 * serial_null() - Void registration routine of a serial driver
27 *
28 * This routine implements a void registration routine of a serial
29 * driver. The registration routine of a particular driver is aliased
30 * to this empty function in case the driver is not compiled into
31 * U-Boot.
32 */
Marek Vasut2a333ae2012-09-12 17:49:58 +020033static void serial_null(void)
34{
35}
36
Marek Vasut9cd2b9e2012-10-08 11:36:39 +000037/**
Joe Hershberger32057712012-12-11 22:16:27 -060038 * on_baudrate() - Update the actual baudrate when the env var changes
39 *
40 * This will check for a valid baudrate and only apply it if valid.
41 */
42static int on_baudrate(const char *name, const char *value, enum env_op op,
43 int flags)
44{
45 int i;
46 int baudrate;
47
48 switch (op) {
49 case env_op_create:
50 case env_op_overwrite:
51 /*
52 * Switch to new baudrate if new baudrate is supported
53 */
54 baudrate = simple_strtoul(value, NULL, 10);
55
56 /* Not actually changing */
57 if (gd->baudrate == baudrate)
58 return 0;
59
Axel Lin99351752013-06-23 00:46:41 +080060 for (i = 0; i < ARRAY_SIZE(baudrate_table); ++i) {
Joe Hershberger32057712012-12-11 22:16:27 -060061 if (baudrate == baudrate_table[i])
62 break;
63 }
Axel Lin99351752013-06-23 00:46:41 +080064 if (i == ARRAY_SIZE(baudrate_table)) {
Joe Hershberger32057712012-12-11 22:16:27 -060065 if ((flags & H_FORCE) == 0)
66 printf("## Baudrate %d bps not supported\n",
67 baudrate);
68 return 1;
69 }
70 if ((flags & H_INTERACTIVE) != 0) {
71 printf("## Switch baudrate to %d"
72 " bps and press ENTER ...\n", baudrate);
73 udelay(50000);
74 }
75
76 gd->baudrate = baudrate;
Joe Hershberger32057712012-12-11 22:16:27 -060077
78 serial_setbrg();
79
80 udelay(50000);
81
82 if ((flags & H_INTERACTIVE) != 0)
83 while (1) {
84 if (getc() == '\r')
85 break;
86 }
87
88 return 0;
89 case env_op_delete:
90 printf("## Baudrate may not be deleted\n");
91 return 1;
92 default:
93 return 0;
94 }
95}
96U_BOOT_ENV_CALLBACK(baudrate, on_baudrate);
97
98/**
Marek Vasut9cd2b9e2012-10-08 11:36:39 +000099 * serial_initfunc() - Forward declare of driver registration routine
100 * @name: Name of the real driver registration routine.
101 *
102 * This macro expands onto forward declaration of a driver registration
103 * routine, which is then used below in serial_initialize() function.
104 * The declaration is made weak and aliases to serial_null() so in case
105 * the driver is not compiled in, the function is still declared and can
106 * be used, but aliases to serial_null() and thus is optimized away.
107 */
Marek Vasut2a333ae2012-09-12 17:49:58 +0200108#define serial_initfunc(name) \
109 void name(void) \
110 __attribute__((weak, alias("serial_null")));
111
Jeroen Hofstee94a255d2014-10-27 20:10:07 +0100112serial_initfunc(amirix_serial_initialize);
113serial_initfunc(arc_serial_initialize);
114serial_initfunc(arm_dcc_initialize);
Marek Vasut01911422012-09-13 01:20:07 +0200115serial_initfunc(asc_serial_initialize);
Jeroen Hofstee94a255d2014-10-27 20:10:07 +0100116serial_initfunc(atmel_serial_initialize);
117serial_initfunc(au1x00_serial_initialize);
118serial_initfunc(bfin_jtag_initialize);
119serial_initfunc(bfin_serial_initialize);
120serial_initfunc(bmw_serial_initialize);
121serial_initfunc(clps7111_serial_initialize);
122serial_initfunc(cogent_serial_initialize);
123serial_initfunc(cpci750_serial_initialize);
124serial_initfunc(evb64260_serial_initialize);
125serial_initfunc(imx_serial_initialize);
126serial_initfunc(iop480_serial_initialize);
Marek Vasut6cb32732012-09-13 01:20:59 +0200127serial_initfunc(jz_serial_initialize);
Jeroen Hofstee94a255d2014-10-27 20:10:07 +0100128serial_initfunc(leon2_serial_initialize);
129serial_initfunc(leon3_serial_initialize);
130serial_initfunc(lh7a40x_serial_initialize);
131serial_initfunc(lpc32xx_serial_initialize);
132serial_initfunc(marvell_serial_initialize);
133serial_initfunc(max3100_serial_initialize);
134serial_initfunc(mcf_serial_initialize);
135serial_initfunc(ml2_serial_initialize);
136serial_initfunc(mpc512x_serial_initialize);
Marek Vasutb57c6522012-09-13 01:26:42 +0200137serial_initfunc(mpc5xx_serial_initialize);
Marek Vasutd68f4da2012-09-13 01:34:16 +0200138serial_initfunc(mpc8260_scc_serial_initialize);
139serial_initfunc(mpc8260_smc_serial_initialize);
Marek Vasut7a311542012-09-13 01:38:52 +0200140serial_initfunc(mpc85xx_serial_initialize);
Jeroen Hofstee94a255d2014-10-27 20:10:07 +0100141serial_initfunc(mpc8xx_serial_initialize);
Marek Vasuta9434722012-09-14 22:37:43 +0200142serial_initfunc(mxc_serial_initialize);
Andreas Wass661edaa2013-08-14 23:45:03 +0200143serial_initfunc(mxs_auart_initialize);
Jeroen Hofstee94a255d2014-10-27 20:10:07 +0100144serial_initfunc(ns16550_serial_initialize);
145serial_initfunc(oc_serial_initialize);
146serial_initfunc(p3mx_serial_initialize);
147serial_initfunc(pl01x_serial_initialize);
148serial_initfunc(pxa_serial_initialize);
149serial_initfunc(s3c24xx_serial_initialize);
150serial_initfunc(s5p_serial_initialize);
151serial_initfunc(sa1100_serial_initialize);
152serial_initfunc(sandbox_serial_initialize);
153serial_initfunc(sconsole_serial_initialize);
154serial_initfunc(sh_serial_initialize);
rev13@wp.plab3f0c72015-03-01 12:44:41 +0100155serial_initfunc(stm32_serial_initialize);
Jeroen Hofstee94a255d2014-10-27 20:10:07 +0100156serial_initfunc(uartlite_serial_initialize);
157serial_initfunc(zynq_serial_initialize);
Marek Vasutf0eb1f62012-09-12 13:50:56 +0200158
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000159/**
160 * serial_register() - Register serial driver with serial driver core
161 * @dev: Pointer to the serial driver structure
162 *
163 * This function registers the serial driver supplied via @dev with
164 * serial driver core, thus making U-Boot aware of it and making it
165 * available for U-Boot to use. On platforms that still require manual
166 * relocation of constant variables, relocation of the supplied structure
167 * is performed.
168 */
Mike Frysingerc52b4f72011-04-29 18:03:30 +0000169void serial_register(struct serial_device *dev)
wdenk281e00a2004-08-01 22:48:16 +0000170{
Wolfgang Denk2e5167c2010-10-28 20:00:11 +0200171#ifdef CONFIG_NEEDS_MANUAL_RELOC
Marek Vasutf2760c42012-09-16 18:54:22 +0200172 if (dev->start)
173 dev->start += gd->reloc_off;
174 if (dev->stop)
175 dev->stop += gd->reloc_off;
176 if (dev->setbrg)
177 dev->setbrg += gd->reloc_off;
178 if (dev->getc)
179 dev->getc += gd->reloc_off;
180 if (dev->tstc)
181 dev->tstc += gd->reloc_off;
182 if (dev->putc)
183 dev->putc += gd->reloc_off;
184 if (dev->puts)
185 dev->puts += gd->reloc_off;
Peter Tyser521af042009-09-21 11:20:36 -0500186#endif
wdenk281e00a2004-08-01 22:48:16 +0000187
188 dev->next = serial_devices;
189 serial_devices = dev;
wdenk281e00a2004-08-01 22:48:16 +0000190}
191
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000192/**
193 * serial_initialize() - Register all compiled-in serial port drivers
194 *
195 * This function registers all serial port drivers that are compiled
196 * into the U-Boot binary with the serial core, thus making them
197 * available to U-Boot to use. Lastly, this function assigns a default
198 * serial port to the serial core. That serial port is then used as a
199 * default output.
200 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000201void serial_initialize(void)
wdenk281e00a2004-08-01 22:48:16 +0000202{
Jeroen Hofstee94a255d2014-10-27 20:10:07 +0100203 amirix_serial_initialize();
204 arc_serial_initialize();
205 arm_dcc_initialize();
Marek Vasut01911422012-09-13 01:20:07 +0200206 asc_serial_initialize();
Jeroen Hofstee94a255d2014-10-27 20:10:07 +0100207 atmel_serial_initialize();
208 au1x00_serial_initialize();
209 bfin_jtag_initialize();
210 bfin_serial_initialize();
211 bmw_serial_initialize();
212 clps7111_serial_initialize();
213 cogent_serial_initialize();
214 cpci750_serial_initialize();
215 evb64260_serial_initialize();
216 imx_serial_initialize();
217 iop480_serial_initialize();
Marek Vasut6cb32732012-09-13 01:20:59 +0200218 jz_serial_initialize();
Jeroen Hofstee94a255d2014-10-27 20:10:07 +0100219 leon2_serial_initialize();
220 leon3_serial_initialize();
221 lh7a40x_serial_initialize();
222 lpc32xx_serial_initialize();
223 marvell_serial_initialize();
224 max3100_serial_initialize();
225 mcf_serial_initialize();
226 ml2_serial_initialize();
227 mpc512x_serial_initialize();
Marek Vasutb57c6522012-09-13 01:26:42 +0200228 mpc5xx_serial_initialize();
Marek Vasutd68f4da2012-09-13 01:34:16 +0200229 mpc8260_scc_serial_initialize();
230 mpc8260_smc_serial_initialize();
Marek Vasut7a311542012-09-13 01:38:52 +0200231 mpc85xx_serial_initialize();
Jeroen Hofstee94a255d2014-10-27 20:10:07 +0100232 mpc8xx_serial_initialize();
Marek Vasuta9434722012-09-14 22:37:43 +0200233 mxc_serial_initialize();
Andreas Wass661edaa2013-08-14 23:45:03 +0200234 mxs_auart_initialize();
Jeroen Hofstee94a255d2014-10-27 20:10:07 +0100235 ns16550_serial_initialize();
236 oc_serial_initialize();
237 p3mx_serial_initialize();
238 pl01x_serial_initialize();
239 pxa_serial_initialize();
240 s3c24xx_serial_initialize();
241 s5p_serial_initialize();
242 sa1100_serial_initialize();
243 sandbox_serial_initialize();
244 sconsole_serial_initialize();
245 sh_serial_initialize();
rev13@wp.plab3f0c72015-03-01 12:44:41 +0100246 stm32_serial_initialize();
Jeroen Hofstee94a255d2014-10-27 20:10:07 +0100247 uartlite_serial_initialize();
248 zynq_serial_initialize();
Marek Vasut7b953c52012-09-13 01:16:50 +0200249
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000250 serial_assign(default_serial_console()->name);
wdenk281e00a2004-08-01 22:48:16 +0000251}
252
Jeroen Hofstee654f8d02014-10-08 22:57:44 +0200253static int serial_stub_start(struct stdio_dev *sdev)
Simon Glass709ea542014-07-23 06:54:59 -0600254{
255 struct serial_device *dev = sdev->priv;
256
257 return dev->start();
258}
259
Jeroen Hofstee654f8d02014-10-08 22:57:44 +0200260static int serial_stub_stop(struct stdio_dev *sdev)
Simon Glass709ea542014-07-23 06:54:59 -0600261{
262 struct serial_device *dev = sdev->priv;
263
264 return dev->stop();
265}
266
Jeroen Hofstee654f8d02014-10-08 22:57:44 +0200267static void serial_stub_putc(struct stdio_dev *sdev, const char ch)
Simon Glass709ea542014-07-23 06:54:59 -0600268{
269 struct serial_device *dev = sdev->priv;
270
271 dev->putc(ch);
272}
273
Jeroen Hofstee654f8d02014-10-08 22:57:44 +0200274static void serial_stub_puts(struct stdio_dev *sdev, const char *str)
Simon Glass709ea542014-07-23 06:54:59 -0600275{
276 struct serial_device *dev = sdev->priv;
277
278 dev->puts(str);
279}
280
281int serial_stub_getc(struct stdio_dev *sdev)
282{
283 struct serial_device *dev = sdev->priv;
284
285 return dev->getc();
286}
287
288int serial_stub_tstc(struct stdio_dev *sdev)
289{
290 struct serial_device *dev = sdev->priv;
291
292 return dev->tstc();
293}
294
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000295/**
296 * serial_stdio_init() - Register serial ports with STDIO core
297 *
298 * This function generates a proxy driver for each serial port driver.
299 * These proxy drivers then register with the STDIO core, making the
300 * serial drivers available as STDIO devices.
301 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000302void serial_stdio_init(void)
wdenk281e00a2004-08-01 22:48:16 +0000303{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200304 struct stdio_dev dev;
wdenk281e00a2004-08-01 22:48:16 +0000305 struct serial_device *s = serial_devices;
306
wdenk2ee66532004-10-11 22:43:02 +0000307 while (s) {
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000308 memset(&dev, 0, sizeof(dev));
wdenk281e00a2004-08-01 22:48:16 +0000309
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000310 strcpy(dev.name, s->name);
wdenk281e00a2004-08-01 22:48:16 +0000311 dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT;
312
Simon Glass709ea542014-07-23 06:54:59 -0600313 dev.start = serial_stub_start;
314 dev.stop = serial_stub_stop;
315 dev.putc = serial_stub_putc;
316 dev.puts = serial_stub_puts;
317 dev.getc = serial_stub_getc;
318 dev.tstc = serial_stub_tstc;
Simon Glassaddf9512014-09-04 16:27:23 -0600319 dev.priv = s;
wdenk281e00a2004-08-01 22:48:16 +0000320
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000321 stdio_register(&dev);
wdenk281e00a2004-08-01 22:48:16 +0000322
323 s = s->next;
324 }
325}
326
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000327/**
328 * serial_assign() - Select the serial output device by name
329 * @name: Name of the serial driver to be used as default output
330 *
331 * This function configures the serial output multiplexing by
332 * selecting which serial device will be used as default. In case
333 * the STDIO "serial" device is selected as stdin/stdout/stderr,
334 * the serial device previously configured by this function will be
335 * used for the particular operation.
336 *
337 * Returns 0 on success, negative on error.
338 */
Gerlando Falauto7813ca92011-11-18 06:49:12 +0000339int serial_assign(const char *name)
wdenk281e00a2004-08-01 22:48:16 +0000340{
341 struct serial_device *s;
342
wdenk2ee66532004-10-11 22:43:02 +0000343 for (s = serial_devices; s; s = s->next) {
Marek Vasut6d93e252012-10-06 14:07:03 +0000344 if (strcmp(s->name, name))
345 continue;
346 serial_current = s;
347 return 0;
wdenk281e00a2004-08-01 22:48:16 +0000348 }
349
Marek Vasut6d93e252012-10-06 14:07:03 +0000350 return -EINVAL;
wdenk281e00a2004-08-01 22:48:16 +0000351}
352
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000353/**
354 * serial_reinit_all() - Reinitialize all compiled-in serial ports
355 *
356 * This function reinitializes all serial ports that are compiled
357 * into U-Boot by calling their serial_start() functions.
358 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000359void serial_reinit_all(void)
wdenk281e00a2004-08-01 22:48:16 +0000360{
361 struct serial_device *s;
362
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000363 for (s = serial_devices; s; s = s->next)
Marek Vasut89143fb2012-09-07 14:35:31 +0200364 s->start();
wdenk281e00a2004-08-01 22:48:16 +0000365}
366
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000367/**
368 * get_current() - Return pointer to currently selected serial port
369 *
370 * This function returns a pointer to currently selected serial port.
371 * The currently selected serial port is altered by serial_assign()
372 * function.
373 *
374 * In case this function is called before relocation or before any serial
375 * port is configured, this function calls default_serial_console() to
376 * determine the serial port. Otherwise, the configured serial port is
377 * returned.
378 *
379 * Returns pointer to the currently selected serial port on success,
380 * NULL on error.
381 */
Simon Glass857c2832011-08-19 11:09:43 +0000382static struct serial_device *get_current(void)
wdenk281e00a2004-08-01 22:48:16 +0000383{
Simon Glass857c2832011-08-19 11:09:43 +0000384 struct serial_device *dev;
385
Marek Vasutdee19412012-10-06 14:07:04 +0000386 if (!(gd->flags & GD_FLG_RELOC))
Simon Glass857c2832011-08-19 11:09:43 +0000387 dev = default_serial_console();
Marek Vasutdee19412012-10-06 14:07:04 +0000388 else if (!serial_current)
389 dev = default_serial_console();
390 else
Simon Glass857c2832011-08-19 11:09:43 +0000391 dev = serial_current;
Marek Vasutdee19412012-10-06 14:07:04 +0000392
393 /* We must have a console device */
394 if (!dev) {
395#ifdef CONFIG_SPL_BUILD
396 puts("Cannot find console\n");
397 hang();
398#else
399 panic("Cannot find console\n");
400#endif
401 }
402
Simon Glass857c2832011-08-19 11:09:43 +0000403 return dev;
404}
wdenk281e00a2004-08-01 22:48:16 +0000405
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000406/**
407 * serial_init() - Initialize currently selected serial port
408 *
409 * This function initializes the currently selected serial port. This
410 * usually involves setting up the registers of that particular port,
411 * enabling clock and such. This function uses the get_current() call
412 * to determine which port is selected.
413 *
414 * Returns 0 on success, negative on error.
415 */
Simon Glass857c2832011-08-19 11:09:43 +0000416int serial_init(void)
417{
Simon Glass093f79a2014-07-23 06:55:07 -0600418 gd->flags |= GD_FLG_SERIAL_READY;
Marek Vasut89143fb2012-09-07 14:35:31 +0200419 return get_current()->start();
wdenk281e00a2004-08-01 22:48:16 +0000420}
421
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000422/**
423 * serial_setbrg() - Configure baud-rate of currently selected serial port
424 *
425 * This function configures the baud-rate of the currently selected
426 * serial port. The baud-rate is retrieved from global data within
427 * the serial port driver. This function uses the get_current() call
428 * to determine which port is selected.
429 *
430 * Returns 0 on success, negative on error.
431 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000432void serial_setbrg(void)
wdenk281e00a2004-08-01 22:48:16 +0000433{
Simon Glass857c2832011-08-19 11:09:43 +0000434 get_current()->setbrg();
wdenk281e00a2004-08-01 22:48:16 +0000435}
436
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000437/**
438 * serial_getc() - Read character from currently selected serial port
439 *
440 * This function retrieves a character from currently selected serial
441 * port. In case there is no character waiting on the serial port,
442 * this function will block and wait for the character to appear. This
443 * function uses the get_current() call to determine which port is
444 * selected.
445 *
446 * Returns the character on success, negative on error.
447 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000448int serial_getc(void)
wdenk281e00a2004-08-01 22:48:16 +0000449{
Simon Glass857c2832011-08-19 11:09:43 +0000450 return get_current()->getc();
wdenk281e00a2004-08-01 22:48:16 +0000451}
452
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000453/**
454 * serial_tstc() - Test if data is available on currently selected serial port
455 *
456 * This function tests if one or more characters are available on
457 * currently selected serial port. This function never blocks. This
458 * function uses the get_current() call to determine which port is
459 * selected.
460 *
461 * Returns positive if character is available, zero otherwise.
462 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000463int serial_tstc(void)
wdenk281e00a2004-08-01 22:48:16 +0000464{
Simon Glass857c2832011-08-19 11:09:43 +0000465 return get_current()->tstc();
wdenk281e00a2004-08-01 22:48:16 +0000466}
467
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000468/**
469 * serial_putc() - Output character via currently selected serial port
470 * @c: Single character to be output from the serial port.
471 *
472 * This function outputs a character via currently selected serial
473 * port. This character is passed to the serial port driver responsible
474 * for controlling the hardware. The hardware may still be in process
475 * of transmitting another character, therefore this function may block
476 * for a short amount of time. This function uses the get_current()
477 * call to determine which port is selected.
478 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000479void serial_putc(const char c)
wdenk281e00a2004-08-01 22:48:16 +0000480{
Simon Glass857c2832011-08-19 11:09:43 +0000481 get_current()->putc(c);
wdenk281e00a2004-08-01 22:48:16 +0000482}
483
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000484/**
485 * serial_puts() - Output string via currently selected serial port
486 * @s: Zero-terminated string to be output from the serial port.
487 *
488 * This function outputs a zero-terminated string via currently
489 * selected serial port. This function behaves as an accelerator
490 * in case the hardware can queue multiple characters for transfer.
491 * The whole string that is to be output is available to the function
492 * implementing the hardware manipulation. Transmitting the whole
493 * string may take some time, thus this function may block for some
494 * amount of time. This function uses the get_current() call to
495 * determine which port is selected.
496 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000497void serial_puts(const char *s)
wdenk281e00a2004-08-01 22:48:16 +0000498{
Simon Glass857c2832011-08-19 11:09:43 +0000499 get_current()->puts(s);
wdenk281e00a2004-08-01 22:48:16 +0000500}
Mike Frysinger7b826c22011-05-14 06:56:15 +0000501
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000502/**
503 * default_serial_puts() - Output string by calling serial_putc() in loop
504 * @s: Zero-terminated string to be output from the serial port.
505 *
506 * This function outputs a zero-terminated string by calling serial_putc()
507 * in a loop. Most drivers do not support queueing more than one byte for
508 * transfer, thus this function precisely implements their serial_puts().
509 *
510 * To optimize the number of get_current() calls, this function only
511 * calls get_current() once and then directly accesses the putc() call
512 * of the &struct serial_device .
513 */
Marek Vasutbfb7d7a2012-10-06 14:07:01 +0000514void default_serial_puts(const char *s)
515{
516 struct serial_device *dev = get_current();
517 while (*s)
518 dev->putc(*s++);
519}
520
Mike Frysinger7b826c22011-05-14 06:56:15 +0000521#if CONFIG_POST & CONFIG_SYS_POST_UART
522static const int bauds[] = CONFIG_SYS_BAUDRATE_TABLE;
523
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000524/**
525 * uart_post_test() - Test the currently selected serial port using POST
526 * @flags: POST framework flags
527 *
528 * Do a loopback test of the currently selected serial port. This
529 * function is only useful in the context of the POST testing framwork.
530 * The serial port is firstly configured into loopback mode and then
531 * characters are sent through it.
532 *
533 * Returns 0 on success, value otherwise.
534 */
Mike Frysinger7b826c22011-05-14 06:56:15 +0000535/* Mark weak until post/cpu/.../uart.c migrate over */
536__weak
537int uart_post_test(int flags)
538{
539 unsigned char c;
540 int ret, saved_baud, b;
541 struct serial_device *saved_dev, *s;
Mike Frysinger7b826c22011-05-14 06:56:15 +0000542
543 /* Save current serial state */
544 ret = 0;
545 saved_dev = serial_current;
Masahiro Yamada8e261572014-04-04 20:09:58 +0900546 saved_baud = gd->baudrate;
Mike Frysinger7b826c22011-05-14 06:56:15 +0000547
548 for (s = serial_devices; s; s = s->next) {
549 /* If this driver doesn't support loop back, skip it */
550 if (!s->loop)
551 continue;
552
553 /* Test the next device */
554 serial_current = s;
555
556 ret = serial_init();
557 if (ret)
558 goto done;
559
560 /* Consume anything that happens to be queued */
561 while (serial_tstc())
562 serial_getc();
563
564 /* Enable loop back */
565 s->loop(1);
566
567 /* Test every available baud rate */
568 for (b = 0; b < ARRAY_SIZE(bauds); ++b) {
Masahiro Yamada8e261572014-04-04 20:09:58 +0900569 gd->baudrate = bauds[b];
Mike Frysinger7b826c22011-05-14 06:56:15 +0000570 serial_setbrg();
571
572 /*
573 * Stick to printable chars to avoid issues:
574 * - terminal corruption
575 * - serial program reacting to sequences and sending
576 * back random extra data
577 * - most serial drivers add in extra chars (like \r\n)
578 */
579 for (c = 0x20; c < 0x7f; ++c) {
580 /* Send it out */
581 serial_putc(c);
582
583 /* Make sure it's the same one */
584 ret = (c != serial_getc());
585 if (ret) {
586 s->loop(0);
587 goto done;
588 }
589
590 /* Clean up the output in case it was sent */
591 serial_putc('\b');
592 ret = ('\b' != serial_getc());
593 if (ret) {
594 s->loop(0);
595 goto done;
596 }
597 }
598 }
599
600 /* Disable loop back */
601 s->loop(0);
602
Marek Vasut89143fb2012-09-07 14:35:31 +0200603 /* XXX: There is no serial_stop() !? */
604 if (s->stop)
605 s->stop();
Mike Frysinger7b826c22011-05-14 06:56:15 +0000606 }
607
608 done:
609 /* Restore previous serial state */
610 serial_current = saved_dev;
Masahiro Yamada8e261572014-04-04 20:09:58 +0900611 gd->baudrate = saved_baud;
Mike Frysinger7b826c22011-05-14 06:56:15 +0000612 serial_reinit_all();
613 serial_setbrg();
614
615 return ret;
616}
617#endif