- TTY: serial, cleanup include file (bnc#881571).
[opensuse:kernel.git] / drivers / tty / serial / apbuart.c
1 /*
2  *  Driver for GRLIB serial ports (APBUART)
3  *
4  *  Based on linux/drivers/serial/amba.c
5  *
6  *  Copyright (C) 2000 Deep Blue Solutions Ltd.
7  *  Copyright (C) 2003 Konrad Eisele <eiselekd@web.de>
8  *  Copyright (C) 2006 Daniel Hellstrom <daniel@gaisler.com>, Aeroflex Gaisler AB
9  *  Copyright (C) 2008 Gilead Kutnick <kutnickg@zin-tech.com>
10  *  Copyright (C) 2009 Kristoffer Glembo <kristoffer@gaisler.com>, Aeroflex Gaisler AB
11  */
12
13 #if defined(CONFIG_SERIAL_GRLIB_GAISLER_APBUART_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
14 #define SUPPORT_SYSRQ
15 #endif
16
17 #include <linux/module.h>
18 #include <linux/tty.h>
19 #include <linux/tty_flip.h>
20 #include <linux/ioport.h>
21 #include <linux/init.h>
22 #include <linux/serial.h>
23 #include <linux/console.h>
24 #include <linux/sysrq.h>
25 #include <linux/kthread.h>
26 #include <linux/device.h>
27 #include <linux/of.h>
28 #include <linux/of_device.h>
29 #include <linux/of_platform.h>
30 #include <linux/of_irq.h>
31 #include <linux/platform_device.h>
32 #include <linux/io.h>
33 #include <linux/serial_core.h>
34 #include <asm/irq.h>
35
36 #include "apbuart.h"
37
38 #define SERIAL_APBUART_MAJOR    TTY_MAJOR
39 #define SERIAL_APBUART_MINOR    64
40 #define UART_DUMMY_RSR_RX       0x8000  /* for ignore all read */
41
42 static void apbuart_tx_chars(struct uart_port *port);
43
44 static void apbuart_stop_tx(struct uart_port *port)
45 {
46         unsigned int cr;
47
48         cr = UART_GET_CTRL(port);
49         cr &= ~UART_CTRL_TI;
50         UART_PUT_CTRL(port, cr);
51 }
52
53 static void apbuart_start_tx(struct uart_port *port)
54 {
55         unsigned int cr;
56
57         cr = UART_GET_CTRL(port);
58         cr |= UART_CTRL_TI;
59         UART_PUT_CTRL(port, cr);
60
61         if (UART_GET_STATUS(port) & UART_STATUS_THE)
62                 apbuart_tx_chars(port);
63 }
64
65 static void apbuart_stop_rx(struct uart_port *port)
66 {
67         unsigned int cr;
68
69         cr = UART_GET_CTRL(port);
70         cr &= ~(UART_CTRL_RI);
71         UART_PUT_CTRL(port, cr);
72 }
73
74 static void apbuart_enable_ms(struct uart_port *port)
75 {
76         /* No modem status change interrupts for APBUART */
77 }
78
79 static void apbuart_rx_chars(struct uart_port *port)
80 {
81         struct tty_struct *tty = port->state->port.tty;
82         unsigned int status, ch, rsr, flag;
83         unsigned int max_chars = port->fifosize;
84
85         status = UART_GET_STATUS(port);
86
87         while (UART_RX_DATA(status) && (max_chars--)) {
88
89                 ch = UART_GET_CHAR(port);
90                 flag = TTY_NORMAL;
91
92                 port->icount.rx++;
93
94                 rsr = UART_GET_STATUS(port) | UART_DUMMY_RSR_RX;
95                 UART_PUT_STATUS(port, 0);
96                 if (rsr & UART_STATUS_ERR) {
97
98                         if (rsr & UART_STATUS_BR) {
99                                 rsr &= ~(UART_STATUS_FE | UART_STATUS_PE);
100                                 port->icount.brk++;
101                                 if (uart_handle_break(port))
102                                         goto ignore_char;
103                         } else if (rsr & UART_STATUS_PE) {
104                                 port->icount.parity++;
105                         } else if (rsr & UART_STATUS_FE) {
106                                 port->icount.frame++;
107                         }
108                         if (rsr & UART_STATUS_OE)
109                                 port->icount.overrun++;
110
111                         rsr &= port->read_status_mask;
112
113                         if (rsr & UART_STATUS_PE)
114                                 flag = TTY_PARITY;
115                         else if (rsr & UART_STATUS_FE)
116                                 flag = TTY_FRAME;
117                 }
118
119                 if (uart_handle_sysrq_char(port, ch))
120                         goto ignore_char;
121
122                 uart_insert_char(port, rsr, UART_STATUS_OE, ch, flag);
123
124
125               ignore_char:
126                 status = UART_GET_STATUS(port);
127         }
128
129         tty_flip_buffer_push(tty);
130 }
131
132 static void apbuart_tx_chars(struct uart_port *port)
133 {
134         struct circ_buf *xmit = &port->state->xmit;
135         int count;
136
137         if (port->x_char) {
138                 UART_PUT_CHAR(port, port->x_char);
139                 port->icount.tx++;
140                 port->x_char = 0;
141                 return;
142         }
143
144         if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
145                 apbuart_stop_tx(port);
146                 return;
147         }
148
149         /* amba: fill FIFO */
150         count = port->fifosize >> 1;
151         do {
152                 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
153                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
154                 port->icount.tx++;
155                 if (uart_circ_empty(xmit))
156                         break;
157         } while (--count > 0);
158
159         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
160                 uart_write_wakeup(port);
161
162         if (uart_circ_empty(xmit))
163                 apbuart_stop_tx(port);
164 }
165
166 static irqreturn_t apbuart_int(int irq, void *dev_id)
167 {
168         struct uart_port *port = dev_id;
169         unsigned int status;
170
171         spin_lock(&port->lock);
172
173         status = UART_GET_STATUS(port);
174         if (status & UART_STATUS_DR)
175                 apbuart_rx_chars(port);
176         if (status & UART_STATUS_THE)
177                 apbuart_tx_chars(port);
178
179         spin_unlock(&port->lock);
180
181         return IRQ_HANDLED;
182 }
183
184 static unsigned int apbuart_tx_empty(struct uart_port *port)
185 {
186         unsigned int status = UART_GET_STATUS(port);
187         return status & UART_STATUS_THE ? TIOCSER_TEMT : 0;
188 }
189
190 static unsigned int apbuart_get_mctrl(struct uart_port *port)
191 {
192         /* The GRLIB APBUART handles flow control in hardware */
193         return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
194 }
195
196 static void apbuart_set_mctrl(struct uart_port *port, unsigned int mctrl)
197 {
198         /* The GRLIB APBUART handles flow control in hardware */
199 }
200
201 static void apbuart_break_ctl(struct uart_port *port, int break_state)
202 {
203         /* We don't support sending break */
204 }
205
206 static int apbuart_startup(struct uart_port *port)
207 {
208         int retval;
209         unsigned int cr;
210
211         /* Allocate the IRQ */
212         retval = request_irq(port->irq, apbuart_int, 0, "apbuart", port);
213         if (retval)
214                 return retval;
215
216         /* Finally, enable interrupts */
217         cr = UART_GET_CTRL(port);
218         UART_PUT_CTRL(port,
219                       cr | UART_CTRL_RE | UART_CTRL_TE |
220                       UART_CTRL_RI | UART_CTRL_TI);
221
222         return 0;
223 }
224
225 static void apbuart_shutdown(struct uart_port *port)
226 {
227         unsigned int cr;
228
229         /* disable all interrupts, disable the port */
230         cr = UART_GET_CTRL(port);
231         UART_PUT_CTRL(port,
232                       cr & ~(UART_CTRL_RE | UART_CTRL_TE |
233                              UART_CTRL_RI | UART_CTRL_TI));
234
235         /* Free the interrupt */
236         free_irq(port->irq, port);
237 }
238
239 static void apbuart_set_termios(struct uart_port *port,
240                                 struct ktermios *termios, struct ktermios *old)
241 {
242         unsigned int cr;
243         unsigned long flags;
244         unsigned int baud, quot;
245
246         /* Ask the core to calculate the divisor for us. */
247         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk / 16);
248         if (baud == 0)
249                 panic("invalid baudrate %i\n", port->uartclk / 16);
250
251         /* uart_get_divisor calc a *16 uart freq, apbuart is *8 */
252         quot = (uart_get_divisor(port, baud)) * 2;
253         cr = UART_GET_CTRL(port);
254         cr &= ~(UART_CTRL_PE | UART_CTRL_PS);
255
256         if (termios->c_cflag & PARENB) {
257                 cr |= UART_CTRL_PE;
258                 if ((termios->c_cflag & PARODD))
259                         cr |= UART_CTRL_PS;
260         }
261
262         /* Enable flow control. */
263         if (termios->c_cflag & CRTSCTS)
264                 cr |= UART_CTRL_FL;
265
266         spin_lock_irqsave(&port->lock, flags);
267
268         /* Update the per-port timeout. */
269         uart_update_timeout(port, termios->c_cflag, baud);
270
271         port->read_status_mask = UART_STATUS_OE;
272         if (termios->c_iflag & INPCK)
273                 port->read_status_mask |= UART_STATUS_FE | UART_STATUS_PE;
274
275         /* Characters to ignore */
276         port->ignore_status_mask = 0;
277         if (termios->c_iflag & IGNPAR)
278                 port->ignore_status_mask |= UART_STATUS_FE | UART_STATUS_PE;
279
280         /* Ignore all characters if CREAD is not set. */
281         if ((termios->c_cflag & CREAD) == 0)
282                 port->ignore_status_mask |= UART_DUMMY_RSR_RX;
283
284         /* Set baud rate */
285         quot -= 1;
286         UART_PUT_SCAL(port, quot);
287         UART_PUT_CTRL(port, cr);
288
289         spin_unlock_irqrestore(&port->lock, flags);
290 }
291
292 static const char *apbuart_type(struct uart_port *port)
293 {
294         return port->type == PORT_APBUART ? "GRLIB/APBUART" : NULL;
295 }
296
297 static void apbuart_release_port(struct uart_port *port)
298 {
299         release_mem_region(port->mapbase, 0x100);
300 }
301
302 static int apbuart_request_port(struct uart_port *port)
303 {
304         return request_mem_region(port->mapbase, 0x100, "grlib-apbuart")
305             != NULL ? 0 : -EBUSY;
306         return 0;
307 }
308
309 /* Configure/autoconfigure the port */
310 static void apbuart_config_port(struct uart_port *port, int flags)
311 {
312         if (flags & UART_CONFIG_TYPE) {
313                 port->type = PORT_APBUART;
314                 apbuart_request_port(port);
315         }
316 }
317
318 /* Verify the new serial_struct (for TIOCSSERIAL) */
319 static int apbuart_verify_port(struct uart_port *port,
320                                struct serial_struct *ser)
321 {
322         int ret = 0;
323         if (ser->type != PORT_UNKNOWN && ser->type != PORT_APBUART)
324                 ret = -EINVAL;
325         if (ser->irq < 0 || ser->irq >= NR_IRQS)
326                 ret = -EINVAL;
327         if (ser->baud_base < 9600)
328                 ret = -EINVAL;
329         return ret;
330 }
331
332 static struct uart_ops grlib_apbuart_ops = {
333         .tx_empty = apbuart_tx_empty,
334         .set_mctrl = apbuart_set_mctrl,
335         .get_mctrl = apbuart_get_mctrl,
336         .stop_tx = apbuart_stop_tx,
337         .start_tx = apbuart_start_tx,
338         .stop_rx = apbuart_stop_rx,
339         .enable_ms = apbuart_enable_ms,
340         .break_ctl = apbuart_break_ctl,
341         .startup = apbuart_startup,
342         .shutdown = apbuart_shutdown,
343         .set_termios = apbuart_set_termios,
344         .type = apbuart_type,
345         .release_port = apbuart_release_port,
346         .request_port = apbuart_request_port,
347         .config_port = apbuart_config_port,
348         .verify_port = apbuart_verify_port,
349 };
350
351 static struct uart_port grlib_apbuart_ports[UART_NR];
352 static struct device_node *grlib_apbuart_nodes[UART_NR];
353
354 static int apbuart_scan_fifo_size(struct uart_port *port, int portnumber)
355 {
356         int ctrl, loop = 0;
357         int status;
358         int fifosize;
359         unsigned long flags;
360
361         ctrl = UART_GET_CTRL(port);
362
363         /*
364          * Enable the transceiver and wait for it to be ready to send data.
365          * Clear interrupts so that this process will not be externally
366          * interrupted in the middle (which can cause the transceiver to
367          * drain prematurely).
368          */
369
370         local_irq_save(flags);
371
372         UART_PUT_CTRL(port, ctrl | UART_CTRL_TE);
373
374         while (!UART_TX_READY(UART_GET_STATUS(port)))
375                 loop++;
376
377         /*
378          * Disable the transceiver so data isn't actually sent during the
379          * actual test.
380          */
381
382         UART_PUT_CTRL(port, ctrl & ~(UART_CTRL_TE));
383
384         fifosize = 1;
385         UART_PUT_CHAR(port, 0);
386
387         /*
388          * So long as transmitting a character increments the tranceivier FIFO
389          * length the FIFO must be at least that big. These bytes will
390          * automatically drain off of the FIFO.
391          */
392
393         status = UART_GET_STATUS(port);
394         while (((status >> 20) & 0x3F) == fifosize) {
395                 fifosize++;
396                 UART_PUT_CHAR(port, 0);
397                 status = UART_GET_STATUS(port);
398         }
399
400         fifosize--;
401
402         UART_PUT_CTRL(port, ctrl);
403         local_irq_restore(flags);
404
405         if (fifosize == 0)
406                 fifosize = 1;
407
408         return fifosize;
409 }
410
411 static void apbuart_flush_fifo(struct uart_port *port)
412 {
413         int i;
414
415         for (i = 0; i < port->fifosize; i++)
416                 UART_GET_CHAR(port);
417 }
418
419
420 /* ======================================================================== */
421 /* Console driver, if enabled                                               */
422 /* ======================================================================== */
423
424 #ifdef CONFIG_SERIAL_GRLIB_GAISLER_APBUART_CONSOLE
425
426 static void apbuart_console_putchar(struct uart_port *port, int ch)
427 {
428         unsigned int status;
429         do {
430                 status = UART_GET_STATUS(port);
431         } while (!UART_TX_READY(status));
432         UART_PUT_CHAR(port, ch);
433 }
434
435 static void
436 apbuart_console_write(struct console *co, const char *s, unsigned int count)
437 {
438         struct uart_port *port = &grlib_apbuart_ports[co->index];
439         unsigned int status, old_cr, new_cr;
440
441         /* First save the CR then disable the interrupts */
442         old_cr = UART_GET_CTRL(port);
443         new_cr = old_cr & ~(UART_CTRL_RI | UART_CTRL_TI);
444         UART_PUT_CTRL(port, new_cr);
445
446         uart_console_write(port, s, count, apbuart_console_putchar);
447
448         /*
449          *      Finally, wait for transmitter to become empty
450          *      and restore the TCR
451          */
452         do {
453                 status = UART_GET_STATUS(port);
454         } while (!UART_TX_READY(status));
455         UART_PUT_CTRL(port, old_cr);
456 }
457
458 static void __init
459 apbuart_console_get_options(struct uart_port *port, int *baud,
460                             int *parity, int *bits)
461 {
462         if (UART_GET_CTRL(port) & (UART_CTRL_RE | UART_CTRL_TE)) {
463
464                 unsigned int quot, status;
465                 status = UART_GET_STATUS(port);
466
467                 *parity = 'n';
468                 if (status & UART_CTRL_PE) {
469                         if ((status & UART_CTRL_PS) == 0)
470                                 *parity = 'e';
471                         else
472                                 *parity = 'o';
473                 }
474
475                 *bits = 8;
476                 quot = UART_GET_SCAL(port) / 8;
477                 *baud = port->uartclk / (16 * (quot + 1));
478         }
479 }
480
481 static int __init apbuart_console_setup(struct console *co, char *options)
482 {
483         struct uart_port *port;
484         int baud = 38400;
485         int bits = 8;
486         int parity = 'n';
487         int flow = 'n';
488
489         pr_debug("apbuart_console_setup co=%p, co->index=%i, options=%s\n",
490                  co, co->index, options);
491
492         /*
493          * Check whether an invalid uart number has been specified, and
494          * if so, search for the first available port that does have
495          * console support.
496          */
497         if (co->index >= grlib_apbuart_port_nr)
498                 co->index = 0;
499
500         port = &grlib_apbuart_ports[co->index];
501
502         spin_lock_init(&port->lock);
503
504         if (options)
505                 uart_parse_options(options, &baud, &parity, &bits, &flow);
506         else
507                 apbuart_console_get_options(port, &baud, &parity, &bits);
508
509         return uart_set_options(port, co, baud, parity, bits, flow);
510 }
511
512 static struct uart_driver grlib_apbuart_driver;
513
514 static struct console grlib_apbuart_console = {
515         .name = "ttyS",
516         .write = apbuart_console_write,
517         .device = uart_console_device,
518         .setup = apbuart_console_setup,
519         .flags = CON_PRINTBUFFER,
520         .index = -1,
521         .data = &grlib_apbuart_driver,
522 };
523
524
525 static int grlib_apbuart_configure(void);
526
527 static int __init apbuart_console_init(void)
528 {
529         if (grlib_apbuart_configure())
530                 return -ENODEV;
531         register_console(&grlib_apbuart_console);
532         return 0;
533 }
534
535 console_initcall(apbuart_console_init);
536
537 #define APBUART_CONSOLE (&grlib_apbuart_console)
538 #else
539 #define APBUART_CONSOLE NULL
540 #endif
541
542 static struct uart_driver grlib_apbuart_driver = {
543         .owner = THIS_MODULE,
544         .driver_name = "serial",
545         .dev_name = "ttyS",
546         .major = SERIAL_APBUART_MAJOR,
547         .minor = SERIAL_APBUART_MINOR,
548         .nr = UART_NR,
549         .cons = APBUART_CONSOLE,
550 };
551
552
553 /* ======================================================================== */
554 /* OF Platform Driver                                                       */
555 /* ======================================================================== */
556
557 static int __devinit apbuart_probe(struct platform_device *op)
558 {
559         int i;
560         struct uart_port *port = NULL;
561
562         for (i = 0; i < grlib_apbuart_port_nr; i++) {
563                 if (op->dev.of_node == grlib_apbuart_nodes[i])
564                         break;
565         }
566
567         port = &grlib_apbuart_ports[i];
568         port->dev = &op->dev;
569         port->irq = op->archdata.irqs[0];
570
571         uart_add_one_port(&grlib_apbuart_driver, (struct uart_port *) port);
572
573         apbuart_flush_fifo((struct uart_port *) port);
574
575         printk(KERN_INFO "grlib-apbuart at 0x%llx, irq %d\n",
576                (unsigned long long) port->mapbase, port->irq);
577         return 0;
578 }
579
580 static struct of_device_id __initdata apbuart_match[] = {
581         {
582          .name = "GAISLER_APBUART",
583          },
584         {
585          .name = "01_00c",
586          },
587         {},
588 };
589
590 static struct platform_driver grlib_apbuart_of_driver = {
591         .probe = apbuart_probe,
592         .driver = {
593                 .owner = THIS_MODULE,
594                 .name = "grlib-apbuart",
595                 .of_match_table = apbuart_match,
596         },
597 };
598
599
600 static int grlib_apbuart_configure(void)
601 {
602         struct device_node *np;
603         int line = 0;
604
605         for_each_matching_node(np, apbuart_match) {
606                 const int *ampopts;
607                 const u32 *freq_hz;
608                 const struct amba_prom_registers *regs;
609                 struct uart_port *port;
610                 unsigned long addr;
611
612                 ampopts = of_get_property(np, "ampopts", NULL);
613                 if (ampopts && (*ampopts == 0))
614                         continue; /* Ignore if used by another OS instance */
615                 regs = of_get_property(np, "reg", NULL);
616                 /* Frequency of APB Bus is frequency of UART */
617                 freq_hz = of_get_property(np, "freq", NULL);
618
619                 if (!regs || !freq_hz || (*freq_hz == 0))
620                         continue;
621
622                 grlib_apbuart_nodes[line] = np;
623
624                 addr = regs->phys_addr;
625
626                 port = &grlib_apbuart_ports[line];
627
628                 port->mapbase = addr;
629                 port->membase = ioremap(addr, sizeof(struct grlib_apbuart_regs_map));
630                 port->irq = 0;
631                 port->iotype = UPIO_MEM;
632                 port->ops = &grlib_apbuart_ops;
633                 port->flags = UPF_BOOT_AUTOCONF;
634                 port->line = line;
635                 port->uartclk = *freq_hz;
636                 port->fifosize = apbuart_scan_fifo_size((struct uart_port *) port, line);
637                 line++;
638
639                 /* We support maximum UART_NR uarts ... */
640                 if (line == UART_NR)
641                         break;
642         }
643
644         grlib_apbuart_driver.nr = grlib_apbuart_port_nr = line;
645         return line ? 0 : -ENODEV;
646 }
647
648 static int __init grlib_apbuart_init(void)
649 {
650         int ret;
651
652         /* Find all APBUARTS in device the tree and initialize their ports */
653         ret = grlib_apbuart_configure();
654         if (ret)
655                 return ret;
656
657         printk(KERN_INFO "Serial: GRLIB APBUART driver\n");
658
659         ret = uart_register_driver(&grlib_apbuart_driver);
660
661         if (ret) {
662                 printk(KERN_ERR "%s: uart_register_driver failed (%i)\n",
663                        __FILE__, ret);
664                 return ret;
665         }
666
667         ret = platform_driver_register(&grlib_apbuart_of_driver);
668         if (ret) {
669                 printk(KERN_ERR
670                        "%s: platform_driver_register failed (%i)\n",
671                        __FILE__, ret);
672                 uart_unregister_driver(&grlib_apbuart_driver);
673                 return ret;
674         }
675
676         return ret;
677 }
678
679 static void __exit grlib_apbuart_exit(void)
680 {
681         int i;
682
683         for (i = 0; i < grlib_apbuart_port_nr; i++)
684                 uart_remove_one_port(&grlib_apbuart_driver,
685                                      &grlib_apbuart_ports[i]);
686
687         uart_unregister_driver(&grlib_apbuart_driver);
688         platform_driver_unregister(&grlib_apbuart_of_driver);
689 }
690
691 module_init(grlib_apbuart_init);
692 module_exit(grlib_apbuart_exit);
693
694 MODULE_AUTHOR("Aeroflex Gaisler AB");
695 MODULE_DESCRIPTION("GRLIB APBUART serial driver");
696 MODULE_VERSION("2.1");
697 MODULE_LICENSE("GPL");