4 * Driver for M32R serial ports
6 * Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
7 * Based on drivers/serial/8250.c.
9 * Copyright (C) 2001 Russell King.
10 * Copyright (C) 2004 Hirokazu Takata <takata at linux-m32r.org>
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.
19 * A note about mapbase / membase
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.
25 * membase is an 'ioremapped' cookie. This is compatible with the old
26 * serial.c driver, and is currently the preferred form.
28 #include <linux/config.h>
30 #if defined(CONFIG_SERIAL_M32R_SIO_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
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>
48 #define PORT_M32R_BASE PORT_M32R_SIO
49 #define PORT_INDEX(x) (x - PORT_M32R_BASE + 1)
50 #define BAUD_RATE 115200
52 #include <linux/serial_core.h>
54 #include "m32r_sio_reg.h"
60 #define DEBUG_AUTOCONF(fmt...) printk(fmt)
62 #define DEBUG_AUTOCONF(fmt...) do { } while (0)
66 #define DEBUG_INTR(fmt...) printk(fmt)
68 #define DEBUG_INTR(fmt...) do { } while (0)
71 #define PASS_LIMIT 256
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.
78 #define is_real_interrupt(irq) ((irq) != 0)
80 #include <asm/serial.h>
82 /* Standard COM flags */
83 #define STD_COM_FLAGS (ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST)
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.
90 #undef SERIAL_PORT_DFNS
91 #if defined(CONFIG_PLAT_USRV)
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 */
98 #else /* !CONFIG_PLAT_USRV */
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 */
105 #define SERIAL_PORT_DFNS \
106 { 0, BASE_BAUD, M32R_SIO_OFFSET, M32R_IRQ_SIO0_R, \
107 STD_COM_FLAGS }, /* ttyS0 */
110 #endif /* !CONFIG_PLAT_USRV */
112 static struct old_serial_port old_serial_port
[] = {
113 SERIAL_PORT_DFNS
/* defined in asm/serial.h */
116 #define UART_NR ARRAY_SIZE(old_serial_port)
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 */
126 unsigned char mcr_mask
; /* mask of user bits */
127 unsigned char mcr_force
; /* mask of forced bits */
128 unsigned char lsr_break_flag
;
131 * We provide a per-port pm hook.
133 void (*pm
)(struct uart_port
*port
,
134 unsigned int state
, unsigned int old
);
139 struct list_head
*head
;
142 static struct irq_info irq_lists
[NR_IRQS
];
145 * Here we define the default xmit fifo size used for each type of UART.
147 static const struct serial_uart_config uart_config
[] = {
150 .dfl_xmit_fifo_size
= 1,
153 [PORT_INDEX(PORT_M32R_SIO
)] = {
155 .dfl_xmit_fifo_size
= 1,
160 #ifdef CONFIG_SERIAL_M32R_PLDSIO
162 #define __sio_in(x) inw((unsigned long)(x))
163 #define __sio_out(v,x) outw((v),(unsigned long)(x))
165 static inline void sio_set_baud_rate(unsigned long baud
)
167 unsigned short sbaud
;
168 sbaud
= (boot_cpu_data
.bus_clock
/ (baud
* 4))-1;
169 __sio_out(sbaud
, PLD_ESIO0BAUR
);
172 static void sio_reset(void)
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
);
184 static void sio_init(void)
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
);
195 static void sio_error(int *status
)
197 printk("SIO0 error[%04x]\n", *status
);
200 } while ((*status
= __sio_in(PLD_ESIO0CR
)) != 3);
203 #else /* not CONFIG_SERIAL_M32R_PLDSIO */
205 #define __sio_in(x) inl(x)
206 #define __sio_out(v,x) outl((v),(x))
208 static inline void sio_set_baud_rate(unsigned long baud
)
212 i
= boot_cpu_data
.bus_clock
/ (baud
* 16);
213 j
= (boot_cpu_data
.bus_clock
- (i
* baud
* 16)) / baud
;
217 __sio_out(i
, M32R_SIO0_BAUR_PORTL
);
218 __sio_out(j
, M32R_SIO0_RBAUR_PORTL
);
221 static void sio_reset(void)
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 */
231 static void sio_init(void)
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
);
241 static void sio_error(int *status
)
243 printk("SIO0 error[%04x]\n", *status
);
246 } while ((*status
= __sio_in(M32R_SIO0_CR_PORTL
)) != 3);
249 #endif /* CONFIG_SERIAL_M32R_PLDSIO */
251 static _INLINE_
unsigned int sio_in(struct uart_sio_port
*up
, int offset
)
253 return __sio_in(up
->port
.iobase
+ offset
);
256 static _INLINE_
void sio_out(struct uart_sio_port
*up
, int offset
, int value
)
258 __sio_out(value
, up
->port
.iobase
+ offset
);
261 static _INLINE_
unsigned int serial_in(struct uart_sio_port
*up
, int offset
)
266 return __sio_in(offset
);
270 serial_out(struct uart_sio_port
*up
, int offset
, int value
)
275 __sio_out(value
, offset
);
278 static void m32r_sio_stop_tx(struct uart_port
*port
)
280 struct uart_sio_port
*up
= (struct uart_sio_port
*)port
;
282 if (up
->ier
& UART_IER_THRI
) {
283 up
->ier
&= ~UART_IER_THRI
;
284 serial_out(up
, UART_IER
, up
->ier
);
288 static void m32r_sio_start_tx(struct uart_port
*port
)
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
;
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
++;
301 while((serial_in(up
, UART_LSR
) & UART_EMPTY
) != UART_EMPTY
);
303 struct uart_sio_port
*up
= (struct uart_sio_port
*)port
;
305 if (!(up
->ier
& UART_IER_THRI
)) {
306 up
->ier
|= UART_IER_THRI
;
307 serial_out(up
, UART_IER
, up
->ier
);
312 static void m32r_sio_stop_rx(struct uart_port
*port
)
314 struct uart_sio_port
*up
= (struct uart_sio_port
*)port
;
316 up
->ier
&= ~UART_IER_RLSI
;
317 up
->port
.read_status_mask
&= ~UART_LSR_DR
;
318 serial_out(up
, UART_IER
, up
->ier
);
321 static void m32r_sio_enable_ms(struct uart_port
*port
)
323 struct uart_sio_port
*up
= (struct uart_sio_port
*)port
;
325 up
->ier
|= UART_IER_MSI
;
326 serial_out(up
, UART_IER
, up
->ier
);
329 static _INLINE_
void receive_chars(struct uart_sio_port
*up
, int *status
,
330 struct pt_regs
*regs
)
332 struct tty_struct
*tty
= up
->port
.info
->tty
;
338 ch
= sio_in(up
, SIORXB
);
340 up
->port
.icount
.rx
++;
342 if (unlikely(*status
& (UART_LSR_BI
| UART_LSR_PE
|
343 UART_LSR_FE
| UART_LSR_OE
))) {
345 * For statistics only
347 if (*status
& UART_LSR_BI
) {
348 *status
&= ~(UART_LSR_FE
| UART_LSR_PE
);
349 up
->port
.icount
.brk
++;
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.
356 if (uart_handle_break(&up
->port
))
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
++;
366 * Mask off conditions which should be ingored.
368 *status
&= up
->port
.read_status_mask
;
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;
376 if (*status
& UART_LSR_BI
) {
377 DEBUG_INTR("handling break....");
379 } else if (*status
& UART_LSR_PE
)
381 else if (*status
& UART_LSR_FE
)
384 if (uart_handle_sysrq_char(&up
->port
, ch
, regs
))
386 if ((*status
& up
->port
.ignore_status_mask
) == 0)
387 tty_insert_flip_char(tty
, ch
, flag
);
389 if (*status
& UART_LSR_OE
) {
391 * Overrun is special, since it's reported
392 * immediately, and doesn't affect the current
395 tty_insert_flip_char(tty
, 0, TTY_OVERRUN
);
398 *status
= serial_in(up
, UART_LSR
);
399 } while ((*status
& UART_LSR_DR
) && (max_count
-- > 0));
400 tty_flip_buffer_push(tty
);
403 static _INLINE_
void transmit_chars(struct uart_sio_port
*up
)
405 struct circ_buf
*xmit
= &up
->port
.info
->xmit
;
408 if (up
->port
.x_char
) {
409 #ifndef CONFIG_SERIAL_M32R_PLDSIO /* XXX */
410 serial_out(up
, UART_TX
, up
->port
.x_char
);
412 up
->port
.icount
.tx
++;
416 if (uart_circ_empty(xmit
) || uart_tx_stopped(&up
->port
)) {
417 m32r_sio_stop_tx(&up
->port
);
421 count
= up
->port
.fifosize
;
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
))
428 while (!serial_in(up
, UART_LSR
) & UART_LSR_THRE
);
430 } while (--count
> 0);
432 if (uart_circ_chars_pending(xmit
) < WAKEUP_CHARS
)
433 uart_write_wakeup(&up
->port
);
435 DEBUG_INTR("THRE...");
437 if (uart_circ_empty(xmit
))
438 m32r_sio_stop_tx(&up
->port
);
442 * This handles the interrupt from one port.
444 static inline void m32r_sio_handle_port(struct uart_sio_port
*up
,
445 unsigned int status
, struct pt_regs
*regs
)
447 DEBUG_INTR("status = %x...", status
);
450 receive_chars(up
, &status
, regs
);
456 * This is the serial driver's interrupt routine.
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.)
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.
466 * This means we need to loop through all ports. checking that they
467 * don't have an interrupt pending.
469 static irqreturn_t
m32r_sio_interrupt(int irq
, void *dev_id
,
470 struct pt_regs
*regs
)
472 struct irq_info
*i
= dev_id
;
473 struct list_head
*l
, *end
= NULL
;
474 int pass_counter
= 0;
476 DEBUG_INTR("m32r_sio_interrupt(%d)...", irq
);
478 #ifdef CONFIG_SERIAL_M32R_PLDSIO
479 // if (irq == PLD_IRQ_SIO0_SND)
480 // irq = PLD_IRQ_SIO0_RCV;
482 if (irq
== M32R_IRQ_SIO0_S
)
483 irq
= M32R_IRQ_SIO0_R
;
490 struct uart_sio_port
*up
;
493 up
= list_entry(l
, struct uart_sio_port
, list
);
495 sts
= sio_in(up
, SIOSTS
);
497 spin_lock(&up
->port
.lock
);
498 m32r_sio_handle_port(up
, sts
, regs
);
499 spin_unlock(&up
->port
.lock
);
502 } else if (end
== NULL
)
507 if (l
== i
->head
&& pass_counter
++ > PASS_LIMIT
) {
514 spin_unlock(&i
->lock
);
516 DEBUG_INTR("end.\n");
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.
528 static void serial_do_unlink(struct irq_info
*i
, struct uart_sio_port
*up
)
530 spin_lock_irq(&i
->lock
);
532 if (!list_empty(i
->head
)) {
533 if (i
->head
== &up
->list
)
534 i
->head
= i
->head
->next
;
537 BUG_ON(i
->head
!= &up
->list
);
541 spin_unlock_irq(&i
->lock
);
544 static int serial_link_irq_chain(struct uart_sio_port
*up
)
546 struct irq_info
*i
= irq_lists
+ up
->port
.irq
;
547 int ret
, irq_flags
= up
->port
.flags
& UPF_SHARE_IRQ
? SA_SHIRQ
: 0;
549 spin_lock_irq(&i
->lock
);
552 list_add(&up
->list
, i
->head
);
553 spin_unlock_irq(&i
->lock
);
557 INIT_LIST_HEAD(&up
->list
);
559 spin_unlock_irq(&i
->lock
);
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
);
566 serial_do_unlink(i
, up
);
572 static void serial_unlink_irq_chain(struct uart_sio_port
*up
)
574 struct irq_info
*i
= irq_lists
+ up
->port
.irq
;
576 BUG_ON(i
->head
== NULL
);
578 if (list_empty(i
->head
)) {
579 free_irq(up
->port
.irq
, i
);
580 free_irq(up
->port
.irq
+ 1, i
);
583 serial_do_unlink(i
, up
);
587 * This function is used to handle ports that do not have an interrupt.
589 static void m32r_sio_timeout(unsigned long data
)
591 struct uart_sio_port
*up
= (struct uart_sio_port
*)data
;
592 unsigned int timeout
;
595 sts
= sio_in(up
, SIOSTS
);
597 spin_lock(&up
->port
.lock
);
598 m32r_sio_handle_port(up
, sts
, NULL
);
599 spin_unlock(&up
->port
.lock
);
602 timeout
= up
->port
.timeout
;
603 timeout
= timeout
> 6 ? (timeout
/ 2 - 2) : 1;
604 mod_timer(&up
->timer
, jiffies
+ timeout
);
607 static unsigned int m32r_sio_tx_empty(struct uart_port
*port
)
609 struct uart_sio_port
*up
= (struct uart_sio_port
*)port
;
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
);
620 static unsigned int m32r_sio_get_mctrl(struct uart_port
*port
)
625 static void m32r_sio_set_mctrl(struct uart_port
*port
, unsigned int mctrl
)
630 static void m32r_sio_break_ctl(struct uart_port
*port
, int break_state
)
635 static int m32r_sio_startup(struct uart_port
*port
)
637 struct uart_sio_port
*up
= (struct uart_sio_port
*)port
;
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.
647 if (!is_real_interrupt(up
->port
.irq
)) {
648 unsigned int timeout
= up
->port
.timeout
;
650 timeout
= timeout
> 6 ? (timeout
/ 2 - 2) : 1;
652 up
->timer
.data
= (unsigned long)up
;
653 mod_timer(&up
->timer
, jiffies
+ timeout
);
655 retval
= serial_link_irq_chain(up
);
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.
665 * - M32R_PLDSIO: 0x04
667 up
->ier
= UART_IER_MSI
| UART_IER_RLSI
| UART_IER_RDI
;
668 sio_out(up
, SIOTRCR
, up
->ier
);
671 * And clear the interrupt registers again for luck.
678 static void m32r_sio_shutdown(struct uart_port
*port
)
680 struct uart_sio_port
*up
= (struct uart_sio_port
*)port
;
683 * Disable interrupts from this port
686 sio_out(up
, SIOTRCR
, 0);
689 * Disable break condition and FIFOs
694 if (!is_real_interrupt(up
->port
.irq
))
695 del_timer_sync(&up
->timer
);
697 serial_unlink_irq_chain(up
);
700 static unsigned int m32r_sio_get_divisor(struct uart_port
*port
,
703 return uart_get_divisor(port
, baud
);
706 static void m32r_sio_set_termios(struct uart_port
*port
,
707 struct termios
*termios
, struct termios
*old
)
709 struct uart_sio_port
*up
= (struct uart_sio_port
*)port
;
710 unsigned char cval
= 0;
712 unsigned int baud
, quot
;
714 switch (termios
->c_cflag
& CSIZE
) {
716 cval
= UART_LCR_WLEN5
;
719 cval
= UART_LCR_WLEN6
;
722 cval
= UART_LCR_WLEN7
;
726 cval
= UART_LCR_WLEN8
;
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
;
737 if (termios
->c_cflag
& CMSPAR
)
738 cval
|= UART_LCR_SPAR
;
742 * Ask the core to calculate the divisor for us.
744 #ifdef CONFIG_SERIAL_M32R_PLDSIO
745 baud
= uart_get_baud_rate(port
, termios
, old
, 0, port
->uartclk
/4);
747 baud
= uart_get_baud_rate(port
, termios
, old
, 0, port
->uartclk
/16);
749 quot
= m32r_sio_get_divisor(port
, baud
);
752 * Ok, we're now changing the port state. Do it with
753 * interrupts disabled.
755 spin_lock_irqsave(&up
->port
.lock
, flags
);
757 sio_set_baud_rate(baud
);
760 * Update the per-port timeout.
762 uart_update_timeout(port
, termios
->c_cflag
, baud
);
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
;
771 * Characteres to ignore
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
;
779 * If we're ignoring parity and break indicators,
780 * ignore overruns too (for real raw support).
782 if (termios
->c_iflag
& IGNPAR
)
783 up
->port
.ignore_status_mask
|= UART_LSR_OE
;
787 * ignore all characters if CREAD is not set
789 if ((termios
->c_cflag
& CREAD
) == 0)
790 up
->port
.ignore_status_mask
|= UART_LSR_DR
;
793 * CTS flow control flag and modem status interrupts
795 up
->ier
&= ~UART_IER_MSI
;
796 if (UART_ENABLE_MS(&up
->port
, termios
->c_cflag
))
797 up
->ier
|= UART_IER_MSI
;
799 serial_out(up
, UART_IER
, up
->ier
);
801 up
->lcr
= cval
; /* Save LCR */
802 spin_unlock_irqrestore(&up
->port
.lock
, flags
);
805 static void m32r_sio_pm(struct uart_port
*port
, unsigned int state
,
806 unsigned int oldstate
)
808 struct uart_sio_port
*up
= (struct uart_sio_port
*)port
;
811 up
->pm(port
, state
, oldstate
);
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?
820 m32r_sio_request_std_resource(struct uart_sio_port
*up
, struct resource
**res
)
822 unsigned int size
= 8 << up
->port
.regshift
;
823 #ifndef CONFIG_SERIAL_M32R_PLDSIO
828 switch (up
->port
.iotype
) {
830 if (up
->port
.mapbase
) {
831 #ifdef CONFIG_SERIAL_M32R_PLDSIO
832 *res
= request_mem_region(up
->port
.mapbase
, size
, "serial");
834 start
= up
->port
.mapbase
;
835 *res
= request_mem_region(start
, size
, "serial");
843 *res
= request_region(up
->port
.iobase
, size
, "serial");
851 static void m32r_sio_release_port(struct uart_port
*port
)
853 struct uart_sio_port
*up
= (struct uart_sio_port
*)port
;
854 unsigned long start
, offset
= 0, size
= 0;
856 size
<<= up
->port
.regshift
;
858 switch (up
->port
.iotype
) {
860 if (up
->port
.mapbase
) {
864 iounmap(up
->port
.membase
);
865 up
->port
.membase
= NULL
;
867 start
= up
->port
.mapbase
;
870 release_mem_region(start
+ offset
, size
);
871 release_mem_region(start
, 8 << up
->port
.regshift
);
876 start
= up
->port
.iobase
;
879 release_region(start
+ offset
, size
);
880 release_region(start
+ offset
, 8 << up
->port
.regshift
);
888 static int m32r_sio_request_port(struct uart_port
*port
)
890 struct uart_sio_port
*up
= (struct uart_sio_port
*)port
;
891 struct resource
*res
= NULL
;
894 ret
= m32r_sio_request_std_resource(up
, &res
);
897 * If we have a mapbase, then request that as well.
899 if (ret
== 0 && up
->port
.flags
& UPF_IOREMAP
) {
900 int size
= res
->end
- res
->start
+ 1;
902 up
->port
.membase
= ioremap(up
->port
.mapbase
, size
);
903 if (!up
->port
.membase
)
909 release_resource(res
);
915 static void m32r_sio_config_port(struct uart_port
*port
, int flags
)
917 struct uart_sio_port
*up
= (struct uart_sio_port
*)port
;
919 spin_lock_irqsave(&up
->port
.lock
, flags
);
921 up
->port
.type
= (PORT_M32R_SIO
- PORT_M32R_BASE
+ 1);
922 up
->port
.fifosize
= uart_config
[up
->port
.type
].dfl_xmit_fifo_size
;
924 spin_unlock_irqrestore(&up
->port
.lock
, flags
);
928 m32r_sio_verify_port(struct uart_port
*port
, struct serial_struct
*ser
)
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
))
938 m32r_sio_type(struct uart_port
*port
)
940 int type
= port
->type
;
942 if (type
>= ARRAY_SIZE(uart_config
))
944 return uart_config
[type
].name
;
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
,
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
,
967 static struct uart_sio_port m32r_sio_ports
[UART_NR
];
969 static void __init
m32r_sio_init_ports(void)
971 struct uart_sio_port
*up
;
972 static int first
= 1;
979 for (i
= 0, up
= m32r_sio_ports
; i
< ARRAY_SIZE(old_serial_port
);
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
;
992 static void __init
m32r_sio_register_ports(struct uart_driver
*drv
)
996 m32r_sio_init_ports();
998 for (i
= 0; i
< UART_NR
; i
++) {
999 struct uart_sio_port
*up
= &m32r_sio_ports
[i
];
1002 up
->port
.ops
= &m32r_sio_pops
;
1003 init_timer(&up
->timer
);
1004 up
->timer
.function
= m32r_sio_timeout
;
1007 * ALPHA_KLUDGE_MCR needs to be killed.
1009 up
->mcr_mask
= ~ALPHA_KLUDGE_MCR
;
1010 up
->mcr_force
= ALPHA_KLUDGE_MCR
;
1012 uart_add_one_port(drv
, &up
->port
);
1016 #ifdef CONFIG_SERIAL_M32R_SIO_CONSOLE
1019 * Wait for transmitter & holding register to empty
1021 static inline void wait_for_xmitr(struct uart_sio_port
*up
)
1023 unsigned int status
, tmout
= 10000;
1025 /* Wait up to 10ms for the character(s) to be sent. */
1027 status
= sio_in(up
, SIOSTS
);
1032 } while ((status
& UART_EMPTY
) != UART_EMPTY
);
1034 /* Wait up to 1s for flow control if necessary */
1035 if (up
->port
.flags
& UPF_CONS_FLOW
) {
1043 * Print a string to the serial port trying not to disturb
1044 * any possible real use of the port...
1046 * The console_lock must be held when we get here.
1048 static void m32r_sio_console_write(struct console
*co
, const char *s
,
1051 struct uart_sio_port
*up
= &m32r_sio_ports
[co
->index
];
1056 * First save the UER then disable the interrupts
1058 ier
= sio_in(up
, SIOTRCR
);
1059 sio_out(up
, SIOTRCR
, 0);
1062 * Now, do each character
1064 for (i
= 0; i
< count
; i
++, s
++) {
1068 * Send the character out.
1069 * If a LF, also do CR...
1071 sio_out(up
, SIOTXB
, *s
);
1075 sio_out(up
, SIOTXB
, 13);
1080 * Finally, wait for transmitter to become empty
1081 * and restore the IER
1084 sio_out(up
, SIOTRCR
, ier
);
1087 static int __init
m32r_sio_console_setup(struct console
*co
, char *options
)
1089 struct uart_port
*port
;
1096 * Check whether an invalid uart number has been specified, and
1097 * if so, search for the first available port that does have
1100 if (co
->index
>= UART_NR
)
1102 port
= &m32r_sio_ports
[co
->index
].port
;
1107 spin_lock_init(&port
->lock
);
1110 uart_parse_options(options
, &baud
, &parity
, &bits
, &flow
);
1112 return uart_set_options(port
, co
, baud
, parity
, bits
, flow
);
1115 static struct uart_driver m32r_sio_reg
;
1116 static struct console m32r_sio_console
= {
1118 .write
= m32r_sio_console_write
,
1119 .device
= uart_console_device
,
1120 .setup
= m32r_sio_console_setup
,
1121 .flags
= CON_PRINTBUFFER
,
1123 .data
= &m32r_sio_reg
,
1126 static int __init
m32r_sio_console_init(void)
1130 m32r_sio_init_ports();
1131 register_console(&m32r_sio_console
);
1134 console_initcall(m32r_sio_console_init
);
1136 #define M32R_SIO_CONSOLE &m32r_sio_console
1138 #define M32R_SIO_CONSOLE NULL
1141 static struct uart_driver m32r_sio_reg
= {
1142 .owner
= THIS_MODULE
,
1143 .driver_name
= "sio",
1144 .devfs_name
= "tts/",
1149 .cons
= M32R_SIO_CONSOLE
,
1153 * m32r_sio_suspend_port - suspend one serial port
1154 * @line: serial line number
1156 * Suspend one serial port.
1158 void m32r_sio_suspend_port(int line
)
1160 uart_suspend_port(&m32r_sio_reg
, &m32r_sio_ports
[line
].port
);
1164 * m32r_sio_resume_port - resume one serial port
1165 * @line: serial line number
1167 * Resume one serial port.
1169 void m32r_sio_resume_port(int line
)
1171 uart_resume_port(&m32r_sio_reg
, &m32r_sio_ports
[line
].port
);
1174 static int __init
m32r_sio_init(void)
1178 printk(KERN_INFO
"Serial: M32R SIO driver $Revision: 1.11 $ ");
1180 for (i
= 0; i
< NR_IRQS
; i
++)
1181 spin_lock_init(&irq_lists
[i
].lock
);
1183 ret
= uart_register_driver(&m32r_sio_reg
);
1185 m32r_sio_register_ports(&m32r_sio_reg
);
1190 static void __exit
m32r_sio_exit(void)
1194 for (i
= 0; i
< UART_NR
; i
++)
1195 uart_remove_one_port(&m32r_sio_reg
, &m32r_sio_ports
[i
].port
);
1197 uart_unregister_driver(&m32r_sio_reg
);
1200 module_init(m32r_sio_init
);
1201 module_exit(m32r_sio_exit
);
1203 EXPORT_SYMBOL(m32r_sio_suspend_port
);
1204 EXPORT_SYMBOL(m32r_sio_resume_port
);
1206 MODULE_LICENSE("GPL");
1207 MODULE_DESCRIPTION("Generic M32R SIO serial driver $Revision: 1.11 $");