1f8955a0fdb586c9cae12783d3e440641a8e8266
[platform/kernel/u-boot.git] / drivers / serial / serial.c
1 /*
2  * (C) Copyright 2004
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * See file CREDITS for list of people who contributed to this
6  * project.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of
11  * the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21  * MA 02111-1307 USA
22  */
23
24 #include <common.h>
25 #include <environment.h>
26 #include <serial.h>
27 #include <stdio_dev.h>
28 #include <post.h>
29 #include <linux/compiler.h>
30 #include <errno.h>
31
32 DECLARE_GLOBAL_DATA_PTR;
33
34 static struct serial_device *serial_devices;
35 static struct serial_device *serial_current;
36 /*
37  * Table with supported baudrates (defined in config_xyz.h)
38  */
39 static const unsigned long baudrate_table[] = CONFIG_SYS_BAUDRATE_TABLE;
40 #define N_BAUDRATES (sizeof(baudrate_table) / sizeof(baudrate_table[0]))
41
42 /**
43  * serial_null() - Void registration routine of a serial driver
44  *
45  * This routine implements a void registration routine of a serial
46  * driver. The registration routine of a particular driver is aliased
47  * to this empty function in case the driver is not compiled into
48  * U-Boot.
49  */
50 static void serial_null(void)
51 {
52 }
53
54 /**
55  * on_baudrate() - Update the actual baudrate when the env var changes
56  *
57  * This will check for a valid baudrate and only apply it if valid.
58  */
59 static int on_baudrate(const char *name, const char *value, enum env_op op,
60         int flags)
61 {
62         int i;
63         int baudrate;
64
65         switch (op) {
66         case env_op_create:
67         case env_op_overwrite:
68                 /*
69                  * Switch to new baudrate if new baudrate is supported
70                  */
71                 baudrate = simple_strtoul(value, NULL, 10);
72
73                 /* Not actually changing */
74                 if (gd->baudrate == baudrate)
75                         return 0;
76
77                 for (i = 0; i < N_BAUDRATES; ++i) {
78                         if (baudrate == baudrate_table[i])
79                                 break;
80                 }
81                 if (i == N_BAUDRATES) {
82                         if ((flags & H_FORCE) == 0)
83                                 printf("## Baudrate %d bps not supported\n",
84                                         baudrate);
85                         return 1;
86                 }
87                 if ((flags & H_INTERACTIVE) != 0) {
88                         printf("## Switch baudrate to %d"
89                                 " bps and press ENTER ...\n", baudrate);
90                         udelay(50000);
91                 }
92
93                 gd->baudrate = baudrate;
94 #if defined(CONFIG_PPC) || defined(CONFIG_MCF52x2)
95                 gd->bd->bi_baudrate = baudrate;
96 #endif
97
98                 serial_setbrg();
99
100                 udelay(50000);
101
102                 if ((flags & H_INTERACTIVE) != 0)
103                         while (1) {
104                                 if (getc() == '\r')
105                                         break;
106                         }
107
108                 return 0;
109         case env_op_delete:
110                 printf("## Baudrate may not be deleted\n");
111                 return 1;
112         default:
113                 return 0;
114         }
115 }
116 U_BOOT_ENV_CALLBACK(baudrate, on_baudrate);
117
118 /**
119  * serial_initfunc() - Forward declare of driver registration routine
120  * @name:       Name of the real driver registration routine.
121  *
122  * This macro expands onto forward declaration of a driver registration
123  * routine, which is then used below in serial_initialize() function.
124  * The declaration is made weak and aliases to serial_null() so in case
125  * the driver is not compiled in, the function is still declared and can
126  * be used, but aliases to serial_null() and thus is optimized away.
127  */
128 #define serial_initfunc(name)                                   \
129         void name(void)                                         \
130                 __attribute__((weak, alias("serial_null")));
131
132 serial_initfunc(mpc8xx_serial_initialize);
133 serial_initfunc(ns16550_serial_initialize);
134 serial_initfunc(pxa_serial_initialize);
135 serial_initfunc(s3c24xx_serial_initialize);
136 serial_initfunc(s5p_serial_initialize);
137 serial_initfunc(zynq_serial_initalize);
138 serial_initfunc(bfin_serial_initialize);
139 serial_initfunc(bfin_jtag_initialize);
140 serial_initfunc(mpc512x_serial_initialize);
141 serial_initfunc(uartlite_serial_initialize);
142 serial_initfunc(au1x00_serial_initialize);
143 serial_initfunc(asc_serial_initialize);
144 serial_initfunc(jz_serial_initialize);
145 serial_initfunc(mpc5xx_serial_initialize);
146 serial_initfunc(mpc8220_serial_initialize);
147 serial_initfunc(mpc8260_scc_serial_initialize);
148 serial_initfunc(mpc8260_smc_serial_initialize);
149 serial_initfunc(mpc85xx_serial_initialize);
150 serial_initfunc(iop480_serial_initialize);
151 serial_initfunc(leon2_serial_initialize);
152 serial_initfunc(leon3_serial_initialize);
153 serial_initfunc(marvell_serial_initialize);
154 serial_initfunc(amirix_serial_initialize);
155 serial_initfunc(bmw_serial_initialize);
156 serial_initfunc(cogent_serial_initialize);
157 serial_initfunc(cpci750_serial_initialize);
158 serial_initfunc(evb64260_serial_initialize);
159 serial_initfunc(ml2_serial_initialize);
160 serial_initfunc(sconsole_serial_initialize);
161 serial_initfunc(p3mx_serial_initialize);
162 serial_initfunc(altera_jtag_serial_initialize);
163 serial_initfunc(altera_serial_initialize);
164 serial_initfunc(atmel_serial_initialize);
165 serial_initfunc(lpc32xx_serial_initialize);
166 serial_initfunc(mcf_serial_initialize);
167 serial_initfunc(ns9750_serial_initialize);
168 serial_initfunc(oc_serial_initialize);
169 serial_initfunc(s3c64xx_serial_initialize);
170 serial_initfunc(sandbox_serial_initialize);
171 serial_initfunc(clps7111_serial_initialize);
172 serial_initfunc(imx_serial_initialize);
173 serial_initfunc(ixp_serial_initialize);
174 serial_initfunc(ks8695_serial_initialize);
175 serial_initfunc(lh7a40x_serial_initialize);
176 serial_initfunc(max3100_serial_initialize);
177 serial_initfunc(mxc_serial_initialize);
178 serial_initfunc(pl01x_serial_initialize);
179 serial_initfunc(s3c44b0_serial_initialize);
180 serial_initfunc(sa1100_serial_initialize);
181 serial_initfunc(sh_serial_initialize);
182
183 /**
184  * serial_register() - Register serial driver with serial driver core
185  * @dev:        Pointer to the serial driver structure
186  *
187  * This function registers the serial driver supplied via @dev with
188  * serial driver core, thus making U-Boot aware of it and making it
189  * available for U-Boot to use. On platforms that still require manual
190  * relocation of constant variables, relocation of the supplied structure
191  * is performed.
192  */
193 void serial_register(struct serial_device *dev)
194 {
195 #ifdef CONFIG_NEEDS_MANUAL_RELOC
196         if (dev->start)
197                 dev->start += gd->reloc_off;
198         if (dev->stop)
199                 dev->stop += gd->reloc_off;
200         if (dev->setbrg)
201                 dev->setbrg += gd->reloc_off;
202         if (dev->getc)
203                 dev->getc += gd->reloc_off;
204         if (dev->tstc)
205                 dev->tstc += gd->reloc_off;
206         if (dev->putc)
207                 dev->putc += gd->reloc_off;
208         if (dev->puts)
209                 dev->puts += gd->reloc_off;
210 #endif
211
212         dev->next = serial_devices;
213         serial_devices = dev;
214 }
215
216 /**
217  * serial_initialize() - Register all compiled-in serial port drivers
218  *
219  * This function registers all serial port drivers that are compiled
220  * into the U-Boot binary with the serial core, thus making them
221  * available to U-Boot to use. Lastly, this function assigns a default
222  * serial port to the serial core. That serial port is then used as a
223  * default output.
224  */
225 void serial_initialize(void)
226 {
227         mpc8xx_serial_initialize();
228         ns16550_serial_initialize();
229         pxa_serial_initialize();
230         s3c24xx_serial_initialize();
231         s5p_serial_initialize();
232         mpc512x_serial_initialize();
233         bfin_serial_initialize();
234         bfin_jtag_initialize();
235         uartlite_serial_initialize();
236         zynq_serial_initalize();
237         au1x00_serial_initialize();
238         asc_serial_initialize();
239         jz_serial_initialize();
240         mpc5xx_serial_initialize();
241         mpc8220_serial_initialize();
242         mpc8260_scc_serial_initialize();
243         mpc8260_smc_serial_initialize();
244         mpc85xx_serial_initialize();
245         iop480_serial_initialize();
246         leon2_serial_initialize();
247         leon3_serial_initialize();
248         marvell_serial_initialize();
249         amirix_serial_initialize();
250         bmw_serial_initialize();
251         cogent_serial_initialize();
252         cpci750_serial_initialize();
253         evb64260_serial_initialize();
254         ml2_serial_initialize();
255         sconsole_serial_initialize();
256         p3mx_serial_initialize();
257         altera_jtag_serial_initialize();
258         altera_serial_initialize();
259         atmel_serial_initialize();
260         lpc32xx_serial_initialize();
261         mcf_serial_initialize();
262         ns9750_serial_initialize();
263         oc_serial_initialize();
264         s3c64xx_serial_initialize();
265         sandbox_serial_initialize();
266         clps7111_serial_initialize();
267         imx_serial_initialize();
268         ixp_serial_initialize();
269         ks8695_serial_initialize();
270         lh7a40x_serial_initialize();
271         max3100_serial_initialize();
272         mxc_serial_initialize();
273         pl01x_serial_initialize();
274         s3c44b0_serial_initialize();
275         sa1100_serial_initialize();
276         sh_serial_initialize();
277
278         serial_assign(default_serial_console()->name);
279 }
280
281 /**
282  * serial_stdio_init() - Register serial ports with STDIO core
283  *
284  * This function generates a proxy driver for each serial port driver.
285  * These proxy drivers then register with the STDIO core, making the
286  * serial drivers available as STDIO devices.
287  */
288 void serial_stdio_init(void)
289 {
290         struct stdio_dev dev;
291         struct serial_device *s = serial_devices;
292
293         while (s) {
294                 memset(&dev, 0, sizeof(dev));
295
296                 strcpy(dev.name, s->name);
297                 dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT;
298
299                 dev.start = s->start;
300                 dev.stop = s->stop;
301                 dev.putc = s->putc;
302                 dev.puts = s->puts;
303                 dev.getc = s->getc;
304                 dev.tstc = s->tstc;
305
306                 stdio_register(&dev);
307
308                 s = s->next;
309         }
310 }
311
312 /**
313  * serial_assign() - Select the serial output device by name
314  * @name:       Name of the serial driver to be used as default output
315  *
316  * This function configures the serial output multiplexing by
317  * selecting which serial device will be used as default. In case
318  * the STDIO "serial" device is selected as stdin/stdout/stderr,
319  * the serial device previously configured by this function will be
320  * used for the particular operation.
321  *
322  * Returns 0 on success, negative on error.
323  */
324 int serial_assign(const char *name)
325 {
326         struct serial_device *s;
327
328         for (s = serial_devices; s; s = s->next) {
329                 if (strcmp(s->name, name))
330                         continue;
331                 serial_current = s;
332                 return 0;
333         }
334
335         return -EINVAL;
336 }
337
338 /**
339  * serial_reinit_all() - Reinitialize all compiled-in serial ports
340  *
341  * This function reinitializes all serial ports that are compiled
342  * into U-Boot by calling their serial_start() functions.
343  */
344 void serial_reinit_all(void)
345 {
346         struct serial_device *s;
347
348         for (s = serial_devices; s; s = s->next)
349                 s->start();
350 }
351
352 /**
353  * get_current() - Return pointer to currently selected serial port
354  *
355  * This function returns a pointer to currently selected serial port.
356  * The currently selected serial port is altered by serial_assign()
357  * function.
358  *
359  * In case this function is called before relocation or before any serial
360  * port is configured, this function calls default_serial_console() to
361  * determine the serial port. Otherwise, the configured serial port is
362  * returned.
363  *
364  * Returns pointer to the currently selected serial port on success,
365  * NULL on error.
366  */
367 static struct serial_device *get_current(void)
368 {
369         struct serial_device *dev;
370
371         if (!(gd->flags & GD_FLG_RELOC))
372                 dev = default_serial_console();
373         else if (!serial_current)
374                 dev = default_serial_console();
375         else
376                 dev = serial_current;
377
378         /* We must have a console device */
379         if (!dev) {
380 #ifdef CONFIG_SPL_BUILD
381                 puts("Cannot find console\n");
382                 hang();
383 #else
384                 panic("Cannot find console\n");
385 #endif
386         }
387
388         return dev;
389 }
390
391 /**
392  * serial_init() - Initialize currently selected serial port
393  *
394  * This function initializes the currently selected serial port. This
395  * usually involves setting up the registers of that particular port,
396  * enabling clock and such. This function uses the get_current() call
397  * to determine which port is selected.
398  *
399  * Returns 0 on success, negative on error.
400  */
401 int serial_init(void)
402 {
403         return get_current()->start();
404 }
405
406 /**
407  * serial_setbrg() - Configure baud-rate of currently selected serial port
408  *
409  * This function configures the baud-rate of the currently selected
410  * serial port. The baud-rate is retrieved from global data within
411  * the serial port driver. This function uses the get_current() call
412  * to determine which port is selected.
413  *
414  * Returns 0 on success, negative on error.
415  */
416 void serial_setbrg(void)
417 {
418         get_current()->setbrg();
419 }
420
421 /**
422  * serial_getc() - Read character from currently selected serial port
423  *
424  * This function retrieves a character from currently selected serial
425  * port. In case there is no character waiting on the serial port,
426  * this function will block and wait for the character to appear. This
427  * function uses the get_current() call to determine which port is
428  * selected.
429  *
430  * Returns the character on success, negative on error.
431  */
432 int serial_getc(void)
433 {
434         return get_current()->getc();
435 }
436
437 /**
438  * serial_tstc() - Test if data is available on currently selected serial port
439  *
440  * This function tests if one or more characters are available on
441  * currently selected serial port. This function never blocks. This
442  * function uses the get_current() call to determine which port is
443  * selected.
444  *
445  * Returns positive if character is available, zero otherwise.
446  */
447 int serial_tstc(void)
448 {
449         return get_current()->tstc();
450 }
451
452 /**
453  * serial_putc() - Output character via currently selected serial port
454  * @c:  Single character to be output from the serial port.
455  *
456  * This function outputs a character via currently selected serial
457  * port. This character is passed to the serial port driver responsible
458  * for controlling the hardware. The hardware may still be in process
459  * of transmitting another character, therefore this function may block
460  * for a short amount of time. This function uses the get_current()
461  * call to determine which port is selected.
462  */
463 void serial_putc(const char c)
464 {
465         get_current()->putc(c);
466 }
467
468 /**
469  * serial_puts() - Output string via currently selected serial port
470  * @s:  Zero-terminated string to be output from the serial port.
471  *
472  * This function outputs a zero-terminated string via currently
473  * selected serial port. This function behaves as an accelerator
474  * in case the hardware can queue multiple characters for transfer.
475  * The whole string that is to be output is available to the function
476  * implementing the hardware manipulation. Transmitting the whole
477  * string may take some time, thus this function may block for some
478  * amount of time. This function uses the get_current() call to
479  * determine which port is selected.
480  */
481 void serial_puts(const char *s)
482 {
483         get_current()->puts(s);
484 }
485
486 /**
487  * default_serial_puts() - Output string by calling serial_putc() in loop
488  * @s:  Zero-terminated string to be output from the serial port.
489  *
490  * This function outputs a zero-terminated string by calling serial_putc()
491  * in a loop. Most drivers do not support queueing more than one byte for
492  * transfer, thus this function precisely implements their serial_puts().
493  *
494  * To optimize the number of get_current() calls, this function only
495  * calls get_current() once and then directly accesses the putc() call
496  * of the &struct serial_device .
497  */
498 void default_serial_puts(const char *s)
499 {
500         struct serial_device *dev = get_current();
501         while (*s)
502                 dev->putc(*s++);
503 }
504
505 #if CONFIG_POST & CONFIG_SYS_POST_UART
506 static const int bauds[] = CONFIG_SYS_BAUDRATE_TABLE;
507
508 /**
509  * uart_post_test() - Test the currently selected serial port using POST
510  * @flags:      POST framework flags
511  *
512  * Do a loopback test of the currently selected serial port. This
513  * function is only useful in the context of the POST testing framwork.
514  * The serial port is firstly configured into loopback mode and then
515  * characters are sent through it.
516  *
517  * Returns 0 on success, value otherwise.
518  */
519 /* Mark weak until post/cpu/.../uart.c migrate over */
520 __weak
521 int uart_post_test(int flags)
522 {
523         unsigned char c;
524         int ret, saved_baud, b;
525         struct serial_device *saved_dev, *s;
526         bd_t *bd = gd->bd;
527
528         /* Save current serial state */
529         ret = 0;
530         saved_dev = serial_current;
531         saved_baud = bd->bi_baudrate;
532
533         for (s = serial_devices; s; s = s->next) {
534                 /* If this driver doesn't support loop back, skip it */
535                 if (!s->loop)
536                         continue;
537
538                 /* Test the next device */
539                 serial_current = s;
540
541                 ret = serial_init();
542                 if (ret)
543                         goto done;
544
545                 /* Consume anything that happens to be queued */
546                 while (serial_tstc())
547                         serial_getc();
548
549                 /* Enable loop back */
550                 s->loop(1);
551
552                 /* Test every available baud rate */
553                 for (b = 0; b < ARRAY_SIZE(bauds); ++b) {
554                         bd->bi_baudrate = bauds[b];
555                         serial_setbrg();
556
557                         /*
558                          * Stick to printable chars to avoid issues:
559                          *  - terminal corruption
560                          *  - serial program reacting to sequences and sending
561                          *    back random extra data
562                          *  - most serial drivers add in extra chars (like \r\n)
563                          */
564                         for (c = 0x20; c < 0x7f; ++c) {
565                                 /* Send it out */
566                                 serial_putc(c);
567
568                                 /* Make sure it's the same one */
569                                 ret = (c != serial_getc());
570                                 if (ret) {
571                                         s->loop(0);
572                                         goto done;
573                                 }
574
575                                 /* Clean up the output in case it was sent */
576                                 serial_putc('\b');
577                                 ret = ('\b' != serial_getc());
578                                 if (ret) {
579                                         s->loop(0);
580                                         goto done;
581                                 }
582                         }
583                 }
584
585                 /* Disable loop back */
586                 s->loop(0);
587
588                 /* XXX: There is no serial_stop() !? */
589                 if (s->stop)
590                         s->stop();
591         }
592
593  done:
594         /* Restore previous serial state */
595         serial_current = saved_dev;
596         bd->bi_baudrate = saved_baud;
597         serial_reinit_all();
598         serial_setbrg();
599
600         return ret;
601 }
602 #endif