Merge with /pub/scm/linux/kernel/git/torvalds/linux-2.6.git
[linux-2.6] / drivers / serial / m32r_sio.c
1 /*
2  *  m32r_sio.c
3  *
4  *  Driver for M32R serial ports
5  *
6  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
7  *  Based on drivers/serial/8250.c.
8  *
9  *  Copyright (C) 2001  Russell King.
10  *  Copyright (C) 2004  Hirokazu Takata <takata at linux-m32r.org>
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  */
17
18 /*
19  * A note about mapbase / membase
20  *
21  *  mapbase is the physical address of the IO port.  Currently, we don't
22  *  support this very well, and it may well be dropped from this driver
23  *  in future.  As such, mapbase should be NULL.
24  *
25  *  membase is an 'ioremapped' cookie.  This is compatible with the old
26  *  serial.c driver, and is currently the preferred form.
27  */
28 #include <linux/config.h>
29
30 #if defined(CONFIG_SERIAL_M32R_SIO_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
31 #define SUPPORT_SYSRQ
32 #endif
33
34 #include <linux/module.h>
35 #include <linux/tty.h>
36 #include <linux/ioport.h>
37 #include <linux/init.h>
38 #include <linux/console.h>
39 #include <linux/sysrq.h>
40 #include <linux/serial.h>
41 #include <linux/serialP.h>
42 #include <linux/delay.h>
43
44 #include <asm/m32r.h>
45 #include <asm/io.h>
46 #include <asm/irq.h>
47
48 #define PORT_M32R_BASE  PORT_M32R_SIO
49 #define PORT_INDEX(x)   (x - PORT_M32R_BASE + 1)
50 #define BAUD_RATE       115200
51
52 #include <linux/serial_core.h>
53 #include "m32r_sio.h"
54 #include "m32r_sio_reg.h"
55
56 /*
57  * Debugging.
58  */
59 #if 0
60 #define DEBUG_AUTOCONF(fmt...)  printk(fmt)
61 #else
62 #define DEBUG_AUTOCONF(fmt...)  do { } while (0)
63 #endif
64
65 #if 0
66 #define DEBUG_INTR(fmt...)      printk(fmt)
67 #else
68 #define DEBUG_INTR(fmt...)      do { } while (0)
69 #endif
70
71 #define PASS_LIMIT      256
72
73 /*
74  * We default to IRQ0 for the "no irq" hack.   Some
75  * machine types want others as well - they're free
76  * to redefine this in their header file.
77  */
78 #define is_real_interrupt(irq)  ((irq) != 0)
79
80 #include <asm/serial.h>
81
82 /* Standard COM flags */
83 #define STD_COM_FLAGS (UPF_BOOT_AUTOCONF | UPF_SKIP_TEST)
84
85 /*
86  * SERIAL_PORT_DFNS tells us about built-in ports that have no
87  * standard enumeration mechanism.   Platforms that can find all
88  * serial ports via mechanisms like ACPI or PCI need not supply it.
89  */
90 #undef SERIAL_PORT_DFNS
91 #if defined(CONFIG_PLAT_USRV)
92
93 #define SERIAL_PORT_DFNS                                                \
94        /* UART  CLK     PORT   IRQ            FLAGS */                  \
95         { 0, BASE_BAUD, 0x3F8, PLD_IRQ_UART0, STD_COM_FLAGS }, /* ttyS0 */ \
96         { 0, BASE_BAUD, 0x2F8, PLD_IRQ_UART1, STD_COM_FLAGS }, /* ttyS1 */
97
98 #else /* !CONFIG_PLAT_USRV */
99
100 #if defined(CONFIG_SERIAL_M32R_PLDSIO)
101 #define SERIAL_PORT_DFNS                                                \
102         { 0, BASE_BAUD, ((unsigned long)PLD_ESIO0CR), PLD_IRQ_SIO0_RCV, \
103           STD_COM_FLAGS }, /* ttyS0 */
104 #else
105 #define SERIAL_PORT_DFNS                                                \
106         { 0, BASE_BAUD, M32R_SIO_OFFSET, M32R_IRQ_SIO0_R,               \
107           STD_COM_FLAGS }, /* ttyS0 */
108 #endif
109
110 #endif /* !CONFIG_PLAT_USRV */
111
112 static struct old_serial_port old_serial_port[] = {
113         SERIAL_PORT_DFNS        /* defined in asm/serial.h */
114 };
115
116 #define UART_NR ARRAY_SIZE(old_serial_port)
117
118 struct uart_sio_port {
119         struct uart_port        port;
120         struct timer_list       timer;          /* "no irq" timer */
121         struct list_head        list;           /* ports on this IRQ */
122         unsigned short          rev;
123         unsigned char           acr;
124         unsigned char           ier;
125         unsigned char           lcr;
126         unsigned char           mcr_mask;       /* mask of user bits */
127         unsigned char           mcr_force;      /* mask of forced bits */
128         unsigned char           lsr_break_flag;
129
130         /*
131          * We provide a per-port pm hook.
132          */
133         void                    (*pm)(struct uart_port *port,
134                                       unsigned int state, unsigned int old);
135 };
136
137 struct irq_info {
138         spinlock_t              lock;
139         struct list_head        *head;
140 };
141
142 static struct irq_info irq_lists[NR_IRQS];
143
144 /*
145  * Here we define the default xmit fifo size used for each type of UART.
146  */
147 static const struct serial_uart_config uart_config[] = {
148         [PORT_UNKNOWN] = {
149                 .name                   = "unknown",
150                 .dfl_xmit_fifo_size     = 1,
151                 .flags                  = 0,
152         },
153         [PORT_INDEX(PORT_M32R_SIO)] = {
154                 .name                   = "M32RSIO",
155                 .dfl_xmit_fifo_size     = 1,
156                 .flags                  = 0,
157         },
158 };
159
160 #ifdef CONFIG_SERIAL_M32R_PLDSIO
161
162 #define __sio_in(x) inw((unsigned long)(x))
163 #define __sio_out(v,x) outw((v),(unsigned long)(x))
164
165 static inline void sio_set_baud_rate(unsigned long baud)
166 {
167         unsigned short sbaud;
168         sbaud = (boot_cpu_data.bus_clock / (baud * 4))-1;
169         __sio_out(sbaud, PLD_ESIO0BAUR);
170 }
171
172 static void sio_reset(void)
173 {
174         unsigned short tmp;
175
176         tmp = __sio_in(PLD_ESIO0RXB);
177         tmp = __sio_in(PLD_ESIO0RXB);
178         tmp = __sio_in(PLD_ESIO0CR);
179         sio_set_baud_rate(BAUD_RATE);
180         __sio_out(0x0300, PLD_ESIO0CR);
181         __sio_out(0x0003, PLD_ESIO0CR);
182 }
183
184 static void sio_init(void)
185 {
186         unsigned short tmp;
187
188         tmp = __sio_in(PLD_ESIO0RXB);
189         tmp = __sio_in(PLD_ESIO0RXB);
190         tmp = __sio_in(PLD_ESIO0CR);
191         __sio_out(0x0300, PLD_ESIO0CR);
192         __sio_out(0x0003, PLD_ESIO0CR);
193 }
194
195 static void sio_error(int *status)
196 {
197         printk("SIO0 error[%04x]\n", *status);
198         do {
199                 sio_init();
200         } while ((*status = __sio_in(PLD_ESIO0CR)) != 3);
201 }
202
203 #else /* not CONFIG_SERIAL_M32R_PLDSIO */
204
205 #define __sio_in(x) inl(x)
206 #define __sio_out(v,x) outl((v),(x))
207
208 static inline void sio_set_baud_rate(unsigned long baud)
209 {
210         unsigned long i, j;
211
212         i = boot_cpu_data.bus_clock / (baud * 16);
213         j = (boot_cpu_data.bus_clock - (i * baud * 16)) / baud;
214         i -= 1;
215         j = (j + 1) >> 1;
216
217         __sio_out(i, M32R_SIO0_BAUR_PORTL);
218         __sio_out(j, M32R_SIO0_RBAUR_PORTL);
219 }
220
221 static void sio_reset(void)
222 {
223         __sio_out(0x00000300, M32R_SIO0_CR_PORTL);      /* init status */
224         __sio_out(0x00000800, M32R_SIO0_MOD1_PORTL);    /* 8bit        */
225         __sio_out(0x00000080, M32R_SIO0_MOD0_PORTL);    /* 1stop non   */
226         sio_set_baud_rate(BAUD_RATE);
227         __sio_out(0x00000000, M32R_SIO0_TRCR_PORTL);
228         __sio_out(0x00000003, M32R_SIO0_CR_PORTL);      /* RXCEN */
229 }
230
231 static void sio_init(void)
232 {
233         unsigned int tmp;
234
235         tmp = __sio_in(M32R_SIO0_RXB_PORTL);
236         tmp = __sio_in(M32R_SIO0_RXB_PORTL);
237         tmp = __sio_in(M32R_SIO0_STS_PORTL);
238         __sio_out(0x00000003, M32R_SIO0_CR_PORTL);
239 }
240
241 static void sio_error(int *status)
242 {
243         printk("SIO0 error[%04x]\n", *status);
244         do {
245                 sio_init();
246         } while ((*status = __sio_in(M32R_SIO0_CR_PORTL)) != 3);
247 }
248
249 #endif /* CONFIG_SERIAL_M32R_PLDSIO */
250
251 static _INLINE_ unsigned int sio_in(struct uart_sio_port *up, int offset)
252 {
253         return __sio_in(up->port.iobase + offset);
254 }
255
256 static _INLINE_ void sio_out(struct uart_sio_port *up, int offset, int value)
257 {
258         __sio_out(value, up->port.iobase + offset);
259 }
260
261 static _INLINE_ unsigned int serial_in(struct uart_sio_port *up, int offset)
262 {
263         if (!offset)
264                 return 0;
265
266         return __sio_in(offset);
267 }
268
269 static _INLINE_ void
270 serial_out(struct uart_sio_port *up, int offset, int value)
271 {
272         if (!offset)
273                 return;
274
275         __sio_out(value, offset);
276 }
277
278 static void m32r_sio_stop_tx(struct uart_port *port)
279 {
280         struct uart_sio_port *up = (struct uart_sio_port *)port;
281
282         if (up->ier & UART_IER_THRI) {
283                 up->ier &= ~UART_IER_THRI;
284                 serial_out(up, UART_IER, up->ier);
285         }
286 }
287
288 static void m32r_sio_start_tx(struct uart_port *port)
289 {
290 #ifdef CONFIG_SERIAL_M32R_PLDSIO
291         struct uart_sio_port *up = (struct uart_sio_port *)port;
292         struct circ_buf *xmit = &up->port.info->xmit;
293
294         if (!(up->ier & UART_IER_THRI)) {
295                 up->ier |= UART_IER_THRI;
296                 serial_out(up, UART_IER, up->ier);
297                 serial_out(up, UART_TX, xmit->buf[xmit->tail]);
298                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
299                 up->port.icount.tx++;
300         }
301         while((serial_in(up, UART_LSR) & UART_EMPTY) != UART_EMPTY);
302 #else
303         struct uart_sio_port *up = (struct uart_sio_port *)port;
304
305         if (!(up->ier & UART_IER_THRI)) {
306                 up->ier |= UART_IER_THRI;
307                 serial_out(up, UART_IER, up->ier);
308         }
309 #endif
310 }
311
312 static void m32r_sio_stop_rx(struct uart_port *port)
313 {
314         struct uart_sio_port *up = (struct uart_sio_port *)port;
315
316         up->ier &= ~UART_IER_RLSI;
317         up->port.read_status_mask &= ~UART_LSR_DR;
318         serial_out(up, UART_IER, up->ier);
319 }
320
321 static void m32r_sio_enable_ms(struct uart_port *port)
322 {
323         struct uart_sio_port *up = (struct uart_sio_port *)port;
324
325         up->ier |= UART_IER_MSI;
326         serial_out(up, UART_IER, up->ier);
327 }
328
329 static _INLINE_ void receive_chars(struct uart_sio_port *up, int *status,
330         struct pt_regs *regs)
331 {
332         struct tty_struct *tty = up->port.info->tty;
333         unsigned char ch;
334         unsigned char flag;
335         int max_count = 256;
336
337         do {
338                 ch = sio_in(up, SIORXB);
339                 flag = TTY_NORMAL;
340                 up->port.icount.rx++;
341
342                 if (unlikely(*status & (UART_LSR_BI | UART_LSR_PE |
343                                        UART_LSR_FE | UART_LSR_OE))) {
344                         /*
345                          * For statistics only
346                          */
347                         if (*status & UART_LSR_BI) {
348                                 *status &= ~(UART_LSR_FE | UART_LSR_PE);
349                                 up->port.icount.brk++;
350                                 /*
351                                  * We do the SysRQ and SAK checking
352                                  * here because otherwise the break
353                                  * may get masked by ignore_status_mask
354                                  * or read_status_mask.
355                                  */
356                                 if (uart_handle_break(&up->port))
357                                         goto ignore_char;
358                         } else if (*status & UART_LSR_PE)
359                                 up->port.icount.parity++;
360                         else if (*status & UART_LSR_FE)
361                                 up->port.icount.frame++;
362                         if (*status & UART_LSR_OE)
363                                 up->port.icount.overrun++;
364
365                         /*
366                          * Mask off conditions which should be ingored.
367                          */
368                         *status &= up->port.read_status_mask;
369
370                         if (up->port.line == up->port.cons->index) {
371                                 /* Recover the break flag from console xmit */
372                                 *status |= up->lsr_break_flag;
373                                 up->lsr_break_flag = 0;
374                         }
375
376                         if (*status & UART_LSR_BI) {
377                                 DEBUG_INTR("handling break....");
378                                 flag = TTY_BREAK;
379                         } else if (*status & UART_LSR_PE)
380                                 flag = TTY_PARITY;
381                         else if (*status & UART_LSR_FE)
382                                 flag = TTY_FRAME;
383                 }
384                 if (uart_handle_sysrq_char(&up->port, ch, regs))
385                         goto ignore_char;
386                 if ((*status & up->port.ignore_status_mask) == 0)
387                         tty_insert_flip_char(tty, ch, flag);
388
389                 if (*status & UART_LSR_OE) {
390                         /*
391                          * Overrun is special, since it's reported
392                          * immediately, and doesn't affect the current
393                          * character.
394                          */
395                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
396                 }
397         ignore_char:
398                 *status = serial_in(up, UART_LSR);
399         } while ((*status & UART_LSR_DR) && (max_count-- > 0));
400         tty_flip_buffer_push(tty);
401 }
402
403 static _INLINE_ void transmit_chars(struct uart_sio_port *up)
404 {
405         struct circ_buf *xmit = &up->port.info->xmit;
406         int count;
407
408         if (up->port.x_char) {
409 #ifndef CONFIG_SERIAL_M32R_PLDSIO       /* XXX */
410                 serial_out(up, UART_TX, up->port.x_char);
411 #endif
412                 up->port.icount.tx++;
413                 up->port.x_char = 0;
414                 return;
415         }
416         if (uart_circ_empty(xmit) || uart_tx_stopped(&up->port)) {
417                 m32r_sio_stop_tx(&up->port);
418                 return;
419         }
420
421         count = up->port.fifosize;
422         do {
423                 serial_out(up, UART_TX, xmit->buf[xmit->tail]);
424                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
425                 up->port.icount.tx++;
426                 if (uart_circ_empty(xmit))
427                         break;
428                 while (!serial_in(up, UART_LSR) & UART_LSR_THRE);
429
430         } while (--count > 0);
431
432         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
433                 uart_write_wakeup(&up->port);
434
435         DEBUG_INTR("THRE...");
436
437         if (uart_circ_empty(xmit))
438                 m32r_sio_stop_tx(&up->port);
439 }
440
441 /*
442  * This handles the interrupt from one port.
443  */
444 static inline void m32r_sio_handle_port(struct uart_sio_port *up,
445         unsigned int status, struct pt_regs *regs)
446 {
447         DEBUG_INTR("status = %x...", status);
448
449         if (status & 0x04)
450                 receive_chars(up, &status, regs);
451         if (status & 0x01)
452                 transmit_chars(up);
453 }
454
455 /*
456  * This is the serial driver's interrupt routine.
457  *
458  * Arjan thinks the old way was overly complex, so it got simplified.
459  * Alan disagrees, saying that need the complexity to handle the weird
460  * nature of ISA shared interrupts.  (This is a special exception.)
461  *
462  * In order to handle ISA shared interrupts properly, we need to check
463  * that all ports have been serviced, and therefore the ISA interrupt
464  * line has been de-asserted.
465  *
466  * This means we need to loop through all ports. checking that they
467  * don't have an interrupt pending.
468  */
469 static irqreturn_t m32r_sio_interrupt(int irq, void *dev_id,
470         struct pt_regs *regs)
471 {
472         struct irq_info *i = dev_id;
473         struct list_head *l, *end = NULL;
474         int pass_counter = 0;
475
476         DEBUG_INTR("m32r_sio_interrupt(%d)...", irq);
477
478 #ifdef CONFIG_SERIAL_M32R_PLDSIO
479 //      if (irq == PLD_IRQ_SIO0_SND)
480 //              irq = PLD_IRQ_SIO0_RCV;
481 #else
482         if (irq == M32R_IRQ_SIO0_S)
483                 irq = M32R_IRQ_SIO0_R;
484 #endif
485
486         spin_lock(&i->lock);
487
488         l = i->head;
489         do {
490                 struct uart_sio_port *up;
491                 unsigned int sts;
492
493                 up = list_entry(l, struct uart_sio_port, list);
494
495                 sts = sio_in(up, SIOSTS);
496                 if (sts & 0x5) {
497                         spin_lock(&up->port.lock);
498                         m32r_sio_handle_port(up, sts, regs);
499                         spin_unlock(&up->port.lock);
500
501                         end = NULL;
502                 } else if (end == NULL)
503                         end = l;
504
505                 l = l->next;
506
507                 if (l == i->head && pass_counter++ > PASS_LIMIT) {
508                         if (sts & 0xe0)
509                                 sio_error(&sts);
510                         break;
511                 }
512         } while (l != end);
513
514         spin_unlock(&i->lock);
515
516         DEBUG_INTR("end.\n");
517
518         return IRQ_HANDLED;
519 }
520
521 /*
522  * To support ISA shared interrupts, we need to have one interrupt
523  * handler that ensures that the IRQ line has been deasserted
524  * before returning.  Failing to do this will result in the IRQ
525  * line being stuck active, and, since ISA irqs are edge triggered,
526  * no more IRQs will be seen.
527  */
528 static void serial_do_unlink(struct irq_info *i, struct uart_sio_port *up)
529 {
530         spin_lock_irq(&i->lock);
531
532         if (!list_empty(i->head)) {
533                 if (i->head == &up->list)
534                         i->head = i->head->next;
535                 list_del(&up->list);
536         } else {
537                 BUG_ON(i->head != &up->list);
538                 i->head = NULL;
539         }
540
541         spin_unlock_irq(&i->lock);
542 }
543
544 static int serial_link_irq_chain(struct uart_sio_port *up)
545 {
546         struct irq_info *i = irq_lists + up->port.irq;
547         int ret, irq_flags = up->port.flags & UPF_SHARE_IRQ ? SA_SHIRQ : 0;
548
549         spin_lock_irq(&i->lock);
550
551         if (i->head) {
552                 list_add(&up->list, i->head);
553                 spin_unlock_irq(&i->lock);
554
555                 ret = 0;
556         } else {
557                 INIT_LIST_HEAD(&up->list);
558                 i->head = &up->list;
559                 spin_unlock_irq(&i->lock);
560
561                 ret = request_irq(up->port.irq, m32r_sio_interrupt,
562                                   irq_flags, "SIO0-RX", i);
563                 ret |= request_irq(up->port.irq + 1, m32r_sio_interrupt,
564                                   irq_flags, "SIO0-TX", i);
565                 if (ret < 0)
566                         serial_do_unlink(i, up);
567         }
568
569         return ret;
570 }
571
572 static void serial_unlink_irq_chain(struct uart_sio_port *up)
573 {
574         struct irq_info *i = irq_lists + up->port.irq;
575
576         BUG_ON(i->head == NULL);
577
578         if (list_empty(i->head)) {
579                 free_irq(up->port.irq, i);
580                 free_irq(up->port.irq + 1, i);
581         }
582
583         serial_do_unlink(i, up);
584 }
585
586 /*
587  * This function is used to handle ports that do not have an interrupt.
588  */
589 static void m32r_sio_timeout(unsigned long data)
590 {
591         struct uart_sio_port *up = (struct uart_sio_port *)data;
592         unsigned int timeout;
593         unsigned int sts;
594
595         sts = sio_in(up, SIOSTS);
596         if (sts & 0x5) {
597                 spin_lock(&up->port.lock);
598                 m32r_sio_handle_port(up, sts, NULL);
599                 spin_unlock(&up->port.lock);
600         }
601
602         timeout = up->port.timeout;
603         timeout = timeout > 6 ? (timeout / 2 - 2) : 1;
604         mod_timer(&up->timer, jiffies + timeout);
605 }
606
607 static unsigned int m32r_sio_tx_empty(struct uart_port *port)
608 {
609         struct uart_sio_port *up = (struct uart_sio_port *)port;
610         unsigned long flags;
611         unsigned int ret;
612
613         spin_lock_irqsave(&up->port.lock, flags);
614         ret = serial_in(up, UART_LSR) & UART_LSR_TEMT ? TIOCSER_TEMT : 0;
615         spin_unlock_irqrestore(&up->port.lock, flags);
616
617         return ret;
618 }
619
620 static unsigned int m32r_sio_get_mctrl(struct uart_port *port)
621 {
622         return 0;
623 }
624
625 static void m32r_sio_set_mctrl(struct uart_port *port, unsigned int mctrl)
626 {
627
628 }
629
630 static void m32r_sio_break_ctl(struct uart_port *port, int break_state)
631 {
632
633 }
634
635 static int m32r_sio_startup(struct uart_port *port)
636 {
637         struct uart_sio_port *up = (struct uart_sio_port *)port;
638         int retval;
639
640         sio_init();
641
642         /*
643          * If the "interrupt" for this port doesn't correspond with any
644          * hardware interrupt, we use a timer-based system.  The original
645          * driver used to do this with IRQ0.
646          */
647         if (!is_real_interrupt(up->port.irq)) {
648                 unsigned int timeout = up->port.timeout;
649
650                 timeout = timeout > 6 ? (timeout / 2 - 2) : 1;
651
652                 up->timer.data = (unsigned long)up;
653                 mod_timer(&up->timer, jiffies + timeout);
654         } else {
655                 retval = serial_link_irq_chain(up);
656                 if (retval)
657                         return retval;
658         }
659
660         /*
661          * Finally, enable interrupts.  Note: Modem status interrupts
662          * are set via set_termios(), which will be occurring imminently
663          * anyway, so we don't enable them here.
664          * - M32R_SIO: 0x0c
665          * - M32R_PLDSIO: 0x04
666          */
667         up->ier = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI;
668         sio_out(up, SIOTRCR, up->ier);
669
670         /*
671          * And clear the interrupt registers again for luck.
672          */
673         sio_reset();
674
675         return 0;
676 }
677
678 static void m32r_sio_shutdown(struct uart_port *port)
679 {
680         struct uart_sio_port *up = (struct uart_sio_port *)port;
681
682         /*
683          * Disable interrupts from this port
684          */
685         up->ier = 0;
686         sio_out(up, SIOTRCR, 0);
687
688         /*
689          * Disable break condition and FIFOs
690          */
691
692         sio_init();
693
694         if (!is_real_interrupt(up->port.irq))
695                 del_timer_sync(&up->timer);
696         else
697                 serial_unlink_irq_chain(up);
698 }
699
700 static unsigned int m32r_sio_get_divisor(struct uart_port *port,
701         unsigned int baud)
702 {
703         return uart_get_divisor(port, baud);
704 }
705
706 static void m32r_sio_set_termios(struct uart_port *port,
707         struct termios *termios, struct termios *old)
708 {
709         struct uart_sio_port *up = (struct uart_sio_port *)port;
710         unsigned char cval = 0;
711         unsigned long flags;
712         unsigned int baud, quot;
713
714         switch (termios->c_cflag & CSIZE) {
715         case CS5:
716                 cval = UART_LCR_WLEN5;
717                 break;
718         case CS6:
719                 cval = UART_LCR_WLEN6;
720                 break;
721         case CS7:
722                 cval = UART_LCR_WLEN7;
723                 break;
724         default:
725         case CS8:
726                 cval = UART_LCR_WLEN8;
727                 break;
728         }
729
730         if (termios->c_cflag & CSTOPB)
731                 cval |= UART_LCR_STOP;
732         if (termios->c_cflag & PARENB)
733                 cval |= UART_LCR_PARITY;
734         if (!(termios->c_cflag & PARODD))
735                 cval |= UART_LCR_EPAR;
736 #ifdef CMSPAR
737         if (termios->c_cflag & CMSPAR)
738                 cval |= UART_LCR_SPAR;
739 #endif
740
741         /*
742          * Ask the core to calculate the divisor for us.
743          */
744 #ifdef CONFIG_SERIAL_M32R_PLDSIO
745         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/4);
746 #else
747         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
748 #endif
749         quot = m32r_sio_get_divisor(port, baud);
750
751         /*
752          * Ok, we're now changing the port state.  Do it with
753          * interrupts disabled.
754          */
755         spin_lock_irqsave(&up->port.lock, flags);
756
757         sio_set_baud_rate(baud);
758
759         /*
760          * Update the per-port timeout.
761          */
762         uart_update_timeout(port, termios->c_cflag, baud);
763
764         up->port.read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
765         if (termios->c_iflag & INPCK)
766                 up->port.read_status_mask |= UART_LSR_FE | UART_LSR_PE;
767         if (termios->c_iflag & (BRKINT | PARMRK))
768                 up->port.read_status_mask |= UART_LSR_BI;
769
770         /*
771          * Characteres to ignore
772          */
773         up->port.ignore_status_mask = 0;
774         if (termios->c_iflag & IGNPAR)
775                 up->port.ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
776         if (termios->c_iflag & IGNBRK) {
777                 up->port.ignore_status_mask |= UART_LSR_BI;
778                 /*
779                  * If we're ignoring parity and break indicators,
780                  * ignore overruns too (for real raw support).
781                  */
782                 if (termios->c_iflag & IGNPAR)
783                         up->port.ignore_status_mask |= UART_LSR_OE;
784         }
785
786         /*
787          * ignore all characters if CREAD is not set
788          */
789         if ((termios->c_cflag & CREAD) == 0)
790                 up->port.ignore_status_mask |= UART_LSR_DR;
791
792         /*
793          * CTS flow control flag and modem status interrupts
794          */
795         up->ier &= ~UART_IER_MSI;
796         if (UART_ENABLE_MS(&up->port, termios->c_cflag))
797                 up->ier |= UART_IER_MSI;
798
799         serial_out(up, UART_IER, up->ier);
800
801         up->lcr = cval;                                 /* Save LCR */
802         spin_unlock_irqrestore(&up->port.lock, flags);
803 }
804
805 static void m32r_sio_pm(struct uart_port *port, unsigned int state,
806         unsigned int oldstate)
807 {
808         struct uart_sio_port *up = (struct uart_sio_port *)port;
809
810         if (up->pm)
811                 up->pm(port, state, oldstate);
812 }
813
814 /*
815  * Resource handling.  This is complicated by the fact that resources
816  * depend on the port type.  Maybe we should be claiming the standard
817  * 8250 ports, and then trying to get other resources as necessary?
818  */
819 static int
820 m32r_sio_request_std_resource(struct uart_sio_port *up, struct resource **res)
821 {
822         unsigned int size = 8 << up->port.regshift;
823 #ifndef CONFIG_SERIAL_M32R_PLDSIO
824         unsigned long start;
825 #endif
826         int ret = 0;
827
828         switch (up->port.iotype) {
829         case UPIO_MEM:
830                 if (up->port.mapbase) {
831 #ifdef CONFIG_SERIAL_M32R_PLDSIO
832                         *res = request_mem_region(up->port.mapbase, size, "serial");
833 #else
834                         start = up->port.mapbase;
835                         *res = request_mem_region(start, size, "serial");
836 #endif
837                         if (!*res)
838                                 ret = -EBUSY;
839                 }
840                 break;
841
842         case UPIO_PORT:
843                 *res = request_region(up->port.iobase, size, "serial");
844                 if (!*res)
845                         ret = -EBUSY;
846                 break;
847         }
848         return ret;
849 }
850
851 static void m32r_sio_release_port(struct uart_port *port)
852 {
853         struct uart_sio_port *up = (struct uart_sio_port *)port;
854         unsigned long start, offset = 0, size = 0;
855
856         size <<= up->port.regshift;
857
858         switch (up->port.iotype) {
859         case UPIO_MEM:
860                 if (up->port.mapbase) {
861                         /*
862                          * Unmap the area.
863                          */
864                         iounmap(up->port.membase);
865                         up->port.membase = NULL;
866
867                         start = up->port.mapbase;
868
869                         if (size)
870                                 release_mem_region(start + offset, size);
871                         release_mem_region(start, 8 << up->port.regshift);
872                 }
873                 break;
874
875         case UPIO_PORT:
876                 start = up->port.iobase;
877
878                 if (size)
879                         release_region(start + offset, size);
880                 release_region(start + offset, 8 << up->port.regshift);
881                 break;
882
883         default:
884                 break;
885         }
886 }
887
888 static int m32r_sio_request_port(struct uart_port *port)
889 {
890         struct uart_sio_port *up = (struct uart_sio_port *)port;
891         struct resource *res = NULL;
892         int ret = 0;
893
894         ret = m32r_sio_request_std_resource(up, &res);
895
896         /*
897          * If we have a mapbase, then request that as well.
898          */
899         if (ret == 0 && up->port.flags & UPF_IOREMAP) {
900                 int size = res->end - res->start + 1;
901
902                 up->port.membase = ioremap(up->port.mapbase, size);
903                 if (!up->port.membase)
904                         ret = -ENOMEM;
905         }
906
907         if (ret < 0) {
908                 if (res)
909                         release_resource(res);
910         }
911
912         return ret;
913 }
914
915 static void m32r_sio_config_port(struct uart_port *port, int flags)
916 {
917         struct uart_sio_port *up = (struct uart_sio_port *)port;
918
919         spin_lock_irqsave(&up->port.lock, flags);
920
921         up->port.type = (PORT_M32R_SIO - PORT_M32R_BASE + 1);
922         up->port.fifosize = uart_config[up->port.type].dfl_xmit_fifo_size;
923
924         spin_unlock_irqrestore(&up->port.lock, flags);
925 }
926
927 static int
928 m32r_sio_verify_port(struct uart_port *port, struct serial_struct *ser)
929 {
930         if (ser->irq >= NR_IRQS || ser->irq < 0 ||
931             ser->baud_base < 9600 || ser->type < PORT_UNKNOWN ||
932             ser->type >= ARRAY_SIZE(uart_config))
933                 return -EINVAL;
934         return 0;
935 }
936
937 static const char *
938 m32r_sio_type(struct uart_port *port)
939 {
940         int type = port->type;
941
942         if (type >= ARRAY_SIZE(uart_config))
943                 type = 0;
944         return uart_config[type].name;
945 }
946
947 static struct uart_ops m32r_sio_pops = {
948         .tx_empty       = m32r_sio_tx_empty,
949         .set_mctrl      = m32r_sio_set_mctrl,
950         .get_mctrl      = m32r_sio_get_mctrl,
951         .stop_tx        = m32r_sio_stop_tx,
952         .start_tx       = m32r_sio_start_tx,
953         .stop_rx        = m32r_sio_stop_rx,
954         .enable_ms      = m32r_sio_enable_ms,
955         .break_ctl      = m32r_sio_break_ctl,
956         .startup        = m32r_sio_startup,
957         .shutdown       = m32r_sio_shutdown,
958         .set_termios    = m32r_sio_set_termios,
959         .pm             = m32r_sio_pm,
960         .type           = m32r_sio_type,
961         .release_port   = m32r_sio_release_port,
962         .request_port   = m32r_sio_request_port,
963         .config_port    = m32r_sio_config_port,
964         .verify_port    = m32r_sio_verify_port,
965 };
966
967 static struct uart_sio_port m32r_sio_ports[UART_NR];
968
969 static void __init m32r_sio_init_ports(void)
970 {
971         struct uart_sio_port *up;
972         static int first = 1;
973         int i;
974
975         if (!first)
976                 return;
977         first = 0;
978
979         for (i = 0, up = m32r_sio_ports; i < ARRAY_SIZE(old_serial_port);
980              i++, up++) {
981                 up->port.iobase   = old_serial_port[i].port;
982                 up->port.irq      = irq_canonicalize(old_serial_port[i].irq);
983                 up->port.uartclk  = old_serial_port[i].baud_base * 16;
984                 up->port.flags    = old_serial_port[i].flags;
985                 up->port.membase  = old_serial_port[i].iomem_base;
986                 up->port.iotype   = old_serial_port[i].io_type;
987                 up->port.regshift = old_serial_port[i].iomem_reg_shift;
988                 up->port.ops      = &m32r_sio_pops;
989         }
990 }
991
992 static void __init m32r_sio_register_ports(struct uart_driver *drv)
993 {
994         int i;
995
996         m32r_sio_init_ports();
997
998         for (i = 0; i < UART_NR; i++) {
999                 struct uart_sio_port *up = &m32r_sio_ports[i];
1000
1001                 up->port.line = i;
1002                 up->port.ops = &m32r_sio_pops;
1003                 init_timer(&up->timer);
1004                 up->timer.function = m32r_sio_timeout;
1005
1006                 /*
1007                  * ALPHA_KLUDGE_MCR needs to be killed.
1008                  */
1009                 up->mcr_mask = ~ALPHA_KLUDGE_MCR;
1010                 up->mcr_force = ALPHA_KLUDGE_MCR;
1011
1012                 uart_add_one_port(drv, &up->port);
1013         }
1014 }
1015
1016 #ifdef CONFIG_SERIAL_M32R_SIO_CONSOLE
1017
1018 /*
1019  *      Wait for transmitter & holding register to empty
1020  */
1021 static inline void wait_for_xmitr(struct uart_sio_port *up)
1022 {
1023         unsigned int status, tmout = 10000;
1024
1025         /* Wait up to 10ms for the character(s) to be sent. */
1026         do {
1027                 status = sio_in(up, SIOSTS);
1028
1029                 if (--tmout == 0)
1030                         break;
1031                 udelay(1);
1032         } while ((status & UART_EMPTY) != UART_EMPTY);
1033
1034         /* Wait up to 1s for flow control if necessary */
1035         if (up->port.flags & UPF_CONS_FLOW) {
1036                 tmout = 1000000;
1037                 while (--tmout)
1038                         udelay(1);
1039         }
1040 }
1041
1042 /*
1043  *      Print a string to the serial port trying not to disturb
1044  *      any possible real use of the port...
1045  *
1046  *      The console_lock must be held when we get here.
1047  */
1048 static void m32r_sio_console_write(struct console *co, const char *s,
1049         unsigned int count)
1050 {
1051         struct uart_sio_port *up = &m32r_sio_ports[co->index];
1052         unsigned int ier;
1053         int i;
1054
1055         /*
1056          *      First save the UER then disable the interrupts
1057          */
1058         ier = sio_in(up, SIOTRCR);
1059         sio_out(up, SIOTRCR, 0);
1060
1061         /*
1062          *      Now, do each character
1063          */
1064         for (i = 0; i < count; i++, s++) {
1065                 wait_for_xmitr(up);
1066
1067                 /*
1068                  *      Send the character out.
1069                  *      If a LF, also do CR...
1070                  */
1071                 sio_out(up, SIOTXB, *s);
1072
1073                 if (*s == 10) {
1074                         wait_for_xmitr(up);
1075                         sio_out(up, SIOTXB, 13);
1076                 }
1077         }
1078
1079         /*
1080          *      Finally, wait for transmitter to become empty
1081          *      and restore the IER
1082          */
1083         wait_for_xmitr(up);
1084         sio_out(up, SIOTRCR, ier);
1085 }
1086
1087 static int __init m32r_sio_console_setup(struct console *co, char *options)
1088 {
1089         struct uart_port *port;
1090         int baud = 9600;
1091         int bits = 8;
1092         int parity = 'n';
1093         int flow = 'n';
1094
1095         /*
1096          * Check whether an invalid uart number has been specified, and
1097          * if so, search for the first available port that does have
1098          * console support.
1099          */
1100         if (co->index >= UART_NR)
1101                 co->index = 0;
1102         port = &m32r_sio_ports[co->index].port;
1103
1104         /*
1105          * Temporary fix.
1106          */
1107         spin_lock_init(&port->lock);
1108
1109         if (options)
1110                 uart_parse_options(options, &baud, &parity, &bits, &flow);
1111
1112         return uart_set_options(port, co, baud, parity, bits, flow);
1113 }
1114
1115 static struct uart_driver m32r_sio_reg;
1116 static struct console m32r_sio_console = {
1117         .name           = "ttyS",
1118         .write          = m32r_sio_console_write,
1119         .device         = uart_console_device,
1120         .setup          = m32r_sio_console_setup,
1121         .flags          = CON_PRINTBUFFER,
1122         .index          = -1,
1123         .data           = &m32r_sio_reg,
1124 };
1125
1126 static int __init m32r_sio_console_init(void)
1127 {
1128         sio_reset();
1129         sio_init();
1130         m32r_sio_init_ports();
1131         register_console(&m32r_sio_console);
1132         return 0;
1133 }
1134 console_initcall(m32r_sio_console_init);
1135
1136 #define M32R_SIO_CONSOLE        &m32r_sio_console
1137 #else
1138 #define M32R_SIO_CONSOLE        NULL
1139 #endif
1140
1141 static struct uart_driver m32r_sio_reg = {
1142         .owner                  = THIS_MODULE,
1143         .driver_name            = "sio",
1144         .devfs_name             = "tts/",
1145         .dev_name               = "ttyS",
1146         .major                  = TTY_MAJOR,
1147         .minor                  = 64,
1148         .nr                     = UART_NR,
1149         .cons                   = M32R_SIO_CONSOLE,
1150 };
1151
1152 /**
1153  *      m32r_sio_suspend_port - suspend one serial port
1154  *      @line: serial line number
1155  *
1156  *      Suspend one serial port.
1157  */
1158 void m32r_sio_suspend_port(int line)
1159 {
1160         uart_suspend_port(&m32r_sio_reg, &m32r_sio_ports[line].port);
1161 }
1162
1163 /**
1164  *      m32r_sio_resume_port - resume one serial port
1165  *      @line: serial line number
1166  *
1167  *      Resume one serial port.
1168  */
1169 void m32r_sio_resume_port(int line)
1170 {
1171         uart_resume_port(&m32r_sio_reg, &m32r_sio_ports[line].port);
1172 }
1173
1174 static int __init m32r_sio_init(void)
1175 {
1176         int ret, i;
1177
1178         printk(KERN_INFO "Serial: M32R SIO driver $Revision: 1.11 $ ");
1179
1180         for (i = 0; i < NR_IRQS; i++)
1181                 spin_lock_init(&irq_lists[i].lock);
1182
1183         ret = uart_register_driver(&m32r_sio_reg);
1184         if (ret >= 0)
1185                 m32r_sio_register_ports(&m32r_sio_reg);
1186
1187         return ret;
1188 }
1189
1190 static void __exit m32r_sio_exit(void)
1191 {
1192         int i;
1193
1194         for (i = 0; i < UART_NR; i++)
1195                 uart_remove_one_port(&m32r_sio_reg, &m32r_sio_ports[i].port);
1196
1197         uart_unregister_driver(&m32r_sio_reg);
1198 }
1199
1200 module_init(m32r_sio_init);
1201 module_exit(m32r_sio_exit);
1202
1203 EXPORT_SYMBOL(m32r_sio_suspend_port);
1204 EXPORT_SYMBOL(m32r_sio_resume_port);
1205
1206 MODULE_LICENSE("GPL");
1207 MODULE_DESCRIPTION("Generic M32R SIO serial driver $Revision: 1.11 $");