1 files changed, 85 insertions, 367 deletions

diff --git a/drivers/tty/serial/pch_uart.c b/drivers/tty/serial/pch_uart.c
index 8318925fbf6..f913ed054c1 100644
--- a/drivers/tty/serial/pch_uart.c
+++ b/drivers/tty/serial/pch_uart.c
@@ -1,5 +1,5 @@
 /*
- *Copyright (C) 2011 LAPIS Semiconductor Co., Ltd.
+ *Copyright (C) 2010 OKI SEMICONDUCTOR CO., LTD.
  *
  *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
@@ -20,16 +20,10 @@
 #include <linux/module.h>
 #include <linux/pci.h>
 #include <linux/serial_core.h>
-#include <linux/tty.h>
-#include <linux/tty_flip.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/dmi.h>
-#include <linux/console.h>
-#include <linux/nmi.h>
-#include <linux/delay.h>
 
-#include <linux/debugfs.h>
 #include <linux/dmaengine.h>
 #include <linux/pch_dma.h>
 
@@ -39,7 +33,6 @@ enum {
         PCH_UART_HANDLED_RX_ERR_INT_SHIFT,
         PCH_UART_HANDLED_RX_TRG_INT_SHIFT,
         PCH_UART_HANDLED_MS_INT_SHIFT,
-        PCH_UART_HANDLED_LS_INT_SHIFT,
 };
 
 enum {
@@ -51,8 +44,8 @@ enum {
 
 /* Set the max number of UART port
  * Intel EG20T PCH: 4 port
- * LAPIS Semiconductor ML7213 IOH: 3 port
- * LAPIS Semiconductor ML7223 IOH: 2 port
+ * OKI SEMICONDUCTOR ML7213 IOH: 3 port
+ * OKI SEMICONDUCTOR ML7223 IOH: 2 port
 */
 #define PCH_UART_NR     4
 
@@ -64,8 +57,6 @@ enum {
                                         PCH_UART_HANDLED_RX_TRG_INT_SHIFT)<<1))
 #define PCH_UART_HANDLED_MS_INT (1<<((PCH_UART_HANDLED_MS_INT_SHIFT)<<1))
 
-#define PCH_UART_HANDLED_LS_INT (1<<((PCH_UART_HANDLED_LS_INT_SHIFT)<<1))
-
 #define PCH_UART_RBR            0x00
 #define PCH_UART_THR            0x00
 
@@ -148,8 +139,6 @@ enum {
 #define PCH_UART_DLL            0x00
 #define PCH_UART_DLM            0x01
 
-#define PCH_UART_BRCSR          0x0E
-
 #define PCH_UART_IID_RLS        (PCH_UART_IIR_REI)
 #define PCH_UART_IID_RDR        (PCH_UART_IIR_RRI)
 #define PCH_UART_IID_RDR_TO     (PCH_UART_IIR_RRI | PCH_UART_IIR_TOI)
@@ -207,14 +196,6 @@ enum {
 
 #define PCI_VENDOR_ID_ROHM              0x10DB
 
-#define BOTH_EMPTY (UART_LSR_TEMT | UART_LSR_THRE)
-
-#define DEFAULT_UARTCLK   1843200 /*   1.8432 MHz */
-#define CMITC_UARTCLK   192000000 /* 192.0000 MHz */
-#define FRI2_64_UARTCLK  64000000 /*  64.0000 MHz */
-#define FRI2_48_UARTCLK  48000000 /*  48.0000 MHz */
-#define NTC1_UARTCLK     64000000 /*  64.0000 MHz */
-
 struct pch_uart_buffer {
         unsigned char *buf;
         int size;
@@ -228,10 +209,11 @@ struct eg20t_port {
         unsigned int iobase;
         struct pci_dev *pdev;
         int fifo_size;
-        int uartclk;
+        int base_baud;
         int start_tx;
         int start_rx;
         int tx_empty;
+        int int_dis_flag;
         int trigger;
         int trigger_level;
         struct pch_uart_buffer rxbuf;
@@ -239,6 +221,7 @@ struct eg20t_port {
         unsigned int fcr;
         unsigned int mcr;
         unsigned int use_dma;
+        unsigned int use_dma_flag;
         struct dma_async_tx_descriptor  *desc_tx;
         struct dma_async_tx_descriptor  *desc_rx;
         struct pch_dma_slave            param_tx;
@@ -251,11 +234,6 @@ struct eg20t_port {
         int                             tx_dma_use;
         void                            *rx_buf_virt;
         dma_addr_t                      rx_buf_dma;
-
-        struct dentry   *debugfs;
-
-        /* protect the eg20t_port private structure and io access to membase */
-        spinlock_t lock;
 };
 
 /**
@@ -296,106 +274,27 @@ static struct pch_uart_driver_data drv_dat[] = {
         [pch_ml7831_uart1] = {PCH_UART_2LINE, 1},
 };
 
-#ifdef CONFIG_SERIAL_PCH_UART_CONSOLE
-static struct eg20t_port *pch_uart_ports[PCH_UART_NR];
-#endif
 static unsigned int default_baud = 9600;
-static unsigned int user_uartclk = 0;
 static const int trigger_level_256[4] = { 1, 64, 128, 224 };
 static const int trigger_level_64[4] = { 1, 16, 32, 56 };
 static const int trigger_level_16[4] = { 1, 4, 8, 14 };
 static const int trigger_level_1[4] = { 1, 1, 1, 1 };
 
-#ifdef CONFIG_DEBUG_FS
-
-#define PCH_REGS_BUFSIZE        1024
-
-
-static ssize_t port_show_regs(struct file *file, char __user *user_buf,
-                                size_t count, loff_t *ppos)
+static void pch_uart_hal_request(struct pci_dev *pdev, int fifosize,
+                                 int base_baud)
 {
-        struct eg20t_port *priv = file->private_data;
-        char *buf;
-        u32 len = 0;
-        ssize_t ret;
-        unsigned char lcr;
-
-        buf = kzalloc(PCH_REGS_BUFSIZE, GFP_KERNEL);
-        if (!buf)
-                return 0;
-
-        len += snprintf(buf + len, PCH_REGS_BUFSIZE - len,
-                        "PCH EG20T port[%d] regs:\n", priv->port.line);
-
-        len += snprintf(buf + len, PCH_REGS_BUFSIZE - len,
-                        "=================================\n");
-        len += snprintf(buf + len, PCH_REGS_BUFSIZE - len,
-                        "IER: \t0x%02x\n", ioread8(priv->membase + UART_IER));
-        len += snprintf(buf + len, PCH_REGS_BUFSIZE - len,
-                        "IIR: \t0x%02x\n", ioread8(priv->membase + UART_IIR));
-        len += snprintf(buf + len, PCH_REGS_BUFSIZE - len,
-                        "LCR: \t0x%02x\n", ioread8(priv->membase + UART_LCR));
-        len += snprintf(buf + len, PCH_REGS_BUFSIZE - len,
-                        "MCR: \t0x%02x\n", ioread8(priv->membase + UART_MCR));
-        len += snprintf(buf + len, PCH_REGS_BUFSIZE - len,
-                        "LSR: \t0x%02x\n", ioread8(priv->membase + UART_LSR));
-        len += snprintf(buf + len, PCH_REGS_BUFSIZE - len,
-                        "MSR: \t0x%02x\n", ioread8(priv->membase + UART_MSR));
-        len += snprintf(buf + len, PCH_REGS_BUFSIZE - len,
-                        "BRCSR: \t0x%02x\n",
-                        ioread8(priv->membase + PCH_UART_BRCSR));
-
-        lcr = ioread8(priv->membase + UART_LCR);
-        iowrite8(PCH_UART_LCR_DLAB, priv->membase + UART_LCR);
-        len += snprintf(buf + len, PCH_REGS_BUFSIZE - len,
-                        "DLL: \t0x%02x\n", ioread8(priv->membase + UART_DLL));
-        len += snprintf(buf + len, PCH_REGS_BUFSIZE - len,
-                        "DLM: \t0x%02x\n", ioread8(priv->membase + UART_DLM));
-        iowrite8(lcr, priv->membase + UART_LCR);
-
-        if (len > PCH_REGS_BUFSIZE)
-                len = PCH_REGS_BUFSIZE;
+        struct eg20t_port *priv = pci_get_drvdata(pdev);
 
-        ret =  simple_read_from_buffer(user_buf, count, ppos, buf, len);
-        kfree(buf);
-        return ret;
+        priv->trigger_level = 1;
+        priv->fcr = 0;
 }
 
-static const struct file_operations port_regs_ops = {
-        .owner          = THIS_MODULE,
-        .open           = simple_open,
-        .read           = port_show_regs,
-        .llseek         = default_llseek,
-};
-#endif  /* CONFIG_DEBUG_FS */
-
-/* Return UART clock, checking for board specific clocks. */
-static int pch_uart_get_uartclk(void)
+static unsigned int get_msr(struct eg20t_port *priv, void __iomem *base)
 {
-        const char *cmp;
+        unsigned int msr = ioread8(base + UART_MSR);
+        priv->dmsr |= msr & PCH_UART_MSR_DELTA;
 
-        if (user_uartclk)
-                return user_uartclk;
-
-        cmp = dmi_get_system_info(DMI_BOARD_NAME);
-        if (cmp && strstr(cmp, "CM-iTC"))
-                return CMITC_UARTCLK;
-
-        cmp = dmi_get_system_info(DMI_BIOS_VERSION);
-        if (cmp && strnstr(cmp, "FRI2", 4))
-                return FRI2_64_UARTCLK;
-
-        cmp = dmi_get_system_info(DMI_PRODUCT_NAME);
-        if (cmp && strstr(cmp, "Fish River Island II"))
-                return FRI2_48_UARTCLK;
-
-        /* Kontron COMe-mTT10 (nanoETXexpress-TT) */
-        cmp = dmi_get_system_info(DMI_BOARD_NAME);
-        if (cmp && (strstr(cmp, "COMe-mTT") ||
-                    strstr(cmp, "nanoETXexpress-TT")))
-                return NTC1_UARTCLK;
-
-        return DEFAULT_UARTCLK;
+        return msr;
 }
 
 static void pch_uart_hal_enable_interrupt(struct eg20t_port *priv,
@@ -421,7 +320,7 @@ static int pch_uart_hal_set_line(struct eg20t_port *priv, int baud,
         unsigned int dll, dlm, lcr;
         int div;
 
-        div = DIV_ROUND_CLOSEST(priv->uartclk / 16, baud);
+        div = DIV_ROUND_CLOSEST(priv->base_baud / 16, baud);
         if (div < 0 || USHRT_MAX <= div) {
                 dev_err(priv->port.dev, "Invalid Baud(div=0x%x)\n", div);
                 return -EINVAL;
@@ -531,9 +430,8 @@ static int pch_uart_hal_set_fifo(struct eg20t_port *priv,
 
 static u8 pch_uart_hal_get_modem(struct eg20t_port *priv)
 {
-        unsigned int msr = ioread8(priv->membase + UART_MSR);
-        priv->dmsr = msr & PCH_UART_MSR_DELTA;
-        return (u8)msr;
+        priv->dmsr = 0;
+        return get_msr(priv, priv->membase);
 }
 
 static void pch_uart_hal_write(struct eg20t_port *priv,
@@ -564,10 +462,14 @@ static int pch_uart_hal_read(struct eg20t_port *priv, unsigned char *buf,
         return i;
 }
 
-static unsigned char pch_uart_hal_get_iid(struct eg20t_port *priv)
+static unsigned int pch_uart_hal_get_iid(struct eg20t_port *priv)
 {
-        return ioread8(priv->membase + UART_IIR) &\
-                      (PCH_UART_IIR_IID | PCH_UART_IIR_TOI | PCH_UART_IIR_IP);
+        unsigned int iir;
+        int ret;
+
+        iir = ioread8(priv->membase + UART_IIR);
+        ret = (iir & (PCH_UART_IIR_IID | PCH_UART_IIR_TOI | PCH_UART_IIR_IP));
+        return ret;
 }
 
 static u8 pch_uart_hal_get_line_status(struct eg20t_port *priv)
@@ -610,7 +512,7 @@ static int push_rx(struct eg20t_port *priv, const unsigned char *buf,
 
 static int pop_tx_x(struct eg20t_port *priv, unsigned char *buf)
 {
-        int ret = 0;
+        int ret;
         struct uart_port *port = &priv->port;
 
         if (port->x_char) {
@@ -619,6 +521,8 @@ static int pop_tx_x(struct eg20t_port *priv, unsigned char *buf)
                 buf[0] = port->x_char;
                 port->x_char = 0;
                 ret = 1;
+        } else {
+                ret = 0;
         }
 
         return ret;
@@ -666,13 +570,10 @@ static void pch_free_dma(struct uart_port *port)
                 dma_release_channel(priv->chan_rx);
                 priv->chan_rx = NULL;
         }
-
-        if (priv->rx_buf_dma) {
-                dma_free_coherent(port->dev, port->fifosize, priv->rx_buf_virt,
-                                  priv->rx_buf_dma);
-                priv->rx_buf_virt = NULL;
-                priv->rx_buf_dma = 0;
-        }
+        if (sg_dma_address(&priv->sg_rx))
+                dma_free_coherent(port->dev, port->fifosize,
+                                  sg_virt(&priv->sg_rx),
+                                  sg_dma_address(&priv->sg_rx));
 
         return;
 }
@@ -757,8 +658,7 @@ static void pch_dma_rx_complete(void *arg)
                 tty_flip_buffer_push(tty);
         tty_kref_put(tty);
         async_tx_ack(priv->desc_rx);
-        pch_uart_hal_enable_interrupt(priv, PCH_UART_HAL_RX_INT |
-                                            PCH_UART_HAL_RX_ERR_INT);
+        pch_uart_hal_enable_interrupt(priv, PCH_UART_HAL_RX_INT);
 }
 
 static void pch_dma_tx_complete(void *arg)
@@ -813,8 +713,7 @@ static int handle_rx_to(struct eg20t_port *priv)
         int rx_size;
         int ret;
         if (!priv->start_rx) {
-                pch_uart_hal_disable_interrupt(priv, PCH_UART_HAL_RX_INT |
-                                                     PCH_UART_HAL_RX_ERR_INT);
+                pch_uart_hal_disable_interrupt(priv, PCH_UART_HAL_RX_INT);
                 return 0;
         }
         buf = &priv->rxbuf;
@@ -852,8 +751,8 @@ static int dma_handle_rx(struct eg20t_port *priv)
 
         sg_dma_address(sg) = priv->rx_buf_dma;
 
-        desc = dmaengine_prep_slave_sg(priv->chan_rx,
-                        sg, 1, DMA_DEV_TO_MEM,
+        desc = priv->chan_rx->device->device_prep_slave_sg(priv->chan_rx,
+                        sg, 1, DMA_FROM_DEVICE,
                         DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
 
         if (!desc)
@@ -979,10 +878,6 @@ static unsigned int dma_handle_tx(struct eg20t_port *priv)
         priv->tx_dma_use = 1;
 
         priv->sg_tx_p = kzalloc(sizeof(struct scatterlist)*num, GFP_ATOMIC);
-        if (!priv->sg_tx_p) {
-                dev_err(priv->port.dev, "%s:kzalloc Failed\n", __func__);
-                return 0;
-        }
 
         sg_init_table(priv->sg_tx_p, num); /* Initialize SG table */
         sg = priv->sg_tx_p;
@@ -1015,8 +910,8 @@ static unsigned int dma_handle_tx(struct eg20t_port *priv)
                         sg_dma_len(sg) = size;
         }
 
-        desc = dmaengine_prep_slave_sg(priv->chan_tx,
-                                        priv->sg_tx_p, nent, DMA_MEM_TO_DEV,
+        desc = priv->chan_tx->device->device_prep_slave_sg(priv->chan_tx,
+                                        priv->sg_tx_p, nent, DMA_TO_DEVICE,
                                         DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
         if (!desc) {
                 dev_err(priv->port.dev, "%s:device_prep_slave_sg Failed\n",
@@ -1062,17 +957,12 @@ static irqreturn_t pch_uart_interrupt(int irq, void *dev_id)
         unsigned int handled;
         u8 lsr;
         int ret = 0;
-        unsigned char iid;
+        unsigned int iid;
         unsigned long flags;
-        int next = 1;
-        u8 msr;
 
-        spin_lock_irqsave(&priv->lock, flags);
+        spin_lock_irqsave(&priv->port.lock, flags);
         handled = 0;
-        while (next) {
-                iid = pch_uart_hal_get_iid(priv);
-                if (iid & PCH_UART_IIR_IP) /* No Interrupt */
-                        break;
+        while ((iid = pch_uart_hal_get_iid(priv)) > 1) {
                 switch (iid) {
                 case PCH_UART_IID_RLS:  /* Receiver Line Status */
                         lsr = pch_uart_hal_get_line_status(priv);
@@ -1080,20 +970,16 @@ static irqreturn_t pch_uart_interrupt(int irq, void *dev_id)
                                                 UART_LSR_PE | UART_LSR_OE)) {
                                 pch_uart_err_ir(priv, lsr);
                                 ret = PCH_UART_HANDLED_RX_ERR_INT;
-                        } else {
-                                ret = PCH_UART_HANDLED_LS_INT;
                         }
                         break;
                 case PCH_UART_IID_RDR:  /* Received Data Ready */
                         if (priv->use_dma) {
                                 pch_uart_hal_disable_interrupt(priv,
-                                                PCH_UART_HAL_RX_INT |
-                                                PCH_UART_HAL_RX_ERR_INT);
+                                                        PCH_UART_HAL_RX_INT);
                                 ret = dma_handle_rx(priv);
                                 if (!ret)
                                         pch_uart_hal_enable_interrupt(priv,
-                                                PCH_UART_HAL_RX_INT |
-                                                PCH_UART_HAL_RX_ERR_INT);
+                                                        PCH_UART_HAL_RX_INT);
                         } else {
                                 ret = handle_rx(priv);
                         }
@@ -1110,24 +996,22 @@ static irqreturn_t pch_uart_interrupt(int irq, void *dev_id)
                                 ret = handle_tx(priv);
                         break;
                 case PCH_UART_IID_MS:   /* Modem Status */
-                        msr = pch_uart_hal_get_modem(priv);
-                        next = 0; /* MS ir prioirty is the lowest. So, MS ir
-                                     means final interrupt */
-                        if ((msr & UART_MSR_ANY_DELTA) == 0)
-                                break;
-                        ret |= PCH_UART_HANDLED_MS_INT;
+                        ret = PCH_UART_HANDLED_MS_INT;
                         break;
                 default:        /* Never junp to this label */
-                        dev_err(priv->port.dev, "%s:iid=%02x (%lu)\n", __func__,
+                        dev_err(priv->port.dev, "%s:iid=%d (%lu)\n", __func__,
                                 iid, jiffies);
                         ret = -1;
-                        next = 0;
                         break;
                 }
                 handled |= (unsigned int)ret;
         }
+        if (handled == 0 && iid <= 1) {
+                if (priv->int_dis_flag)
+                        priv->int_dis_flag = 0;
+        }
 
-        spin_unlock_irqrestore(&priv->lock, flags);
+        spin_unlock_irqrestore(&priv->port.lock, flags);
         return IRQ_RETVAL(handled);
 }
 
@@ -1136,12 +1020,14 @@ static irqreturn_t pch_uart_interrupt(int irq, void *dev_id)
 static unsigned int pch_uart_tx_empty(struct uart_port *port)
 {
         struct eg20t_port *priv;
-
+        int ret;
         priv = container_of(port, struct eg20t_port, port);
         if (priv->tx_empty)
-                return TIOCSER_TEMT;
+                ret = TIOCSER_TEMT;
         else
-                return 0;
+                ret = 0;
+
+        return ret;
 }
 
 /* Returns the current state of modem control inputs. */
@@ -1219,8 +1105,8 @@ static void pch_uart_stop_rx(struct uart_port *port)
         struct eg20t_port *priv;
         priv = container_of(port, struct eg20t_port, port);
         priv->start_rx = 0;
-        pch_uart_hal_disable_interrupt(priv, PCH_UART_HAL_RX_INT |
-                                             PCH_UART_HAL_RX_ERR_INT);
+        pch_uart_hal_disable_interrupt(priv, PCH_UART_HAL_RX_INT);
+        priv->int_dis_flag = 1;
 }
 
 /* Enable the modem status interrupts. */
@@ -1238,9 +1124,9 @@ static void pch_uart_break_ctl(struct uart_port *port, int ctl)
         unsigned long flags;
 
         priv = container_of(port, struct eg20t_port, port);
-        spin_lock_irqsave(&priv->lock, flags);
+        spin_lock_irqsave(&port->lock, flags);
         pch_uart_hal_set_break(priv, ctl);
-        spin_unlock_irqrestore(&priv->lock, flags);
+        spin_unlock_irqrestore(&port->lock, flags);
 }
 
 /* Grab any interrupt resources and initialise any low level driver state. */
@@ -1255,9 +1141,9 @@ static int pch_uart_startup(struct uart_port *port)
         priv->tx_empty = 1;
 
         if (port->uartclk)
-                priv->uartclk = port->uartclk;
+                priv->base_baud = port->uartclk;
         else
-                port->uartclk = priv->uartclk;
+                port->uartclk = priv->base_baud;
 
         pch_uart_hal_disable_interrupt(priv, PCH_UART_HAL_ALL_INT);
         ret = pch_uart_hal_set_line(priv, default_baud,
@@ -1275,7 +1161,6 @@ static int pch_uart_startup(struct uart_port *port)
                 break;
         case 16:
                 fifo_size = PCH_UART_HAL_FIFO16;
-                break;
         case 1:
         default:
                 fifo_size = PCH_UART_HAL_FIFO_DIS;
@@ -1313,8 +1198,7 @@ static int pch_uart_startup(struct uart_port *port)
                 pch_request_dma(port);
 
         priv->start_rx = 1;
-        pch_uart_hal_enable_interrupt(priv, PCH_UART_HAL_RX_INT |
-                                            PCH_UART_HAL_RX_ERR_INT);
+        pch_uart_hal_enable_interrupt(priv, PCH_UART_HAL_RX_INT);
         uart_update_timeout(port, CS8, default_baud);
 
         return 0;
@@ -1372,13 +1256,14 @@ static void pch_uart_set_termios(struct uart_port *port,
                 stb = PCH_UART_HAL_STB1;
 
         if (termios->c_cflag & PARENB) {
-                if (termios->c_cflag & PARODD)
+                if (!(termios->c_cflag & PARODD))
                         parity = PCH_UART_HAL_PARITY_ODD;
                 else
                         parity = PCH_UART_HAL_PARITY_EVEN;
 
-        } else
+        } else {
                 parity = PCH_UART_HAL_PARITY_NONE;
+        }
 
         /* Only UART0 has auto hardware flow function */
         if ((termios->c_cflag & CRTSCTS) && (priv->fifo_size == 256))
@@ -1390,8 +1275,7 @@ static void pch_uart_set_termios(struct uart_port *port,
 
         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk / 16);
 
-        spin_lock_irqsave(&priv->lock, flags);
-        spin_lock(&port->lock);
+        spin_lock_irqsave(&port->lock, flags);
 
         uart_update_timeout(port, termios->c_cflag, baud);
         rtn = pch_uart_hal_set_line(priv, baud, parity, bits, stb);
@@ -1404,8 +1288,7 @@ static void pch_uart_set_termios(struct uart_port *port,
                 tty_termios_encode_baud_rate(termios, baud, baud);
 
 out:
-        spin_unlock(&port->lock);
-        spin_unlock_irqrestore(&priv->lock, flags);
+        spin_unlock_irqrestore(&port->lock, flags);
 }
 
 static const char *pch_uart_type(struct uart_port *port)
@@ -1471,10 +1354,9 @@ static int pch_uart_verify_port(struct uart_port *port,
                         __func__);
                 return -EOPNOTSUPP;
 #endif
-                dev_info(priv->port.dev, "PCH UART : Use DMA Mode\n");
-                if (!priv->use_dma)
-                        pch_request_dma(port);
                 priv->use_dma = 1;
+                priv->use_dma_flag = 1;
+                dev_info(priv->port.dev, "PCH UART : Use DMA Mode\n");
         }
 
         return 0;
@@ -1501,148 +1383,6 @@ static struct uart_ops pch_uart_ops = {
         .verify_port = pch_uart_verify_port
 };
 
-#ifdef CONFIG_SERIAL_PCH_UART_CONSOLE
-
-/*
- *      Wait for transmitter & holding register to empty
- */
-static void wait_for_xmitr(struct eg20t_port *up, int bits)
-{
-        unsigned int status, tmout = 10000;
-
-        /* Wait up to 10ms for the character(s) to be sent. */
-        for (;;) {
-                status = ioread8(up->membase + UART_LSR);
-
-                if ((status & bits) == bits)
-                        break;
-                if (--tmout == 0)
-                        break;
-                udelay(1);
-        }
-
-        /* Wait up to 1s for flow control if necessary */
-        if (up->port.flags & UPF_CONS_FLOW) {
-                unsigned int tmout;
-                for (tmout = 1000000; tmout; tmout--) {
-                        unsigned int msr = ioread8(up->membase + UART_MSR);
-                        if (msr & UART_MSR_CTS)
-                                break;
-                        udelay(1);
-                        touch_nmi_watchdog();
-                }
-        }
-}
-
-static void pch_console_putchar(struct uart_port *port, int ch)
-{
-        struct eg20t_port *priv =
-                container_of(port, struct eg20t_port, port);
-
-        wait_for_xmitr(priv, UART_LSR_THRE);
-        iowrite8(ch, priv->membase + PCH_UART_THR);
-}
-
-/*
- *      Print a string to the serial port trying not to disturb
- *      any possible real use of the port...
- *
- *      The console_lock must be held when we get here.
- */
-static void
-pch_console_write(struct console *co, const char *s, unsigned int count)
-{
-        struct eg20t_port *priv;
-        unsigned long flags;
-        int priv_locked = 1;
-        int port_locked = 1;
-        u8 ier;
-
-        priv = pch_uart_ports[co->index];
-
-        touch_nmi_watchdog();
-
-        local_irq_save(flags);
-        if (priv->port.sysrq) {
-                spin_lock(&priv->lock);
-                /* serial8250_handle_port() already took the port lock */
-                port_locked = 0;
-        } else if (oops_in_progress) {
-                priv_locked = spin_trylock(&priv->lock);
-                port_locked = spin_trylock(&priv->port.lock);
-        } else {
-                spin_lock(&priv->lock);
-                spin_lock(&priv->port.lock);
-        }
-
-        /*
-         *      First save the IER then disable the interrupts
-         */
-        ier = ioread8(priv->membase + UART_IER);
-
-        pch_uart_hal_disable_interrupt(priv, PCH_UART_HAL_ALL_INT);
-
-        uart_console_write(&priv->port, s, count, pch_console_putchar);
-
-        /*
-         *      Finally, wait for transmitter to become empty
-         *      and restore the IER
-         */
-        wait_for_xmitr(priv, BOTH_EMPTY);
-        iowrite8(ier, priv->membase + UART_IER);
-
-        if (port_locked)
-                spin_unlock(&priv->port.lock);
-        if (priv_locked)
-                spin_unlock(&priv->lock);
-        local_irq_restore(flags);
-}
-
-static int __init pch_console_setup(struct console *co, char *options)
-{
-        struct uart_port *port;
-        int baud = default_baud;
-        int bits = 8;
-        int parity = 'n';
-        int flow = 'n';
-
-        /*
-         * Check whether an invalid uart number has been specified, and
-         * if so, search for the first available port that does have
-         * console support.
-         */
-        if (co->index >= PCH_UART_NR)
-                co->index = 0;
-        port = &pch_uart_ports[co->index]->port;
-
-        if (!port || (!port->iobase && !port->membase))
-                return -ENODEV;
-
-        port->uartclk = pch_uart_get_uartclk();
-
-        if (options)
-                uart_parse_options(options, &baud, &parity, &bits, &flow);
-
-        return uart_set_options(port, co, baud, parity, bits, flow);
-}
-
-static struct uart_driver pch_uart_driver;
-
-static struct console pch_console = {
-        .name           = PCH_UART_DRIVER_DEVICE,
-        .write          = pch_console_write,
-        .device         = uart_console_device,
-        .setup          = pch_console_setup,
-        .flags          = CON_PRINTBUFFER | CON_ANYTIME,
-        .index          = -1,
-        .data           = &pch_uart_driver,
-};
-
-#define PCH_CONSOLE     (&pch_console)
-#else
-#define PCH_CONSOLE     NULL
-#endif
-
 static struct uart_driver pch_uart_driver = {
         .owner = THIS_MODULE,
         .driver_name = KBUILD_MODNAME,
@@ -1650,7 +1390,6 @@ static struct uart_driver pch_uart_driver = {
         .major = 0,
         .minor = 0,
         .nr = PCH_UART_NR,
-        .cons = PCH_CONSOLE,
 };
 
 static struct eg20t_port *pch_uart_init_port(struct pci_dev *pdev,
@@ -1661,10 +1400,10 @@ static struct eg20t_port *pch_uart_init_port(struct pci_dev *pdev,
         unsigned int iobase;
         unsigned int mapbase;
         unsigned char *rxbuf;
-        int fifosize;
+        int fifosize, base_baud;
         int port_type;
         struct pch_uart_driver_data *board;
-        char name[32];  /* for debugfs file name */
+        const char *board_name;
 
         board = &drv_dat[id->driver_data];
         port_type = board->port_type;
@@ -1677,6 +1416,13 @@ static struct eg20t_port *pch_uart_init_port(struct pci_dev *pdev,
         if (!rxbuf)
                 goto init_port_free_txbuf;
 
+        base_baud = 1843200; /* 1.8432MHz */
+
+        /* quirk for CM-iTC board */
+        board_name = dmi_get_system_info(DMI_BOARD_NAME);
+        if (board_name && strstr(board_name, "CM-iTC"))
+                base_baud = 192000000; /* 192.0MHz */
+
         switch (port_type) {
         case PORT_UNKNOWN:
                 fifosize = 256; /* EG20T/ML7213: UART0 */
@@ -1690,9 +1436,6 @@ static struct eg20t_port *pch_uart_init_port(struct pci_dev *pdev,
         }
 
         pci_enable_msi(pdev);
-        pci_set_master(pdev);
-
-        spin_lock_init(&priv->lock);
 
         iobase = pci_resource_start(pdev, 0);
         mapbase = pci_resource_start(pdev, 1);
@@ -1704,7 +1447,7 @@ static struct eg20t_port *pch_uart_init_port(struct pci_dev *pdev,
         priv->rxbuf.size = PAGE_SIZE;
 
         priv->fifo_size = fifosize;
-        priv->uartclk = pch_uart_get_uartclk();
+        priv->base_baud = base_baud;
         priv->port_type = PORT_MAX_8250 + port_type + 1;
         priv->port.dev = &pdev->dev;
         priv->port.iobase = iobase;
@@ -1721,28 +1464,15 @@ static struct eg20t_port *pch_uart_init_port(struct pci_dev *pdev,
         spin_lock_init(&priv->port.lock);
 
         pci_set_drvdata(pdev, priv);
-        priv->trigger_level = 1;
-        priv->fcr = 0;
+        pch_uart_hal_request(pdev, fifosize, base_baud);
 
-#ifdef CONFIG_SERIAL_PCH_UART_CONSOLE
-        pch_uart_ports[board->line_no] = priv;
-#endif
         ret = uart_add_one_port(&pch_uart_driver, &priv->port);
         if (ret < 0)
                 goto init_port_hal_free;
 
-#ifdef CONFIG_DEBUG_FS
-        snprintf(name, sizeof(name), "uart%d_regs", board->line_no);
-        priv->debugfs = debugfs_create_file(name, S_IFREG | S_IRUGO,
-                                NULL, priv, &port_regs_ops);
-#endif
-
         return priv;
 
 init_port_hal_free:
-#ifdef CONFIG_SERIAL_PCH_UART_CONSOLE
-        pch_uart_ports[board->line_no] = NULL;
-#endif
         free_page((unsigned long)rxbuf);
 init_port_free_txbuf:
         kfree(priv);
@@ -1753,11 +1483,6 @@ init_port_alloc_err:
 
 static void pch_uart_exit_port(struct eg20t_port *priv)
 {
-
-#ifdef CONFIG_DEBUG_FS
-        if (priv->debugfs)
-                debugfs_remove(priv->debugfs);
-#endif
         uart_remove_one_port(&pch_uart_driver, &priv->port);
         pci_set_drvdata(priv->pdev, NULL);
         free_page((unsigned long)priv->rxbuf.buf);
@@ -1765,13 +1490,11 @@ static void pch_uart_exit_port(struct eg20t_port *priv)
 
 static void pch_uart_pci_remove(struct pci_dev *pdev)
 {
-        struct eg20t_port *priv = pci_get_drvdata(pdev);
+        struct eg20t_port *priv;
 
-        pci_disable_msi(pdev);
+        priv = (struct eg20t_port *)pci_get_drvdata(pdev);
 
-#ifdef CONFIG_SERIAL_PCH_UART_CONSOLE
-        pch_uart_ports[priv->port.line] = NULL;
-#endif
+        pci_disable_msi(pdev);
         pch_uart_exit_port(priv);
         pci_disable_device(pdev);
         kfree(priv);
@@ -1839,7 +1562,7 @@ static DEFINE_PCI_DEVICE_TABLE(pch_uart_pci_id) = {
         {0,},
 };
 
-static int pch_uart_pci_probe(struct pci_dev *pdev,
+static int __devinit pch_uart_pci_probe(struct pci_dev *pdev,
                                         const struct pci_device_id *id)
 {
         int ret;
@@ -1869,7 +1592,7 @@ static struct pci_driver pch_uart_pci_driver = {
         .name = "pch_uart",
         .id_table = pch_uart_pci_id,
         .probe = pch_uart_pci_probe,
-        .remove = pch_uart_pci_remove,
+        .remove = __devexit_p(pch_uart_pci_remove),
         .suspend = pch_uart_pci_suspend,
         .resume = pch_uart_pci_resume,
 };
@@ -1902,8 +1625,3 @@ module_exit(pch_uart_module_exit);
 MODULE_LICENSE("GPL v2");
 MODULE_DESCRIPTION("Intel EG20T PCH UART PCI Driver");
 module_param(default_baud, uint, S_IRUGO);
-MODULE_PARM_DESC(default_baud,
-                 "Default BAUD for initial driver state and console (default 9600)");
-module_param(user_uartclk, uint, S_IRUGO);
-MODULE_PARM_DESC(user_uartclk,
-                 "Override UART default or board specific UART clock");