Merge branch 'devel-stable' into for-next

8 files changed, 71 insertions, 26 deletions

diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
index 9bed1a2a67a1..605b016bcea4 100644
--- a/drivers/dma/Kconfig
+++ b/drivers/dma/Kconfig
@@ -346,6 +346,7 @@ config MOXART_DMA
         tristate "MOXART DMA support"
         depends on ARCH_MOXART
         select DMA_ENGINE
+        select DMA_OF
         select DMA_VIRTUAL_CHANNELS
         help
           Enable support for the MOXA ART SoC DMA controller.
diff --git a/drivers/dma/imx-sdma.c b/drivers/dma/imx-sdma.c
index 4e7918339b12..19041cefabb1 100644
--- a/drivers/dma/imx-sdma.c
+++ b/drivers/dma/imx-sdma.c
@@ -449,6 +449,7 @@ static const struct of_device_id sdma_dt_ids[] = {
         { .compatible = "fsl,imx51-sdma", .data = &sdma_imx51, },
         { .compatible = "fsl,imx35-sdma", .data = &sdma_imx35, },
         { .compatible = "fsl,imx31-sdma", .data = &sdma_imx31, },
+        { .compatible = "fsl,imx25-sdma", .data = &sdma_imx25, },
         { /* sentinel */ }
 };
 MODULE_DEVICE_TABLE(of, sdma_dt_ids);
diff --git a/drivers/dma/ioat/dma.c b/drivers/dma/ioat/dma.c
index 87529181efcc..4e3549a16132 100644
--- a/drivers/dma/ioat/dma.c
+++ b/drivers/dma/ioat/dma.c
@@ -77,7 +77,8 @@ static irqreturn_t ioat_dma_do_interrupt(int irq, void *data)
         attnstatus = readl(instance->reg_base + IOAT_ATTNSTATUS_OFFSET);
         for_each_set_bit(bit, &attnstatus, BITS_PER_LONG) {
                 chan = ioat_chan_by_index(instance, bit);
-                tasklet_schedule(&chan->cleanup_task);
+                if (test_bit(IOAT_RUN, &chan->state))
+                        tasklet_schedule(&chan->cleanup_task);
         }
 
         writeb(intrctrl, instance->reg_base + IOAT_INTRCTRL_OFFSET);
@@ -93,7 +94,8 @@ static irqreturn_t ioat_dma_do_interrupt_msix(int irq, void *data)
 {
         struct ioat_chan_common *chan = data;
 
-        tasklet_schedule(&chan->cleanup_task);
+        if (test_bit(IOAT_RUN, &chan->state))
+                tasklet_schedule(&chan->cleanup_task);
 
         return IRQ_HANDLED;
 }
@@ -116,7 +118,6 @@ void ioat_init_channel(struct ioatdma_device *device, struct ioat_chan_common *c
         chan->timer.function = device->timer_fn;
         chan->timer.data = data;
         tasklet_init(&chan->cleanup_task, device->cleanup_fn, data);
-        tasklet_disable(&chan->cleanup_task);
 }
 
 /**
@@ -354,13 +355,49 @@ static int ioat1_dma_alloc_chan_resources(struct dma_chan *c)
         writel(((u64) chan->completion_dma) >> 32,
                chan->reg_base + IOAT_CHANCMP_OFFSET_HIGH);
 
-        tasklet_enable(&chan->cleanup_task);
+        set_bit(IOAT_RUN, &chan->state);
         ioat1_dma_start_null_desc(ioat);  /* give chain to dma device */
         dev_dbg(to_dev(chan), "%s: allocated %d descriptors\n",
                 __func__, ioat->desccount);
         return ioat->desccount;
 }
 
+void ioat_stop(struct ioat_chan_common *chan)
+{
+        struct ioatdma_device *device = chan->device;
+        struct pci_dev *pdev = device->pdev;
+        int chan_id = chan_num(chan);
+        struct msix_entry *msix;
+
+        /* 1/ stop irq from firing tasklets
+         * 2/ stop the tasklet from re-arming irqs
+         */
+        clear_bit(IOAT_RUN, &chan->state);
+
+        /* flush inflight interrupts */
+        switch (device->irq_mode) {
+        case IOAT_MSIX:
+                msix = &device->msix_entries[chan_id];
+                synchronize_irq(msix->vector);
+                break;
+        case IOAT_MSI:
+        case IOAT_INTX:
+                synchronize_irq(pdev->irq);
+                break;
+        default:
+                break;
+        }
+
+        /* flush inflight timers */
+        del_timer_sync(&chan->timer);
+
+        /* flush inflight tasklet runs */
+        tasklet_kill(&chan->cleanup_task);
+
+        /* final cleanup now that everything is quiesced and can't re-arm */
+        device->cleanup_fn((unsigned long) &chan->common);
+}
+
 /**
  * ioat1_dma_free_chan_resources - release all the descriptors
  * @chan: the channel to be cleaned
@@ -379,9 +416,7 @@ static void ioat1_dma_free_chan_resources(struct dma_chan *c)
         if (ioat->desccount == 0)
                 return;
 
-        tasklet_disable(&chan->cleanup_task);
-        del_timer_sync(&chan->timer);
-        ioat1_cleanup(ioat);
+        ioat_stop(chan);
 
         /* Delay 100ms after reset to allow internal DMA logic to quiesce
          * before removing DMA descriptor resources.
@@ -526,8 +561,11 @@ ioat1_dma_prep_memcpy(struct dma_chan *c, dma_addr_t dma_dest,
 static void ioat1_cleanup_event(unsigned long data)
 {
         struct ioat_dma_chan *ioat = to_ioat_chan((void *) data);
+        struct ioat_chan_common *chan = &ioat->base;
 
         ioat1_cleanup(ioat);
+        if (!test_bit(IOAT_RUN, &chan->state))
+                return;
         writew(IOAT_CHANCTRL_RUN, ioat->base.reg_base + IOAT_CHANCTRL_OFFSET);
 }
 
diff --git a/drivers/dma/ioat/dma.h b/drivers/dma/ioat/dma.h
index 11fb877ddca9..e982f00a9843 100644
--- a/drivers/dma/ioat/dma.h
+++ b/drivers/dma/ioat/dma.h
@@ -356,6 +356,7 @@ bool ioat_cleanup_preamble(struct ioat_chan_common *chan,
 void ioat_kobject_add(struct ioatdma_device *device, struct kobj_type *type);
 void ioat_kobject_del(struct ioatdma_device *device);
 int ioat_dma_setup_interrupts(struct ioatdma_device *device);
+void ioat_stop(struct ioat_chan_common *chan);
 extern const struct sysfs_ops ioat_sysfs_ops;
 extern struct ioat_sysfs_entry ioat_version_attr;
 extern struct ioat_sysfs_entry ioat_cap_attr;
diff --git a/drivers/dma/ioat/dma_v2.c b/drivers/dma/ioat/dma_v2.c
index 5d3affe7e976..8d1058085eeb 100644
--- a/drivers/dma/ioat/dma_v2.c
+++ b/drivers/dma/ioat/dma_v2.c
@@ -190,8 +190,11 @@ static void ioat2_cleanup(struct ioat2_dma_chan *ioat)
 void ioat2_cleanup_event(unsigned long data)
 {
         struct ioat2_dma_chan *ioat = to_ioat2_chan((void *) data);
+        struct ioat_chan_common *chan = &ioat->base;
 
         ioat2_cleanup(ioat);
+        if (!test_bit(IOAT_RUN, &chan->state))
+                return;
         writew(IOAT_CHANCTRL_RUN, ioat->base.reg_base + IOAT_CHANCTRL_OFFSET);
 }
 
@@ -553,10 +556,10 @@ int ioat2_alloc_chan_resources(struct dma_chan *c)
         ioat->issued = 0;
         ioat->tail = 0;
         ioat->alloc_order = order;
+        set_bit(IOAT_RUN, &chan->state);
         spin_unlock_bh(&ioat->prep_lock);
         spin_unlock_bh(&chan->cleanup_lock);
 
-        tasklet_enable(&chan->cleanup_task);
         ioat2_start_null_desc(ioat);
 
         /* check that we got off the ground */
@@ -566,7 +569,6 @@ int ioat2_alloc_chan_resources(struct dma_chan *c)
         } while (i++ < 20 && !is_ioat_active(status) && !is_ioat_idle(status));
 
         if (is_ioat_active(status) || is_ioat_idle(status)) {
-                set_bit(IOAT_RUN, &chan->state);
                 return 1 << ioat->alloc_order;
         } else {
                 u32 chanerr = readl(chan->reg_base + IOAT_CHANERR_OFFSET);
@@ -809,11 +811,8 @@ void ioat2_free_chan_resources(struct dma_chan *c)
         if (!ioat->ring)
                 return;
 
-        tasklet_disable(&chan->cleanup_task);
-        del_timer_sync(&chan->timer);
-        device->cleanup_fn((unsigned long) c);
+        ioat_stop(chan);
         device->reset_hw(chan);
-        clear_bit(IOAT_RUN, &chan->state);
 
         spin_lock_bh(&chan->cleanup_lock);
         spin_lock_bh(&ioat->prep_lock);
diff --git a/drivers/dma/ioat/dma_v3.c b/drivers/dma/ioat/dma_v3.c
index 820817e97e62..b9b38a1cf92f 100644
--- a/drivers/dma/ioat/dma_v3.c
+++ b/drivers/dma/ioat/dma_v3.c
@@ -464,8 +464,11 @@ static void ioat3_cleanup(struct ioat2_dma_chan *ioat)
 static void ioat3_cleanup_event(unsigned long data)
 {
         struct ioat2_dma_chan *ioat = to_ioat2_chan((void *) data);
+        struct ioat_chan_common *chan = &ioat->base;
 
         ioat3_cleanup(ioat);
+        if (!test_bit(IOAT_RUN, &chan->state))
+                return;
         writew(IOAT_CHANCTRL_RUN, ioat->base.reg_base + IOAT_CHANCTRL_OFFSET);
 }
 
diff --git a/drivers/dma/mv_xor.c b/drivers/dma/mv_xor.c
index 53fb0c8365b0..766b68ed505c 100644
--- a/drivers/dma/mv_xor.c
+++ b/drivers/dma/mv_xor.c
@@ -497,8 +497,8 @@ mv_xor_tx_submit(struct dma_async_tx_descriptor *tx)
                 if (!mv_can_chain(grp_start))
                         goto submit_done;
 
-                dev_dbg(mv_chan_to_devp(mv_chan), "Append to last desc %x\n",
-                        old_chain_tail->async_tx.phys);
+                dev_dbg(mv_chan_to_devp(mv_chan), "Append to last desc %pa\n",
+                        &old_chain_tail->async_tx.phys);
 
                 /* fix up the hardware chain */
                 mv_desc_set_next_desc(old_chain_tail, grp_start->async_tx.phys);
@@ -527,7 +527,8 @@ submit_done:
 /* returns the number of allocated descriptors */
 static int mv_xor_alloc_chan_resources(struct dma_chan *chan)
 {
-        char *hw_desc;
+        void *virt_desc;
+        dma_addr_t dma_desc;
         int idx;
         struct mv_xor_chan *mv_chan = to_mv_xor_chan(chan);
         struct mv_xor_desc_slot *slot = NULL;
@@ -542,17 +543,16 @@ static int mv_xor_alloc_chan_resources(struct dma_chan *chan)
                                 " %d descriptor slots", idx);
                         break;
                 }
-                hw_desc = (char *) mv_chan->dma_desc_pool_virt;
-                slot->hw_desc = (void *) &hw_desc[idx * MV_XOR_SLOT_SIZE];
+                virt_desc = mv_chan->dma_desc_pool_virt;
+                slot->hw_desc = virt_desc + idx * MV_XOR_SLOT_SIZE;
 
                 dma_async_tx_descriptor_init(&slot->async_tx, chan);
                 slot->async_tx.tx_submit = mv_xor_tx_submit;
                 INIT_LIST_HEAD(&slot->chain_node);
                 INIT_LIST_HEAD(&slot->slot_node);
                 INIT_LIST_HEAD(&slot->tx_list);
-                hw_desc = (char *) mv_chan->dma_desc_pool;
-                slot->async_tx.phys =
-                        (dma_addr_t) &hw_desc[idx * MV_XOR_SLOT_SIZE];
+                dma_desc = mv_chan->dma_desc_pool;
+                slot->async_tx.phys = dma_desc + idx * MV_XOR_SLOT_SIZE;
                 slot->idx = idx++;
 
                 spin_lock_bh(&mv_chan->lock);
@@ -582,8 +582,8 @@ mv_xor_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
         int slot_cnt;
 
         dev_dbg(mv_chan_to_devp(mv_chan),
-                "%s dest: %x src %x len: %u flags: %ld\n",
-                __func__, dest, src, len, flags);
+                "%s dest: %pad src %pad len: %u flags: %ld\n",
+                __func__, &dest, &src, len, flags);
         if (unlikely(len < MV_XOR_MIN_BYTE_COUNT))
                 return NULL;
 
@@ -626,8 +626,8 @@ mv_xor_prep_dma_xor(struct dma_chan *chan, dma_addr_t dest, dma_addr_t *src,
         BUG_ON(len > MV_XOR_MAX_BYTE_COUNT);
 
         dev_dbg(mv_chan_to_devp(mv_chan),
-                "%s src_cnt: %d len: dest %x %u flags: %ld\n",
-                __func__, src_cnt, len, dest, flags);
+                "%s src_cnt: %d len: %u dest %pad flags: %ld\n",
+                __func__, src_cnt, len, &dest, flags);
 
         spin_lock_bh(&mv_chan->lock);
         slot_cnt = mv_chan_xor_slot_count(len, src_cnt);
diff --git a/drivers/dma/ste_dma40.c b/drivers/dma/ste_dma40.c
index 00a2de957b23..bf18c786ed40 100644
--- a/drivers/dma/ste_dma40.c
+++ b/drivers/dma/ste_dma40.c
@@ -1641,6 +1641,7 @@ static void dma_tasklet(unsigned long data)
         struct d40_chan *d40c = (struct d40_chan *) data;
         struct d40_desc *d40d;
         unsigned long flags;
+        bool callback_active;
         dma_async_tx_callback callback;
         void *callback_param;
 
@@ -1668,6 +1669,7 @@ static void dma_tasklet(unsigned long data)
         }
 
         /* Callback to client */
+        callback_active = !!(d40d->txd.flags & DMA_PREP_INTERRUPT);
         callback = d40d->txd.callback;
         callback_param = d40d->txd.callback_param;
 
@@ -1690,7 +1692,7 @@ static void dma_tasklet(unsigned long data)
 
         spin_unlock_irqrestore(&d40c->lock, flags);
 
-        if (callback && (d40d->txd.flags & DMA_PREP_INTERRUPT))
+        if (callback_active && callback)
                 callback(callback_param);
 
         return;