2 * su.c: Small serial driver for keyboard/mouse interface on sparc32/PCI
4 * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
5 * Copyright (C) 1998-1999 Pete Zaitcev (zaitcev@yahoo.com)
7 * This is mainly a variation of 8250.c, credits go to authors mentioned
8 * therein. In fact this driver should be merged into the generic 8250.c
9 * infrastructure perhaps using a 8250_sparc.c module.
11 * Fixed to use tty_get_baud_rate().
12 * Theodore Ts'o <tytso@mit.edu>, 2001-Oct-12
14 * Converted to new 2.5.x UART layer.
15 * David S. Miller (davem@davemloft.net), 2002-Jul-29
18 #include <linux/module.h>
19 #include <linux/kernel.h>
20 #include <linux/spinlock.h>
21 #include <linux/errno.h>
22 #include <linux/tty.h>
23 #include <linux/tty_flip.h>
24 #include <linux/major.h>
25 #include <linux/string.h>
26 #include <linux/ptrace.h>
27 #include <linux/ioport.h>
28 #include <linux/circ_buf.h>
29 #include <linux/serial.h>
30 #include <linux/sysrq.h>
31 #include <linux/console.h>
32 #include <linux/slab.h>
34 #include <linux/serio.h>
36 #include <linux/serial_reg.h>
37 #include <linux/init.h>
38 #include <linux/delay.h>
39 #include <linux/of_device.h>
44 #include <asm/setup.h>
46 #if defined(CONFIG_SERIAL_SUNSU_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
50 #include <linux/serial_core.h>
51 #include <linux/sunserialcore.h>
53 /* We are on a NS PC87303 clocked with 24.0 MHz, which results
54 * in a UART clock of 1.8462 MHz.
56 #define SU_BASE_BAUD (1846200 / 16)
58 enum su_type
{ SU_PORT_NONE
, SU_PORT_MS
, SU_PORT_KBD
, SU_PORT_PORT
};
59 static char *su_typev
[] = { "su(???)", "su(mouse)", "su(kbd)", "su(serial)" };
61 struct serial_uart_config
{
63 int dfl_xmit_fifo_size
;
68 * Here we define the default xmit fifo size used for each type of UART.
70 static const struct serial_uart_config uart_config
[] = {
75 { "16550A", 16, UART_CLEAR_FIFO
| UART_USE_FIFO
},
77 { "ST16650", 1, UART_CLEAR_FIFO
| UART_STARTECH
},
78 { "ST16650V2", 32, UART_CLEAR_FIFO
| UART_USE_FIFO
| UART_STARTECH
},
79 { "TI16750", 64, UART_CLEAR_FIFO
| UART_USE_FIFO
},
81 { "16C950/954", 128, UART_CLEAR_FIFO
| UART_USE_FIFO
},
82 { "ST16654", 64, UART_CLEAR_FIFO
| UART_USE_FIFO
| UART_STARTECH
},
83 { "XR16850", 128, UART_CLEAR_FIFO
| UART_USE_FIFO
| UART_STARTECH
},
84 { "RSA", 2048, UART_CLEAR_FIFO
| UART_USE_FIFO
}
87 struct uart_sunsu_port
{
88 struct uart_port port
;
93 unsigned int lsr_break_flag
;
96 /* Probing information. */
98 unsigned int type_probed
; /* XXX Stupid */
99 unsigned long reg_size
;
107 static unsigned int serial_in(struct uart_sunsu_port
*up
, int offset
)
109 offset
<<= up
->port
.regshift
;
111 switch (up
->port
.iotype
) {
113 outb(up
->port
.hub6
- 1 + offset
, up
->port
.iobase
);
114 return inb(up
->port
.iobase
+ 1);
117 return readb(up
->port
.membase
+ offset
);
120 return inb(up
->port
.iobase
+ offset
);
124 static void serial_out(struct uart_sunsu_port
*up
, int offset
, int value
)
126 #ifndef CONFIG_SPARC64
128 * MrCoffee has weird schematics: IRQ4 & P10(?) pins of SuperIO are
129 * connected with a gate then go to SlavIO. When IRQ4 goes tristated
130 * gate outputs a logical one. Since we use level triggered interrupts
131 * we have lockup and watchdog reset. We cannot mask IRQ because
132 * keyboard shares IRQ with us (Word has it as Bob Smelik's design).
133 * This problem is similar to what Alpha people suffer, see serial.c.
135 if (offset
== UART_MCR
)
136 value
|= UART_MCR_OUT2
;
138 offset
<<= up
->port
.regshift
;
140 switch (up
->port
.iotype
) {
142 outb(up
->port
.hub6
- 1 + offset
, up
->port
.iobase
);
143 outb(value
, up
->port
.iobase
+ 1);
147 writeb(value
, up
->port
.membase
+ offset
);
151 outb(value
, up
->port
.iobase
+ offset
);
156 * We used to support using pause I/O for certain machines. We
157 * haven't supported this for a while, but just in case it's badly
158 * needed for certain old 386 machines, I've left these #define's
161 #define serial_inp(up, offset) serial_in(up, offset)
162 #define serial_outp(up, offset, value) serial_out(up, offset, value)
168 static void serial_icr_write(struct uart_sunsu_port
*up
, int offset
, int value
)
170 serial_out(up
, UART_SCR
, offset
);
171 serial_out(up
, UART_ICR
, value
);
174 #if 0 /* Unused currently */
175 static unsigned int serial_icr_read(struct uart_sunsu_port
*up
, int offset
)
179 serial_icr_write(up
, UART_ACR
, up
->acr
| UART_ACR_ICRRD
);
180 serial_out(up
, UART_SCR
, offset
);
181 value
= serial_in(up
, UART_ICR
);
182 serial_icr_write(up
, UART_ACR
, up
->acr
);
188 #ifdef CONFIG_SERIAL_8250_RSA
190 * Attempts to turn on the RSA FIFO. Returns zero on failure.
191 * We set the port uart clock rate if we succeed.
193 static int __enable_rsa(struct uart_sunsu_port
*up
)
198 mode
= serial_inp(up
, UART_RSA_MSR
);
199 result
= mode
& UART_RSA_MSR_FIFO
;
202 serial_outp(up
, UART_RSA_MSR
, mode
| UART_RSA_MSR_FIFO
);
203 mode
= serial_inp(up
, UART_RSA_MSR
);
204 result
= mode
& UART_RSA_MSR_FIFO
;
208 up
->port
.uartclk
= SERIAL_RSA_BAUD_BASE
* 16;
213 static void enable_rsa(struct uart_sunsu_port
*up
)
215 if (up
->port
.type
== PORT_RSA
) {
216 if (up
->port
.uartclk
!= SERIAL_RSA_BAUD_BASE
* 16) {
217 spin_lock_irq(&up
->port
.lock
);
219 spin_unlock_irq(&up
->port
.lock
);
221 if (up
->port
.uartclk
== SERIAL_RSA_BAUD_BASE
* 16)
222 serial_outp(up
, UART_RSA_FRR
, 0);
227 * Attempts to turn off the RSA FIFO. Returns zero on failure.
228 * It is unknown why interrupts were disabled in here. However,
229 * the caller is expected to preserve this behaviour by grabbing
230 * the spinlock before calling this function.
232 static void disable_rsa(struct uart_sunsu_port
*up
)
237 if (up
->port
.type
== PORT_RSA
&&
238 up
->port
.uartclk
== SERIAL_RSA_BAUD_BASE
* 16) {
239 spin_lock_irq(&up
->port
.lock
);
241 mode
= serial_inp(up
, UART_RSA_MSR
);
242 result
= !(mode
& UART_RSA_MSR_FIFO
);
245 serial_outp(up
, UART_RSA_MSR
, mode
& ~UART_RSA_MSR_FIFO
);
246 mode
= serial_inp(up
, UART_RSA_MSR
);
247 result
= !(mode
& UART_RSA_MSR_FIFO
);
251 up
->port
.uartclk
= SERIAL_RSA_BAUD_BASE_LO
* 16;
252 spin_unlock_irq(&up
->port
.lock
);
255 #endif /* CONFIG_SERIAL_8250_RSA */
257 static inline void __stop_tx(struct uart_sunsu_port
*p
)
259 if (p
->ier
& UART_IER_THRI
) {
260 p
->ier
&= ~UART_IER_THRI
;
261 serial_out(p
, UART_IER
, p
->ier
);
265 static void sunsu_stop_tx(struct uart_port
*port
)
267 struct uart_sunsu_port
*up
= (struct uart_sunsu_port
*) port
;
272 * We really want to stop the transmitter from sending.
274 if (up
->port
.type
== PORT_16C950
) {
275 up
->acr
|= UART_ACR_TXDIS
;
276 serial_icr_write(up
, UART_ACR
, up
->acr
);
280 static void sunsu_start_tx(struct uart_port
*port
)
282 struct uart_sunsu_port
*up
= (struct uart_sunsu_port
*) port
;
284 if (!(up
->ier
& UART_IER_THRI
)) {
285 up
->ier
|= UART_IER_THRI
;
286 serial_out(up
, UART_IER
, up
->ier
);
290 * Re-enable the transmitter if we disabled it.
292 if (up
->port
.type
== PORT_16C950
&& up
->acr
& UART_ACR_TXDIS
) {
293 up
->acr
&= ~UART_ACR_TXDIS
;
294 serial_icr_write(up
, UART_ACR
, up
->acr
);
298 static void sunsu_stop_rx(struct uart_port
*port
)
300 struct uart_sunsu_port
*up
= (struct uart_sunsu_port
*) port
;
302 up
->ier
&= ~UART_IER_RLSI
;
303 up
->port
.read_status_mask
&= ~UART_LSR_DR
;
304 serial_out(up
, UART_IER
, up
->ier
);
307 static void sunsu_enable_ms(struct uart_port
*port
)
309 struct uart_sunsu_port
*up
= (struct uart_sunsu_port
*) port
;
312 spin_lock_irqsave(&up
->port
.lock
, flags
);
313 up
->ier
|= UART_IER_MSI
;
314 serial_out(up
, UART_IER
, up
->ier
);
315 spin_unlock_irqrestore(&up
->port
.lock
, flags
);
318 static struct tty_struct
*
319 receive_chars(struct uart_sunsu_port
*up
, unsigned char *status
)
321 struct tty_struct
*tty
= up
->port
.state
->port
.tty
;
322 unsigned char ch
, flag
;
324 int saw_console_brk
= 0;
327 ch
= serial_inp(up
, UART_RX
);
329 up
->port
.icount
.rx
++;
331 if (unlikely(*status
& (UART_LSR_BI
| UART_LSR_PE
|
332 UART_LSR_FE
| UART_LSR_OE
))) {
334 * For statistics only
336 if (*status
& UART_LSR_BI
) {
337 *status
&= ~(UART_LSR_FE
| UART_LSR_PE
);
338 up
->port
.icount
.brk
++;
339 if (up
->port
.cons
!= NULL
&&
340 up
->port
.line
== up
->port
.cons
->index
)
343 * We do the SysRQ and SAK checking
344 * here because otherwise the break
345 * may get masked by ignore_status_mask
346 * or read_status_mask.
348 if (uart_handle_break(&up
->port
))
350 } else if (*status
& UART_LSR_PE
)
351 up
->port
.icount
.parity
++;
352 else if (*status
& UART_LSR_FE
)
353 up
->port
.icount
.frame
++;
354 if (*status
& UART_LSR_OE
)
355 up
->port
.icount
.overrun
++;
358 * Mask off conditions which should be ingored.
360 *status
&= up
->port
.read_status_mask
;
362 if (up
->port
.cons
!= NULL
&&
363 up
->port
.line
== up
->port
.cons
->index
) {
364 /* Recover the break flag from console xmit */
365 *status
|= up
->lsr_break_flag
;
366 up
->lsr_break_flag
= 0;
369 if (*status
& UART_LSR_BI
) {
371 } else if (*status
& UART_LSR_PE
)
373 else if (*status
& UART_LSR_FE
)
376 if (uart_handle_sysrq_char(&up
->port
, ch
))
378 if ((*status
& up
->port
.ignore_status_mask
) == 0)
379 tty_insert_flip_char(tty
, ch
, flag
);
380 if (*status
& UART_LSR_OE
)
382 * Overrun is special, since it's reported
383 * immediately, and doesn't affect the current
386 tty_insert_flip_char(tty
, 0, TTY_OVERRUN
);
388 *status
= serial_inp(up
, UART_LSR
);
389 } while ((*status
& UART_LSR_DR
) && (max_count
-- > 0));
397 static void transmit_chars(struct uart_sunsu_port
*up
)
399 struct circ_buf
*xmit
= &up
->port
.state
->xmit
;
402 if (up
->port
.x_char
) {
403 serial_outp(up
, UART_TX
, up
->port
.x_char
);
404 up
->port
.icount
.tx
++;
408 if (uart_tx_stopped(&up
->port
)) {
409 sunsu_stop_tx(&up
->port
);
412 if (uart_circ_empty(xmit
)) {
417 count
= up
->port
.fifosize
;
419 serial_out(up
, UART_TX
, xmit
->buf
[xmit
->tail
]);
420 xmit
->tail
= (xmit
->tail
+ 1) & (UART_XMIT_SIZE
- 1);
421 up
->port
.icount
.tx
++;
422 if (uart_circ_empty(xmit
))
424 } while (--count
> 0);
426 if (uart_circ_chars_pending(xmit
) < WAKEUP_CHARS
)
427 uart_write_wakeup(&up
->port
);
429 if (uart_circ_empty(xmit
))
433 static void check_modem_status(struct uart_sunsu_port
*up
)
437 status
= serial_in(up
, UART_MSR
);
439 if ((status
& UART_MSR_ANY_DELTA
) == 0)
442 if (status
& UART_MSR_TERI
)
443 up
->port
.icount
.rng
++;
444 if (status
& UART_MSR_DDSR
)
445 up
->port
.icount
.dsr
++;
446 if (status
& UART_MSR_DDCD
)
447 uart_handle_dcd_change(&up
->port
, status
& UART_MSR_DCD
);
448 if (status
& UART_MSR_DCTS
)
449 uart_handle_cts_change(&up
->port
, status
& UART_MSR_CTS
);
451 wake_up_interruptible(&up
->port
.state
->port
.delta_msr_wait
);
454 static irqreturn_t
sunsu_serial_interrupt(int irq
, void *dev_id
)
456 struct uart_sunsu_port
*up
= dev_id
;
458 unsigned char status
;
460 spin_lock_irqsave(&up
->port
.lock
, flags
);
463 struct tty_struct
*tty
;
465 status
= serial_inp(up
, UART_LSR
);
467 if (status
& UART_LSR_DR
)
468 tty
= receive_chars(up
, &status
);
469 check_modem_status(up
);
470 if (status
& UART_LSR_THRE
)
473 spin_unlock_irqrestore(&up
->port
.lock
, flags
);
476 tty_flip_buffer_push(tty
);
478 spin_lock_irqsave(&up
->port
.lock
, flags
);
480 } while (!(serial_in(up
, UART_IIR
) & UART_IIR_NO_INT
));
482 spin_unlock_irqrestore(&up
->port
.lock
, flags
);
487 /* Separate interrupt handling path for keyboard/mouse ports. */
490 sunsu_change_speed(struct uart_port
*port
, unsigned int cflag
,
491 unsigned int iflag
, unsigned int quot
);
493 static void sunsu_change_mouse_baud(struct uart_sunsu_port
*up
)
495 unsigned int cur_cflag
= up
->cflag
;
499 up
->cflag
|= suncore_mouse_baud_cflag_next(cur_cflag
, &new_baud
);
501 quot
= up
->port
.uartclk
/ (16 * new_baud
);
503 sunsu_change_speed(&up
->port
, up
->cflag
, 0, quot
);
506 static void receive_kbd_ms_chars(struct uart_sunsu_port
*up
, int is_break
)
509 unsigned char ch
= serial_inp(up
, UART_RX
);
511 /* Stop-A is handled by drivers/char/keyboard.c now. */
512 if (up
->su_type
== SU_PORT_KBD
) {
514 serio_interrupt(&up
->serio
, ch
, 0);
516 } else if (up
->su_type
== SU_PORT_MS
) {
517 int ret
= suncore_mouse_baud_detection(ch
, is_break
);
521 sunsu_change_mouse_baud(up
);
528 serio_interrupt(&up
->serio
, ch
, 0);
533 } while (serial_in(up
, UART_LSR
) & UART_LSR_DR
);
536 static irqreturn_t
sunsu_kbd_ms_interrupt(int irq
, void *dev_id
)
538 struct uart_sunsu_port
*up
= dev_id
;
540 if (!(serial_in(up
, UART_IIR
) & UART_IIR_NO_INT
)) {
541 unsigned char status
= serial_inp(up
, UART_LSR
);
543 if ((status
& UART_LSR_DR
) || (status
& UART_LSR_BI
))
544 receive_kbd_ms_chars(up
, (status
& UART_LSR_BI
) != 0);
550 static unsigned int sunsu_tx_empty(struct uart_port
*port
)
552 struct uart_sunsu_port
*up
= (struct uart_sunsu_port
*) port
;
556 spin_lock_irqsave(&up
->port
.lock
, flags
);
557 ret
= serial_in(up
, UART_LSR
) & UART_LSR_TEMT
? TIOCSER_TEMT
: 0;
558 spin_unlock_irqrestore(&up
->port
.lock
, flags
);
563 static unsigned int sunsu_get_mctrl(struct uart_port
*port
)
565 struct uart_sunsu_port
*up
= (struct uart_sunsu_port
*) port
;
566 unsigned char status
;
569 status
= serial_in(up
, UART_MSR
);
572 if (status
& UART_MSR_DCD
)
574 if (status
& UART_MSR_RI
)
576 if (status
& UART_MSR_DSR
)
578 if (status
& UART_MSR_CTS
)
583 static void sunsu_set_mctrl(struct uart_port
*port
, unsigned int mctrl
)
585 struct uart_sunsu_port
*up
= (struct uart_sunsu_port
*) port
;
586 unsigned char mcr
= 0;
588 if (mctrl
& TIOCM_RTS
)
590 if (mctrl
& TIOCM_DTR
)
592 if (mctrl
& TIOCM_OUT1
)
593 mcr
|= UART_MCR_OUT1
;
594 if (mctrl
& TIOCM_OUT2
)
595 mcr
|= UART_MCR_OUT2
;
596 if (mctrl
& TIOCM_LOOP
)
597 mcr
|= UART_MCR_LOOP
;
599 serial_out(up
, UART_MCR
, mcr
);
602 static void sunsu_break_ctl(struct uart_port
*port
, int break_state
)
604 struct uart_sunsu_port
*up
= (struct uart_sunsu_port
*) port
;
607 spin_lock_irqsave(&up
->port
.lock
, flags
);
608 if (break_state
== -1)
609 up
->lcr
|= UART_LCR_SBC
;
611 up
->lcr
&= ~UART_LCR_SBC
;
612 serial_out(up
, UART_LCR
, up
->lcr
);
613 spin_unlock_irqrestore(&up
->port
.lock
, flags
);
616 static int sunsu_startup(struct uart_port
*port
)
618 struct uart_sunsu_port
*up
= (struct uart_sunsu_port
*) port
;
622 if (up
->port
.type
== PORT_16C950
) {
623 /* Wake up and initialize UART */
625 serial_outp(up
, UART_LCR
, 0xBF);
626 serial_outp(up
, UART_EFR
, UART_EFR_ECB
);
627 serial_outp(up
, UART_IER
, 0);
628 serial_outp(up
, UART_LCR
, 0);
629 serial_icr_write(up
, UART_CSR
, 0); /* Reset the UART */
630 serial_outp(up
, UART_LCR
, 0xBF);
631 serial_outp(up
, UART_EFR
, UART_EFR_ECB
);
632 serial_outp(up
, UART_LCR
, 0);
635 #ifdef CONFIG_SERIAL_8250_RSA
637 * If this is an RSA port, see if we can kick it up to the
638 * higher speed clock.
644 * Clear the FIFO buffers and disable them.
645 * (they will be reenabled in set_termios())
647 if (uart_config
[up
->port
.type
].flags
& UART_CLEAR_FIFO
) {
648 serial_outp(up
, UART_FCR
, UART_FCR_ENABLE_FIFO
);
649 serial_outp(up
, UART_FCR
, UART_FCR_ENABLE_FIFO
|
650 UART_FCR_CLEAR_RCVR
| UART_FCR_CLEAR_XMIT
);
651 serial_outp(up
, UART_FCR
, 0);
655 * Clear the interrupt registers.
657 (void) serial_inp(up
, UART_LSR
);
658 (void) serial_inp(up
, UART_RX
);
659 (void) serial_inp(up
, UART_IIR
);
660 (void) serial_inp(up
, UART_MSR
);
663 * At this point, there's no way the LSR could still be 0xff;
664 * if it is, then bail out, because there's likely no UART
667 if (!(up
->port
.flags
& UPF_BUGGY_UART
) &&
668 (serial_inp(up
, UART_LSR
) == 0xff)) {
669 printk("ttyS%d: LSR safety check engaged!\n", up
->port
.line
);
673 if (up
->su_type
!= SU_PORT_PORT
) {
674 retval
= request_irq(up
->port
.irq
, sunsu_kbd_ms_interrupt
,
675 IRQF_SHARED
, su_typev
[up
->su_type
], up
);
677 retval
= request_irq(up
->port
.irq
, sunsu_serial_interrupt
,
678 IRQF_SHARED
, su_typev
[up
->su_type
], up
);
681 printk("su: Cannot register IRQ %d\n", up
->port
.irq
);
686 * Now, initialize the UART
688 serial_outp(up
, UART_LCR
, UART_LCR_WLEN8
);
690 spin_lock_irqsave(&up
->port
.lock
, flags
);
692 up
->port
.mctrl
|= TIOCM_OUT2
;
694 sunsu_set_mctrl(&up
->port
, up
->port
.mctrl
);
695 spin_unlock_irqrestore(&up
->port
.lock
, flags
);
698 * Finally, enable interrupts. Note: Modem status interrupts
699 * are set via set_termios(), which will be occurring imminently
700 * anyway, so we don't enable them here.
702 up
->ier
= UART_IER_RLSI
| UART_IER_RDI
;
703 serial_outp(up
, UART_IER
, up
->ier
);
705 if (up
->port
.flags
& UPF_FOURPORT
) {
708 * Enable interrupts on the AST Fourport board
710 icp
= (up
->port
.iobase
& 0xfe0) | 0x01f;
716 * And clear the interrupt registers again for luck.
718 (void) serial_inp(up
, UART_LSR
);
719 (void) serial_inp(up
, UART_RX
);
720 (void) serial_inp(up
, UART_IIR
);
721 (void) serial_inp(up
, UART_MSR
);
726 static void sunsu_shutdown(struct uart_port
*port
)
728 struct uart_sunsu_port
*up
= (struct uart_sunsu_port
*) port
;
732 * Disable interrupts from this port
735 serial_outp(up
, UART_IER
, 0);
737 spin_lock_irqsave(&up
->port
.lock
, flags
);
738 if (up
->port
.flags
& UPF_FOURPORT
) {
739 /* reset interrupts on the AST Fourport board */
740 inb((up
->port
.iobase
& 0xfe0) | 0x1f);
741 up
->port
.mctrl
|= TIOCM_OUT1
;
743 up
->port
.mctrl
&= ~TIOCM_OUT2
;
745 sunsu_set_mctrl(&up
->port
, up
->port
.mctrl
);
746 spin_unlock_irqrestore(&up
->port
.lock
, flags
);
749 * Disable break condition and FIFOs
751 serial_out(up
, UART_LCR
, serial_inp(up
, UART_LCR
) & ~UART_LCR_SBC
);
752 serial_outp(up
, UART_FCR
, UART_FCR_ENABLE_FIFO
|
753 UART_FCR_CLEAR_RCVR
|
754 UART_FCR_CLEAR_XMIT
);
755 serial_outp(up
, UART_FCR
, 0);
757 #ifdef CONFIG_SERIAL_8250_RSA
759 * Reset the RSA board back to 115kbps compat mode.
765 * Read data port to reset things.
767 (void) serial_in(up
, UART_RX
);
769 free_irq(up
->port
.irq
, up
);
773 sunsu_change_speed(struct uart_port
*port
, unsigned int cflag
,
774 unsigned int iflag
, unsigned int quot
)
776 struct uart_sunsu_port
*up
= (struct uart_sunsu_port
*) port
;
777 unsigned char cval
, fcr
= 0;
780 switch (cflag
& CSIZE
) {
799 cval
|= UART_LCR_PARITY
;
800 if (!(cflag
& PARODD
))
801 cval
|= UART_LCR_EPAR
;
804 cval
|= UART_LCR_SPAR
;
808 * Work around a bug in the Oxford Semiconductor 952 rev B
809 * chip which causes it to seriously miscalculate baud rates
812 if ((quot
& 0xff) == 0 && up
->port
.type
== PORT_16C950
&&
816 if (uart_config
[up
->port
.type
].flags
& UART_USE_FIFO
) {
817 if ((up
->port
.uartclk
/ quot
) < (2400 * 16))
818 fcr
= UART_FCR_ENABLE_FIFO
| UART_FCR_TRIGGER_1
;
819 #ifdef CONFIG_SERIAL_8250_RSA
820 else if (up
->port
.type
== PORT_RSA
)
821 fcr
= UART_FCR_ENABLE_FIFO
| UART_FCR_TRIGGER_14
;
824 fcr
= UART_FCR_ENABLE_FIFO
| UART_FCR_TRIGGER_8
;
826 if (up
->port
.type
== PORT_16750
)
827 fcr
|= UART_FCR7_64BYTE
;
830 * Ok, we're now changing the port state. Do it with
831 * interrupts disabled.
833 spin_lock_irqsave(&up
->port
.lock
, flags
);
836 * Update the per-port timeout.
838 uart_update_timeout(port
, cflag
, (port
->uartclk
/ (16 * quot
)));
840 up
->port
.read_status_mask
= UART_LSR_OE
| UART_LSR_THRE
| UART_LSR_DR
;
842 up
->port
.read_status_mask
|= UART_LSR_FE
| UART_LSR_PE
;
843 if (iflag
& (BRKINT
| PARMRK
))
844 up
->port
.read_status_mask
|= UART_LSR_BI
;
847 * Characteres to ignore
849 up
->port
.ignore_status_mask
= 0;
851 up
->port
.ignore_status_mask
|= UART_LSR_PE
| UART_LSR_FE
;
852 if (iflag
& IGNBRK
) {
853 up
->port
.ignore_status_mask
|= UART_LSR_BI
;
855 * If we're ignoring parity and break indicators,
856 * ignore overruns too (for real raw support).
859 up
->port
.ignore_status_mask
|= UART_LSR_OE
;
863 * ignore all characters if CREAD is not set
865 if ((cflag
& CREAD
) == 0)
866 up
->port
.ignore_status_mask
|= UART_LSR_DR
;
869 * CTS flow control flag and modem status interrupts
871 up
->ier
&= ~UART_IER_MSI
;
872 if (UART_ENABLE_MS(&up
->port
, cflag
))
873 up
->ier
|= UART_IER_MSI
;
875 serial_out(up
, UART_IER
, up
->ier
);
877 if (uart_config
[up
->port
.type
].flags
& UART_STARTECH
) {
878 serial_outp(up
, UART_LCR
, 0xBF);
879 serial_outp(up
, UART_EFR
, cflag
& CRTSCTS
? UART_EFR_CTS
:0);
881 serial_outp(up
, UART_LCR
, cval
| UART_LCR_DLAB
);/* set DLAB */
882 serial_outp(up
, UART_DLL
, quot
& 0xff); /* LS of divisor */
883 serial_outp(up
, UART_DLM
, quot
>> 8); /* MS of divisor */
884 if (up
->port
.type
== PORT_16750
)
885 serial_outp(up
, UART_FCR
, fcr
); /* set fcr */
886 serial_outp(up
, UART_LCR
, cval
); /* reset DLAB */
887 up
->lcr
= cval
; /* Save LCR */
888 if (up
->port
.type
!= PORT_16750
) {
889 if (fcr
& UART_FCR_ENABLE_FIFO
) {
890 /* emulated UARTs (Lucent Venus 167x) need two steps */
891 serial_outp(up
, UART_FCR
, UART_FCR_ENABLE_FIFO
);
893 serial_outp(up
, UART_FCR
, fcr
); /* set fcr */
898 spin_unlock_irqrestore(&up
->port
.lock
, flags
);
902 sunsu_set_termios(struct uart_port
*port
, struct ktermios
*termios
,
903 struct ktermios
*old
)
905 unsigned int baud
, quot
;
908 * Ask the core to calculate the divisor for us.
910 baud
= uart_get_baud_rate(port
, termios
, old
, 0, port
->uartclk
/16);
911 quot
= uart_get_divisor(port
, baud
);
913 sunsu_change_speed(port
, termios
->c_cflag
, termios
->c_iflag
, quot
);
916 static void sunsu_release_port(struct uart_port
*port
)
920 static int sunsu_request_port(struct uart_port
*port
)
925 static void sunsu_config_port(struct uart_port
*port
, int flags
)
927 struct uart_sunsu_port
*up
= (struct uart_sunsu_port
*) port
;
929 if (flags
& UART_CONFIG_TYPE
) {
931 * We are supposed to call autoconfig here, but this requires
932 * splitting all the OBP probing crap from the UART probing.
933 * We'll do it when we kill sunsu.c altogether.
935 port
->type
= up
->type_probed
; /* XXX */
940 sunsu_verify_port(struct uart_port
*port
, struct serial_struct
*ser
)
946 sunsu_type(struct uart_port
*port
)
948 int type
= port
->type
;
950 if (type
>= ARRAY_SIZE(uart_config
))
952 return uart_config
[type
].name
;
955 static struct uart_ops sunsu_pops
= {
956 .tx_empty
= sunsu_tx_empty
,
957 .set_mctrl
= sunsu_set_mctrl
,
958 .get_mctrl
= sunsu_get_mctrl
,
959 .stop_tx
= sunsu_stop_tx
,
960 .start_tx
= sunsu_start_tx
,
961 .stop_rx
= sunsu_stop_rx
,
962 .enable_ms
= sunsu_enable_ms
,
963 .break_ctl
= sunsu_break_ctl
,
964 .startup
= sunsu_startup
,
965 .shutdown
= sunsu_shutdown
,
966 .set_termios
= sunsu_set_termios
,
968 .release_port
= sunsu_release_port
,
969 .request_port
= sunsu_request_port
,
970 .config_port
= sunsu_config_port
,
971 .verify_port
= sunsu_verify_port
,
976 static struct uart_sunsu_port sunsu_ports
[UART_NR
];
980 static DEFINE_SPINLOCK(sunsu_serio_lock
);
982 static int sunsu_serio_write(struct serio
*serio
, unsigned char ch
)
984 struct uart_sunsu_port
*up
= serio
->port_data
;
988 spin_lock_irqsave(&sunsu_serio_lock
, flags
);
991 lsr
= serial_in(up
, UART_LSR
);
992 } while (!(lsr
& UART_LSR_THRE
));
994 /* Send the character out. */
995 serial_out(up
, UART_TX
, ch
);
997 spin_unlock_irqrestore(&sunsu_serio_lock
, flags
);
1002 static int sunsu_serio_open(struct serio
*serio
)
1004 struct uart_sunsu_port
*up
= serio
->port_data
;
1005 unsigned long flags
;
1008 spin_lock_irqsave(&sunsu_serio_lock
, flags
);
1009 if (!up
->serio_open
) {
1014 spin_unlock_irqrestore(&sunsu_serio_lock
, flags
);
1019 static void sunsu_serio_close(struct serio
*serio
)
1021 struct uart_sunsu_port
*up
= serio
->port_data
;
1022 unsigned long flags
;
1024 spin_lock_irqsave(&sunsu_serio_lock
, flags
);
1026 spin_unlock_irqrestore(&sunsu_serio_lock
, flags
);
1029 #endif /* CONFIG_SERIO */
1031 static void sunsu_autoconfig(struct uart_sunsu_port
*up
)
1033 unsigned char status1
, status2
, scratch
, scratch2
, scratch3
;
1034 unsigned char save_lcr
, save_mcr
;
1035 unsigned long flags
;
1037 if (up
->su_type
== SU_PORT_NONE
)
1040 up
->type_probed
= PORT_UNKNOWN
;
1041 up
->port
.iotype
= UPIO_MEM
;
1043 spin_lock_irqsave(&up
->port
.lock
, flags
);
1045 if (!(up
->port
.flags
& UPF_BUGGY_UART
)) {
1047 * Do a simple existence test first; if we fail this, there's
1048 * no point trying anything else.
1050 * 0x80 is used as a nonsense port to prevent against false
1051 * positives due to ISA bus float. The assumption is that
1052 * 0x80 is a non-existent port; which should be safe since
1053 * include/asm/io.h also makes this assumption.
1055 scratch
= serial_inp(up
, UART_IER
);
1056 serial_outp(up
, UART_IER
, 0);
1060 scratch2
= serial_inp(up
, UART_IER
);
1061 serial_outp(up
, UART_IER
, 0x0f);
1065 scratch3
= serial_inp(up
, UART_IER
);
1066 serial_outp(up
, UART_IER
, scratch
);
1067 if (scratch2
!= 0 || scratch3
!= 0x0F)
1068 goto out
; /* We failed; there's nothing here */
1071 save_mcr
= serial_in(up
, UART_MCR
);
1072 save_lcr
= serial_in(up
, UART_LCR
);
1075 * Check to see if a UART is really there. Certain broken
1076 * internal modems based on the Rockwell chipset fail this
1077 * test, because they apparently don't implement the loopback
1078 * test mode. So this test is skipped on the COM 1 through
1079 * COM 4 ports. This *should* be safe, since no board
1080 * manufacturer would be stupid enough to design a board
1081 * that conflicts with COM 1-4 --- we hope!
1083 if (!(up
->port
.flags
& UPF_SKIP_TEST
)) {
1084 serial_outp(up
, UART_MCR
, UART_MCR_LOOP
| 0x0A);
1085 status1
= serial_inp(up
, UART_MSR
) & 0xF0;
1086 serial_outp(up
, UART_MCR
, save_mcr
);
1087 if (status1
!= 0x90)
1088 goto out
; /* We failed loopback test */
1090 serial_outp(up
, UART_LCR
, 0xBF); /* set up for StarTech test */
1091 serial_outp(up
, UART_EFR
, 0); /* EFR is the same as FCR */
1092 serial_outp(up
, UART_LCR
, 0);
1093 serial_outp(up
, UART_FCR
, UART_FCR_ENABLE_FIFO
);
1094 scratch
= serial_in(up
, UART_IIR
) >> 6;
1097 up
->port
.type
= PORT_16450
;
1100 up
->port
.type
= PORT_UNKNOWN
;
1103 up
->port
.type
= PORT_16550
;
1106 up
->port
.type
= PORT_16550A
;
1109 if (up
->port
.type
== PORT_16550A
) {
1110 /* Check for Startech UART's */
1111 serial_outp(up
, UART_LCR
, UART_LCR_DLAB
);
1112 if (serial_in(up
, UART_EFR
) == 0) {
1113 up
->port
.type
= PORT_16650
;
1115 serial_outp(up
, UART_LCR
, 0xBF);
1116 if (serial_in(up
, UART_EFR
) == 0)
1117 up
->port
.type
= PORT_16650V2
;
1120 if (up
->port
.type
== PORT_16550A
) {
1121 /* Check for TI 16750 */
1122 serial_outp(up
, UART_LCR
, save_lcr
| UART_LCR_DLAB
);
1123 serial_outp(up
, UART_FCR
,
1124 UART_FCR_ENABLE_FIFO
| UART_FCR7_64BYTE
);
1125 scratch
= serial_in(up
, UART_IIR
) >> 5;
1128 * If this is a 16750, and not a cheap UART
1129 * clone, then it should only go into 64 byte
1130 * mode if the UART_FCR7_64BYTE bit was set
1131 * while UART_LCR_DLAB was latched.
1133 serial_outp(up
, UART_FCR
, UART_FCR_ENABLE_FIFO
);
1134 serial_outp(up
, UART_LCR
, 0);
1135 serial_outp(up
, UART_FCR
,
1136 UART_FCR_ENABLE_FIFO
| UART_FCR7_64BYTE
);
1137 scratch
= serial_in(up
, UART_IIR
) >> 5;
1139 up
->port
.type
= PORT_16750
;
1141 serial_outp(up
, UART_FCR
, UART_FCR_ENABLE_FIFO
);
1143 serial_outp(up
, UART_LCR
, save_lcr
);
1144 if (up
->port
.type
== PORT_16450
) {
1145 scratch
= serial_in(up
, UART_SCR
);
1146 serial_outp(up
, UART_SCR
, 0xa5);
1147 status1
= serial_in(up
, UART_SCR
);
1148 serial_outp(up
, UART_SCR
, 0x5a);
1149 status2
= serial_in(up
, UART_SCR
);
1150 serial_outp(up
, UART_SCR
, scratch
);
1152 if ((status1
!= 0xa5) || (status2
!= 0x5a))
1153 up
->port
.type
= PORT_8250
;
1156 up
->port
.fifosize
= uart_config
[up
->port
.type
].dfl_xmit_fifo_size
;
1158 if (up
->port
.type
== PORT_UNKNOWN
)
1160 up
->type_probed
= up
->port
.type
; /* XXX */
1165 #ifdef CONFIG_SERIAL_8250_RSA
1166 if (up
->port
.type
== PORT_RSA
)
1167 serial_outp(up
, UART_RSA_FRR
, 0);
1169 serial_outp(up
, UART_MCR
, save_mcr
);
1170 serial_outp(up
, UART_FCR
, (UART_FCR_ENABLE_FIFO
|
1171 UART_FCR_CLEAR_RCVR
|
1172 UART_FCR_CLEAR_XMIT
));
1173 serial_outp(up
, UART_FCR
, 0);
1174 (void)serial_in(up
, UART_RX
);
1175 serial_outp(up
, UART_IER
, 0);
1178 spin_unlock_irqrestore(&up
->port
.lock
, flags
);
1181 static struct uart_driver sunsu_reg
= {
1182 .owner
= THIS_MODULE
,
1183 .driver_name
= "sunsu",
1188 static int sunsu_kbd_ms_init(struct uart_sunsu_port
*up
)
1192 struct serio
*serio
;
1195 if (up
->su_type
== SU_PORT_KBD
) {
1196 up
->cflag
= B1200
| CS8
| CLOCAL
| CREAD
;
1199 up
->cflag
= B4800
| CS8
| CLOCAL
| CREAD
;
1202 quot
= up
->port
.uartclk
/ (16 * baud
);
1204 sunsu_autoconfig(up
);
1205 if (up
->port
.type
== PORT_UNKNOWN
)
1208 printk("%s: %s port at %llx, irq %u\n",
1209 up
->port
.dev
->of_node
->full_name
,
1210 (up
->su_type
== SU_PORT_KBD
) ? "Keyboard" : "Mouse",
1211 (unsigned long long) up
->port
.mapbase
,
1216 serio
->port_data
= up
;
1218 serio
->id
.type
= SERIO_RS232
;
1219 if (up
->su_type
== SU_PORT_KBD
) {
1220 serio
->id
.proto
= SERIO_SUNKBD
;
1221 strlcpy(serio
->name
, "sukbd", sizeof(serio
->name
));
1223 serio
->id
.proto
= SERIO_SUN
;
1224 serio
->id
.extra
= 1;
1225 strlcpy(serio
->name
, "sums", sizeof(serio
->name
));
1227 strlcpy(serio
->phys
,
1228 (!(up
->port
.line
& 1) ? "su/serio0" : "su/serio1"),
1229 sizeof(serio
->phys
));
1231 serio
->write
= sunsu_serio_write
;
1232 serio
->open
= sunsu_serio_open
;
1233 serio
->close
= sunsu_serio_close
;
1234 serio
->dev
.parent
= up
->port
.dev
;
1236 serio_register_port(serio
);
1239 sunsu_change_speed(&up
->port
, up
->cflag
, 0, quot
);
1241 sunsu_startup(&up
->port
);
1246 * ------------------------------------------------------------
1247 * Serial console driver
1248 * ------------------------------------------------------------
1251 #ifdef CONFIG_SERIAL_SUNSU_CONSOLE
1253 #define BOTH_EMPTY (UART_LSR_TEMT | UART_LSR_THRE)
1256 * Wait for transmitter & holding register to empty
1258 static __inline__
void wait_for_xmitr(struct uart_sunsu_port
*up
)
1260 unsigned int status
, tmout
= 10000;
1262 /* Wait up to 10ms for the character(s) to be sent. */
1264 status
= serial_in(up
, UART_LSR
);
1266 if (status
& UART_LSR_BI
)
1267 up
->lsr_break_flag
= UART_LSR_BI
;
1272 } while ((status
& BOTH_EMPTY
) != BOTH_EMPTY
);
1274 /* Wait up to 1s for flow control if necessary */
1275 if (up
->port
.flags
& UPF_CONS_FLOW
) {
1278 ((serial_in(up
, UART_MSR
) & UART_MSR_CTS
) == 0))
1283 static void sunsu_console_putchar(struct uart_port
*port
, int ch
)
1285 struct uart_sunsu_port
*up
= (struct uart_sunsu_port
*)port
;
1288 serial_out(up
, UART_TX
, ch
);
1292 * Print a string to the serial port trying not to disturb
1293 * any possible real use of the port...
1295 static void sunsu_console_write(struct console
*co
, const char *s
,
1298 struct uart_sunsu_port
*up
= &sunsu_ports
[co
->index
];
1299 unsigned long flags
;
1303 local_irq_save(flags
);
1304 if (up
->port
.sysrq
) {
1306 } else if (oops_in_progress
) {
1307 locked
= spin_trylock(&up
->port
.lock
);
1309 spin_lock(&up
->port
.lock
);
1312 * First save the UER then disable the interrupts
1314 ier
= serial_in(up
, UART_IER
);
1315 serial_out(up
, UART_IER
, 0);
1317 uart_console_write(&up
->port
, s
, count
, sunsu_console_putchar
);
1320 * Finally, wait for transmitter to become empty
1321 * and restore the IER
1324 serial_out(up
, UART_IER
, ier
);
1327 spin_unlock(&up
->port
.lock
);
1328 local_irq_restore(flags
);
1332 * Setup initial baud/bits/parity. We do two things here:
1333 * - construct a cflag setting for the first su_open()
1334 * - initialize the serial port
1335 * Return non-zero if we didn't find a serial port.
1337 static int __init
sunsu_console_setup(struct console
*co
, char *options
)
1339 static struct ktermios dummy
;
1340 struct ktermios termios
;
1341 struct uart_port
*port
;
1343 printk("Console: ttyS%d (SU)\n",
1344 (sunsu_reg
.minor
- 64) + co
->index
);
1347 * Check whether an invalid uart number has been specified, and
1348 * if so, search for the first available port that does have
1351 if (co
->index
>= UART_NR
)
1353 port
= &sunsu_ports
[co
->index
].port
;
1358 spin_lock_init(&port
->lock
);
1360 /* Get firmware console settings. */
1361 sunserial_console_termios(co
, port
->dev
->of_node
);
1363 memset(&termios
, 0, sizeof(struct ktermios
));
1364 termios
.c_cflag
= co
->cflag
;
1365 port
->mctrl
|= TIOCM_DTR
;
1366 port
->ops
->set_termios(port
, &termios
, &dummy
);
1371 static struct console sunsu_console
= {
1373 .write
= sunsu_console_write
,
1374 .device
= uart_console_device
,
1375 .setup
= sunsu_console_setup
,
1376 .flags
= CON_PRINTBUFFER
,
1385 static inline struct console
*SUNSU_CONSOLE(void)
1387 return &sunsu_console
;
1390 #define SUNSU_CONSOLE() (NULL)
1391 #define sunsu_serial_console_init() do { } while (0)
1394 static enum su_type
su_get_type(struct device_node
*dp
)
1396 struct device_node
*ap
= of_find_node_by_path("/aliases");
1399 const char *keyb
= of_get_property(ap
, "keyboard", NULL
);
1400 const char *ms
= of_get_property(ap
, "mouse", NULL
);
1403 if (dp
== of_find_node_by_path(keyb
))
1407 if (dp
== of_find_node_by_path(ms
))
1412 return SU_PORT_PORT
;
1415 static int su_probe(struct platform_device
*op
)
1418 struct device_node
*dp
= op
->dev
.of_node
;
1419 struct uart_sunsu_port
*up
;
1420 struct resource
*rp
;
1425 type
= su_get_type(dp
);
1426 if (type
== SU_PORT_PORT
) {
1427 if (inst
>= UART_NR
)
1429 up
= &sunsu_ports
[inst
];
1431 up
= kzalloc(sizeof(*up
), GFP_KERNEL
);
1436 up
->port
.line
= inst
;
1438 spin_lock_init(&up
->port
.lock
);
1442 rp
= &op
->resource
[0];
1443 up
->port
.mapbase
= rp
->start
;
1444 up
->reg_size
= resource_size(rp
);
1445 up
->port
.membase
= of_ioremap(rp
, 0, up
->reg_size
, "su");
1446 if (!up
->port
.membase
) {
1447 if (type
!= SU_PORT_PORT
)
1452 up
->port
.irq
= op
->archdata
.irqs
[0];
1454 up
->port
.dev
= &op
->dev
;
1456 up
->port
.type
= PORT_UNKNOWN
;
1457 up
->port
.uartclk
= (SU_BASE_BAUD
* 16);
1460 if (up
->su_type
== SU_PORT_KBD
|| up
->su_type
== SU_PORT_MS
) {
1461 err
= sunsu_kbd_ms_init(up
);
1463 of_iounmap(&op
->resource
[0],
1464 up
->port
.membase
, up
->reg_size
);
1468 dev_set_drvdata(&op
->dev
, up
);
1473 up
->port
.flags
|= UPF_BOOT_AUTOCONF
;
1475 sunsu_autoconfig(up
);
1478 if (up
->port
.type
== PORT_UNKNOWN
)
1481 up
->port
.ops
= &sunsu_pops
;
1483 ignore_line
= false;
1484 if (!strcmp(dp
->name
, "rsc-console") ||
1485 !strcmp(dp
->name
, "lom-console"))
1488 sunserial_console_match(SUNSU_CONSOLE(), dp
,
1489 &sunsu_reg
, up
->port
.line
,
1491 err
= uart_add_one_port(&sunsu_reg
, &up
->port
);
1495 dev_set_drvdata(&op
->dev
, up
);
1502 of_iounmap(&op
->resource
[0], up
->port
.membase
, up
->reg_size
);
1506 static int __devexit
su_remove(struct platform_device
*op
)
1508 struct uart_sunsu_port
*up
= dev_get_drvdata(&op
->dev
);
1511 if (up
->su_type
== SU_PORT_MS
||
1512 up
->su_type
== SU_PORT_KBD
)
1517 serio_unregister_port(&up
->serio
);
1519 } else if (up
->port
.type
!= PORT_UNKNOWN
)
1520 uart_remove_one_port(&sunsu_reg
, &up
->port
);
1522 if (up
->port
.membase
)
1523 of_iounmap(&op
->resource
[0], up
->port
.membase
, up
->reg_size
);
1528 dev_set_drvdata(&op
->dev
, NULL
);
1533 static const struct of_device_id su_match
[] = {
1550 MODULE_DEVICE_TABLE(of
, su_match
);
1552 static struct platform_driver su_driver
= {
1555 .owner
= THIS_MODULE
,
1556 .of_match_table
= su_match
,
1559 .remove
= su_remove
,
1562 static int __init
sunsu_init(void)
1564 struct device_node
*dp
;
1568 for_each_node_by_name(dp
, "su") {
1569 if (su_get_type(dp
) == SU_PORT_PORT
)
1572 for_each_node_by_name(dp
, "su_pnp") {
1573 if (su_get_type(dp
) == SU_PORT_PORT
)
1576 for_each_node_by_name(dp
, "serial") {
1577 if (of_device_is_compatible(dp
, "su")) {
1578 if (su_get_type(dp
) == SU_PORT_PORT
)
1582 for_each_node_by_type(dp
, "serial") {
1583 if (of_device_is_compatible(dp
, "su")) {
1584 if (su_get_type(dp
) == SU_PORT_PORT
)
1590 err
= sunserial_register_minors(&sunsu_reg
, num_uart
);
1595 err
= platform_driver_register(&su_driver
);
1596 if (err
&& num_uart
)
1597 sunserial_unregister_minors(&sunsu_reg
, num_uart
);
1602 static void __exit
sunsu_exit(void)
1605 sunserial_unregister_minors(&sunsu_reg
, sunsu_reg
.nr
);
1608 module_init(sunsu_init
);
1609 module_exit(sunsu_exit
);
1611 MODULE_AUTHOR("Eddie C. Dost, Peter Zaitcev, and David S. Miller");
1612 MODULE_DESCRIPTION("Sun SU serial port driver");
1613 MODULE_VERSION("2.0");
1614 MODULE_LICENSE("GPL");