blob: d2eb7520d03886748c7d0130a0851c51eca8d997 [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
Marek Vasutf0eb1f62012-09-12 13:50:56 +0200112serial_initfunc(mpc8xx_serial_initialize);
Marek Vasutabc0ed82012-09-12 20:02:05 +0200113serial_initfunc(ns16550_serial_initialize);
Marek Vasut1fe5c112012-09-12 13:57:58 +0200114serial_initfunc(pxa_serial_initialize);
Marek Vasut28af6382012-09-12 16:01:16 +0200115serial_initfunc(s3c24xx_serial_initialize);
Marek Vasutb4980512012-09-12 19:39:57 +0200116serial_initfunc(s5p_serial_initialize);
Michal Simek870e0bd2014-04-25 13:46:28 +0200117serial_initfunc(zynq_serial_initialize);
Marek Vasut5ae1de02012-09-12 20:07:54 +0200118serial_initfunc(bfin_serial_initialize);
Marek Vasut41651ca2012-09-13 00:02:54 +0200119serial_initfunc(bfin_jtag_initialize);
Marek Vasut918327c2012-09-12 19:50:18 +0200120serial_initfunc(mpc512x_serial_initialize);
Marek Vasut87d69222012-09-12 19:45:58 +0200121serial_initfunc(uartlite_serial_initialize);
Marek Vasut7b953c52012-09-13 01:16:50 +0200122serial_initfunc(au1x00_serial_initialize);
Marek Vasut01911422012-09-13 01:20:07 +0200123serial_initfunc(asc_serial_initialize);
Marek Vasut6cb32732012-09-13 01:20:59 +0200124serial_initfunc(jz_serial_initialize);
Marek Vasutb57c6522012-09-13 01:26:42 +0200125serial_initfunc(mpc5xx_serial_initialize);
Marek Vasutd68f4da2012-09-13 01:34:16 +0200126serial_initfunc(mpc8260_scc_serial_initialize);
127serial_initfunc(mpc8260_smc_serial_initialize);
Marek Vasut7a311542012-09-13 01:38:52 +0200128serial_initfunc(mpc85xx_serial_initialize);
Marek Vasutfcc20742012-09-13 01:40:33 +0200129serial_initfunc(iop480_serial_initialize);
Marek Vasutaf7be3b2012-09-13 12:25:07 +0200130serial_initfunc(leon2_serial_initialize);
Marek Vasut29b5ff72012-09-13 12:25:48 +0200131serial_initfunc(leon3_serial_initialize);
Marek Vasutafe4c382012-09-13 12:26:39 +0200132serial_initfunc(marvell_serial_initialize);
Marek Vasut5dee6f52012-09-13 12:27:37 +0200133serial_initfunc(amirix_serial_initialize);
Marek Vasutc45a14a2012-09-13 12:28:07 +0200134serial_initfunc(bmw_serial_initialize);
Marek Vasutd25c39d2012-09-13 12:29:31 +0200135serial_initfunc(cogent_serial_initialize);
Marek Vasut619c90b2012-09-13 12:32:56 +0200136serial_initfunc(cpci750_serial_initialize);
Marek Vasut829b3b22012-09-13 12:33:50 +0200137serial_initfunc(evb64260_serial_initialize);
Marek Vasutd126f282012-09-13 12:34:24 +0200138serial_initfunc(ml2_serial_initialize);
Marek Vasut26d8eaa2012-09-13 12:34:49 +0200139serial_initfunc(sconsole_serial_initialize);
Marek Vasut088a4f32012-09-13 12:35:54 +0200140serial_initfunc(p3mx_serial_initialize);
Marek Vasut8c085752012-09-13 16:48:50 +0200141serial_initfunc(altera_jtag_serial_initialize);
Marek Vasutb207d642012-09-13 16:49:51 +0200142serial_initfunc(altera_serial_initialize);
Marek Vasutcfba4572012-09-13 16:50:30 +0200143serial_initfunc(atmel_serial_initialize);
Marek Vasute503f902012-09-13 16:51:02 +0200144serial_initfunc(lpc32xx_serial_initialize);
Marek Vasutabaef692012-09-13 16:51:38 +0200145serial_initfunc(mcf_serial_initialize);
Marek Vasut69ea8072012-09-13 16:52:38 +0200146serial_initfunc(oc_serial_initialize);
Marek Vasutcef46b72012-09-14 22:33:21 +0200147serial_initfunc(sandbox_serial_initialize);
Marek Vasut8b029db2012-09-14 22:34:22 +0200148serial_initfunc(clps7111_serial_initialize);
Marek Vasut7882e7c2012-09-14 22:34:51 +0200149serial_initfunc(imx_serial_initialize);
Marek Vasuta7ffb2f2012-09-14 22:35:43 +0200150serial_initfunc(ks8695_serial_initialize);
Marek Vasut1f673b42012-09-14 22:36:27 +0200151serial_initfunc(lh7a40x_serial_initialize);
Marek Vasut7cd851a2012-09-14 22:37:17 +0200152serial_initfunc(max3100_serial_initialize);
Marek Vasuta9434722012-09-14 22:37:43 +0200153serial_initfunc(mxc_serial_initialize);
Marek Vasut39f61472012-09-14 22:38:46 +0200154serial_initfunc(pl01x_serial_initialize);
Marek Vasuta30a4222012-09-14 22:39:44 +0200155serial_initfunc(sa1100_serial_initialize);
Marek Vasut8bdd7ef2012-09-14 22:40:08 +0200156serial_initfunc(sh_serial_initialize);
Jagannadha Sutradharudu Tekia168d3a2013-08-04 01:22:25 +0530157serial_initfunc(arm_dcc_initialize);
Andreas Wass661edaa2013-08-14 23:45:03 +0200158serial_initfunc(mxs_auart_initialize);
Alexey Brodkin22a240c2013-12-13 10:35:11 +0400159serial_initfunc(arc_serial_initialize);
Marek Vasutf0eb1f62012-09-12 13:50:56 +0200160
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000161/**
162 * serial_register() - Register serial driver with serial driver core
163 * @dev: Pointer to the serial driver structure
164 *
165 * This function registers the serial driver supplied via @dev with
166 * serial driver core, thus making U-Boot aware of it and making it
167 * available for U-Boot to use. On platforms that still require manual
168 * relocation of constant variables, relocation of the supplied structure
169 * is performed.
170 */
Mike Frysingerc52b4f72011-04-29 18:03:30 +0000171void serial_register(struct serial_device *dev)
wdenk281e00a2004-08-01 22:48:16 +0000172{
Wolfgang Denk2e5167c2010-10-28 20:00:11 +0200173#ifdef CONFIG_NEEDS_MANUAL_RELOC
Marek Vasutf2760c42012-09-16 18:54:22 +0200174 if (dev->start)
175 dev->start += gd->reloc_off;
176 if (dev->stop)
177 dev->stop += gd->reloc_off;
178 if (dev->setbrg)
179 dev->setbrg += gd->reloc_off;
180 if (dev->getc)
181 dev->getc += gd->reloc_off;
182 if (dev->tstc)
183 dev->tstc += gd->reloc_off;
184 if (dev->putc)
185 dev->putc += gd->reloc_off;
186 if (dev->puts)
187 dev->puts += gd->reloc_off;
Peter Tyser521af042009-09-21 11:20:36 -0500188#endif
wdenk281e00a2004-08-01 22:48:16 +0000189
190 dev->next = serial_devices;
191 serial_devices = dev;
wdenk281e00a2004-08-01 22:48:16 +0000192}
193
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000194/**
195 * serial_initialize() - Register all compiled-in serial port drivers
196 *
197 * This function registers all serial port drivers that are compiled
198 * into the U-Boot binary with the serial core, thus making them
199 * available to U-Boot to use. Lastly, this function assigns a default
200 * serial port to the serial core. That serial port is then used as a
201 * default output.
202 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000203void serial_initialize(void)
wdenk281e00a2004-08-01 22:48:16 +0000204{
Marek Vasutf0eb1f62012-09-12 13:50:56 +0200205 mpc8xx_serial_initialize();
Marek Vasutabc0ed82012-09-12 20:02:05 +0200206 ns16550_serial_initialize();
Marek Vasut1fe5c112012-09-12 13:57:58 +0200207 pxa_serial_initialize();
Marek Vasut28af6382012-09-12 16:01:16 +0200208 s3c24xx_serial_initialize();
Marek Vasutb4980512012-09-12 19:39:57 +0200209 s5p_serial_initialize();
Marek Vasut918327c2012-09-12 19:50:18 +0200210 mpc512x_serial_initialize();
Marek Vasut5ae1de02012-09-12 20:07:54 +0200211 bfin_serial_initialize();
Marek Vasut41651ca2012-09-13 00:02:54 +0200212 bfin_jtag_initialize();
Marek Vasut87d69222012-09-12 19:45:58 +0200213 uartlite_serial_initialize();
Michal Simek870e0bd2014-04-25 13:46:28 +0200214 zynq_serial_initialize();
Marek Vasut7b953c52012-09-13 01:16:50 +0200215 au1x00_serial_initialize();
Marek Vasut01911422012-09-13 01:20:07 +0200216 asc_serial_initialize();
Marek Vasut6cb32732012-09-13 01:20:59 +0200217 jz_serial_initialize();
Marek Vasutb57c6522012-09-13 01:26:42 +0200218 mpc5xx_serial_initialize();
Marek Vasutd68f4da2012-09-13 01:34:16 +0200219 mpc8260_scc_serial_initialize();
220 mpc8260_smc_serial_initialize();
Marek Vasut7a311542012-09-13 01:38:52 +0200221 mpc85xx_serial_initialize();
Marek Vasutfcc20742012-09-13 01:40:33 +0200222 iop480_serial_initialize();
Marek Vasutaf7be3b2012-09-13 12:25:07 +0200223 leon2_serial_initialize();
Marek Vasut29b5ff72012-09-13 12:25:48 +0200224 leon3_serial_initialize();
Marek Vasutafe4c382012-09-13 12:26:39 +0200225 marvell_serial_initialize();
Marek Vasut5dee6f52012-09-13 12:27:37 +0200226 amirix_serial_initialize();
Marek Vasutc45a14a2012-09-13 12:28:07 +0200227 bmw_serial_initialize();
Marek Vasutd25c39d2012-09-13 12:29:31 +0200228 cogent_serial_initialize();
Marek Vasut619c90b2012-09-13 12:32:56 +0200229 cpci750_serial_initialize();
Marek Vasut829b3b22012-09-13 12:33:50 +0200230 evb64260_serial_initialize();
Marek Vasutd126f282012-09-13 12:34:24 +0200231 ml2_serial_initialize();
Marek Vasut26d8eaa2012-09-13 12:34:49 +0200232 sconsole_serial_initialize();
Marek Vasut088a4f32012-09-13 12:35:54 +0200233 p3mx_serial_initialize();
Marek Vasut8c085752012-09-13 16:48:50 +0200234 altera_jtag_serial_initialize();
Marek Vasutb207d642012-09-13 16:49:51 +0200235 altera_serial_initialize();
Marek Vasutcfba4572012-09-13 16:50:30 +0200236 atmel_serial_initialize();
Marek Vasute503f902012-09-13 16:51:02 +0200237 lpc32xx_serial_initialize();
Marek Vasutabaef692012-09-13 16:51:38 +0200238 mcf_serial_initialize();
Marek Vasut69ea8072012-09-13 16:52:38 +0200239 oc_serial_initialize();
Marek Vasutcef46b72012-09-14 22:33:21 +0200240 sandbox_serial_initialize();
Marek Vasut8b029db2012-09-14 22:34:22 +0200241 clps7111_serial_initialize();
Marek Vasut7882e7c2012-09-14 22:34:51 +0200242 imx_serial_initialize();
Marek Vasuta7ffb2f2012-09-14 22:35:43 +0200243 ks8695_serial_initialize();
Marek Vasut1f673b42012-09-14 22:36:27 +0200244 lh7a40x_serial_initialize();
Marek Vasut7cd851a2012-09-14 22:37:17 +0200245 max3100_serial_initialize();
Marek Vasuta9434722012-09-14 22:37:43 +0200246 mxc_serial_initialize();
Marek Vasut39f61472012-09-14 22:38:46 +0200247 pl01x_serial_initialize();
Marek Vasuta30a4222012-09-14 22:39:44 +0200248 sa1100_serial_initialize();
Marek Vasut8bdd7ef2012-09-14 22:40:08 +0200249 sh_serial_initialize();
Jagannadha Sutradharudu Tekia168d3a2013-08-04 01:22:25 +0530250 arm_dcc_initialize();
Andreas Wass661edaa2013-08-14 23:45:03 +0200251 mxs_auart_initialize();
Alexey Brodkin22a240c2013-12-13 10:35:11 +0400252 arc_serial_initialize();
Marek Vasut7b953c52012-09-13 01:16:50 +0200253
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000254 serial_assign(default_serial_console()->name);
wdenk281e00a2004-08-01 22:48:16 +0000255}
256
Simon Glass709ea542014-07-23 06:54:59 -0600257int serial_stub_start(struct stdio_dev *sdev)
258{
259 struct serial_device *dev = sdev->priv;
260
261 return dev->start();
262}
263
264int serial_stub_stop(struct stdio_dev *sdev)
265{
266 struct serial_device *dev = sdev->priv;
267
268 return dev->stop();
269}
270
271void serial_stub_putc(struct stdio_dev *sdev, const char ch)
272{
273 struct serial_device *dev = sdev->priv;
274
275 dev->putc(ch);
276}
277
278void serial_stub_puts(struct stdio_dev *sdev, const char *str)
279{
280 struct serial_device *dev = sdev->priv;
281
282 dev->puts(str);
283}
284
285int serial_stub_getc(struct stdio_dev *sdev)
286{
287 struct serial_device *dev = sdev->priv;
288
289 return dev->getc();
290}
291
292int serial_stub_tstc(struct stdio_dev *sdev)
293{
294 struct serial_device *dev = sdev->priv;
295
296 return dev->tstc();
297}
298
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000299/**
300 * serial_stdio_init() - Register serial ports with STDIO core
301 *
302 * This function generates a proxy driver for each serial port driver.
303 * These proxy drivers then register with the STDIO core, making the
304 * serial drivers available as STDIO devices.
305 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000306void serial_stdio_init(void)
wdenk281e00a2004-08-01 22:48:16 +0000307{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200308 struct stdio_dev dev;
wdenk281e00a2004-08-01 22:48:16 +0000309 struct serial_device *s = serial_devices;
310
wdenk2ee66532004-10-11 22:43:02 +0000311 while (s) {
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000312 memset(&dev, 0, sizeof(dev));
wdenk281e00a2004-08-01 22:48:16 +0000313
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000314 strcpy(dev.name, s->name);
wdenk281e00a2004-08-01 22:48:16 +0000315 dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT;
316
Simon Glass709ea542014-07-23 06:54:59 -0600317 dev.start = serial_stub_start;
318 dev.stop = serial_stub_stop;
319 dev.putc = serial_stub_putc;
320 dev.puts = serial_stub_puts;
321 dev.getc = serial_stub_getc;
322 dev.tstc = serial_stub_tstc;
wdenk281e00a2004-08-01 22:48:16 +0000323
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000324 stdio_register(&dev);
wdenk281e00a2004-08-01 22:48:16 +0000325
326 s = s->next;
327 }
328}
329
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000330/**
331 * serial_assign() - Select the serial output device by name
332 * @name: Name of the serial driver to be used as default output
333 *
334 * This function configures the serial output multiplexing by
335 * selecting which serial device will be used as default. In case
336 * the STDIO "serial" device is selected as stdin/stdout/stderr,
337 * the serial device previously configured by this function will be
338 * used for the particular operation.
339 *
340 * Returns 0 on success, negative on error.
341 */
Gerlando Falauto7813ca92011-11-18 06:49:12 +0000342int serial_assign(const char *name)
wdenk281e00a2004-08-01 22:48:16 +0000343{
344 struct serial_device *s;
345
wdenk2ee66532004-10-11 22:43:02 +0000346 for (s = serial_devices; s; s = s->next) {
Marek Vasut6d93e252012-10-06 14:07:03 +0000347 if (strcmp(s->name, name))
348 continue;
349 serial_current = s;
350 return 0;
wdenk281e00a2004-08-01 22:48:16 +0000351 }
352
Marek Vasut6d93e252012-10-06 14:07:03 +0000353 return -EINVAL;
wdenk281e00a2004-08-01 22:48:16 +0000354}
355
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000356/**
357 * serial_reinit_all() - Reinitialize all compiled-in serial ports
358 *
359 * This function reinitializes all serial ports that are compiled
360 * into U-Boot by calling their serial_start() functions.
361 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000362void serial_reinit_all(void)
wdenk281e00a2004-08-01 22:48:16 +0000363{
364 struct serial_device *s;
365
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000366 for (s = serial_devices; s; s = s->next)
Marek Vasut89143fb2012-09-07 14:35:31 +0200367 s->start();
wdenk281e00a2004-08-01 22:48:16 +0000368}
369
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000370/**
371 * get_current() - Return pointer to currently selected serial port
372 *
373 * This function returns a pointer to currently selected serial port.
374 * The currently selected serial port is altered by serial_assign()
375 * function.
376 *
377 * In case this function is called before relocation or before any serial
378 * port is configured, this function calls default_serial_console() to
379 * determine the serial port. Otherwise, the configured serial port is
380 * returned.
381 *
382 * Returns pointer to the currently selected serial port on success,
383 * NULL on error.
384 */
Simon Glass857c2832011-08-19 11:09:43 +0000385static struct serial_device *get_current(void)
wdenk281e00a2004-08-01 22:48:16 +0000386{
Simon Glass857c2832011-08-19 11:09:43 +0000387 struct serial_device *dev;
388
Marek Vasutdee19412012-10-06 14:07:04 +0000389 if (!(gd->flags & GD_FLG_RELOC))
Simon Glass857c2832011-08-19 11:09:43 +0000390 dev = default_serial_console();
Marek Vasutdee19412012-10-06 14:07:04 +0000391 else if (!serial_current)
392 dev = default_serial_console();
393 else
Simon Glass857c2832011-08-19 11:09:43 +0000394 dev = serial_current;
Marek Vasutdee19412012-10-06 14:07:04 +0000395
396 /* We must have a console device */
397 if (!dev) {
398#ifdef CONFIG_SPL_BUILD
399 puts("Cannot find console\n");
400 hang();
401#else
402 panic("Cannot find console\n");
403#endif
404 }
405
Simon Glass857c2832011-08-19 11:09:43 +0000406 return dev;
407}
wdenk281e00a2004-08-01 22:48:16 +0000408
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000409/**
410 * serial_init() - Initialize currently selected serial port
411 *
412 * This function initializes the currently selected serial port. This
413 * usually involves setting up the registers of that particular port,
414 * enabling clock and such. This function uses the get_current() call
415 * to determine which port is selected.
416 *
417 * Returns 0 on success, negative on error.
418 */
Simon Glass857c2832011-08-19 11:09:43 +0000419int serial_init(void)
420{
Simon Glass093f79a2014-07-23 06:55:07 -0600421 gd->flags |= GD_FLG_SERIAL_READY;
Marek Vasut89143fb2012-09-07 14:35:31 +0200422 return get_current()->start();
wdenk281e00a2004-08-01 22:48:16 +0000423}
424
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000425/**
426 * serial_setbrg() - Configure baud-rate of currently selected serial port
427 *
428 * This function configures the baud-rate of the currently selected
429 * serial port. The baud-rate is retrieved from global data within
430 * the serial port driver. This function uses the get_current() call
431 * to determine which port is selected.
432 *
433 * Returns 0 on success, negative on error.
434 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000435void serial_setbrg(void)
wdenk281e00a2004-08-01 22:48:16 +0000436{
Simon Glass857c2832011-08-19 11:09:43 +0000437 get_current()->setbrg();
wdenk281e00a2004-08-01 22:48:16 +0000438}
439
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000440/**
441 * serial_getc() - Read character from currently selected serial port
442 *
443 * This function retrieves a character from currently selected serial
444 * port. In case there is no character waiting on the serial port,
445 * this function will block and wait for the character to appear. This
446 * function uses the get_current() call to determine which port is
447 * selected.
448 *
449 * Returns the character on success, negative on error.
450 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000451int serial_getc(void)
wdenk281e00a2004-08-01 22:48:16 +0000452{
Simon Glass857c2832011-08-19 11:09:43 +0000453 return get_current()->getc();
wdenk281e00a2004-08-01 22:48:16 +0000454}
455
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000456/**
457 * serial_tstc() - Test if data is available on currently selected serial port
458 *
459 * This function tests if one or more characters are available on
460 * currently selected serial port. This function never blocks. This
461 * function uses the get_current() call to determine which port is
462 * selected.
463 *
464 * Returns positive if character is available, zero otherwise.
465 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000466int serial_tstc(void)
wdenk281e00a2004-08-01 22:48:16 +0000467{
Simon Glass857c2832011-08-19 11:09:43 +0000468 return get_current()->tstc();
wdenk281e00a2004-08-01 22:48:16 +0000469}
470
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000471/**
472 * serial_putc() - Output character via currently selected serial port
473 * @c: Single character to be output from the serial port.
474 *
475 * This function outputs a character via currently selected serial
476 * port. This character is passed to the serial port driver responsible
477 * for controlling the hardware. The hardware may still be in process
478 * of transmitting another character, therefore this function may block
479 * for a short amount of time. This function uses the get_current()
480 * call to determine which port is selected.
481 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000482void serial_putc(const char c)
wdenk281e00a2004-08-01 22:48:16 +0000483{
Simon Glass857c2832011-08-19 11:09:43 +0000484 get_current()->putc(c);
wdenk281e00a2004-08-01 22:48:16 +0000485}
486
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000487/**
488 * serial_puts() - Output string via currently selected serial port
489 * @s: Zero-terminated string to be output from the serial port.
490 *
491 * This function outputs a zero-terminated string via currently
492 * selected serial port. This function behaves as an accelerator
493 * in case the hardware can queue multiple characters for transfer.
494 * The whole string that is to be output is available to the function
495 * implementing the hardware manipulation. Transmitting the whole
496 * string may take some time, thus this function may block for some
497 * amount of time. This function uses the get_current() call to
498 * determine which port is selected.
499 */
Gerlando Falautoa6e6f7f2011-11-18 06:49:11 +0000500void serial_puts(const char *s)
wdenk281e00a2004-08-01 22:48:16 +0000501{
Simon Glass857c2832011-08-19 11:09:43 +0000502 get_current()->puts(s);
wdenk281e00a2004-08-01 22:48:16 +0000503}
Mike Frysinger7b826c22011-05-14 06:56:15 +0000504
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000505/**
506 * default_serial_puts() - Output string by calling serial_putc() in loop
507 * @s: Zero-terminated string to be output from the serial port.
508 *
509 * This function outputs a zero-terminated string by calling serial_putc()
510 * in a loop. Most drivers do not support queueing more than one byte for
511 * transfer, thus this function precisely implements their serial_puts().
512 *
513 * To optimize the number of get_current() calls, this function only
514 * calls get_current() once and then directly accesses the putc() call
515 * of the &struct serial_device .
516 */
Marek Vasutbfb7d7a2012-10-06 14:07:01 +0000517void default_serial_puts(const char *s)
518{
519 struct serial_device *dev = get_current();
520 while (*s)
521 dev->putc(*s++);
522}
523
Mike Frysinger7b826c22011-05-14 06:56:15 +0000524#if CONFIG_POST & CONFIG_SYS_POST_UART
525static const int bauds[] = CONFIG_SYS_BAUDRATE_TABLE;
526
Marek Vasut9cd2b9e2012-10-08 11:36:39 +0000527/**
528 * uart_post_test() - Test the currently selected serial port using POST
529 * @flags: POST framework flags
530 *
531 * Do a loopback test of the currently selected serial port. This
532 * function is only useful in the context of the POST testing framwork.
533 * The serial port is firstly configured into loopback mode and then
534 * characters are sent through it.
535 *
536 * Returns 0 on success, value otherwise.
537 */
Mike Frysinger7b826c22011-05-14 06:56:15 +0000538/* Mark weak until post/cpu/.../uart.c migrate over */
539__weak
540int uart_post_test(int flags)
541{
542 unsigned char c;
543 int ret, saved_baud, b;
544 struct serial_device *saved_dev, *s;
Mike Frysinger7b826c22011-05-14 06:56:15 +0000545
546 /* Save current serial state */
547 ret = 0;
548 saved_dev = serial_current;
Masahiro Yamada8e261572014-04-04 20:09:58 +0900549 saved_baud = gd->baudrate;
Mike Frysinger7b826c22011-05-14 06:56:15 +0000550
551 for (s = serial_devices; s; s = s->next) {
552 /* If this driver doesn't support loop back, skip it */
553 if (!s->loop)
554 continue;
555
556 /* Test the next device */
557 serial_current = s;
558
559 ret = serial_init();
560 if (ret)
561 goto done;
562
563 /* Consume anything that happens to be queued */
564 while (serial_tstc())
565 serial_getc();
566
567 /* Enable loop back */
568 s->loop(1);
569
570 /* Test every available baud rate */
571 for (b = 0; b < ARRAY_SIZE(bauds); ++b) {
Masahiro Yamada8e261572014-04-04 20:09:58 +0900572 gd->baudrate = bauds[b];
Mike Frysinger7b826c22011-05-14 06:56:15 +0000573 serial_setbrg();
574
575 /*
576 * Stick to printable chars to avoid issues:
577 * - terminal corruption
578 * - serial program reacting to sequences and sending
579 * back random extra data
580 * - most serial drivers add in extra chars (like \r\n)
581 */
582 for (c = 0x20; c < 0x7f; ++c) {
583 /* Send it out */
584 serial_putc(c);
585
586 /* Make sure it's the same one */
587 ret = (c != serial_getc());
588 if (ret) {
589 s->loop(0);
590 goto done;
591 }
592
593 /* Clean up the output in case it was sent */
594 serial_putc('\b');
595 ret = ('\b' != serial_getc());
596 if (ret) {
597 s->loop(0);
598 goto done;
599 }
600 }
601 }
602
603 /* Disable loop back */
604 s->loop(0);
605
Marek Vasut89143fb2012-09-07 14:35:31 +0200606 /* XXX: There is no serial_stop() !? */
607 if (s->stop)
608 s->stop();
Mike Frysinger7b826c22011-05-14 06:56:15 +0000609 }
610
611 done:
612 /* Restore previous serial state */
613 serial_current = saved_dev;
Masahiro Yamada8e261572014-04-04 20:09:58 +0900614 gd->baudrate = saved_baud;
Mike Frysinger7b826c22011-05-14 06:56:15 +0000615 serial_reinit_all();
616 serial_setbrg();
617
618 return ret;
619}
620#endif