11 files changed, 328 insertions, 141 deletions

diff --git a/drivers/serial/8250_pnp.c b/drivers/serial/8250_pnp.c
index 24485cc62ff8..4822cb50cd0f 100644
--- a/drivers/serial/8250_pnp.c
+++ b/drivers/serial/8250_pnp.c
@@ -348,6 +348,8 @@ static const struct pnp_device_id pnp_dev_table[] = {
         {       "FUJ02E6",              0       },
         /* Fujitsu Wacom 2FGT Tablet PC device */
         {       "FUJ02E7",              0       },
+        /* Fujitsu Wacom 1FGT Tablet PC device */
+        {       "FUJ02E9",              0       },
         /*
          * LG C1 EXPRESS DUAL (C1-PB11A3) touch screen (actually a FUJ02E6 in
          * disguise)
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index f55c49475a8c..302836a80693 100644
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -518,12 +518,13 @@ config SERIAL_S3C2412
           Serial port support for the Samsung S3C2412 and S3C2413 SoC
 
 config SERIAL_S3C2440
-        tristate "Samsung S3C2440/S3C2442 Serial port support"
-        depends on SERIAL_SAMSUNG && (CPU_S3C2440 || CPU_S3C2442)
+        tristate "Samsung S3C2440/S3C2442/S3C2416 Serial port support"
+        depends on SERIAL_SAMSUNG && (CPU_S3C2440 || CPU_S3C2442 || CPU_S3C2416)
         default y if CPU_S3C2440
         default y if CPU_S3C2442
+        select SERIAL_SAMSUNG_UARTS_4 if CPU_S3C2416
         help
-          Serial port support for the Samsung S3C2440 and S3C2442 SoC
+          Serial port support for the Samsung S3C2440, S3C2416 and S3C2442 SoC
 
 config SERIAL_S3C24A0
         tristate "Samsung S3C24A0 Serial port support"
@@ -533,21 +534,13 @@ config SERIAL_S3C24A0
           Serial port support for the Samsung S3C24A0 SoC
 
 config SERIAL_S3C6400
-        tristate "Samsung S3C6400/S3C6410/S5P6440 Seria port support"
-        depends on SERIAL_SAMSUNG && (CPU_S3C6400 || CPU_S3C6410 || CPU_S5P6440)
+        tristate "Samsung S3C6400/S3C6410/S5P6440/S5PC100 Serial port support"
+        depends on SERIAL_SAMSUNG && (CPU_S3C6400 || CPU_S3C6410 || CPU_S5P6440 || CPU_S5PC100)
         select SERIAL_SAMSUNG_UARTS_4
         default y
         help
-          Serial port support for the Samsung S3C6400, S3C6410 and S5P6440
-          SoCs
-
-config SERIAL_S5PC100
-        tristate "Samsung S5PC100 Serial port support"
-        depends on SERIAL_SAMSUNG && CPU_S5PC100
-        select SERIAL_SAMSUNG_UARTS_4
-        default y
-        help
-          Serial port support for the Samsung S5PC100 SoCs
+          Serial port support for the Samsung S3C6400, S3C6410, S5P6440
+          and S5PC100 SoCs
 
 config SERIAL_S5PV210
         tristate "Samsung S5PV210 Serial port support"
diff --git a/drivers/serial/Makefile b/drivers/serial/Makefile
index 6aa4723b74ee..328f107346c4 100644
--- a/drivers/serial/Makefile
+++ b/drivers/serial/Makefile
@@ -44,7 +44,6 @@ obj-$(CONFIG_SERIAL_S3C2412) += s3c2412.o
 obj-$(CONFIG_SERIAL_S3C2440) += s3c2440.o
 obj-$(CONFIG_SERIAL_S3C24A0) += s3c24a0.o
 obj-$(CONFIG_SERIAL_S3C6400) += s3c6400.o
-obj-$(CONFIG_SERIAL_S5PC100) += s3c6400.o
 obj-$(CONFIG_SERIAL_S5PV210) += s5pv210.o
 obj-$(CONFIG_SERIAL_MAX3100) += max3100.o
 obj-$(CONFIG_SERIAL_IP22_ZILOG) += ip22zilog.o
diff --git a/drivers/serial/atmel_serial.c b/drivers/serial/atmel_serial.c
index 2c9bf9b68327..eed3c2d8dd1c 100644
--- a/drivers/serial/atmel_serial.c
+++ b/drivers/serial/atmel_serial.c
@@ -38,6 +38,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/atmel_pdc.h>
 #include <linux/atmel_serial.h>
+#include <linux/uaccess.h>
 
 #include <asm/io.h>
 
@@ -59,6 +60,9 @@
 
 #include <linux/serial_core.h>
 
+static void atmel_start_rx(struct uart_port *port);
+static void atmel_stop_rx(struct uart_port *port);
+
 #ifdef CONFIG_SERIAL_ATMEL_TTYAT
 
 /* Use device name ttyAT, major 204 and minor 154-169.  This is necessary if we
@@ -93,6 +97,7 @@
 #define UART_GET_BRGR(port)     __raw_readl((port)->membase + ATMEL_US_BRGR)
 #define UART_PUT_BRGR(port,v)   __raw_writel(v, (port)->membase + ATMEL_US_BRGR)
 #define UART_PUT_RTOR(port,v)   __raw_writel(v, (port)->membase + ATMEL_US_RTOR)
+#define UART_PUT_TTGR(port, v)  __raw_writel(v, (port)->membase + ATMEL_US_TTGR)
 
  /* PDC registers */
 #define UART_PUT_PTCR(port,v)   __raw_writel(v, (port)->membase + ATMEL_PDC_PTCR)
@@ -147,6 +152,9 @@ struct atmel_uart_port {
         unsigned int            irq_status_prev;
 
         struct circ_buf         rx_ring;
+
+        struct serial_rs485     rs485;          /* rs485 settings */
+        unsigned int            tx_done_mask;
 };
 
 static struct atmel_uart_port atmel_ports[ATMEL_MAX_UART];
@@ -187,6 +195,46 @@ static bool atmel_use_dma_tx(struct uart_port *port)
 }
 #endif
 
+/* Enable or disable the rs485 support */
+void atmel_config_rs485(struct uart_port *port, struct serial_rs485 *rs485conf)
+{
+        struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
+        unsigned int mode;
+
+        spin_lock(&port->lock);
+
+        /* Disable interrupts */
+        UART_PUT_IDR(port, atmel_port->tx_done_mask);
+
+        mode = UART_GET_MR(port);
+
+        /* Resetting serial mode to RS232 (0x0) */
+        mode &= ~ATMEL_US_USMODE;
+
+        atmel_port->rs485 = *rs485conf;
+
+        if (rs485conf->flags & SER_RS485_ENABLED) {
+                dev_dbg(port->dev, "Setting UART to RS485\n");
+                atmel_port->tx_done_mask = ATMEL_US_TXEMPTY;
+                UART_PUT_TTGR(port, rs485conf->delay_rts_before_send);
+                mode |= ATMEL_US_USMODE_RS485;
+        } else {
+                dev_dbg(port->dev, "Setting UART to RS232\n");
+                if (atmel_use_dma_tx(port))
+                        atmel_port->tx_done_mask = ATMEL_US_ENDTX |
+                                ATMEL_US_TXBUFE;
+                else
+                        atmel_port->tx_done_mask = ATMEL_US_TXRDY;
+        }
+        UART_PUT_MR(port, mode);
+
+        /* Enable interrupts */
+        UART_PUT_IER(port, atmel_port->tx_done_mask);
+
+        spin_unlock(&port->lock);
+
+}
+
 /*
  * Return TIOCSER_TEMT when transmitter FIFO and Shift register is empty.
  */
@@ -202,6 +250,7 @@ static void atmel_set_mctrl(struct uart_port *port, u_int mctrl)
 {
         unsigned int control = 0;
         unsigned int mode;
+        struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
 
 #ifdef CONFIG_ARCH_AT91RM9200
         if (cpu_is_at91rm9200()) {
@@ -236,6 +285,17 @@ static void atmel_set_mctrl(struct uart_port *port, u_int mctrl)
                 mode |= ATMEL_US_CHMODE_LOC_LOOP;
         else
                 mode |= ATMEL_US_CHMODE_NORMAL;
+
+        /* Resetting serial mode to RS232 (0x0) */
+        mode &= ~ATMEL_US_USMODE;
+
+        if (atmel_port->rs485.flags & SER_RS485_ENABLED) {
+                dev_dbg(port->dev, "Setting UART to RS485\n");
+                UART_PUT_TTGR(port, atmel_port->rs485.delay_rts_before_send);
+                mode |= ATMEL_US_USMODE_RS485;
+        } else {
+                dev_dbg(port->dev, "Setting UART to RS232\n");
+        }
         UART_PUT_MR(port, mode);
 }
 
@@ -268,12 +328,17 @@ static u_int atmel_get_mctrl(struct uart_port *port)
  */
 static void atmel_stop_tx(struct uart_port *port)
 {
+        struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
+
         if (atmel_use_dma_tx(port)) {
                 /* disable PDC transmit */
                 UART_PUT_PTCR(port, ATMEL_PDC_TXTDIS);
-                UART_PUT_IDR(port, ATMEL_US_ENDTX | ATMEL_US_TXBUFE);
-        } else
-                UART_PUT_IDR(port, ATMEL_US_TXRDY);
+        }
+        /* Disable interrupts */
+        UART_PUT_IDR(port, atmel_port->tx_done_mask);
+
+        if (atmel_port->rs485.flags & SER_RS485_ENABLED)
+                atmel_start_rx(port);
 }
 
 /*
@@ -281,17 +346,39 @@ static void atmel_stop_tx(struct uart_port *port)
  */
 static void atmel_start_tx(struct uart_port *port)
 {
+        struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
+
         if (atmel_use_dma_tx(port)) {
                 if (UART_GET_PTSR(port) & ATMEL_PDC_TXTEN)
                         /* The transmitter is already running.  Yes, we
                            really need this.*/
                         return;
 
-                UART_PUT_IER(port, ATMEL_US_ENDTX | ATMEL_US_TXBUFE);
+                if (atmel_port->rs485.flags & SER_RS485_ENABLED)
+                        atmel_stop_rx(port);
+
                 /* re-enable PDC transmit */
                 UART_PUT_PTCR(port, ATMEL_PDC_TXTEN);
-        } else
-                UART_PUT_IER(port, ATMEL_US_TXRDY);
+        }
+        /* Enable interrupts */
+        UART_PUT_IER(port, atmel_port->tx_done_mask);
+}
+
+/*
+ * start receiving - port is in process of being opened.
+ */
+static void atmel_start_rx(struct uart_port *port)
+{
+        UART_PUT_CR(port, ATMEL_US_RSTSTA);  /* reset status and receiver */
+
+        if (atmel_use_dma_rx(port)) {
+                /* enable PDC controller */
+                UART_PUT_IER(port, ATMEL_US_ENDRX | ATMEL_US_TIMEOUT |
+                        port->read_status_mask);
+                UART_PUT_PTCR(port, ATMEL_PDC_RXTEN);
+        } else {
+                UART_PUT_IER(port, ATMEL_US_RXRDY);
+        }
 }
 
 /*
@@ -302,9 +389,11 @@ static void atmel_stop_rx(struct uart_port *port)
         if (atmel_use_dma_rx(port)) {
                 /* disable PDC receive */
                 UART_PUT_PTCR(port, ATMEL_PDC_RXTDIS);
-                UART_PUT_IDR(port, ATMEL_US_ENDRX | ATMEL_US_TIMEOUT);
-        } else
+                UART_PUT_IDR(port, ATMEL_US_ENDRX | ATMEL_US_TIMEOUT |
+                        port->read_status_mask);
+        } else {
                 UART_PUT_IDR(port, ATMEL_US_RXRDY);
+        }
 }
 
 /*
@@ -428,8 +517,9 @@ static void atmel_rx_chars(struct uart_port *port)
 static void atmel_tx_chars(struct uart_port *port)
 {
         struct circ_buf *xmit = &port->state->xmit;
+        struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
 
-        if (port->x_char && UART_GET_CSR(port) & ATMEL_US_TXRDY) {
+        if (port->x_char && UART_GET_CSR(port) & atmel_port->tx_done_mask) {
                 UART_PUT_CHAR(port, port->x_char);
                 port->icount.tx++;
                 port->x_char = 0;
@@ -437,7 +527,7 @@ static void atmel_tx_chars(struct uart_port *port)
         if (uart_circ_empty(xmit) || uart_tx_stopped(port))
                 return;
 
-        while (UART_GET_CSR(port) & ATMEL_US_TXRDY) {
+        while (UART_GET_CSR(port) & atmel_port->tx_done_mask) {
                 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
                 port->icount.tx++;
@@ -449,7 +539,8 @@ static void atmel_tx_chars(struct uart_port *port)
                 uart_write_wakeup(port);
 
         if (!uart_circ_empty(xmit))
-                UART_PUT_IER(port, ATMEL_US_TXRDY);
+                /* Enable interrupts */
+                UART_PUT_IER(port, atmel_port->tx_done_mask);
 }
 
 /*
@@ -501,18 +592,10 @@ atmel_handle_transmit(struct uart_port *port, unsigned int pending)
 {
         struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
 
-        if (atmel_use_dma_tx(port)) {
-                /* PDC transmit */
-                if (pending & (ATMEL_US_ENDTX | ATMEL_US_TXBUFE)) {
-                        UART_PUT_IDR(port, ATMEL_US_ENDTX | ATMEL_US_TXBUFE);
-                        tasklet_schedule(&atmel_port->tasklet);
-                }
-        } else {
-                /* Interrupt transmit */
-                if (pending & ATMEL_US_TXRDY) {
-                        UART_PUT_IDR(port, ATMEL_US_TXRDY);
-                        tasklet_schedule(&atmel_port->tasklet);
-                }
+        if (pending & atmel_port->tx_done_mask) {
+                /* Either PDC or interrupt transmission */
+                UART_PUT_IDR(port, atmel_port->tx_done_mask);
+                tasklet_schedule(&atmel_port->tasklet);
         }
 }
 
@@ -590,9 +673,15 @@ static void atmel_tx_dma(struct uart_port *port)
 
                 UART_PUT_TPR(port, pdc->dma_addr + xmit->tail);
                 UART_PUT_TCR(port, count);
-                /* re-enable PDC transmit and interrupts */
+                /* re-enable PDC transmit */
                 UART_PUT_PTCR(port, ATMEL_PDC_TXTEN);
-                UART_PUT_IER(port, ATMEL_US_ENDTX | ATMEL_US_TXBUFE);
+                /* Enable interrupts */
+                UART_PUT_IER(port, atmel_port->tx_done_mask);
+        } else {
+                if (atmel_port->rs485.flags & SER_RS485_ENABLED) {
+                        /* DMA done, stop TX, start RX for RS485 */
+                        atmel_start_rx(port);
+                }
         }
 
         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
@@ -1017,6 +1106,7 @@ static void atmel_set_termios(struct uart_port *port, struct ktermios *termios,
 {
         unsigned long flags;
         unsigned int mode, imr, quot, baud;
+        struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
 
         /* Get current mode register */
         mode = UART_GET_MR(port) & ~(ATMEL_US_USCLKS | ATMEL_US_CHRL
@@ -1115,6 +1205,17 @@ static void atmel_set_termios(struct uart_port *port, struct ktermios *termios,
         /* disable receiver and transmitter */
         UART_PUT_CR(port, ATMEL_US_TXDIS | ATMEL_US_RXDIS);
 
+        /* Resetting serial mode to RS232 (0x0) */
+        mode &= ~ATMEL_US_USMODE;
+
+        if (atmel_port->rs485.flags & SER_RS485_ENABLED) {
+                dev_dbg(port->dev, "Setting UART to RS485\n");
+                UART_PUT_TTGR(port, atmel_port->rs485.delay_rts_before_send);
+                mode |= ATMEL_US_USMODE_RS485;
+        } else {
+                dev_dbg(port->dev, "Setting UART to RS232\n");
+        }
+
         /* set the parity, stop bits and data size */
         UART_PUT_MR(port, mode);
 
@@ -1231,6 +1332,35 @@ static void atmel_poll_put_char(struct uart_port *port, unsigned char ch)
 }
 #endif
 
+static int
+atmel_ioctl(struct uart_port *port, unsigned int cmd, unsigned long arg)
+{
+        struct serial_rs485 rs485conf;
+
+        switch (cmd) {
+        case TIOCSRS485:
+                if (copy_from_user(&rs485conf, (struct serial_rs485 *) arg,
+                                        sizeof(rs485conf)))
+                        return -EFAULT;
+
+                atmel_config_rs485(port, &rs485conf);
+                break;
+
+        case TIOCGRS485:
+                if (copy_to_user((struct serial_rs485 *) arg,
+                                        &(to_atmel_uart_port(port)->rs485),
+                                        sizeof(rs485conf)))
+                        return -EFAULT;
+                break;
+
+        default:
+                return -ENOIOCTLCMD;
+        }
+        return 0;
+}
+
+
+
 static struct uart_ops atmel_pops = {
         .tx_empty       = atmel_tx_empty,
         .set_mctrl      = atmel_set_mctrl,
@@ -1250,6 +1380,7 @@ static struct uart_ops atmel_pops = {
         .config_port    = atmel_config_port,
         .verify_port    = atmel_verify_port,
         .pm             = atmel_serial_pm,
+        .ioctl          = atmel_ioctl,
 #ifdef CONFIG_CONSOLE_POLL
         .poll_get_char  = atmel_poll_get_char,
         .poll_put_char  = atmel_poll_put_char,
@@ -1265,13 +1396,12 @@ static void __devinit atmel_init_port(struct atmel_uart_port *atmel_port,
         struct uart_port *port = &atmel_port->uart;
         struct atmel_uart_data *data = pdev->dev.platform_data;
 
-        port->iotype    = UPIO_MEM;
-        port->flags     = UPF_BOOT_AUTOCONF;
-        port->ops       = &atmel_pops;
-        port->fifosize  = 1;
-        port->line      = pdev->id;
-        port->dev       = &pdev->dev;
-
+        port->iotype            = UPIO_MEM;
+        port->flags             = UPF_BOOT_AUTOCONF;
+        port->ops               = &atmel_pops;
+        port->fifosize          = 1;
+        port->line              = pdev->id;
+        port->dev               = &pdev->dev;
         port->mapbase   = pdev->resource[0].start;
         port->irq       = pdev->resource[1].start;
 
@@ -1299,8 +1429,16 @@ static void __devinit atmel_init_port(struct atmel_uart_port *atmel_port,
 
         atmel_port->use_dma_rx = data->use_dma_rx;
         atmel_port->use_dma_tx = data->use_dma_tx;
-        if (atmel_use_dma_tx(port))
+        atmel_port->rs485       = data->rs485;
+        /* Use TXEMPTY for interrupt when rs485 else TXRDY or ENDTX|TXBUFE */
+        if (atmel_port->rs485.flags & SER_RS485_ENABLED)
+                atmel_port->tx_done_mask = ATMEL_US_TXEMPTY;
+        else if (atmel_use_dma_tx(port)) {
                 port->fifosize = PDC_BUFFER_SIZE;
+                atmel_port->tx_done_mask = ATMEL_US_ENDTX | ATMEL_US_TXBUFE;
+        } else {
+                atmel_port->tx_done_mask = ATMEL_US_TXRDY;
+        }
 }
 
 /*
@@ -1334,6 +1472,7 @@ static void atmel_console_putchar(struct uart_port *port, int ch)
 static void atmel_console_write(struct console *co, const char *s, u_int count)
 {
         struct uart_port *port = &atmel_ports[co->index].uart;
+        struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
         unsigned int status, imr;
         unsigned int pdc_tx;
 
@@ -1341,7 +1480,7 @@ static void atmel_console_write(struct console *co, const char *s, u_int count)
          * First, save IMR and then disable interrupts
          */
         imr = UART_GET_IMR(port);
-        UART_PUT_IDR(port, ATMEL_US_RXRDY | ATMEL_US_TXRDY);
+        UART_PUT_IDR(port, ATMEL_US_RXRDY | atmel_port->tx_done_mask);
 
         /* Store PDC transmit status and disable it */
         pdc_tx = UART_GET_PTSR(port) & ATMEL_PDC_TXTEN;
diff --git a/drivers/serial/imx.c b/drivers/serial/imx.c
index 4315b23590bd..eacb588a9345 100644
--- a/drivers/serial/imx.c
+++ b/drivers/serial/imx.c
@@ -120,7 +120,8 @@
 #define  MX2_UCR3_RXDMUXSEL      (1<<2)  /* RXD Muxed Input Select, on mx2/mx3 */
 #define  UCR3_INVT       (1<<1)  /* Inverted Infrared transmission */
 #define  UCR3_BPEN       (1<<0)  /* Preset registers enable */
-#define  UCR4_CTSTL_32   (32<<10) /* CTS trigger level (32 chars) */
+#define  UCR4_CTSTL_SHF  10      /* CTS trigger level shift */
+#define  UCR4_CTSTL_MASK 0x3F    /* CTS trigger is 6 bits wide */
 #define  UCR4_INVR       (1<<9)  /* Inverted infrared reception */
 #define  UCR4_ENIRI      (1<<8)  /* Serial infrared interrupt enable */
 #define  UCR4_WKEN       (1<<7)  /* Wake interrupt enable */
@@ -591,6 +592,9 @@ static int imx_setup_ufcr(struct imx_port *sport, unsigned int mode)
         return 0;
 }
 
+/* half the RX buffer size */
+#define CTSTL 16
+
 static int imx_startup(struct uart_port *port)
 {
         struct imx_port *sport = (struct imx_port *)port;
@@ -607,6 +611,10 @@ static int imx_startup(struct uart_port *port)
         if (USE_IRDA(sport))
                 temp |= UCR4_IRSC;
 
+        /* set the trigger level for CTS */
+        temp &= ~(UCR4_CTSTL_MASK<<  UCR4_CTSTL_SHF);
+        temp |= CTSTL<<  UCR4_CTSTL_SHF;
+
         writel(temp & ~UCR4_DREN, sport->port.membase + UCR4);
 
         if (USE_IRDA(sport)) {
diff --git a/drivers/serial/mcf.c b/drivers/serial/mcf.c
index 7bb5fee639e3..b5aaef965f24 100644
--- a/drivers/serial/mcf.c
+++ b/drivers/serial/mcf.c
@@ -263,6 +263,7 @@ static void mcf_set_termios(struct uart_port *port, struct ktermios *termios,
         }
 
         spin_lock_irqsave(&port->lock, flags);
+        uart_update_timeout(port, termios->c_cflag, baud);
         writeb(MCFUART_UCR_CMDRESETRX, port->membase + MCFUART_UCR);
         writeb(MCFUART_UCR_CMDRESETTX, port->membase + MCFUART_UCR);
         writeb(MCFUART_UCR_CMDRESETMRPTR, port->membase + MCFUART_UCR);
@@ -379,6 +380,7 @@ static irqreturn_t mcf_interrupt(int irq, void *data)
 static void mcf_config_port(struct uart_port *port, int flags)
 {
         port->type = PORT_MCF;
+        port->fifosize = MCFUART_TXFIFOSIZE;
 
         /* Clear mask, so no surprise interrupts. */
         writeb(0, port->membase + MCFUART_UIMR);
@@ -424,7 +426,7 @@ static int mcf_verify_port(struct uart_port *port, struct serial_struct *ser)
 /*
  *      Define the basic serial functions we support.
  */
-static struct uart_ops mcf_uart_ops = {
+static const struct uart_ops mcf_uart_ops = {
         .tx_empty       = mcf_tx_empty,
         .get_mctrl      = mcf_get_mctrl,
         .set_mctrl      = mcf_set_mctrl,
@@ -443,7 +445,7 @@ static struct uart_ops mcf_uart_ops = {
         .verify_port    = mcf_verify_port,
 };
 
-static struct mcf_uart mcf_ports[3];
+static struct mcf_uart mcf_ports[4];
 
 #define MCF_MAXPORTS    ARRAY_SIZE(mcf_ports)
 
diff --git a/drivers/serial/mpc52xx_uart.c b/drivers/serial/mpc52xx_uart.c
index 3119fddaedb5..02469c31bf0b 100644
--- a/drivers/serial/mpc52xx_uart.c
+++ b/drivers/serial/mpc52xx_uart.c
@@ -29,39 +29,6 @@
  * kind, whether express or implied.
  */
 
-/* Platform device Usage :
- *
- * Since PSCs can have multiple function, the correct driver for each one
- * is selected by calling mpc52xx_match_psc_function(...). The function
- * handled by this driver is "uart".
- *
- * The driver init all necessary registers to place the PSC in uart mode without
- * DCD. However, the pin multiplexing aren't changed and should be set either
- * by the bootloader or in the platform init code.
- *
- * The idx field must be equal to the PSC index (e.g. 0 for PSC1, 1 for PSC2,
- * and so on). So the PSC1 is mapped to /dev/ttyPSC0, PSC2 to /dev/ttyPSC1 and
- * so on. But be warned, it's an ABSOLUTE REQUIREMENT ! This is needed mainly
- * fpr the console code : without this 1:1 mapping, at early boot time, when we
- * are parsing the kernel args console=ttyPSC?, we wouldn't know which PSC it
- * will be mapped to.
- */
-
-/* OF Platform device Usage :
- *
- * This driver is only used for PSCs configured in uart mode.  The device
- * tree will have a node for each PSC with "mpc52xx-psc-uart" in the compatible
- * list.
- *
- * By default, PSC devices are enumerated in the order they are found.  However
- * a particular PSC number can be forces by adding 'device_no = <port#>'
- * to the device node.
- *
- * The driver init all necessary registers to place the PSC in uart mode without
- * DCD. However, the pin multiplexing aren't changed and should be set either
- * by the bootloader or in the platform init code.
- */
-
 #undef DEBUG
 
 #include <linux/device.h>
@@ -1500,7 +1467,7 @@ mpc52xx_uart_init(void)
         /*
          * Map the PSC FIFO Controller and init if on MPC512x.
          */
-        if (psc_ops->fifoc_init) {
+        if (psc_ops && psc_ops->fifoc_init) {
                 ret = psc_ops->fifoc_init();
                 if (ret)
                         return ret;
diff --git a/drivers/serial/pmac_zilog.c b/drivers/serial/pmac_zilog.c
index 4eaa043ca2a8..700e10833bf9 100644
--- a/drivers/serial/pmac_zilog.c
+++ b/drivers/serial/pmac_zilog.c
@@ -752,8 +752,10 @@ static void pmz_break_ctl(struct uart_port *port, int break_state)
                 uap->curregs[R5] = new_reg;
 
                 /* NOTE: Not subject to 'transmitter active' rule. */
-                if (ZS_IS_ASLEEP(uap))
+                if (ZS_IS_ASLEEP(uap)) {
+                        spin_unlock_irqrestore(&port->lock, flags);
                         return;
+                }
                 write_zsreg(uap, R5, uap->curregs[R5]);
         }
 
diff --git a/drivers/serial/serial_cs.c b/drivers/serial/serial_cs.c
index 175d202ab37e..8cfa5b12ea7a 100644
--- a/drivers/serial/serial_cs.c
+++ b/drivers/serial/serial_cs.c
@@ -105,6 +105,10 @@ struct serial_cfg_mem {
  * manfid 0x0160, 0x0104
  * This card appears to have a 14.7456MHz clock.
  */
+/* Generic Modem: MD55x (GPRS/EDGE) have
+ * Elan VPU16551 UART with 14.7456MHz oscillator
+ * manfid 0x015D, 0x4C45
+ */
 static void quirk_setup_brainboxes_0104(struct pcmcia_device *link, struct uart_port *port)
 {
         port->uartclk = 14745600;
@@ -196,6 +200,11 @@ static const struct serial_quirk quirks[] = {
                 .multi  = -1,
                 .setup  = quirk_setup_brainboxes_0104,
         }, {
+                .manfid = 0x015D,
+                .prodid = 0x4C45,
+                .multi  = -1,
+                .setup  = quirk_setup_brainboxes_0104,
+        }, {
                 .manfid = MANFID_IBM,
                 .prodid = ~0,
                 .multi  = -1,
diff --git a/drivers/serial/serial_ks8695.c b/drivers/serial/serial_ks8695.c
index 2e71bbc04dac..b1962025b1aa 100644
--- a/drivers/serial/serial_ks8695.c
+++ b/drivers/serial/serial_ks8695.c
@@ -650,6 +650,7 @@ static struct console ks8695_console = {
 
 static int __init ks8695_console_init(void)
 {
+        add_preferred_console(SERIAL_KS8695_DEVNAME, 0, NULL);
         register_console(&ks8695_console);
         return 0;
 }
diff --git a/drivers/serial/sh-sci.c b/drivers/serial/sh-sci.c
index 78e0545243d0..8d993c4cceac 100644
--- a/drivers/serial/sh-sci.c
+++ b/drivers/serial/sh-sci.c
@@ -83,8 +83,8 @@ struct sci_port {
 
         /* Interface clock */
         struct clk              *iclk;
-        /* Data clock */
-        struct clk              *dclk;
+        /* Function clock */
+        struct clk              *fclk;
 
         struct list_head        node;
         struct dma_chan                 *chan_tx;
@@ -107,6 +107,7 @@ struct sci_port {
         struct work_struct              work_tx;
         struct work_struct              work_rx;
         struct timer_list               rx_timer;
+        unsigned int                    rx_timeout;
 #endif
 };
 
@@ -674,22 +675,22 @@ static irqreturn_t sci_rx_interrupt(int irq, void *ptr)
         struct sci_port *s = to_sci_port(port);
 
         if (s->chan_rx) {
-                unsigned long tout;
                 u16 scr = sci_in(port, SCSCR);
                 u16 ssr = sci_in(port, SCxSR);
 
                 /* Disable future Rx interrupts */
-                sci_out(port, SCSCR, scr & ~SCI_CTRL_FLAGS_RIE);
+                if (port->type == PORT_SCIFA) {
+                        disable_irq_nosync(irq);
+                        scr |= 0x4000;
+                } else {
+                        scr &= ~SCI_CTRL_FLAGS_RIE;
+                }
+                sci_out(port, SCSCR, scr);
                 /* Clear current interrupt */
                 sci_out(port, SCxSR, ssr & ~(1 | SCxSR_RDxF(port)));
-                /* Calculate delay for 1.5 DMA buffers */
-                tout = (port->timeout - HZ / 50) * s->buf_len_rx * 3 /
-                        port->fifosize / 2;
-                dev_dbg(port->dev, "Rx IRQ: setup timeout in %lu ms\n",
-                        tout * 1000 / HZ);
-                if (tout < 2)
-                        tout = 2;
-                mod_timer(&s->rx_timer, jiffies + tout);
+                dev_dbg(port->dev, "Rx IRQ %lu: setup t-out in %u jiffies\n",
+                        jiffies, s->rx_timeout);
+                mod_timer(&s->rx_timer, jiffies + s->rx_timeout);
 
                 return IRQ_HANDLED;
         }
@@ -799,7 +800,7 @@ static int sci_notifier(struct notifier_block *self,
             (phase == CPUFREQ_RESUMECHANGE)) {
                 spin_lock_irqsave(&priv->lock, flags);
                 list_for_each_entry(sci_port, &priv->ports, node)
-                        sci_port->port.uartclk = clk_get_rate(sci_port->dclk);
+                        sci_port->port.uartclk = clk_get_rate(sci_port->iclk);
                 spin_unlock_irqrestore(&priv->lock, flags);
         }
 
@@ -810,21 +811,17 @@ static void sci_clk_enable(struct uart_port *port)
 {
         struct sci_port *sci_port = to_sci_port(port);
 
-        clk_enable(sci_port->dclk);
-        sci_port->port.uartclk = clk_get_rate(sci_port->dclk);
-
-        if (sci_port->iclk)
-                clk_enable(sci_port->iclk);
+        clk_enable(sci_port->iclk);
+        sci_port->port.uartclk = clk_get_rate(sci_port->iclk);
+        clk_enable(sci_port->fclk);
 }
 
 static void sci_clk_disable(struct uart_port *port)
 {
         struct sci_port *sci_port = to_sci_port(port);
 
-        if (sci_port->iclk)
-                clk_disable(sci_port->iclk);
-
-        clk_disable(sci_port->dclk);
+        clk_disable(sci_port->fclk);
+        clk_disable(sci_port->iclk);
 }
 
 static int sci_request_irq(struct sci_port *port)
@@ -922,13 +919,17 @@ static void sci_dma_tx_complete(void *arg)
         s->cookie_tx = -EINVAL;
         s->desc_tx = NULL;
 
-        spin_unlock_irqrestore(&port->lock, flags);
-
         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
                 uart_write_wakeup(port);
 
-        if (uart_circ_chars_pending(xmit))
+        if (!uart_circ_empty(xmit)) {
                 schedule_work(&s->work_tx);
+        } else if (port->type == PORT_SCIFA) {
+                u16 ctrl = sci_in(port, SCSCR);
+                sci_out(port, SCSCR, ctrl & ~SCI_CTRL_FLAGS_TIE);
+        }
+
+        spin_unlock_irqrestore(&port->lock, flags);
 }
 
 /* Locking: called with port lock held */
@@ -972,13 +973,13 @@ static void sci_dma_rx_complete(void *arg)
         unsigned long flags;
         int count;
 
-        dev_dbg(port->dev, "%s(%d)\n", __func__, port->line);
+        dev_dbg(port->dev, "%s(%d) active #%d\n", __func__, port->line, s->active_rx);
 
         spin_lock_irqsave(&port->lock, flags);
 
         count = sci_dma_rx_push(s, tty, s->buf_len_rx);
 
-        mod_timer(&s->rx_timer, jiffies + msecs_to_jiffies(5));
+        mod_timer(&s->rx_timer, jiffies + s->rx_timeout);
 
         spin_unlock_irqrestore(&port->lock, flags);
 
@@ -1050,6 +1051,8 @@ static void sci_submit_rx(struct sci_port *s)
                         sci_rx_dma_release(s, true);
                         return;
                 }
+                dev_dbg(s->port.dev, "%s(): cookie %d to #%d\n", __func__,
+                        s->cookie_rx[i], i);
         }
 
         s->active_rx = s->cookie_rx[0];
@@ -1107,10 +1110,10 @@ static void work_fn_rx(struct work_struct *work)
                 return;
         }
 
-        dev_dbg(port->dev, "%s: cookie %d #%d\n", __func__,
-                s->cookie_rx[new], new);
-
         s->active_rx = s->cookie_rx[!new];
+
+        dev_dbg(port->dev, "%s: cookie %d #%d, new active #%d\n", __func__,
+                s->cookie_rx[new], new, s->active_rx);
 }
 
 static void work_fn_tx(struct work_struct *work)
@@ -1172,23 +1175,28 @@ static void work_fn_tx(struct work_struct *work)
 
 static void sci_start_tx(struct uart_port *port)
 {
+        struct sci_port *s = to_sci_port(port);
         unsigned short ctrl;
 
 #ifdef CONFIG_SERIAL_SH_SCI_DMA
-        struct sci_port *s = to_sci_port(port);
-
-        if (s->chan_tx) {
-                if (!uart_circ_empty(&s->port.state->xmit) && s->cookie_tx < 0)
-                        schedule_work(&s->work_tx);
-
-                return;
+        if (port->type == PORT_SCIFA) {
+                u16 new, scr = sci_in(port, SCSCR);
+                if (s->chan_tx)
+                        new = scr | 0x8000;
+                else
+                        new = scr & ~0x8000;
+                if (new != scr)
+                        sci_out(port, SCSCR, new);
         }
+        if (s->chan_tx && !uart_circ_empty(&s->port.state->xmit) &&
+            s->cookie_tx < 0)
+                schedule_work(&s->work_tx);
 #endif
-
-        /* Set TIE (Transmit Interrupt Enable) bit in SCSCR */
-        ctrl = sci_in(port, SCSCR);
-        ctrl |= SCI_CTRL_FLAGS_TIE;
-        sci_out(port, SCSCR, ctrl);
+        if (!s->chan_tx || port->type == PORT_SCIFA) {
+                /* Set TIE (Transmit Interrupt Enable) bit in SCSCR */
+                ctrl = sci_in(port, SCSCR);
+                sci_out(port, SCSCR, ctrl | SCI_CTRL_FLAGS_TIE);
+        }
 }
 
 static void sci_stop_tx(struct uart_port *port)
@@ -1197,6 +1205,8 @@ static void sci_stop_tx(struct uart_port *port)
 
         /* Clear TIE (Transmit Interrupt Enable) bit in SCSCR */
         ctrl = sci_in(port, SCSCR);
+        if (port->type == PORT_SCIFA)
+                ctrl &= ~0x8000;
         ctrl &= ~SCI_CTRL_FLAGS_TIE;
         sci_out(port, SCSCR, ctrl);
 }
@@ -1207,6 +1217,8 @@ static void sci_start_rx(struct uart_port *port)
 
         /* Set RIE (Receive Interrupt Enable) bit in SCSCR */
         ctrl |= sci_in(port, SCSCR);
+        if (port->type == PORT_SCIFA)
+                ctrl &= ~0x4000;
         sci_out(port, SCSCR, ctrl);
 }
 
@@ -1216,6 +1228,8 @@ static void sci_stop_rx(struct uart_port *port)
 
         /* Clear RIE (Receive Interrupt Enable) bit in SCSCR */
         ctrl = sci_in(port, SCSCR);
+        if (port->type == PORT_SCIFA)
+                ctrl &= ~0x4000;
         ctrl &= ~(SCI_CTRL_FLAGS_RIE | SCI_CTRL_FLAGS_REIE);
         sci_out(port, SCSCR, ctrl);
 }
@@ -1250,8 +1264,12 @@ static void rx_timer_fn(unsigned long arg)
 {
         struct sci_port *s = (struct sci_port *)arg;
         struct uart_port *port = &s->port;
-
         u16 scr = sci_in(port, SCSCR);
+
+        if (port->type == PORT_SCIFA) {
+                scr &= ~0x4000;
+                enable_irq(s->irqs[1]);
+        }
         sci_out(port, SCSCR, scr | SCI_CTRL_FLAGS_RIE);
         dev_dbg(port->dev, "DMA Rx timed out\n");
         schedule_work(&s->work_rx);
@@ -1401,8 +1419,12 @@ static void sci_shutdown(struct uart_port *port)
 static void sci_set_termios(struct uart_port *port, struct ktermios *termios,
                             struct ktermios *old)
 {
+#ifdef CONFIG_SERIAL_SH_SCI_DMA
+        struct sci_port *s = to_sci_port(port);
+#endif
         unsigned int status, baud, smr_val, max_baud;
         int t = -1;
+        u16 scfcr = 0;
 
         /*
          * earlyprintk comes here early on with port->uartclk set to zero.
@@ -1425,7 +1447,7 @@ static void sci_set_termios(struct uart_port *port, struct ktermios *termios,
         sci_out(port, SCSCR, 0x00);     /* TE=0, RE=0, CKE1=0 */
 
         if (port->type != PORT_SCI)
-                sci_out(port, SCFCR, SCFCR_RFRST | SCFCR_TFRST);
+                sci_out(port, SCFCR, scfcr | SCFCR_RFRST | SCFCR_TFRST);
 
         smr_val = sci_in(port, SCSMR) & 3;
         if ((termios->c_cflag & CSIZE) == CS7)
@@ -1456,10 +1478,32 @@ static void sci_set_termios(struct uart_port *port, struct ktermios *termios,
         }
 
         sci_init_pins(port, termios->c_cflag);
-        sci_out(port, SCFCR, (termios->c_cflag & CRTSCTS) ? SCFCR_MCE : 0);
+        sci_out(port, SCFCR, scfcr | ((termios->c_cflag & CRTSCTS) ? SCFCR_MCE : 0));
 
         sci_out(port, SCSCR, SCSCR_INIT(port));
 
+#ifdef CONFIG_SERIAL_SH_SCI_DMA
+        /*
+         * Calculate delay for 1.5 DMA buffers: see
+         * drivers/serial/serial_core.c::uart_update_timeout(). With 10 bits
+         * (CS8), 250Hz, 115200 baud and 64 bytes FIFO, the above function
+         * calculates 1 jiffie for the data plus 5 jiffies for the "slop(e)."
+         * Then below we calculate 3 jiffies (12ms) for 1.5 DMA buffers (3 FIFO
+         * sizes), but it has been found out experimentally, that this is not
+         * enough: the driver too often needlessly runs on a DMA timeout. 20ms
+         * as a minimum seem to work perfectly.
+         */
+        if (s->chan_rx) {
+                s->rx_timeout = (port->timeout - HZ / 50) * s->buf_len_rx * 3 /
+                        port->fifosize / 2;
+                dev_dbg(port->dev,
+                        "DMA Rx t-out %ums, tty t-out %u jiffies\n",
+                        s->rx_timeout * 1000 / HZ, port->timeout);
+                if (s->rx_timeout < msecs_to_jiffies(20))
+                        s->rx_timeout = msecs_to_jiffies(20);
+        }
+#endif
+
         if ((termios->c_cflag & CREAD) != 0)
                 sci_start_rx(port);
 }
@@ -1551,10 +1595,10 @@ static struct uart_ops sci_uart_ops = {
 #endif
 };
 
-static void __devinit sci_init_single(struct platform_device *dev,
-                                      struct sci_port *sci_port,
-                                      unsigned int index,
-                                      struct plat_sci_port *p)
+static int __devinit sci_init_single(struct platform_device *dev,
+                                     struct sci_port *sci_port,
+                                     unsigned int index,
+                                     struct plat_sci_port *p)
 {
         struct uart_port *port = &sci_port->port;
 
@@ -1575,8 +1619,23 @@ static void __devinit sci_init_single(struct platform_device *dev,
         }
 
         if (dev) {
-                sci_port->iclk = p->clk ? clk_get(&dev->dev, p->clk) : NULL;
-                sci_port->dclk = clk_get(&dev->dev, "peripheral_clk");
+                sci_port->iclk = clk_get(&dev->dev, "sci_ick");
+                if (IS_ERR(sci_port->iclk)) {
+                        sci_port->iclk = clk_get(&dev->dev, "peripheral_clk");
+                        if (IS_ERR(sci_port->iclk)) {
+                                dev_err(&dev->dev, "can't get iclk\n");
+                                return PTR_ERR(sci_port->iclk);
+                        }
+                }
+
+                /*
+                 * The function clock is optional, ignore it if we can't
+                 * find it.
+                 */
+                sci_port->fclk = clk_get(&dev->dev, "sci_fck");
+                if (IS_ERR(sci_port->fclk))
+                        sci_port->fclk = NULL;
+
                 sci_port->enable = sci_clk_enable;
                 sci_port->disable = sci_clk_disable;
                 port->dev = &dev->dev;
@@ -1603,6 +1662,7 @@ static void __devinit sci_init_single(struct platform_device *dev,
 #endif
 
         memcpy(&sci_port->irqs, &p->irqs, sizeof(p->irqs));
+        return 0;
 }
 
 #ifdef CONFIG_SERIAL_SH_SCI_CONSOLE
@@ -1752,8 +1812,11 @@ static int sci_remove(struct platform_device *dev)
         cpufreq_unregister_notifier(&priv->clk_nb, CPUFREQ_TRANSITION_NOTIFIER);
 
         spin_lock_irqsave(&priv->lock, flags);
-        list_for_each_entry(p, &priv->ports, node)
+        list_for_each_entry(p, &priv->ports, node) {
                 uart_remove_one_port(&sci_uart_driver, &p->port);
+                clk_put(p->iclk);
+                clk_put(p->fclk);
+        }
         spin_unlock_irqrestore(&priv->lock, flags);
 
         kfree(priv);
@@ -1779,7 +1842,9 @@ static int __devinit sci_probe_single(struct platform_device *dev,
                 return 0;
         }
 
-        sci_init_single(dev, sciport, index, p);
+        ret = sci_init_single(dev, sciport, index, p);
+        if (ret)
+                return ret;
 
         ret = uart_add_one_port(&sci_uart_driver, &sciport->port);
         if (ret)