38 files changed, 300 insertions, 640 deletions
diff --git a/arch/arm/include/asm/hardware/iop_adma.h b/arch/arm/include/asm/hardware/iop_adma.h
index 59b8c3892f7..122f86d8c99 100644
--- a/arch/arm/include/asm/hardware/iop_adma.h
+++ b/arch/arm/include/asm/hardware/iop_adma.h
@@ -49,7 +49,6 @@ struct iop_adma_device {
 /**
 * struct iop_adma_chan - internal representation of an ADMA device
 * @pending: allows batching of hardware operations
- * @completed_cookie: identifier for the most recently completed operation
 * @lock: serializes enqueue/dequeue operations to the slot pool
 * @mmr_base: memory mapped register base
 * @chain: device chain view of the descriptors
@@ -62,7 +61,6 @@ struct iop_adma_device {
 */
 struct iop_adma_chan {
        int pending;
-        dma_cookie_t completed_cookie;
        spinlock_t lock; /* protects the descriptor slot pool */
        void __iomem *mmr_base;
        struct list_head chain;
diff --git a/drivers/dma/amba-pl08x.c b/drivers/dma/amba-pl08x.c
index 513184b4fdd..1b53f260525 100644
--- a/drivers/dma/amba-pl08x.c
+++ b/drivers/dma/amba-pl08x.c
@@ -85,6 +85,8 @@
 #include <linux/slab.h>
 #include <asm/hardware/pl080.h>
+#include "dmaengine.h"
 #define DRIVER_NAME     "pl08xdmac"
 static struct amba_driver pl08x_amba_driver;
@@ -919,13 +921,10 @@ static dma_cookie_t pl08x_tx_submit(struct dma_async_tx_descriptor *tx)
        struct pl08x_dma_chan *plchan = to_pl08x_chan(tx->chan);
        struct pl08x_txd *txd = to_pl08x_txd(tx);
        unsigned long flags;
+        dma_cookie_t cookie;
        spin_lock_irqsave(&plchan->lock, flags);
+        cookie = dma_cookie_assign(tx);
-        plchan->chan.cookie += 1;
-        if (plchan->chan.cookie < 0)
-                plchan->chan.cookie = 1;
-        tx->cookie = plchan->chan.cookie;
        /* Put this onto the pending list */
        list_add_tail(&txd->node, &plchan->pend_list);
@@ -945,7 +944,7 @@ static dma_cookie_t pl08x_tx_submit(struct dma_async_tx_descriptor *tx)
        spin_unlock_irqrestore(&plchan->lock, flags);
-        return tx->cookie;
+        return cookie;
 }
 static struct dma_async_tx_descriptor *pl08x_prep_dma_interrupt(
@@ -965,31 +964,17 @@ static enum dma_status pl08x_dma_tx_status(struct dma_chan *chan,
                dma_cookie_t cookie, struct dma_tx_state *txstate)
 {
        struct pl08x_dma_chan *plchan = to_pl08x_chan(chan);
-        dma_cookie_t last_used;
-        dma_cookie_t last_complete;
        enum dma_status ret;
-        u32 bytesleft = 0;
-        last_used = plchan->chan.cookie;
-        last_complete = plchan->lc;
-        ret = dma_async_is_complete(cookie, last_complete, last_used);
+        ret = dma_cookie_status(chan, cookie, txstate);
-        if (ret == DMA_SUCCESS) {
+        if (ret == DMA_SUCCESS)
-                dma_set_tx_state(txstate, last_complete, last_used, 0);
                return ret;
-        }
        /*
         * This cookie not complete yet
+         * Get number of bytes left in the active transactions and queue
         */
-        last_used = plchan->chan.cookie;
+        dma_set_residue(txstate, pl08x_getbytes_chan(plchan));
-        last_complete = plchan->lc;
-        /* Get number of bytes left in the active transactions and queue */
-        bytesleft = pl08x_getbytes_chan(plchan);
-        dma_set_tx_state(txstate, last_complete, last_used,
-                         bytesleft);
        if (plchan->state == PL08X_CHAN_PAUSED)
                return DMA_PAUSED;
@@ -1543,7 +1528,7 @@ static void pl08x_tasklet(unsigned long data)
        if (txd) {
                /* Update last completed */
-                plchan->lc = txd->tx.cookie;
+                dma_cookie_complete(&txd->tx);
        }
        /* If a new descriptor is queued, set it up plchan->at is NULL here */
@@ -1724,8 +1709,7 @@ static int pl08x_dma_init_virtual_channels(struct pl08x_driver_data *pl08x,
                         chan->name);
                chan->chan.device = dmadev;
-                chan->chan.cookie = 0;
+                dma_cookie_init(&chan->chan);
-                chan->lc = 0;
                spin_lock_init(&chan->lock);
                INIT_LIST_HEAD(&chan->pend_list);
diff --git a/drivers/dma/at_hdmac.c b/drivers/dma/at_hdmac.c
index f4aed5fc2cb..5d225ddc769 100644
--- a/drivers/dma/at_hdmac.c
+++ b/drivers/dma/at_hdmac.c
@@ -27,6 +27,7 @@
 #include <linux/of_device.h>
 #include "at_hdmac_regs.h"
+#include "dmaengine.h"
 /*
 * Glossary
@@ -192,27 +193,6 @@ static void atc_desc_chain(struct at_desc **first, struct at_desc **prev,
 }
 /**
- * atc_assign_cookie - compute and assign new cookie
- * @atchan: channel we work on
- * @desc: descriptor to assign cookie for
- *
- * Called with atchan->lock held and bh disabled
- */
-static dma_cookie_t
-atc_assign_cookie(struct at_dma_chan *atchan, struct at_desc *desc)
-{
-        dma_cookie_t cookie = atchan->chan_common.cookie;
-        if (++cookie < 0)
-                cookie = 1;
-        atchan->chan_common.cookie = cookie;
-        desc->txd.cookie = cookie;
-        return cookie;
-}
-/**
 * atc_dostart - starts the DMA engine for real
 * @atchan: the channel we want to start
 * @first: first descriptor in the list we want to begin with
@@ -269,7 +249,7 @@ atc_chain_complete(struct at_dma_chan *atchan, struct at_desc *desc)
        dev_vdbg(chan2dev(&atchan->chan_common),
                "descriptor %u complete\n", txd->cookie);
-        atchan->completed_cookie = txd->cookie;
+        dma_cookie_complete(txd);
        /* move children to free_list */
        list_splice_init(&desc->tx_list, &atchan->free_list);
@@ -547,7 +527,7 @@ static dma_cookie_t atc_tx_submit(struct dma_async_tx_descriptor *tx)
        unsigned long           flags;
        spin_lock_irqsave(&atchan->lock, flags);
-        cookie = atc_assign_cookie(atchan, desc);
+        cookie = dma_cookie_assign(tx);
        if (list_empty(&atchan->active_list)) {
                dev_vdbg(chan2dev(tx->chan), "tx_submit: started %u\n",
@@ -1016,26 +996,20 @@ atc_tx_status(struct dma_chan *chan,
        spin_lock_irqsave(&atchan->lock, flags);
-        last_complete = atchan->completed_cookie;
+        ret = dma_cookie_status(chan, cookie, txstate);
-        last_used = chan->cookie;
-        ret = dma_async_is_complete(cookie, last_complete, last_used);
        if (ret != DMA_SUCCESS) {
                atc_cleanup_descriptors(atchan);
-                last_complete = atchan->completed_cookie;
+                ret = dma_cookie_status(chan, cookie, txstate);
-                last_used = chan->cookie;
-                ret = dma_async_is_complete(cookie, last_complete, last_used);
        }
+        last_complete = chan->completed_cookie;
+        last_used = chan->cookie;
        spin_unlock_irqrestore(&atchan->lock, flags);
        if (ret != DMA_SUCCESS)
-                dma_set_tx_state(txstate, last_complete, last_used,
+                dma_set_residue(txstate, atc_first_active(atchan)->len);
-                        atc_first_active(atchan)->len);
-        else
-                dma_set_tx_state(txstate, last_complete, last_used, 0);
        if (atc_chan_is_paused(atchan))
                ret = DMA_PAUSED;
@@ -1129,7 +1103,7 @@ static int atc_alloc_chan_resources(struct dma_chan *chan)
        spin_lock_irqsave(&atchan->lock, flags);
        atchan->descs_allocated = i;
        list_splice(&tmp_list, &atchan->free_list);
-        atchan->completed_cookie = chan->cookie = 1;
+        dma_cookie_init(chan);
        spin_unlock_irqrestore(&atchan->lock, flags);
        /* channel parameters */
@@ -1329,7 +1303,7 @@ static int __init at_dma_probe(struct platform_device *pdev)
                struct at_dma_chan      *atchan = &atdma->chan[i];
                atchan->chan_common.device = &atdma->dma_common;
-                atchan->chan_common.cookie = atchan->completed_cookie = 1;
+                dma_cookie_init(&atchan->chan_common);
                list_add_tail(&atchan->chan_common.device_node,
                                &atdma->dma_common.channels);
diff --git a/drivers/dma/at_hdmac_regs.h b/drivers/dma/at_hdmac_regs.h
index a8d3277d60b..08fd8a0ae79 100644
--- a/drivers/dma/at_hdmac_regs.h
+++ b/drivers/dma/at_hdmac_regs.h
@@ -208,7 +208,6 @@ enum atc_status {
 * @save_dscr: for cyclic operations, preserve next descriptor address in
 *             the cyclic list on suspend/resume cycle
 * @lock: serializes enqueue/dequeue operations to descriptors lists
- * @completed_cookie: identifier for the most recently completed operation
 * @active_list: list of descriptors dmaengine is being running on
 * @queue: list of descriptors ready to be submitted to engine
 * @free_list: list of descriptors usable by the channel
@@ -227,7 +226,6 @@ struct at_dma_chan {
        spinlock_t              lock;
        /* these other elements are all protected by lock */
-        dma_cookie_t            completed_cookie;
        struct list_head        active_list;
        struct list_head        queue;
        struct list_head        free_list;
diff --git a/drivers/dma/coh901318.c b/drivers/dma/coh901318.c
index d65a718c0f9..187bb9eef4a 100644
--- a/drivers/dma/coh901318.c
+++ b/drivers/dma/coh901318.c
@@ -24,6 +24,7 @@
 #include <mach/coh901318.h>
 #include "coh901318_lli.h"
+#include "dmaengine.h"
 #define COHC_2_DEV(cohc) (&cohc->chan.dev->device)
@@ -59,7 +60,6 @@ struct coh901318_base {
 struct coh901318_chan {
        spinlock_t lock;
        int allocated;
-        int completed;
        int id;
        int stopped;
@@ -318,20 +318,6 @@ static int coh901318_prep_linked_list(struct coh901318_chan *cohc,
        return 0;
 }
-static dma_cookie_t
-coh901318_assign_cookie(struct coh901318_chan *cohc,
-                        struct coh901318_desc *cohd)
-{
-        dma_cookie_t cookie = cohc->chan.cookie;
-        if (++cookie < 0)
-                cookie = 1;
-        cohc->chan.cookie = cookie;
-        cohd->desc.cookie = cookie;
-        return cookie;
-}
 static struct coh901318_desc *
 coh901318_desc_get(struct coh901318_chan *cohc)
@@ -705,7 +691,7 @@ static void dma_tasklet(unsigned long data)
        callback_param = cohd_fin->desc.callback_param;
        /* sign this job as completed on the channel */
-        cohc->completed = cohd_fin->desc.cookie;
+        dma_cookie_complete(&cohd_fin->desc);
        /* release the lli allocation and remove the descriptor */
        coh901318_lli_free(&cohc->base->pool, &cohd_fin->lli);
@@ -929,7 +915,7 @@ static int coh901318_alloc_chan_resources(struct dma_chan *chan)
        coh901318_config(cohc, NULL);
        cohc->allocated = 1;
-        cohc->completed = chan->cookie = 1;
+        dma_cookie_init(chan);
        spin_unlock_irqrestore(&cohc->lock, flags);
@@ -966,16 +952,16 @@ coh901318_tx_submit(struct dma_async_tx_descriptor *tx)
                                                   desc);
        struct coh901318_chan *cohc = to_coh901318_chan(tx->chan);
        unsigned long flags;
+        dma_cookie_t cookie;
        spin_lock_irqsave(&cohc->lock, flags);
+        cookie = dma_cookie_assign(tx);
-        tx->cookie = coh901318_assign_cookie(cohc, cohd);
        coh901318_desc_queue(cohc, cohd);
        spin_unlock_irqrestore(&cohc->lock, flags);
-        return tx->cookie;
+        return cookie;
 }
 static struct dma_async_tx_descriptor *
@@ -1165,17 +1151,12 @@ 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;
+        enum dma_status ret;
-        dma_cookie_t last_complete;
-        int ret;
-        last_complete = cohc->completed;
-        last_used = chan->cookie;
-        ret = dma_async_is_complete(cookie, last_complete, last_used);
+        ret = dma_cookie_status(chan, cookie, txstate);
+        /* FIXME: should be conditional on ret != DMA_SUCCESS? */
+        dma_set_residue(txstate, coh901318_get_bytes_left(chan));
-        dma_set_tx_state(txstate, last_complete, last_used,
-                         coh901318_get_bytes_left(chan));
        if (ret == DMA_IN_PROGRESS && cohc->stopped)
                ret = DMA_PAUSED;
diff --git a/drivers/dma/dmaengine.h b/drivers/dma/dmaengine.h
new file mode 100644
index 00000000000..17f983a4e9b
--- /dev/null
+++ b/drivers/dma/dmaengine.h
@@ -0,0 +1,89 @@
+/*
+ * The contents of this file are private to DMA engine drivers, and is not
+ * part of the API to be used by DMA engine users.
+ */
+#ifndef DMAENGINE_H
+#define DMAENGINE_H
+#include <linux/bug.h>
+#include <linux/dmaengine.h>
+/**
+ * dma_cookie_init - initialize the cookies for a DMA channel
+ * @chan: dma channel to initialize
+ */
+static inline void dma_cookie_init(struct dma_chan *chan)
+{
+        chan->cookie = DMA_MIN_COOKIE;
+        chan->completed_cookie = DMA_MIN_COOKIE;
+}
+/**
+ * dma_cookie_assign - assign a DMA engine cookie to the descriptor
+ * @tx: descriptor needing cookie
+ *
+ * Assign a unique non-zero per-channel cookie to the descriptor.
+ * Note: caller is expected to hold a lock to prevent concurrency.
+ */
+static inline dma_cookie_t dma_cookie_assign(struct dma_async_tx_descriptor *tx)
+{
+        struct dma_chan *chan = tx->chan;
+        dma_cookie_t cookie;
+        cookie = chan->cookie + 1;
+        if (cookie < DMA_MIN_COOKIE)
+                cookie = DMA_MIN_COOKIE;
+        tx->cookie = chan->cookie = cookie;
+        return cookie;
+}
+/**
+ * dma_cookie_complete - complete a descriptor
+ * @tx: descriptor to complete
+ *
+ * Mark this descriptor complete by updating the channels completed
+ * cookie marker.  Zero the descriptors cookie to prevent accidental
+ * repeated completions.
+ *
+ * Note: caller is expected to hold a lock to prevent concurrency.
+ */
+static inline void dma_cookie_complete(struct dma_async_tx_descriptor *tx)
+{
+        BUG_ON(tx->cookie < DMA_MIN_COOKIE);
+        tx->chan->completed_cookie = tx->cookie;
+        tx->cookie = 0;
+}
+/**
+ * dma_cookie_status - report cookie status
+ * @chan: dma channel
+ * @cookie: cookie we are interested in
+ * @state: dma_tx_state structure to return last/used cookies
+ *
+ * Report the status of the cookie, filling in the state structure if
+ * non-NULL.  No locking is required.
+ */
+static inline enum dma_status dma_cookie_status(struct dma_chan *chan,
+        dma_cookie_t cookie, struct dma_tx_state *state)
+{
+        dma_cookie_t used, complete;
+        used = chan->cookie;
+        complete = chan->completed_cookie;
+        barrier();
+        if (state) {
+                state->last = complete;
+                state->used = used;
+                state->residue = 0;
+        }
+        return dma_async_is_complete(cookie, complete, used);
+}
+static inline void dma_set_residue(struct dma_tx_state *state, u32 residue)
+{
+        if (state)
+                state->residue = residue;
+}
+#endif
diff --git a/drivers/dma/dw_dmac.c b/drivers/dma/dw_dmac.c
index 0e4b5c6a2f8..cb173bbdcfd 100644
--- a/drivers/dma/dw_dmac.c
+++ b/drivers/dma/dw_dmac.c
@@ -23,6 +23,7 @@
 #include <linux/slab.h>
 #include "dw_dmac_regs.h"
+#include "dmaengine.h"
 /*
 * This supports the Synopsys "DesignWare AHB Central DMA Controller",
@@ -156,21 +157,6 @@ static void dwc_desc_put(struct dw_dma_chan *dwc, struct dw_desc *desc)
        }
 }
-/* Called with dwc->lock held and bh disabled */
-static dma_cookie_t
-dwc_assign_cookie(struct dw_dma_chan *dwc, struct dw_desc *desc)
-{
-        dma_cookie_t cookie = dwc->chan.cookie;
-        if (++cookie < 0)
-                cookie = 1;
-        dwc->chan.cookie = cookie;
-        desc->txd.cookie = cookie;
-        return cookie;
-}
 static void dwc_initialize(struct dw_dma_chan *dwc)
 {
        struct dw_dma *dw = to_dw_dma(dwc->chan.device);
@@ -249,7 +235,7 @@ dwc_descriptor_complete(struct dw_dma_chan *dwc, struct dw_desc *desc,
        dev_vdbg(chan2dev(&dwc->chan), "descriptor %u complete\n", txd->cookie);
        spin_lock_irqsave(&dwc->lock, flags);
-        dwc->completed = txd->cookie;
+        dma_cookie_complete(txd);
        if (callback_required) {
                callback = txd->callback;
                param = txd->callback_param;
@@ -602,7 +588,7 @@ static dma_cookie_t dwc_tx_submit(struct dma_async_tx_descriptor *tx)
        unsigned long           flags;
        spin_lock_irqsave(&dwc->lock, flags);
-        cookie = dwc_assign_cookie(dwc, desc);
+        cookie = dma_cookie_assign(tx);
        /*
         * REVISIT: We should attempt to chain as many descriptors as
@@ -993,28 +979,17 @@ dwc_tx_status(struct dma_chan *chan,
              struct dma_tx_state *txstate)
 {
        struct dw_dma_chan      *dwc = to_dw_dma_chan(chan);
-        dma_cookie_t            last_used;
+        enum dma_status         ret;
-        dma_cookie_t            last_complete;
-        int                     ret;
-        last_complete = dwc->completed;
-        last_used = chan->cookie;
-        ret = dma_async_is_complete(cookie, last_complete, last_used);
+        ret = dma_cookie_status(chan, cookie, txstate);
        if (ret != DMA_SUCCESS) {
                dwc_scan_descriptors(to_dw_dma(chan->device), dwc);
-                last_complete = dwc->completed;
+                ret = dma_cookie_status(chan, cookie, txstate);
-                last_used = chan->cookie;
-                ret = dma_async_is_complete(cookie, last_complete, last_used);
        }
        if (ret != DMA_SUCCESS)
-                dma_set_tx_state(txstate, last_complete, last_used,
+                dma_set_residue(txstate, dwc_first_active(dwc)->len);
-                                dwc_first_active(dwc)->len);
-        else
-                dma_set_tx_state(txstate, last_complete, last_used, 0);
        if (dwc->paused)
                return DMA_PAUSED;
@@ -1046,7 +1021,7 @@ static int dwc_alloc_chan_resources(struct dma_chan *chan)
                return -EIO;
        }
-        dwc->completed = chan->cookie = 1;
+        dma_cookie_init(chan);
        /*
         * NOTE: some controllers may have additional features that we
@@ -1474,7 +1449,7 @@ static int __init dw_probe(struct platform_device *pdev)
                struct dw_dma_chan      *dwc = &dw->chan[i];
                dwc->chan.device = &dw->dma;
-                dwc->chan.cookie = dwc->completed = 1;
+                dma_cookie_init(&dwc->chan);
                if (pdata->chan_allocation_order == CHAN_ALLOCATION_ASCENDING)
                        list_add_tail(&dwc->chan.device_node,
                                        &dw->dma.channels);
diff --git a/drivers/dma/dw_dmac_regs.h b/drivers/dma/dw_dmac_regs.h
index eec0481a12f..f298f69ecbf 100644
--- a/drivers/dma/dw_dmac_regs.h
+++ b/drivers/dma/dw_dmac_regs.h
@@ -158,7 +158,6 @@ struct dw_dma_chan {
        /* these other elements are all protected by lock */
        unsigned long           flags;
-        dma_cookie_t            completed;
        struct list_head        active_list;
        struct list_head        queue;
        struct list_head        free_list;
diff --git a/drivers/dma/ep93xx_dma.c b/drivers/dma/ep93xx_dma.c
index 59e7a965772..f25e83bf567 100644
--- a/drivers/dma/ep93xx_dma.c
+++ b/drivers/dma/ep93xx_dma.c
@@ -28,6 +28,8 @@
 #include <mach/dma.h>
+#include "dmaengine.h"
 /* M2P registers */
 #define M2P_CONTROL                     0x0000
 #define M2P_CONTROL_STALLINT            BIT(0)
@@ -122,7 +124,6 @@ struct ep93xx_dma_desc {
 * @lock: lock protecting the fields following
 * @flags: flags for the channel
 * @buffer: which buffer to use next (0/1)
- * @last_completed: last completed cookie value
 * @active: flattened chain of descriptors currently being processed
 * @queue: pending descriptors which are handled next
 * @free_list: list of free descriptors which can be used
@@ -157,7 +158,6 @@ struct ep93xx_dma_chan {
 #define EP93XX_DMA_IS_CYCLIC            0
        int                             buffer;
-        dma_cookie_t                    last_completed;
        struct list_head                active;
        struct list_head                queue;
        struct list_head                free_list;
@@ -703,7 +703,7 @@ static void ep93xx_dma_tasklet(unsigned long data)
        desc = ep93xx_dma_get_active(edmac);
        if (desc) {
                if (desc->complete) {
-                        edmac->last_completed = desc->txd.cookie;
+                        dma_cookie_complete(&desc->txd);
                        list_splice_init(&edmac->active, &list);
                }
                callback = desc->txd.callback;
@@ -783,17 +783,10 @@ static dma_cookie_t ep93xx_dma_tx_submit(struct dma_async_tx_descriptor *tx)
        unsigned long flags;
        spin_lock_irqsave(&edmac->lock, flags);
+        cookie = dma_cookie_assign(tx);
-        cookie = edmac->chan.cookie;
-        if (++cookie < 0)
-                cookie = 1;
        desc = container_of(tx, struct ep93xx_dma_desc, txd);
-        edmac->chan.cookie = cookie;
-        desc->txd.cookie = cookie;
        /*
         * If nothing is currently prosessed, we push this descriptor
         * directly to the hardware. Otherwise we put the descriptor
@@ -861,8 +854,7 @@ static int ep93xx_dma_alloc_chan_resources(struct dma_chan *chan)
                goto fail_clk_disable;
        spin_lock_irq(&edmac->lock);
-        edmac->last_completed = 1;
+        dma_cookie_init(&edmac->chan);
-        edmac->chan.cookie = 1;
        ret = edmac->edma->hw_setup(edmac);
        spin_unlock_irq(&edmac->lock);
@@ -1248,18 +1240,13 @@ static enum dma_status ep93xx_dma_tx_status(struct dma_chan *chan,
                                            struct dma_tx_state *state)
 {
        struct ep93xx_dma_chan *edmac = to_ep93xx_dma_chan(chan);
-        dma_cookie_t last_used, last_completed;
        enum dma_status ret;
        unsigned long flags;
        spin_lock_irqsave(&edmac->lock, flags);
-        last_used = chan->cookie;
+        ret = dma_cookie_status(chan, cookie, state);
-        last_completed = edmac->last_completed;
        spin_unlock_irqrestore(&edmac->lock, flags);
-        ret = dma_async_is_complete(cookie, last_completed, last_used);
-        dma_set_tx_state(state, last_completed, last_used, 0);
        return ret;
 }
diff --git a/drivers/dma/fsldma.c b/drivers/dma/fsldma.c
index b98070c33ca..7d7384b3462 100644
--- a/drivers/dma/fsldma.c
+++ b/drivers/dma/fsldma.c
@@ -35,6 +35,7 @@
 #include <linux/dmapool.h>
 #include <linux/of_platform.h>
+#include "dmaengine.h"
 #include "fsldma.h"
 #define chan_dbg(chan, fmt, arg...)                                     \
@@ -413,17 +414,10 @@ static dma_cookie_t fsl_dma_tx_submit(struct dma_async_tx_descriptor *tx)
         * assign cookies to all of the software descriptors
         * that make up this transaction
         */
-        cookie = chan->common.cookie;
        list_for_each_entry(child, &desc->tx_list, node) {
-                cookie++;
+                cookie = dma_cookie_assign(&child->async_tx);
-                if (cookie < DMA_MIN_COOKIE)
-                        cookie = DMA_MIN_COOKIE;
-                child->async_tx.cookie = cookie;
        }
-        chan->common.cookie = cookie;
        /* put this transaction onto the tail of the pending queue */
        append_ld_queue(chan, desc);
@@ -984,19 +978,14 @@ static enum dma_status fsl_tx_status(struct dma_chan *dchan,
                                        struct dma_tx_state *txstate)
 {
        struct fsldma_chan *chan = to_fsl_chan(dchan);
-        dma_cookie_t last_complete;
+        enum dma_status ret;
-        dma_cookie_t last_used;
        unsigned long flags;
        spin_lock_irqsave(&chan->desc_lock, flags);
+        ret = dma_cookie_status(dchan, cookie, txstate);
-        last_complete = chan->completed_cookie;
-        last_used = dchan->cookie;
        spin_unlock_irqrestore(&chan->desc_lock, flags);
-        dma_set_tx_state(txstate, last_complete, last_used, 0);
+        return ret;
-        return dma_async_is_complete(cookie, last_complete, last_used);
 }
 /*----------------------------------------------------------------------------*/
@@ -1087,8 +1076,8 @@ static void dma_do_tasklet(unsigned long data)
                desc = to_fsl_desc(chan->ld_running.prev);
                cookie = desc->async_tx.cookie;
+                dma_cookie_complete(&desc->async_tx);
-                chan->completed_cookie = cookie;
                chan_dbg(chan, "completed_cookie=%d\n", cookie);
        }
@@ -1303,6 +1292,7 @@ static int __devinit fsl_dma_chan_probe(struct fsldma_device *fdev,
        chan->idle = true;
        chan->common.device = &fdev->common;
+        dma_cookie_init(&chan->common);
        /* find the IRQ line, if it exists in the device tree */
        chan->irq = irq_of_parse_and_map(node, 0);
diff --git a/drivers/dma/fsldma.h b/drivers/dma/fsldma.h
index 9cb5aa57c67..f5c38791fc7 100644
--- a/drivers/dma/fsldma.h
+++ b/drivers/dma/fsldma.h
@@ -137,7 +137,6 @@ struct fsldma_device {
 struct fsldma_chan {
        char name[8];                   /* Channel name */
        struct fsldma_chan_regs __iomem *regs;
-        dma_cookie_t completed_cookie;  /* The maximum cookie completed */
        spinlock_t desc_lock;           /* Descriptor operation lock */
        struct list_head ld_pending;    /* Link descriptors queue */
        struct list_head ld_running;    /* Link descriptors queue */
diff --git a/drivers/dma/imx-dma.c b/drivers/dma/imx-dma.c
index c32103f04fb..20c1565a748 100644
--- a/drivers/dma/imx-dma.c
+++ b/drivers/dma/imx-dma.c
@@ -32,6 +32,7 @@
 #include <mach/dma-v1.h>
 #include <mach/hardware.h>
+#include "dmaengine.h"
 #define IMXDMA_MAX_CHAN_DESCRIPTORS     16
 enum  imxdma_prep_type {
@@ -77,7 +78,8 @@ struct imxdma_channel {
        u32                             watermark_level;
        struct dma_chan                 chan;
        spinlock_t                      lock;
-        dma_cookie_t                    last_completed;
+        struct dma_async_tx_descriptor  desc;
+        enum dma_status                 status;
        int                             dma_request;
        struct scatterlist              *sg_list;
 };
@@ -192,7 +194,7 @@ static void imxdma_tasklet(unsigned long data)
        if (desc->desc.callback)
                desc->desc.callback(desc->desc.callback_param);
-        imxdmac->last_completed = desc->desc.cookie;
+        dma_cookie_complete(&desc->desc);
        /* If we are dealing with a cyclic descriptor keep it on ld_active */
        if (imxdma_chan_is_doing_cyclic(imxdmac))
@@ -276,31 +278,7 @@ static enum dma_status imxdma_tx_status(struct dma_chan *chan,
                                            dma_cookie_t cookie,
                                            struct dma_tx_state *txstate)
 {
-        struct imxdma_channel *imxdmac = to_imxdma_chan(chan);
+        return dma_cookie_status(chan, cookie, txstate);
-        dma_cookie_t last_used;
-        enum dma_status ret;
-        unsigned long flags;
-        spin_lock_irqsave(&imxdmac->lock, flags);
-        last_used = chan->cookie;
-        ret = dma_async_is_complete(cookie, imxdmac->last_completed, last_used);
-        dma_set_tx_state(txstate, imxdmac->last_completed, last_used, 0);
-        spin_unlock_irqrestore(&imxdmac->lock, flags);
-        return ret;
-}
-static dma_cookie_t imxdma_assign_cookie(struct imxdma_channel *imxdma)
-{
-        dma_cookie_t cookie = imxdma->chan.cookie;
-        if (++cookie < 0)
-                cookie = 1;
-        imxdma->chan.cookie = cookie;
-        return cookie;
 }
 static dma_cookie_t imxdma_tx_submit(struct dma_async_tx_descriptor *tx)
@@ -310,11 +288,7 @@ static dma_cookie_t imxdma_tx_submit(struct dma_async_tx_descriptor *tx)
        unsigned long flags;
        spin_lock_irqsave(&imxdmac->lock, flags);
+        cookie = dma_cookie_assign(tx);
-        list_move_tail(imxdmac->ld_free.next, &imxdmac->ld_queue);
-        cookie = imxdma_assign_cookie(imxdmac);
-        tx->cookie = cookie;
        spin_unlock_irqrestore(&imxdmac->lock, flags);
        return cookie;
@@ -583,6 +557,7 @@ static int __init imxdma_probe(struct platform_device *pdev)
                tasklet_init(&imxdmac->dma_tasklet, imxdma_tasklet,
                             (unsigned long)imxdmac);
                imxdmac->chan.device = &imxdma->dma_device;
+                dma_cookie_init(&imxdmac->chan);
                imxdmac->channel = i;
                /* Add the channel to the DMAC list */
diff --git a/drivers/dma/imx-sdma.c b/drivers/dma/imx-sdma.c
index f0bfc0e0741..5da552d1f92 100644
--- a/drivers/dma/imx-sdma.c
+++ b/drivers/dma/imx-sdma.c
@@ -43,6 +43,8 @@
 #include <mach/dma.h>
 #include <mach/hardware.h>
+#include "dmaengine.h"
 /* SDMA registers */
 #define SDMA_H_C0PTR            0x000
 #define SDMA_H_INTR             0x004
@@ -267,7 +269,6 @@ struct sdma_channel {
        struct dma_chan                 chan;
        spinlock_t                      lock;
        struct dma_async_tx_descriptor  desc;
-        dma_cookie_t                    last_completed;
        enum dma_status                 status;
        unsigned int                    chn_count;
        unsigned int                    chn_real_count;
@@ -529,7 +530,7 @@ static void mxc_sdma_handle_channel_normal(struct sdma_channel *sdmac)
        else
                sdmac->status = DMA_SUCCESS;
-        sdmac->last_completed = sdmac->desc.cookie;
+        dma_cookie_complete(&sdmac->desc);
        if (sdmac->desc.callback)
                sdmac->desc.callback(sdmac->desc.callback_param);
 }
@@ -814,19 +815,6 @@ out:
        return ret;
 }
-static dma_cookie_t sdma_assign_cookie(struct sdma_channel *sdmac)
-{
-        dma_cookie_t cookie = sdmac->chan.cookie;
-        if (++cookie < 0)
-                cookie = 1;
-        sdmac->chan.cookie = cookie;
-        sdmac->desc.cookie = cookie;
-        return cookie;
-}
 static struct sdma_channel *to_sdma_chan(struct dma_chan *chan)
 {
        return container_of(chan, struct sdma_channel, chan);
@@ -840,7 +828,7 @@ static dma_cookie_t sdma_tx_submit(struct dma_async_tx_descriptor *tx)
        spin_lock_irqsave(&sdmac->lock, flags);
-        cookie = sdma_assign_cookie(sdmac);
+        cookie = dma_cookie_assign(tx);
        spin_unlock_irqrestore(&sdmac->lock, flags);
@@ -1127,7 +1115,7 @@ static enum dma_status sdma_tx_status(struct dma_chan *chan,
        last_used = chan->cookie;
-        dma_set_tx_state(txstate, sdmac->last_completed, last_used,
+        dma_set_tx_state(txstate, chan->completed_cookie, last_used,
                        sdmac->chn_count - sdmac->chn_real_count);
        return sdmac->status;
@@ -1368,6 +1356,7 @@ static int __init sdma_probe(struct platform_device *pdev)
                spin_lock_init(&sdmac->lock);
                sdmac->chan.device = &sdma->dma_device;
+                dma_cookie_init(&sdmac->chan);
                sdmac->channel = i;
                /*
diff --git a/drivers/dma/intel_mid_dma.c b/drivers/dma/intel_mid_dma.c
index 923476d74a5..2449812f546 100644
--- a/drivers/dma/intel_mid_dma.c
+++ b/drivers/dma/intel_mid_dma.c
@@ -29,6 +29,8 @@
 #include <linux/intel_mid_dma.h>
 #include <linux/module.h>
+#include "dmaengine.h"
 #define MAX_CHAN        4 /*max ch across controllers*/
 #include "intel_mid_dma_regs.h"
@@ -288,7 +290,7 @@ static void midc_descriptor_complete(struct intel_mid_dma_chan *midc,
        struct intel_mid_dma_lli        *llitem;
        void *param_txd = NULL;
-        midc->completed = txd->cookie;
+        dma_cookie_complete(txd);
        callback_txd = txd->callback;
        param_txd = txd->callback_param;
@@ -434,14 +436,7 @@ static dma_cookie_t intel_mid_dma_tx_submit(struct dma_async_tx_descriptor *tx)
        dma_cookie_t            cookie;
        spin_lock_bh(&midc->lock);
-        cookie = midc->chan.cookie;
+        cookie = dma_cookie_assign(tx);
-        if (++cookie < 0)
-                cookie = 1;
-        midc->chan.cookie = cookie;
-        desc->txd.cookie = cookie;
        if (list_empty(&midc->active_list))
                list_add_tail(&desc->desc_node, &midc->active_list);
@@ -482,31 +477,18 @@ static enum dma_status intel_mid_dma_tx_status(struct dma_chan *chan,
                                                dma_cookie_t cookie,
                                                struct dma_tx_state *txstate)
 {
-        struct intel_mid_dma_chan       *midc = to_intel_mid_dma_chan(chan);
+        struct intel_mid_dma_chan *midc = to_intel_mid_dma_chan(chan);
-        dma_cookie_t            last_used;
+        enum dma_status ret;
-        dma_cookie_t            last_complete;
-        int                             ret;
-        last_complete = midc->completed;
-        last_used = chan->cookie;
-        ret = dma_async_is_complete(cookie, last_complete, last_used);
+        ret = dma_cookie_status(chan, cookie, txstate);
        if (ret != DMA_SUCCESS) {
                spin_lock_bh(&midc->lock);
                midc_scan_descriptors(to_middma_device(chan->device), midc);
                spin_unlock_bh(&midc->lock);
-                last_complete = midc->completed;
+                ret = dma_cookie_status(chan, cookie, txstate);
-                last_used = chan->cookie;
-                ret = dma_async_is_complete(cookie, last_complete, last_used);
        }
-        if (txstate) {
-                txstate->last = last_complete;
-                txstate->used = last_used;
-                txstate->residue = 0;
-        }
        return ret;
 }
@@ -886,7 +868,7 @@ static int intel_mid_dma_alloc_chan_resources(struct dma_chan *chan)
                pm_runtime_put(&mid->pdev->dev);
                return -EIO;
        }
-        midc->completed = chan->cookie = 1;
+        dma_cookie_init(chan);
        spin_lock_bh(&midc->lock);
        while (midc->descs_allocated < DESCS_PER_CHANNEL) {
@@ -1119,7 +1101,7 @@ static int mid_setup_dma(struct pci_dev *pdev)
                struct intel_mid_dma_chan *midch = &dma->ch[i];
                midch->chan.device = &dma->common;
-                midch->chan.cookie =  1;
+                dma_cookie_init(&midch->chan);
                midch->ch_id = dma->chan_base + i;
                pr_debug("MDMA:Init CH %d, ID %d\n", i, midch->ch_id);
diff --git a/drivers/dma/intel_mid_dma_regs.h b/drivers/dma/intel_mid_dma_regs.h
index c83d35b97bd..1bfa9268fea 100644
--- a/drivers/dma/intel_mid_dma_regs.h
+++ b/drivers/dma/intel_mid_dma_regs.h
@@ -165,7 +165,6 @@ union intel_mid_dma_cfg_hi {
 * @dma_base: MMIO register space DMA engine base pointer
 * @ch_id: DMA channel id
 * @lock: channel spinlock
- * @completed: DMA cookie
 * @active_list: current active descriptors
 * @queue: current queued up descriptors
 * @free_list: current free descriptors
@@ -183,7 +182,6 @@ struct intel_mid_dma_chan {
        void __iomem            *dma_base;
        int                     ch_id;
        spinlock_t              lock;
-        dma_cookie_t            completed;
        struct list_head        active_list;
        struct list_head        queue;
        struct list_head        free_list;
diff --git a/drivers/dma/ioat/dma.c b/drivers/dma/ioat/dma.c
index a4d6cb0c034..31493d80e0e 100644
--- a/drivers/dma/ioat/dma.c
+++ b/drivers/dma/ioat/dma.c
@@ -40,6 +40,8 @@
 #include "registers.h"
 #include "hw.h"
+#include "../dmaengine.h"
 int ioat_pending_level = 4;
 module_param(ioat_pending_level, int, 0644);
 MODULE_PARM_DESC(ioat_pending_level,
@@ -107,6 +109,7 @@ void ioat_init_channel(struct ioatdma_device *device, struct ioat_chan_common *c
        chan->reg_base = device->reg_base + (0x80 * (idx + 1));
        spin_lock_init(&chan->cleanup_lock);
        chan->common.device = dma;
+        dma_cookie_init(&chan->common);
        list_add_tail(&chan->common.device_node, &dma->channels);
        device->idx[idx] = chan;
        init_timer(&chan->timer);
@@ -235,12 +238,7 @@ static dma_cookie_t ioat1_tx_submit(struct dma_async_tx_descriptor *tx)
        spin_lock_bh(&ioat->desc_lock);
        /* cookie incr and addition to used_list must be atomic */
-        cookie = c->cookie;
+        cookie = dma_cookie_assign(tx);
-        cookie++;
-        if (cookie < 0)
-                cookie = 1;
-        c->cookie = cookie;
-        tx->cookie = cookie;
        dev_dbg(to_dev(&ioat->base), "%s: cookie: %d\n", __func__, cookie);
        /* write address into NextDescriptor field of last desc in chain */
@@ -603,8 +601,7 @@ static void __cleanup(struct ioat_dma_chan *ioat, unsigned long phys_complete)
                 */
                dump_desc_dbg(ioat, desc);
                if (tx->cookie) {
-                        chan->completed_cookie = tx->cookie;
+                        dma_cookie_complete(tx);
-                        tx->cookie = 0;
                        ioat_dma_unmap(chan, tx->flags, desc->len, desc->hw);
                        ioat->active -= desc->hw->tx_cnt;
                        if (tx->callback) {
@@ -733,13 +730,15 @@ ioat_dma_tx_status(struct dma_chan *c, dma_cookie_t cookie,
 {
        struct ioat_chan_common *chan = to_chan_common(c);
        struct ioatdma_device *device = chan->device;
+        enum dma_status ret;
-        if (ioat_tx_status(c, cookie, txstate) == DMA_SUCCESS)
+        ret = dma_cookie_status(c, cookie, txstate);
-                return DMA_SUCCESS;
+        if (ret == DMA_SUCCESS)
+                return ret;
        device->cleanup_fn((unsigned long) c);
-        return ioat_tx_status(c, cookie, txstate);
+        return dma_cookie_status(c, cookie, txstate);
 }
 static void ioat1_dma_start_null_desc(struct ioat_dma_chan *ioat)
diff --git a/drivers/dma/ioat/dma.h b/drivers/dma/ioat/dma.h
index 5216c8a92a2..c7888bccd97 100644
--- a/drivers/dma/ioat/dma.h
+++ b/drivers/dma/ioat/dma.h
@@ -90,7 +90,6 @@ struct ioat_chan_common {
        void __iomem *reg_base;
        unsigned long last_completion;
        spinlock_t cleanup_lock;
-        dma_cookie_t completed_cookie;
        unsigned long state;
        #define IOAT_COMPLETION_PENDING 0
        #define IOAT_COMPLETION_ACK 1
@@ -143,28 +142,6 @@ static inline struct ioat_dma_chan *to_ioat_chan(struct dma_chan *c)
        return container_of(chan, struct ioat_dma_chan, base);
 }
-/**
- * ioat_tx_status - poll the status of an ioat transaction
- * @c: channel handle
- * @cookie: transaction identifier
- * @txstate: if set, updated with the transaction state
- */
-static inline enum dma_status
-ioat_tx_status(struct dma_chan *c, dma_cookie_t cookie,
-                 struct dma_tx_state *txstate)
-{
-        struct ioat_chan_common *chan = to_chan_common(c);
-        dma_cookie_t last_used;
-        dma_cookie_t last_complete;
-        last_used = c->cookie;
-        last_complete = chan->completed_cookie;
-        dma_set_tx_state(txstate, last_complete, last_used, 0);
-        return dma_async_is_complete(cookie, last_complete, last_used);
-}
 /* wrapper around hardware descriptor format + additional software fields */
 /**
diff --git a/drivers/dma/ioat/dma_v2.c b/drivers/dma/ioat/dma_v2.c
index 5d65f837797..e8e110ff3d9 100644
--- a/drivers/dma/ioat/dma_v2.c
+++ b/drivers/dma/ioat/dma_v2.c
@@ -41,6 +41,8 @@
 #include "registers.h"
 #include "hw.h"
+#include "../dmaengine.h"
 int ioat_ring_alloc_order = 8;
 module_param(ioat_ring_alloc_order, int, 0644);
 MODULE_PARM_DESC(ioat_ring_alloc_order,
@@ -147,8 +149,7 @@ static void __cleanup(struct ioat2_dma_chan *ioat, unsigned long phys_complete)
                dump_desc_dbg(ioat, desc);
                if (tx->cookie) {
                        ioat_dma_unmap(chan, tx->flags, desc->len, desc->hw);
-                        chan->completed_cookie = tx->cookie;
+                        dma_cookie_complete(tx);
-                        tx->cookie = 0;
                        if (tx->callback) {
                                tx->callback(tx->callback_param);
                                tx->callback = NULL;
@@ -398,13 +399,9 @@ static dma_cookie_t ioat2_tx_submit_unlock(struct dma_async_tx_descriptor *tx)
        struct dma_chan *c = tx->chan;
        struct ioat2_dma_chan *ioat = to_ioat2_chan(c);
        struct ioat_chan_common *chan = &ioat->base;
-        dma_cookie_t cookie = c->cookie;
+        dma_cookie_t cookie;
-        cookie++;
+        cookie = dma_cookie_assign(tx);
-        if (cookie < 0)
-                cookie = 1;
-        tx->cookie = cookie;
-        c->cookie = cookie;
        dev_dbg(to_dev(&ioat->base), "%s: cookie: %d\n", __func__, cookie);
        if (!test_and_set_bit(IOAT_COMPLETION_PENDING, &chan->state))
diff --git a/drivers/dma/ioat/dma_v3.c b/drivers/dma/ioat/dma_v3.c
index f519c93a61e..2c4476c0e40 100644
--- a/drivers/dma/ioat/dma_v3.c
+++ b/drivers/dma/ioat/dma_v3.c
@@ -61,6 +61,7 @@
 #include <linux/dmaengine.h>
 #include <linux/dma-mapping.h>
 #include <linux/prefetch.h>
+#include "../dmaengine.h"
 #include "registers.h"
 #include "hw.h"
 #include "dma.h"
@@ -277,9 +278,8 @@ static void __cleanup(struct ioat2_dma_chan *ioat, unsigned long phys_complete)
                dump_desc_dbg(ioat, desc);
                tx = &desc->txd;
                if (tx->cookie) {
-                        chan->completed_cookie = tx->cookie;
+                        dma_cookie_complete(tx);
                        ioat3_dma_unmap(ioat, desc, idx + i);
-                        tx->cookie = 0;
                        if (tx->callback) {
                                tx->callback(tx->callback_param);
                                tx->callback = NULL;
@@ -411,13 +411,15 @@ ioat3_tx_status(struct dma_chan *c, dma_cookie_t cookie,
                struct dma_tx_state *txstate)
 {
        struct ioat2_dma_chan *ioat = to_ioat2_chan(c);
+        enum dma_status ret;
-        if (ioat_tx_status(c, cookie, txstate) == DMA_SUCCESS)
+        ret = dma_cookie_status(c, cookie, txstate);
-                return DMA_SUCCESS;
+        if (ret == DMA_SUCCESS)
+                return ret;
        ioat3_cleanup(ioat);
-        return ioat_tx_status(c, cookie, txstate);
+        return dma_cookie_status(c, cookie, txstate);
 }
 static struct dma_async_tx_descriptor *
diff --git a/drivers/dma/iop-adma.c b/drivers/dma/iop-adma.c
index 04be90b645b..4499f88789b 100644
--- a/drivers/dma/iop-adma.c
+++ b/drivers/dma/iop-adma.c
@@ -36,6 +36,8 @@
 #include <mach/adma.h>
+#include "dmaengine.h"
 #define to_iop_adma_chan(chan) container_of(chan, struct iop_adma_chan, common)
 #define to_iop_adma_device(dev) \
        container_of(dev, struct iop_adma_device, common)
@@ -317,7 +319,7 @@ static void __iop_adma_slot_cleanup(struct iop_adma_chan *iop_chan)
        }
        if (cookie > 0) {
-                iop_chan->completed_cookie = cookie;
+                iop_chan->common.completed_cookie = cookie;
                pr_debug("\tcompleted cookie %d\n", cookie);
        }
 }
@@ -438,18 +440,6 @@ retry:
        return NULL;
 }
-static dma_cookie_t
-iop_desc_assign_cookie(struct iop_adma_chan *iop_chan,
-        struct iop_adma_desc_slot *desc)
-{
-        dma_cookie_t cookie = iop_chan->common.cookie;
-        cookie++;
-        if (cookie < 0)
-                cookie = 1;
-        iop_chan->common.cookie = desc->async_tx.cookie = cookie;
-        return cookie;
-}
 static void iop_adma_check_threshold(struct iop_adma_chan *iop_chan)
 {
        dev_dbg(iop_chan->device->common.dev, "pending: %d\n",
@@ -477,7 +467,7 @@ iop_adma_tx_submit(struct dma_async_tx_descriptor *tx)
        slots_per_op = grp_start->slots_per_op;
        spin_lock_bh(&iop_chan->lock);
-        cookie = iop_desc_assign_cookie(iop_chan, sw_desc);
+        cookie = dma_cookie_assign(tx);
        old_chain_tail = list_entry(iop_chan->chain.prev,
                struct iop_adma_desc_slot, chain_node);
@@ -904,24 +894,15 @@ static enum dma_status iop_adma_status(struct dma_chan *chan,
                                        struct dma_tx_state *txstate)
 {
        struct iop_adma_chan *iop_chan = to_iop_adma_chan(chan);
-        dma_cookie_t last_used;
+        int ret;
-        dma_cookie_t last_complete;
-        enum dma_status ret;
+        ret = dma_cookie_status(chan, cookie, txstate);
-        last_used = chan->cookie;
-        last_complete = iop_chan->completed_cookie;
-        dma_set_tx_state(txstate, last_complete, last_used, 0);
-        ret = dma_async_is_complete(cookie, last_complete, last_used);
        if (ret == DMA_SUCCESS)
                return ret;
        iop_adma_slot_cleanup(iop_chan);
-        last_used = chan->cookie;
+        return dma_cookie_status(chan, cookie, txstate);
-        last_complete = iop_chan->completed_cookie;
-        dma_set_tx_state(txstate, last_complete, last_used, 0);
-        return dma_async_is_complete(cookie, last_complete, last_used);
 }
 static irqreturn_t iop_adma_eot_handler(int irq, void *data)
@@ -1565,6 +1546,7 @@ static int __devinit iop_adma_probe(struct platform_device *pdev)
        INIT_LIST_HEAD(&iop_chan->chain);
        INIT_LIST_HEAD(&iop_chan->all_slots);
        iop_chan->common.device = dma_dev;
+        dma_cookie_init(&iop_chan->common);
        list_add_tail(&iop_chan->common.device_node, &dma_dev->channels);
        if (dma_has_cap(DMA_MEMCPY, dma_dev->cap_mask)) {
@@ -1642,16 +1624,12 @@ static void iop_chan_start_null_memcpy(struct iop_adma_chan *iop_chan)
                iop_desc_set_dest_addr(grp_start, iop_chan, 0);
                iop_desc_set_memcpy_src_addr(grp_start, 0);
-                cookie = iop_chan->common.cookie;
+                cookie = dma_cookie_assign(&sw_desc->async_tx);
-                cookie++;
-                if (cookie <= 1)
-                        cookie = 2;
                /* initialize the completed cookie to be less than
                 * the most recently used cookie
                 */
-                iop_chan->completed_cookie = cookie - 1;
+                iop_chan->common.completed_cookie = cookie - 1;
-                iop_chan->common.cookie = sw_desc->async_tx.cookie = cookie;
                /* channel should not be busy */
                BUG_ON(iop_chan_is_busy(iop_chan));
@@ -1699,16 +1677,12 @@ static void iop_chan_start_null_xor(struct iop_adma_chan *iop_chan)
                iop_desc_set_xor_src_addr(grp_start, 0, 0);
                iop_desc_set_xor_src_addr(grp_start, 1, 0);
-                cookie = iop_chan->common.cookie;
+                cookie = dma_cookie_assign(&sw_desc->async_tx);
-                cookie++;
-                if (cookie <= 1)
-                        cookie = 2;
                /* initialize the completed cookie to be less than
                 * the most recently used cookie
                 */
-                iop_chan->completed_cookie = cookie - 1;
+                iop_chan->common.completed_cookie = cookie - 1;
-                iop_chan->common.cookie = sw_desc->async_tx.cookie = cookie;
                /* channel should not be busy */
                BUG_ON(iop_chan_is_busy(iop_chan));
diff --git a/drivers/dma/ipu/ipu_idmac.c b/drivers/dma/ipu/ipu_idmac.c
index 6212b16e8cf..1880274b085 100644
--- a/drivers/dma/ipu/ipu_idmac.c
+++ b/drivers/dma/ipu/ipu_idmac.c
@@ -25,6 +25,7 @@
 #include <mach/ipu.h>
+#include "../dmaengine.h"
 #include "ipu_intern.h"
 #define FS_VF_IN_VALID  0x00000002
@@ -866,14 +867,7 @@ static dma_cookie_t idmac_tx_submit(struct dma_async_tx_descriptor *tx)
        dev_dbg(dev, "Submitting sg %p\n", &desc->sg[0]);
-        cookie = ichan->dma_chan.cookie;
+        cookie = dma_cookie_assign(tx);
-        if (++cookie < 0)
-                cookie = 1;
-        /* from dmaengine.h: "last cookie value returned to client" */
-        ichan->dma_chan.cookie = cookie;
-        tx->cookie = cookie;
        /* ipu->lock can be taken under ichan->lock, but not v.v. */
        spin_lock_irqsave(&ichan->lock, flags);
@@ -1295,7 +1289,7 @@ static irqreturn_t idmac_interrupt(int irq, void *dev_id)
        /* Flip the active buffer - even if update above failed */
        ichan->active_buffer = !ichan->active_buffer;
        if (done)
-                ichan->completed = desc->txd.cookie;
+                dma_cookie_complete(&desc->txd);
        callback = desc->txd.callback;
        callback_param = desc->txd.callback_param;
@@ -1510,8 +1504,7 @@ static int idmac_alloc_chan_resources(struct dma_chan *chan)
        BUG_ON(chan->client_count > 1);
        WARN_ON(ichan->status != IPU_CHANNEL_FREE);
-        chan->cookie            = 1;
+        dma_cookie_init(chan);
-        ichan->completed        = -ENXIO;
        ret = ipu_irq_map(chan->chan_id);
        if (ret < 0)
@@ -1600,9 +1593,7 @@ static void idmac_free_chan_resources(struct dma_chan *chan)
 static enum dma_status idmac_tx_status(struct dma_chan *chan,
                       dma_cookie_t cookie, struct dma_tx_state *txstate)
 {
-        struct idmac_channel *ichan = to_idmac_chan(chan);
+        dma_set_tx_state(txstate, chan->completed_cookie, chan->cookie, 0);
-        dma_set_tx_state(txstate, ichan->completed, chan->cookie, 0);
        if (cookie != chan->cookie)
                return DMA_ERROR;
        return DMA_SUCCESS;
@@ -1638,11 +1629,10 @@ static int __init ipu_idmac_init(struct ipu *ipu)
                ichan->status           = IPU_CHANNEL_FREE;
                ichan->sec_chan_en      = false;
-                ichan->completed        = -ENXIO;
                snprintf(ichan->eof_name, sizeof(ichan->eof_name), "IDMAC EOF %d", i);
                dma_chan->device        = &idmac->dma;
-                dma_chan->cookie        = 1;
+                dma_cookie_init(dma_chan);
                dma_chan->chan_id       = i;
                list_add_tail(&dma_chan->device_node, &dma->channels);
        }
diff --git a/drivers/dma/mpc512x_dma.c b/drivers/dma/mpc512x_dma.c
index 4d6d4cf6694..2ab0a3d0eed 100644
--- a/drivers/dma/mpc512x_dma.c
+++ b/drivers/dma/mpc512x_dma.c
@@ -44,6 +44,8 @@
 #include <linux/random.h>
+#include "dmaengine.h"
 /* Number of DMA Transfer descriptors allocated per channel */
 #define MPC_DMA_DESCRIPTORS     64
@@ -188,7 +190,6 @@ struct mpc_dma_chan {
        struct list_head                completed;
        struct mpc_dma_tcd              *tcd;
        dma_addr_t                      tcd_paddr;
-        dma_cookie_t                    completed_cookie;
        /* Lock for this structure */
        spinlock_t                      lock;
@@ -365,7 +366,7 @@ static void mpc_dma_process_completed(struct mpc_dma *mdma)
                /* Free descriptors */
                spin_lock_irqsave(&mchan->lock, flags);
                list_splice_tail_init(&list, &mchan->free);
-                mchan->completed_cookie = last_cookie;
+                mchan->chan.completed_cookie = last_cookie;
                spin_unlock_irqrestore(&mchan->lock, flags);
        }
 }
@@ -438,13 +439,7 @@ static dma_cookie_t mpc_dma_tx_submit(struct dma_async_tx_descriptor *txd)
                mpc_dma_execute(mchan);
        /* Update cookie */
-        cookie = mchan->chan.cookie + 1;
+        cookie = dma_cookie_assign(txd);
-        if (cookie <= 0)
-                cookie = 1;
-        mchan->chan.cookie = cookie;
-        mdesc->desc.cookie = cookie;
        spin_unlock_irqrestore(&mchan->lock, flags);
        return cookie;
@@ -562,17 +557,14 @@ mpc_dma_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
               struct dma_tx_state *txstate)
 {
        struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(chan);
+        enum dma_status ret;
        unsigned long flags;
-        dma_cookie_t last_used;
-        dma_cookie_t last_complete;
        spin_lock_irqsave(&mchan->lock, flags);
-        last_used = mchan->chan.cookie;
+        ret = dma_cookie_status(chan, cookie, txstate);
-        last_complete = mchan->completed_cookie;
        spin_unlock_irqrestore(&mchan->lock, flags);
-        dma_set_tx_state(txstate, last_complete, last_used, 0);
+        return ret;
-        return dma_async_is_complete(cookie, last_complete, last_used);
 }
 /* Prepare descriptor for memory to memory copy */
@@ -741,8 +733,7 @@ static int __devinit mpc_dma_probe(struct platform_device *op)
                mchan = &mdma->channels[i];
                mchan->chan.device = dma;
-                mchan->chan.cookie = 1;
+                dma_cookie_init(&mchan->chan);
-                mchan->completed_cookie = mchan->chan.cookie;
                INIT_LIST_HEAD(&mchan->free);
                INIT_LIST_HEAD(&mchan->prepared);
diff --git a/drivers/dma/mv_xor.c b/drivers/dma/mv_xor.c
index e779b434af4..fa5d55fea46 100644
--- a/drivers/dma/mv_xor.c
+++ b/drivers/dma/mv_xor.c
@@ -26,6 +26,8 @@
 #include <linux/platform_device.h>
 #include <linux/memory.h>
 #include <plat/mv_xor.h>
+#include "dmaengine.h"
 #include "mv_xor.h"
 static void mv_xor_issue_pending(struct dma_chan *chan);
@@ -435,7 +437,7 @@ static void __mv_xor_slot_cleanup(struct mv_xor_chan *mv_chan)
        }
        if (cookie > 0)
-                mv_chan->completed_cookie = cookie;
+                mv_chan->common.completed_cookie = cookie;
 }
 static void
@@ -534,18 +536,6 @@ retry:
        return NULL;
 }
-static dma_cookie_t
-mv_desc_assign_cookie(struct mv_xor_chan *mv_chan,
-                      struct mv_xor_desc_slot *desc)
-{
-        dma_cookie_t cookie = mv_chan->common.cookie;
-        if (++cookie < 0)
-                cookie = 1;
-        mv_chan->common.cookie = desc->async_tx.cookie = cookie;
-        return cookie;
-}
 /************************ DMA engine API functions ****************************/
 static dma_cookie_t
 mv_xor_tx_submit(struct dma_async_tx_descriptor *tx)
@@ -563,7 +553,7 @@ mv_xor_tx_submit(struct dma_async_tx_descriptor *tx)
        grp_start = sw_desc->group_head;
        spin_lock_bh(&mv_chan->lock);
-        cookie = mv_desc_assign_cookie(mv_chan, sw_desc);
+        cookie = dma_cookie_assign(tx);
        if (list_empty(&mv_chan->chain))
                list_splice_init(&sw_desc->tx_list, &mv_chan->chain);
@@ -820,27 +810,16 @@ static enum dma_status mv_xor_status(struct dma_chan *chan,
                                          struct dma_tx_state *txstate)
 {
        struct mv_xor_chan *mv_chan = to_mv_xor_chan(chan);
-        dma_cookie_t last_used;
-        dma_cookie_t last_complete;
        enum dma_status ret;
-        last_used = chan->cookie;
+        ret = dma_cookie_status(chan, cookie, txstate);
-        last_complete = mv_chan->completed_cookie;
-        mv_chan->is_complete_cookie = cookie;
-        dma_set_tx_state(txstate, last_complete, last_used, 0);
-        ret = dma_async_is_complete(cookie, last_complete, last_used);
        if (ret == DMA_SUCCESS) {
                mv_xor_clean_completed_slots(mv_chan);
                return ret;
        }
        mv_xor_slot_cleanup(mv_chan);
-        last_used = chan->cookie;
+        return dma_cookie_status(chan, cookie, txstate);
-        last_complete = mv_chan->completed_cookie;
-        dma_set_tx_state(txstate, last_complete, last_used, 0);
-        return dma_async_is_complete(cookie, last_complete, last_used);
 }
 static void mv_dump_xor_regs(struct mv_xor_chan *chan)
@@ -1214,6 +1193,7 @@ static int __devinit mv_xor_probe(struct platform_device *pdev)
        INIT_LIST_HEAD(&mv_chan->completed_slots);
        INIT_LIST_HEAD(&mv_chan->all_slots);
        mv_chan->common.device = dma_dev;
+        dma_cookie_init(&mv_chan->common);
        list_add_tail(&mv_chan->common.device_node, &dma_dev->channels);
diff --git a/drivers/dma/mv_xor.h b/drivers/dma/mv_xor.h
index 977b592e976..654876b7ba1 100644
--- a/drivers/dma/mv_xor.h
+++ b/drivers/dma/mv_xor.h
@@ -78,7 +78,6 @@ struct mv_xor_device {
 /**
 * struct mv_xor_chan - internal representation of a XOR channel
 * @pending: allows batching of hardware operations
- * @completed_cookie: identifier for the most recently completed operation
 * @lock: serializes enqueue/dequeue operations to the descriptors pool
 * @mmr_base: memory mapped register base
 * @idx: the index of the xor channel
@@ -93,7 +92,6 @@ struct mv_xor_device {
 */
 struct mv_xor_chan {
        int                     pending;
-        dma_cookie_t            completed_cookie;
        spinlock_t              lock; /* protects the descriptor slot pool */
        void __iomem            *mmr_base;
        unsigned int            idx;
@@ -109,7 +107,6 @@ struct mv_xor_chan {
 #ifdef USE_TIMER
        unsigned long           cleanup_time;
        u32                     current_on_last_cleanup;
-        dma_cookie_t            is_complete_cookie;
 #endif
 };
diff --git a/drivers/dma/mxs-dma.c b/drivers/dma/mxs-dma.c
index b06cd4ca626..a2267f9ab56 100644
--- a/drivers/dma/mxs-dma.c
+++ b/drivers/dma/mxs-dma.c
@@ -28,6 +28,8 @@
 #include <mach/dma.h>
 #include <mach/common.h>
+#include "dmaengine.h"
 /*
 * NOTE: The term "PIO" throughout the mxs-dma implementation means
 * PIO mode of mxs apbh-dma and apbx-dma.  With this working mode,
@@ -111,7 +113,6 @@ struct mxs_dma_chan {
        struct mxs_dma_ccw              *ccw;
        dma_addr_t                      ccw_phys;
        int                             desc_count;
-        dma_cookie_t                    last_completed;
        enum dma_status                 status;
        unsigned int                    flags;
 #define MXS_DMA_SG_LOOP                 (1 << 0)
@@ -193,19 +194,6 @@ static void mxs_dma_resume_chan(struct mxs_dma_chan *mxs_chan)
        mxs_chan->status = DMA_IN_PROGRESS;
 }
-static dma_cookie_t mxs_dma_assign_cookie(struct mxs_dma_chan *mxs_chan)
-{
-        dma_cookie_t cookie = mxs_chan->chan.cookie;
-        if (++cookie < 0)
-                cookie = 1;
-        mxs_chan->chan.cookie = cookie;
-        mxs_chan->desc.cookie = cookie;
-        return cookie;
-}
 static struct mxs_dma_chan *to_mxs_dma_chan(struct dma_chan *chan)
 {
        return container_of(chan, struct mxs_dma_chan, chan);
@@ -217,7 +205,7 @@ static dma_cookie_t mxs_dma_tx_submit(struct dma_async_tx_descriptor *tx)
        mxs_dma_enable_chan(mxs_chan);
-        return mxs_dma_assign_cookie(mxs_chan);
+        return dma_cookie_assign(tx);
 }
 static void mxs_dma_tasklet(unsigned long data)
@@ -274,7 +262,7 @@ static irqreturn_t mxs_dma_int_handler(int irq, void *dev_id)
                stat1 &= ~(1 << channel);
                if (mxs_chan->status == DMA_SUCCESS)
-                        mxs_chan->last_completed = mxs_chan->desc.cookie;
+                        dma_cookie_complete(&mxs_chan->desc);
                /* schedule tasklet on this channel */
                tasklet_schedule(&mxs_chan->tasklet);
@@ -538,7 +526,7 @@ static enum dma_status mxs_dma_tx_status(struct dma_chan *chan,
        dma_cookie_t last_used;
        last_used = chan->cookie;
-        dma_set_tx_state(txstate, mxs_chan->last_completed, last_used, 0);
+        dma_set_tx_state(txstate, chan->completed_cookie, last_used, 0);
        return mxs_chan->status;
 }
@@ -630,6 +618,7 @@ static int __init mxs_dma_probe(struct platform_device *pdev)
                mxs_chan->mxs_dma = mxs_dma;
                mxs_chan->chan.device = &mxs_dma->dma_device;
+                dma_cookie_init(&mxs_chan->chan);
                tasklet_init(&mxs_chan->tasklet, mxs_dma_tasklet,
                             (unsigned long) mxs_chan);
diff --git a/drivers/dma/pch_dma.c b/drivers/dma/pch_dma.c
index 823f58179f9..c93bb045997 100644
--- a/drivers/dma/pch_dma.c
+++ b/drivers/dma/pch_dma.c
@@ -25,6 +25,8 @@
 #include <linux/module.h>
 #include <linux/pch_dma.h>
+#include "dmaengine.h"
 #define DRV_NAME "pch-dma"
 #define DMA_CTL0_DISABLE                0x0
@@ -105,7 +107,6 @@ struct pch_dma_chan {
        spinlock_t              lock;
-        dma_cookie_t            completed_cookie;
        struct list_head        active_list;
        struct list_head        queue;
        struct list_head        free_list;
@@ -416,20 +417,6 @@ static void pdc_advance_work(struct pch_dma_chan *pd_chan)
        }
 }
-static dma_cookie_t pdc_assign_cookie(struct pch_dma_chan *pd_chan,
-                                      struct pch_dma_desc *desc)
-{
-        dma_cookie_t cookie = pd_chan->chan.cookie;
-        if (++cookie < 0)
-                cookie = 1;
-        pd_chan->chan.cookie = cookie;
-        desc->txd.cookie = cookie;
-        return cookie;
-}
 static dma_cookie_t pd_tx_submit(struct dma_async_tx_descriptor *txd)
 {
        struct pch_dma_desc *desc = to_pd_desc(txd);
@@ -437,7 +424,7 @@ static dma_cookie_t pd_tx_submit(struct dma_async_tx_descriptor *txd)
        dma_cookie_t cookie;
        spin_lock(&pd_chan->lock);
-        cookie = pdc_assign_cookie(pd_chan, desc);
+        cookie = dma_cookie_assign(txd);
        if (list_empty(&pd_chan->active_list)) {
                list_add_tail(&desc->desc_node, &pd_chan->active_list);
@@ -544,7 +531,7 @@ static int pd_alloc_chan_resources(struct dma_chan *chan)
        spin_lock_irq(&pd_chan->lock);
        list_splice(&tmp_list, &pd_chan->free_list);
        pd_chan->descs_allocated = i;
-        pd_chan->completed_cookie = chan->cookie = 1;
+        dma_cookie_init(chan);
        spin_unlock_irq(&pd_chan->lock);
        pdc_enable_irq(chan, 1);
@@ -578,19 +565,12 @@ static enum dma_status pd_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
                                    struct dma_tx_state *txstate)
 {
        struct pch_dma_chan *pd_chan = to_pd_chan(chan);
-        dma_cookie_t last_used;
+        enum dma_status ret;
-        dma_cookie_t last_completed;
-        int ret;
        spin_lock_irq(&pd_chan->lock);
-        last_completed = pd_chan->completed_cookie;
+        ret = dma_cookie_status(chan, cookie, txstate);
-        last_used = chan->cookie;
        spin_unlock_irq(&pd_chan->lock);
-        ret = dma_async_is_complete(cookie, last_completed, last_used);
-        dma_set_tx_state(txstate, last_completed, last_used, 0);
        return ret;
 }
@@ -932,7 +912,7 @@ static int __devinit pch_dma_probe(struct pci_dev *pdev,
                struct pch_dma_chan *pd_chan = &pd->channels[i];
                pd_chan->chan.device = &pd->dma;
-                pd_chan->chan.cookie = 1;
+                dma_cookie_init(&pd_chan->chan);
                pd_chan->membase = &regs->desc[i];
diff --git a/drivers/dma/pl330.c b/drivers/dma/pl330.c
index 7253d17f05f..e863d7fc465 100644
--- a/drivers/dma/pl330.c
+++ b/drivers/dma/pl330.c
@@ -28,6 +28,7 @@
 #include <linux/scatterlist.h>
 #include <linux/of.h>
+#include "dmaengine.h"
 #define PL330_MAX_CHAN          8
 #define PL330_MAX_IRQS          32
 #define PL330_MAX_PERI          32
@@ -285,6 +286,7 @@ static unsigned cmd_line;
 #endif
 /* The number of default descriptors */
 #define NR_DEFAULT_DESC 16
 /* Populated by the PL330 core driver for DMA API driver's info */
@@ -545,9 +547,6 @@ struct dma_pl330_chan {
        /* DMA-Engine Channel */
        struct dma_chan chan;
-        /* Last completed cookie */
-        dma_cookie_t completed;
        /* List of to be xfered descriptors */
        struct list_head work_list;
@@ -2320,7 +2319,7 @@ static void pl330_tasklet(unsigned long data)
        /* Pick up ripe tomatoes */
        list_for_each_entry_safe(desc, _dt, &pch->work_list, node)
                if (desc->status == DONE) {
-                        pch->completed = desc->txd.cookie;
+                        dma_cookie_complete(&desc->txd);
                        list_move_tail(&desc->node, &list);
                }
@@ -2391,7 +2390,7 @@ static int pl330_alloc_chan_resources(struct dma_chan *chan)
        spin_lock_irqsave(&pch->lock, flags);
-        pch->completed = chan->cookie = 1;
+        dma_cookie_init(chan);
        pch->cyclic = false;
        pch->pl330_chid = pl330_request_channel(&pdmac->pif);
@@ -2426,7 +2425,6 @@ static int pl330_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd, unsigned
                /* Mark all desc done */
                list_for_each_entry_safe(desc, _dt, &pch->work_list , node) {
                        desc->status = DONE;
-                        pch->completed = desc->txd.cookie;
                        list_move_tail(&desc->node, &list);
                }
@@ -2482,18 +2480,7 @@ static enum dma_status
 pl330_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
                 struct dma_tx_state *txstate)
 {
-        struct dma_pl330_chan *pch = to_pchan(chan);
+        return dma_cookie_status(chan, cookie, txstate);
-        dma_cookie_t last_done, last_used;
-        int ret;
-        last_done = pch->completed;
-        last_used = chan->cookie;
-        ret = dma_async_is_complete(cookie, last_done, last_used);
-        dma_set_tx_state(txstate, last_done, last_used, 0);
-        return ret;
 }
 static void pl330_issue_pending(struct dma_chan *chan)
@@ -2516,26 +2503,16 @@ static dma_cookie_t pl330_tx_submit(struct dma_async_tx_descriptor *tx)
        spin_lock_irqsave(&pch->lock, flags);
        /* Assign cookies to all nodes */
-        cookie = tx->chan->cookie;
        while (!list_empty(&last->node)) {
                desc = list_entry(last->node.next, struct dma_pl330_desc, node);
-                if (++cookie < 0)
+                dma_cookie_assign(&desc->txd);
-                        cookie = 1;
-                desc->txd.cookie = cookie;
                list_move_tail(&desc->node, &pch->work_list);
        }
-        if (++cookie < 0)
+        cookie = dma_cookie_assign(&last->txd);
-                cookie = 1;
-        last->txd.cookie = cookie;
        list_add_tail(&last->node, &pch->work_list);
-        tx->chan->cookie = cookie;
        spin_unlock_irqrestore(&pch->lock, flags);
        return cookie;
diff --git a/drivers/dma/ppc4xx/adma.c b/drivers/dma/ppc4xx/adma.c
index fc457a7e883..ced98826684 100644
--- a/drivers/dma/ppc4xx/adma.c
+++ b/drivers/dma/ppc4xx/adma.c
@@ -46,6 +46,7 @@
 #include <asm/dcr.h>
 #include <asm/dcr-regs.h>
 #include "adma.h"
+#include "../dmaengine.h"
 enum ppc_adma_init_code {
        PPC_ADMA_INIT_OK = 0,
@@ -1930,7 +1931,7 @@ static void __ppc440spe_adma_slot_cleanup(struct ppc440spe_adma_chan *chan)
                                if (end_of_chain && slot_cnt) {
                                        /* Should wait for ZeroSum completion */
                                        if (cookie > 0)
-                                                chan->completed_cookie = cookie;
+                                                chan->common.completed_cookie = cookie;
                                        return;
                                }
@@ -1960,7 +1961,7 @@ static void __ppc440spe_adma_slot_cleanup(struct ppc440spe_adma_chan *chan)
        BUG_ON(!seen_current);
        if (cookie > 0) {
-                chan->completed_cookie = cookie;
+                chan->common.completed_cookie = cookie;
                pr_debug("\tcompleted cookie %d\n", cookie);
        }
@@ -2150,22 +2151,6 @@ static int ppc440spe_adma_alloc_chan_resources(struct dma_chan *chan)
 }
 /**
- * ppc440spe_desc_assign_cookie - assign a cookie
- */
-static dma_cookie_t ppc440spe_desc_assign_cookie(
-                struct ppc440spe_adma_chan *chan,
-                struct ppc440spe_adma_desc_slot *desc)
-{
-        dma_cookie_t cookie = chan->common.cookie;
-        cookie++;
-        if (cookie < 0)
-                cookie = 1;
-        chan->common.cookie = desc->async_tx.cookie = cookie;
-        return cookie;
-}
-/**
 * ppc440spe_rxor_set_region_data -
 */
 static void ppc440spe_rxor_set_region(struct ppc440spe_adma_desc_slot *desc,
@@ -2235,8 +2220,7 @@ static dma_cookie_t ppc440spe_adma_tx_submit(struct dma_async_tx_descriptor *tx)
        slots_per_op = group_start->slots_per_op;
        spin_lock_bh(&chan->lock);
+        cookie = dma_cookie_assign(tx);
-        cookie = ppc440spe_desc_assign_cookie(chan, sw_desc);
        if (unlikely(list_empty(&chan->chain))) {
                /* first peer */
@@ -3944,28 +3928,16 @@ static enum dma_status ppc440spe_adma_tx_status(struct dma_chan *chan,
                        dma_cookie_t cookie, struct dma_tx_state *txstate)
 {
        struct ppc440spe_adma_chan *ppc440spe_chan;
-        dma_cookie_t last_used;
-        dma_cookie_t last_complete;
        enum dma_status ret;
        ppc440spe_chan = to_ppc440spe_adma_chan(chan);
-        last_used = chan->cookie;
+        ret = dma_cookie_status(chan, cookie, txstate);
-        last_complete = ppc440spe_chan->completed_cookie;
-        dma_set_tx_state(txstate, last_complete, last_used, 0);
-        ret = dma_async_is_complete(cookie, last_complete, last_used);
        if (ret == DMA_SUCCESS)
                return ret;
        ppc440spe_adma_slot_cleanup(ppc440spe_chan);
-        last_used = chan->cookie;
+        return dma_cookie_status(chan, cookie, txstate);
-        last_complete = ppc440spe_chan->completed_cookie;
-        dma_set_tx_state(txstate, last_complete, last_used, 0);
-        return dma_async_is_complete(cookie, last_complete, last_used);
 }
 /**
@@ -4050,16 +4022,12 @@ static void ppc440spe_chan_start_null_xor(struct ppc440spe_adma_chan *chan)
                async_tx_ack(&sw_desc->async_tx);
                ppc440spe_desc_init_null_xor(group_start);
-                cookie = chan->common.cookie;
+                cookie = dma_cookie_assign(&sw_desc->async_tx);
-                cookie++;
-                if (cookie <= 1)
-                        cookie = 2;
                /* initialize the completed cookie to be less than
                 * the most recently used cookie
                 */
-                chan->completed_cookie = cookie - 1;
+                chan->common.completed_cookie = cookie - 1;
-                chan->common.cookie = sw_desc->async_tx.cookie = cookie;
                /* channel should not be busy */
                BUG_ON(ppc440spe_chan_is_busy(chan));
@@ -4529,6 +4497,7 @@ static int __devinit ppc440spe_adma_probe(struct platform_device *ofdev)
        INIT_LIST_HEAD(&chan->all_slots);
        chan->device = adev;
        chan->common.device = &adev->common;
+        dma_cookie_init(&chan->common);
        list_add_tail(&chan->common.device_node, &adev->common.channels);
        tasklet_init(&chan->irq_tasklet, ppc440spe_adma_tasklet,
                     (unsigned long)chan);
diff --git a/drivers/dma/ppc4xx/adma.h b/drivers/dma/ppc4xx/adma.h
index 8ada5a812e3..26b7a5ed9ac 100644
--- a/drivers/dma/ppc4xx/adma.h
+++ b/drivers/dma/ppc4xx/adma.h
@@ -81,7 +81,6 @@ struct ppc440spe_adma_device {
 * @common: common dmaengine channel object members
 * @all_slots: complete domain of slots usable by the channel
 * @pending: allows batching of hardware operations
- * @completed_cookie: identifier for the most recently completed operation
 * @slots_allocated: records the actual size of the descriptor slot pool
 * @hw_chain_inited: h/w descriptor chain initialization flag
 * @irq_tasklet: bottom half where ppc440spe_adma_slot_cleanup runs
@@ -99,7 +98,6 @@ struct ppc440spe_adma_chan {
        struct list_head all_slots;
        struct ppc440spe_adma_desc_slot *last_used;
        int pending;
-        dma_cookie_t completed_cookie;
        int slots_allocated;
        int hw_chain_inited;
        struct tasklet_struct irq_tasklet;
diff --git a/drivers/dma/shdma.c b/drivers/dma/shdma.c
index 812fd76e9c1..5c4088603dd 100644
--- a/drivers/dma/shdma.c
+++ b/drivers/dma/shdma.c
@@ -30,6 +30,8 @@
 #include <linux/kdebug.h>
 #include <linux/spinlock.h>
 #include <linux/rculist.h>
+#include "dmaengine.h"
 #include "shdma.h"
 /* DMA descriptor control */
@@ -296,13 +298,7 @@ static dma_cookie_t sh_dmae_tx_submit(struct dma_async_tx_descriptor *tx)
        else
                power_up = false;
-        cookie = sh_chan->common.cookie;
+        cookie = dma_cookie_assign(tx);
-        cookie++;
-        if (cookie < 0)
-                cookie = 1;
-        sh_chan->common.cookie = cookie;
-        tx->cookie = cookie;
        /* Mark all chunks of this descriptor as submitted, move to the queue */
        list_for_each_entry_safe(chunk, c, desc->node.prev, node) {
@@ -764,12 +760,12 @@ static dma_async_tx_callback __ld_cleanup(struct sh_dmae_chan *sh_chan, bool all
                        cookie = tx->cookie;
                if (desc->mark == DESC_COMPLETED && desc->chunks == 1) {
-                        if (sh_chan->completed_cookie != desc->cookie - 1)
+                        if (sh_chan->common.completed_cookie != desc->cookie - 1)
                                dev_dbg(sh_chan->dev,
                                        "Completing cookie %d, expected %d\n",
                                        desc->cookie,
-                                        sh_chan->completed_cookie + 1);
+                                        sh_chan->common.completed_cookie + 1);
-                        sh_chan->completed_cookie = desc->cookie;
+                        sh_chan->common.completed_cookie = desc->cookie;
                }
                /* Call callback on the last chunk */
@@ -823,7 +819,7 @@ static dma_async_tx_callback __ld_cleanup(struct sh_dmae_chan *sh_chan, bool all
                 * Terminating and the loop completed normally: forgive
                 * uncompleted cookies
                 */
-                sh_chan->completed_cookie = sh_chan->common.cookie;
+                sh_chan->common.completed_cookie = sh_chan->common.cookie;
        spin_unlock_irqrestore(&sh_chan->desc_lock, flags);
@@ -883,23 +879,14 @@ static enum dma_status sh_dmae_tx_status(struct dma_chan *chan,
                                        struct dma_tx_state *txstate)
 {
        struct sh_dmae_chan *sh_chan = to_sh_chan(chan);
-        dma_cookie_t last_used;
-        dma_cookie_t last_complete;
        enum dma_status status;
        unsigned long flags;
        sh_dmae_chan_ld_cleanup(sh_chan, false);
-        /* First read completed cookie to avoid a skew */
-        last_complete = sh_chan->completed_cookie;
-        rmb();
-        last_used = chan->cookie;
-        BUG_ON(last_complete < 0);
-        dma_set_tx_state(txstate, last_complete, last_used, 0);
        spin_lock_irqsave(&sh_chan->desc_lock, flags);
-        status = dma_async_is_complete(cookie, last_complete, last_used);
+        status = dma_cookie_status(chan, cookie, txstate);
        /*
         * If we don't find cookie on the queue, it has been aborted and we have
@@ -1102,6 +1089,7 @@ static int __devinit sh_dmae_chan_probe(struct sh_dmae_device *shdev, int id,
        /* reference struct dma_device */
        new_sh_chan->common.device = &shdev->common;
+        dma_cookie_init(&new_sh_chan->common);
        new_sh_chan->dev = shdev->common.dev;
        new_sh_chan->id = id;
diff --git a/drivers/dma/shdma.h b/drivers/dma/shdma.h
index 2b55a276dc5..0b1d2c105f0 100644
--- a/drivers/dma/shdma.h
+++ b/drivers/dma/shdma.h
@@ -30,7 +30,6 @@ enum dmae_pm_state {
 };
 struct sh_dmae_chan {
-        dma_cookie_t completed_cookie;  /* The maximum cookie completed */
        spinlock_t desc_lock;           /* Descriptor operation lock */
        struct list_head ld_queue;      /* Link descriptors queue */
        struct list_head ld_free;       /* Link descriptors free */
diff --git a/drivers/dma/sirf-dma.c b/drivers/dma/sirf-dma.c
index 2333810d168..45ba352fb87 100644
--- a/drivers/dma/sirf-dma.c
+++ b/drivers/dma/sirf-dma.c
@@ -18,6 +18,8 @@
 #include <linux/of_platform.h>
 #include <linux/sirfsoc_dma.h>
+#include "dmaengine.h"
 #define SIRFSOC_DMA_DESCRIPTORS                 16
 #define SIRFSOC_DMA_CHANNELS                    16
@@ -59,7 +61,6 @@ struct sirfsoc_dma_chan {
        struct list_head                queued;
        struct list_head                active;
        struct list_head                completed;
-        dma_cookie_t                    completed_cookie;
        unsigned long                   happened_cyclic;
        unsigned long                   completed_cyclic;
@@ -208,7 +209,7 @@ static void sirfsoc_dma_process_completed(struct sirfsoc_dma *sdma)
                        /* Free descriptors */
                        spin_lock_irqsave(&schan->lock, flags);
                        list_splice_tail_init(&list, &schan->free);
-                        schan->completed_cookie = last_cookie;
+                        schan->chan.completed_cookie = last_cookie;
                        spin_unlock_irqrestore(&schan->lock, flags);
                } else {
                        /* for cyclic channel, desc is always in active list */
@@ -258,13 +259,7 @@ static dma_cookie_t sirfsoc_dma_tx_submit(struct dma_async_tx_descriptor *txd)
        /* Move descriptor to queue */
        list_move_tail(&sdesc->node, &schan->queued);
-        /* Update cookie */
+        cookie = dma_cookie_assign(txd);
-        cookie = schan->chan.cookie + 1;
-        if (cookie <= 0)
-                cookie = 1;
-        schan->chan.cookie = cookie;
-        sdesc->desc.cookie = cookie;
        spin_unlock_irqrestore(&schan->lock, flags);
@@ -414,16 +409,13 @@ sirfsoc_dma_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
 {
        struct sirfsoc_dma_chan *schan = dma_chan_to_sirfsoc_dma_chan(chan);
        unsigned long flags;
-        dma_cookie_t last_used;
+        enum dma_status ret;
-        dma_cookie_t last_complete;
        spin_lock_irqsave(&schan->lock, flags);
-        last_used = schan->chan.cookie;
+        ret = dma_cookie_status(chan, cookie, txstate);
-        last_complete = schan->completed_cookie;
        spin_unlock_irqrestore(&schan->lock, flags);
-        dma_set_tx_state(txstate, last_complete, last_used, 0);
+        return ret;
-        return dma_async_is_complete(cookie, last_complete, last_used);
 }
 static struct dma_async_tx_descriptor *sirfsoc_dma_prep_interleaved(
@@ -635,8 +627,7 @@ static int __devinit sirfsoc_dma_probe(struct platform_device *op)
                schan = &sdma->channels[i];
                schan->chan.device = dma;
-                schan->chan.cookie = 1;
+                dma_cookie_init(&schan->chan);
-                schan->completed_cookie = schan->chan.cookie;
                INIT_LIST_HEAD(&schan->free);
                INIT_LIST_HEAD(&schan->prepared);
diff --git a/drivers/dma/ste_dma40.c b/drivers/dma/ste_dma40.c
index cc5ecbc067a..1ea6d02d08a 100644
--- a/drivers/dma/ste_dma40.c
+++ b/drivers/dma/ste_dma40.c
@@ -21,6 +21,7 @@
 #include <plat/ste_dma40.h>
+#include "dmaengine.h"
 #include "ste_dma40_ll.h"
 #define D40_NAME "dma40"
@@ -220,8 +221,6 @@ struct d40_base;
 *
 * @lock: A spinlock to protect this struct.
 * @log_num: The logical number, if any of this channel.
- * @completed: Starts with 1, after first interrupt it is set to dma engine's
- * current cookie.
 * @pending_tx: The number of pending transfers. Used between interrupt handler
 * and tasklet.
 * @busy: Set to true when transfer is ongoing on this channel.
@@ -250,8 +249,6 @@ struct d40_base;
 struct d40_chan {
        spinlock_t                       lock;
        int                              log_num;
-        /* ID of the most recent completed transfer */
-        int                              completed;
        int                              pending_tx;
        bool                             busy;
        struct d40_phy_res              *phy_chan;
@@ -1223,21 +1220,14 @@ static dma_cookie_t d40_tx_submit(struct dma_async_tx_descriptor *tx)
                                             chan);
        struct d40_desc *d40d = container_of(tx, struct d40_desc, txd);
        unsigned long flags;
+        dma_cookie_t cookie;
        spin_lock_irqsave(&d40c->lock, flags);
+        cookie = dma_cookie_assign(tx);
-        d40c->chan.cookie++;
-        if (d40c->chan.cookie < 0)
-                d40c->chan.cookie = 1;
-        d40d->txd.cookie = d40c->chan.cookie;
        d40_desc_queue(d40c, d40d);
        spin_unlock_irqrestore(&d40c->lock, flags);
-        return tx->cookie;
+        return cookie;
 }
 static int d40_start(struct d40_chan *d40c)
@@ -1357,7 +1347,7 @@ static void dma_tasklet(unsigned long data)
                goto err;
        if (!d40d->cyclic)
-                d40c->completed = d40d->txd.cookie;
+                dma_cookie_complete(&d40d->txd);
        /*
         * If terminating a channel pending_tx is set to zero.
@@ -2182,7 +2172,7 @@ static int d40_alloc_chan_resources(struct dma_chan *chan)
        bool is_free_phy;
        spin_lock_irqsave(&d40c->lock, flags);
-        d40c->completed = chan->cookie = 1;
+        dma_cookie_init(chan);
        /* If no dma configuration is set use default configuration (memcpy) */
        if (!d40c->configured) {
@@ -2342,25 +2332,19 @@ static enum dma_status d40_tx_status(struct dma_chan *chan,
                                     struct dma_tx_state *txstate)
 {
        struct d40_chan *d40c = container_of(chan, struct d40_chan, chan);
-        dma_cookie_t last_used;
+        enum dma_status ret;
-        dma_cookie_t last_complete;
-        int ret;
        if (d40c->phy_chan == NULL) {
                chan_err(d40c, "Cannot read status of unallocated channel\n");
                return -EINVAL;
        }
-        last_complete = d40c->completed;
+        ret = dma_cookie_status(chan, cookie, txstate);
-        last_used = chan->cookie;
+        if (ret != DMA_SUCCESS)
+                dma_set_residue(txstate, stedma40_residue(chan));
        if (d40_is_paused(d40c))
                ret = DMA_PAUSED;
-        else
-                ret = dma_async_is_complete(cookie, last_complete, last_used);
-        dma_set_tx_state(txstate, last_complete, last_used,
-                         stedma40_residue(chan));
        return ret;
 }
diff --git a/drivers/dma/timb_dma.c b/drivers/dma/timb_dma.c
index a6f9c1684a0..d408c220602 100644
--- a/drivers/dma/timb_dma.c
+++ b/drivers/dma/timb_dma.c
@@ -31,6 +31,8 @@
 #include <linux/timb_dma.h>
+#include "dmaengine.h"
 #define DRIVER_NAME "timb-dma"
 /* Global DMA registers */
@@ -84,7 +86,6 @@ struct timb_dma_chan {
                                        especially the lists and descriptors,
                                        from races between the tasklet and calls
                                        from above */
-        dma_cookie_t            last_completed_cookie;
        bool                    ongoing;
        struct list_head        active_list;
        struct list_head        queue;
@@ -284,7 +285,7 @@ static void __td_finish(struct timb_dma_chan *td_chan)
        else
                iowrite32(0, td_chan->membase + TIMBDMA_OFFS_TX_DLAR);
 */
-        td_chan->last_completed_cookie = txd->cookie;
+        dma_cookie_complete(txd);
        td_chan->ongoing = false;
        callback = txd->callback;
@@ -349,12 +350,7 @@ static dma_cookie_t td_tx_submit(struct dma_async_tx_descriptor *txd)
        dma_cookie_t cookie;
        spin_lock_bh(&td_chan->lock);
+        cookie = dma_cookie_assign(txd);
-        cookie = txd->chan->cookie;
-        if (++cookie < 0)
-                cookie = 1;
-        txd->chan->cookie = cookie;
-        txd->cookie = cookie;
        if (list_empty(&td_chan->active_list)) {
                dev_dbg(chan2dev(txd->chan), "%s: started %u\n", __func__,
@@ -481,8 +477,7 @@ static int td_alloc_chan_resources(struct dma_chan *chan)
        }
        spin_lock_bh(&td_chan->lock);
-        td_chan->last_completed_cookie = 1;
+        dma_cookie_init(chan);
-        chan->cookie = 1;
        spin_unlock_bh(&td_chan->lock);
        return 0;
@@ -515,24 +510,13 @@ static void td_free_chan_resources(struct dma_chan *chan)
 static enum dma_status td_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
                                    struct dma_tx_state *txstate)
 {
-        struct timb_dma_chan *td_chan =
+        enum dma_status ret;
-                container_of(chan, struct timb_dma_chan, chan);
-        dma_cookie_t            last_used;
-        dma_cookie_t            last_complete;
-        int                     ret;
        dev_dbg(chan2dev(chan), "%s: Entry\n", __func__);
-        last_complete = td_chan->last_completed_cookie;
+        ret = dma_cookie_status(chan, cookie, txstate);
-        last_used = chan->cookie;
-        ret = dma_async_is_complete(cookie, last_complete, last_used);
-        dma_set_tx_state(txstate, last_complete, last_used, 0);
-        dev_dbg(chan2dev(chan),
+        dev_dbg(chan2dev(chan), "%s: exit, ret: %d\n",  __func__, ret);
-                "%s: exit, ret: %d, last_complete: %d, last_used: %d\n",
-                __func__, ret, last_complete, last_used);
        return ret;
 }
@@ -766,7 +750,7 @@ static int __devinit td_probe(struct platform_device *pdev)
                }
                td_chan->chan.device = &td->dma;
-                td_chan->chan.cookie = 1;
+                dma_cookie_init(&td_chan->chan);
                spin_lock_init(&td_chan->lock);
                INIT_LIST_HEAD(&td_chan->active_list);
                INIT_LIST_HEAD(&td_chan->queue);
diff --git a/drivers/dma/txx9dmac.c b/drivers/dma/txx9dmac.c
index 6122c364cf1..40440f94638 100644
--- a/drivers/dma/txx9dmac.c
+++ b/drivers/dma/txx9dmac.c
@@ -15,6 +15,8 @@
 #include <linux/platform_device.h>
 #include <linux/slab.h>
 #include <linux/scatterlist.h>
+#include "dmaengine.h"
 #include "txx9dmac.h"
 static struct txx9dmac_chan *to_txx9dmac_chan(struct dma_chan *chan)
@@ -279,21 +281,6 @@ static void txx9dmac_desc_put(struct txx9dmac_chan *dc,
        }
 }
-/* Called with dc->lock held and bh disabled */
-static dma_cookie_t
-txx9dmac_assign_cookie(struct txx9dmac_chan *dc, struct txx9dmac_desc *desc)
-{
-        dma_cookie_t cookie = dc->chan.cookie;
-        if (++cookie < 0)
-                cookie = 1;
-        dc->chan.cookie = cookie;
-        desc->txd.cookie = cookie;
-        return cookie;
-}
 /*----------------------------------------------------------------------*/
 static void txx9dmac_dump_regs(struct txx9dmac_chan *dc)
@@ -424,7 +411,7 @@ txx9dmac_descriptor_complete(struct txx9dmac_chan *dc,
        dev_vdbg(chan2dev(&dc->chan), "descriptor %u %p complete\n",
                 txd->cookie, desc);
-        dc->completed = txd->cookie;
+        dma_cookie_complete(txd);
        callback = txd->callback;
        param = txd->callback_param;
@@ -738,7 +725,7 @@ static dma_cookie_t txx9dmac_tx_submit(struct dma_async_tx_descriptor *tx)
        dma_cookie_t cookie;
        spin_lock_bh(&dc->lock);
-        cookie = txx9dmac_assign_cookie(dc, desc);
+        cookie = dma_cookie_assign(tx);
        dev_vdbg(chan2dev(tx->chan), "tx_submit: queued %u %p\n",
                 desc->txd.cookie, desc);
@@ -972,27 +959,17 @@ txx9dmac_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
                   struct dma_tx_state *txstate)
 {
        struct txx9dmac_chan *dc = to_txx9dmac_chan(chan);
-        dma_cookie_t last_used;
+        enum dma_status ret;
-        dma_cookie_t last_complete;
-        int ret;
-        last_complete = dc->completed;
+        ret = dma_cookie_status(chan, cookie, txstate);
-        last_used = chan->cookie;
-        ret = dma_async_is_complete(cookie, last_complete, last_used);
        if (ret != DMA_SUCCESS) {
                spin_lock_bh(&dc->lock);
                txx9dmac_scan_descriptors(dc);
                spin_unlock_bh(&dc->lock);
-                last_complete = dc->completed;
+                ret = dma_cookie_status(chan, cookie, txstate);
-                last_used = chan->cookie;
-                ret = dma_async_is_complete(cookie, last_complete, last_used);
        }
-        dma_set_tx_state(txstate, last_complete, last_used, 0);
        return ret;
 }
@@ -1057,7 +1034,7 @@ static int txx9dmac_alloc_chan_resources(struct dma_chan *chan)
                return -EIO;
        }
-        dc->completed = chan->cookie = 1;
+        dma_cookie_init(chan);
        dc->ccr = TXX9_DMA_CCR_IMMCHN | TXX9_DMA_CCR_INTENE | CCR_LE;
        txx9dmac_chan_set_SMPCHN(dc);
@@ -1186,7 +1163,7 @@ static int __init txx9dmac_chan_probe(struct platform_device *pdev)
        dc->ddev->chan[ch] = dc;
        dc->chan.device = &dc->dma;
        list_add_tail(&dc->chan.device_node, &dc->chan.device->channels);
-        dc->chan.cookie = dc->completed = 1;
+        dma_cookie_init(&dc->chan);
        if (is_dmac64(dc))
                dc->ch_regs = &__txx9dmac_regs(dc->ddev)->CHAN[ch];
diff --git a/drivers/dma/txx9dmac.h b/drivers/dma/txx9dmac.h
index 365d42366b9..f5a76059888 100644
--- a/drivers/dma/txx9dmac.h
+++ b/drivers/dma/txx9dmac.h
@@ -172,7 +172,6 @@ struct txx9dmac_chan {
        spinlock_t              lock;
        /* these other elements are all protected by lock */
-        dma_cookie_t            completed;
        struct list_head        active_list;
        struct list_head        queue;
        struct list_head        free_list;
diff --git a/include/linux/amba/pl08x.h b/include/linux/amba/pl08x.h
index 2c58853ca42..e64ce2cfee9 100644
--- a/include/linux/amba/pl08x.h
+++ b/include/linux/amba/pl08x.h
@@ -172,7 +172,6 @@ enum pl08x_dma_chan_state {
 * @runtime_addr: address for RX/TX according to the runtime config
 * @runtime_direction: current direction of this channel according to
 * runtime config
- * @lc: last completed transaction on this channel
 * @pend_list: queued transactions pending on this channel
 * @at: active transaction on this channel
 * @lock: a lock for this channel data
@@ -197,7 +196,6 @@ struct pl08x_dma_chan {
        u32 src_cctl;
        u32 dst_cctl;
        enum dma_transfer_direction runtime_direction;
-        dma_cookie_t lc;
        struct list_head pend_list;
        struct pl08x_txd *at;
        spinlock_t lock;
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index 7e640bf27d2..715babf4bff 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -18,8 +18,8 @@
 * The full GNU General Public License is included in this distribution in the
 * file called COPYING.
 */
-#ifndef DMAENGINE_H
+#ifndef LINUX_DMAENGINE_H
-#define DMAENGINE_H
+#define LINUX_DMAENGINE_H
 #include <linux/device.h>
 #include <linux/uio.h>
@@ -258,6 +258,7 @@ struct dma_chan_percpu {
 * struct dma_chan - devices supply DMA channels, clients use them
 * @device: ptr to the dma device who supplies this channel, always !%NULL
 * @cookie: last cookie value returned to client
+ * @completed_cookie: last completed cookie for this channel
 * @chan_id: channel ID for sysfs
 * @dev: class device for sysfs
 * @device_node: used to add this to the device chan list
@@ -269,6 +270,7 @@ struct dma_chan_percpu {
 struct dma_chan {
        struct dma_device *device;
        dma_cookie_t cookie;
+        dma_cookie_t completed_cookie;
        /* sysfs */
        int chan_id;