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;
83 static struct sci_port *kgdb_sci_port;
86 #ifdef CONFIG_SERIAL_SH_SCI_CONSOLE
87 static struct sci_port *serial_console_port;
90 /* Function prototypes */
91 static void sci_stop_tx(struct uart_port *port);
93 #define SCI_NPORTS CONFIG_SERIAL_SH_SCI_NR_UARTS
95 static struct sci_port sci_ports[SCI_NPORTS];
96 static struct uart_driver sci_uart_driver;
98 #if defined(CONFIG_SERIAL_SH_SCI_CONSOLE) && \
99 defined(CONFIG_SH_STANDARD_BIOS) || defined(CONFIG_SH_KGDB)
100 static inline void handle_error(struct uart_port *port)
102 /* Clear error flags */
103 sci_out(port, SCxSR, SCxSR_ERROR_CLEAR(port));
106 static int get_char(struct uart_port *port)
109 unsigned short status;
112 spin_lock_irqsave(&port->lock, flags);
114 status = sci_in(port, SCxSR);
115 if (status & SCxSR_ERRORS(port)) {
119 } while (!(status & SCxSR_RDxF(port)));
120 c = sci_in(port, SCxRDR);
121 sci_in(port, SCxSR); /* Dummy read */
122 sci_out(port, SCxSR, SCxSR_RDxF_CLEAR(port));
123 spin_unlock_irqrestore(&port->lock, flags);
127 #endif /* CONFIG_SH_STANDARD_BIOS || CONFIG_SH_KGDB */
129 #if defined(CONFIG_SERIAL_SH_SCI_CONSOLE) || defined(CONFIG_SH_KGDB)
130 static void put_char(struct uart_port *port, char c)
133 unsigned short status;
135 spin_lock_irqsave(&port->lock, flags);
138 status = sci_in(port, SCxSR);
139 } while (!(status & SCxSR_TDxE(port)));
141 sci_out(port, SCxTDR, c);
142 sci_in(port, SCxSR); /* Dummy read */
143 sci_out(port, SCxSR, SCxSR_TDxE_CLEAR(port));
145 spin_unlock_irqrestore(&port->lock, flags);
149 #ifdef CONFIG_SERIAL_SH_SCI_CONSOLE
150 static void put_string(struct sci_port *sci_port, const char *buffer, int count)
152 struct uart_port *port = &sci_port->port;
153 const unsigned char *p = buffer;
156 #if defined(CONFIG_SH_STANDARD_BIOS) || defined(CONFIG_SH_KGDB)
160 #ifdef CONFIG_SH_STANDARD_BIOS
161 /* This call only does a trap the first time it is
162 * called, and so is safe to do here unconditionally
164 usegdb |= sh_bios_in_gdb_mode();
166 #ifdef CONFIG_SH_KGDB
167 usegdb |= (kgdb_in_gdb_mode && (sci_port == kgdb_sci_port));
171 /* $<packet info>#<checksum>. */
175 put_char(port, 'O'); /* 'O'utput to console */
178 for (i=0; i<count; i++) { /* Don't use run length encoding */
189 put_char(port, highhex(checksum));
190 put_char(port, lowhex(checksum));
191 } while (get_char(port) != '+');
193 #endif /* CONFIG_SH_STANDARD_BIOS || CONFIG_SH_KGDB */
194 for (i=0; i<count; i++) {
196 put_char(port, '\r');
197 put_char(port, *p++);
200 #endif /* CONFIG_SERIAL_SH_SCI_CONSOLE */
202 #ifdef CONFIG_SH_KGDB
203 static int kgdb_sci_getchar(void)
207 /* Keep trying to read a character, this could be neater */
208 while ((c = get_char(&kgdb_sci_port->port)) < 0)
214 static inline void kgdb_sci_putchar(int c)
216 put_char(&kgdb_sci_port->port, c);
218 #endif /* CONFIG_SH_KGDB */
220 #if defined(__H8300S__)
221 enum { sci_disable, sci_enable };
223 static void h8300_sci_config(struct uart_port* port, unsigned int ctrl)
225 volatile unsigned char *mstpcrl=(volatile unsigned char *)MSTPCRL;
226 int ch = (port->mapbase - SMR0) >> 3;
227 unsigned char mask = 1 << (ch+1);
229 if (ctrl == sci_disable) {
236 static inline void h8300_sci_enable(struct uart_port *port)
238 h8300_sci_config(port, sci_enable);
241 static inline void h8300_sci_disable(struct uart_port *port)
243 h8300_sci_config(port, sci_disable);
247 #if defined(SCI_ONLY) || defined(SCI_AND_SCIF) && \
248 defined(__H8300H__) || defined(__H8300S__)
249 static void sci_init_pins_sci(struct uart_port* port, unsigned int cflag)
251 int ch = (port->mapbase - SMR0) >> 3;
254 H8300_GPIO_DDR(h8300_sci_pins[ch].port,
255 h8300_sci_pins[ch].rx,
257 H8300_GPIO_DDR(h8300_sci_pins[ch].port,
258 h8300_sci_pins[ch].tx,
262 H8300_SCI_DR(ch) |= h8300_sci_pins[ch].tx;
265 #define sci_init_pins_sci NULL
268 #if defined(CONFIG_CPU_SUBTYPE_SH7707) || defined(CONFIG_CPU_SUBTYPE_SH7709)
269 static void sci_init_pins_irda(struct uart_port *port, unsigned int cflag)
271 unsigned int fcr_val = 0;
274 fcr_val |= SCFCR_MCE;
276 sci_out(port, SCFCR, fcr_val);
279 #define sci_init_pins_irda NULL
283 #define sci_init_pins_scif NULL
286 #if defined(SCIF_ONLY) || defined(SCI_AND_SCIF)
287 #if defined(CONFIG_CPU_SUBTYPE_SH7300) || defined(CONFIG_CPU_SUBTYPE_SH7710)
288 /* SH7300 doesn't use RTS/CTS */
289 static void sci_init_pins_scif(struct uart_port *port, unsigned int cflag)
291 sci_out(port, SCFCR, 0);
293 #elif defined(CONFIG_CPU_SH3)
294 /* For SH7705, SH7706, SH7707, SH7709, SH7709A, SH7729 */
295 static void sci_init_pins_scif(struct uart_port *port, unsigned int cflag)
297 unsigned int fcr_val = 0;
300 /* We need to set SCPCR to enable RTS/CTS */
301 data = ctrl_inw(SCPCR);
302 /* Clear out SCP7MD1,0, SCP6MD1,0, SCP4MD1,0*/
303 ctrl_outw(data & 0x0fcf, SCPCR);
306 fcr_val |= SCFCR_MCE;
308 /* We need to set SCPCR to enable RTS/CTS */
309 data = ctrl_inw(SCPCR);
310 /* Clear out SCP7MD1,0, SCP4MD1,0,
311 Set SCP6MD1,0 = {01} (output) */
312 ctrl_outw((data & 0x0fcf) | 0x1000, SCPCR);
314 data = ctrl_inb(SCPDR);
315 /* Set /RTS2 (bit6) = 0 */
316 ctrl_outb(data & 0xbf, SCPDR);
319 sci_out(port, SCFCR, fcr_val);
321 #elif defined(CONFIG_CPU_SUBTYPE_SH7722)
322 static void sci_init_pins_scif(struct uart_port *port, unsigned int cflag)
324 unsigned int fcr_val = 0;
326 if (cflag & CRTSCTS) {
327 fcr_val |= SCFCR_MCE;
329 ctrl_outw(0x0000, PORT_PSCR);
333 data = ctrl_inw(PORT_PSCR);
336 ctrl_outw(data, PORT_PSCR);
338 ctrl_outw(ctrl_inw(SCSPTR0) & 0x17, SCSPTR0);
341 sci_out(port, SCFCR, fcr_val);
345 static void sci_init_pins_scif(struct uart_port *port, unsigned int cflag)
347 unsigned int fcr_val = 0;
349 if (cflag & CRTSCTS) {
350 fcr_val |= SCFCR_MCE;
352 #ifdef CONFIG_CPU_SUBTYPE_SH7343
354 #elif defined(CONFIG_CPU_SUBTYPE_SH7780) || defined(CONFIG_CPU_SUBTYPE_SH7785)
355 ctrl_outw(0x0080, SCSPTR0); /* Set RTS = 1 */
357 ctrl_outw(0x0080, SCSPTR2); /* Set RTS = 1 */
360 sci_out(port, SCFCR, fcr_val);
364 #if defined(CONFIG_CPU_SUBTYPE_SH7760) || \
365 defined(CONFIG_CPU_SUBTYPE_SH7780) || \
366 defined(CONFIG_CPU_SUBTYPE_SH7785)
367 static inline int scif_txroom(struct uart_port *port)
369 return SCIF_TXROOM_MAX - (sci_in(port, SCTFDR) & 0x7f);
372 static inline int scif_rxroom(struct uart_port *port)
374 return sci_in(port, SCRFDR) & 0x7f;
377 static inline int scif_txroom(struct uart_port *port)
379 return SCIF_TXROOM_MAX - (sci_in(port, SCFDR) >> 8);
382 static inline int scif_rxroom(struct uart_port *port)
384 return sci_in(port, SCFDR) & SCIF_RFDC_MASK;
387 #endif /* SCIF_ONLY || SCI_AND_SCIF */
389 static inline int sci_txroom(struct uart_port *port)
391 return ((sci_in(port, SCxSR) & SCI_TDRE) != 0);
394 static inline int sci_rxroom(struct uart_port *port)
396 return ((sci_in(port, SCxSR) & SCxSR_RDxF(port)) != 0);
399 /* ********************************************************************** *
400 * the interrupt related routines *
401 * ********************************************************************** */
403 static void sci_transmit_chars(struct uart_port *port)
405 struct circ_buf *xmit = &port->info->xmit;
406 unsigned int stopped = uart_tx_stopped(port);
407 unsigned short status;
411 status = sci_in(port, SCxSR);
412 if (!(status & SCxSR_TDxE(port))) {
413 ctrl = sci_in(port, SCSCR);
414 if (uart_circ_empty(xmit)) {
415 ctrl &= ~SCI_CTRL_FLAGS_TIE;
417 ctrl |= SCI_CTRL_FLAGS_TIE;
419 sci_out(port, SCSCR, ctrl);
424 if (port->type == PORT_SCIF)
425 count = scif_txroom(port);
428 count = sci_txroom(port);
436 } else if (!uart_circ_empty(xmit) && !stopped) {
437 c = xmit->buf[xmit->tail];
438 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
443 sci_out(port, SCxTDR, c);
446 } while (--count > 0);
448 sci_out(port, SCxSR, SCxSR_TDxE_CLEAR(port));
450 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
451 uart_write_wakeup(port);
452 if (uart_circ_empty(xmit)) {
455 ctrl = sci_in(port, SCSCR);
457 #if !defined(SCI_ONLY)
458 if (port->type == PORT_SCIF) {
459 sci_in(port, SCxSR); /* Dummy read */
460 sci_out(port, SCxSR, SCxSR_TDxE_CLEAR(port));
464 ctrl |= SCI_CTRL_FLAGS_TIE;
465 sci_out(port, SCSCR, ctrl);
469 /* On SH3, SCIF may read end-of-break as a space->mark char */
470 #define STEPFN(c) ({int __c=(c); (((__c-1)|(__c)) == -1); })
472 static inline void sci_receive_chars(struct uart_port *port)
474 struct sci_port *sci_port = (struct sci_port *)port;
475 struct tty_struct *tty = port->info->tty;
476 int i, count, copied = 0;
477 unsigned short status;
480 status = sci_in(port, SCxSR);
481 if (!(status & SCxSR_RDxF(port)))
485 #if !defined(SCI_ONLY)
486 if (port->type == PORT_SCIF)
487 count = scif_rxroom(port);
490 count = sci_rxroom(port);
492 /* Don't copy more bytes than there is room for in the buffer */
493 count = tty_buffer_request_room(tty, count);
495 /* If for any reason we can't copy more data, we're done! */
499 if (port->type == PORT_SCI) {
500 char c = sci_in(port, SCxRDR);
501 if (uart_handle_sysrq_char(port, c) || sci_port->break_flag)
504 tty_insert_flip_char(tty, c, TTY_NORMAL);
507 for (i=0; i<count; i++) {
508 char c = sci_in(port, SCxRDR);
509 status = sci_in(port, SCxSR);
510 #if defined(CONFIG_CPU_SH3)
511 /* Skip "chars" during break */
512 if (sci_port->break_flag) {
514 (status & SCxSR_FER(port))) {
519 /* Nonzero => end-of-break */
520 pr_debug("scif: debounce<%02x>\n", c);
521 sci_port->break_flag = 0;
528 #endif /* CONFIG_CPU_SH3 */
529 if (uart_handle_sysrq_char(port, c)) {
534 /* Store data and status */
535 if (status&SCxSR_FER(port)) {
537 pr_debug("sci: frame error\n");
538 } else if (status&SCxSR_PER(port)) {
540 pr_debug("sci: parity error\n");
543 tty_insert_flip_char(tty, c, flag);
547 sci_in(port, SCxSR); /* dummy read */
548 sci_out(port, SCxSR, SCxSR_RDxF_CLEAR(port));
551 port->icount.rx += count;
555 /* Tell the rest of the system the news. New characters! */
556 tty_flip_buffer_push(tty);
558 sci_in(port, SCxSR); /* dummy read */
559 sci_out(port, SCxSR, SCxSR_RDxF_CLEAR(port));
563 #define SCI_BREAK_JIFFIES (HZ/20)
564 /* The sci generates interrupts during the break,
565 * 1 per millisecond or so during the break period, for 9600 baud.
566 * So dont bother disabling interrupts.
567 * But dont want more than 1 break event.
568 * Use a kernel timer to periodically poll the rx line until
569 * the break is finished.
571 static void sci_schedule_break_timer(struct sci_port *port)
573 port->break_timer.expires = jiffies + SCI_BREAK_JIFFIES;
574 add_timer(&port->break_timer);
576 /* Ensure that two consecutive samples find the break over. */
577 static void sci_break_timer(unsigned long data)
579 struct sci_port *port = (struct sci_port *)data;
581 if (sci_rxd_in(&port->port) == 0) {
582 port->break_flag = 1;
583 sci_schedule_break_timer(port);
584 } else if (port->break_flag == 1) {
586 port->break_flag = 2;
587 sci_schedule_break_timer(port);
589 port->break_flag = 0;
592 static inline int sci_handle_errors(struct uart_port *port)
595 unsigned short status = sci_in(port, SCxSR);
596 struct tty_struct *tty = port->info->tty;
598 if (status & SCxSR_ORER(port)) {
600 if (tty_insert_flip_char(tty, 0, TTY_OVERRUN))
602 pr_debug("sci: overrun error\n");
605 if (status & SCxSR_FER(port)) {
606 if (sci_rxd_in(port) == 0) {
607 /* Notify of BREAK */
608 struct sci_port *sci_port = (struct sci_port *)port;
610 if (!sci_port->break_flag) {
611 sci_port->break_flag = 1;
612 sci_schedule_break_timer(sci_port);
614 /* Do sysrq handling. */
615 if (uart_handle_break(port))
617 pr_debug("sci: BREAK detected\n");
618 if (tty_insert_flip_char(tty, 0, TTY_BREAK))
623 if (tty_insert_flip_char(tty, 0, TTY_FRAME))
625 pr_debug("sci: frame error\n");
629 if (status & SCxSR_PER(port)) {
631 if (tty_insert_flip_char(tty, 0, TTY_PARITY))
633 pr_debug("sci: parity error\n");
637 tty_flip_buffer_push(tty);
642 static inline int sci_handle_breaks(struct uart_port *port)
645 unsigned short status = sci_in(port, SCxSR);
646 struct tty_struct *tty = port->info->tty;
647 struct sci_port *s = &sci_ports[port->line];
649 if (uart_handle_break(port))
652 if (!s->break_flag && status & SCxSR_BRK(port)) {
653 #if defined(CONFIG_CPU_SH3)
657 /* Notify of BREAK */
658 if (tty_insert_flip_char(tty, 0, TTY_BREAK))
660 pr_debug("sci: BREAK detected\n");
663 #if defined(SCIF_ORER)
664 /* XXX: Handle SCIF overrun error */
665 if (port->type == PORT_SCIF && (sci_in(port, SCLSR) & SCIF_ORER) != 0) {
666 sci_out(port, SCLSR, 0);
667 if (tty_insert_flip_char(tty, 0, TTY_OVERRUN)) {
669 pr_debug("sci: overrun error\n");
675 tty_flip_buffer_push(tty);
680 static irqreturn_t sci_rx_interrupt(int irq, void *port)
682 /* I think sci_receive_chars has to be called irrespective
683 * of whether the I_IXOFF is set, otherwise, how is the interrupt
686 sci_receive_chars(port);
691 static irqreturn_t sci_tx_interrupt(int irq, void *ptr)
693 struct uart_port *port = ptr;
695 spin_lock_irq(&port->lock);
696 sci_transmit_chars(port);
697 spin_unlock_irq(&port->lock);
702 static irqreturn_t sci_er_interrupt(int irq, void *ptr)
704 struct uart_port *port = ptr;
707 if (port->type == PORT_SCI) {
708 if (sci_handle_errors(port)) {
709 /* discard character in rx buffer */
711 sci_out(port, SCxSR, SCxSR_RDxF_CLEAR(port));
714 #if defined(SCIF_ORER)
715 if((sci_in(port, SCLSR) & SCIF_ORER) != 0) {
716 struct tty_struct *tty = port->info->tty;
718 sci_out(port, SCLSR, 0);
719 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
720 tty_flip_buffer_push(tty);
721 pr_debug("scif: overrun error\n");
724 sci_rx_interrupt(irq, ptr);
727 sci_out(port, SCxSR, SCxSR_ERROR_CLEAR(port));
729 /* Kick the transmission */
730 sci_tx_interrupt(irq, ptr);
735 static irqreturn_t sci_br_interrupt(int irq, void *ptr)
737 struct uart_port *port = ptr;
740 sci_handle_breaks(port);
741 sci_out(port, SCxSR, SCxSR_BREAK_CLEAR(port));
746 static irqreturn_t sci_mpxed_interrupt(int irq, void *ptr)
748 unsigned short ssr_status, scr_status;
749 struct uart_port *port = ptr;
751 ssr_status = sci_in(port,SCxSR);
752 scr_status = sci_in(port,SCSCR);
755 if ((ssr_status & 0x0020) && (scr_status & 0x0080))
756 sci_tx_interrupt(irq, ptr);
758 if ((ssr_status & 0x0002) && (scr_status & 0x0040))
759 sci_rx_interrupt(irq, ptr);
760 /* Error Interrupt */
761 if ((ssr_status & 0x0080) && (scr_status & 0x0400))
762 sci_er_interrupt(irq, ptr);
763 /* Break Interrupt */
764 if ((ssr_status & 0x0010) && (scr_status & 0x0200))
765 sci_br_interrupt(irq, ptr);
770 #ifdef CONFIG_CPU_FREQ
772 * Here we define a transistion notifier so that we can update all of our
773 * ports' baud rate when the peripheral clock changes.
775 static int sci_notifier(struct notifier_block *self,
776 unsigned long phase, void *p)
778 struct cpufreq_freqs *freqs = p;
781 if ((phase == CPUFREQ_POSTCHANGE) ||
782 (phase == CPUFREQ_RESUMECHANGE)){
783 for (i = 0; i < SCI_NPORTS; i++) {
784 struct uart_port *port = &sci_ports[i].port;
788 * Update the uartclk per-port if frequency has
789 * changed, since it will no longer necessarily be
790 * consistent with the old frequency.
792 * Really we want to be able to do something like
793 * uart_change_speed() or something along those lines
794 * here to implicitly reset the per-port baud rate..
796 * Clean this up later..
798 clk = clk_get(NULL, "module_clk");
799 port->uartclk = clk_get_rate(clk) * 16;
803 printk(KERN_INFO "%s: got a postchange notification "
804 "for cpu %d (old %d, new %d)\n",
805 __FUNCTION__, freqs->cpu, freqs->old, freqs->new);
811 static struct notifier_block sci_nb = { &sci_notifier, NULL, 0 };
812 #endif /* CONFIG_CPU_FREQ */
814 static int sci_request_irq(struct sci_port *port)
817 irqreturn_t (*handlers[4])(int irq, void *ptr) = {
818 sci_er_interrupt, sci_rx_interrupt, sci_tx_interrupt,
821 const char *desc[] = { "SCI Receive Error", "SCI Receive Data Full",
822 "SCI Transmit Data Empty", "SCI Break" };
824 if (port->irqs[0] == port->irqs[1]) {
825 if (!port->irqs[0]) {
826 printk(KERN_ERR "sci: Cannot allocate irq.(IRQ=0)\n");
830 if (request_irq(port->irqs[0], sci_mpxed_interrupt,
831 IRQF_DISABLED, "sci", port)) {
832 printk(KERN_ERR "sci: Cannot allocate irq.\n");
836 for (i = 0; i < ARRAY_SIZE(handlers); i++) {
839 if (request_irq(port->irqs[i], handlers[i],
840 IRQF_DISABLED, desc[i], port)) {
841 printk(KERN_ERR "sci: Cannot allocate irq.\n");
850 static void sci_free_irq(struct sci_port *port)
854 if (port->irqs[0] == port->irqs[1]) {
856 printk("sci: sci_free_irq error\n");
858 free_irq(port->irqs[0], port);
860 for (i = 0; i < ARRAY_SIZE(port->irqs); i++) {
864 free_irq(port->irqs[i], port);
869 static unsigned int sci_tx_empty(struct uart_port *port)
875 static void sci_set_mctrl(struct uart_port *port, unsigned int mctrl)
877 /* This routine is used for seting signals of: DTR, DCD, CTS/RTS */
878 /* We use SCIF's hardware for CTS/RTS, so don't need any for that. */
879 /* If you have signals for DTR and DCD, please implement here. */
882 static unsigned int sci_get_mctrl(struct uart_port *port)
884 /* This routine is used for geting signals of: DTR, DCD, DSR, RI,
887 return TIOCM_DTR | TIOCM_RTS | TIOCM_DSR;
890 static void sci_start_tx(struct uart_port *port)
894 /* Set TIE (Transmit Interrupt Enable) bit in SCSCR */
895 ctrl = sci_in(port, SCSCR);
896 ctrl |= SCI_CTRL_FLAGS_TIE;
897 sci_out(port, SCSCR, ctrl);
900 static void sci_stop_tx(struct uart_port *port)
904 /* Clear TIE (Transmit Interrupt Enable) bit in SCSCR */
905 ctrl = sci_in(port, SCSCR);
906 ctrl &= ~SCI_CTRL_FLAGS_TIE;
907 sci_out(port, SCSCR, ctrl);
910 static void sci_start_rx(struct uart_port *port, unsigned int tty_start)
914 /* Set RIE (Receive Interrupt Enable) bit in SCSCR */
915 ctrl = sci_in(port, SCSCR);
916 ctrl |= SCI_CTRL_FLAGS_RIE | SCI_CTRL_FLAGS_REIE;
917 sci_out(port, SCSCR, ctrl);
920 static void sci_stop_rx(struct uart_port *port)
924 /* Clear RIE (Receive Interrupt Enable) bit in SCSCR */
925 ctrl = sci_in(port, SCSCR);
926 ctrl &= ~(SCI_CTRL_FLAGS_RIE | SCI_CTRL_FLAGS_REIE);
927 sci_out(port, SCSCR, ctrl);
930 static void sci_enable_ms(struct uart_port *port)
932 /* Nothing here yet .. */
935 static void sci_break_ctl(struct uart_port *port, int break_state)
937 /* Nothing here yet .. */
940 static int sci_startup(struct uart_port *port)
942 struct sci_port *s = &sci_ports[port->line];
949 sci_start_rx(port, 1);
954 static void sci_shutdown(struct uart_port *port)
956 struct sci_port *s = &sci_ports[port->line];
966 static void sci_set_termios(struct uart_port *port, struct ktermios *termios,
967 struct ktermios *old)
969 struct sci_port *s = &sci_ports[port->line];
970 unsigned int status, baud, smr_val;
973 baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
981 #if defined(CONFIG_SUPERH) && !defined(CONFIG_SUPERH64)
982 struct clk *clk = clk_get(NULL, "module_clk");
983 t = SCBRR_VALUE(baud, clk_get_rate(clk));
986 t = SCBRR_VALUE(baud);
993 status = sci_in(port, SCxSR);
994 } while (!(status & SCxSR_TEND(port)));
996 sci_out(port, SCSCR, 0x00); /* TE=0, RE=0, CKE1=0 */
998 #if !defined(SCI_ONLY)
999 if (port->type == PORT_SCIF)
1000 sci_out(port, SCFCR, SCFCR_RFRST | SCFCR_TFRST);
1003 smr_val = sci_in(port, SCSMR) & 3;
1004 if ((termios->c_cflag & CSIZE) == CS7)
1006 if (termios->c_cflag & PARENB)
1008 if (termios->c_cflag & PARODD)
1010 if (termios->c_cflag & CSTOPB)
1013 uart_update_timeout(port, termios->c_cflag, baud);
1015 sci_out(port, SCSMR, smr_val);
1019 sci_out(port, SCSMR, (sci_in(port, SCSMR) & ~3) | 1);
1022 sci_out(port, SCSMR, sci_in(port, SCSMR) & ~3);
1024 sci_out(port, SCBRR, t);
1025 udelay((1000000+(baud-1)) / baud); /* Wait one bit interval */
1028 if (likely(s->init_pins))
1029 s->init_pins(port, termios->c_cflag);
1031 sci_out(port, SCSCR, SCSCR_INIT(port));
1033 if ((termios->c_cflag & CREAD) != 0)
1034 sci_start_rx(port,0);
1037 static const char *sci_type(struct uart_port *port)
1039 switch (port->type) {
1040 case PORT_SCI: return "sci";
1041 case PORT_SCIF: return "scif";
1042 case PORT_IRDA: return "irda";
1048 static void sci_release_port(struct uart_port *port)
1050 /* Nothing here yet .. */
1053 static int sci_request_port(struct uart_port *port)
1055 /* Nothing here yet .. */
1059 static void sci_config_port(struct uart_port *port, int flags)
1061 struct sci_port *s = &sci_ports[port->line];
1063 port->type = s->type;
1065 switch (port->type) {
1067 s->init_pins = sci_init_pins_sci;
1070 s->init_pins = sci_init_pins_scif;
1073 s->init_pins = sci_init_pins_irda;
1077 #if defined(CONFIG_CPU_SUBTYPE_SH5_101) || defined(CONFIG_CPU_SUBTYPE_SH5_103)
1078 if (port->mapbase == 0)
1079 port->mapbase = onchip_remap(SCIF_ADDR_SH5, 1024, "SCIF");
1081 port->membase = (void __iomem *)port->mapbase;
1085 static int sci_verify_port(struct uart_port *port, struct serial_struct *ser)
1087 struct sci_port *s = &sci_ports[port->line];
1089 if (ser->irq != s->irqs[SCIx_TXI_IRQ] || ser->irq > NR_IRQS)
1091 if (ser->baud_base < 2400)
1092 /* No paper tape reader for Mitch.. */
1098 static struct uart_ops sci_uart_ops = {
1099 .tx_empty = sci_tx_empty,
1100 .set_mctrl = sci_set_mctrl,
1101 .get_mctrl = sci_get_mctrl,
1102 .start_tx = sci_start_tx,
1103 .stop_tx = sci_stop_tx,
1104 .stop_rx = sci_stop_rx,
1105 .enable_ms = sci_enable_ms,
1106 .break_ctl = sci_break_ctl,
1107 .startup = sci_startup,
1108 .shutdown = sci_shutdown,
1109 .set_termios = sci_set_termios,
1111 .release_port = sci_release_port,
1112 .request_port = sci_request_port,
1113 .config_port = sci_config_port,
1114 .verify_port = sci_verify_port,
1117 static void __init sci_init_ports(void)
1119 static int first = 1;
1127 for (i = 0; i < SCI_NPORTS; i++) {
1128 sci_ports[i].port.ops = &sci_uart_ops;
1129 sci_ports[i].port.iotype = UPIO_MEM;
1130 sci_ports[i].port.line = i;
1131 sci_ports[i].port.fifosize = 1;
1133 #if defined(__H8300H__) || defined(__H8300S__)
1135 sci_ports[i].enable = h8300_sci_enable;
1136 sci_ports[i].disable = h8300_sci_disable;
1138 sci_ports[i].port.uartclk = CONFIG_CPU_CLOCK;
1139 #elif defined(CONFIG_SUPERH64)
1140 sci_ports[i].port.uartclk = current_cpu_data.module_clock * 16;
1143 * XXX: We should use a proper SCI/SCIF clock
1146 struct clk *clk = clk_get(NULL, "module_clk");
1147 sci_ports[i].port.uartclk = clk_get_rate(clk) * 16;
1152 sci_ports[i].break_timer.data = (unsigned long)&sci_ports[i];
1153 sci_ports[i].break_timer.function = sci_break_timer;
1155 init_timer(&sci_ports[i].break_timer);
1159 int __init early_sci_setup(struct uart_port *port)
1161 if (unlikely(port->line > SCI_NPORTS))
1166 sci_ports[port->line].port.membase = port->membase;
1167 sci_ports[port->line].port.mapbase = port->mapbase;
1168 sci_ports[port->line].port.type = port->type;
1173 #ifdef CONFIG_SERIAL_SH_SCI_CONSOLE
1175 * Print a string to the serial port trying not to disturb
1176 * any possible real use of the port...
1178 static void serial_console_write(struct console *co, const char *s,
1181 put_string(serial_console_port, s, count);
1184 static int __init serial_console_setup(struct console *co, char *options)
1186 struct uart_port *port;
1194 * Check whether an invalid uart number has been specified, and
1195 * if so, search for the first available port that does have
1198 if (co->index >= SCI_NPORTS)
1201 serial_console_port = &sci_ports[co->index];
1202 port = &serial_console_port->port;
1205 * Also need to check port->type, we don't actually have any
1206 * UPIO_PORT ports, but uart_report_port() handily misreports
1207 * it anyways if we don't have a port available by the time this is
1212 if (!port->membase || !port->mapbase)
1215 port->type = serial_console_port->type;
1217 if (port->flags & UPF_IOREMAP)
1218 sci_config_port(port, 0);
1220 if (serial_console_port->enable)
1221 serial_console_port->enable(port);
1224 uart_parse_options(options, &baud, &parity, &bits, &flow);
1226 ret = uart_set_options(port, co, baud, parity, bits, flow);
1227 #if defined(__H8300H__) || defined(__H8300S__)
1228 /* disable rx interrupt */
1235 static struct console serial_console = {
1237 .device = uart_console_device,
1238 .write = serial_console_write,
1239 .setup = serial_console_setup,
1240 .flags = CON_PRINTBUFFER,
1242 .data = &sci_uart_driver,
1245 static int __init sci_console_init(void)
1248 register_console(&serial_console);
1251 console_initcall(sci_console_init);
1252 #endif /* CONFIG_SERIAL_SH_SCI_CONSOLE */
1254 #ifdef CONFIG_SH_KGDB
1256 * FIXME: Most of this can go away.. at the moment, we rely on
1257 * arch/sh/kernel/setup.c to do the command line parsing for kgdb, though
1258 * most of that can easily be done here instead.
1260 * For the time being, just accept the values that were parsed earlier..
1262 static void __init kgdb_console_get_options(struct uart_port *port, int *baud,
1263 int *parity, int *bits)
1266 *parity = tolower(kgdb_parity);
1267 *bits = kgdb_bits - '0';
1271 * The naming here is somewhat misleading, since kgdb_console_setup() takes
1272 * care of the early-on initialization for kgdb, regardless of whether we
1273 * actually use kgdb as a console or not.
1275 * On the plus side, this lets us kill off the old kgdb_sci_setup() nonsense.
1277 int __init kgdb_console_setup(struct console *co, char *options)
1279 struct uart_port *port = &sci_ports[kgdb_portnum].port;
1285 if (co->index != kgdb_portnum)
1286 co->index = kgdb_portnum;
1288 kgdb_sci_port = &sci_ports[co->index];
1289 port = &kgdb_sci_port->port;
1292 * Also need to check port->type, we don't actually have any
1293 * UPIO_PORT ports, but uart_report_port() handily misreports
1294 * it anyways if we don't have a port available by the time this is
1299 if (!port->membase || !port->mapbase)
1303 uart_parse_options(options, &baud, &parity, &bits, &flow);
1305 kgdb_console_get_options(port, &baud, &parity, &bits);
1307 kgdb_getchar = kgdb_sci_getchar;
1308 kgdb_putchar = kgdb_sci_putchar;
1310 return uart_set_options(port, co, baud, parity, bits, flow);
1312 #endif /* CONFIG_SH_KGDB */
1314 #ifdef CONFIG_SH_KGDB_CONSOLE
1315 static struct console kgdb_console = {
1317 .device = uart_console_device,
1318 .write = kgdb_console_write,
1319 .setup = kgdb_console_setup,
1320 .flags = CON_PRINTBUFFER,
1322 .data = &sci_uart_driver,
1325 /* Register the KGDB console so we get messages (d'oh!) */
1326 static int __init kgdb_console_init(void)
1329 register_console(&kgdb_console);
1332 console_initcall(kgdb_console_init);
1333 #endif /* CONFIG_SH_KGDB_CONSOLE */
1335 #if defined(CONFIG_SH_KGDB_CONSOLE)
1336 #define SCI_CONSOLE &kgdb_console
1337 #elif defined(CONFIG_SERIAL_SH_SCI_CONSOLE)
1338 #define SCI_CONSOLE &serial_console
1340 #define SCI_CONSOLE 0
1343 static char banner[] __initdata =
1344 KERN_INFO "SuperH SCI(F) driver initialized\n";
1346 static struct uart_driver sci_uart_driver = {
1347 .owner = THIS_MODULE,
1348 .driver_name = "sci",
1349 .dev_name = "ttySC",
1351 .minor = SCI_MINOR_START,
1353 .cons = SCI_CONSOLE,
1357 * Register a set of serial devices attached to a platform device. The
1358 * list is terminated with a zero flags entry, which means we expect
1359 * all entries to have at least UPF_BOOT_AUTOCONF set. Platforms that need
1360 * remapping (such as sh64) should also set UPF_IOREMAP.
1362 static int __devinit sci_probe(struct platform_device *dev)
1364 struct plat_sci_port *p = dev->dev.platform_data;
1367 for (i = 0; p && p->flags != 0; p++, i++) {
1368 struct sci_port *sciport = &sci_ports[i];
1371 if (unlikely(i == SCI_NPORTS)) {
1372 dev_notice(&dev->dev, "Attempting to register port "
1373 "%d when only %d are available.\n",
1375 dev_notice(&dev->dev, "Consider bumping "
1376 "CONFIG_SERIAL_SH_SCI_NR_UARTS!\n");
1380 sciport->port.mapbase = p->mapbase;
1383 * For the simple (and majority of) cases where we don't need
1384 * to do any remapping, just cast the cookie directly.
1386 if (p->mapbase && !p->membase && !(p->flags & UPF_IOREMAP))
1387 p->membase = (void __iomem *)p->mapbase;
1389 sciport->port.membase = p->membase;
1391 sciport->port.irq = p->irqs[SCIx_TXI_IRQ];
1392 sciport->port.flags = p->flags;
1393 sciport->port.dev = &dev->dev;
1395 sciport->type = sciport->port.type = p->type;
1397 memcpy(&sciport->irqs, &p->irqs, sizeof(p->irqs));
1399 uart_add_one_port(&sci_uart_driver, &sciport->port);
1402 #if defined(CONFIG_SH_KGDB) && !defined(CONFIG_SH_KGDB_CONSOLE)
1403 kgdb_sci_port = &sci_ports[kgdb_portnum];
1404 kgdb_getchar = kgdb_sci_getchar;
1405 kgdb_putchar = kgdb_sci_putchar;
1408 #ifdef CONFIG_CPU_FREQ
1409 cpufreq_register_notifier(&sci_nb, CPUFREQ_TRANSITION_NOTIFIER);
1410 dev_info(&dev->dev, "sci: CPU frequency notifier registered\n");
1413 #ifdef CONFIG_SH_STANDARD_BIOS
1414 sh_bios_gdb_detach();
1420 static int __devexit sci_remove(struct platform_device *dev)
1424 for (i = 0; i < SCI_NPORTS; i++)
1425 uart_remove_one_port(&sci_uart_driver, &sci_ports[i].port);
1430 static int sci_suspend(struct platform_device *dev, pm_message_t state)
1434 for (i = 0; i < SCI_NPORTS; i++) {
1435 struct sci_port *p = &sci_ports[i];
1437 if (p->type != PORT_UNKNOWN && p->port.dev == &dev->dev)
1438 uart_suspend_port(&sci_uart_driver, &p->port);
1444 static int sci_resume(struct platform_device *dev)
1448 for (i = 0; i < SCI_NPORTS; i++) {
1449 struct sci_port *p = &sci_ports[i];
1451 if (p->type != PORT_UNKNOWN && p->port.dev == &dev->dev)
1452 uart_resume_port(&sci_uart_driver, &p->port);
1458 static struct platform_driver sci_driver = {
1460 .remove = __devexit_p(sci_remove),
1461 .suspend = sci_suspend,
1462 .resume = sci_resume,
1465 .owner = THIS_MODULE,
1469 static int __init sci_init(void)
1477 ret = uart_register_driver(&sci_uart_driver);
1478 if (likely(ret == 0)) {
1479 ret = platform_driver_register(&sci_driver);
1481 uart_unregister_driver(&sci_uart_driver);
1487 static void __exit sci_exit(void)
1489 platform_driver_unregister(&sci_driver);
1490 uart_unregister_driver(&sci_uart_driver);
1493 module_init(sci_init);
1494 module_exit(sci_exit);
1496 MODULE_LICENSE("GPL");