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