tty: remove invalid location line in file header
[linux-2.6.git] / drivers / tty / serial / sh-sci.c
1 /*
2  * SuperH on-chip serial module support.  (SCI with no FIFO / with FIFO)
3  *
4  *  Copyright (C) 2002 - 2011  Paul Mundt
5  *  Modified to support SH7720 SCIF. Markus Brunner, Mark Jonas (Jul 2007).
6  *
7  * based off of the old drivers/char/sh-sci.c by:
8  *
9  *   Copyright (C) 1999, 2000  Niibe Yutaka
10  *   Copyright (C) 2000  Sugioka Toshinobu
11  *   Modified to support multiple serial ports. Stuart Menefy (May 2000).
12  *   Modified to support SecureEdge. David McCullough (2002)
13  *   Modified to support SH7300 SCIF. Takashi Kusuda (Jun 2003).
14  *   Removed SH7300 support (Jul 2007).
15  *
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
18  * for more details.
19  */
20 #if defined(CONFIG_SERIAL_SH_SCI_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
21 #define SUPPORT_SYSRQ
22 #endif
23
24 #undef DEBUG
25
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>
37 #include <linux/mm.h>
38 #include <linux/init.h>
39 #include <linux/delay.h>
40 #include <linux/console.h>
41 #include <linux/platform_device.h>
42 #include <linux/serial_sci.h>
43 #include <linux/notifier.h>
44 #include <linux/cpufreq.h>
45 #include <linux/clk.h>
46 #include <linux/ctype.h>
47 #include <linux/err.h>
48 #include <linux/dmaengine.h>
49 #include <linux/scatterlist.h>
50 #include <linux/slab.h>
51
52 #ifdef CONFIG_SUPERH
53 #include <asm/sh_bios.h>
54 #endif
55
56 #ifdef CONFIG_H8300
57 #include <asm/gpio.h>
58 #endif
59
60 #include "sh-sci.h"
61
62 struct sci_port {
63         struct uart_port        port;
64
65         /* Platform configuration */
66         struct plat_sci_port    *cfg;
67
68         /* Port enable callback */
69         void                    (*enable)(struct uart_port *port);
70
71         /* Port disable callback */
72         void                    (*disable)(struct uart_port *port);
73
74         /* Break timer */
75         struct timer_list       break_timer;
76         int                     break_flag;
77
78         /* Interface clock */
79         struct clk              *iclk;
80         /* Function clock */
81         struct clk              *fclk;
82
83         struct dma_chan                 *chan_tx;
84         struct dma_chan                 *chan_rx;
85
86 #ifdef CONFIG_SERIAL_SH_SCI_DMA
87         struct dma_async_tx_descriptor  *desc_tx;
88         struct dma_async_tx_descriptor  *desc_rx[2];
89         dma_cookie_t                    cookie_tx;
90         dma_cookie_t                    cookie_rx[2];
91         dma_cookie_t                    active_rx;
92         struct scatterlist              sg_tx;
93         unsigned int                    sg_len_tx;
94         struct scatterlist              sg_rx[2];
95         size_t                          buf_len_rx;
96         struct sh_dmae_slave            param_tx;
97         struct sh_dmae_slave            param_rx;
98         struct work_struct              work_tx;
99         struct work_struct              work_rx;
100         struct timer_list               rx_timer;
101         unsigned int                    rx_timeout;
102 #endif
103
104         struct notifier_block           freq_transition;
105 };
106
107 /* Function prototypes */
108 static void sci_start_tx(struct uart_port *port);
109 static void sci_stop_tx(struct uart_port *port);
110 static void sci_start_rx(struct uart_port *port);
111
112 #define SCI_NPORTS CONFIG_SERIAL_SH_SCI_NR_UARTS
113
114 static struct sci_port sci_ports[SCI_NPORTS];
115 static struct uart_driver sci_uart_driver;
116
117 static inline struct sci_port *
118 to_sci_port(struct uart_port *uart)
119 {
120         return container_of(uart, struct sci_port, port);
121 }
122
123 #if defined(CONFIG_CONSOLE_POLL) || defined(CONFIG_SERIAL_SH_SCI_CONSOLE)
124
125 #ifdef CONFIG_CONSOLE_POLL
126 static int sci_poll_get_char(struct uart_port *port)
127 {
128         unsigned short status;
129         int c;
130
131         do {
132                 status = sci_in(port, SCxSR);
133                 if (status & SCxSR_ERRORS(port)) {
134                         sci_out(port, SCxSR, SCxSR_ERROR_CLEAR(port));
135                         continue;
136                 }
137                 break;
138         } while (1);
139
140         if (!(status & SCxSR_RDxF(port)))
141                 return NO_POLL_CHAR;
142
143         c = sci_in(port, SCxRDR);
144
145         /* Dummy read */
146         sci_in(port, SCxSR);
147         sci_out(port, SCxSR, SCxSR_RDxF_CLEAR(port));
148
149         return c;
150 }
151 #endif
152
153 static void sci_poll_put_char(struct uart_port *port, unsigned char c)
154 {
155         unsigned short status;
156
157         do {
158                 status = sci_in(port, SCxSR);
159         } while (!(status & SCxSR_TDxE(port)));
160
161         sci_out(port, SCxTDR, c);
162         sci_out(port, SCxSR, SCxSR_TDxE_CLEAR(port) & ~SCxSR_TEND(port));
163 }
164 #endif /* CONFIG_CONSOLE_POLL || CONFIG_SERIAL_SH_SCI_CONSOLE */
165
166 #if defined(__H8300H__) || defined(__H8300S__)
167 static void sci_init_pins(struct uart_port *port, unsigned int cflag)
168 {
169         int ch = (port->mapbase - SMR0) >> 3;
170
171         /* set DDR regs */
172         H8300_GPIO_DDR(h8300_sci_pins[ch].port,
173                        h8300_sci_pins[ch].rx,
174                        H8300_GPIO_INPUT);
175         H8300_GPIO_DDR(h8300_sci_pins[ch].port,
176                        h8300_sci_pins[ch].tx,
177                        H8300_GPIO_OUTPUT);
178
179         /* tx mark output*/
180         H8300_SCI_DR(ch) |= h8300_sci_pins[ch].tx;
181 }
182 #elif defined(CONFIG_CPU_SUBTYPE_SH7710) || defined(CONFIG_CPU_SUBTYPE_SH7712)
183 static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
184 {
185         if (port->mapbase == 0xA4400000) {
186                 __raw_writew(__raw_readw(PACR) & 0xffc0, PACR);
187                 __raw_writew(__raw_readw(PBCR) & 0x0fff, PBCR);
188         } else if (port->mapbase == 0xA4410000)
189                 __raw_writew(__raw_readw(PBCR) & 0xf003, PBCR);
190 }
191 #elif defined(CONFIG_CPU_SUBTYPE_SH7720) || defined(CONFIG_CPU_SUBTYPE_SH7721)
192 static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
193 {
194         unsigned short data;
195
196         if (cflag & CRTSCTS) {
197                 /* enable RTS/CTS */
198                 if (port->mapbase == 0xa4430000) { /* SCIF0 */
199                         /* Clear PTCR bit 9-2; enable all scif pins but sck */
200                         data = __raw_readw(PORT_PTCR);
201                         __raw_writew((data & 0xfc03), PORT_PTCR);
202                 } else if (port->mapbase == 0xa4438000) { /* SCIF1 */
203                         /* Clear PVCR bit 9-2 */
204                         data = __raw_readw(PORT_PVCR);
205                         __raw_writew((data & 0xfc03), PORT_PVCR);
206                 }
207         } else {
208                 if (port->mapbase == 0xa4430000) { /* SCIF0 */
209                         /* Clear PTCR bit 5-2; enable only tx and rx  */
210                         data = __raw_readw(PORT_PTCR);
211                         __raw_writew((data & 0xffc3), PORT_PTCR);
212                 } else if (port->mapbase == 0xa4438000) { /* SCIF1 */
213                         /* Clear PVCR bit 5-2 */
214                         data = __raw_readw(PORT_PVCR);
215                         __raw_writew((data & 0xffc3), PORT_PVCR);
216                 }
217         }
218 }
219 #elif defined(CONFIG_CPU_SH3)
220 /* For SH7705, SH7706, SH7707, SH7709, SH7709A, SH7729 */
221 static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
222 {
223         unsigned short data;
224
225         /* We need to set SCPCR to enable RTS/CTS */
226         data = __raw_readw(SCPCR);
227         /* Clear out SCP7MD1,0, SCP6MD1,0, SCP4MD1,0*/
228         __raw_writew(data & 0x0fcf, SCPCR);
229
230         if (!(cflag & CRTSCTS)) {
231                 /* We need to set SCPCR to enable RTS/CTS */
232                 data = __raw_readw(SCPCR);
233                 /* Clear out SCP7MD1,0, SCP4MD1,0,
234                    Set SCP6MD1,0 = {01} (output)  */
235                 __raw_writew((data & 0x0fcf) | 0x1000, SCPCR);
236
237                 data = __raw_readb(SCPDR);
238                 /* Set /RTS2 (bit6) = 0 */
239                 __raw_writeb(data & 0xbf, SCPDR);
240         }
241 }
242 #elif defined(CONFIG_CPU_SUBTYPE_SH7722)
243 static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
244 {
245         unsigned short data;
246
247         if (port->mapbase == 0xffe00000) {
248                 data = __raw_readw(PSCR);
249                 data &= ~0x03cf;
250                 if (!(cflag & CRTSCTS))
251                         data |= 0x0340;
252
253                 __raw_writew(data, PSCR);
254         }
255 }
256 #elif defined(CONFIG_CPU_SUBTYPE_SH7757) || \
257       defined(CONFIG_CPU_SUBTYPE_SH7763) || \
258       defined(CONFIG_CPU_SUBTYPE_SH7780) || \
259       defined(CONFIG_CPU_SUBTYPE_SH7785) || \
260       defined(CONFIG_CPU_SUBTYPE_SH7786) || \
261       defined(CONFIG_CPU_SUBTYPE_SHX3)
262 static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
263 {
264         if (!(cflag & CRTSCTS))
265                 __raw_writew(0x0080, SCSPTR0); /* Set RTS = 1 */
266 }
267 #elif defined(CONFIG_CPU_SH4) && !defined(CONFIG_CPU_SH4A)
268 static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
269 {
270         if (!(cflag & CRTSCTS))
271                 __raw_writew(0x0080, SCSPTR2); /* Set RTS = 1 */
272 }
273 #else
274 static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
275 {
276         /* Nothing to do */
277 }
278 #endif
279
280 #if defined(CONFIG_CPU_SUBTYPE_SH7760) || \
281     defined(CONFIG_CPU_SUBTYPE_SH7780) || \
282     defined(CONFIG_CPU_SUBTYPE_SH7785) || \
283     defined(CONFIG_CPU_SUBTYPE_SH7786)
284 static int scif_txfill(struct uart_port *port)
285 {
286         return sci_in(port, SCTFDR) & 0xff;
287 }
288
289 static int scif_txroom(struct uart_port *port)
290 {
291         return SCIF_TXROOM_MAX - scif_txfill(port);
292 }
293
294 static int scif_rxfill(struct uart_port *port)
295 {
296         return sci_in(port, SCRFDR) & 0xff;
297 }
298 #elif defined(CONFIG_CPU_SUBTYPE_SH7763)
299 static int scif_txfill(struct uart_port *port)
300 {
301         if (port->mapbase == 0xffe00000 ||
302             port->mapbase == 0xffe08000)
303                 /* SCIF0/1*/
304                 return sci_in(port, SCTFDR) & 0xff;
305         else
306                 /* SCIF2 */
307                 return sci_in(port, SCFDR) >> 8;
308 }
309
310 static int scif_txroom(struct uart_port *port)
311 {
312         if (port->mapbase == 0xffe00000 ||
313             port->mapbase == 0xffe08000)
314                 /* SCIF0/1*/
315                 return SCIF_TXROOM_MAX - scif_txfill(port);
316         else
317                 /* SCIF2 */
318                 return SCIF2_TXROOM_MAX - scif_txfill(port);
319 }
320
321 static int scif_rxfill(struct uart_port *port)
322 {
323         if ((port->mapbase == 0xffe00000) ||
324             (port->mapbase == 0xffe08000)) {
325                 /* SCIF0/1*/
326                 return sci_in(port, SCRFDR) & 0xff;
327         } else {
328                 /* SCIF2 */
329                 return sci_in(port, SCFDR) & SCIF2_RFDC_MASK;
330         }
331 }
332 #elif defined(CONFIG_ARCH_SH7372)
333 static int scif_txfill(struct uart_port *port)
334 {
335         if (port->type == PORT_SCIFA)
336                 return sci_in(port, SCFDR) >> 8;
337         else
338                 return sci_in(port, SCTFDR);
339 }
340
341 static int scif_txroom(struct uart_port *port)
342 {
343         return port->fifosize - scif_txfill(port);
344 }
345
346 static int scif_rxfill(struct uart_port *port)
347 {
348         if (port->type == PORT_SCIFA)
349                 return sci_in(port, SCFDR) & SCIF_RFDC_MASK;
350         else
351                 return sci_in(port, SCRFDR);
352 }
353 #else
354 static int scif_txfill(struct uart_port *port)
355 {
356         return sci_in(port, SCFDR) >> 8;
357 }
358
359 static int scif_txroom(struct uart_port *port)
360 {
361         return SCIF_TXROOM_MAX - scif_txfill(port);
362 }
363
364 static int scif_rxfill(struct uart_port *port)
365 {
366         return sci_in(port, SCFDR) & SCIF_RFDC_MASK;
367 }
368 #endif
369
370 static int sci_txfill(struct uart_port *port)
371 {
372         return !(sci_in(port, SCxSR) & SCI_TDRE);
373 }
374
375 static int sci_txroom(struct uart_port *port)
376 {
377         return !sci_txfill(port);
378 }
379
380 static int sci_rxfill(struct uart_port *port)
381 {
382         return (sci_in(port, SCxSR) & SCxSR_RDxF(port)) != 0;
383 }
384
385 /* ********************************************************************** *
386  *                   the interrupt related routines                       *
387  * ********************************************************************** */
388
389 static void sci_transmit_chars(struct uart_port *port)
390 {
391         struct circ_buf *xmit = &port->state->xmit;
392         unsigned int stopped = uart_tx_stopped(port);
393         unsigned short status;
394         unsigned short ctrl;
395         int count;
396
397         status = sci_in(port, SCxSR);
398         if (!(status & SCxSR_TDxE(port))) {
399                 ctrl = sci_in(port, SCSCR);
400                 if (uart_circ_empty(xmit))
401                         ctrl &= ~SCSCR_TIE;
402                 else
403                         ctrl |= SCSCR_TIE;
404                 sci_out(port, SCSCR, ctrl);
405                 return;
406         }
407
408         if (port->type == PORT_SCI)
409                 count = sci_txroom(port);
410         else
411                 count = scif_txroom(port);
412
413         do {
414                 unsigned char c;
415
416                 if (port->x_char) {
417                         c = port->x_char;
418                         port->x_char = 0;
419                 } else if (!uart_circ_empty(xmit) && !stopped) {
420                         c = xmit->buf[xmit->tail];
421                         xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
422                 } else {
423                         break;
424                 }
425
426                 sci_out(port, SCxTDR, c);
427
428                 port->icount.tx++;
429         } while (--count > 0);
430
431         sci_out(port, SCxSR, SCxSR_TDxE_CLEAR(port));
432
433         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
434                 uart_write_wakeup(port);
435         if (uart_circ_empty(xmit)) {
436                 sci_stop_tx(port);
437         } else {
438                 ctrl = sci_in(port, SCSCR);
439
440                 if (port->type != PORT_SCI) {
441                         sci_in(port, SCxSR); /* Dummy read */
442                         sci_out(port, SCxSR, SCxSR_TDxE_CLEAR(port));
443                 }
444
445                 ctrl |= SCSCR_TIE;
446                 sci_out(port, SCSCR, ctrl);
447         }
448 }
449
450 /* On SH3, SCIF may read end-of-break as a space->mark char */
451 #define STEPFN(c)  ({int __c = (c); (((__c-1)|(__c)) == -1); })
452
453 static void sci_receive_chars(struct uart_port *port)
454 {
455         struct sci_port *sci_port = to_sci_port(port);
456         struct tty_struct *tty = port->state->port.tty;
457         int i, count, copied = 0;
458         unsigned short status;
459         unsigned char flag;
460
461         status = sci_in(port, SCxSR);
462         if (!(status & SCxSR_RDxF(port)))
463                 return;
464
465         while (1) {
466                 if (port->type == PORT_SCI)
467                         count = sci_rxfill(port);
468                 else
469                         count = scif_rxfill(port);
470
471                 /* Don't copy more bytes than there is room for in the buffer */
472                 count = tty_buffer_request_room(tty, count);
473
474                 /* If for any reason we can't copy more data, we're done! */
475                 if (count == 0)
476                         break;
477
478                 if (port->type == PORT_SCI) {
479                         char c = sci_in(port, SCxRDR);
480                         if (uart_handle_sysrq_char(port, c) ||
481                             sci_port->break_flag)
482                                 count = 0;
483                         else
484                                 tty_insert_flip_char(tty, c, TTY_NORMAL);
485                 } else {
486                         for (i = 0; i < count; i++) {
487                                 char c = sci_in(port, SCxRDR);
488                                 status = sci_in(port, SCxSR);
489 #if defined(CONFIG_CPU_SH3)
490                                 /* Skip "chars" during break */
491                                 if (sci_port->break_flag) {
492                                         if ((c == 0) &&
493                                             (status & SCxSR_FER(port))) {
494                                                 count--; i--;
495                                                 continue;
496                                         }
497
498                                         /* Nonzero => end-of-break */
499                                         dev_dbg(port->dev, "debounce<%02x>\n", c);
500                                         sci_port->break_flag = 0;
501
502                                         if (STEPFN(c)) {
503                                                 count--; i--;
504                                                 continue;
505                                         }
506                                 }
507 #endif /* CONFIG_CPU_SH3 */
508                                 if (uart_handle_sysrq_char(port, c)) {
509                                         count--; i--;
510                                         continue;
511                                 }
512
513                                 /* Store data and status */
514                                 if (status & SCxSR_FER(port)) {
515                                         flag = TTY_FRAME;
516                                         dev_notice(port->dev, "frame error\n");
517                                 } else if (status & SCxSR_PER(port)) {
518                                         flag = TTY_PARITY;
519                                         dev_notice(port->dev, "parity error\n");
520                                 } else
521                                         flag = TTY_NORMAL;
522
523                                 tty_insert_flip_char(tty, c, flag);
524                         }
525                 }
526
527                 sci_in(port, SCxSR); /* dummy read */
528                 sci_out(port, SCxSR, SCxSR_RDxF_CLEAR(port));
529
530                 copied += count;
531                 port->icount.rx += count;
532         }
533
534         if (copied) {
535                 /* Tell the rest of the system the news. New characters! */
536                 tty_flip_buffer_push(tty);
537         } else {
538                 sci_in(port, SCxSR); /* dummy read */
539                 sci_out(port, SCxSR, SCxSR_RDxF_CLEAR(port));
540         }
541 }
542
543 #define SCI_BREAK_JIFFIES (HZ/20)
544
545 /*
546  * The sci generates interrupts during the break,
547  * 1 per millisecond or so during the break period, for 9600 baud.
548  * So dont bother disabling interrupts.
549  * But dont want more than 1 break event.
550  * Use a kernel timer to periodically poll the rx line until
551  * the break is finished.
552  */
553 static inline void sci_schedule_break_timer(struct sci_port *port)
554 {
555         mod_timer(&port->break_timer, jiffies + SCI_BREAK_JIFFIES);
556 }
557
558 /* Ensure that two consecutive samples find the break over. */
559 static void sci_break_timer(unsigned long data)
560 {
561         struct sci_port *port = (struct sci_port *)data;
562
563         if (sci_rxd_in(&port->port) == 0) {
564                 port->break_flag = 1;
565                 sci_schedule_break_timer(port);
566         } else if (port->break_flag == 1) {
567                 /* break is over. */
568                 port->break_flag = 2;
569                 sci_schedule_break_timer(port);
570         } else
571                 port->break_flag = 0;
572 }
573
574 static int sci_handle_errors(struct uart_port *port)
575 {
576         int copied = 0;
577         unsigned short status = sci_in(port, SCxSR);
578         struct tty_struct *tty = port->state->port.tty;
579
580         if (status & SCxSR_ORER(port)) {
581                 /* overrun error */
582                 if (tty_insert_flip_char(tty, 0, TTY_OVERRUN))
583                         copied++;
584
585                 dev_notice(port->dev, "overrun error");
586         }
587
588         if (status & SCxSR_FER(port)) {
589                 if (sci_rxd_in(port) == 0) {
590                         /* Notify of BREAK */
591                         struct sci_port *sci_port = to_sci_port(port);
592
593                         if (!sci_port->break_flag) {
594                                 sci_port->break_flag = 1;
595                                 sci_schedule_break_timer(sci_port);
596
597                                 /* Do sysrq handling. */
598                                 if (uart_handle_break(port))
599                                         return 0;
600
601                                 dev_dbg(port->dev, "BREAK detected\n");
602
603                                 if (tty_insert_flip_char(tty, 0, TTY_BREAK))
604                                         copied++;
605                         }
606
607                 } else {
608                         /* frame error */
609                         if (tty_insert_flip_char(tty, 0, TTY_FRAME))
610                                 copied++;
611
612                         dev_notice(port->dev, "frame error\n");
613                 }
614         }
615
616         if (status & SCxSR_PER(port)) {
617                 /* parity error */
618                 if (tty_insert_flip_char(tty, 0, TTY_PARITY))
619                         copied++;
620
621                 dev_notice(port->dev, "parity error");
622         }
623
624         if (copied)
625                 tty_flip_buffer_push(tty);
626
627         return copied;
628 }
629
630 static int sci_handle_fifo_overrun(struct uart_port *port)
631 {
632         struct tty_struct *tty = port->state->port.tty;
633         int copied = 0;
634
635         if (port->type != PORT_SCIF)
636                 return 0;
637
638         if ((sci_in(port, SCLSR) & SCIF_ORER) != 0) {
639                 sci_out(port, SCLSR, 0);
640
641                 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
642                 tty_flip_buffer_push(tty);
643
644                 dev_notice(port->dev, "overrun error\n");
645                 copied++;
646         }
647
648         return copied;
649 }
650
651 static int sci_handle_breaks(struct uart_port *port)
652 {
653         int copied = 0;
654         unsigned short status = sci_in(port, SCxSR);
655         struct tty_struct *tty = port->state->port.tty;
656         struct sci_port *s = to_sci_port(port);
657
658         if (uart_handle_break(port))
659                 return 0;
660
661         if (!s->break_flag && status & SCxSR_BRK(port)) {
662 #if defined(CONFIG_CPU_SH3)
663                 /* Debounce break */
664                 s->break_flag = 1;
665 #endif
666                 /* Notify of BREAK */
667                 if (tty_insert_flip_char(tty, 0, TTY_BREAK))
668                         copied++;
669
670                 dev_dbg(port->dev, "BREAK detected\n");
671         }
672
673         if (copied)
674                 tty_flip_buffer_push(tty);
675
676         copied += sci_handle_fifo_overrun(port);
677
678         return copied;
679 }
680
681 static irqreturn_t sci_rx_interrupt(int irq, void *ptr)
682 {
683 #ifdef CONFIG_SERIAL_SH_SCI_DMA
684         struct uart_port *port = ptr;
685         struct sci_port *s = to_sci_port(port);
686
687         if (s->chan_rx) {
688                 u16 scr = sci_in(port, SCSCR);
689                 u16 ssr = sci_in(port, SCxSR);
690
691                 /* Disable future Rx interrupts */
692                 if (port->type == PORT_SCIFA || port->type == PORT_SCIFB) {
693                         disable_irq_nosync(irq);
694                         scr |= 0x4000;
695                 } else {
696                         scr &= ~SCSCR_RIE;
697                 }
698                 sci_out(port, SCSCR, scr);
699                 /* Clear current interrupt */
700                 sci_out(port, SCxSR, ssr & ~(1 | SCxSR_RDxF(port)));
701                 dev_dbg(port->dev, "Rx IRQ %lu: setup t-out in %u jiffies\n",
702                         jiffies, s->rx_timeout);
703                 mod_timer(&s->rx_timer, jiffies + s->rx_timeout);
704
705                 return IRQ_HANDLED;
706         }
707 #endif
708
709         /* I think sci_receive_chars has to be called irrespective
710          * of whether the I_IXOFF is set, otherwise, how is the interrupt
711          * to be disabled?
712          */
713         sci_receive_chars(ptr);
714
715         return IRQ_HANDLED;
716 }
717
718 static irqreturn_t sci_tx_interrupt(int irq, void *ptr)
719 {
720         struct uart_port *port = ptr;
721         unsigned long flags;
722
723         spin_lock_irqsave(&port->lock, flags);
724         sci_transmit_chars(port);
725         spin_unlock_irqrestore(&port->lock, flags);
726
727         return IRQ_HANDLED;
728 }
729
730 static irqreturn_t sci_er_interrupt(int irq, void *ptr)
731 {
732         struct uart_port *port = ptr;
733
734         /* Handle errors */
735         if (port->type == PORT_SCI) {
736                 if (sci_handle_errors(port)) {
737                         /* discard character in rx buffer */
738                         sci_in(port, SCxSR);
739                         sci_out(port, SCxSR, SCxSR_RDxF_CLEAR(port));
740                 }
741         } else {
742                 sci_handle_fifo_overrun(port);
743                 sci_rx_interrupt(irq, ptr);
744         }
745
746         sci_out(port, SCxSR, SCxSR_ERROR_CLEAR(port));
747
748         /* Kick the transmission */
749         sci_tx_interrupt(irq, ptr);
750
751         return IRQ_HANDLED;
752 }
753
754 static irqreturn_t sci_br_interrupt(int irq, void *ptr)
755 {
756         struct uart_port *port = ptr;
757
758         /* Handle BREAKs */
759         sci_handle_breaks(port);
760         sci_out(port, SCxSR, SCxSR_BREAK_CLEAR(port));
761
762         return IRQ_HANDLED;
763 }
764
765 static inline unsigned long port_rx_irq_mask(struct uart_port *port)
766 {
767         /*
768          * Not all ports (such as SCIFA) will support REIE. Rather than
769          * special-casing the port type, we check the port initialization
770          * IRQ enable mask to see whether the IRQ is desired at all. If
771          * it's unset, it's logically inferred that there's no point in
772          * testing for it.
773          */
774         return SCSCR_RIE | (to_sci_port(port)->cfg->scscr & SCSCR_REIE);
775 }
776
777 static irqreturn_t sci_mpxed_interrupt(int irq, void *ptr)
778 {
779         unsigned short ssr_status, scr_status, err_enabled;
780         struct uart_port *port = ptr;
781         struct sci_port *s = to_sci_port(port);
782         irqreturn_t ret = IRQ_NONE;
783
784         ssr_status = sci_in(port, SCxSR);
785         scr_status = sci_in(port, SCSCR);
786         err_enabled = scr_status & port_rx_irq_mask(port);
787
788         /* Tx Interrupt */
789         if ((ssr_status & SCxSR_TDxE(port)) && (scr_status & SCSCR_TIE) &&
790             !s->chan_tx)
791                 ret = sci_tx_interrupt(irq, ptr);
792
793         /*
794          * Rx Interrupt: if we're using DMA, the DMA controller clears RDF /
795          * DR flags
796          */
797         if (((ssr_status & SCxSR_RDxF(port)) || s->chan_rx) &&
798             (scr_status & SCSCR_RIE))
799                 ret = sci_rx_interrupt(irq, ptr);
800
801         /* Error Interrupt */
802         if ((ssr_status & SCxSR_ERRORS(port)) && err_enabled)
803                 ret = sci_er_interrupt(irq, ptr);
804
805         /* Break Interrupt */
806         if ((ssr_status & SCxSR_BRK(port)) && err_enabled)
807                 ret = sci_br_interrupt(irq, ptr);
808
809         return ret;
810 }
811
812 /*
813  * Here we define a transition notifier so that we can update all of our
814  * ports' baud rate when the peripheral clock changes.
815  */
816 static int sci_notifier(struct notifier_block *self,
817                         unsigned long phase, void *p)
818 {
819         struct sci_port *sci_port;
820         unsigned long flags;
821
822         sci_port = container_of(self, struct sci_port, freq_transition);
823
824         if ((phase == CPUFREQ_POSTCHANGE) ||
825             (phase == CPUFREQ_RESUMECHANGE)) {
826                 struct uart_port *port = &sci_port->port;
827
828                 spin_lock_irqsave(&port->lock, flags);
829                 port->uartclk = clk_get_rate(sci_port->iclk);
830                 spin_unlock_irqrestore(&port->lock, flags);
831         }
832
833         return NOTIFY_OK;
834 }
835
836 static void sci_clk_enable(struct uart_port *port)
837 {
838         struct sci_port *sci_port = to_sci_port(port);
839
840         clk_enable(sci_port->iclk);
841         sci_port->port.uartclk = clk_get_rate(sci_port->iclk);
842         clk_enable(sci_port->fclk);
843 }
844
845 static void sci_clk_disable(struct uart_port *port)
846 {
847         struct sci_port *sci_port = to_sci_port(port);
848
849         clk_disable(sci_port->fclk);
850         clk_disable(sci_port->iclk);
851 }
852
853 static int sci_request_irq(struct sci_port *port)
854 {
855         int i;
856         irqreturn_t (*handlers[4])(int irq, void *ptr) = {
857                 sci_er_interrupt, sci_rx_interrupt, sci_tx_interrupt,
858                 sci_br_interrupt,
859         };
860         const char *desc[] = { "SCI Receive Error", "SCI Receive Data Full",
861                                "SCI Transmit Data Empty", "SCI Break" };
862
863         if (port->cfg->irqs[0] == port->cfg->irqs[1]) {
864                 if (unlikely(!port->cfg->irqs[0]))
865                         return -ENODEV;
866
867                 if (request_irq(port->cfg->irqs[0], sci_mpxed_interrupt,
868                                 IRQF_DISABLED, "sci", port)) {
869                         dev_err(port->port.dev, "Can't allocate IRQ\n");
870                         return -ENODEV;
871                 }
872         } else {
873                 for (i = 0; i < ARRAY_SIZE(handlers); i++) {
874                         if (unlikely(!port->cfg->irqs[i]))
875                                 continue;
876
877                         if (request_irq(port->cfg->irqs[i], handlers[i],
878                                         IRQF_DISABLED, desc[i], port)) {
879                                 dev_err(port->port.dev, "Can't allocate IRQ\n");
880                                 return -ENODEV;
881                         }
882                 }
883         }
884
885         return 0;
886 }
887
888 static void sci_free_irq(struct sci_port *port)
889 {
890         int i;
891
892         if (port->cfg->irqs[0] == port->cfg->irqs[1])
893                 free_irq(port->cfg->irqs[0], port);
894         else {
895                 for (i = 0; i < ARRAY_SIZE(port->cfg->irqs); i++) {
896                         if (!port->cfg->irqs[i])
897                                 continue;
898
899                         free_irq(port->cfg->irqs[i], port);
900                 }
901         }
902 }
903
904 static unsigned int sci_tx_empty(struct uart_port *port)
905 {
906         unsigned short status = sci_in(port, SCxSR);
907         unsigned short in_tx_fifo = scif_txfill(port);
908
909         return (status & SCxSR_TEND(port)) && !in_tx_fifo ? TIOCSER_TEMT : 0;
910 }
911
912 static void sci_set_mctrl(struct uart_port *port, unsigned int mctrl)
913 {
914         /* This routine is used for seting signals of: DTR, DCD, CTS/RTS */
915         /* We use SCIF's hardware for CTS/RTS, so don't need any for that. */
916         /* If you have signals for DTR and DCD, please implement here. */
917 }
918
919 static unsigned int sci_get_mctrl(struct uart_port *port)
920 {
921         /* This routine is used for getting signals of: DTR, DCD, DSR, RI,
922            and CTS/RTS */
923
924         return TIOCM_DTR | TIOCM_RTS | TIOCM_DSR;
925 }
926
927 #ifdef CONFIG_SERIAL_SH_SCI_DMA
928 static void sci_dma_tx_complete(void *arg)
929 {
930         struct sci_port *s = arg;
931         struct uart_port *port = &s->port;
932         struct circ_buf *xmit = &port->state->xmit;
933         unsigned long flags;
934
935         dev_dbg(port->dev, "%s(%d)\n", __func__, port->line);
936
937         spin_lock_irqsave(&port->lock, flags);
938
939         xmit->tail += sg_dma_len(&s->sg_tx);
940         xmit->tail &= UART_XMIT_SIZE - 1;
941
942         port->icount.tx += sg_dma_len(&s->sg_tx);
943
944         async_tx_ack(s->desc_tx);
945         s->cookie_tx = -EINVAL;
946         s->desc_tx = NULL;
947
948         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
949                 uart_write_wakeup(port);
950
951         if (!uart_circ_empty(xmit)) {
952                 schedule_work(&s->work_tx);
953         } else if (port->type == PORT_SCIFA || port->type == PORT_SCIFB) {
954                 u16 ctrl = sci_in(port, SCSCR);
955                 sci_out(port, SCSCR, ctrl & ~SCSCR_TIE);
956         }
957
958         spin_unlock_irqrestore(&port->lock, flags);
959 }
960
961 /* Locking: called with port lock held */
962 static int sci_dma_rx_push(struct sci_port *s, struct tty_struct *tty,
963                            size_t count)
964 {
965         struct uart_port *port = &s->port;
966         int i, active, room;
967
968         room = tty_buffer_request_room(tty, count);
969
970         if (s->active_rx == s->cookie_rx[0]) {
971                 active = 0;
972         } else if (s->active_rx == s->cookie_rx[1]) {
973                 active = 1;
974         } else {
975                 dev_err(port->dev, "cookie %d not found!\n", s->active_rx);
976                 return 0;
977         }
978
979         if (room < count)
980                 dev_warn(port->dev, "Rx overrun: dropping %u bytes\n",
981                          count - room);
982         if (!room)
983                 return room;
984
985         for (i = 0; i < room; i++)
986                 tty_insert_flip_char(tty, ((u8 *)sg_virt(&s->sg_rx[active]))[i],
987                                      TTY_NORMAL);
988
989         port->icount.rx += room;
990
991         return room;
992 }
993
994 static void sci_dma_rx_complete(void *arg)
995 {
996         struct sci_port *s = arg;
997         struct uart_port *port = &s->port;
998         struct tty_struct *tty = port->state->port.tty;
999         unsigned long flags;
1000         int count;
1001
1002         dev_dbg(port->dev, "%s(%d) active #%d\n", __func__, port->line, s->active_rx);
1003
1004         spin_lock_irqsave(&port->lock, flags);
1005
1006         count = sci_dma_rx_push(s, tty, s->buf_len_rx);
1007
1008         mod_timer(&s->rx_timer, jiffies + s->rx_timeout);
1009
1010         spin_unlock_irqrestore(&port->lock, flags);
1011
1012         if (count)
1013                 tty_flip_buffer_push(tty);
1014
1015         schedule_work(&s->work_rx);
1016 }
1017
1018 static void sci_rx_dma_release(struct sci_port *s, bool enable_pio)
1019 {
1020         struct dma_chan *chan = s->chan_rx;
1021         struct uart_port *port = &s->port;
1022
1023         s->chan_rx = NULL;
1024         s->cookie_rx[0] = s->cookie_rx[1] = -EINVAL;
1025         dma_release_channel(chan);
1026         if (sg_dma_address(&s->sg_rx[0]))
1027                 dma_free_coherent(port->dev, s->buf_len_rx * 2,
1028                                   sg_virt(&s->sg_rx[0]), sg_dma_address(&s->sg_rx[0]));
1029         if (enable_pio)
1030                 sci_start_rx(port);
1031 }
1032
1033 static void sci_tx_dma_release(struct sci_port *s, bool enable_pio)
1034 {
1035         struct dma_chan *chan = s->chan_tx;
1036         struct uart_port *port = &s->port;
1037
1038         s->chan_tx = NULL;
1039         s->cookie_tx = -EINVAL;
1040         dma_release_channel(chan);
1041         if (enable_pio)
1042                 sci_start_tx(port);
1043 }
1044
1045 static void sci_submit_rx(struct sci_port *s)
1046 {
1047         struct dma_chan *chan = s->chan_rx;
1048         int i;
1049
1050         for (i = 0; i < 2; i++) {
1051                 struct scatterlist *sg = &s->sg_rx[i];
1052                 struct dma_async_tx_descriptor *desc;
1053
1054                 desc = chan->device->device_prep_slave_sg(chan,
1055                         sg, 1, DMA_FROM_DEVICE, DMA_PREP_INTERRUPT);
1056
1057                 if (desc) {
1058                         s->desc_rx[i] = desc;
1059                         desc->callback = sci_dma_rx_complete;
1060                         desc->callback_param = s;
1061                         s->cookie_rx[i] = desc->tx_submit(desc);
1062                 }
1063
1064                 if (!desc || s->cookie_rx[i] < 0) {
1065                         if (i) {
1066                                 async_tx_ack(s->desc_rx[0]);
1067                                 s->cookie_rx[0] = -EINVAL;
1068                         }
1069                         if (desc) {
1070                                 async_tx_ack(desc);
1071                                 s->cookie_rx[i] = -EINVAL;
1072                         }
1073                         dev_warn(s->port.dev,
1074                                  "failed to re-start DMA, using PIO\n");
1075                         sci_rx_dma_release(s, true);
1076                         return;
1077                 }
1078                 dev_dbg(s->port.dev, "%s(): cookie %d to #%d\n", __func__,
1079                         s->cookie_rx[i], i);
1080         }
1081
1082         s->active_rx = s->cookie_rx[0];
1083
1084         dma_async_issue_pending(chan);
1085 }
1086
1087 static void work_fn_rx(struct work_struct *work)
1088 {
1089         struct sci_port *s = container_of(work, struct sci_port, work_rx);
1090         struct uart_port *port = &s->port;
1091         struct dma_async_tx_descriptor *desc;
1092         int new;
1093
1094         if (s->active_rx == s->cookie_rx[0]) {
1095                 new = 0;
1096         } else if (s->active_rx == s->cookie_rx[1]) {
1097                 new = 1;
1098         } else {
1099                 dev_err(port->dev, "cookie %d not found!\n", s->active_rx);
1100                 return;
1101         }
1102         desc = s->desc_rx[new];
1103
1104         if (dma_async_is_tx_complete(s->chan_rx, s->active_rx, NULL, NULL) !=
1105             DMA_SUCCESS) {
1106                 /* Handle incomplete DMA receive */
1107                 struct tty_struct *tty = port->state->port.tty;
1108                 struct dma_chan *chan = s->chan_rx;
1109                 struct sh_desc *sh_desc = container_of(desc, struct sh_desc,
1110                                                        async_tx);
1111                 unsigned long flags;
1112                 int count;
1113
1114                 chan->device->device_control(chan, DMA_TERMINATE_ALL, 0);
1115                 dev_dbg(port->dev, "Read %u bytes with cookie %d\n",
1116                         sh_desc->partial, sh_desc->cookie);
1117
1118                 spin_lock_irqsave(&port->lock, flags);
1119                 count = sci_dma_rx_push(s, tty, sh_desc->partial);
1120                 spin_unlock_irqrestore(&port->lock, flags);
1121
1122                 if (count)
1123                         tty_flip_buffer_push(tty);
1124
1125                 sci_submit_rx(s);
1126
1127                 return;
1128         }
1129
1130         s->cookie_rx[new] = desc->tx_submit(desc);
1131         if (s->cookie_rx[new] < 0) {
1132                 dev_warn(port->dev, "Failed submitting Rx DMA descriptor\n");
1133                 sci_rx_dma_release(s, true);
1134                 return;
1135         }
1136
1137         s->active_rx = s->cookie_rx[!new];
1138
1139         dev_dbg(port->dev, "%s: cookie %d #%d, new active #%d\n", __func__,
1140                 s->cookie_rx[new], new, s->active_rx);
1141 }
1142
1143 static void work_fn_tx(struct work_struct *work)
1144 {
1145         struct sci_port *s = container_of(work, struct sci_port, work_tx);
1146         struct dma_async_tx_descriptor *desc;
1147         struct dma_chan *chan = s->chan_tx;
1148         struct uart_port *port = &s->port;
1149         struct circ_buf *xmit = &port->state->xmit;
1150         struct scatterlist *sg = &s->sg_tx;
1151
1152         /*
1153          * DMA is idle now.
1154          * Port xmit buffer is already mapped, and it is one page... Just adjust
1155          * offsets and lengths. Since it is a circular buffer, we have to
1156          * transmit till the end, and then the rest. Take the port lock to get a
1157          * consistent xmit buffer state.
1158          */
1159         spin_lock_irq(&port->lock);
1160         sg->offset = xmit->tail & (UART_XMIT_SIZE - 1);
1161         sg_dma_address(sg) = (sg_dma_address(sg) & ~(UART_XMIT_SIZE - 1)) +
1162                 sg->offset;
1163         sg_dma_len(sg) = min((int)CIRC_CNT(xmit->head, xmit->tail, UART_XMIT_SIZE),
1164                 CIRC_CNT_TO_END(xmit->head, xmit->tail, UART_XMIT_SIZE));
1165         spin_unlock_irq(&port->lock);
1166
1167         BUG_ON(!sg_dma_len(sg));
1168
1169         desc = chan->device->device_prep_slave_sg(chan,
1170                         sg, s->sg_len_tx, DMA_TO_DEVICE,
1171                         DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
1172         if (!desc) {
1173                 /* switch to PIO */
1174                 sci_tx_dma_release(s, true);
1175                 return;
1176         }
1177
1178         dma_sync_sg_for_device(port->dev, sg, 1, DMA_TO_DEVICE);
1179
1180         spin_lock_irq(&port->lock);
1181         s->desc_tx = desc;
1182         desc->callback = sci_dma_tx_complete;
1183         desc->callback_param = s;
1184         spin_unlock_irq(&port->lock);
1185         s->cookie_tx = desc->tx_submit(desc);
1186         if (s->cookie_tx < 0) {
1187                 dev_warn(port->dev, "Failed submitting Tx DMA descriptor\n");
1188                 /* switch to PIO */
1189                 sci_tx_dma_release(s, true);
1190                 return;
1191         }
1192
1193         dev_dbg(port->dev, "%s: %p: %d...%d, cookie %d\n", __func__,
1194                 xmit->buf, xmit->tail, xmit->head, s->cookie_tx);
1195
1196         dma_async_issue_pending(chan);
1197 }
1198 #endif
1199
1200 static void sci_start_tx(struct uart_port *port)
1201 {
1202         struct sci_port *s = to_sci_port(port);
1203         unsigned short ctrl;
1204
1205 #ifdef CONFIG_SERIAL_SH_SCI_DMA
1206         if (port->type == PORT_SCIFA || port->type == PORT_SCIFB) {
1207                 u16 new, scr = sci_in(port, SCSCR);
1208                 if (s->chan_tx)
1209                         new = scr | 0x8000;
1210                 else
1211                         new = scr & ~0x8000;
1212                 if (new != scr)
1213                         sci_out(port, SCSCR, new);
1214         }
1215
1216         if (s->chan_tx && !uart_circ_empty(&s->port.state->xmit) &&
1217             s->cookie_tx < 0)
1218                 schedule_work(&s->work_tx);
1219 #endif
1220
1221         if (!s->chan_tx || port->type == PORT_SCIFA || port->type == PORT_SCIFB) {
1222                 /* Set TIE (Transmit Interrupt Enable) bit in SCSCR */
1223                 ctrl = sci_in(port, SCSCR);
1224                 sci_out(port, SCSCR, ctrl | SCSCR_TIE);
1225         }
1226 }
1227
1228 static void sci_stop_tx(struct uart_port *port)
1229 {
1230         unsigned short ctrl;
1231
1232         /* Clear TIE (Transmit Interrupt Enable) bit in SCSCR */
1233         ctrl = sci_in(port, SCSCR);
1234
1235         if (port->type == PORT_SCIFA || port->type == PORT_SCIFB)
1236                 ctrl &= ~0x8000;
1237
1238         ctrl &= ~SCSCR_TIE;
1239
1240         sci_out(port, SCSCR, ctrl);
1241 }
1242
1243 static void sci_start_rx(struct uart_port *port)
1244 {
1245         unsigned short ctrl;
1246
1247         ctrl = sci_in(port, SCSCR) | port_rx_irq_mask(port);
1248
1249         if (port->type == PORT_SCIFA || port->type == PORT_SCIFB)
1250                 ctrl &= ~0x4000;
1251
1252         sci_out(port, SCSCR, ctrl);
1253 }
1254
1255 static void sci_stop_rx(struct uart_port *port)
1256 {
1257         unsigned short ctrl;
1258
1259         ctrl = sci_in(port, SCSCR);
1260
1261         if (port->type == PORT_SCIFA || port->type == PORT_SCIFB)
1262                 ctrl &= ~0x4000;
1263
1264         ctrl &= ~port_rx_irq_mask(port);
1265
1266         sci_out(port, SCSCR, ctrl);
1267 }
1268
1269 static void sci_enable_ms(struct uart_port *port)
1270 {
1271         /* Nothing here yet .. */
1272 }
1273
1274 static void sci_break_ctl(struct uart_port *port, int break_state)
1275 {
1276         /* Nothing here yet .. */
1277 }
1278
1279 #ifdef CONFIG_SERIAL_SH_SCI_DMA
1280 static bool filter(struct dma_chan *chan, void *slave)
1281 {
1282         struct sh_dmae_slave *param = slave;
1283
1284         dev_dbg(chan->device->dev, "%s: slave ID %d\n", __func__,
1285                 param->slave_id);
1286
1287         if (param->dma_dev == chan->device->dev) {
1288                 chan->private = param;
1289                 return true;
1290         } else {
1291                 return false;
1292         }
1293 }
1294
1295 static void rx_timer_fn(unsigned long arg)
1296 {
1297         struct sci_port *s = (struct sci_port *)arg;
1298         struct uart_port *port = &s->port;
1299         u16 scr = sci_in(port, SCSCR);
1300
1301         if (port->type == PORT_SCIFA || port->type == PORT_SCIFB) {
1302                 scr &= ~0x4000;
1303                 enable_irq(s->cfg->irqs[1]);
1304         }
1305         sci_out(port, SCSCR, scr | SCSCR_RIE);
1306         dev_dbg(port->dev, "DMA Rx timed out\n");
1307         schedule_work(&s->work_rx);
1308 }
1309
1310 static void sci_request_dma(struct uart_port *port)
1311 {
1312         struct sci_port *s = to_sci_port(port);
1313         struct sh_dmae_slave *param;
1314         struct dma_chan *chan;
1315         dma_cap_mask_t mask;
1316         int nent;
1317
1318         dev_dbg(port->dev, "%s: port %d DMA %p\n", __func__,
1319                 port->line, s->cfg->dma_dev);
1320
1321         if (!s->cfg->dma_dev)
1322                 return;
1323
1324         dma_cap_zero(mask);
1325         dma_cap_set(DMA_SLAVE, mask);
1326
1327         param = &s->param_tx;
1328
1329         /* Slave ID, e.g., SHDMA_SLAVE_SCIF0_TX */
1330         param->slave_id = s->cfg->dma_slave_tx;
1331         param->dma_dev = s->cfg->dma_dev;
1332
1333         s->cookie_tx = -EINVAL;
1334         chan = dma_request_channel(mask, filter, param);
1335         dev_dbg(port->dev, "%s: TX: got channel %p\n", __func__, chan);
1336         if (chan) {
1337                 s->chan_tx = chan;
1338                 sg_init_table(&s->sg_tx, 1);
1339                 /* UART circular tx buffer is an aligned page. */
1340                 BUG_ON((int)port->state->xmit.buf & ~PAGE_MASK);
1341                 sg_set_page(&s->sg_tx, virt_to_page(port->state->xmit.buf),
1342                             UART_XMIT_SIZE, (int)port->state->xmit.buf & ~PAGE_MASK);
1343                 nent = dma_map_sg(port->dev, &s->sg_tx, 1, DMA_TO_DEVICE);
1344                 if (!nent)
1345                         sci_tx_dma_release(s, false);
1346                 else
1347                         dev_dbg(port->dev, "%s: mapped %d@%p to %x\n", __func__,
1348                                 sg_dma_len(&s->sg_tx),
1349                                 port->state->xmit.buf, sg_dma_address(&s->sg_tx));
1350
1351                 s->sg_len_tx = nent;
1352
1353                 INIT_WORK(&s->work_tx, work_fn_tx);
1354         }
1355
1356         param = &s->param_rx;
1357
1358         /* Slave ID, e.g., SHDMA_SLAVE_SCIF0_RX */
1359         param->slave_id = s->cfg->dma_slave_rx;
1360         param->dma_dev = s->cfg->dma_dev;
1361
1362         chan = dma_request_channel(mask, filter, param);
1363         dev_dbg(port->dev, "%s: RX: got channel %p\n", __func__, chan);
1364         if (chan) {
1365                 dma_addr_t dma[2];
1366                 void *buf[2];
1367                 int i;
1368
1369                 s->chan_rx = chan;
1370
1371                 s->buf_len_rx = 2 * max(16, (int)port->fifosize);
1372                 buf[0] = dma_alloc_coherent(port->dev, s->buf_len_rx * 2,
1373                                             &dma[0], GFP_KERNEL);
1374
1375                 if (!buf[0]) {
1376                         dev_warn(port->dev,
1377                                  "failed to allocate dma buffer, using PIO\n");
1378                         sci_rx_dma_release(s, true);
1379                         return;
1380                 }
1381
1382                 buf[1] = buf[0] + s->buf_len_rx;
1383                 dma[1] = dma[0] + s->buf_len_rx;
1384
1385                 for (i = 0; i < 2; i++) {
1386                         struct scatterlist *sg = &s->sg_rx[i];
1387
1388                         sg_init_table(sg, 1);
1389                         sg_set_page(sg, virt_to_page(buf[i]), s->buf_len_rx,
1390                                     (int)buf[i] & ~PAGE_MASK);
1391                         sg_dma_address(sg) = dma[i];
1392                 }
1393
1394                 INIT_WORK(&s->work_rx, work_fn_rx);
1395                 setup_timer(&s->rx_timer, rx_timer_fn, (unsigned long)s);
1396
1397                 sci_submit_rx(s);
1398         }
1399 }
1400
1401 static void sci_free_dma(struct uart_port *port)
1402 {
1403         struct sci_port *s = to_sci_port(port);
1404
1405         if (!s->cfg->dma_dev)
1406                 return;
1407
1408         if (s->chan_tx)
1409                 sci_tx_dma_release(s, false);
1410         if (s->chan_rx)
1411                 sci_rx_dma_release(s, false);
1412 }
1413 #else
1414 static inline void sci_request_dma(struct uart_port *port)
1415 {
1416 }
1417
1418 static inline void sci_free_dma(struct uart_port *port)
1419 {
1420 }
1421 #endif
1422
1423 static int sci_startup(struct uart_port *port)
1424 {
1425         struct sci_port *s = to_sci_port(port);
1426         int ret;
1427
1428         dev_dbg(port->dev, "%s(%d)\n", __func__, port->line);
1429
1430         if (s->enable)
1431                 s->enable(port);
1432
1433         ret = sci_request_irq(s);
1434         if (unlikely(ret < 0))
1435                 return ret;
1436
1437         sci_request_dma(port);
1438
1439         sci_start_tx(port);
1440         sci_start_rx(port);
1441
1442         return 0;
1443 }
1444
1445 static void sci_shutdown(struct uart_port *port)
1446 {
1447         struct sci_port *s = to_sci_port(port);
1448
1449         dev_dbg(port->dev, "%s(%d)\n", __func__, port->line);
1450
1451         sci_stop_rx(port);
1452         sci_stop_tx(port);
1453
1454         sci_free_dma(port);
1455         sci_free_irq(s);
1456
1457         if (s->disable)
1458                 s->disable(port);
1459 }
1460
1461 static unsigned int sci_scbrr_calc(unsigned int algo_id, unsigned int bps,
1462                                    unsigned long freq)
1463 {
1464         switch (algo_id) {
1465         case SCBRR_ALGO_1:
1466                 return ((freq + 16 * bps) / (16 * bps) - 1);
1467         case SCBRR_ALGO_2:
1468                 return ((freq + 16 * bps) / (32 * bps) - 1);
1469         case SCBRR_ALGO_3:
1470                 return (((freq * 2) + 16 * bps) / (16 * bps) - 1);
1471         case SCBRR_ALGO_4:
1472                 return (((freq * 2) + 16 * bps) / (32 * bps) - 1);
1473         case SCBRR_ALGO_5:
1474                 return (((freq * 1000 / 32) / bps) - 1);
1475         }
1476
1477         /* Warn, but use a safe default */
1478         WARN_ON(1);
1479
1480         return ((freq + 16 * bps) / (32 * bps) - 1);
1481 }
1482
1483 static void sci_set_termios(struct uart_port *port, struct ktermios *termios,
1484                             struct ktermios *old)
1485 {
1486         struct sci_port *s = to_sci_port(port);
1487         unsigned int status, baud, smr_val, max_baud;
1488         int t = -1;
1489         u16 scfcr = 0;
1490
1491         /*
1492          * earlyprintk comes here early on with port->uartclk set to zero.
1493          * the clock framework is not up and running at this point so here
1494          * we assume that 115200 is the maximum baud rate. please note that
1495          * the baud rate is not programmed during earlyprintk - it is assumed
1496          * that the previous boot loader has enabled required clocks and
1497          * setup the baud rate generator hardware for us already.
1498          */
1499         max_baud = port->uartclk ? port->uartclk / 16 : 115200;
1500
1501         baud = uart_get_baud_rate(port, termios, old, 0, max_baud);
1502         if (likely(baud && port->uartclk))
1503                 t = sci_scbrr_calc(s->cfg->scbrr_algo_id, baud, port->uartclk);
1504
1505         if (s->enable)
1506                 s->enable(port);
1507
1508         do {
1509                 status = sci_in(port, SCxSR);
1510         } while (!(status & SCxSR_TEND(port)));
1511
1512         sci_out(port, SCSCR, 0x00);     /* TE=0, RE=0, CKE1=0 */
1513
1514         if (port->type != PORT_SCI)
1515                 sci_out(port, SCFCR, scfcr | SCFCR_RFRST | SCFCR_TFRST);
1516
1517         smr_val = sci_in(port, SCSMR) & 3;
1518
1519         if ((termios->c_cflag & CSIZE) == CS7)
1520                 smr_val |= 0x40;
1521         if (termios->c_cflag & PARENB)
1522                 smr_val |= 0x20;
1523         if (termios->c_cflag & PARODD)
1524                 smr_val |= 0x30;
1525         if (termios->c_cflag & CSTOPB)
1526                 smr_val |= 0x08;
1527
1528         uart_update_timeout(port, termios->c_cflag, baud);
1529
1530         sci_out(port, SCSMR, smr_val);
1531
1532         dev_dbg(port->dev, "%s: SMR %x, t %x, SCSCR %x\n", __func__, smr_val, t,
1533                 s->cfg->scscr);
1534
1535         if (t > 0) {
1536                 if (t >= 256) {
1537                         sci_out(port, SCSMR, (sci_in(port, SCSMR) & ~3) | 1);
1538                         t >>= 2;
1539                 } else
1540                         sci_out(port, SCSMR, sci_in(port, SCSMR) & ~3);
1541
1542                 sci_out(port, SCBRR, t);
1543                 udelay((1000000+(baud-1)) / baud); /* Wait one bit interval */
1544         }
1545
1546         sci_init_pins(port, termios->c_cflag);
1547         sci_out(port, SCFCR, scfcr | ((termios->c_cflag & CRTSCTS) ? SCFCR_MCE : 0));
1548
1549         sci_out(port, SCSCR, s->cfg->scscr);
1550
1551 #ifdef CONFIG_SERIAL_SH_SCI_DMA
1552         /*
1553          * Calculate delay for 1.5 DMA buffers: see
1554          * drivers/serial/serial_core.c::uart_update_timeout(). With 10 bits
1555          * (CS8), 250Hz, 115200 baud and 64 bytes FIFO, the above function
1556          * calculates 1 jiffie for the data plus 5 jiffies for the "slop(e)."
1557          * Then below we calculate 3 jiffies (12ms) for 1.5 DMA buffers (3 FIFO
1558          * sizes), but it has been found out experimentally, that this is not
1559          * enough: the driver too often needlessly runs on a DMA timeout. 20ms
1560          * as a minimum seem to work perfectly.
1561          */
1562         if (s->chan_rx) {
1563                 s->rx_timeout = (port->timeout - HZ / 50) * s->buf_len_rx * 3 /
1564                         port->fifosize / 2;
1565                 dev_dbg(port->dev,
1566                         "DMA Rx t-out %ums, tty t-out %u jiffies\n",
1567                         s->rx_timeout * 1000 / HZ, port->timeout);
1568                 if (s->rx_timeout < msecs_to_jiffies(20))
1569                         s->rx_timeout = msecs_to_jiffies(20);
1570         }
1571 #endif
1572
1573         if ((termios->c_cflag & CREAD) != 0)
1574                 sci_start_rx(port);
1575
1576         if (s->disable)
1577                 s->disable(port);
1578 }
1579
1580 static const char *sci_type(struct uart_port *port)
1581 {
1582         switch (port->type) {
1583         case PORT_IRDA:
1584                 return "irda";
1585         case PORT_SCI:
1586                 return "sci";
1587         case PORT_SCIF:
1588                 return "scif";
1589         case PORT_SCIFA:
1590                 return "scifa";
1591         case PORT_SCIFB:
1592                 return "scifb";
1593         }
1594
1595         return NULL;
1596 }
1597
1598 static inline unsigned long sci_port_size(struct uart_port *port)
1599 {
1600         /*
1601          * Pick an arbitrary size that encapsulates all of the base
1602          * registers by default. This can be optimized later, or derived
1603          * from platform resource data at such a time that ports begin to
1604          * behave more erratically.
1605          */
1606         return 64;
1607 }
1608
1609 static int sci_remap_port(struct uart_port *port)
1610 {
1611         unsigned long size = sci_port_size(port);
1612
1613         /*
1614          * Nothing to do if there's already an established membase.
1615          */
1616         if (port->membase)
1617                 return 0;
1618
1619         if (port->flags & UPF_IOREMAP) {
1620                 port->membase = ioremap_nocache(port->mapbase, size);
1621                 if (unlikely(!port->membase)) {
1622                         dev_err(port->dev, "can't remap port#%d\n", port->line);
1623                         return -ENXIO;
1624                 }
1625         } else {
1626                 /*
1627                  * For the simple (and majority of) cases where we don't
1628                  * need to do any remapping, just cast the cookie
1629                  * directly.
1630                  */
1631                 port->membase = (void __iomem *)port->mapbase;
1632         }
1633
1634         return 0;
1635 }
1636
1637 static void sci_release_port(struct uart_port *port)
1638 {
1639         if (port->flags & UPF_IOREMAP) {
1640                 iounmap(port->membase);
1641                 port->membase = NULL;
1642         }
1643
1644         release_mem_region(port->mapbase, sci_port_size(port));
1645 }
1646
1647 static int sci_request_port(struct uart_port *port)
1648 {
1649         unsigned long size = sci_port_size(port);
1650         struct resource *res;
1651         int ret;
1652
1653         res = request_mem_region(port->mapbase, size, dev_name(port->dev));
1654         if (unlikely(res == NULL))
1655                 return -EBUSY;
1656
1657         ret = sci_remap_port(port);
1658         if (unlikely(ret != 0)) {
1659                 release_resource(res);
1660                 return ret;
1661         }
1662
1663         return 0;
1664 }
1665
1666 static void sci_config_port(struct uart_port *port, int flags)
1667 {
1668         if (flags & UART_CONFIG_TYPE) {
1669                 struct sci_port *sport = to_sci_port(port);
1670
1671                 port->type = sport->cfg->type;
1672                 sci_request_port(port);
1673         }
1674 }
1675
1676 static int sci_verify_port(struct uart_port *port, struct serial_struct *ser)
1677 {
1678         struct sci_port *s = to_sci_port(port);
1679
1680         if (ser->irq != s->cfg->irqs[SCIx_TXI_IRQ] || ser->irq > nr_irqs)
1681                 return -EINVAL;
1682         if (ser->baud_base < 2400)
1683                 /* No paper tape reader for Mitch.. */
1684                 return -EINVAL;
1685
1686         return 0;
1687 }
1688
1689 static struct uart_ops sci_uart_ops = {
1690         .tx_empty       = sci_tx_empty,
1691         .set_mctrl      = sci_set_mctrl,
1692         .get_mctrl      = sci_get_mctrl,
1693         .start_tx       = sci_start_tx,
1694         .stop_tx        = sci_stop_tx,
1695         .stop_rx        = sci_stop_rx,
1696         .enable_ms      = sci_enable_ms,
1697         .break_ctl      = sci_break_ctl,
1698         .startup        = sci_startup,
1699         .shutdown       = sci_shutdown,
1700         .set_termios    = sci_set_termios,
1701         .type           = sci_type,
1702         .release_port   = sci_release_port,
1703         .request_port   = sci_request_port,
1704         .config_port    = sci_config_port,
1705         .verify_port    = sci_verify_port,
1706 #ifdef CONFIG_CONSOLE_POLL
1707         .poll_get_char  = sci_poll_get_char,
1708         .poll_put_char  = sci_poll_put_char,
1709 #endif
1710 };
1711
1712 static int __devinit sci_init_single(struct platform_device *dev,
1713                                      struct sci_port *sci_port,
1714                                      unsigned int index,
1715                                      struct plat_sci_port *p)
1716 {
1717         struct uart_port *port = &sci_port->port;
1718
1719         port->ops       = &sci_uart_ops;
1720         port->iotype    = UPIO_MEM;
1721         port->line      = index;
1722
1723         switch (p->type) {
1724         case PORT_SCIFB:
1725                 port->fifosize = 256;
1726                 break;
1727         case PORT_SCIFA:
1728                 port->fifosize = 64;
1729                 break;
1730         case PORT_SCIF:
1731                 port->fifosize = 16;
1732                 break;
1733         default:
1734                 port->fifosize = 1;
1735                 break;
1736         }
1737
1738         if (dev) {
1739                 sci_port->iclk = clk_get(&dev->dev, "sci_ick");
1740                 if (IS_ERR(sci_port->iclk)) {
1741                         sci_port->iclk = clk_get(&dev->dev, "peripheral_clk");
1742                         if (IS_ERR(sci_port->iclk)) {
1743                                 dev_err(&dev->dev, "can't get iclk\n");
1744                                 return PTR_ERR(sci_port->iclk);
1745                         }
1746                 }
1747
1748                 /*
1749                  * The function clock is optional, ignore it if we can't
1750                  * find it.
1751                  */
1752                 sci_port->fclk = clk_get(&dev->dev, "sci_fck");
1753                 if (IS_ERR(sci_port->fclk))
1754                         sci_port->fclk = NULL;
1755
1756                 sci_port->enable = sci_clk_enable;
1757                 sci_port->disable = sci_clk_disable;
1758                 port->dev = &dev->dev;
1759         }
1760
1761         sci_port->break_timer.data = (unsigned long)sci_port;
1762         sci_port->break_timer.function = sci_break_timer;
1763         init_timer(&sci_port->break_timer);
1764
1765         sci_port->cfg           = p;
1766
1767         port->mapbase           = p->mapbase;
1768         port->type              = p->type;
1769         port->flags             = p->flags;
1770
1771         /*
1772          * The UART port needs an IRQ value, so we peg this to the TX IRQ
1773          * for the multi-IRQ ports, which is where we are primarily
1774          * concerned with the shutdown path synchronization.
1775          *
1776          * For the muxed case there's nothing more to do.
1777          */
1778         port->irq               = p->irqs[SCIx_TXI_IRQ];
1779
1780         if (p->dma_dev)
1781                 dev_dbg(port->dev, "DMA device %p, tx %d, rx %d\n",
1782                         p->dma_dev, p->dma_slave_tx, p->dma_slave_rx);
1783
1784         return 0;
1785 }
1786
1787 #ifdef CONFIG_SERIAL_SH_SCI_CONSOLE
1788 static void serial_console_putchar(struct uart_port *port, int ch)
1789 {
1790         sci_poll_put_char(port, ch);
1791 }
1792
1793 /*
1794  *      Print a string to the serial port trying not to disturb
1795  *      any possible real use of the port...
1796  */
1797 static void serial_console_write(struct console *co, const char *s,
1798                                  unsigned count)
1799 {
1800         struct sci_port *sci_port = &sci_ports[co->index];
1801         struct uart_port *port = &sci_port->port;
1802         unsigned short bits;
1803
1804         if (sci_port->enable)
1805                 sci_port->enable(port);
1806
1807         uart_console_write(port, s, count, serial_console_putchar);
1808
1809         /* wait until fifo is empty and last bit has been transmitted */
1810         bits = SCxSR_TDxE(port) | SCxSR_TEND(port);
1811         while ((sci_in(port, SCxSR) & bits) != bits)
1812                 cpu_relax();
1813
1814         if (sci_port->disable)
1815                 sci_port->disable(port);
1816 }
1817
1818 static int __devinit serial_console_setup(struct console *co, char *options)
1819 {
1820         struct sci_port *sci_port;
1821         struct uart_port *port;
1822         int baud = 115200;
1823         int bits = 8;
1824         int parity = 'n';
1825         int flow = 'n';
1826         int ret;
1827
1828         /*
1829          * Refuse to handle any bogus ports.
1830          */
1831         if (co->index < 0 || co->index >= SCI_NPORTS)
1832                 return -ENODEV;
1833
1834         sci_port = &sci_ports[co->index];
1835         port = &sci_port->port;
1836
1837         /*
1838          * Refuse to handle uninitialized ports.
1839          */
1840         if (!port->ops)
1841                 return -ENODEV;
1842
1843         ret = sci_remap_port(port);
1844         if (unlikely(ret != 0))
1845                 return ret;
1846
1847         if (sci_port->enable)
1848                 sci_port->enable(port);
1849
1850         if (options)
1851                 uart_parse_options(options, &baud, &parity, &bits, &flow);
1852
1853         ret = uart_set_options(port, co, baud, parity, bits, flow);
1854 #if defined(__H8300H__) || defined(__H8300S__)
1855         /* disable rx interrupt */
1856         if (ret == 0)
1857                 sci_stop_rx(port);
1858 #endif
1859         /* TODO: disable clock */
1860         return ret;
1861 }
1862
1863 static struct console serial_console = {
1864         .name           = "ttySC",
1865         .device         = uart_console_device,
1866         .write          = serial_console_write,
1867         .setup          = serial_console_setup,
1868         .flags          = CON_PRINTBUFFER,
1869         .index          = -1,
1870         .data           = &sci_uart_driver,
1871 };
1872
1873 static struct console early_serial_console = {
1874         .name           = "early_ttySC",
1875         .write          = serial_console_write,
1876         .flags          = CON_PRINTBUFFER,
1877         .index          = -1,
1878 };
1879
1880 static char early_serial_buf[32];
1881
1882 static int __devinit sci_probe_earlyprintk(struct platform_device *pdev)
1883 {
1884         struct plat_sci_port *cfg = pdev->dev.platform_data;
1885
1886         if (early_serial_console.data)
1887                 return -EEXIST;
1888
1889         early_serial_console.index = pdev->id;
1890
1891         sci_init_single(NULL, &sci_ports[pdev->id], pdev->id, cfg);
1892
1893         serial_console_setup(&early_serial_console, early_serial_buf);
1894
1895         if (!strstr(early_serial_buf, "keep"))
1896                 early_serial_console.flags |= CON_BOOT;
1897
1898         register_console(&early_serial_console);
1899         return 0;
1900 }
1901
1902 #define SCI_CONSOLE     (&serial_console)
1903
1904 #else
1905 static inline int __devinit sci_probe_earlyprintk(struct platform_device *pdev)
1906 {
1907         return -EINVAL;
1908 }
1909
1910 #define SCI_CONSOLE     NULL
1911
1912 #endif /* CONFIG_SERIAL_SH_SCI_CONSOLE */
1913
1914 static char banner[] __initdata =
1915         KERN_INFO "SuperH SCI(F) driver initialized\n";
1916
1917 static struct uart_driver sci_uart_driver = {
1918         .owner          = THIS_MODULE,
1919         .driver_name    = "sci",
1920         .dev_name       = "ttySC",
1921         .major          = SCI_MAJOR,
1922         .minor          = SCI_MINOR_START,
1923         .nr             = SCI_NPORTS,
1924         .cons           = SCI_CONSOLE,
1925 };
1926
1927 static int sci_remove(struct platform_device *dev)
1928 {
1929         struct sci_port *port = platform_get_drvdata(dev);
1930
1931         cpufreq_unregister_notifier(&port->freq_transition,
1932                                     CPUFREQ_TRANSITION_NOTIFIER);
1933
1934         uart_remove_one_port(&sci_uart_driver, &port->port);
1935
1936         clk_put(port->iclk);
1937         clk_put(port->fclk);
1938
1939         return 0;
1940 }
1941
1942 static int __devinit sci_probe_single(struct platform_device *dev,
1943                                       unsigned int index,
1944                                       struct plat_sci_port *p,
1945                                       struct sci_port *sciport)
1946 {
1947         int ret;
1948
1949         /* Sanity check */
1950         if (unlikely(index >= SCI_NPORTS)) {
1951                 dev_notice(&dev->dev, "Attempting to register port "
1952                            "%d when only %d are available.\n",
1953                            index+1, SCI_NPORTS);
1954                 dev_notice(&dev->dev, "Consider bumping "
1955                            "CONFIG_SERIAL_SH_SCI_NR_UARTS!\n");
1956                 return 0;
1957         }
1958
1959         ret = sci_init_single(dev, sciport, index, p);
1960         if (ret)
1961                 return ret;
1962
1963         return uart_add_one_port(&sci_uart_driver, &sciport->port);
1964 }
1965
1966 static int __devinit sci_probe(struct platform_device *dev)
1967 {
1968         struct plat_sci_port *p = dev->dev.platform_data;
1969         struct sci_port *sp = &sci_ports[dev->id];
1970         int ret;
1971
1972         /*
1973          * If we've come here via earlyprintk initialization, head off to
1974          * the special early probe. We don't have sufficient device state
1975          * to make it beyond this yet.
1976          */
1977         if (is_early_platform_device(dev))
1978                 return sci_probe_earlyprintk(dev);
1979
1980         platform_set_drvdata(dev, sp);
1981
1982         ret = sci_probe_single(dev, dev->id, p, sp);
1983         if (ret)
1984                 goto err_unreg;
1985
1986         sp->freq_transition.notifier_call = sci_notifier;
1987
1988         ret = cpufreq_register_notifier(&sp->freq_transition,
1989                                         CPUFREQ_TRANSITION_NOTIFIER);
1990         if (unlikely(ret < 0))
1991                 goto err_unreg;
1992
1993 #ifdef CONFIG_SH_STANDARD_BIOS
1994         sh_bios_gdb_detach();
1995 #endif
1996
1997         return 0;
1998
1999 err_unreg:
2000         sci_remove(dev);
2001         return ret;
2002 }
2003
2004 static int sci_suspend(struct device *dev)
2005 {
2006         struct sci_port *sport = dev_get_drvdata(dev);
2007
2008         if (sport)
2009                 uart_suspend_port(&sci_uart_driver, &sport->port);
2010
2011         return 0;
2012 }
2013
2014 static int sci_resume(struct device *dev)
2015 {
2016         struct sci_port *sport = dev_get_drvdata(dev);
2017
2018         if (sport)
2019                 uart_resume_port(&sci_uart_driver, &sport->port);
2020
2021         return 0;
2022 }
2023
2024 static const struct dev_pm_ops sci_dev_pm_ops = {
2025         .suspend        = sci_suspend,
2026         .resume         = sci_resume,
2027 };
2028
2029 static struct platform_driver sci_driver = {
2030         .probe          = sci_probe,
2031         .remove         = sci_remove,
2032         .driver         = {
2033                 .name   = "sh-sci",
2034                 .owner  = THIS_MODULE,
2035                 .pm     = &sci_dev_pm_ops,
2036         },
2037 };
2038
2039 static int __init sci_init(void)
2040 {
2041         int ret;
2042
2043         printk(banner);
2044
2045         ret = uart_register_driver(&sci_uart_driver);
2046         if (likely(ret == 0)) {
2047                 ret = platform_driver_register(&sci_driver);
2048                 if (unlikely(ret))
2049                         uart_unregister_driver(&sci_uart_driver);
2050         }
2051
2052         return ret;
2053 }
2054
2055 static void __exit sci_exit(void)
2056 {
2057         platform_driver_unregister(&sci_driver);
2058         uart_unregister_driver(&sci_uart_driver);
2059 }
2060
2061 #ifdef CONFIG_SERIAL_SH_SCI_CONSOLE
2062 early_platform_init_buffer("earlyprintk", &sci_driver,
2063                            early_serial_buf, ARRAY_SIZE(early_serial_buf));
2064 #endif
2065 module_init(sci_init);
2066 module_exit(sci_exit);
2067
2068 MODULE_LICENSE("GPL");
2069 MODULE_ALIAS("platform:sh-sci");