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