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