2 * drivers/serial/sh-sci.c
4 * SuperH on-chip serial module support. (SCI with no FIFO / with FIFO)
6 * Copyright (C) 2002 - 2006 Paul Mundt
8 * based off of the old drivers/char/sh-sci.c by:
10 * Copyright (C) 1999, 2000 Niibe Yutaka
11 * Copyright (C) 2000 Sugioka Toshinobu
12 * Modified to support multiple serial ports. Stuart Menefy (May 2000).
13 * Modified to support SecureEdge. David McCullough (2002)
14 * Modified to support SH7300 SCIF. Takashi Kusuda (Jun 2003).
16 * This file is subject to the terms and conditions of the GNU General Public
17 * License. See the file "COPYING" in the main directory of this archive
20 #if defined(CONFIG_SERIAL_SH_SCI_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
26 #include <linux/module.h>
27 #include <linux/errno.h>
28 #include <linux/timer.h>
29 #include <linux/interrupt.h>
30 #include <linux/tty.h>
31 #include <linux/tty_flip.h>
32 #include <linux/serial.h>
33 #include <linux/major.h>
34 #include <linux/string.h>
35 #include <linux/sysrq.h>
36 #include <linux/ioport.h>
38 #include <linux/init.h>
39 #include <linux/delay.h>
40 #include <linux/console.h>
41 #include <linux/platform_device.h>
43 #ifdef CONFIG_CPU_FREQ
44 #include <linux/notifier.h>
45 #include <linux/cpufreq.h>
48 #if defined(CONFIG_SUPERH) && !defined(CONFIG_SUPERH64)
49 #include <linux/ctype.h>
50 #include <asm/clock.h>
51 #include <asm/sh_bios.h>
59 struct uart_port port
;
64 /* Port IRQs: ERI, RXI, TXI, BRI (optional) */
65 unsigned int irqs
[SCIx_NR_IRQS
];
67 /* Port pin configuration */
68 void (*init_pins
)(struct uart_port
*port
,
71 /* Port enable callback */
72 void (*enable
)(struct uart_port
*port
);
74 /* Port disable callback */
75 void (*disable
)(struct uart_port
*port
);
78 struct timer_list break_timer
;
86 static struct sci_port
*kgdb_sci_port
;
89 #ifdef CONFIG_SERIAL_SH_SCI_CONSOLE
90 static struct sci_port
*serial_console_port
;
93 /* Function prototypes */
94 static void sci_stop_tx(struct uart_port
*port
);
96 #define SCI_NPORTS CONFIG_SERIAL_SH_SCI_NR_UARTS
98 static struct sci_port sci_ports
[SCI_NPORTS
];
99 static struct uart_driver sci_uart_driver
;
101 #if defined(CONFIG_SERIAL_SH_SCI_CONSOLE) && \
102 defined(CONFIG_SH_STANDARD_BIOS) || defined(CONFIG_SH_KGDB)
103 static inline void handle_error(struct uart_port
*port
)
105 /* Clear error flags */
106 sci_out(port
, SCxSR
, SCxSR_ERROR_CLEAR(port
));
109 static int get_char(struct uart_port
*port
)
112 unsigned short status
;
115 spin_lock_irqsave(&port
->lock
, flags
);
117 status
= sci_in(port
, SCxSR
);
118 if (status
& SCxSR_ERRORS(port
)) {
122 } while (!(status
& SCxSR_RDxF(port
)));
123 c
= sci_in(port
, SCxRDR
);
124 sci_in(port
, SCxSR
); /* Dummy read */
125 sci_out(port
, SCxSR
, SCxSR_RDxF_CLEAR(port
));
126 spin_unlock_irqrestore(&port
->lock
, flags
);
130 #endif /* CONFIG_SH_STANDARD_BIOS || CONFIG_SH_KGDB */
132 #if defined(CONFIG_SERIAL_SH_SCI_CONSOLE) || defined(CONFIG_SH_KGDB)
133 static void put_char(struct uart_port
*port
, char c
)
136 unsigned short status
;
138 spin_lock_irqsave(&port
->lock
, flags
);
141 status
= sci_in(port
, SCxSR
);
142 } while (!(status
& SCxSR_TDxE(port
)));
144 sci_out(port
, SCxTDR
, c
);
145 sci_in(port
, SCxSR
); /* Dummy read */
146 sci_out(port
, SCxSR
, SCxSR_TDxE_CLEAR(port
));
148 spin_unlock_irqrestore(&port
->lock
, flags
);
152 #ifdef CONFIG_SERIAL_SH_SCI_CONSOLE
153 static void put_string(struct sci_port
*sci_port
, const char *buffer
, int count
)
155 struct uart_port
*port
= &sci_port
->port
;
156 const unsigned char *p
= buffer
;
159 #if defined(CONFIG_SH_STANDARD_BIOS) || defined(CONFIG_SH_KGDB)
163 #ifdef CONFIG_SH_STANDARD_BIOS
164 /* This call only does a trap the first time it is
165 * called, and so is safe to do here unconditionally
167 usegdb
|= sh_bios_in_gdb_mode();
169 #ifdef CONFIG_SH_KGDB
170 usegdb
|= (kgdb_in_gdb_mode
&& (sci_port
== kgdb_sci_port
));
174 /* $<packet info>#<checksum>. */
178 put_char(port
, 'O'); /* 'O'utput to console */
181 for (i
=0; i
<count
; i
++) { /* Don't use run length encoding */
192 put_char(port
, highhex(checksum
));
193 put_char(port
, lowhex(checksum
));
194 } while (get_char(port
) != '+');
196 #endif /* CONFIG_SH_STANDARD_BIOS || CONFIG_SH_KGDB */
197 for (i
=0; i
<count
; i
++) {
199 put_char(port
, '\r');
200 put_char(port
, *p
++);
203 #endif /* CONFIG_SERIAL_SH_SCI_CONSOLE */
205 #ifdef CONFIG_SH_KGDB
206 static int kgdb_sci_getchar(void)
210 /* Keep trying to read a character, this could be neater */
211 while ((c
= get_char(&kgdb_sci_port
->port
)) < 0)
217 static inline void kgdb_sci_putchar(int c
)
219 put_char(&kgdb_sci_port
->port
, c
);
221 #endif /* CONFIG_SH_KGDB */
223 #if defined(__H8300S__)
224 enum { sci_disable
, sci_enable
};
226 static void h8300_sci_config(struct uart_port
* port
, unsigned int ctrl
)
228 volatile unsigned char *mstpcrl
=(volatile unsigned char *)MSTPCRL
;
229 int ch
= (port
->mapbase
- SMR0
) >> 3;
230 unsigned char mask
= 1 << (ch
+1);
232 if (ctrl
== sci_disable
) {
239 static inline void h8300_sci_enable(struct uart_port
*port
)
241 h8300_sci_config(port
, sci_enable
);
244 static inline void h8300_sci_disable(struct uart_port
*port
)
246 h8300_sci_config(port
, sci_disable
);
250 #if defined(SCI_ONLY) || defined(SCI_AND_SCIF) && \
251 defined(__H8300H__) || defined(__H8300S__)
252 static void sci_init_pins_sci(struct uart_port
* port
, unsigned int cflag
)
254 int ch
= (port
->mapbase
- SMR0
) >> 3;
257 H8300_GPIO_DDR(h8300_sci_pins
[ch
].port
,
258 h8300_sci_pins
[ch
].rx
,
260 H8300_GPIO_DDR(h8300_sci_pins
[ch
].port
,
261 h8300_sci_pins
[ch
].tx
,
265 H8300_SCI_DR(ch
) |= h8300_sci_pins
[ch
].tx
;
268 #define sci_init_pins_sci NULL
271 #if defined(CONFIG_CPU_SUBTYPE_SH7707) || defined(CONFIG_CPU_SUBTYPE_SH7709)
272 static void sci_init_pins_irda(struct uart_port
*port
, unsigned int cflag
)
274 unsigned int fcr_val
= 0;
277 fcr_val
|= SCFCR_MCE
;
279 sci_out(port
, SCFCR
, fcr_val
);
282 #define sci_init_pins_irda NULL
286 #define sci_init_pins_scif NULL
289 #if defined(SCIF_ONLY) || defined(SCI_AND_SCIF)
290 #if defined(CONFIG_CPU_SUBTYPE_SH7300)
291 /* SH7300 doesn't use RTS/CTS */
292 static void sci_init_pins_scif(struct uart_port
*port
, unsigned int cflag
)
294 sci_out(port
, SCFCR
, 0);
296 #elif defined(CONFIG_CPU_SUBTYPE_SH7710) || defined(CONFIG_CPU_SUBTYPE_SH7712)
297 static void sci_init_pins_scif(struct uart_port
* port
, unsigned int cflag
)
299 unsigned int fcr_val
= 0;
301 set_sh771x_scif_pfc(port
);
302 if (cflag
& CRTSCTS
) {
303 fcr_val
|= SCFCR_MCE
;
305 sci_out(port
, SCFCR
, fcr_val
);
307 #elif defined(CONFIG_CPU_SH3)
308 /* For SH7705, SH7706, SH7707, SH7709, SH7709A, SH7729 */
309 static void sci_init_pins_scif(struct uart_port
*port
, unsigned int cflag
)
311 unsigned int fcr_val
= 0;
314 /* We need to set SCPCR to enable RTS/CTS */
315 data
= ctrl_inw(SCPCR
);
316 /* Clear out SCP7MD1,0, SCP6MD1,0, SCP4MD1,0*/
317 ctrl_outw(data
& 0x0fcf, SCPCR
);
320 fcr_val
|= SCFCR_MCE
;
322 /* We need to set SCPCR to enable RTS/CTS */
323 data
= ctrl_inw(SCPCR
);
324 /* Clear out SCP7MD1,0, SCP4MD1,0,
325 Set SCP6MD1,0 = {01} (output) */
326 ctrl_outw((data
& 0x0fcf) | 0x1000, SCPCR
);
328 data
= ctrl_inb(SCPDR
);
329 /* Set /RTS2 (bit6) = 0 */
330 ctrl_outb(data
& 0xbf, SCPDR
);
333 sci_out(port
, SCFCR
, fcr_val
);
335 #elif defined(CONFIG_CPU_SUBTYPE_SH7722)
336 static void sci_init_pins_scif(struct uart_port
*port
, unsigned int cflag
)
338 unsigned int fcr_val
= 0;
340 if (cflag
& CRTSCTS
) {
341 fcr_val
|= SCFCR_MCE
;
343 ctrl_outw(0x0000, PORT_PSCR
);
347 data
= ctrl_inw(PORT_PSCR
);
350 ctrl_outw(data
, PORT_PSCR
);
352 ctrl_outw(ctrl_inw(SCSPTR0
) & 0x17, SCSPTR0
);
355 sci_out(port
, SCFCR
, fcr_val
);
359 static void sci_init_pins_scif(struct uart_port
*port
, unsigned int cflag
)
361 unsigned int fcr_val
= 0;
363 if (cflag
& CRTSCTS
) {
364 fcr_val
|= SCFCR_MCE
;
366 #ifdef CONFIG_CPU_SUBTYPE_SH7343
368 #elif defined(CONFIG_CPU_SUBTYPE_SH7780) || defined(CONFIG_CPU_SUBTYPE_SH7785)
369 ctrl_outw(0x0080, SCSPTR0
); /* Set RTS = 1 */
371 ctrl_outw(0x0080, SCSPTR2
); /* Set RTS = 1 */
374 sci_out(port
, SCFCR
, fcr_val
);
378 #if defined(CONFIG_CPU_SUBTYPE_SH7760) || \
379 defined(CONFIG_CPU_SUBTYPE_SH7780) || \
380 defined(CONFIG_CPU_SUBTYPE_SH7785)
381 static inline int scif_txroom(struct uart_port
*port
)
383 return SCIF_TXROOM_MAX
- (sci_in(port
, SCTFDR
) & 0x7f);
386 static inline int scif_rxroom(struct uart_port
*port
)
388 return sci_in(port
, SCRFDR
) & 0x7f;
391 static inline int scif_txroom(struct uart_port
*port
)
393 return SCIF_TXROOM_MAX
- (sci_in(port
, SCFDR
) >> 8);
396 static inline int scif_rxroom(struct uart_port
*port
)
398 return sci_in(port
, SCFDR
) & SCIF_RFDC_MASK
;
401 #endif /* SCIF_ONLY || SCI_AND_SCIF */
403 static inline int sci_txroom(struct uart_port
*port
)
405 return ((sci_in(port
, SCxSR
) & SCI_TDRE
) != 0);
408 static inline int sci_rxroom(struct uart_port
*port
)
410 return ((sci_in(port
, SCxSR
) & SCxSR_RDxF(port
)) != 0);
413 /* ********************************************************************** *
414 * the interrupt related routines *
415 * ********************************************************************** */
417 static void sci_transmit_chars(struct uart_port
*port
)
419 struct circ_buf
*xmit
= &port
->info
->xmit
;
420 unsigned int stopped
= uart_tx_stopped(port
);
421 unsigned short status
;
425 status
= sci_in(port
, SCxSR
);
426 if (!(status
& SCxSR_TDxE(port
))) {
427 ctrl
= sci_in(port
, SCSCR
);
428 if (uart_circ_empty(xmit
)) {
429 ctrl
&= ~SCI_CTRL_FLAGS_TIE
;
431 ctrl
|= SCI_CTRL_FLAGS_TIE
;
433 sci_out(port
, SCSCR
, ctrl
);
438 if (port
->type
== PORT_SCIF
)
439 count
= scif_txroom(port
);
442 count
= sci_txroom(port
);
450 } else if (!uart_circ_empty(xmit
) && !stopped
) {
451 c
= xmit
->buf
[xmit
->tail
];
452 xmit
->tail
= (xmit
->tail
+ 1) & (UART_XMIT_SIZE
- 1);
457 sci_out(port
, SCxTDR
, c
);
460 } while (--count
> 0);
462 sci_out(port
, SCxSR
, SCxSR_TDxE_CLEAR(port
));
464 if (uart_circ_chars_pending(xmit
) < WAKEUP_CHARS
)
465 uart_write_wakeup(port
);
466 if (uart_circ_empty(xmit
)) {
469 ctrl
= sci_in(port
, SCSCR
);
471 #if !defined(SCI_ONLY)
472 if (port
->type
== PORT_SCIF
) {
473 sci_in(port
, SCxSR
); /* Dummy read */
474 sci_out(port
, SCxSR
, SCxSR_TDxE_CLEAR(port
));
478 ctrl
|= SCI_CTRL_FLAGS_TIE
;
479 sci_out(port
, SCSCR
, ctrl
);
483 /* On SH3, SCIF may read end-of-break as a space->mark char */
484 #define STEPFN(c) ({int __c=(c); (((__c-1)|(__c)) == -1); })
486 static inline void sci_receive_chars(struct uart_port
*port
)
488 struct sci_port
*sci_port
= (struct sci_port
*)port
;
489 struct tty_struct
*tty
= port
->info
->tty
;
490 int i
, count
, copied
= 0;
491 unsigned short status
;
494 status
= sci_in(port
, SCxSR
);
495 if (!(status
& SCxSR_RDxF(port
)))
499 #if !defined(SCI_ONLY)
500 if (port
->type
== PORT_SCIF
)
501 count
= scif_rxroom(port
);
504 count
= sci_rxroom(port
);
506 /* Don't copy more bytes than there is room for in the buffer */
507 count
= tty_buffer_request_room(tty
, count
);
509 /* If for any reason we can't copy more data, we're done! */
513 if (port
->type
== PORT_SCI
) {
514 char c
= sci_in(port
, SCxRDR
);
515 if (uart_handle_sysrq_char(port
, c
) || sci_port
->break_flag
)
518 tty_insert_flip_char(tty
, c
, TTY_NORMAL
);
521 for (i
=0; i
<count
; i
++) {
522 char c
= sci_in(port
, SCxRDR
);
523 status
= sci_in(port
, SCxSR
);
524 #if defined(CONFIG_CPU_SH3)
525 /* Skip "chars" during break */
526 if (sci_port
->break_flag
) {
528 (status
& SCxSR_FER(port
))) {
533 /* Nonzero => end-of-break */
534 pr_debug("scif: debounce<%02x>\n", c
);
535 sci_port
->break_flag
= 0;
542 #endif /* CONFIG_CPU_SH3 */
543 if (uart_handle_sysrq_char(port
, c
)) {
548 /* Store data and status */
549 if (status
&SCxSR_FER(port
)) {
551 pr_debug("sci: frame error\n");
552 } else if (status
&SCxSR_PER(port
)) {
554 pr_debug("sci: parity error\n");
557 tty_insert_flip_char(tty
, c
, flag
);
561 sci_in(port
, SCxSR
); /* dummy read */
562 sci_out(port
, SCxSR
, SCxSR_RDxF_CLEAR(port
));
565 port
->icount
.rx
+= count
;
569 /* Tell the rest of the system the news. New characters! */
570 tty_flip_buffer_push(tty
);
572 sci_in(port
, SCxSR
); /* dummy read */
573 sci_out(port
, SCxSR
, SCxSR_RDxF_CLEAR(port
));
577 #define SCI_BREAK_JIFFIES (HZ/20)
578 /* The sci generates interrupts during the break,
579 * 1 per millisecond or so during the break period, for 9600 baud.
580 * So dont bother disabling interrupts.
581 * But dont want more than 1 break event.
582 * Use a kernel timer to periodically poll the rx line until
583 * the break is finished.
585 static void sci_schedule_break_timer(struct sci_port
*port
)
587 port
->break_timer
.expires
= jiffies
+ SCI_BREAK_JIFFIES
;
588 add_timer(&port
->break_timer
);
590 /* Ensure that two consecutive samples find the break over. */
591 static void sci_break_timer(unsigned long data
)
593 struct sci_port
*port
= (struct sci_port
*)data
;
595 if (sci_rxd_in(&port
->port
) == 0) {
596 port
->break_flag
= 1;
597 sci_schedule_break_timer(port
);
598 } else if (port
->break_flag
== 1) {
600 port
->break_flag
= 2;
601 sci_schedule_break_timer(port
);
603 port
->break_flag
= 0;
606 static inline int sci_handle_errors(struct uart_port
*port
)
609 unsigned short status
= sci_in(port
, SCxSR
);
610 struct tty_struct
*tty
= port
->info
->tty
;
612 if (status
& SCxSR_ORER(port
)) {
614 if (tty_insert_flip_char(tty
, 0, TTY_OVERRUN
))
616 pr_debug("sci: overrun error\n");
619 if (status
& SCxSR_FER(port
)) {
620 if (sci_rxd_in(port
) == 0) {
621 /* Notify of BREAK */
622 struct sci_port
*sci_port
= (struct sci_port
*)port
;
624 if (!sci_port
->break_flag
) {
625 sci_port
->break_flag
= 1;
626 sci_schedule_break_timer(sci_port
);
628 /* Do sysrq handling. */
629 if (uart_handle_break(port
))
631 pr_debug("sci: BREAK detected\n");
632 if (tty_insert_flip_char(tty
, 0, TTY_BREAK
))
637 if (tty_insert_flip_char(tty
, 0, TTY_FRAME
))
639 pr_debug("sci: frame error\n");
643 if (status
& SCxSR_PER(port
)) {
645 if (tty_insert_flip_char(tty
, 0, TTY_PARITY
))
647 pr_debug("sci: parity error\n");
651 tty_flip_buffer_push(tty
);
656 static inline int sci_handle_breaks(struct uart_port
*port
)
659 unsigned short status
= sci_in(port
, SCxSR
);
660 struct tty_struct
*tty
= port
->info
->tty
;
661 struct sci_port
*s
= &sci_ports
[port
->line
];
663 if (uart_handle_break(port
))
666 if (!s
->break_flag
&& status
& SCxSR_BRK(port
)) {
667 #if defined(CONFIG_CPU_SH3)
671 /* Notify of BREAK */
672 if (tty_insert_flip_char(tty
, 0, TTY_BREAK
))
674 pr_debug("sci: BREAK detected\n");
677 #if defined(SCIF_ORER)
678 /* XXX: Handle SCIF overrun error */
679 if (port
->type
== PORT_SCIF
&& (sci_in(port
, SCLSR
) & SCIF_ORER
) != 0) {
680 sci_out(port
, SCLSR
, 0);
681 if (tty_insert_flip_char(tty
, 0, TTY_OVERRUN
)) {
683 pr_debug("sci: overrun error\n");
689 tty_flip_buffer_push(tty
);
694 static irqreturn_t
sci_rx_interrupt(int irq
, void *port
)
696 /* I think sci_receive_chars has to be called irrespective
697 * of whether the I_IXOFF is set, otherwise, how is the interrupt
700 sci_receive_chars(port
);
705 static irqreturn_t
sci_tx_interrupt(int irq
, void *ptr
)
707 struct uart_port
*port
= ptr
;
709 spin_lock_irq(&port
->lock
);
710 sci_transmit_chars(port
);
711 spin_unlock_irq(&port
->lock
);
716 static irqreturn_t
sci_er_interrupt(int irq
, void *ptr
)
718 struct uart_port
*port
= ptr
;
721 if (port
->type
== PORT_SCI
) {
722 if (sci_handle_errors(port
)) {
723 /* discard character in rx buffer */
725 sci_out(port
, SCxSR
, SCxSR_RDxF_CLEAR(port
));
728 #if defined(SCIF_ORER)
729 if((sci_in(port
, SCLSR
) & SCIF_ORER
) != 0) {
730 struct tty_struct
*tty
= port
->info
->tty
;
732 sci_out(port
, SCLSR
, 0);
733 tty_insert_flip_char(tty
, 0, TTY_OVERRUN
);
734 tty_flip_buffer_push(tty
);
735 pr_debug("scif: overrun error\n");
738 sci_rx_interrupt(irq
, ptr
);
741 sci_out(port
, SCxSR
, SCxSR_ERROR_CLEAR(port
));
743 /* Kick the transmission */
744 sci_tx_interrupt(irq
, ptr
);
749 static irqreturn_t
sci_br_interrupt(int irq
, void *ptr
)
751 struct uart_port
*port
= ptr
;
754 sci_handle_breaks(port
);
755 sci_out(port
, SCxSR
, SCxSR_BREAK_CLEAR(port
));
760 static irqreturn_t
sci_mpxed_interrupt(int irq
, void *ptr
)
762 unsigned short ssr_status
, scr_status
;
763 struct uart_port
*port
= ptr
;
765 ssr_status
= sci_in(port
,SCxSR
);
766 scr_status
= sci_in(port
,SCSCR
);
769 if ((ssr_status
& 0x0020) && (scr_status
& 0x0080))
770 sci_tx_interrupt(irq
, ptr
);
772 if ((ssr_status
& 0x0002) && (scr_status
& 0x0040))
773 sci_rx_interrupt(irq
, ptr
);
774 /* Error Interrupt */
775 if ((ssr_status
& 0x0080) && (scr_status
& 0x0400))
776 sci_er_interrupt(irq
, ptr
);
777 /* Break Interrupt */
778 if ((ssr_status
& 0x0010) && (scr_status
& 0x0200))
779 sci_br_interrupt(irq
, ptr
);
784 #ifdef CONFIG_CPU_FREQ
786 * Here we define a transistion notifier so that we can update all of our
787 * ports' baud rate when the peripheral clock changes.
789 static int sci_notifier(struct notifier_block
*self
,
790 unsigned long phase
, void *p
)
792 struct cpufreq_freqs
*freqs
= p
;
795 if ((phase
== CPUFREQ_POSTCHANGE
) ||
796 (phase
== CPUFREQ_RESUMECHANGE
)){
797 for (i
= 0; i
< SCI_NPORTS
; i
++) {
798 struct uart_port
*port
= &sci_ports
[i
].port
;
802 * Update the uartclk per-port if frequency has
803 * changed, since it will no longer necessarily be
804 * consistent with the old frequency.
806 * Really we want to be able to do something like
807 * uart_change_speed() or something along those lines
808 * here to implicitly reset the per-port baud rate..
810 * Clean this up later..
812 clk
= clk_get(NULL
, "module_clk");
813 port
->uartclk
= clk_get_rate(clk
) * 16;
817 printk(KERN_INFO
"%s: got a postchange notification "
818 "for cpu %d (old %d, new %d)\n",
819 __FUNCTION__
, freqs
->cpu
, freqs
->old
, freqs
->new);
825 static struct notifier_block sci_nb
= { &sci_notifier
, NULL
, 0 };
826 #endif /* CONFIG_CPU_FREQ */
828 static int sci_request_irq(struct sci_port
*port
)
831 irqreturn_t (*handlers
[4])(int irq
, void *ptr
) = {
832 sci_er_interrupt
, sci_rx_interrupt
, sci_tx_interrupt
,
835 const char *desc
[] = { "SCI Receive Error", "SCI Receive Data Full",
836 "SCI Transmit Data Empty", "SCI Break" };
838 if (port
->irqs
[0] == port
->irqs
[1]) {
839 if (!port
->irqs
[0]) {
840 printk(KERN_ERR
"sci: Cannot allocate irq.(IRQ=0)\n");
844 if (request_irq(port
->irqs
[0], sci_mpxed_interrupt
,
845 IRQF_DISABLED
, "sci", port
)) {
846 printk(KERN_ERR
"sci: Cannot allocate irq.\n");
850 for (i
= 0; i
< ARRAY_SIZE(handlers
); i
++) {
853 if (request_irq(port
->irqs
[i
], handlers
[i
],
854 IRQF_DISABLED
, desc
[i
], port
)) {
855 printk(KERN_ERR
"sci: Cannot allocate irq.\n");
864 static void sci_free_irq(struct sci_port
*port
)
868 if (port
->irqs
[0] == port
->irqs
[1]) {
870 printk("sci: sci_free_irq error\n");
872 free_irq(port
->irqs
[0], port
);
874 for (i
= 0; i
< ARRAY_SIZE(port
->irqs
); i
++) {
878 free_irq(port
->irqs
[i
], port
);
883 static unsigned int sci_tx_empty(struct uart_port
*port
)
889 static void sci_set_mctrl(struct uart_port
*port
, unsigned int mctrl
)
891 /* This routine is used for seting signals of: DTR, DCD, CTS/RTS */
892 /* We use SCIF's hardware for CTS/RTS, so don't need any for that. */
893 /* If you have signals for DTR and DCD, please implement here. */
896 static unsigned int sci_get_mctrl(struct uart_port
*port
)
898 /* This routine is used for geting signals of: DTR, DCD, DSR, RI,
901 return TIOCM_DTR
| TIOCM_RTS
| TIOCM_DSR
;
904 static void sci_start_tx(struct uart_port
*port
)
908 /* Set TIE (Transmit Interrupt Enable) bit in SCSCR */
909 ctrl
= sci_in(port
, SCSCR
);
910 ctrl
|= SCI_CTRL_FLAGS_TIE
;
911 sci_out(port
, SCSCR
, ctrl
);
914 static void sci_stop_tx(struct uart_port
*port
)
918 /* Clear TIE (Transmit Interrupt Enable) bit in SCSCR */
919 ctrl
= sci_in(port
, SCSCR
);
920 ctrl
&= ~SCI_CTRL_FLAGS_TIE
;
921 sci_out(port
, SCSCR
, ctrl
);
924 static void sci_start_rx(struct uart_port
*port
, unsigned int tty_start
)
928 /* Set RIE (Receive Interrupt Enable) bit in SCSCR */
929 ctrl
= sci_in(port
, SCSCR
);
930 ctrl
|= SCI_CTRL_FLAGS_RIE
| SCI_CTRL_FLAGS_REIE
;
931 sci_out(port
, SCSCR
, ctrl
);
934 static void sci_stop_rx(struct uart_port
*port
)
938 /* Clear RIE (Receive Interrupt Enable) bit in SCSCR */
939 ctrl
= sci_in(port
, SCSCR
);
940 ctrl
&= ~(SCI_CTRL_FLAGS_RIE
| SCI_CTRL_FLAGS_REIE
);
941 sci_out(port
, SCSCR
, ctrl
);
944 static void sci_enable_ms(struct uart_port
*port
)
946 /* Nothing here yet .. */
949 static void sci_break_ctl(struct uart_port
*port
, int break_state
)
951 /* Nothing here yet .. */
954 static int sci_startup(struct uart_port
*port
)
956 struct sci_port
*s
= &sci_ports
[port
->line
];
961 s
->clk
= clk_get(NULL
, "module_clk");
965 sci_start_rx(port
, 1);
970 static void sci_shutdown(struct uart_port
*port
)
972 struct sci_port
*s
= &sci_ports
[port
->line
];
985 static void sci_set_termios(struct uart_port
*port
, struct ktermios
*termios
,
986 struct ktermios
*old
)
988 struct sci_port
*s
= &sci_ports
[port
->line
];
989 unsigned int status
, baud
, smr_val
;
992 baud
= uart_get_baud_rate(port
, termios
, old
, 0, port
->uartclk
/16);
1000 #if defined(CONFIG_SUPERH) && !defined(CONFIG_SUPERH64)
1001 t
= SCBRR_VALUE(baud
, clk_get_rate(s
->clk
));
1003 t
= SCBRR_VALUE(baud
);
1010 status
= sci_in(port
, SCxSR
);
1011 } while (!(status
& SCxSR_TEND(port
)));
1013 sci_out(port
, SCSCR
, 0x00); /* TE=0, RE=0, CKE1=0 */
1015 #if !defined(SCI_ONLY)
1016 if (port
->type
== PORT_SCIF
)
1017 sci_out(port
, SCFCR
, SCFCR_RFRST
| SCFCR_TFRST
);
1020 smr_val
= sci_in(port
, SCSMR
) & 3;
1021 if ((termios
->c_cflag
& CSIZE
) == CS7
)
1023 if (termios
->c_cflag
& PARENB
)
1025 if (termios
->c_cflag
& PARODD
)
1027 if (termios
->c_cflag
& CSTOPB
)
1030 uart_update_timeout(port
, termios
->c_cflag
, baud
);
1032 sci_out(port
, SCSMR
, smr_val
);
1036 sci_out(port
, SCSMR
, (sci_in(port
, SCSMR
) & ~3) | 1);
1039 sci_out(port
, SCSMR
, sci_in(port
, SCSMR
) & ~3);
1041 sci_out(port
, SCBRR
, t
);
1042 udelay((1000000+(baud
-1)) / baud
); /* Wait one bit interval */
1045 if (likely(s
->init_pins
))
1046 s
->init_pins(port
, termios
->c_cflag
);
1048 sci_out(port
, SCSCR
, SCSCR_INIT(port
));
1050 if ((termios
->c_cflag
& CREAD
) != 0)
1051 sci_start_rx(port
,0);
1054 static const char *sci_type(struct uart_port
*port
)
1056 switch (port
->type
) {
1057 case PORT_SCI
: return "sci";
1058 case PORT_SCIF
: return "scif";
1059 case PORT_IRDA
: return "irda";
1065 static void sci_release_port(struct uart_port
*port
)
1067 /* Nothing here yet .. */
1070 static int sci_request_port(struct uart_port
*port
)
1072 /* Nothing here yet .. */
1076 static void sci_config_port(struct uart_port
*port
, int flags
)
1078 struct sci_port
*s
= &sci_ports
[port
->line
];
1080 port
->type
= s
->type
;
1082 switch (port
->type
) {
1084 s
->init_pins
= sci_init_pins_sci
;
1087 s
->init_pins
= sci_init_pins_scif
;
1090 s
->init_pins
= sci_init_pins_irda
;
1094 #if defined(CONFIG_CPU_SUBTYPE_SH5_101) || defined(CONFIG_CPU_SUBTYPE_SH5_103)
1095 if (port
->mapbase
== 0)
1096 port
->mapbase
= onchip_remap(SCIF_ADDR_SH5
, 1024, "SCIF");
1098 port
->membase
= (void __iomem
*)port
->mapbase
;
1102 static int sci_verify_port(struct uart_port
*port
, struct serial_struct
*ser
)
1104 struct sci_port
*s
= &sci_ports
[port
->line
];
1106 if (ser
->irq
!= s
->irqs
[SCIx_TXI_IRQ
] || ser
->irq
> NR_IRQS
)
1108 if (ser
->baud_base
< 2400)
1109 /* No paper tape reader for Mitch.. */
1115 static struct uart_ops sci_uart_ops
= {
1116 .tx_empty
= sci_tx_empty
,
1117 .set_mctrl
= sci_set_mctrl
,
1118 .get_mctrl
= sci_get_mctrl
,
1119 .start_tx
= sci_start_tx
,
1120 .stop_tx
= sci_stop_tx
,
1121 .stop_rx
= sci_stop_rx
,
1122 .enable_ms
= sci_enable_ms
,
1123 .break_ctl
= sci_break_ctl
,
1124 .startup
= sci_startup
,
1125 .shutdown
= sci_shutdown
,
1126 .set_termios
= sci_set_termios
,
1128 .release_port
= sci_release_port
,
1129 .request_port
= sci_request_port
,
1130 .config_port
= sci_config_port
,
1131 .verify_port
= sci_verify_port
,
1134 static void __init
sci_init_ports(void)
1136 static int first
= 1;
1144 for (i
= 0; i
< SCI_NPORTS
; i
++) {
1145 sci_ports
[i
].port
.ops
= &sci_uart_ops
;
1146 sci_ports
[i
].port
.iotype
= UPIO_MEM
;
1147 sci_ports
[i
].port
.line
= i
;
1148 sci_ports
[i
].port
.fifosize
= 1;
1150 #if defined(__H8300H__) || defined(__H8300S__)
1152 sci_ports
[i
].enable
= h8300_sci_enable
;
1153 sci_ports
[i
].disable
= h8300_sci_disable
;
1155 sci_ports
[i
].port
.uartclk
= CONFIG_CPU_CLOCK
;
1156 #elif defined(CONFIG_SUPERH64)
1157 sci_ports
[i
].port
.uartclk
= current_cpu_data
.module_clock
* 16;
1160 * XXX: We should use a proper SCI/SCIF clock
1163 struct clk
*clk
= clk_get(NULL
, "module_clk");
1164 sci_ports
[i
].port
.uartclk
= clk_get_rate(clk
) * 16;
1169 sci_ports
[i
].break_timer
.data
= (unsigned long)&sci_ports
[i
];
1170 sci_ports
[i
].break_timer
.function
= sci_break_timer
;
1172 init_timer(&sci_ports
[i
].break_timer
);
1176 int __init
early_sci_setup(struct uart_port
*port
)
1178 if (unlikely(port
->line
> SCI_NPORTS
))
1183 sci_ports
[port
->line
].port
.membase
= port
->membase
;
1184 sci_ports
[port
->line
].port
.mapbase
= port
->mapbase
;
1185 sci_ports
[port
->line
].port
.type
= port
->type
;
1190 #ifdef CONFIG_SERIAL_SH_SCI_CONSOLE
1192 * Print a string to the serial port trying not to disturb
1193 * any possible real use of the port...
1195 static void serial_console_write(struct console
*co
, const char *s
,
1198 put_string(serial_console_port
, s
, count
);
1201 static int __init
serial_console_setup(struct console
*co
, char *options
)
1203 struct uart_port
*port
;
1211 * Check whether an invalid uart number has been specified, and
1212 * if so, search for the first available port that does have
1215 if (co
->index
>= SCI_NPORTS
)
1218 serial_console_port
= &sci_ports
[co
->index
];
1219 port
= &serial_console_port
->port
;
1222 * Also need to check port->type, we don't actually have any
1223 * UPIO_PORT ports, but uart_report_port() handily misreports
1224 * it anyways if we don't have a port available by the time this is
1229 if (!port
->membase
|| !port
->mapbase
)
1232 port
->type
= serial_console_port
->type
;
1234 if (port
->flags
& UPF_IOREMAP
)
1235 sci_config_port(port
, 0);
1237 if (serial_console_port
->enable
)
1238 serial_console_port
->enable(port
);
1241 uart_parse_options(options
, &baud
, &parity
, &bits
, &flow
);
1243 ret
= uart_set_options(port
, co
, baud
, parity
, bits
, flow
);
1244 #if defined(__H8300H__) || defined(__H8300S__)
1245 /* disable rx interrupt */
1252 static struct console serial_console
= {
1254 .device
= uart_console_device
,
1255 .write
= serial_console_write
,
1256 .setup
= serial_console_setup
,
1257 .flags
= CON_PRINTBUFFER
,
1259 .data
= &sci_uart_driver
,
1262 static int __init
sci_console_init(void)
1265 register_console(&serial_console
);
1268 console_initcall(sci_console_init
);
1269 #endif /* CONFIG_SERIAL_SH_SCI_CONSOLE */
1271 #ifdef CONFIG_SH_KGDB
1273 * FIXME: Most of this can go away.. at the moment, we rely on
1274 * arch/sh/kernel/setup.c to do the command line parsing for kgdb, though
1275 * most of that can easily be done here instead.
1277 * For the time being, just accept the values that were parsed earlier..
1279 static void __init
kgdb_console_get_options(struct uart_port
*port
, int *baud
,
1280 int *parity
, int *bits
)
1283 *parity
= tolower(kgdb_parity
);
1284 *bits
= kgdb_bits
- '0';
1288 * The naming here is somewhat misleading, since kgdb_console_setup() takes
1289 * care of the early-on initialization for kgdb, regardless of whether we
1290 * actually use kgdb as a console or not.
1292 * On the plus side, this lets us kill off the old kgdb_sci_setup() nonsense.
1294 int __init
kgdb_console_setup(struct console
*co
, char *options
)
1296 struct uart_port
*port
= &sci_ports
[kgdb_portnum
].port
;
1302 if (co
->index
!= kgdb_portnum
)
1303 co
->index
= kgdb_portnum
;
1305 kgdb_sci_port
= &sci_ports
[co
->index
];
1306 port
= &kgdb_sci_port
->port
;
1309 * Also need to check port->type, we don't actually have any
1310 * UPIO_PORT ports, but uart_report_port() handily misreports
1311 * it anyways if we don't have a port available by the time this is
1316 if (!port
->membase
|| !port
->mapbase
)
1320 uart_parse_options(options
, &baud
, &parity
, &bits
, &flow
);
1322 kgdb_console_get_options(port
, &baud
, &parity
, &bits
);
1324 kgdb_getchar
= kgdb_sci_getchar
;
1325 kgdb_putchar
= kgdb_sci_putchar
;
1327 return uart_set_options(port
, co
, baud
, parity
, bits
, flow
);
1329 #endif /* CONFIG_SH_KGDB */
1331 #ifdef CONFIG_SH_KGDB_CONSOLE
1332 static struct console kgdb_console
= {
1334 .device
= uart_console_device
,
1335 .write
= kgdb_console_write
,
1336 .setup
= kgdb_console_setup
,
1337 .flags
= CON_PRINTBUFFER
,
1339 .data
= &sci_uart_driver
,
1342 /* Register the KGDB console so we get messages (d'oh!) */
1343 static int __init
kgdb_console_init(void)
1346 register_console(&kgdb_console
);
1349 console_initcall(kgdb_console_init
);
1350 #endif /* CONFIG_SH_KGDB_CONSOLE */
1352 #if defined(CONFIG_SH_KGDB_CONSOLE)
1353 #define SCI_CONSOLE &kgdb_console
1354 #elif defined(CONFIG_SERIAL_SH_SCI_CONSOLE)
1355 #define SCI_CONSOLE &serial_console
1357 #define SCI_CONSOLE 0
1360 static char banner
[] __initdata
=
1361 KERN_INFO
"SuperH SCI(F) driver initialized\n";
1363 static struct uart_driver sci_uart_driver
= {
1364 .owner
= THIS_MODULE
,
1365 .driver_name
= "sci",
1366 .dev_name
= "ttySC",
1368 .minor
= SCI_MINOR_START
,
1370 .cons
= SCI_CONSOLE
,
1374 * Register a set of serial devices attached to a platform device. The
1375 * list is terminated with a zero flags entry, which means we expect
1376 * all entries to have at least UPF_BOOT_AUTOCONF set. Platforms that need
1377 * remapping (such as sh64) should also set UPF_IOREMAP.
1379 static int __devinit
sci_probe(struct platform_device
*dev
)
1381 struct plat_sci_port
*p
= dev
->dev
.platform_data
;
1384 for (i
= 0; p
&& p
->flags
!= 0; p
++, i
++) {
1385 struct sci_port
*sciport
= &sci_ports
[i
];
1388 if (unlikely(i
== SCI_NPORTS
)) {
1389 dev_notice(&dev
->dev
, "Attempting to register port "
1390 "%d when only %d are available.\n",
1392 dev_notice(&dev
->dev
, "Consider bumping "
1393 "CONFIG_SERIAL_SH_SCI_NR_UARTS!\n");
1397 sciport
->port
.mapbase
= p
->mapbase
;
1400 * For the simple (and majority of) cases where we don't need
1401 * to do any remapping, just cast the cookie directly.
1403 if (p
->mapbase
&& !p
->membase
&& !(p
->flags
& UPF_IOREMAP
))
1404 p
->membase
= (void __iomem
*)p
->mapbase
;
1406 sciport
->port
.membase
= p
->membase
;
1408 sciport
->port
.irq
= p
->irqs
[SCIx_TXI_IRQ
];
1409 sciport
->port
.flags
= p
->flags
;
1410 sciport
->port
.dev
= &dev
->dev
;
1412 sciport
->type
= sciport
->port
.type
= p
->type
;
1414 memcpy(&sciport
->irqs
, &p
->irqs
, sizeof(p
->irqs
));
1416 uart_add_one_port(&sci_uart_driver
, &sciport
->port
);
1419 #if defined(CONFIG_SH_KGDB) && !defined(CONFIG_SH_KGDB_CONSOLE)
1420 kgdb_sci_port
= &sci_ports
[kgdb_portnum
];
1421 kgdb_getchar
= kgdb_sci_getchar
;
1422 kgdb_putchar
= kgdb_sci_putchar
;
1425 #ifdef CONFIG_CPU_FREQ
1426 cpufreq_register_notifier(&sci_nb
, CPUFREQ_TRANSITION_NOTIFIER
);
1427 dev_info(&dev
->dev
, "sci: CPU frequency notifier registered\n");
1430 #ifdef CONFIG_SH_STANDARD_BIOS
1431 sh_bios_gdb_detach();
1437 static int __devexit
sci_remove(struct platform_device
*dev
)
1441 for (i
= 0; i
< SCI_NPORTS
; i
++)
1442 uart_remove_one_port(&sci_uart_driver
, &sci_ports
[i
].port
);
1447 static int sci_suspend(struct platform_device
*dev
, pm_message_t state
)
1451 for (i
= 0; i
< SCI_NPORTS
; i
++) {
1452 struct sci_port
*p
= &sci_ports
[i
];
1454 if (p
->type
!= PORT_UNKNOWN
&& p
->port
.dev
== &dev
->dev
)
1455 uart_suspend_port(&sci_uart_driver
, &p
->port
);
1461 static int sci_resume(struct platform_device
*dev
)
1465 for (i
= 0; i
< SCI_NPORTS
; i
++) {
1466 struct sci_port
*p
= &sci_ports
[i
];
1468 if (p
->type
!= PORT_UNKNOWN
&& p
->port
.dev
== &dev
->dev
)
1469 uart_resume_port(&sci_uart_driver
, &p
->port
);
1475 static struct platform_driver sci_driver
= {
1477 .remove
= __devexit_p(sci_remove
),
1478 .suspend
= sci_suspend
,
1479 .resume
= sci_resume
,
1482 .owner
= THIS_MODULE
,
1486 static int __init
sci_init(void)
1494 ret
= uart_register_driver(&sci_uart_driver
);
1495 if (likely(ret
== 0)) {
1496 ret
= platform_driver_register(&sci_driver
);
1498 uart_unregister_driver(&sci_uart_driver
);
1504 static void __exit
sci_exit(void)
1506 platform_driver_unregister(&sci_driver
);
1507 uart_unregister_driver(&sci_uart_driver
);
1510 module_init(sci_init
);
1511 module_exit(sci_exit
);
1513 MODULE_LICENSE("GPL");