1 files changed, 191 insertions, 72 deletions

diff --git a/drivers/dma/coh901318.c b/drivers/dma/coh901318.c
index 1656fdcdb6c2..a724e6be1b4d 100644
--- a/drivers/dma/coh901318.c
+++ b/drivers/dma/coh901318.c
@@ -37,7 +37,7 @@ struct coh901318_desc {
         struct list_head node;
         struct scatterlist *sg;
         unsigned int sg_len;
-        struct coh901318_lli *data;
+        struct coh901318_lli *lli;
         enum dma_data_direction dir;
         unsigned long flags;
 };
@@ -283,7 +283,7 @@ static int coh901318_start(struct coh901318_chan *cohc)
 }
 
 static int coh901318_prep_linked_list(struct coh901318_chan *cohc,
-                                      struct coh901318_lli *data)
+                                      struct coh901318_lli *lli)
 {
         int channel = cohc->id;
         void __iomem *virtbase = cohc->base->virtbase;
@@ -292,18 +292,18 @@ static int coh901318_prep_linked_list(struct coh901318_chan *cohc,
                      COH901318_CX_STAT_SPACING*channel) &
                COH901318_CX_STAT_ACTIVE);
 
-        writel(data->src_addr,
+        writel(lli->src_addr,
                virtbase + COH901318_CX_SRC_ADDR +
                COH901318_CX_SRC_ADDR_SPACING * channel);
 
-        writel(data->dst_addr, virtbase +
+        writel(lli->dst_addr, virtbase +
                COH901318_CX_DST_ADDR +
                COH901318_CX_DST_ADDR_SPACING * channel);
 
-        writel(data->link_addr, virtbase + COH901318_CX_LNK_ADDR +
+        writel(lli->link_addr, virtbase + COH901318_CX_LNK_ADDR +
                COH901318_CX_LNK_ADDR_SPACING * channel);
 
-        writel(data->control, virtbase + COH901318_CX_CTRL +
+        writel(lli->control, virtbase + COH901318_CX_CTRL +
                COH901318_CX_CTRL_SPACING * channel);
 
         return 0;
@@ -408,33 +408,107 @@ coh901318_first_queued(struct coh901318_chan *cohc)
         return d;
 }
 
+static inline u32 coh901318_get_bytes_in_lli(struct coh901318_lli *in_lli)
+{
+        struct coh901318_lli *lli = in_lli;
+        u32 bytes = 0;
+
+        while (lli) {
+                bytes += lli->control & COH901318_CX_CTRL_TC_VALUE_MASK;
+                lli = lli->virt_link_addr;
+        }
+        return bytes;
+}
+
 /*
- * DMA start/stop controls
+ * Get the number of bytes left to transfer on this channel,
+ * it is unwise to call this before stopping the channel for
+ * absolute measures, but for a rough guess you can still call
+ * it.
  */
-u32 coh901318_get_bytes_left(struct dma_chan *chan)
+static u32 coh901318_get_bytes_left(struct dma_chan *chan)
 {
-        unsigned long flags;
-        u32 ret;
         struct coh901318_chan *cohc = to_coh901318_chan(chan);
+        struct coh901318_desc *cohd;
+        struct list_head *pos;
+        unsigned long flags;
+        u32 left = 0;
+        int i = 0;
 
         spin_lock_irqsave(&cohc->lock, flags);
 
-        /* Read transfer count value */
-        ret = readl(cohc->base->virtbase +
-                    COH901318_CX_CTRL+COH901318_CX_CTRL_SPACING *
-                    cohc->id) & COH901318_CX_CTRL_TC_VALUE_MASK;
+        /*
+         * If there are many queued jobs, we iterate and add the
+         * size of them all. We take a special look on the first
+         * job though, since it is probably active.
+         */
+        list_for_each(pos, &cohc->active) {
+                /*
+                 * The first job in the list will be working on the
+                 * hardware. The job can be stopped but still active,
+                 * so that the transfer counter is somewhere inside
+                 * the buffer.
+                 */
+                cohd = list_entry(pos, struct coh901318_desc, node);
+
+                if (i == 0) {
+                        struct coh901318_lli *lli;
+                        dma_addr_t ladd;
+
+                        /* Read current transfer count value */
+                        left = readl(cohc->base->virtbase +
+                                     COH901318_CX_CTRL +
+                                     COH901318_CX_CTRL_SPACING * cohc->id) &
+                                COH901318_CX_CTRL_TC_VALUE_MASK;
+
+                        /* See if the transfer is linked... */
+                        ladd = readl(cohc->base->virtbase +
+                                     COH901318_CX_LNK_ADDR +
+                                     COH901318_CX_LNK_ADDR_SPACING *
+                                     cohc->id) &
+                                ~COH901318_CX_LNK_LINK_IMMEDIATE;
+                        /* Single transaction */
+                        if (!ladd)
+                                continue;
+
+                        /*
+                         * Linked transaction, follow the lli, find the
+                         * currently processing lli, and proceed to the next
+                         */
+                        lli = cohd->lli;
+                        while (lli && lli->link_addr != ladd)
+                                lli = lli->virt_link_addr;
+
+                        if (lli)
+                                lli = lli->virt_link_addr;
+
+                        /*
+                         * Follow remaining lli links around to count the total
+                         * number of bytes left
+                         */
+                        left += coh901318_get_bytes_in_lli(lli);
+                } else {
+                        left += coh901318_get_bytes_in_lli(cohd->lli);
+                }
+                i++;
+        }
+
+        /* Also count bytes in the queued jobs */
+        list_for_each(pos, &cohc->queue) {
+                cohd = list_entry(pos, struct coh901318_desc, node);
+                left += coh901318_get_bytes_in_lli(cohd->lli);
+        }
 
         spin_unlock_irqrestore(&cohc->lock, flags);
 
-        return ret;
+        return left;
 }
-EXPORT_SYMBOL(coh901318_get_bytes_left);
-
 
-/* Stops a transfer without losing data. Enables power save.
-   Use this function in conjunction with coh901318_continue(..)
-*/
-void coh901318_stop(struct dma_chan *chan)
+/*
+ * Pauses a transfer without losing data. Enables power save.
+ * Use this function in conjunction with coh901318_resume.
+ */
+static void coh901318_pause(struct dma_chan *chan)
 {
         u32 val;
         unsigned long flags;
@@ -475,12 +549,11 @@ void coh901318_stop(struct dma_chan *chan)
 
         spin_unlock_irqrestore(&cohc->lock, flags);
 }
-EXPORT_SYMBOL(coh901318_stop);
 
-/* Continues a transfer that has been stopped via 300_dma_stop(..).
+/* Resumes a transfer that has been stopped via 300_dma_stop(..).
    Power save is handled.
 */
-void coh901318_continue(struct dma_chan *chan)
+static void coh901318_resume(struct dma_chan *chan)
 {
         u32 val;
         unsigned long flags;
@@ -506,7 +579,6 @@ void coh901318_continue(struct dma_chan *chan)
 
         spin_unlock_irqrestore(&cohc->lock, flags);
 }
-EXPORT_SYMBOL(coh901318_continue);
 
 bool coh901318_filter_id(struct dma_chan *chan, void *chan_id)
 {
@@ -565,29 +637,30 @@ static int coh901318_config(struct coh901318_chan *cohc,
  */
 static struct coh901318_desc *coh901318_queue_start(struct coh901318_chan *cohc)
 {
-        struct coh901318_desc *cohd_que;
+        struct coh901318_desc *cohd;
 
-        /* start queued jobs, if any
+        /*
+         * start queued jobs, if any
          * TODO: transmit all queued jobs in one go
          */
-        cohd_que = coh901318_first_queued(cohc);
+        cohd = coh901318_first_queued(cohc);
 
-        if (cohd_que != NULL) {
+        if (cohd != NULL) {
                 /* Remove from queue */
-                coh901318_desc_remove(cohd_que);
+                coh901318_desc_remove(cohd);
                 /* initiate DMA job */
                 cohc->busy = 1;
 
-                coh901318_desc_submit(cohc, cohd_que);
+                coh901318_desc_submit(cohc, cohd);
 
-                coh901318_prep_linked_list(cohc, cohd_que->data);
+                coh901318_prep_linked_list(cohc, cohd->lli);
 
-                /* start dma job */
+                /* start dma job on this channel */
                 coh901318_start(cohc);
 
         }
 
-        return cohd_que;
+        return cohd;
 }
 
 /*
@@ -622,7 +695,7 @@ static void dma_tasklet(unsigned long data)
         cohc->completed = cohd_fin->desc.cookie;
 
         /* release the lli allocation and remove the descriptor */
-        coh901318_lli_free(&cohc->base->pool, &cohd_fin->data);
+        coh901318_lli_free(&cohc->base->pool, &cohd_fin->lli);
 
         /* return desc to free-list */
         coh901318_desc_remove(cohd_fin);
@@ -666,23 +739,44 @@ static void dma_tasklet(unsigned long data)
 /* called from interrupt context */
 static void dma_tc_handle(struct coh901318_chan *cohc)
 {
-        BUG_ON(!cohc->allocated && (list_empty(&cohc->active) ||
-                                    list_empty(&cohc->queue)));
-
-        if (!cohc->allocated)
+        /*
+         * If the channel is not allocated, then we shouldn't have
+         * any TC interrupts on it.
+         */
+        if (!cohc->allocated) {
+                dev_err(COHC_2_DEV(cohc), "spurious interrupt from "
+                        "unallocated channel\n");
                 return;
+        }
 
         spin_lock(&cohc->lock);
 
+        /*
+         * When we reach this point, at least one queue item
+         * should have been moved over from cohc->queue to
+         * cohc->active and run to completion, that is why we're
+         * getting a terminal count interrupt is it not?
+         * If you get this BUG() the most probable cause is that
+         * the individual nodes in the lli chain have IRQ enabled,
+         * so check your platform config for lli chain ctrl.
+         */
+        BUG_ON(list_empty(&cohc->active));
+
         cohc->nbr_active_done++;
 
+        /*
+         * This attempt to take a job from cohc->queue, put it
+         * into cohc->active and start it.
+         */
         if (coh901318_queue_start(cohc) == NULL)
                 cohc->busy = 0;
 
-        BUG_ON(list_empty(&cohc->active));
-
         spin_unlock(&cohc->lock);
 
+        /*
+         * This tasklet will remove items from cohc->active
+         * and thus terminates them.
+         */
         if (cohc_chan_conf(cohc)->priority_high)
                 tasklet_hi_schedule(&cohc->tasklet);
         else
@@ -809,6 +903,7 @@ static irqreturn_t dma_irq_handler(int irq, void *dev_id)
 static int coh901318_alloc_chan_resources(struct dma_chan *chan)
 {
         struct coh901318_chan   *cohc = to_coh901318_chan(chan);
+        unsigned long flags;
 
         dev_vdbg(COHC_2_DEV(cohc), "[%s] DMA channel %d\n",
                  __func__, cohc->id);
@@ -816,11 +911,15 @@ static int coh901318_alloc_chan_resources(struct dma_chan *chan)
         if (chan->client_count > 1)
                 return -EBUSY;
 
+        spin_lock_irqsave(&cohc->lock, flags);
+
         coh901318_config(cohc, NULL);
 
         cohc->allocated = 1;
         cohc->completed = chan->cookie = 1;
 
+        spin_unlock_irqrestore(&cohc->lock, flags);
+
         return 1;
 }
 
@@ -843,7 +942,7 @@ coh901318_free_chan_resources(struct dma_chan *chan)
 
         spin_unlock_irqrestore(&cohc->lock, flags);
 
-        chan->device->device_terminate_all(chan);
+        chan->device->device_control(chan, DMA_TERMINATE_ALL, 0);
 }
 
 
@@ -870,7 +969,7 @@ static struct dma_async_tx_descriptor *
 coh901318_prep_memcpy(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
                       size_t size, unsigned long flags)
 {
-        struct coh901318_lli *data;
+        struct coh901318_lli *lli;
         struct coh901318_desc *cohd;
         unsigned long flg;
         struct coh901318_chan *cohc = to_coh901318_chan(chan);
@@ -892,23 +991,23 @@ coh901318_prep_memcpy(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
         if ((lli_len << MAX_DMA_PACKET_SIZE_SHIFT) < size)
                 lli_len++;
 
-        data = coh901318_lli_alloc(&cohc->base->pool, lli_len);
+        lli = coh901318_lli_alloc(&cohc->base->pool, lli_len);
 
-        if (data == NULL)
+        if (lli == NULL)
                 goto err;
 
         ret = coh901318_lli_fill_memcpy(
-                &cohc->base->pool, data, src, size, dest,
+                &cohc->base->pool, lli, src, size, dest,
                 cohc_chan_param(cohc)->ctrl_lli_chained,
                 ctrl_last);
         if (ret)
                 goto err;
 
-        COH_DBG(coh901318_list_print(cohc, data));
+        COH_DBG(coh901318_list_print(cohc, lli));
 
         /* Pick a descriptor to handle this transfer */
         cohd = coh901318_desc_get(cohc);
-        cohd->data = data;
+        cohd->lli = lli;
         cohd->flags = flags;
         cohd->desc.tx_submit = coh901318_tx_submit;
 
@@ -926,7 +1025,7 @@ coh901318_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                         unsigned long flags)
 {
         struct coh901318_chan *cohc = to_coh901318_chan(chan);
-        struct coh901318_lli *data;
+        struct coh901318_lli *lli;
         struct coh901318_desc *cohd;
         const struct coh901318_params *params;
         struct scatterlist *sg;
@@ -999,13 +1098,13 @@ coh901318_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
         }
 
         pr_debug("Allocate %d lli:s for this transfer\n", len);
-        data = coh901318_lli_alloc(&cohc->base->pool, len);
+        lli = coh901318_lli_alloc(&cohc->base->pool, len);
 
-        if (data == NULL)
+        if (lli == NULL)
                 goto err_dma_alloc;
 
-        /* initiate allocated data list */
-        ret = coh901318_lli_fill_sg(&cohc->base->pool, data, sgl, sg_len,
+        /* initiate allocated lli list */
+        ret = coh901318_lli_fill_sg(&cohc->base->pool, lli, sgl, sg_len,
                                     cohc_dev_addr(cohc),
                                     ctrl_chained,
                                     ctrl,
@@ -1014,14 +1113,14 @@ coh901318_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
         if (ret)
                 goto err_lli_fill;
 
-        COH_DBG(coh901318_list_print(cohc, data));
+        COH_DBG(coh901318_list_print(cohc, lli));
 
         /* Pick a descriptor to handle this transfer */
         cohd = coh901318_desc_get(cohc);
         cohd->dir = direction;
         cohd->flags = flags;
         cohd->desc.tx_submit = coh901318_tx_submit;
-        cohd->data = data;
+        cohd->lli = lli;
 
         spin_unlock_irqrestore(&cohc->lock, flg);
 
@@ -1035,9 +1134,8 @@ coh901318_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
 }
 
 static enum dma_status
-coh901318_is_tx_complete(struct dma_chan *chan,
-                         dma_cookie_t cookie, dma_cookie_t *done,
-                         dma_cookie_t *used)
+coh901318_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
+                 struct dma_tx_state *txstate)
 {
         struct coh901318_chan *cohc = to_coh901318_chan(chan);
         dma_cookie_t last_used;
@@ -1049,10 +1147,10 @@ coh901318_is_tx_complete(struct dma_chan *chan,
 
         ret = dma_async_is_complete(cookie, last_complete, last_used);
 
-        if (done)
-                *done = last_complete;
-        if (used)
-                *used = last_used;
+        dma_set_tx_state(txstate, last_complete, last_used,
+                         coh901318_get_bytes_left(chan));
+        if (ret == DMA_IN_PROGRESS && cohc->stopped)
+                ret = DMA_PAUSED;
 
         return ret;
 }
@@ -1065,23 +1163,42 @@ coh901318_issue_pending(struct dma_chan *chan)
 
         spin_lock_irqsave(&cohc->lock, flags);
 
-        /* Busy means that pending jobs are already being processed */
+        /*
+         * Busy means that pending jobs are already being processed,
+         * and then there is no point in starting the queue: the
+         * terminal count interrupt on the channel will take the next
+         * job on the queue and execute it anyway.
+         */
         if (!cohc->busy)
                 coh901318_queue_start(cohc);
 
         spin_unlock_irqrestore(&cohc->lock, flags);
 }
 
-static void
-coh901318_terminate_all(struct dma_chan *chan)
+static int
+coh901318_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
+                  unsigned long arg)
 {
         unsigned long flags;
         struct coh901318_chan *cohc = to_coh901318_chan(chan);
         struct coh901318_desc *cohd;
         void __iomem *virtbase = cohc->base->virtbase;
 
-        coh901318_stop(chan);
+        if (cmd == DMA_PAUSE) {
+                coh901318_pause(chan);
+                return 0;
+        }
+
+        if (cmd == DMA_RESUME) {
+                coh901318_resume(chan);
+                return 0;
+        }
 
+        if (cmd != DMA_TERMINATE_ALL)
+                return -ENXIO;
+
+        /* The remainder of this function terminates the transfer */
+        coh901318_pause(chan);
         spin_lock_irqsave(&cohc->lock, flags);
 
         /* Clear any pending BE or TC interrupt */
@@ -1099,7 +1216,7 @@ coh901318_terminate_all(struct dma_chan *chan)
 
         while ((cohd = coh901318_first_active_get(cohc))) {
                 /* release the lli allocation*/
-                coh901318_lli_free(&cohc->base->pool, &cohd->data);
+                coh901318_lli_free(&cohc->base->pool, &cohd->lli);
 
                 /* return desc to free-list */
                 coh901318_desc_remove(cohd);
@@ -1108,7 +1225,7 @@ coh901318_terminate_all(struct dma_chan *chan)
 
         while ((cohd = coh901318_first_queued(cohc))) {
                 /* release the lli allocation*/
-                coh901318_lli_free(&cohc->base->pool, &cohd->data);
+                coh901318_lli_free(&cohc->base->pool, &cohd->lli);
 
                 /* return desc to free-list */
                 coh901318_desc_remove(cohd);
@@ -1120,6 +1237,8 @@ coh901318_terminate_all(struct dma_chan *chan)
         cohc->busy = 0;
 
         spin_unlock_irqrestore(&cohc->lock, flags);
+
+        return 0;
 }
 void coh901318_base_init(struct dma_device *dma, const int *pick_chans,
                          struct coh901318_base *base)
@@ -1235,9 +1354,9 @@ static int __init coh901318_probe(struct platform_device *pdev)
         base->dma_slave.device_alloc_chan_resources = coh901318_alloc_chan_resources;
         base->dma_slave.device_free_chan_resources = coh901318_free_chan_resources;
         base->dma_slave.device_prep_slave_sg = coh901318_prep_slave_sg;
-        base->dma_slave.device_is_tx_complete = coh901318_is_tx_complete;
+        base->dma_slave.device_tx_status = coh901318_tx_status;
         base->dma_slave.device_issue_pending = coh901318_issue_pending;
-        base->dma_slave.device_terminate_all = coh901318_terminate_all;
+        base->dma_slave.device_control = coh901318_control;
         base->dma_slave.dev = &pdev->dev;
 
         err = dma_async_device_register(&base->dma_slave);
@@ -1255,9 +1374,9 @@ static int __init coh901318_probe(struct platform_device *pdev)
         base->dma_memcpy.device_alloc_chan_resources = coh901318_alloc_chan_resources;
         base->dma_memcpy.device_free_chan_resources = coh901318_free_chan_resources;
         base->dma_memcpy.device_prep_dma_memcpy = coh901318_prep_memcpy;
-        base->dma_memcpy.device_is_tx_complete = coh901318_is_tx_complete;
+        base->dma_memcpy.device_tx_status = coh901318_tx_status;
         base->dma_memcpy.device_issue_pending = coh901318_issue_pending;
-        base->dma_memcpy.device_terminate_all = coh901318_terminate_all;
+        base->dma_memcpy.device_control = coh901318_control;
         base->dma_memcpy.dev = &pdev->dev;
         /*
          * This controller can only access address at even 32bit boundaries,