6 files changed, 424 insertions, 162 deletions

diff --git a/drivers/tty/serial/8250/8250.c b/drivers/tty/serial/8250/8250.c
index 5c27f7e6c9f1..47d061b9ad4d 100644
--- a/drivers/tty/serial/8250/8250.c
+++ b/drivers/tty/serial/8250/8250.c
@@ -284,7 +284,20 @@ static const struct serial8250_config uart_config[] = {
         },
 };
 
-#if defined(CONFIG_MIPS_ALCHEMY)
+/* Uart divisor latch read */
+static int default_serial_dl_read(struct uart_8250_port *up)
+{
+        return serial_in(up, UART_DLL) | serial_in(up, UART_DLM) << 8;
+}
+
+/* Uart divisor latch write */
+static void default_serial_dl_write(struct uart_8250_port *up, int value)
+{
+        serial_out(up, UART_DLL, value & 0xff);
+        serial_out(up, UART_DLM, value >> 8 & 0xff);
+}
+
+#ifdef CONFIG_MIPS_ALCHEMY
 
 /* Au1x00 UART hardware has a weird register layout */
 static const u8 au_io_in_map[] = {
@@ -305,22 +318,32 @@ static const u8 au_io_out_map[] = {
         [UART_MCR] = 6,
 };
 
-/* sane hardware needs no mapping */
-static inline int map_8250_in_reg(struct uart_port *p, int offset)
+static unsigned int au_serial_in(struct uart_port *p, int offset)
+{
+        offset = au_io_in_map[offset] << p->regshift;
+        return __raw_readl(p->membase + offset);
+}
+
+static void au_serial_out(struct uart_port *p, int offset, int value)
+{
+        offset = au_io_out_map[offset] << p->regshift;
+        __raw_writel(value, p->membase + offset);
+}
+
+/* Au1x00 haven't got a standard divisor latch */
+static int au_serial_dl_read(struct uart_8250_port *up)
 {
-        if (p->iotype != UPIO_AU)
-                return offset;
-        return au_io_in_map[offset];
+        return __raw_readl(up->port.membase + 0x28);
 }
 
-static inline int map_8250_out_reg(struct uart_port *p, int offset)
+static void au_serial_dl_write(struct uart_8250_port *up, int value)
 {
-        if (p->iotype != UPIO_AU)
-                return offset;
-        return au_io_out_map[offset];
+        __raw_writel(value, up->port.membase + 0x28);
 }
 
-#elif defined(CONFIG_SERIAL_8250_RM9K)
+#endif
+
+#ifdef CONFIG_SERIAL_8250_RM9K
 
 static const u8
         regmap_in[8] = {
@@ -344,87 +367,79 @@ static const u8
                 [UART_SCR]      = 0x2c
         };
 
-static inline int map_8250_in_reg(struct uart_port *p, int offset)
+static unsigned int rm9k_serial_in(struct uart_port *p, int offset)
 {
-        if (p->iotype != UPIO_RM9000)
-                return offset;
-        return regmap_in[offset];
+        offset = regmap_in[offset] << p->regshift;
+        return readl(p->membase + offset);
 }
 
-static inline int map_8250_out_reg(struct uart_port *p, int offset)
+static void rm9k_serial_out(struct uart_port *p, int offset, int value)
 {
-        if (p->iotype != UPIO_RM9000)
-                return offset;
-        return regmap_out[offset];
+        offset = regmap_out[offset] << p->regshift;
+        writel(value, p->membase + offset);
 }
 
-#else
+static int rm9k_serial_dl_read(struct uart_8250_port *up)
+{
+        return ((__raw_readl(up->port.membase + 0x10) << 8) |
+                (__raw_readl(up->port.membase + 0x08) & 0xff)) & 0xffff;
+}
 
-/* sane hardware needs no mapping */
-#define map_8250_in_reg(up, offset) (offset)
-#define map_8250_out_reg(up, offset) (offset)
+static void rm9k_serial_dl_write(struct uart_8250_port *up, int value)
+{
+        __raw_writel(value, up->port.membase + 0x08);
+        __raw_writel(value >> 8, up->port.membase + 0x10);
+}
 
 #endif
 
 static unsigned int hub6_serial_in(struct uart_port *p, int offset)
 {
-        offset = map_8250_in_reg(p, offset) << p->regshift;
+        offset = offset << p->regshift;
         outb(p->hub6 - 1 + offset, p->iobase);
         return inb(p->iobase + 1);
 }
 
 static void hub6_serial_out(struct uart_port *p, int offset, int value)
 {
-        offset = map_8250_out_reg(p, offset) << p->regshift;
+        offset = offset << p->regshift;
         outb(p->hub6 - 1 + offset, p->iobase);
         outb(value, p->iobase + 1);
 }
 
 static unsigned int mem_serial_in(struct uart_port *p, int offset)
 {
-        offset = map_8250_in_reg(p, offset) << p->regshift;
+        offset = offset << p->regshift;
         return readb(p->membase + offset);
 }
 
 static void mem_serial_out(struct uart_port *p, int offset, int value)
 {
-        offset = map_8250_out_reg(p, offset) << p->regshift;
+        offset = offset << p->regshift;
         writeb(value, p->membase + offset);
 }
 
 static void mem32_serial_out(struct uart_port *p, int offset, int value)
 {
-        offset = map_8250_out_reg(p, offset) << p->regshift;
+        offset = offset << p->regshift;
         writel(value, p->membase + offset);
 }
 
 static unsigned int mem32_serial_in(struct uart_port *p, int offset)
 {
-        offset = map_8250_in_reg(p, offset) << p->regshift;
+        offset = offset << p->regshift;
         return readl(p->membase + offset);
 }
 
-static unsigned int au_serial_in(struct uart_port *p, int offset)
-{
-        offset = map_8250_in_reg(p, offset) << p->regshift;
-        return __raw_readl(p->membase + offset);
-}
-
-static void au_serial_out(struct uart_port *p, int offset, int value)
-{
-        offset = map_8250_out_reg(p, offset) << p->regshift;
-        __raw_writel(value, p->membase + offset);
-}
-
 static unsigned int io_serial_in(struct uart_port *p, int offset)
 {
-        offset = map_8250_in_reg(p, offset) << p->regshift;
+        offset = offset << p->regshift;
         return inb(p->iobase + offset);
 }
 
 static void io_serial_out(struct uart_port *p, int offset, int value)
 {
-        offset = map_8250_out_reg(p, offset) << p->regshift;
+        offset = offset << p->regshift;
         outb(value, p->iobase + offset);
 }
 
@@ -434,6 +449,10 @@ static void set_io_from_upio(struct uart_port *p)
 {
         struct uart_8250_port *up =
                 container_of(p, struct uart_8250_port, port);
+
+        up->dl_read = default_serial_dl_read;
+        up->dl_write = default_serial_dl_write;
+
         switch (p->iotype) {
         case UPIO_HUB6:
                 p->serial_in = hub6_serial_in;
@@ -445,16 +464,28 @@ static void set_io_from_upio(struct uart_port *p)
                 p->serial_out = mem_serial_out;
                 break;
 
-        case UPIO_RM9000:
         case UPIO_MEM32:
                 p->serial_in = mem32_serial_in;
                 p->serial_out = mem32_serial_out;
                 break;
 
+#ifdef CONFIG_SERIAL_8250_RM9K
+        case UPIO_RM9000:
+                p->serial_in = rm9k_serial_in;
+                p->serial_out = rm9k_serial_out;
+                up->dl_read = rm9k_serial_dl_read;
+                up->dl_write = rm9k_serial_dl_write;
+                break;
+#endif
+
+#ifdef CONFIG_MIPS_ALCHEMY
         case UPIO_AU:
                 p->serial_in = au_serial_in;
                 p->serial_out = au_serial_out;
+                up->dl_read = au_serial_dl_read;
+                up->dl_write = au_serial_dl_write;
                 break;
+#endif
 
         default:
                 p->serial_in = io_serial_in;
@@ -481,59 +512,6 @@ serial_port_out_sync(struct uart_port *p, int offset, int value)
         }
 }
 
-/* Uart divisor latch read */
-static inline int _serial_dl_read(struct uart_8250_port *up)
-{
-        return serial_in(up, UART_DLL) | serial_in(up, UART_DLM) << 8;
-}
-
-/* Uart divisor latch write */
-static inline void _serial_dl_write(struct uart_8250_port *up, int value)
-{
-        serial_out(up, UART_DLL, value & 0xff);
-        serial_out(up, UART_DLM, value >> 8 & 0xff);
-}
-
-#if defined(CONFIG_MIPS_ALCHEMY)
-/* Au1x00 haven't got a standard divisor latch */
-static int serial_dl_read(struct uart_8250_port *up)
-{
-        if (up->port.iotype == UPIO_AU)
-                return __raw_readl(up->port.membase + 0x28);
-        else
-                return _serial_dl_read(up);
-}
-
-static void serial_dl_write(struct uart_8250_port *up, int value)
-{
-        if (up->port.iotype == UPIO_AU)
-                __raw_writel(value, up->port.membase + 0x28);
-        else
-                _serial_dl_write(up, value);
-}
-#elif defined(CONFIG_SERIAL_8250_RM9K)
-static int serial_dl_read(struct uart_8250_port *up)
-{
-        return  (up->port.iotype == UPIO_RM9000) ?
-                (((__raw_readl(up->port.membase + 0x10) << 8) |
-                (__raw_readl(up->port.membase + 0x08) & 0xff)) & 0xffff) :
-                _serial_dl_read(up);
-}
-
-static void serial_dl_write(struct uart_8250_port *up, int value)
-{
-        if (up->port.iotype == UPIO_RM9000) {
-                __raw_writel(value, up->port.membase + 0x08);
-                __raw_writel(value >> 8, up->port.membase + 0x10);
-        } else {
-                _serial_dl_write(up, value);
-        }
-}
-#else
-#define serial_dl_read(up) _serial_dl_read(up)
-#define serial_dl_write(up, value) _serial_dl_write(up, value)
-#endif
-
 /*
  * For the 16C950
  */
@@ -568,6 +546,16 @@ static void serial8250_clear_fifos(struct uart_8250_port *p)
         }
 }
 
+void serial8250_clear_and_reinit_fifos(struct uart_8250_port *p)
+{
+        unsigned char fcr;
+
+        serial8250_clear_fifos(p);
+        fcr = uart_config[p->port.type].fcr;
+        serial_out(p, UART_FCR, fcr);
+}
+EXPORT_SYMBOL_GPL(serial8250_clear_and_reinit_fifos);
+
 /*
  * IER sleep support.  UARTs which have EFRs need the "extended
  * capability" bit enabled.  Note that on XR16C850s, we need to
@@ -1332,27 +1320,6 @@ static void serial8250_enable_ms(struct uart_port *port)
 }
 
 /*
- * Clear the Tegra rx fifo after a break
- *
- * FIXME: This needs to become a port specific callback once we have a
- * framework for this
- */
-static void clear_rx_fifo(struct uart_8250_port *up)
-{
-        unsigned int status, tmout = 10000;
-        do {
-                status = serial_in(up, UART_LSR);
-                if (status & (UART_LSR_FIFOE | UART_LSR_BRK_ERROR_BITS))
-                        status = serial_in(up, UART_RX);
-                else
-                        break;
-                if (--tmout == 0)
-                        break;
-                udelay(1);
-        } while (1);
-}
-
-/*
  * serial8250_rx_chars: processes according to the passed in LSR
  * value, and returns the remaining LSR bits not handled
  * by this Rx routine.
@@ -1386,20 +1353,10 @@ serial8250_rx_chars(struct uart_8250_port *up, unsigned char lsr)
                 up->lsr_saved_flags = 0;
 
                 if (unlikely(lsr & UART_LSR_BRK_ERROR_BITS)) {
-                        /*
-                         * For statistics only
-                         */
                         if (lsr & UART_LSR_BI) {
                                 lsr &= ~(UART_LSR_FE | UART_LSR_PE);
                                 port->icount.brk++;
                                 /*
-                                 * If tegra port then clear the rx fifo to
-                                 * accept another break/character.
-                                 */
-                                if (port->type == PORT_TEGRA)
-                                        clear_rx_fifo(up);
-
-                                /*
                                  * We do the SysRQ and SAK checking
                                  * here because otherwise the break
                                  * may get masked by ignore_status_mask
@@ -2280,10 +2237,11 @@ serial8250_do_set_termios(struct uart_port *port, struct ktermios *termios,
                 quot++;
 
         if (up->capabilities & UART_CAP_FIFO && port->fifosize > 1) {
-                if (baud < 2400)
-                        fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_1;
-                else
-                        fcr = uart_config[port->type].fcr;
+                fcr = uart_config[port->type].fcr;
+                if (baud < 2400) {
+                        fcr &= ~UART_FCR_TRIGGER_MASK;
+                        fcr |= UART_FCR_TRIGGER_1;
+                }
         }
 
         /*
@@ -3037,6 +2995,7 @@ static int __devinit serial8250_probe(struct platform_device *dev)
                 port.serial_in          = p->serial_in;
                 port.serial_out         = p->serial_out;
                 port.handle_irq         = p->handle_irq;
+                port.handle_break       = p->handle_break;
                 port.set_termios        = p->set_termios;
                 port.pm                 = p->pm;
                 port.dev                = &dev->dev;
@@ -3153,7 +3112,7 @@ static struct uart_8250_port *serial8250_find_match_or_unused(struct uart_port *
 }
 
 /**
- *      serial8250_register_port - register a serial port
+ *      serial8250_register_8250_port - register a serial port
  *      @port: serial port template
  *
  *      Configure the serial port specified by the request. If the
@@ -3165,50 +3124,56 @@ static struct uart_8250_port *serial8250_find_match_or_unused(struct uart_port *
  *
  *      On success the port is ready to use and the line number is returned.
  */
-int serial8250_register_port(struct uart_port *port)
+int serial8250_register_8250_port(struct uart_8250_port *up)
 {
         struct uart_8250_port *uart;
         int ret = -ENOSPC;
 
-        if (port->uartclk == 0)
+        if (up->port.uartclk == 0)
                 return -EINVAL;
 
         mutex_lock(&serial_mutex);
 
-        uart = serial8250_find_match_or_unused(port);
+        uart = serial8250_find_match_or_unused(&up->port);
         if (uart) {
                 uart_remove_one_port(&serial8250_reg, &uart->port);
 
-                uart->port.iobase       = port->iobase;
-                uart->port.membase      = port->membase;
-                uart->port.irq          = port->irq;
-                uart->port.irqflags     = port->irqflags;
-                uart->port.uartclk      = port->uartclk;
-                uart->port.fifosize     = port->fifosize;
-                uart->port.regshift     = port->regshift;
-                uart->port.iotype       = port->iotype;
-                uart->port.flags        = port->flags | UPF_BOOT_AUTOCONF;
-                uart->port.mapbase      = port->mapbase;
-                uart->port.private_data = port->private_data;
-                if (port->dev)
-                        uart->port.dev = port->dev;
-
-                if (port->flags & UPF_FIXED_TYPE)
-                        serial8250_init_fixed_type_port(uart, port->type);
+                uart->port.iobase       = up->port.iobase;
+                uart->port.membase      = up->port.membase;
+                uart->port.irq          = up->port.irq;
+                uart->port.irqflags     = up->port.irqflags;
+                uart->port.uartclk      = up->port.uartclk;
+                uart->port.fifosize     = up->port.fifosize;
+                uart->port.regshift     = up->port.regshift;
+                uart->port.iotype       = up->port.iotype;
+                uart->port.flags        = up->port.flags | UPF_BOOT_AUTOCONF;
+                uart->port.mapbase      = up->port.mapbase;
+                uart->port.private_data = up->port.private_data;
+                if (up->port.dev)
+                        uart->port.dev = up->port.dev;
+
+                if (up->port.flags & UPF_FIXED_TYPE)
+                        serial8250_init_fixed_type_port(uart, up->port.type);
 
                 set_io_from_upio(&uart->port);
                 /* Possibly override default I/O functions.  */
-                if (port->serial_in)
-                        uart->port.serial_in = port->serial_in;
-                if (port->serial_out)
-                        uart->port.serial_out = port->serial_out;
-                if (port->handle_irq)
-                        uart->port.handle_irq = port->handle_irq;
+                if (up->port.serial_in)
+                        uart->port.serial_in = up->port.serial_in;
+                if (up->port.serial_out)
+                        uart->port.serial_out = up->port.serial_out;
+                if (up->port.handle_irq)
+                        uart->port.handle_irq = up->port.handle_irq;
                 /*  Possibly override set_termios call */
-                if (port->set_termios)
-                        uart->port.set_termios = port->set_termios;
-                if (port->pm)
-                        uart->port.pm = port->pm;
+                if (up->port.set_termios)
+                        uart->port.set_termios = up->port.set_termios;
+                if (up->port.pm)
+                        uart->port.pm = up->port.pm;
+                if (up->port.handle_break)
+                        uart->port.handle_break = up->port.handle_break;
+                if (up->dl_read)
+                        uart->dl_read = up->dl_read;
+                if (up->dl_write)
+                        uart->dl_write = up->dl_write;
 
                 if (serial8250_isa_config != NULL)
                         serial8250_isa_config(0, &uart->port,
@@ -3222,6 +3187,29 @@ int serial8250_register_port(struct uart_port *port)
 
         return ret;
 }
+EXPORT_SYMBOL(serial8250_register_8250_port);
+
+/**
+ *      serial8250_register_port - register a serial port
+ *      @port: serial port template
+ *
+ *      Configure the serial port specified by the request. If the
+ *      port exists and is in use, it is hung up and unregistered
+ *      first.
+ *
+ *      The port is then probed and if necessary the IRQ is autodetected
+ *      If this fails an error is returned.
+ *
+ *      On success the port is ready to use and the line number is returned.
+ */
+int serial8250_register_port(struct uart_port *port)
+{
+        struct uart_8250_port up;
+
+        memset(&up, 0, sizeof(up));
+        memcpy(&up.port, port, sizeof(*port));
+        return serial8250_register_8250_port(&up);
+}
 EXPORT_SYMBOL(serial8250_register_port);
 
 /**
diff --git a/drivers/tty/serial/8250/8250.h b/drivers/tty/serial/8250/8250.h
index 2868a1da254d..f9719d167c8d 100644
--- a/drivers/tty/serial/8250/8250.h
+++ b/drivers/tty/serial/8250/8250.h
@@ -37,6 +37,10 @@ struct uart_8250_port {
         unsigned char           lsr_saved_flags;
 #define MSR_SAVE_FLAGS UART_MSR_ANY_DELTA
         unsigned char           msr_saved_flags;
+
+        /* 8250 specific callbacks */
+        int                     (*dl_read)(struct uart_8250_port *);
+        void                    (*dl_write)(struct uart_8250_port *, int);
 };
 
 struct old_serial_port {
@@ -96,6 +100,18 @@ static inline void serial_out(struct uart_8250_port *up, int offset, int value)
         up->port.serial_out(&up->port, offset, value);
 }
 
+void serial8250_clear_and_reinit_fifos(struct uart_8250_port *p);
+
+static inline int serial_dl_read(struct uart_8250_port *up)
+{
+        return up->dl_read(up);
+}
+
+static inline void serial_dl_write(struct uart_8250_port *up, int value)
+{
+        up->dl_write(up, value);
+}
+
 #if defined(__alpha__) && !defined(CONFIG_PCI)
 /*
  * Digital did something really horribly wrong with the OUT1 and OUT2
diff --git a/drivers/tty/serial/8250/8250_em.c b/drivers/tty/serial/8250/8250_em.c
new file mode 100644
index 000000000000..3a0363e7f3a7
--- /dev/null
+++ b/drivers/tty/serial/8250/8250_em.c
@@ -0,0 +1,186 @@
+/*
+ * Renesas Emma Mobile 8250 driver
+ *
+ *  Copyright (C) 2012 Magnus Damm
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/device.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/serial_8250.h>
+#include <linux/serial_core.h>
+#include <linux/serial_reg.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/slab.h>
+
+#include "8250.h"
+
+#define UART_DLL_EM 9
+#define UART_DLM_EM 10
+
+struct serial8250_em_priv {
+        struct clk *sclk;
+        int line;
+};
+
+static void serial8250_em_serial_out(struct uart_port *p, int offset, int value)
+{
+        switch (offset) {
+        case UART_TX: /* TX @ 0x00 */
+                writeb(value, p->membase);
+                break;
+        case UART_FCR: /* FCR @ 0x0c (+1) */
+        case UART_LCR: /* LCR @ 0x10 (+1) */
+        case UART_MCR: /* MCR @ 0x14 (+1) */
+        case UART_SCR: /* SCR @ 0x20 (+1) */
+                writel(value, p->membase + ((offset + 1) << 2));
+                break;
+        case UART_IER: /* IER @ 0x04 */
+                value &= 0x0f; /* only 4 valid bits - not Xscale */
+                /* fall-through */
+        case UART_DLL_EM: /* DLL @ 0x24 (+9) */
+        case UART_DLM_EM: /* DLM @ 0x28 (+9) */
+                writel(value, p->membase + (offset << 2));
+        }
+}
+
+static unsigned int serial8250_em_serial_in(struct uart_port *p, int offset)
+{
+        switch (offset) {
+        case UART_RX: /* RX @ 0x00 */
+                return readb(p->membase);
+        case UART_MCR: /* MCR @ 0x14 (+1) */
+        case UART_LSR: /* LSR @ 0x18 (+1) */
+        case UART_MSR: /* MSR @ 0x1c (+1) */
+        case UART_SCR: /* SCR @ 0x20 (+1) */
+                return readl(p->membase + ((offset + 1) << 2));
+        case UART_IER: /* IER @ 0x04 */
+        case UART_IIR: /* IIR @ 0x08 */
+        case UART_DLL_EM: /* DLL @ 0x24 (+9) */
+        case UART_DLM_EM: /* DLM @ 0x28 (+9) */
+                return readl(p->membase + (offset << 2));
+        }
+        return 0;
+}
+
+static int serial8250_em_serial_dl_read(struct uart_8250_port *up)
+{
+        return serial_in(up, UART_DLL_EM) | serial_in(up, UART_DLM_EM) << 8;
+}
+
+static void serial8250_em_serial_dl_write(struct uart_8250_port *up, int value)
+{
+        serial_out(up, UART_DLL_EM, value & 0xff);
+        serial_out(up, UART_DLM_EM, value >> 8 & 0xff);
+}
+
+static int __devinit serial8250_em_probe(struct platform_device *pdev)
+{
+        struct resource *regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        struct resource *irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        struct serial8250_em_priv *priv;
+        struct uart_8250_port up;
+        int ret = -EINVAL;
+
+        if (!regs || !irq) {
+                dev_err(&pdev->dev, "missing registers or irq\n");
+                goto err0;
+        }
+
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv) {
+                dev_err(&pdev->dev, "unable to allocate private data\n");
+                ret = -ENOMEM;
+                goto err0;
+        }
+
+        priv->sclk = clk_get(&pdev->dev, "sclk");
+        if (IS_ERR(priv->sclk)) {
+                dev_err(&pdev->dev, "unable to get clock\n");
+                ret = PTR_ERR(priv->sclk);
+                goto err1;
+        }
+
+        memset(&up, 0, sizeof(up));
+        up.port.mapbase = regs->start;
+        up.port.irq = irq->start;
+        up.port.type = PORT_UNKNOWN;
+        up.port.flags = UPF_BOOT_AUTOCONF | UPF_FIXED_PORT | UPF_IOREMAP;
+        up.port.dev = &pdev->dev;
+        up.port.private_data = priv;
+
+        clk_enable(priv->sclk);
+        up.port.uartclk = clk_get_rate(priv->sclk);
+
+        up.port.iotype = UPIO_MEM32;
+        up.port.serial_in = serial8250_em_serial_in;
+        up.port.serial_out = serial8250_em_serial_out;
+        up.dl_read = serial8250_em_serial_dl_read;
+        up.dl_write = serial8250_em_serial_dl_write;
+
+        ret = serial8250_register_8250_port(&up);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "unable to register 8250 port\n");
+                goto err2;
+        }
+
+        priv->line = ret;
+        platform_set_drvdata(pdev, priv);
+        return 0;
+
+ err2:
+        clk_disable(priv->sclk);
+        clk_put(priv->sclk);
+ err1:
+        kfree(priv);
+ err0:
+        return ret;
+}
+
+static int __devexit serial8250_em_remove(struct platform_device *pdev)
+{
+        struct serial8250_em_priv *priv = platform_get_drvdata(pdev);
+
+        serial8250_unregister_port(priv->line);
+        clk_disable(priv->sclk);
+        clk_put(priv->sclk);
+        kfree(priv);
+        return 0;
+}
+
+static const struct of_device_id serial8250_em_dt_ids[] __devinitconst = {
+        { .compatible = "renesas,em-uart", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, serial8250_em_dt_ids);
+
+static struct platform_driver serial8250_em_platform_driver = {
+        .driver = {
+                .name           = "serial8250-em",
+                .of_match_table = serial8250_em_dt_ids,
+                .owner          = THIS_MODULE,
+        },
+        .probe                  = serial8250_em_probe,
+        .remove                 = __devexit_p(serial8250_em_remove),
+};
+
+module_platform_driver(serial8250_em_platform_driver);
+
+MODULE_AUTHOR("Magnus Damm");
+MODULE_DESCRIPTION("Renesas Emma Mobile 8250 Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/tty/serial/8250/8250_pci.c b/drivers/tty/serial/8250/8250_pci.c
index 858dca865d6a..28e7c7cce893 100644
--- a/drivers/tty/serial/8250/8250_pci.c
+++ b/drivers/tty/serial/8250/8250_pci.c
@@ -17,6 +17,7 @@
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/tty.h>
+#include <linux/serial_reg.h>
 #include <linux/serial_core.h>
 #include <linux/8250_pci.h>
 #include <linux/bitops.h>
@@ -1092,11 +1093,49 @@ static int skip_tx_en_setup(struct serial_private *priv,
         return pci_default_setup(priv, board, port, idx);
 }
 
+static void kt_handle_break(struct uart_port *p)
+{
+        struct uart_8250_port *up =
+                container_of(p, struct uart_8250_port, port);
+        /*
+         * On receipt of a BI, serial device in Intel ME (Intel
+         * management engine) needs to have its fifos cleared for sane
+         * SOL (Serial Over Lan) output.
+         */
+        serial8250_clear_and_reinit_fifos(up);
+}
+
+static unsigned int kt_serial_in(struct uart_port *p, int offset)
+{
+        struct uart_8250_port *up =
+                container_of(p, struct uart_8250_port, port);
+        unsigned int val;
+
+        /*
+         * When the Intel ME (management engine) gets reset its serial
+         * port registers could return 0 momentarily.  Functions like
+         * serial8250_console_write, read and save the IER, perform
+         * some operation and then restore it.  In order to avoid
+         * setting IER register inadvertently to 0, if the value read
+         * is 0, double check with ier value in uart_8250_port and use
+         * that instead.  up->ier should be the same value as what is
+         * currently configured.
+         */
+        val = inb(p->iobase + offset);
+        if (offset == UART_IER) {
+                if (val == 0)
+                        val = up->ier;
+        }
+        return val;
+}
+
 static int kt_serial_setup(struct serial_private *priv,
                            const struct pciserial_board *board,
                            struct uart_port *port, int idx)
 {
         port->flags |= UPF_BUG_THRE;
+        port->serial_in = kt_serial_in;
+        port->handle_break = kt_handle_break;
         return skip_tx_en_setup(priv, board, port, idx);
 }
 
@@ -1609,54 +1648,72 @@ static struct pci_serial_quirk pci_serial_quirks[] __refdata = {
         {
                 .vendor         = PCI_VENDOR_ID_INTEL,
                 .device         = 0x8811,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
                 .init           = pci_eg20t_init,
                 .setup          = pci_default_setup,
         },
         {
                 .vendor         = PCI_VENDOR_ID_INTEL,
                 .device         = 0x8812,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
                 .init           = pci_eg20t_init,
                 .setup          = pci_default_setup,
         },
         {
                 .vendor         = PCI_VENDOR_ID_INTEL,
                 .device         = 0x8813,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
                 .init           = pci_eg20t_init,
                 .setup          = pci_default_setup,
         },
         {
                 .vendor         = PCI_VENDOR_ID_INTEL,
                 .device         = 0x8814,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
                 .init           = pci_eg20t_init,
                 .setup          = pci_default_setup,
         },
         {
                 .vendor         = 0x10DB,
                 .device         = 0x8027,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
                 .init           = pci_eg20t_init,
                 .setup          = pci_default_setup,
         },
         {
                 .vendor         = 0x10DB,
                 .device         = 0x8028,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
                 .init           = pci_eg20t_init,
                 .setup          = pci_default_setup,
         },
         {
                 .vendor         = 0x10DB,
                 .device         = 0x8029,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
                 .init           = pci_eg20t_init,
                 .setup          = pci_default_setup,
         },
         {
                 .vendor         = 0x10DB,
                 .device         = 0x800C,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
                 .init           = pci_eg20t_init,
                 .setup          = pci_default_setup,
         },
         {
                 .vendor         = 0x10DB,
                 .device         = 0x800D,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
                 .init           = pci_eg20t_init,
                 .setup          = pci_default_setup,
         },
@@ -2775,6 +2832,12 @@ void pciserial_suspend_ports(struct serial_private *priv)
         for (i = 0; i < priv->nr; i++)
                 if (priv->line[i] >= 0)
                         serial8250_suspend_port(priv->line[i]);
+
+        /*
+         * Ensure that every init quirk is properly torn down
+         */
+        if (priv->quirk->exit)
+                priv->quirk->exit(priv->dev);
 }
 EXPORT_SYMBOL_GPL(pciserial_suspend_ports);
 
diff --git a/drivers/tty/serial/8250/Kconfig b/drivers/tty/serial/8250/Kconfig
index 591f8018e7dd..8bc7ecbf6bea 100644
--- a/drivers/tty/serial/8250/Kconfig
+++ b/drivers/tty/serial/8250/Kconfig
@@ -278,3 +278,11 @@ config SERIAL_8250_DW
         help
           Selecting this option will enable handling of the extra features
           present in the Synopsys DesignWare APB UART.
+
+config SERIAL_8250_EM
+        tristate "Support for Emma Mobile intergrated serial port"
+        depends on SERIAL_8250 && ARM && HAVE_CLK
+        help
+          Selecting this option will add support for the integrated serial
+          port hardware found on the Emma Mobile line of processors.
+          If unsure, say N.
diff --git a/drivers/tty/serial/8250/Makefile b/drivers/tty/serial/8250/Makefile
index 867bba738908..3f35eacdf673 100644
--- a/drivers/tty/serial/8250/Makefile
+++ b/drivers/tty/serial/8250/Makefile
@@ -18,3 +18,4 @@ obj-$(CONFIG_SERIAL_8250_HUB6)		+= 8250_hub6.o
 obj-$(CONFIG_SERIAL_8250_MCA)           += 8250_mca.o
 obj-$(CONFIG_SERIAL_8250_FSL)           += 8250_fsl.o
 obj-$(CONFIG_SERIAL_8250_DW)            += 8250_dw.o
+obj-$(CONFIG_SERIAL_8250_EM)            += 8250_em.o