Merge branch 'llseek' of git://git.kernel.org/pub/scm/linux/kernel/git/arnd/bkl
[linux-2.6.git] / drivers / serial / mfd.c
index ed2bf6b..dc0967f 100644 (file)
@@ -3,7 +3,7 @@
  *
  * Refer pxa.c, 8250.c and some other drivers in drivers/serial/
  *
- * (C) Copyright 2009 Intel Corporation
+ * (C) Copyright 2010 Intel Corporation
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * of the License.
  */
 
-
 /* Notes:
- * 1. there should be 2 types of register access method, one for
- *    UART ports, the other for the general purpose registers
- *
- * 2. It used to have a Irda port, but was defeatured recently
- *
- * 3. Based on the info from HSU MAS, 0/1 channel are assigned to
- *    port0, 2/3 chan to port 1, 4/5 chan to port 3. Even number
- *    chan will be read, odd chan for write
- *
- * 4. HUS supports both the 64B and 16B FIFO version, but this driver
- *    will only use 64B version
- *
- * 5. In A0 stepping, UART will not support TX half empty flag, thus
- *    need add a #ifdef judgement
- *
- * 6. One more bug for A0, the loopback mode won't support AFC
- *    auto-flow control
+ * 1. DMA channel allocation: 0/1 channel are assigned to port 0,
+ *    2/3 chan to port 1, 4/5 chan to port 3. Even number chans
+ *    are used for RX, odd chans for TX
  *
- * 7. HSU has some special FCR control bits, we add it to serial_reg.h
+ * 2. In A0 stepping, UART will not support TX half empty flag
  *
- * 8. The RI/DSR/DCD/DTR are not pinned out, DCD & DSR are always asserted,
- *    only when the HW is reset the DDCD and DDSR will be triggered
+ * 3. The RI/DSR/DCD/DTR are not pinned out, DCD & DSR are always
+ *    asserted, only when the HW is reset the DDCD and DDSR will
+ *    be triggered
  */
 
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/console.h>
 #include <linux/sysrq.h>
+#include <linux/slab.h>
 #include <linux/serial_reg.h>
 #include <linux/circ_buf.h>
 #include <linux/delay.h>
@@ -75,7 +62,7 @@ struct hsu_dma_buffer {
 
 struct hsu_dma_chan {
        u32     id;
-       u32     dirt;   /* to or from device */
+       enum dma_data_direction dirt;
        struct uart_hsu_port    *uport;
        void __iomem            *reg;
        struct timer_list       rx_timer; /* only needed by RX channel */
@@ -102,8 +89,6 @@ struct uart_hsu_port {
 
 /* Top level data structure of HSU */
 struct hsu_port {
-       struct pci_device       *pdev;
-
        void __iomem    *reg;
        unsigned long   paddr;
        unsigned long   iolen;
@@ -112,23 +97,9 @@ struct hsu_port {
        struct uart_hsu_port    port[3];
        struct hsu_dma_chan     chans[10];
 
-#ifdef CONFIG_DEBUG_FS
        struct dentry *debugfs;
-#endif
 };
 
-static inline void hexdump(char *str, u8 *addr, int cnt)
-{
-       int i;
-
-       for (i = 0; i < cnt; i += 8) {
-               printk("0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x",
-                       addr[i], addr[i+1], addr[i+2], addr[i+3],
-                       addr[i+4], addr[i+5], addr[i+6], addr[i+7]);
-               printk("\n");
-       }
-}
-
 static inline unsigned int serial_in(struct uart_hsu_port *up, int offset)
 {
        unsigned int val;
@@ -257,12 +228,14 @@ static const struct file_operations port_regs_ops = {
        .owner          = THIS_MODULE,
        .open           = hsu_show_regs_open,
        .read           = port_show_regs,
+       .llseek         = default_llseek,
 };
 
 static const struct file_operations dma_regs_ops = {
        .owner          = THIS_MODULE,
        .open           = hsu_show_regs_open,
        .read           = dma_show_regs,
+       .llseek         = default_llseek,
 };
 
 static int hsu_debugfs_init(struct hsu_port *hsu)
@@ -353,9 +326,6 @@ void hsu_dma_tx(struct uart_hsu_port *up)
                                                 | (0x1 << 8)
                                                 | (0x1 << 16)
                                                 | (0x1 << 24));
-
-               WARN(chan_readl(up->txc, HSU_CH_CR) & 0x1,
-                       "TX channel has already be started!!\n");
                up->dma_tx_on = 1;
                chan_writel(up->txc, HSU_CH_CR, 0x1);
        }
@@ -367,7 +337,6 @@ void hsu_dma_tx(struct uart_hsu_port *up)
 /* The buffer is already cache coherent */
 void hsu_dma_start_rx_chan(struct hsu_dma_chan *rxc, struct hsu_dma_buffer *dbuf)
 {
-       /* Need start RX dma channel here */
        dbuf->ofs = 0;
 
        chan_writel(rxc, HSU_CH_BSR, 32);
@@ -426,35 +395,32 @@ void hsu_dma_rx(struct uart_hsu_port *up, u32 int_sts)
                return;
 
        /*
-        * first need to know how many is already transferred,
+        * First need to know how many is already transferred,
         * then check if its a timeout DMA irq, and return
         * the trail bytes out, push them up and reenable the
-        * channel, better to use 2 descriptors at the same time
+        * channel
         */
 
-       /* timeout IRQ, need wait some time, see Errata 2 */
+       /* Timeout IRQ, need wait some time, see Errata 2 */
        if (int_sts & 0xf00)
                udelay(2);
 
        /* Stop the channel */
        chan_writel(chan, HSU_CH_CR, 0x0);
 
-       /* We can use 2 ways to calc the actual transfer len */
        count = chan_readl(chan, HSU_CH_D0SAR) - dbuf->dma_addr;
-
        if (!count) {
-               /* restart the channel before we leave */
+               /* Restart the channel before we leave */
                chan_writel(chan, HSU_CH_CR, 0x3);
                return;
        }
-
        del_timer(&chan->rx_timer);
 
        dma_sync_single_for_cpu(port->dev, dbuf->dma_addr,
                        dbuf->dma_size, DMA_FROM_DEVICE);
 
        /*
-        * head will only wrap around when we recycle
+        * Head will only wrap around when we recycle
         * the DMA buffer, and when that happens, we
         * explicitly set tail to 0. So head will
         * always be greater than tail.
@@ -496,10 +462,6 @@ static void serial_hsu_stop_rx(struct uart_port *port)
        }
 }
 
-/*
- * if there is error flag, should we just reset the FIFO or keeps
- * working on it
- */
 static inline void receive_chars(struct uart_hsu_port *up, int *status)
 {
        struct tty_struct *tty = up->port.state->port.tty;
@@ -571,7 +533,6 @@ static void transmit_chars(struct uart_hsu_port *up)
 {
        struct circ_buf *xmit = &up->port.state->xmit;
        int count;
-       int i = 0; /* for debug use */
 
        if (up->port.x_char) {
                serial_out(up, UART_TX, up->port.x_char);
@@ -592,13 +553,11 @@ static void transmit_chars(struct uart_hsu_port *up)
         * into it won't clear the EMPT bit, so we may need be cautious
         * by useing a shorter buffer
         */
-       /* count = up->port.fifosize; */
        count = up->port.fifosize - 4;
 #endif
        do {
                serial_out(up, UART_TX, xmit->buf[xmit->tail]);
                xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
-               i++;
 
                up->port.icount.tx++;
                if (uart_circ_empty(xmit))
@@ -628,7 +587,7 @@ static inline void check_modem_status(struct uart_hsu_port *up)
        /* We may only get DDCD when HW init and reset */
        if (status & UART_MSR_DDCD)
                uart_handle_dcd_change(&up->port, status & UART_MSR_DCD);
-       /* will start/stop_tx accordingly */
+       /* Will start/stop_tx accordingly */
        if (status & UART_MSR_DCTS)
                uart_handle_cts_change(&up->port, status & UART_MSR_CTS);
 
@@ -647,6 +606,7 @@ static irqreturn_t port_irq(int irq, void *dev_id)
        if (unlikely(!up->running))
                return IRQ_NONE;
 
+       spin_lock_irqsave(&up->port.lock, flags);
        if (up->use_dma) {
                lsr = serial_in(up, UART_LSR);
                if (unlikely(lsr & (UART_LSR_BI | UART_LSR_PE |
@@ -655,10 +615,10 @@ static irqreturn_t port_irq(int irq, void *dev_id)
                                "Got lsr irq while using DMA, lsr = 0x%2x\n",
                                lsr);
                check_modem_status(up);
+               spin_unlock_irqrestore(&up->port.lock, flags);
                return IRQ_HANDLED;
        }
 
-       spin_lock_irqsave(&up->port.lock, flags);
        iir = serial_in(up, UART_IIR);
        if (iir & UART_IIR_NO_INT) {
                spin_unlock_irqrestore(&up->port.lock, flags);
@@ -666,9 +626,9 @@ static irqreturn_t port_irq(int irq, void *dev_id)
        }
 
        lsr = serial_in(up, UART_LSR);
-
        if (lsr & UART_LSR_DR)
                receive_chars(up, &lsr);
+       check_modem_status(up);
 
        /* lsr will be renewed during the receive_chars */
        if (lsr & UART_LSR_THRE)
@@ -701,7 +661,6 @@ static inline void dma_chan_irq(struct hsu_dma_chan *chan)
 
        /* Tx channel */
        if (chan->dirt == DMA_TO_DEVICE) {
-               /* dma for irq should be done */
                chan_writel(chan, HSU_CH_CR, 0x0);
                up->dma_tx_on = 0;
                hsu_dma_tx(up);
@@ -851,7 +810,6 @@ static int serial_hsu_startup(struct uart_port *port)
        spin_unlock_irqrestore(&up->port.lock, flags);
 
        /* DMA init */
-       /* When use DMA, TX/RX's FIFO and IRQ should be disabled */
        if (up->use_dma) {
                struct hsu_dma_buffer *dbuf;
                struct circ_buf *xmit = &port->state->xmit;
@@ -1090,11 +1048,9 @@ static int serial_hsu_request_port(struct uart_port *port)
 
 static void serial_hsu_config_port(struct uart_port *port, int flags)
 {
-#if 0
        struct uart_hsu_port *up =
                container_of(port, struct uart_hsu_port, port);
        up->port.type = PORT_MFD;
-#endif
 }
 
 static int
@@ -1264,25 +1220,38 @@ static struct uart_driver serial_hsu_reg = {
 #ifdef CONFIG_PM
 static int serial_hsu_suspend(struct pci_dev *pdev, pm_message_t state)
 {
+       void *priv = pci_get_drvdata(pdev);
        struct uart_hsu_port *up;
 
-       up = pci_get_drvdata(pdev);
-       if (!up)
-               return 0;
-
-       uart_suspend_port(&serial_hsu_reg, &up->port);
+       /* Make sure this is not the internal dma controller */
+       if (priv && (pdev->device != 0x081E)) {
+               up = priv;
+               uart_suspend_port(&serial_hsu_reg, &up->port);
+       }
 
+       pci_save_state(pdev);
+       pci_set_power_state(pdev, pci_choose_state(pdev, state));
         return 0;
 }
 
 static int serial_hsu_resume(struct pci_dev *pdev)
 {
+       void *priv = pci_get_drvdata(pdev);
        struct uart_hsu_port *up;
+       int ret;
 
-       up = pci_get_drvdata(pdev);
-       if (!up)
-               return 0;
-       uart_resume_port(&serial_hsu_reg, &up->port);
+       pci_set_power_state(pdev, PCI_D0);
+       pci_restore_state(pdev);
+
+       ret = pci_enable_device(pdev);
+       if (ret)
+               dev_warn(&pdev->dev,
+                       "HSU: can't re-enable device, try to continue\n");
+
+       if (priv && (pdev->device != 0x081E)) {
+               up = priv;
+               uart_resume_port(&serial_hsu_reg, &up->port);
+       }
        return 0;
 }
 #else
@@ -1426,7 +1395,7 @@ static void hsu_global_init(void)
                uport->port.ops = &serial_hsu_pops;
                uport->port.line = i;
                uport->port.flags = UPF_IOREMAP;
-               /* make the maxim support rate to 2746800 bps */
+               /* set the scalable maxim support rate to 2746800 bps */
                uport->port.uartclk = 115200 * 24 * 16;
 
                uport->running = 0;
@@ -1457,7 +1426,6 @@ static void hsu_global_init(void)
        }
 
        phsu = hsu;
-
        hsu_debugfs_init(hsu);
        return;
 
@@ -1469,18 +1437,20 @@ err_free_region:
 
 static void serial_hsu_remove(struct pci_dev *pdev)
 {
-       struct hsu_port *hsu;
-       int i;
+       void *priv = pci_get_drvdata(pdev);
+       struct uart_hsu_port *up;
 
-       hsu = pci_get_drvdata(pdev);
-       if (!hsu)
+       if (!priv)
                return;
 
-       for (i = 0; i < 3; i++)
-               uart_remove_one_port(&serial_hsu_reg, &hsu->port[i].port);
+       /* For port 0/1/2, priv is the address of uart_hsu_port */
+       if (pdev->device != 0x081E) {
+               up = priv;
+               uart_remove_one_port(&serial_hsu_reg, &up->port);
+       }
 
        pci_set_drvdata(pdev, NULL);
-       free_irq(hsu->irq, hsu);
+       free_irq(pdev->irq, priv);
        pci_disable_device(pdev);
 }