blob: df2b84aaafd69e36908f561d6273280c41727d9f [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;
77#if defined(CONFIG_PPC) || defined(CONFIG_MCF52x2)
78 gd->bd->bi_baudrate = baudrate;
79#endif
80
81 serial_setbrg();
82
83 udelay(50000);
84
85 if ((flags & H_INTERACTIVE) != 0)
86 while (1) {
87 if (getc() == '\r')
88 break;
89 }
90
91 return 0;
92 case env_op_delete:
93 printf("## Baudrate may not be deleted\n");
94 return 1;
95 default:
96 return 0;
97 }
98}
99U_BOOT_ENV_CALLBACK(baudrate, on_baudrate);
100
101/**
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000102 * serial_initfunc() - Forward declare of driver registration routine
103 * @name: Name of the real driver registration routine.
104 *
105 * This macro expands onto forward declaration of a driver registration
106 * routine, which is then used below in serial_initialize() function.
107 * The declaration is made weak and aliases to serial_null() so in case
108 * the driver is not compiled in, the function is still declared and can
109 * be used, but aliases to serial_null() and thus is optimized away.
110 */
Marek Vasut2a333ae2012-09-12 17:49:58 +0200111#define serial_initfunc(name) \
112 void name(void) \
113 __attribute__((weak, alias("serial_null")));
114
Marek Vasutf0eb1f62012-09-12 13:50:56 +0200115serial_initfunc(mpc8xx_serial_initialize);
Marek Vasutabc0ed82012-09-12 20:02:05 +0200116serial_initfunc(ns16550_serial_initialize);
Marek Vasut1fe5c112012-09-12 13:57:58 +0200117serial_initfunc(pxa_serial_initialize);
Marek Vasut28af6382012-09-12 16:01:16 +0200118serial_initfunc(s3c24xx_serial_initialize);
Marek Vasutb4980512012-09-12 19:39:57 +0200119serial_initfunc(s5p_serial_initialize);
Tom Rini51d81022012-10-08 14:46:23 -0700120serial_initfunc(zynq_serial_initalize);
Marek Vasut5ae1de02012-09-12 20:07:54 +0200121serial_initfunc(bfin_serial_initialize);
Marek Vasut41651ca2012-09-13 00:02:54 +0200122serial_initfunc(bfin_jtag_initialize);
Marek Vasut918327c2012-09-12 19:50:18 +0200123serial_initfunc(mpc512x_serial_initialize);
Marek Vasut87d69222012-09-12 19:45:58 +0200124serial_initfunc(uartlite_serial_initialize);
Marek Vasut7b953c52012-09-13 01:16:50 +0200125serial_initfunc(au1x00_serial_initialize);
Marek Vasut01911422012-09-13 01:20:07 +0200126serial_initfunc(asc_serial_initialize);
Marek Vasut6cb32732012-09-13 01:20:59 +0200127serial_initfunc(jz_serial_initialize);
Marek Vasutb57c6522012-09-13 01:26:42 +0200128serial_initfunc(mpc5xx_serial_initialize);
Marek Vasutd68f4da2012-09-13 01:34:16 +0200129serial_initfunc(mpc8260_scc_serial_initialize);
130serial_initfunc(mpc8260_smc_serial_initialize);
Marek Vasut7a311542012-09-13 01:38:52 +0200131serial_initfunc(mpc85xx_serial_initialize);
Marek Vasutfcc20742012-09-13 01:40:33 +0200132serial_initfunc(iop480_serial_initialize);
Marek Vasutaf7be3b2012-09-13 12:25:07 +0200133serial_initfunc(leon2_serial_initialize);
Marek Vasut29b5ff72012-09-13 12:25:48 +0200134serial_initfunc(leon3_serial_initialize);
Marek Vasutafe4c382012-09-13 12:26:39 +0200135serial_initfunc(marvell_serial_initialize);
Marek Vasut5dee6f52012-09-13 12:27:37 +0200136serial_initfunc(amirix_serial_initialize);
Marek Vasutc45a14a2012-09-13 12:28:07 +0200137serial_initfunc(bmw_serial_initialize);
Marek Vasutd25c39d2012-09-13 12:29:31 +0200138serial_initfunc(cogent_serial_initialize);
Marek Vasut619c90b2012-09-13 12:32:56 +0200139serial_initfunc(cpci750_serial_initialize);
Marek Vasut829b3b22012-09-13 12:33:50 +0200140serial_initfunc(evb64260_serial_initialize);
Marek Vasutd126f282012-09-13 12:34:24 +0200141serial_initfunc(ml2_serial_initialize);
Marek Vasut26d8eaa2012-09-13 12:34:49 +0200142serial_initfunc(sconsole_serial_initialize);
Marek Vasut088a4f32012-09-13 12:35:54 +0200143serial_initfunc(p3mx_serial_initialize);
Marek Vasut8c085752012-09-13 16:48:50 +0200144serial_initfunc(altera_jtag_serial_initialize);
Marek Vasutb207d642012-09-13 16:49:51 +0200145serial_initfunc(altera_serial_initialize);
Marek Vasutcfba4572012-09-13 16:50:30 +0200146serial_initfunc(atmel_serial_initialize);
Marek Vasute503f902012-09-13 16:51:02 +0200147serial_initfunc(lpc32xx_serial_initialize);
Marek Vasutabaef692012-09-13 16:51:38 +0200148serial_initfunc(mcf_serial_initialize);
Marek Vasut69ea8072012-09-13 16:52:38 +0200149serial_initfunc(oc_serial_initialize);
Marek Vasutcef46b72012-09-14 22:33:21 +0200150serial_initfunc(sandbox_serial_initialize);
Marek Vasut8b029db2012-09-14 22:34:22 +0200151serial_initfunc(clps7111_serial_initialize);
Marek Vasut7882e7c2012-09-14 22:34:51 +0200152serial_initfunc(imx_serial_initialize);
Marek Vasutb6cd0fe2012-09-14 22:35:14 +0200153serial_initfunc(ixp_serial_initialize);
Marek Vasuta7ffb2f2012-09-14 22:35:43 +0200154serial_initfunc(ks8695_serial_initialize);
Marek Vasut1f673b42012-09-14 22:36:27 +0200155serial_initfunc(lh7a40x_serial_initialize);
Marek Vasut7cd851a2012-09-14 22:37:17 +0200156serial_initfunc(max3100_serial_initialize);
Marek Vasuta9434722012-09-14 22:37:43 +0200157serial_initfunc(mxc_serial_initialize);
Marek Vasut39f61472012-09-14 22:38:46 +0200158serial_initfunc(pl01x_serial_initialize);
Marek Vasuta30a4222012-09-14 22:39:44 +0200159serial_initfunc(sa1100_serial_initialize);
Marek Vasut8bdd7ef2012-09-14 22:40:08 +0200160serial_initfunc(sh_serial_initialize);
Jagannadha Sutradharudu Tekia168d3a2013-08-04 01:22:25 +0530161serial_initfunc(arm_dcc_initialize);
Andreas Wass661edaa2013-08-14 23:45:03 +0200162serial_initfunc(mxs_auart_initialize);
Marek Vasutf0eb1f62012-09-12 13:50:56 +0200163
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000164/**
165 * serial_register() - Register serial driver with serial driver core
166 * @dev: Pointer to the serial driver structure
167 *
168 * This function registers the serial driver supplied via @dev with
169 * serial driver core, thus making U-Boot aware of it and making it
170 * available for U-Boot to use. On platforms that still require manual
171 * relocation of constant variables, relocation of the supplied structure
172 * is performed.
173 */
Mike Frysingerc52b4f72011-04-29 18:03:30 +0000174void serial_register(struct serial_device *dev)
wdenk281e00a2004-08-01 22:48:16 +0000175{
Wolfgang Denk2e5167c2010-10-28 20:00:11 +0200176#ifdef CONFIG_NEEDS_MANUAL_RELOC
Marek Vasutf2760c42012-09-16 18:54:22 +0200177 if (dev->start)
178 dev->start += gd->reloc_off;
179 if (dev->stop)
180 dev->stop += gd->reloc_off;
181 if (dev->setbrg)
182 dev->setbrg += gd->reloc_off;
183 if (dev->getc)
184 dev->getc += gd->reloc_off;
185 if (dev->tstc)
186 dev->tstc += gd->reloc_off;
187 if (dev->putc)
188 dev->putc += gd->reloc_off;
189 if (dev->puts)
190 dev->puts += gd->reloc_off;
Peter Tyser521af042009-09-21 11:20:36 -0500191#endif
wdenk281e00a2004-08-01 22:48:16 +0000192
193 dev->next = serial_devices;
194 serial_devices = dev;
wdenk281e00a2004-08-01 22:48:16 +0000195}
196
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000197/**
198 * serial_initialize() - Register all compiled-in serial port drivers
199 *
200 * This function registers all serial port drivers that are compiled
201 * into the U-Boot binary with the serial core, thus making them
202 * available to U-Boot to use. Lastly, this function assigns a default
203 * serial port to the serial core. That serial port is then used as a
204 * default output.
205 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000206void serial_initialize(void)
wdenk281e00a2004-08-01 22:48:16 +0000207{
Marek Vasutf0eb1f62012-09-12 13:50:56 +0200208 mpc8xx_serial_initialize();
Marek Vasutabc0ed82012-09-12 20:02:05 +0200209 ns16550_serial_initialize();
Marek Vasut1fe5c112012-09-12 13:57:58 +0200210 pxa_serial_initialize();
Marek Vasut28af6382012-09-12 16:01:16 +0200211 s3c24xx_serial_initialize();
Marek Vasutb4980512012-09-12 19:39:57 +0200212 s5p_serial_initialize();
Marek Vasut918327c2012-09-12 19:50:18 +0200213 mpc512x_serial_initialize();
Marek Vasut5ae1de02012-09-12 20:07:54 +0200214 bfin_serial_initialize();
Marek Vasut41651ca2012-09-13 00:02:54 +0200215 bfin_jtag_initialize();
Marek Vasut87d69222012-09-12 19:45:58 +0200216 uartlite_serial_initialize();
Tom Rini51d81022012-10-08 14:46:23 -0700217 zynq_serial_initalize();
Marek Vasut7b953c52012-09-13 01:16:50 +0200218 au1x00_serial_initialize();
Marek Vasut01911422012-09-13 01:20:07 +0200219 asc_serial_initialize();
Marek Vasut6cb32732012-09-13 01:20:59 +0200220 jz_serial_initialize();
Marek Vasutb57c6522012-09-13 01:26:42 +0200221 mpc5xx_serial_initialize();
Marek Vasutd68f4da2012-09-13 01:34:16 +0200222 mpc8260_scc_serial_initialize();
223 mpc8260_smc_serial_initialize();
Marek Vasut7a311542012-09-13 01:38:52 +0200224 mpc85xx_serial_initialize();
Marek Vasutfcc20742012-09-13 01:40:33 +0200225 iop480_serial_initialize();
Marek Vasutaf7be3b2012-09-13 12:25:07 +0200226 leon2_serial_initialize();
Marek Vasut29b5ff72012-09-13 12:25:48 +0200227 leon3_serial_initialize();
Marek Vasutafe4c382012-09-13 12:26:39 +0200228 marvell_serial_initialize();
Marek Vasut5dee6f52012-09-13 12:27:37 +0200229 amirix_serial_initialize();
Marek Vasutc45a14a2012-09-13 12:28:07 +0200230 bmw_serial_initialize();
Marek Vasutd25c39d2012-09-13 12:29:31 +0200231 cogent_serial_initialize();
Marek Vasut619c90b2012-09-13 12:32:56 +0200232 cpci750_serial_initialize();
Marek Vasut829b3b22012-09-13 12:33:50 +0200233 evb64260_serial_initialize();
Marek Vasutd126f282012-09-13 12:34:24 +0200234 ml2_serial_initialize();
Marek Vasut26d8eaa2012-09-13 12:34:49 +0200235 sconsole_serial_initialize();
Marek Vasut088a4f32012-09-13 12:35:54 +0200236 p3mx_serial_initialize();
Marek Vasut8c085752012-09-13 16:48:50 +0200237 altera_jtag_serial_initialize();
Marek Vasutb207d642012-09-13 16:49:51 +0200238 altera_serial_initialize();
Marek Vasutcfba4572012-09-13 16:50:30 +0200239 atmel_serial_initialize();
Marek Vasute503f902012-09-13 16:51:02 +0200240 lpc32xx_serial_initialize();
Marek Vasutabaef692012-09-13 16:51:38 +0200241 mcf_serial_initialize();
Marek Vasut69ea8072012-09-13 16:52:38 +0200242 oc_serial_initialize();
Marek Vasutcef46b72012-09-14 22:33:21 +0200243 sandbox_serial_initialize();
Marek Vasut8b029db2012-09-14 22:34:22 +0200244 clps7111_serial_initialize();
Marek Vasut7882e7c2012-09-14 22:34:51 +0200245 imx_serial_initialize();
Marek Vasutb6cd0fe2012-09-14 22:35:14 +0200246 ixp_serial_initialize();
Marek Vasuta7ffb2f2012-09-14 22:35:43 +0200247 ks8695_serial_initialize();
Marek Vasut1f673b42012-09-14 22:36:27 +0200248 lh7a40x_serial_initialize();
Marek Vasut7cd851a2012-09-14 22:37:17 +0200249 max3100_serial_initialize();
Marek Vasuta9434722012-09-14 22:37:43 +0200250 mxc_serial_initialize();
Marek Vasut39f61472012-09-14 22:38:46 +0200251 pl01x_serial_initialize();
Marek Vasuta30a4222012-09-14 22:39:44 +0200252 sa1100_serial_initialize();
Marek Vasut8bdd7ef2012-09-14 22:40:08 +0200253 sh_serial_initialize();
Jagannadha Sutradharudu Tekia168d3a2013-08-04 01:22:25 +0530254 arm_dcc_initialize();
Andreas Wass661edaa2013-08-14 23:45:03 +0200255 mxs_auart_initialize();
Marek Vasut7b953c52012-09-13 01:16:50 +0200256
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000257 serial_assign(default_serial_console()->name);
wdenk281e00a2004-08-01 22:48:16 +0000258}
259
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000260/**
261 * serial_stdio_init() - Register serial ports with STDIO core
262 *
263 * This function generates a proxy driver for each serial port driver.
264 * These proxy drivers then register with the STDIO core, making the
265 * serial drivers available as STDIO devices.
266 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000267void serial_stdio_init(void)
wdenk281e00a2004-08-01 22:48:16 +0000268{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200269 struct stdio_dev dev;
wdenk281e00a2004-08-01 22:48:16 +0000270 struct serial_device *s = serial_devices;
271
wdenk2ee66532004-10-11 22:43:02 +0000272 while (s) {
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000273 memset(&dev, 0, sizeof(dev));
wdenk281e00a2004-08-01 22:48:16 +0000274
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000275 strcpy(dev.name, s->name);
wdenk281e00a2004-08-01 22:48:16 +0000276 dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT;
277
Marek Vasut89143fb2012-09-07 14:35:31 +0200278 dev.start = s->start;
279 dev.stop = s->stop;
wdenk281e00a2004-08-01 22:48:16 +0000280 dev.putc = s->putc;
281 dev.puts = s->puts;
282 dev.getc = s->getc;
283 dev.tstc = s->tstc;
284
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000285 stdio_register(&dev);
wdenk281e00a2004-08-01 22:48:16 +0000286
287 s = s->next;
288 }
289}
290
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000291/**
292 * serial_assign() - Select the serial output device by name
293 * @name: Name of the serial driver to be used as default output
294 *
295 * This function configures the serial output multiplexing by
296 * selecting which serial device will be used as default. In case
297 * the STDIO "serial" device is selected as stdin/stdout/stderr,
298 * the serial device previously configured by this function will be
299 * used for the particular operation.
300 *
301 * Returns 0 on success, negative on error.
302 */
Gerlando Falauto7813ca92011-11-18 06:49:12 +0000303int serial_assign(const char *name)
wdenk281e00a2004-08-01 22:48:16 +0000304{
305 struct serial_device *s;
306
wdenk2ee66532004-10-11 22:43:02 +0000307 for (s = serial_devices; s; s = s->next) {
Marek Vasut6d93e252012-10-06 14:07:03 +0000308 if (strcmp(s->name, name))
309 continue;
310 serial_current = s;
311 return 0;
wdenk281e00a2004-08-01 22:48:16 +0000312 }
313
Marek Vasut6d93e252012-10-06 14:07:03 +0000314 return -EINVAL;
wdenk281e00a2004-08-01 22:48:16 +0000315}
316
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000317/**
318 * serial_reinit_all() - Reinitialize all compiled-in serial ports
319 *
320 * This function reinitializes all serial ports that are compiled
321 * into U-Boot by calling their serial_start() functions.
322 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000323void serial_reinit_all(void)
wdenk281e00a2004-08-01 22:48:16 +0000324{
325 struct serial_device *s;
326
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000327 for (s = serial_devices; s; s = s->next)
Marek Vasut89143fb2012-09-07 14:35:31 +0200328 s->start();
wdenk281e00a2004-08-01 22:48:16 +0000329}
330
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000331/**
332 * get_current() - Return pointer to currently selected serial port
333 *
334 * This function returns a pointer to currently selected serial port.
335 * The currently selected serial port is altered by serial_assign()
336 * function.
337 *
338 * In case this function is called before relocation or before any serial
339 * port is configured, this function calls default_serial_console() to
340 * determine the serial port. Otherwise, the configured serial port is
341 * returned.
342 *
343 * Returns pointer to the currently selected serial port on success,
344 * NULL on error.
345 */
Simon Glass857c2832011-08-19 11:09:43 +0000346static struct serial_device *get_current(void)
wdenk281e00a2004-08-01 22:48:16 +0000347{
Simon Glass857c2832011-08-19 11:09:43 +0000348 struct serial_device *dev;
349
Marek Vasutdee19412012-10-06 14:07:04 +0000350 if (!(gd->flags & GD_FLG_RELOC))
Simon Glass857c2832011-08-19 11:09:43 +0000351 dev = default_serial_console();
Marek Vasutdee19412012-10-06 14:07:04 +0000352 else if (!serial_current)
353 dev = default_serial_console();
354 else
Simon Glass857c2832011-08-19 11:09:43 +0000355 dev = serial_current;
Marek Vasutdee19412012-10-06 14:07:04 +0000356
357 /* We must have a console device */
358 if (!dev) {
359#ifdef CONFIG_SPL_BUILD
360 puts("Cannot find console\n");
361 hang();
362#else
363 panic("Cannot find console\n");
364#endif
365 }
366
Simon Glass857c2832011-08-19 11:09:43 +0000367 return dev;
368}
wdenk281e00a2004-08-01 22:48:16 +0000369
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000370/**
371 * serial_init() - Initialize currently selected serial port
372 *
373 * This function initializes the currently selected serial port. This
374 * usually involves setting up the registers of that particular port,
375 * enabling clock and such. This function uses the get_current() call
376 * to determine which port is selected.
377 *
378 * Returns 0 on success, negative on error.
379 */
Simon Glass857c2832011-08-19 11:09:43 +0000380int serial_init(void)
381{
Marek Vasut89143fb2012-09-07 14:35:31 +0200382 return get_current()->start();
wdenk281e00a2004-08-01 22:48:16 +0000383}
384
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000385/**
386 * serial_setbrg() - Configure baud-rate of currently selected serial port
387 *
388 * This function configures the baud-rate of the currently selected
389 * serial port. The baud-rate is retrieved from global data within
390 * the serial port driver. This function uses the get_current() call
391 * to determine which port is selected.
392 *
393 * Returns 0 on success, negative on error.
394 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000395void serial_setbrg(void)
wdenk281e00a2004-08-01 22:48:16 +0000396{
Simon Glass857c2832011-08-19 11:09:43 +0000397 get_current()->setbrg();
wdenk281e00a2004-08-01 22:48:16 +0000398}
399
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000400/**
401 * serial_getc() - Read character from currently selected serial port
402 *
403 * This function retrieves a character from currently selected serial
404 * port. In case there is no character waiting on the serial port,
405 * this function will block and wait for the character to appear. This
406 * function uses the get_current() call to determine which port is
407 * selected.
408 *
409 * Returns the character on success, negative on error.
410 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000411int serial_getc(void)
wdenk281e00a2004-08-01 22:48:16 +0000412{
Simon Glass857c2832011-08-19 11:09:43 +0000413 return get_current()->getc();
wdenk281e00a2004-08-01 22:48:16 +0000414}
415
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000416/**
417 * serial_tstc() - Test if data is available on currently selected serial port
418 *
419 * This function tests if one or more characters are available on
420 * currently selected serial port. This function never blocks. This
421 * function uses the get_current() call to determine which port is
422 * selected.
423 *
424 * Returns positive if character is available, zero otherwise.
425 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000426int serial_tstc(void)
wdenk281e00a2004-08-01 22:48:16 +0000427{
Simon Glass857c2832011-08-19 11:09:43 +0000428 return get_current()->tstc();
wdenk281e00a2004-08-01 22:48:16 +0000429}
430
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000431/**
432 * serial_putc() - Output character via currently selected serial port
433 * @c: Single character to be output from the serial port.
434 *
435 * This function outputs a character via currently selected serial
436 * port. This character is passed to the serial port driver responsible
437 * for controlling the hardware. The hardware may still be in process
438 * of transmitting another character, therefore this function may block
439 * for a short amount of time. This function uses the get_current()
440 * call to determine which port is selected.
441 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000442void serial_putc(const char c)
wdenk281e00a2004-08-01 22:48:16 +0000443{
Simon Glass857c2832011-08-19 11:09:43 +0000444 get_current()->putc(c);
wdenk281e00a2004-08-01 22:48:16 +0000445}
446
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000447/**
448 * serial_puts() - Output string via currently selected serial port
449 * @s: Zero-terminated string to be output from the serial port.
450 *
451 * This function outputs a zero-terminated string via currently
452 * selected serial port. This function behaves as an accelerator
453 * in case the hardware can queue multiple characters for transfer.
454 * The whole string that is to be output is available to the function
455 * implementing the hardware manipulation. Transmitting the whole
456 * string may take some time, thus this function may block for some
457 * amount of time. This function uses the get_current() call to
458 * determine which port is selected.
459 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000460void serial_puts(const char *s)
wdenk281e00a2004-08-01 22:48:16 +0000461{
Simon Glass857c2832011-08-19 11:09:43 +0000462 get_current()->puts(s);
wdenk281e00a2004-08-01 22:48:16 +0000463}
Mike Frysinger7b826c22011-05-14 06:56:15 +0000464
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000465/**
466 * default_serial_puts() - Output string by calling serial_putc() in loop
467 * @s: Zero-terminated string to be output from the serial port.
468 *
469 * This function outputs a zero-terminated string by calling serial_putc()
470 * in a loop. Most drivers do not support queueing more than one byte for
471 * transfer, thus this function precisely implements their serial_puts().
472 *
473 * To optimize the number of get_current() calls, this function only
474 * calls get_current() once and then directly accesses the putc() call
475 * of the &struct serial_device .
476 */
Marek Vasutbfb7d7a2012-10-06 14:07:01 +0000477void default_serial_puts(const char *s)
478{
479 struct serial_device *dev = get_current();
480 while (*s)
481 dev->putc(*s++);
482}
483
Mike Frysinger7b826c22011-05-14 06:56:15 +0000484#if CONFIG_POST & CONFIG_SYS_POST_UART
485static const int bauds[] = CONFIG_SYS_BAUDRATE_TABLE;
486
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000487/**
488 * uart_post_test() - Test the currently selected serial port using POST
489 * @flags: POST framework flags
490 *
491 * Do a loopback test of the currently selected serial port. This
492 * function is only useful in the context of the POST testing framwork.
493 * The serial port is firstly configured into loopback mode and then
494 * characters are sent through it.
495 *
496 * Returns 0 on success, value otherwise.
497 */
Mike Frysinger7b826c22011-05-14 06:56:15 +0000498/* Mark weak until post/cpu/.../uart.c migrate over */
499__weak
500int uart_post_test(int flags)
501{
502 unsigned char c;
503 int ret, saved_baud, b;
504 struct serial_device *saved_dev, *s;
505 bd_t *bd = gd->bd;
506
507 /* Save current serial state */
508 ret = 0;
509 saved_dev = serial_current;
510 saved_baud = bd->bi_baudrate;
511
512 for (s = serial_devices; s; s = s->next) {
513 /* If this driver doesn't support loop back, skip it */
514 if (!s->loop)
515 continue;
516
517 /* Test the next device */
518 serial_current = s;
519
520 ret = serial_init();
521 if (ret)
522 goto done;
523
524 /* Consume anything that happens to be queued */
525 while (serial_tstc())
526 serial_getc();
527
528 /* Enable loop back */
529 s->loop(1);
530
531 /* Test every available baud rate */
532 for (b = 0; b < ARRAY_SIZE(bauds); ++b) {
533 bd->bi_baudrate = bauds[b];
534 serial_setbrg();
535
536 /*
537 * Stick to printable chars to avoid issues:
538 * - terminal corruption
539 * - serial program reacting to sequences and sending
540 * back random extra data
541 * - most serial drivers add in extra chars (like \r\n)
542 */
543 for (c = 0x20; c < 0x7f; ++c) {
544 /* Send it out */
545 serial_putc(c);
546
547 /* Make sure it's the same one */
548 ret = (c != serial_getc());
549 if (ret) {
550 s->loop(0);
551 goto done;
552 }
553
554 /* Clean up the output in case it was sent */
555 serial_putc('\b');
556 ret = ('\b' != serial_getc());
557 if (ret) {
558 s->loop(0);
559 goto done;
560 }
561 }
562 }
563
564 /* Disable loop back */
565 s->loop(0);
566
Marek Vasut89143fb2012-09-07 14:35:31 +0200567 /* XXX: There is no serial_stop() !? */
568 if (s->stop)
569 s->stop();
Mike Frysinger7b826c22011-05-14 06:56:15 +0000570 }
571
572 done:
573 /* Restore previous serial state */
574 serial_current = saved_dev;
575 bd->bi_baudrate = saved_baud;
576 serial_reinit_all();
577 serial_setbrg();
578
579 return ret;
580}
581#endif