Merge branch 'topic/sh' into for-linus

1 files changed, 37 insertions, 4 deletions

diff --git a/drivers/dma/sh/rcar-dmac.c b/drivers/dma/sh/rcar-dmac.c
index dfb17926297b..0dd953884d1d 100644
--- a/drivers/dma/sh/rcar-dmac.c
+++ b/drivers/dma/sh/rcar-dmac.c
@@ -311,7 +311,7 @@ static bool rcar_dmac_chan_is_busy(struct rcar_dmac_chan *chan)
 {
         u32 chcr = rcar_dmac_chan_read(chan, RCAR_DMACHCR);
 
-        return (chcr & (RCAR_DMACHCR_DE | RCAR_DMACHCR_TE)) == RCAR_DMACHCR_DE;
+        return !!(chcr & (RCAR_DMACHCR_DE | RCAR_DMACHCR_TE));
 }
 
 static void rcar_dmac_chan_start_xfer(struct rcar_dmac_chan *chan)
@@ -510,7 +510,7 @@ static void rcar_dmac_desc_put(struct rcar_dmac_chan *chan,
 
         spin_lock_irqsave(&chan->lock, flags);
         list_splice_tail_init(&desc->chunks, &chan->desc.chunks_free);
-        list_add_tail(&desc->node, &chan->desc.free);
+        list_add(&desc->node, &chan->desc.free);
         spin_unlock_irqrestore(&chan->lock, flags);
 }
 
@@ -990,6 +990,8 @@ static void rcar_dmac_free_chan_resources(struct dma_chan *chan)
         list_splice_init(&rchan->desc.done, &list);
         list_splice_init(&rchan->desc.wait, &list);
 
+        rchan->desc.running = NULL;
+
         list_for_each_entry(desc, &list, node)
                 rcar_dmac_realloc_hwdesc(rchan, desc, 0);
 
@@ -1143,6 +1145,7 @@ static unsigned int rcar_dmac_chan_get_residue(struct rcar_dmac_chan *chan,
         struct rcar_dmac_desc *desc = chan->desc.running;
         struct rcar_dmac_xfer_chunk *running = NULL;
         struct rcar_dmac_xfer_chunk *chunk;
+        enum dma_status status;
         unsigned int residue = 0;
         unsigned int dptr = 0;
 
@@ -1150,12 +1153,38 @@ static unsigned int rcar_dmac_chan_get_residue(struct rcar_dmac_chan *chan,
                 return 0;
 
         /*
+         * If the cookie corresponds to a descriptor that has been completed
+         * there is no residue. The same check has already been performed by the
+         * caller but without holding the channel lock, so the descriptor could
+         * now be complete.
+         */
+        status = dma_cookie_status(&chan->chan, cookie, NULL);
+        if (status == DMA_COMPLETE)
+                return 0;
+
+        /*
          * If the cookie doesn't correspond to the currently running transfer
          * then the descriptor hasn't been processed yet, and the residue is
          * equal to the full descriptor size.
          */
-        if (cookie != desc->async_tx.cookie)
-                return desc->size;
+        if (cookie != desc->async_tx.cookie) {
+                list_for_each_entry(desc, &chan->desc.pending, node) {
+                        if (cookie == desc->async_tx.cookie)
+                                return desc->size;
+                }
+                list_for_each_entry(desc, &chan->desc.active, node) {
+                        if (cookie == desc->async_tx.cookie)
+                                return desc->size;
+                }
+
+                /*
+                 * No descriptor found for the cookie, there's thus no residue.
+                 * This shouldn't happen if the calling driver passes a correct
+                 * cookie value.
+                 */
+                WARN(1, "No descriptor for cookie!");
+                return 0;
+        }
 
         /*
          * In descriptor mode the descriptor running pointer is not maintained
@@ -1202,6 +1231,10 @@ static enum dma_status rcar_dmac_tx_status(struct dma_chan *chan,
         residue = rcar_dmac_chan_get_residue(rchan, cookie);
         spin_unlock_irqrestore(&rchan->lock, flags);
 
+        /* if there's no residue, the cookie is complete */
+        if (!residue)
+                return DMA_COMPLETE;
+
         dma_set_residue(txstate, residue);
 
         return status;