include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[linux-3.10.git] / drivers / dma / ioat / dma_v2.c
index 7bbbd83..b5ae56c 100644 (file)
@@ -27,6 +27,7 @@
 
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/interrupt.h>
 #include <linux/dmaengine.h>
 int ioat_ring_alloc_order = 8;
 module_param(ioat_ring_alloc_order, int, 0644);
 MODULE_PARM_DESC(ioat_ring_alloc_order,
-                "ioat2+: allocate 2^n descriptors per channel (default: n=8)");
+                "ioat2+: allocate 2^n descriptors per channel"
+                " (default: 8 max: 16)");
 static int ioat_ring_max_alloc_order = IOAT_MAX_ORDER;
 module_param(ioat_ring_max_alloc_order, int, 0644);
 MODULE_PARM_DESC(ioat_ring_max_alloc_order,
-                "ioat2+: upper limit for dynamic ring resizing (default: n=16)");
+                "ioat2+: upper limit for ring size (default: 16)");
 
 void __ioat2_issue_pending(struct ioat2_dma_chan *ioat)
 {
-       void * __iomem reg_base = ioat->base.reg_base;
+       struct ioat_chan_common *chan = &ioat->base;
 
-       ioat->pending = 0;
-       ioat->dmacount += ioat2_ring_pending(ioat);;
+       ioat->dmacount += ioat2_ring_pending(ioat);
        ioat->issued = ioat->head;
        /* make descriptor updates globally visible before notifying channel */
        wmb();
-       writew(ioat->dmacount, reg_base + IOAT_CHAN_DMACOUNT_OFFSET);
-       dev_dbg(to_dev(&ioat->base),
+       writew(ioat->dmacount, chan->reg_base + IOAT_CHAN_DMACOUNT_OFFSET);
+       dev_dbg(to_dev(chan),
                "%s: head: %#x tail: %#x issued: %#x count: %#x\n",
                __func__, ioat->head, ioat->tail, ioat->issued, ioat->dmacount);
 }
 
-void ioat2_issue_pending(struct dma_chan *chan)
+void ioat2_issue_pending(struct dma_chan *c)
 {
-       struct ioat2_dma_chan *ioat = to_ioat2_chan(chan);
+       struct ioat2_dma_chan *ioat = to_ioat2_chan(c);
 
-       spin_lock_bh(&ioat->ring_lock);
-       if (ioat->pending == 1)
+       if (ioat2_ring_pending(ioat)) {
+               spin_lock_bh(&ioat->ring_lock);
                __ioat2_issue_pending(ioat);
-       spin_unlock_bh(&ioat->ring_lock);
+               spin_unlock_bh(&ioat->ring_lock);
+       }
 }
 
 /**
  * ioat2_update_pending - log pending descriptors
  * @ioat: ioat2+ channel
  *
- * set pending to '1' unless pending is already set to '2', pending == 2
- * indicates that submission is temporarily blocked due to an in-flight
- * reset.  If we are already above the ioat_pending_level threshold then
- * just issue pending.
- *
- * called with ring_lock held
+ * Check if the number of unsubmitted descriptors has exceeded the
+ * watermark.  Called with ring_lock held
  */
 static void ioat2_update_pending(struct ioat2_dma_chan *ioat)
 {
-       if (unlikely(ioat->pending == 2))
-               return;
-       else if (ioat2_ring_pending(ioat) > ioat_pending_level)
+       if (ioat2_ring_pending(ioat) > ioat_pending_level)
                __ioat2_issue_pending(ioat);
-       else
-               ioat->pending = 1;
 }
 
 static void __ioat2_start_null_desc(struct ioat2_dma_chan *ioat)
@@ -165,7 +159,7 @@ static void __cleanup(struct ioat2_dma_chan *ioat, unsigned long phys_complete)
                        seen_current = true;
        }
        ioat->tail += i;
-       BUG_ON(!seen_current); /* no active descs have written a completion? */
+       BUG_ON(active && !seen_current); /* no active descs have written a completion? */
 
        chan->last_completion = phys_complete;
        if (ioat->head == ioat->tail) {
@@ -206,9 +200,9 @@ static void ioat2_cleanup(struct ioat2_dma_chan *ioat)
        spin_unlock_bh(&chan->cleanup_lock);
 }
 
-void ioat2_cleanup_tasklet(unsigned long data)
+void ioat2_cleanup_event(unsigned long data)
 {
-       struct ioat2_dma_chan *ioat = (void *) data;
+       struct ioat2_dma_chan *ioat = to_ioat2_chan((void *) data);
 
        ioat2_cleanup(ioat);
        writew(IOAT_CHANCTRL_RUN, ioat->base.reg_base + IOAT_CHANCTRL_OFFSET);
@@ -238,20 +232,50 @@ void __ioat2_restart_chan(struct ioat2_dma_chan *ioat)
                __ioat2_start_null_desc(ioat);
 }
 
-static void ioat2_restart_channel(struct ioat2_dma_chan *ioat)
+int ioat2_quiesce(struct ioat_chan_common *chan, unsigned long tmo)
 {
-       struct ioat_chan_common *chan = &ioat->base;
-       unsigned long phys_complete;
+       unsigned long end = jiffies + tmo;
+       int err = 0;
        u32 status;
 
        status = ioat_chansts(chan);
        if (is_ioat_active(status) || is_ioat_idle(status))
                ioat_suspend(chan);
        while (is_ioat_active(status) || is_ioat_idle(status)) {
+               if (tmo && time_after(jiffies, end)) {
+                       err = -ETIMEDOUT;
+                       break;
+               }
                status = ioat_chansts(chan);
                cpu_relax();
        }
 
+       return err;
+}
+
+int ioat2_reset_sync(struct ioat_chan_common *chan, unsigned long tmo)
+{
+       unsigned long end = jiffies + tmo;
+       int err = 0;
+
+       ioat_reset(chan);
+       while (ioat_reset_pending(chan)) {
+               if (end && time_after(jiffies, end)) {
+                       err = -ETIMEDOUT;
+                       break;
+               }
+               cpu_relax();
+       }
+
+       return err;
+}
+
+static void ioat2_restart_channel(struct ioat2_dma_chan *ioat)
+{
+       struct ioat_chan_common *chan = &ioat->base;
+       unsigned long phys_complete;
+
+       ioat2_quiesce(chan, 0);
        if (ioat_cleanup_preamble(chan, &phys_complete))
                __cleanup(ioat, phys_complete);
 
@@ -260,7 +284,7 @@ static void ioat2_restart_channel(struct ioat2_dma_chan *ioat)
 
 void ioat2_timer_event(unsigned long data)
 {
-       struct ioat2_dma_chan *ioat = (void *) data;
+       struct ioat2_dma_chan *ioat = to_ioat2_chan((void *) data);
        struct ioat_chan_common *chan = &ioat->base;
 
        spin_lock_bh(&chan->cleanup_lock);
@@ -278,6 +302,8 @@ void ioat2_timer_event(unsigned long data)
                        u32 chanerr;
 
                        chanerr = readl(chan->reg_base + IOAT_CHANERR_OFFSET);
+                       dev_err(to_dev(chan), "%s: Channel halted (%x)\n",
+                               __func__, chanerr);
                        BUG_ON(is_ioat_bug(chanerr));
                }
 
@@ -315,6 +341,19 @@ void ioat2_timer_event(unsigned long data)
        spin_unlock_bh(&chan->cleanup_lock);
 }
 
+static int ioat2_reset_hw(struct ioat_chan_common *chan)
+{
+       /* throw away whatever the channel was doing and get it initialized */
+       u32 chanerr;
+
+       ioat2_quiesce(chan, msecs_to_jiffies(100));
+
+       chanerr = readl(chan->reg_base + IOAT_CHANERR_OFFSET);
+       writel(chanerr, chan->reg_base + IOAT_CHANERR_OFFSET);
+
+       return ioat2_reset_sync(chan, msecs_to_jiffies(200));
+}
+
 /**
  * ioat2_enumerate_channels - find and initialize the device's channels
  * @device: the device to be enumerated
@@ -351,12 +390,13 @@ int ioat2_enumerate_channels(struct ioatdma_device *device)
                if (!ioat)
                        break;
 
-               ioat_init_channel(device, &ioat->base, i,
-                                 device->timer_fn,
-                                 device->cleanup_tasklet,
-                                 (unsigned long) ioat);
+               ioat_init_channel(device, &ioat->base, i);
                ioat->xfercap_log = xfercap_log;
                spin_lock_init(&ioat->ring_lock);
+               if (device->reset_hw(&ioat->base)) {
+                       i = 0;
+                       break;
+               }
        }
        dma->chancnt = i;
        return i;
@@ -397,11 +437,12 @@ static struct ioat_ring_ent *ioat2_alloc_ring_ent(struct dma_chan *chan, gfp_t f
                return NULL;
        memset(hw, 0, sizeof(*hw));
 
-       desc = kzalloc(sizeof(*desc), flags);
+       desc = kmem_cache_alloc(ioat2_cache, flags);
        if (!desc) {
                pci_pool_free(dma->dma_pool, hw, phys);
                return NULL;
        }
+       memset(desc, 0, sizeof(*desc));
 
        dma_async_tx_descriptor_init(&desc->txd, chan);
        desc->txd.tx_submit = ioat2_tx_submit_unlock;
@@ -416,7 +457,7 @@ static void ioat2_free_ring_ent(struct ioat_ring_ent *desc, struct dma_chan *cha
 
        dma = to_ioatdma_device(chan->device);
        pci_pool_free(dma->dma_pool, desc->hw, desc->txd.phys);
-       kfree(desc);
+       kmem_cache_free(ioat2_cache, desc);
 }
 
 static struct ioat_ring_ent **ioat2_alloc_ring(struct dma_chan *c, int order, gfp_t flags)
@@ -463,7 +504,6 @@ int ioat2_alloc_chan_resources(struct dma_chan *c)
        struct ioat2_dma_chan *ioat = to_ioat2_chan(c);
        struct ioat_chan_common *chan = &ioat->base;
        struct ioat_ring_ent **ring;
-       u32 chanerr;
        int order;
 
        /* have we already been set up? */
@@ -473,12 +513,6 @@ int ioat2_alloc_chan_resources(struct dma_chan *c)
        /* Setup register to interrupt and write completion status on error */
        writew(IOAT_CHANCTRL_RUN, chan->reg_base + IOAT_CHANCTRL_OFFSET);
 
-       chanerr = readl(chan->reg_base + IOAT_CHANERR_OFFSET);
-       if (chanerr) {
-               dev_err(to_dev(chan), "CHANERR = %x, clearing\n", chanerr);
-               writel(chanerr, chan->reg_base + IOAT_CHANERR_OFFSET);
-       }
-
        /* allocate a completion writeback area */
        /* doing 2 32bit writes to mmio since 1 64b write doesn't work */
        chan->completion = pci_pool_alloc(chan->device->completion_pool,
@@ -502,7 +536,6 @@ int ioat2_alloc_chan_resources(struct dma_chan *c)
        ioat->head = 0;
        ioat->issued = 0;
        ioat->tail = 0;
-       ioat->pending = 0;
        ioat->alloc_order = order;
        spin_unlock_bh(&ioat->ring_lock);
 
@@ -657,7 +690,7 @@ int ioat2_alloc_and_lock(u16 *idx, struct ioat2_dma_chan *ioat, int num_descs)
 
                        mod_timer(&chan->timer, jiffies + COMPLETION_TIMEOUT);
                        spin_unlock_bh(&chan->cleanup_lock);
-                       device->timer_fn((unsigned long) ioat);
+                       device->timer_fn((unsigned long) &chan->common);
                } else
                        spin_unlock_bh(&chan->cleanup_lock);
                return -ENOMEM;
@@ -690,7 +723,8 @@ ioat2_dma_prep_memcpy_lock(struct dma_chan *c, dma_addr_t dma_dest,
                /* pass */;
        else
                return NULL;
-       for (i = 0; i < num_descs; i++) {
+       i = 0;
+       do {
                size_t copy = min_t(size_t, len, 1 << ioat->xfercap_log);
 
                desc = ioat2_get_ring_ent(ioat, idx + i);
@@ -705,7 +739,7 @@ ioat2_dma_prep_memcpy_lock(struct dma_chan *c, dma_addr_t dma_dest,
                dst += copy;
                src += copy;
                dump_desc_dbg(ioat, desc);
-       }
+       } while (++i < num_descs);
 
        desc->txd.flags = flags;
        desc->len = total_len;
@@ -740,14 +774,8 @@ void ioat2_free_chan_resources(struct dma_chan *c)
 
        tasklet_disable(&chan->cleanup_task);
        del_timer_sync(&chan->timer);
-       device->cleanup_tasklet((unsigned long) ioat);
-
-       /* Delay 100ms after reset to allow internal DMA logic to quiesce
-        * before removing DMA descriptor resources.
-        */
-       writeb(IOAT_CHANCMD_RESET,
-              chan->reg_base + IOAT_CHANCMD_OFFSET(chan->device->version));
-       mdelay(100);
+       device->cleanup_fn((unsigned long) c);
+       device->reset_hw(chan);
 
        spin_lock_bh(&ioat->ring_lock);
        descs = ioat2_ring_space(ioat);
@@ -776,25 +804,9 @@ void ioat2_free_chan_resources(struct dma_chan *c)
 
        chan->last_completion = 0;
        chan->completion_dma = 0;
-       ioat->pending = 0;
        ioat->dmacount = 0;
 }
 
-enum dma_status
-ioat2_is_complete(struct dma_chan *c, dma_cookie_t cookie,
-                    dma_cookie_t *done, dma_cookie_t *used)
-{
-       struct ioat2_dma_chan *ioat = to_ioat2_chan(c);
-       struct ioatdma_device *device = ioat->base.device;
-
-       if (ioat_is_complete(c, cookie, done, used) == DMA_SUCCESS)
-               return DMA_SUCCESS;
-
-       device->cleanup_tasklet((unsigned long) ioat);
-
-       return ioat_is_complete(c, cookie, done, used);
-}
-
 static ssize_t ring_size_show(struct dma_chan *c, char *page)
 {
        struct ioat2_dma_chan *ioat = to_ioat2_chan(c);
@@ -834,7 +846,8 @@ int __devinit ioat2_dma_probe(struct ioatdma_device *device, int dca)
        int err;
 
        device->enumerate_channels = ioat2_enumerate_channels;
-       device->cleanup_tasklet = ioat2_cleanup_tasklet;
+       device->reset_hw = ioat2_reset_hw;
+       device->cleanup_fn = ioat2_cleanup_event;
        device->timer_fn = ioat2_timer_event;
        device->self_test = ioat_dma_self_test;
        dma = &device->common;
@@ -842,7 +855,7 @@ int __devinit ioat2_dma_probe(struct ioatdma_device *device, int dca)
        dma->device_issue_pending = ioat2_issue_pending;
        dma->device_alloc_chan_resources = ioat2_alloc_chan_resources;
        dma->device_free_chan_resources = ioat2_free_chan_resources;
-       dma->device_is_tx_complete = ioat2_is_complete;
+       dma->device_is_tx_complete = ioat_is_dma_complete;
 
        err = ioat_probe(device);
        if (err)