Merge branch 'u-boot-ti/master' into 'u-boot-arm/master'
[karo-tx-uboot.git] / drivers / serial / serial.c
1 /*
2  * (C) Copyright 2004
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * SPDX-License-Identifier:     GPL-2.0+
6  */
7
8 #include <common.h>
9 #include <environment.h>
10 #include <serial.h>
11 #include <stdio_dev.h>
12 #include <post.h>
13 #include <linux/compiler.h>
14 #include <errno.h>
15
16 DECLARE_GLOBAL_DATA_PTR;
17
18 static struct serial_device *serial_devices;
19 static struct serial_device *serial_current;
20 /*
21  * Table with supported baudrates (defined in config_xyz.h)
22  */
23 static const unsigned long baudrate_table[] = CONFIG_SYS_BAUDRATE_TABLE;
24
25 /**
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  */
33 static void serial_null(void)
34 {
35 }
36
37 /**
38  * 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  */
42 static 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
60                 for (i = 0; i < ARRAY_SIZE(baudrate_table); ++i) {
61                         if (baudrate == baudrate_table[i])
62                                 break;
63                 }
64                 if (i == ARRAY_SIZE(baudrate_table)) {
65                         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 }
99 U_BOOT_ENV_CALLBACK(baudrate, on_baudrate);
100
101 /**
102  * 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  */
111 #define serial_initfunc(name)                                   \
112         void name(void)                                         \
113                 __attribute__((weak, alias("serial_null")));
114
115 serial_initfunc(mpc8xx_serial_initialize);
116 serial_initfunc(ns16550_serial_initialize);
117 serial_initfunc(pxa_serial_initialize);
118 serial_initfunc(s3c24xx_serial_initialize);
119 serial_initfunc(s5p_serial_initialize);
120 serial_initfunc(zynq_serial_initalize);
121 serial_initfunc(bfin_serial_initialize);
122 serial_initfunc(bfin_jtag_initialize);
123 serial_initfunc(mpc512x_serial_initialize);
124 serial_initfunc(uartlite_serial_initialize);
125 serial_initfunc(au1x00_serial_initialize);
126 serial_initfunc(asc_serial_initialize);
127 serial_initfunc(jz_serial_initialize);
128 serial_initfunc(mpc5xx_serial_initialize);
129 serial_initfunc(mpc8260_scc_serial_initialize);
130 serial_initfunc(mpc8260_smc_serial_initialize);
131 serial_initfunc(mpc85xx_serial_initialize);
132 serial_initfunc(iop480_serial_initialize);
133 serial_initfunc(leon2_serial_initialize);
134 serial_initfunc(leon3_serial_initialize);
135 serial_initfunc(marvell_serial_initialize);
136 serial_initfunc(amirix_serial_initialize);
137 serial_initfunc(bmw_serial_initialize);
138 serial_initfunc(cogent_serial_initialize);
139 serial_initfunc(cpci750_serial_initialize);
140 serial_initfunc(evb64260_serial_initialize);
141 serial_initfunc(ml2_serial_initialize);
142 serial_initfunc(sconsole_serial_initialize);
143 serial_initfunc(p3mx_serial_initialize);
144 serial_initfunc(altera_jtag_serial_initialize);
145 serial_initfunc(altera_serial_initialize);
146 serial_initfunc(atmel_serial_initialize);
147 serial_initfunc(lpc32xx_serial_initialize);
148 serial_initfunc(mcf_serial_initialize);
149 serial_initfunc(oc_serial_initialize);
150 serial_initfunc(sandbox_serial_initialize);
151 serial_initfunc(clps7111_serial_initialize);
152 serial_initfunc(imx_serial_initialize);
153 serial_initfunc(ixp_serial_initialize);
154 serial_initfunc(ks8695_serial_initialize);
155 serial_initfunc(lh7a40x_serial_initialize);
156 serial_initfunc(max3100_serial_initialize);
157 serial_initfunc(mxc_serial_initialize);
158 serial_initfunc(pl01x_serial_initialize);
159 serial_initfunc(s3c44b0_serial_initialize);
160 serial_initfunc(sa1100_serial_initialize);
161 serial_initfunc(sh_serial_initialize);
162 serial_initfunc(arm_dcc_initialize);
163
164 /**
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  */
174 void serial_register(struct serial_device *dev)
175 {
176 #ifdef CONFIG_NEEDS_MANUAL_RELOC
177         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;
191 #endif
192
193         dev->next = serial_devices;
194         serial_devices = dev;
195 }
196
197 /**
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  */
206 void serial_initialize(void)
207 {
208         mpc8xx_serial_initialize();
209         ns16550_serial_initialize();
210         pxa_serial_initialize();
211         s3c24xx_serial_initialize();
212         s5p_serial_initialize();
213         mpc512x_serial_initialize();
214         bfin_serial_initialize();
215         bfin_jtag_initialize();
216         uartlite_serial_initialize();
217         zynq_serial_initalize();
218         au1x00_serial_initialize();
219         asc_serial_initialize();
220         jz_serial_initialize();
221         mpc5xx_serial_initialize();
222         mpc8260_scc_serial_initialize();
223         mpc8260_smc_serial_initialize();
224         mpc85xx_serial_initialize();
225         iop480_serial_initialize();
226         leon2_serial_initialize();
227         leon3_serial_initialize();
228         marvell_serial_initialize();
229         amirix_serial_initialize();
230         bmw_serial_initialize();
231         cogent_serial_initialize();
232         cpci750_serial_initialize();
233         evb64260_serial_initialize();
234         ml2_serial_initialize();
235         sconsole_serial_initialize();
236         p3mx_serial_initialize();
237         altera_jtag_serial_initialize();
238         altera_serial_initialize();
239         atmel_serial_initialize();
240         lpc32xx_serial_initialize();
241         mcf_serial_initialize();
242         oc_serial_initialize();
243         sandbox_serial_initialize();
244         clps7111_serial_initialize();
245         imx_serial_initialize();
246         ixp_serial_initialize();
247         ks8695_serial_initialize();
248         lh7a40x_serial_initialize();
249         max3100_serial_initialize();
250         mxc_serial_initialize();
251         pl01x_serial_initialize();
252         s3c44b0_serial_initialize();
253         sa1100_serial_initialize();
254         sh_serial_initialize();
255         arm_dcc_initialize();
256
257         serial_assign(default_serial_console()->name);
258 }
259
260 /**
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  */
267 void serial_stdio_init(void)
268 {
269         struct stdio_dev dev;
270         struct serial_device *s = serial_devices;
271
272         while (s) {
273                 memset(&dev, 0, sizeof(dev));
274
275                 strcpy(dev.name, s->name);
276                 dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT;
277
278                 dev.start = s->start;
279                 dev.stop = s->stop;
280                 dev.putc = s->putc;
281                 dev.puts = s->puts;
282                 dev.getc = s->getc;
283                 dev.tstc = s->tstc;
284
285                 stdio_register(&dev);
286
287                 s = s->next;
288         }
289 }
290
291 /**
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  */
303 int serial_assign(const char *name)
304 {
305         struct serial_device *s;
306
307         for (s = serial_devices; s; s = s->next) {
308                 if (strcmp(s->name, name))
309                         continue;
310                 serial_current = s;
311                 return 0;
312         }
313
314         return -EINVAL;
315 }
316
317 /**
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  */
323 void serial_reinit_all(void)
324 {
325         struct serial_device *s;
326
327         for (s = serial_devices; s; s = s->next)
328                 s->start();
329 }
330
331 /**
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  */
346 static struct serial_device *get_current(void)
347 {
348         struct serial_device *dev;
349
350         if (!(gd->flags & GD_FLG_RELOC))
351                 dev = default_serial_console();
352         else if (!serial_current)
353                 dev = default_serial_console();
354         else
355                 dev = serial_current;
356
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
367         return dev;
368 }
369
370 /**
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  */
380 int serial_init(void)
381 {
382         return get_current()->start();
383 }
384
385 /**
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  */
395 void serial_setbrg(void)
396 {
397         get_current()->setbrg();
398 }
399
400 /**
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  */
411 int serial_getc(void)
412 {
413         return get_current()->getc();
414 }
415
416 /**
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  */
426 int serial_tstc(void)
427 {
428         return get_current()->tstc();
429 }
430
431 /**
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  */
442 void serial_putc(const char c)
443 {
444         get_current()->putc(c);
445 }
446
447 /**
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  */
460 void serial_puts(const char *s)
461 {
462         get_current()->puts(s);
463 }
464
465 /**
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  */
477 void default_serial_puts(const char *s)
478 {
479         struct serial_device *dev = get_current();
480         while (*s)
481                 dev->putc(*s++);
482 }
483
484 #if CONFIG_POST & CONFIG_SYS_POST_UART
485 static const int bauds[] = CONFIG_SYS_BAUDRATE_TABLE;
486
487 /**
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  */
498 /* Mark weak until post/cpu/.../uart.c migrate over */
499 __weak
500 int 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
567                 /* XXX: There is no serial_stop() !? */
568                 if (s->stop)
569                         s->stop();
570         }
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