ARM: PL011: Add support for Rx DMA buffer polling.

In DMA support, The received data is not pushed to tty until the DMA buffer
is filled. But some megabyte rate chips such as BT expect fast response and
data should be pushed immediately. In order to fix this issue, We suggest
the use of the timer for polling DMA buffer.
In our test, no data loss occurred at high-baudrate as compared with interrupt-
driven (We tested with 3Mbps).
We changes:

- We add timer for polling. If we set poll_timer to 10, every 10ms,
 timer handler checks the residue in the dma buffer and transfer data
 to the tty. Also, last_residue is updated for the next polling.

- poll_timeout is used to prevent the timer's system cost.
  If poll_timeout is set to 3000 and no data is received in 3 seconds,
  we inactivate poll timer and driver falls back to interrupt-driven.
  When data is received again in FIFO and UART irq is occurred, we switch
  back to DMA mode and start polling.

- We use consistent DMA mappings to avoid from the frequent cache operation
  of the timer function for default.

- pl011_dma_rx_chars is modified. the pending size is recalculated because
  data can be taken by polling.

- the polling time is adjusted if dma rx poll is enabled but no rate is
  specified. Ideal polling interval to push 1 character at every interval
  is the reciprocal of 'baud rate / 10 line bits per character / 1000 ms
  per sec'. But It is very aggressive to system. Experimentally,
 '10000000 / baud' is suitable to receive dozens of characters. the poll rate
 can be specified statically by dma_rx_poll_rate of the platform data as well.

Changes compared to v1:
 - Use of consistent DMA mappings.
 - Added dma_rx_poll_rate in platform data to specify the polling interval.
 - Added dma_rx_poll_timeout in platform data to specify the polling timeout.

Changes compared to v2:
 - Use of consistent DMA mappings for default.
 - Added dma_rx_poll_enable in platform data to adjust the polling time
   according to the baud rate.
 - remove unnecessary lock from the polling function.

Signed-off-by: Chanho Min <chanho.min@lge.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

2 files changed, 141 insertions, 19 deletions

diff --git a/drivers/tty/serial/amba-pl011.c b/drivers/tty/serial/amba-pl011.c
index 3ea5408fcbeb..b031abf43a7a 100644
--- a/drivers/tty/serial/amba-pl011.c
+++ b/drivers/tty/serial/amba-pl011.c
@@ -29,6 +29,7 @@
  * and hooked into this driver.
  */
 
+
 #if defined(CONFIG_SERIAL_AMBA_PL011_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
 #define SUPPORT_SYSRQ
 #endif
@@ -117,6 +118,12 @@ struct pl011_dmarx_data {
         struct pl011_sgbuf      sgbuf_b;
         dma_cookie_t            cookie;
         bool                    running;
+        struct timer_list       timer;
+        unsigned int last_residue;
+        unsigned long last_jiffies;
+        bool auto_poll_rate;
+        unsigned int poll_rate;
+        unsigned int poll_timeout;
 };
 
 struct pl011_dmatx_data {
@@ -223,16 +230,18 @@ static int pl011_fifo_to_tty(struct uart_amba_port *uap)
 static int pl011_sgbuf_init(struct dma_chan *chan, struct pl011_sgbuf *sg,
         enum dma_data_direction dir)
 {
-        sg->buf = kmalloc(PL011_DMA_BUFFER_SIZE, GFP_KERNEL);
+        dma_addr_t dma_addr;
+
+        sg->buf = dma_alloc_coherent(chan->device->dev,
+                PL011_DMA_BUFFER_SIZE, &dma_addr, GFP_KERNEL);
         if (!sg->buf)
                 return -ENOMEM;
 
-        sg_init_one(&sg->sg, sg->buf, PL011_DMA_BUFFER_SIZE);
+        sg_init_table(&sg->sg, 1);
+        sg_set_page(&sg->sg, phys_to_page(dma_addr),
+                PL011_DMA_BUFFER_SIZE, offset_in_page(dma_addr));
+        sg_dma_address(&sg->sg) = dma_addr;
 
-        if (dma_map_sg(chan->device->dev, &sg->sg, 1, dir) != 1) {
-                kfree(sg->buf);
-                return -EINVAL;
-        }
         return 0;
 }
 
@@ -240,8 +249,9 @@ static void pl011_sgbuf_free(struct dma_chan *chan, struct pl011_sgbuf *sg,
         enum dma_data_direction dir)
 {
         if (sg->buf) {
-                dma_unmap_sg(chan->device->dev, &sg->sg, 1, dir);
-                kfree(sg->buf);
+                dma_free_coherent(chan->device->dev,
+                        PL011_DMA_BUFFER_SIZE, sg->buf,
+                        sg_dma_address(&sg->sg));
         }
 }
 
@@ -300,6 +310,29 @@ static void pl011_dma_probe_initcall(struct uart_amba_port *uap)
                 dmaengine_slave_config(chan, &rx_conf);
                 uap->dmarx.chan = chan;
 
+                if (plat->dma_rx_poll_enable) {
+                        /* Set poll rate if specified. */
+                        if (plat->dma_rx_poll_rate) {
+                                uap->dmarx.auto_poll_rate = false;
+                                uap->dmarx.poll_rate = plat->dma_rx_poll_rate;
+                        } else {
+                                /*
+                                 * 100 ms defaults to poll rate if not
+                                 * specified. This will be adjusted with
+                                 * the baud rate at set_termios.
+                                 */
+                                uap->dmarx.auto_poll_rate = true;
+                                uap->dmarx.poll_rate =  100;
+                        }
+                        /* 3 secs defaults poll_timeout if not specified. */
+                        if (plat->dma_rx_poll_timeout)
+                                uap->dmarx.poll_timeout =
+                                        plat->dma_rx_poll_timeout;
+                        else
+                                uap->dmarx.poll_timeout = 3000;
+                } else
+                        uap->dmarx.auto_poll_rate = false;
+
                 dev_info(uap->port.dev, "DMA channel RX %s\n",
                          dma_chan_name(uap->dmarx.chan));
         }
@@ -701,24 +734,30 @@ static void pl011_dma_rx_chars(struct uart_amba_port *uap,
         struct tty_port *port = &uap->port.state->port;
         struct pl011_sgbuf *sgbuf = use_buf_b ?
                 &uap->dmarx.sgbuf_b : &uap->dmarx.sgbuf_a;
-        struct device *dev = uap->dmarx.chan->device->dev;
         int dma_count = 0;
         u32 fifotaken = 0; /* only used for vdbg() */
 
-        /* Pick everything from the DMA first */
+        struct pl011_dmarx_data *dmarx = &uap->dmarx;
+        int dmataken = 0;
+
+        if (uap->dmarx.poll_rate) {
+                /* The data can be taken by polling */
+                dmataken = sgbuf->sg.length - dmarx->last_residue;
+                /* Recalculate the pending size */
+                if (pending >= dmataken)
+                        pending -= dmataken;
+        }
+
+        /* Pick the remain data from the DMA */
         if (pending) {
-                /* Sync in buffer */
-                dma_sync_sg_for_cpu(dev, &sgbuf->sg, 1, DMA_FROM_DEVICE);
 
                 /*
                  * First take all chars in the DMA pipe, then look in the FIFO.
                  * Note that tty_insert_flip_buf() tries to take as many chars
                  * as it can.
                  */
-                dma_count = tty_insert_flip_string(port, sgbuf->buf, pending);
-
-                /* Return buffer to device */
-                dma_sync_sg_for_device(dev, &sgbuf->sg, 1, DMA_FROM_DEVICE);
+                dma_count = tty_insert_flip_string(port, sgbuf->buf + dmataken,
+                                pending);
 
                 uap->port.icount.rx += dma_count;
                 if (dma_count < pending)
@@ -726,6 +765,10 @@ static void pl011_dma_rx_chars(struct uart_amba_port *uap,
                                  "couldn't insert all characters (TTY is full?)\n");
         }
 
+        /* Reset the last_residue for Rx DMA poll */
+        if (uap->dmarx.poll_rate)
+                dmarx->last_residue = sgbuf->sg.length;
+
         /*
          * Only continue with trying to read the FIFO if all DMA chars have
          * been taken first.
@@ -865,6 +908,57 @@ static inline void pl011_dma_rx_stop(struct uart_amba_port *uap)
         writew(uap->dmacr, uap->port.membase + UART011_DMACR);
 }
 
+/*
+ * Timer handler for Rx DMA polling.
+ * Every polling, It checks the residue in the dma buffer and transfer
+ * data to the tty. Also, last_residue is updated for the next polling.
+ */
+static void pl011_dma_rx_poll(unsigned long args)
+{
+        struct uart_amba_port *uap = (struct uart_amba_port *)args;
+        struct tty_port *port = &uap->port.state->port;
+        struct pl011_dmarx_data *dmarx = &uap->dmarx;
+        struct dma_chan *rxchan = uap->dmarx.chan;
+        unsigned long flags = 0;