GNU Linux-libre 4.9.309-gnu1
[releases.git] / drivers / tty / serial / serial_ks8695.c
1 /*
2  *  Driver for KS8695 serial ports
3  *
4  *  Based on drivers/serial/serial_amba.c, by Kam Lee.
5  *
6  *  Copyright 2002-2005 Micrel Inc.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  */
14 #include <linux/module.h>
15 #include <linux/tty.h>
16 #include <linux/tty_flip.h>
17 #include <linux/ioport.h>
18 #include <linux/init.h>
19 #include <linux/serial.h>
20 #include <linux/console.h>
21 #include <linux/sysrq.h>
22 #include <linux/device.h>
23
24 #include <asm/io.h>
25 #include <asm/irq.h>
26 #include <asm/mach/irq.h>
27
28 #include <mach/regs-uart.h>
29 #include <mach/regs-irq.h>
30
31 #if defined(CONFIG_SERIAL_KS8695_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
32 #define SUPPORT_SYSRQ
33 #endif
34
35 #include <linux/serial_core.h>
36
37
38 #define SERIAL_KS8695_MAJOR     204
39 #define SERIAL_KS8695_MINOR     16
40 #define SERIAL_KS8695_DEVNAME   "ttyAM"
41
42 #define SERIAL_KS8695_NR        1
43
44 /*
45  * Access macros for the KS8695 UART
46  */
47 #define UART_GET_CHAR(p)        (__raw_readl((p)->membase + KS8695_URRB) & 0xFF)
48 #define UART_PUT_CHAR(p, c)     __raw_writel((c), (p)->membase + KS8695_URTH)
49 #define UART_GET_FCR(p)         __raw_readl((p)->membase + KS8695_URFC)
50 #define UART_PUT_FCR(p, c)      __raw_writel((c), (p)->membase + KS8695_URFC)
51 #define UART_GET_MSR(p)         __raw_readl((p)->membase + KS8695_URMS)
52 #define UART_GET_LSR(p)         __raw_readl((p)->membase + KS8695_URLS)
53 #define UART_GET_LCR(p)         __raw_readl((p)->membase + KS8695_URLC)
54 #define UART_PUT_LCR(p, c)      __raw_writel((c), (p)->membase + KS8695_URLC)
55 #define UART_GET_MCR(p)         __raw_readl((p)->membase + KS8695_URMC)
56 #define UART_PUT_MCR(p, c)      __raw_writel((c), (p)->membase + KS8695_URMC)
57 #define UART_GET_BRDR(p)        __raw_readl((p)->membase + KS8695_URBD)
58 #define UART_PUT_BRDR(p, c)     __raw_writel((c), (p)->membase + KS8695_URBD)
59
60 #define KS8695_CLR_TX_INT()     __raw_writel(1 << KS8695_IRQ_UART_TX, KS8695_IRQ_VA + KS8695_INTST)
61
62 #define UART_DUMMY_LSR_RX       0x100
63 #define UART_PORT_SIZE          (KS8695_USR - KS8695_URRB + 4)
64
65 static inline int tx_enabled(struct uart_port *port)
66 {
67         return port->unused[0] & 1;
68 }
69
70 static inline int rx_enabled(struct uart_port *port)
71 {
72         return port->unused[0] & 2;
73 }
74
75 static inline int ms_enabled(struct uart_port *port)
76 {
77         return port->unused[0] & 4;
78 }
79
80 static inline void ms_enable(struct uart_port *port, int enabled)
81 {
82         if(enabled)
83                 port->unused[0] |= 4;
84         else
85                 port->unused[0] &= ~4;
86 }
87
88 static inline void rx_enable(struct uart_port *port, int enabled)
89 {
90         if(enabled)
91                 port->unused[0] |= 2;
92         else
93                 port->unused[0] &= ~2;
94 }
95
96 static inline void tx_enable(struct uart_port *port, int enabled)
97 {
98         if(enabled)
99                 port->unused[0] |= 1;
100         else
101                 port->unused[0] &= ~1;
102 }
103
104
105 #ifdef SUPPORT_SYSRQ
106 static struct console ks8695_console;
107 #endif
108
109 static void ks8695uart_stop_tx(struct uart_port *port)
110 {
111         if (tx_enabled(port)) {
112                 /* use disable_irq_nosync() and not disable_irq() to avoid self
113                  * imposed deadlock by not waiting for irq handler to end,
114                  * since this ks8695uart_stop_tx() is called from interrupt context.
115                  */
116                 disable_irq_nosync(KS8695_IRQ_UART_TX);
117                 tx_enable(port, 0);
118         }
119 }
120
121 static void ks8695uart_start_tx(struct uart_port *port)
122 {
123         if (!tx_enabled(port)) {
124                 enable_irq(KS8695_IRQ_UART_TX);
125                 tx_enable(port, 1);
126         }
127 }
128
129 static void ks8695uart_stop_rx(struct uart_port *port)
130 {
131         if (rx_enabled(port)) {
132                 disable_irq(KS8695_IRQ_UART_RX);
133                 rx_enable(port, 0);
134         }
135 }
136
137 static void ks8695uart_enable_ms(struct uart_port *port)
138 {
139         if (!ms_enabled(port)) {
140                 enable_irq(KS8695_IRQ_UART_MODEM_STATUS);
141                 ms_enable(port,1);
142         }
143 }
144
145 static void ks8695uart_disable_ms(struct uart_port *port)
146 {
147         if (ms_enabled(port)) {
148                 disable_irq(KS8695_IRQ_UART_MODEM_STATUS);
149                 ms_enable(port,0);
150         }
151 }
152
153 static irqreturn_t ks8695uart_rx_chars(int irq, void *dev_id)
154 {
155         struct uart_port *port = dev_id;
156         unsigned int status, ch, lsr, flg, max_count = 256;
157
158         status = UART_GET_LSR(port);            /* clears pending LSR interrupts */
159         while ((status & URLS_URDR) && max_count--) {
160                 ch = UART_GET_CHAR(port);
161                 flg = TTY_NORMAL;
162
163                 port->icount.rx++;
164
165                 /*
166                  * Note that the error handling code is
167                  * out of the main execution path
168                  */
169                 lsr = UART_GET_LSR(port) | UART_DUMMY_LSR_RX;
170                 if (unlikely(lsr & (URLS_URBI | URLS_URPE | URLS_URFE | URLS_URROE))) {
171                         if (lsr & URLS_URBI) {
172                                 lsr &= ~(URLS_URFE | URLS_URPE);
173                                 port->icount.brk++;
174                                 if (uart_handle_break(port))
175                                         goto ignore_char;
176                         }
177                         if (lsr & URLS_URPE)
178                                 port->icount.parity++;
179                         if (lsr & URLS_URFE)
180                                 port->icount.frame++;
181                         if (lsr & URLS_URROE)
182                                 port->icount.overrun++;
183
184                         lsr &= port->read_status_mask;
185
186                         if (lsr & URLS_URBI)
187                                 flg = TTY_BREAK;
188                         else if (lsr & URLS_URPE)
189                                 flg = TTY_PARITY;
190                         else if (lsr & URLS_URFE)
191                                 flg = TTY_FRAME;
192                 }
193
194                 if (uart_handle_sysrq_char(port, ch))
195                         goto ignore_char;
196
197                 uart_insert_char(port, lsr, URLS_URROE, ch, flg);
198
199 ignore_char:
200                 status = UART_GET_LSR(port);
201         }
202         tty_flip_buffer_push(&port->state->port);
203
204         return IRQ_HANDLED;
205 }
206
207
208 static irqreturn_t ks8695uart_tx_chars(int irq, void *dev_id)
209 {
210         struct uart_port *port = dev_id;
211         struct circ_buf *xmit = &port->state->xmit;
212         unsigned int count;
213
214         if (port->x_char) {
215                 KS8695_CLR_TX_INT();
216                 UART_PUT_CHAR(port, port->x_char);
217                 port->icount.tx++;
218                 port->x_char = 0;
219                 return IRQ_HANDLED;
220         }
221
222         if (uart_tx_stopped(port) || uart_circ_empty(xmit)) {
223                 ks8695uart_stop_tx(port);
224                 return IRQ_HANDLED;
225         }
226
227         count = 16;     /* fifo size */
228         while (!uart_circ_empty(xmit) && (count-- > 0)) {
229                 KS8695_CLR_TX_INT();
230                 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
231
232                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
233                 port->icount.tx++;
234         }
235
236         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
237                 uart_write_wakeup(port);
238
239         if (uart_circ_empty(xmit))
240                 ks8695uart_stop_tx(port);
241
242         return IRQ_HANDLED;
243 }
244
245 static irqreturn_t ks8695uart_modem_status(int irq, void *dev_id)
246 {
247         struct uart_port *port = dev_id;
248         unsigned int status;
249
250         /*
251          * clear modem interrupt by reading MSR
252          */
253         status = UART_GET_MSR(port);
254
255         if (status & URMS_URDDCD)
256                 uart_handle_dcd_change(port, status & URMS_URDDCD);
257
258         if (status & URMS_URDDST)
259                 port->icount.dsr++;
260
261         if (status & URMS_URDCTS)
262                 uart_handle_cts_change(port, status & URMS_URDCTS);
263
264         if (status & URMS_URTERI)
265                 port->icount.rng++;
266
267         wake_up_interruptible(&port->state->port.delta_msr_wait);
268
269         return IRQ_HANDLED;
270 }
271
272 static unsigned int ks8695uart_tx_empty(struct uart_port *port)
273 {
274         return (UART_GET_LSR(port) & URLS_URTE) ? TIOCSER_TEMT : 0;
275 }
276
277 static unsigned int ks8695uart_get_mctrl(struct uart_port *port)
278 {
279         unsigned int result = 0;
280         unsigned int status;
281
282         status = UART_GET_MSR(port);
283         if (status & URMS_URDCD)
284                 result |= TIOCM_CAR;
285         if (status & URMS_URDSR)
286                 result |= TIOCM_DSR;
287         if (status & URMS_URCTS)
288                 result |= TIOCM_CTS;
289         if (status & URMS_URRI)
290                 result |= TIOCM_RI;
291
292         return result;
293 }
294
295 static void ks8695uart_set_mctrl(struct uart_port *port, u_int mctrl)
296 {
297         unsigned int mcr;
298
299         mcr = UART_GET_MCR(port);
300         if (mctrl & TIOCM_RTS)
301                 mcr |= URMC_URRTS;
302         else
303                 mcr &= ~URMC_URRTS;
304
305         if (mctrl & TIOCM_DTR)
306                 mcr |= URMC_URDTR;
307         else
308                 mcr &= ~URMC_URDTR;
309
310         UART_PUT_MCR(port, mcr);
311 }
312
313 static void ks8695uart_break_ctl(struct uart_port *port, int break_state)
314 {
315         unsigned int lcr;
316
317         lcr = UART_GET_LCR(port);
318
319         if (break_state == -1)
320                 lcr |= URLC_URSBC;
321         else
322                 lcr &= ~URLC_URSBC;
323
324         UART_PUT_LCR(port, lcr);
325 }
326
327 static int ks8695uart_startup(struct uart_port *port)
328 {
329         int retval;
330
331         irq_modify_status(KS8695_IRQ_UART_TX, IRQ_NOREQUEST, IRQ_NOAUTOEN);
332         tx_enable(port, 0);
333         rx_enable(port, 1);
334         ms_enable(port, 1);
335
336         /*
337          * Allocate the IRQ
338          */
339         retval = request_irq(KS8695_IRQ_UART_TX, ks8695uart_tx_chars, 0, "UART TX", port);
340         if (retval)
341                 goto err_tx;
342
343         retval = request_irq(KS8695_IRQ_UART_RX, ks8695uart_rx_chars, 0, "UART RX", port);
344         if (retval)
345                 goto err_rx;
346
347         retval = request_irq(KS8695_IRQ_UART_LINE_STATUS, ks8695uart_rx_chars, 0, "UART LineStatus", port);
348         if (retval)
349                 goto err_ls;
350
351         retval = request_irq(KS8695_IRQ_UART_MODEM_STATUS, ks8695uart_modem_status, 0, "UART ModemStatus", port);
352         if (retval)
353                 goto err_ms;
354
355         return 0;
356
357 err_ms:
358         free_irq(KS8695_IRQ_UART_LINE_STATUS, port);
359 err_ls:
360         free_irq(KS8695_IRQ_UART_RX, port);
361 err_rx:
362         free_irq(KS8695_IRQ_UART_TX, port);
363 err_tx:
364         return retval;
365 }
366
367 static void ks8695uart_shutdown(struct uart_port *port)
368 {
369         /*
370          * Free the interrupt
371          */
372         free_irq(KS8695_IRQ_UART_RX, port);
373         free_irq(KS8695_IRQ_UART_TX, port);
374         free_irq(KS8695_IRQ_UART_MODEM_STATUS, port);
375         free_irq(KS8695_IRQ_UART_LINE_STATUS, port);
376
377         /* disable break condition and fifos */
378         UART_PUT_LCR(port, UART_GET_LCR(port) & ~URLC_URSBC);
379         UART_PUT_FCR(port, UART_GET_FCR(port) & ~URFC_URFE);
380 }
381
382 static void ks8695uart_set_termios(struct uart_port *port, struct ktermios *termios, struct ktermios *old)
383 {
384         unsigned int lcr, fcr = 0;
385         unsigned long flags;
386         unsigned int baud, quot;
387
388         /*
389          * Ask the core to calculate the divisor for us.
390          */
391         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
392         quot = uart_get_divisor(port, baud);
393
394         switch (termios->c_cflag & CSIZE) {
395         case CS5:
396                 lcr = URCL_5;
397                 break;
398         case CS6:
399                 lcr = URCL_6;
400                 break;
401         case CS7:
402                 lcr = URCL_7;
403                 break;
404         default:
405                 lcr = URCL_8;
406                 break;
407         }
408
409         /* stop bits */
410         if (termios->c_cflag & CSTOPB)
411                 lcr |= URLC_URSB;
412
413         /* parity */
414         if (termios->c_cflag & PARENB) {
415                 if (termios->c_cflag & CMSPAR) {        /* Mark or Space parity */
416                         if (termios->c_cflag & PARODD)
417                                 lcr |= URPE_MARK;
418                         else
419                                 lcr |= URPE_SPACE;
420                 }
421                 else if (termios->c_cflag & PARODD)
422                         lcr |= URPE_ODD;
423                 else
424                         lcr |= URPE_EVEN;
425         }
426
427         if (port->fifosize > 1)
428                 fcr = URFC_URFRT_8 | URFC_URTFR | URFC_URRFR | URFC_URFE;
429
430         spin_lock_irqsave(&port->lock, flags);
431
432         /*
433          * Update the per-port timeout.
434          */
435         uart_update_timeout(port, termios->c_cflag, baud);
436
437         port->read_status_mask = URLS_URROE;
438         if (termios->c_iflag & INPCK)
439                 port->read_status_mask |= (URLS_URFE | URLS_URPE);
440         if (termios->c_iflag & (IGNBRK | BRKINT | PARMRK))
441                 port->read_status_mask |= URLS_URBI;
442
443         /*
444          * Characters to ignore
445          */
446         port->ignore_status_mask = 0;
447         if (termios->c_iflag & IGNPAR)
448                 port->ignore_status_mask |= (URLS_URFE | URLS_URPE);
449         if (termios->c_iflag & IGNBRK) {
450                 port->ignore_status_mask |= URLS_URBI;
451                 /*
452                  * If we're ignoring parity and break indicators,
453                  * ignore overruns too (for real raw support).
454                  */
455                 if (termios->c_iflag & IGNPAR)
456                         port->ignore_status_mask |= URLS_URROE;
457         }
458
459         /*
460          * Ignore all characters if CREAD is not set.
461          */
462         if ((termios->c_cflag & CREAD) == 0)
463                 port->ignore_status_mask |= UART_DUMMY_LSR_RX;
464
465         /* first, disable everything */
466         if (UART_ENABLE_MS(port, termios->c_cflag))
467                 ks8695uart_enable_ms(port);
468         else
469                 ks8695uart_disable_ms(port);
470
471         /* Set baud rate */
472         UART_PUT_BRDR(port, quot);
473
474         UART_PUT_LCR(port, lcr);
475         UART_PUT_FCR(port, fcr);
476
477         spin_unlock_irqrestore(&port->lock, flags);
478 }
479
480 static const char *ks8695uart_type(struct uart_port *port)
481 {
482         return port->type == PORT_KS8695 ? "KS8695" : NULL;
483 }
484
485 /*
486  * Release the memory region(s) being used by 'port'
487  */
488 static void ks8695uart_release_port(struct uart_port *port)
489 {
490         release_mem_region(port->mapbase, UART_PORT_SIZE);
491 }
492
493 /*
494  * Request the memory region(s) being used by 'port'
495  */
496 static int ks8695uart_request_port(struct uart_port *port)
497 {
498         return request_mem_region(port->mapbase, UART_PORT_SIZE,
499                         "serial_ks8695") != NULL ? 0 : -EBUSY;
500 }
501
502 /*
503  * Configure/autoconfigure the port.
504  */
505 static void ks8695uart_config_port(struct uart_port *port, int flags)
506 {
507         if (flags & UART_CONFIG_TYPE) {
508                 port->type = PORT_KS8695;
509                 ks8695uart_request_port(port);
510         }
511 }
512
513 /*
514  * verify the new serial_struct (for TIOCSSERIAL).
515  */
516 static int ks8695uart_verify_port(struct uart_port *port, struct serial_struct *ser)
517 {
518         int ret = 0;
519
520         if (ser->type != PORT_UNKNOWN && ser->type != PORT_KS8695)
521                 ret = -EINVAL;
522         if (ser->irq != port->irq)
523                 ret = -EINVAL;
524         if (ser->baud_base < 9600)
525                 ret = -EINVAL;
526         return ret;
527 }
528
529 static struct uart_ops ks8695uart_pops = {
530         .tx_empty       = ks8695uart_tx_empty,
531         .set_mctrl      = ks8695uart_set_mctrl,
532         .get_mctrl      = ks8695uart_get_mctrl,
533         .stop_tx        = ks8695uart_stop_tx,
534         .start_tx       = ks8695uart_start_tx,
535         .stop_rx        = ks8695uart_stop_rx,
536         .enable_ms      = ks8695uart_enable_ms,
537         .break_ctl      = ks8695uart_break_ctl,
538         .startup        = ks8695uart_startup,
539         .shutdown       = ks8695uart_shutdown,
540         .set_termios    = ks8695uart_set_termios,
541         .type           = ks8695uart_type,
542         .release_port   = ks8695uart_release_port,
543         .request_port   = ks8695uart_request_port,
544         .config_port    = ks8695uart_config_port,
545         .verify_port    = ks8695uart_verify_port,
546 };
547
548 static struct uart_port ks8695uart_ports[SERIAL_KS8695_NR] = {
549         {
550                 .membase        = KS8695_UART_VA,
551                 .mapbase        = KS8695_UART_PA,
552                 .iotype         = SERIAL_IO_MEM,
553                 .irq            = KS8695_IRQ_UART_TX,
554                 .uartclk        = KS8695_CLOCK_RATE * 16,
555                 .fifosize       = 16,
556                 .ops            = &ks8695uart_pops,
557                 .flags          = UPF_BOOT_AUTOCONF,
558                 .line           = 0,
559         }
560 };
561
562 #ifdef CONFIG_SERIAL_KS8695_CONSOLE
563 static void ks8695_console_putchar(struct uart_port *port, int ch)
564 {
565         while (!(UART_GET_LSR(port) & URLS_URTHRE))
566                 barrier();
567
568         UART_PUT_CHAR(port, ch);
569 }
570
571 static void ks8695_console_write(struct console *co, const char *s, u_int count)
572 {
573         struct uart_port *port = ks8695uart_ports + co->index;
574
575         uart_console_write(port, s, count, ks8695_console_putchar);
576 }
577
578 static void __init ks8695_console_get_options(struct uart_port *port, int *baud, int *parity, int *bits)
579 {
580         unsigned int lcr;
581
582         lcr = UART_GET_LCR(port);
583
584         switch (lcr & URLC_PARITY) {
585                 case URPE_ODD:
586                         *parity = 'o';
587                         break;
588                 case URPE_EVEN:
589                         *parity = 'e';
590                         break;
591                 default:
592                         *parity = 'n';
593         }
594
595         switch (lcr & URLC_URCL) {
596                 case URCL_5:
597                         *bits = 5;
598                         break;
599                 case URCL_6:
600                         *bits = 6;
601                         break;
602                 case URCL_7:
603                         *bits = 7;
604                         break;
605                 default:
606                         *bits = 8;
607         }
608
609         *baud = port->uartclk / (UART_GET_BRDR(port) & 0x0FFF);
610         *baud /= 16;
611         *baud &= 0xFFFFFFF0;
612 }
613
614 static int __init ks8695_console_setup(struct console *co, char *options)
615 {
616         struct uart_port *port;
617         int baud = 115200;
618         int bits = 8;
619         int parity = 'n';
620         int flow = 'n';
621
622         /*
623          * Check whether an invalid uart number has been specified, and
624          * if so, search for the first available port that does have
625          * console support.
626          */
627         port = uart_get_console(ks8695uart_ports, SERIAL_KS8695_NR, co);
628
629         if (options)
630                 uart_parse_options(options, &baud, &parity, &bits, &flow);
631         else
632                 ks8695_console_get_options(port, &baud, &parity, &bits);
633
634         return uart_set_options(port, co, baud, parity, bits, flow);
635 }
636
637 static struct uart_driver ks8695_reg;
638
639 static struct console ks8695_console = {
640         .name           = SERIAL_KS8695_DEVNAME,
641         .write          = ks8695_console_write,
642         .device         = uart_console_device,
643         .setup          = ks8695_console_setup,
644         .flags          = CON_PRINTBUFFER,
645         .index          = -1,
646         .data           = &ks8695_reg,
647 };
648
649 static int __init ks8695_console_init(void)
650 {
651         add_preferred_console(SERIAL_KS8695_DEVNAME, 0, NULL);
652         register_console(&ks8695_console);
653         return 0;
654 }
655
656 console_initcall(ks8695_console_init);
657
658 #define KS8695_CONSOLE  &ks8695_console
659 #else
660 #define KS8695_CONSOLE  NULL
661 #endif
662
663 static struct uart_driver ks8695_reg = {
664         .owner                  = THIS_MODULE,
665         .driver_name            = "serial_ks8695",
666         .dev_name               = SERIAL_KS8695_DEVNAME,
667         .major                  = SERIAL_KS8695_MAJOR,
668         .minor                  = SERIAL_KS8695_MINOR,
669         .nr                     = SERIAL_KS8695_NR,
670         .cons                   = KS8695_CONSOLE,
671 };
672
673 static int __init ks8695uart_init(void)
674 {
675         int i, ret;
676
677         printk(KERN_INFO "Serial: Micrel KS8695 UART driver\n");
678
679         ret = uart_register_driver(&ks8695_reg);
680         if (ret)
681                 return ret;
682
683         for (i = 0; i < SERIAL_KS8695_NR; i++)
684                 uart_add_one_port(&ks8695_reg, &ks8695uart_ports[0]);
685
686         return 0;
687 }
688
689 static void __exit ks8695uart_exit(void)
690 {
691         int i;
692
693         for (i = 0; i < SERIAL_KS8695_NR; i++)
694                 uart_remove_one_port(&ks8695_reg, &ks8695uart_ports[0]);
695         uart_unregister_driver(&ks8695_reg);
696 }
697
698 module_init(ks8695uart_init);
699 module_exit(ks8695uart_exit);
700
701 MODULE_DESCRIPTION("KS8695 serial port driver");
702 MODULE_AUTHOR("Micrel Inc.");
703 MODULE_LICENSE("GPL");