2
0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-24 05:04:00 +08:00

Merge branch 'rmk_cookie_fixes2' into next

Conflicts:
	drivers/dma/imx-dma.c
	drivers/dma/pl330.c

Signed-off-by: Vinod Koul <vinod.koul@linux.intel.com>
This commit is contained in:
Vinod Koul 2012-03-13 12:39:49 +05:30
commit 1f3d6dc0be
38 changed files with 299 additions and 639 deletions

View File

@ -49,7 +49,6 @@ struct iop_adma_device {
/** /**
* struct iop_adma_chan - internal representation of an ADMA device * struct iop_adma_chan - internal representation of an ADMA device
* @pending: allows batching of hardware operations * @pending: allows batching of hardware operations
* @completed_cookie: identifier for the most recently completed operation
* @lock: serializes enqueue/dequeue operations to the slot pool * @lock: serializes enqueue/dequeue operations to the slot pool
* @mmr_base: memory mapped register base * @mmr_base: memory mapped register base
* @chain: device chain view of the descriptors * @chain: device chain view of the descriptors
@ -62,7 +61,6 @@ struct iop_adma_device {
*/ */
struct iop_adma_chan { struct iop_adma_chan {
int pending; int pending;
dma_cookie_t completed_cookie;
spinlock_t lock; /* protects the descriptor slot pool */ spinlock_t lock; /* protects the descriptor slot pool */
void __iomem *mmr_base; void __iomem *mmr_base;
struct list_head chain; struct list_head chain;

View File

@ -85,6 +85,8 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <asm/hardware/pl080.h> #include <asm/hardware/pl080.h>
#include "dmaengine.h"
#define DRIVER_NAME "pl08xdmac" #define DRIVER_NAME "pl08xdmac"
static struct amba_driver pl08x_amba_driver; 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_dma_chan *plchan = to_pl08x_chan(tx->chan);
struct pl08x_txd *txd = to_pl08x_txd(tx); struct pl08x_txd *txd = to_pl08x_txd(tx);
unsigned long flags; unsigned long flags;
dma_cookie_t cookie;
spin_lock_irqsave(&plchan->lock, flags); 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 */ /* Put this onto the pending list */
list_add_tail(&txd->node, &plchan->pend_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); spin_unlock_irqrestore(&plchan->lock, flags);
return tx->cookie; return cookie;
} }
static struct dma_async_tx_descriptor *pl08x_prep_dma_interrupt( 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) dma_cookie_t cookie, struct dma_tx_state *txstate)
{ {
struct pl08x_dma_chan *plchan = to_pl08x_chan(chan); struct pl08x_dma_chan *plchan = to_pl08x_chan(chan);
dma_cookie_t last_used;
dma_cookie_t last_complete;
enum dma_status ret; enum dma_status ret;
u32 bytesleft = 0;
last_used = plchan->chan.cookie; ret = dma_cookie_status(chan, cookie, txstate);
last_complete = plchan->lc; if (ret == DMA_SUCCESS)
ret = dma_async_is_complete(cookie, last_complete, last_used);
if (ret == DMA_SUCCESS) {
dma_set_tx_state(txstate, last_complete, last_used, 0);
return ret; return ret;
}
/* /*
* This cookie not complete yet * 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) if (plchan->state == PL08X_CHAN_PAUSED)
return DMA_PAUSED; return DMA_PAUSED;
@ -1543,7 +1528,7 @@ static void pl08x_tasklet(unsigned long data)
if (txd) { if (txd) {
/* Update last completed */ /* 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 */ /* 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->name);
chan->chan.device = dmadev; chan->chan.device = dmadev;
chan->chan.cookie = 0; dma_cookie_init(&chan->chan);
chan->lc = 0;
spin_lock_init(&chan->lock); spin_lock_init(&chan->lock);
INIT_LIST_HEAD(&chan->pend_list); INIT_LIST_HEAD(&chan->pend_list);

View File

@ -27,6 +27,7 @@
#include <linux/of_device.h> #include <linux/of_device.h>
#include "at_hdmac_regs.h" #include "at_hdmac_regs.h"
#include "dmaengine.h"
/* /*
* Glossary * Glossary
@ -191,27 +192,6 @@ static void atc_desc_chain(struct at_desc **first, struct at_desc **prev,
*prev = desc; *prev = desc;
} }
/**
* 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 * atc_dostart - starts the DMA engine for real
* @atchan: the channel we want to start * @atchan: the channel we want to start
@ -269,7 +249,7 @@ atc_chain_complete(struct at_dma_chan *atchan, struct at_desc *desc)
dev_vdbg(chan2dev(&atchan->chan_common), dev_vdbg(chan2dev(&atchan->chan_common),
"descriptor %u complete\n", txd->cookie); "descriptor %u complete\n", txd->cookie);
atchan->completed_cookie = txd->cookie; dma_cookie_complete(txd);
/* move children to free_list */ /* move children to free_list */
list_splice_init(&desc->tx_list, &atchan->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; unsigned long flags;
spin_lock_irqsave(&atchan->lock, flags); spin_lock_irqsave(&atchan->lock, flags);
cookie = atc_assign_cookie(atchan, desc); cookie = dma_cookie_assign(tx);
if (list_empty(&atchan->active_list)) { if (list_empty(&atchan->active_list)) {
dev_vdbg(chan2dev(tx->chan), "tx_submit: started %u\n", 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); 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) { if (ret != DMA_SUCCESS) {
atc_cleanup_descriptors(atchan); 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); spin_unlock_irqrestore(&atchan->lock, flags);
if (ret != DMA_SUCCESS) 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)) if (atc_chan_is_paused(atchan))
ret = DMA_PAUSED; ret = DMA_PAUSED;
@ -1129,7 +1103,7 @@ static int atc_alloc_chan_resources(struct dma_chan *chan)
spin_lock_irqsave(&atchan->lock, flags); spin_lock_irqsave(&atchan->lock, flags);
atchan->descs_allocated = i; atchan->descs_allocated = i;
list_splice(&tmp_list, &atchan->free_list); list_splice(&tmp_list, &atchan->free_list);
atchan->completed_cookie = chan->cookie = 1; dma_cookie_init(chan);
spin_unlock_irqrestore(&atchan->lock, flags); spin_unlock_irqrestore(&atchan->lock, flags);
/* channel parameters */ /* channel parameters */
@ -1329,7 +1303,7 @@ static int __init at_dma_probe(struct platform_device *pdev)
struct at_dma_chan *atchan = &atdma->chan[i]; struct at_dma_chan *atchan = &atdma->chan[i];
atchan->chan_common.device = &atdma->dma_common; 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, list_add_tail(&atchan->chan_common.device_node,
&atdma->dma_common.channels); &atdma->dma_common.channels);

View File

@ -208,7 +208,6 @@ enum atc_status {
* @save_dscr: for cyclic operations, preserve next descriptor address in * @save_dscr: for cyclic operations, preserve next descriptor address in
* the cyclic list on suspend/resume cycle * the cyclic list on suspend/resume cycle
* @lock: serializes enqueue/dequeue operations to descriptors lists * @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 * @active_list: list of descriptors dmaengine is being running on
* @queue: list of descriptors ready to be submitted to engine * @queue: list of descriptors ready to be submitted to engine
* @free_list: list of descriptors usable by the channel * @free_list: list of descriptors usable by the channel
@ -227,7 +226,6 @@ struct at_dma_chan {
spinlock_t lock; spinlock_t lock;
/* these other elements are all protected by lock */ /* these other elements are all protected by lock */
dma_cookie_t completed_cookie;
struct list_head active_list; struct list_head active_list;
struct list_head queue; struct list_head queue;
struct list_head free_list; struct list_head free_list;

View File

@ -24,6 +24,7 @@
#include <mach/coh901318.h> #include <mach/coh901318.h>
#include "coh901318_lli.h" #include "coh901318_lli.h"
#include "dmaengine.h"
#define COHC_2_DEV(cohc) (&cohc->chan.dev->device) #define COHC_2_DEV(cohc) (&cohc->chan.dev->device)
@ -59,7 +60,6 @@ struct coh901318_base {
struct coh901318_chan { struct coh901318_chan {
spinlock_t lock; spinlock_t lock;
int allocated; int allocated;
int completed;
int id; int id;
int stopped; int stopped;
@ -318,20 +318,6 @@ static int coh901318_prep_linked_list(struct coh901318_chan *cohc,
return 0; 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 * static struct coh901318_desc *
coh901318_desc_get(struct coh901318_chan *cohc) 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; callback_param = cohd_fin->desc.callback_param;
/* sign this job as completed on the channel */ /* 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 */ /* release the lli allocation and remove the descriptor */
coh901318_lli_free(&cohc->base->pool, &cohd_fin->lli); 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); coh901318_config(cohc, NULL);
cohc->allocated = 1; cohc->allocated = 1;
cohc->completed = chan->cookie = 1; dma_cookie_init(chan);
spin_unlock_irqrestore(&cohc->lock, flags); spin_unlock_irqrestore(&cohc->lock, flags);
@ -966,16 +952,16 @@ coh901318_tx_submit(struct dma_async_tx_descriptor *tx)
desc); desc);
struct coh901318_chan *cohc = to_coh901318_chan(tx->chan); struct coh901318_chan *cohc = to_coh901318_chan(tx->chan);
unsigned long flags; unsigned long flags;
dma_cookie_t cookie;
spin_lock_irqsave(&cohc->lock, flags); spin_lock_irqsave(&cohc->lock, flags);
cookie = dma_cookie_assign(tx);
tx->cookie = coh901318_assign_cookie(cohc, cohd);
coh901318_desc_queue(cohc, cohd); coh901318_desc_queue(cohc, cohd);
spin_unlock_irqrestore(&cohc->lock, flags); spin_unlock_irqrestore(&cohc->lock, flags);
return tx->cookie; return cookie;
} }
static struct dma_async_tx_descriptor * 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 dma_tx_state *txstate)
{ {
struct coh901318_chan *cohc = to_coh901318_chan(chan); 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; ret = dma_cookie_status(chan, cookie, txstate);
last_used = chan->cookie; /* FIXME: should be conditional on ret != DMA_SUCCESS? */
dma_set_residue(txstate, coh901318_get_bytes_left(chan));
ret = dma_async_is_complete(cookie, last_complete, last_used);
dma_set_tx_state(txstate, last_complete, last_used,
coh901318_get_bytes_left(chan));
if (ret == DMA_IN_PROGRESS && cohc->stopped) if (ret == DMA_IN_PROGRESS && cohc->stopped)
ret = DMA_PAUSED; ret = DMA_PAUSED;

89
drivers/dma/dmaengine.h Normal file
View File

@ -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

View File

@ -23,6 +23,7 @@
#include <linux/slab.h> #include <linux/slab.h>
#include "dw_dmac_regs.h" #include "dw_dmac_regs.h"
#include "dmaengine.h"
/* /*
* This supports the Synopsys "DesignWare AHB Central DMA Controller", * 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) static void dwc_initialize(struct dw_dma_chan *dwc)
{ {
struct dw_dma *dw = to_dw_dma(dwc->chan.device); 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); dev_vdbg(chan2dev(&dwc->chan), "descriptor %u complete\n", txd->cookie);
spin_lock_irqsave(&dwc->lock, flags); spin_lock_irqsave(&dwc->lock, flags);
dwc->completed = txd->cookie; dma_cookie_complete(txd);
if (callback_required) { if (callback_required) {
callback = txd->callback; callback = txd->callback;
param = txd->callback_param; param = txd->callback_param;
@ -602,7 +588,7 @@ static dma_cookie_t dwc_tx_submit(struct dma_async_tx_descriptor *tx)
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&dwc->lock, 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 * 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 dma_tx_state *txstate)
{ {
struct dw_dma_chan *dwc = to_dw_dma_chan(chan); 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; 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) { if (ret != DMA_SUCCESS) {
dwc_scan_descriptors(to_dw_dma(chan->device), dwc); 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) 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) if (dwc->paused)
return DMA_PAUSED; return DMA_PAUSED;
@ -1046,7 +1021,7 @@ static int dwc_alloc_chan_resources(struct dma_chan *chan)
return -EIO; return -EIO;
} }
dwc->completed = chan->cookie = 1; dma_cookie_init(chan);
/* /*
* NOTE: some controllers may have additional features that we * 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]; struct dw_dma_chan *dwc = &dw->chan[i];
dwc->chan.device = &dw->dma; dwc->chan.device = &dw->dma;
dwc->chan.cookie = dwc->completed = 1; dma_cookie_init(&dwc->chan);
if (pdata->chan_allocation_order == CHAN_ALLOCATION_ASCENDING) if (pdata->chan_allocation_order == CHAN_ALLOCATION_ASCENDING)
list_add_tail(&dwc->chan.device_node, list_add_tail(&dwc->chan.device_node,
&dw->dma.channels); &dw->dma.channels);

View File

@ -158,7 +158,6 @@ struct dw_dma_chan {
/* these other elements are all protected by lock */ /* these other elements are all protected by lock */
unsigned long flags; unsigned long flags;
dma_cookie_t completed;
struct list_head active_list; struct list_head active_list;
struct list_head queue; struct list_head queue;
struct list_head free_list; struct list_head free_list;

View File

@ -28,6 +28,8 @@
#include <mach/dma.h> #include <mach/dma.h>
#include "dmaengine.h"
/* M2P registers */ /* M2P registers */
#define M2P_CONTROL 0x0000 #define M2P_CONTROL 0x0000
#define M2P_CONTROL_STALLINT BIT(0) #define M2P_CONTROL_STALLINT BIT(0)
@ -122,7 +124,6 @@ struct ep93xx_dma_desc {
* @lock: lock protecting the fields following * @lock: lock protecting the fields following
* @flags: flags for the channel * @flags: flags for the channel
* @buffer: which buffer to use next (0/1) * @buffer: which buffer to use next (0/1)
* @last_completed: last completed cookie value
* @active: flattened chain of descriptors currently being processed * @active: flattened chain of descriptors currently being processed
* @queue: pending descriptors which are handled next * @queue: pending descriptors which are handled next
* @free_list: list of free descriptors which can be used * @free_list: list of free descriptors which can be used
@ -157,7 +158,6 @@ struct ep93xx_dma_chan {
#define EP93XX_DMA_IS_CYCLIC 0 #define EP93XX_DMA_IS_CYCLIC 0
int buffer; int buffer;
dma_cookie_t last_completed;
struct list_head active; struct list_head active;
struct list_head queue; struct list_head queue;
struct list_head free_list; struct list_head free_list;
@ -703,7 +703,7 @@ static void ep93xx_dma_tasklet(unsigned long data)
desc = ep93xx_dma_get_active(edmac); desc = ep93xx_dma_get_active(edmac);
if (desc) { if (desc) {
if (desc->complete) { if (desc->complete) {
edmac->last_completed = desc->txd.cookie; dma_cookie_complete(&desc->txd);
list_splice_init(&edmac->active, &list); list_splice_init(&edmac->active, &list);
} }
callback = desc->txd.callback; 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; unsigned long flags;
spin_lock_irqsave(&edmac->lock, 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); 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 * If nothing is currently prosessed, we push this descriptor
* directly to the hardware. Otherwise we put the 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; goto fail_clk_disable;
spin_lock_irq(&edmac->lock); spin_lock_irq(&edmac->lock);
edmac->last_completed = 1; dma_cookie_init(&edmac->chan);
edmac->chan.cookie = 1;
ret = edmac->edma->hw_setup(edmac); ret = edmac->edma->hw_setup(edmac);
spin_unlock_irq(&edmac->lock); 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 dma_tx_state *state)
{ {
struct ep93xx_dma_chan *edmac = to_ep93xx_dma_chan(chan); struct ep93xx_dma_chan *edmac = to_ep93xx_dma_chan(chan);
dma_cookie_t last_used, last_completed;
enum dma_status ret; enum dma_status ret;
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&edmac->lock, 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); 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; return ret;
} }

View File

@ -35,6 +35,7 @@
#include <linux/dmapool.h> #include <linux/dmapool.h>
#include <linux/of_platform.h> #include <linux/of_platform.h>
#include "dmaengine.h"
#include "fsldma.h" #include "fsldma.h"
#define chan_dbg(chan, fmt, arg...) \ #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 * assign cookies to all of the software descriptors
* that make up this transaction * that make up this transaction
*/ */
cookie = chan->common.cookie;
list_for_each_entry(child, &desc->tx_list, node) { 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 */ /* put this transaction onto the tail of the pending queue */
append_ld_queue(chan, desc); 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 dma_tx_state *txstate)
{ {
struct fsldma_chan *chan = to_fsl_chan(dchan); 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; unsigned long flags;
spin_lock_irqsave(&chan->desc_lock, 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); 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); desc = to_fsl_desc(chan->ld_running.prev);
cookie = desc->async_tx.cookie; cookie = desc->async_tx.cookie;
dma_cookie_complete(&desc->async_tx);
chan->completed_cookie = cookie;
chan_dbg(chan, "completed_cookie=%d\n", 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->idle = true;
chan->common.device = &fdev->common; chan->common.device = &fdev->common;
dma_cookie_init(&chan->common);
/* find the IRQ line, if it exists in the device tree */ /* find the IRQ line, if it exists in the device tree */
chan->irq = irq_of_parse_and_map(node, 0); chan->irq = irq_of_parse_and_map(node, 0);

View File

@ -137,7 +137,6 @@ struct fsldma_device {
struct fsldma_chan { struct fsldma_chan {
char name[8]; /* Channel name */ char name[8]; /* Channel name */
struct fsldma_chan_regs __iomem *regs; struct fsldma_chan_regs __iomem *regs;
dma_cookie_t completed_cookie; /* The maximum cookie completed */
spinlock_t desc_lock; /* Descriptor operation lock */ spinlock_t desc_lock; /* Descriptor operation lock */
struct list_head ld_pending; /* Link descriptors queue */ struct list_head ld_pending; /* Link descriptors queue */
struct list_head ld_running; /* Link descriptors queue */ struct list_head ld_running; /* Link descriptors queue */

View File

@ -32,6 +32,7 @@
#include <mach/dma-v1.h> #include <mach/dma-v1.h>
#include <mach/hardware.h> #include <mach/hardware.h>
#include "dmaengine.h"
#define IMXDMA_MAX_CHAN_DESCRIPTORS 16 #define IMXDMA_MAX_CHAN_DESCRIPTORS 16
enum imxdma_prep_type { enum imxdma_prep_type {
@ -77,7 +78,8 @@ struct imxdma_channel {
u32 watermark_level; u32 watermark_level;
struct dma_chan chan; struct dma_chan chan;
spinlock_t lock; spinlock_t lock;
dma_cookie_t last_completed; struct dma_async_tx_descriptor desc;
enum dma_status status;
int dma_request; int dma_request;
struct scatterlist *sg_list; struct scatterlist *sg_list;
}; };
@ -192,7 +194,7 @@ static void imxdma_tasklet(unsigned long data)
if (desc->desc.callback) if (desc->desc.callback)
desc->desc.callback(desc->desc.callback_param); 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 we are dealing with a cyclic descriptor keep it on ld_active */
if (imxdma_chan_is_doing_cyclic(imxdmac)) 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, dma_cookie_t cookie,
struct dma_tx_state *txstate) 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) 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; unsigned long flags;
spin_lock_irqsave(&imxdmac->lock, 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); spin_unlock_irqrestore(&imxdmac->lock, flags);
return cookie; return cookie;
@ -583,6 +557,7 @@ static int __init imxdma_probe(struct platform_device *pdev)
tasklet_init(&imxdmac->dma_tasklet, imxdma_tasklet, tasklet_init(&imxdmac->dma_tasklet, imxdma_tasklet,
(unsigned long)imxdmac); (unsigned long)imxdmac);
imxdmac->chan.device = &imxdma->dma_device; imxdmac->chan.device = &imxdma->dma_device;
dma_cookie_init(&imxdmac->chan);
imxdmac->channel = i; imxdmac->channel = i;
/* Add the channel to the DMAC list */ /* Add the channel to the DMAC list */

View File

@ -43,6 +43,8 @@
#include <mach/dma.h> #include <mach/dma.h>
#include <mach/hardware.h> #include <mach/hardware.h>
#include "dmaengine.h"
/* SDMA registers */ /* SDMA registers */
#define SDMA_H_C0PTR 0x000 #define SDMA_H_C0PTR 0x000
#define SDMA_H_INTR 0x004 #define SDMA_H_INTR 0x004
@ -267,7 +269,6 @@ struct sdma_channel {
struct dma_chan chan; struct dma_chan chan;
spinlock_t lock; spinlock_t lock;
struct dma_async_tx_descriptor desc; struct dma_async_tx_descriptor desc;
dma_cookie_t last_completed;
enum dma_status status; enum dma_status status;
unsigned int chn_count; unsigned int chn_count;
unsigned int chn_real_count; unsigned int chn_real_count;
@ -529,7 +530,7 @@ static void mxc_sdma_handle_channel_normal(struct sdma_channel *sdmac)
else else
sdmac->status = DMA_SUCCESS; sdmac->status = DMA_SUCCESS;
sdmac->last_completed = sdmac->desc.cookie; dma_cookie_complete(&sdmac->desc);
if (sdmac->desc.callback) if (sdmac->desc.callback)
sdmac->desc.callback(sdmac->desc.callback_param); sdmac->desc.callback(sdmac->desc.callback_param);
} }
@ -814,19 +815,6 @@ out:
return ret; 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) static struct sdma_channel *to_sdma_chan(struct dma_chan *chan)
{ {
return container_of(chan, struct sdma_channel, 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); spin_lock_irqsave(&sdmac->lock, flags);
cookie = sdma_assign_cookie(sdmac); cookie = dma_cookie_assign(tx);
spin_unlock_irqrestore(&sdmac->lock, flags); 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; 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); sdmac->chn_count - sdmac->chn_real_count);
return sdmac->status; return sdmac->status;
@ -1368,6 +1356,7 @@ static int __init sdma_probe(struct platform_device *pdev)
spin_lock_init(&sdmac->lock); spin_lock_init(&sdmac->lock);
sdmac->chan.device = &sdma->dma_device; sdmac->chan.device = &sdma->dma_device;
dma_cookie_init(&sdmac->chan);
sdmac->channel = i; sdmac->channel = i;
/* /*

View File

@ -29,6 +29,8 @@
#include <linux/intel_mid_dma.h> #include <linux/intel_mid_dma.h>
#include <linux/module.h> #include <linux/module.h>
#include "dmaengine.h"
#define MAX_CHAN 4 /*max ch across controllers*/ #define MAX_CHAN 4 /*max ch across controllers*/
#include "intel_mid_dma_regs.h" #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; struct intel_mid_dma_lli *llitem;
void *param_txd = NULL; void *param_txd = NULL;
midc->completed = txd->cookie; dma_cookie_complete(txd);
callback_txd = txd->callback; callback_txd = txd->callback;
param_txd = txd->callback_param; 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; dma_cookie_t cookie;
spin_lock_bh(&midc->lock); 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)) if (list_empty(&midc->active_list))
list_add_tail(&desc->desc_node, &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, dma_cookie_t cookie,
struct dma_tx_state *txstate) 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; 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) { if (ret != DMA_SUCCESS) {
spin_lock_bh(&midc->lock); spin_lock_bh(&midc->lock);
midc_scan_descriptors(to_middma_device(chan->device), midc); midc_scan_descriptors(to_middma_device(chan->device), midc);
spin_unlock_bh(&midc->lock); 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; return ret;
} }
@ -886,7 +868,7 @@ static int intel_mid_dma_alloc_chan_resources(struct dma_chan *chan)
pm_runtime_put(&mid->pdev->dev); pm_runtime_put(&mid->pdev->dev);
return -EIO; return -EIO;
} }
midc->completed = chan->cookie = 1; dma_cookie_init(chan);
spin_lock_bh(&midc->lock); spin_lock_bh(&midc->lock);
while (midc->descs_allocated < DESCS_PER_CHANNEL) { 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]; struct intel_mid_dma_chan *midch = &dma->ch[i];
midch->chan.device = &dma->common; midch->chan.device = &dma->common;
midch->chan.cookie = 1; dma_cookie_init(&midch->chan);
midch->ch_id = dma->chan_base + i; midch->ch_id = dma->chan_base + i;
pr_debug("MDMA:Init CH %d, ID %d\n", i, midch->ch_id); pr_debug("MDMA:Init CH %d, ID %d\n", i, midch->ch_id);

View File

@ -165,7 +165,6 @@ union intel_mid_dma_cfg_hi {
* @dma_base: MMIO register space DMA engine base pointer * @dma_base: MMIO register space DMA engine base pointer
* @ch_id: DMA channel id * @ch_id: DMA channel id
* @lock: channel spinlock * @lock: channel spinlock
* @completed: DMA cookie
* @active_list: current active descriptors * @active_list: current active descriptors
* @queue: current queued up descriptors * @queue: current queued up descriptors
* @free_list: current free descriptors * @free_list: current free descriptors
@ -183,7 +182,6 @@ struct intel_mid_dma_chan {
void __iomem *dma_base; void __iomem *dma_base;
int ch_id; int ch_id;
spinlock_t lock; spinlock_t lock;
dma_cookie_t completed;
struct list_head active_list; struct list_head active_list;
struct list_head queue; struct list_head queue;
struct list_head free_list; struct list_head free_list;

View File

@ -40,6 +40,8 @@
#include "registers.h" #include "registers.h"
#include "hw.h" #include "hw.h"
#include "../dmaengine.h"
int ioat_pending_level = 4; int ioat_pending_level = 4;
module_param(ioat_pending_level, int, 0644); module_param(ioat_pending_level, int, 0644);
MODULE_PARM_DESC(ioat_pending_level, 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)); chan->reg_base = device->reg_base + (0x80 * (idx + 1));
spin_lock_init(&chan->cleanup_lock); spin_lock_init(&chan->cleanup_lock);
chan->common.device = dma; chan->common.device = dma;
dma_cookie_init(&chan->common);
list_add_tail(&chan->common.device_node, &dma->channels); list_add_tail(&chan->common.device_node, &dma->channels);
device->idx[idx] = chan; device->idx[idx] = chan;
init_timer(&chan->timer); 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); spin_lock_bh(&ioat->desc_lock);
/* cookie incr and addition to used_list must be atomic */ /* 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); dev_dbg(to_dev(&ioat->base), "%s: cookie: %d\n", __func__, cookie);
/* write address into NextDescriptor field of last desc in chain */ /* 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); dump_desc_dbg(ioat, desc);
if (tx->cookie) { 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_dma_unmap(chan, tx->flags, desc->len, desc->hw);
ioat->active -= desc->hw->tx_cnt; ioat->active -= desc->hw->tx_cnt;
if (tx->callback) { 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 ioat_chan_common *chan = to_chan_common(c);
struct ioatdma_device *device = chan->device; 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); 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) static void ioat1_dma_start_null_desc(struct ioat_dma_chan *ioat)

View File

@ -90,7 +90,6 @@ struct ioat_chan_common {
void __iomem *reg_base; void __iomem *reg_base;
unsigned long last_completion; unsigned long last_completion;
spinlock_t cleanup_lock; spinlock_t cleanup_lock;
dma_cookie_t completed_cookie;
unsigned long state; unsigned long state;
#define IOAT_COMPLETION_PENDING 0 #define IOAT_COMPLETION_PENDING 0
#define IOAT_COMPLETION_ACK 1 #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); 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 */ /* wrapper around hardware descriptor format + additional software fields */
/** /**

View File

@ -41,6 +41,8 @@
#include "registers.h" #include "registers.h"
#include "hw.h" #include "hw.h"
#include "../dmaengine.h"
int ioat_ring_alloc_order = 8; int ioat_ring_alloc_order = 8;
module_param(ioat_ring_alloc_order, int, 0644); module_param(ioat_ring_alloc_order, int, 0644);
MODULE_PARM_DESC(ioat_ring_alloc_order, 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); dump_desc_dbg(ioat, desc);
if (tx->cookie) { if (tx->cookie) {
ioat_dma_unmap(chan, tx->flags, desc->len, desc->hw); 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) { if (tx->callback) {
tx->callback(tx->callback_param); tx->callback(tx->callback_param);
tx->callback = NULL; 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 dma_chan *c = tx->chan;
struct ioat2_dma_chan *ioat = to_ioat2_chan(c); struct ioat2_dma_chan *ioat = to_ioat2_chan(c);
struct ioat_chan_common *chan = &ioat->base; 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); dev_dbg(to_dev(&ioat->base), "%s: cookie: %d\n", __func__, cookie);
if (!test_and_set_bit(IOAT_COMPLETION_PENDING, &chan->state)) if (!test_and_set_bit(IOAT_COMPLETION_PENDING, &chan->state))

View File

@ -61,6 +61,7 @@
#include <linux/dmaengine.h> #include <linux/dmaengine.h>
#include <linux/dma-mapping.h> #include <linux/dma-mapping.h>
#include <linux/prefetch.h> #include <linux/prefetch.h>
#include "../dmaengine.h"
#include "registers.h" #include "registers.h"
#include "hw.h" #include "hw.h"
#include "dma.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); dump_desc_dbg(ioat, desc);
tx = &desc->txd; tx = &desc->txd;
if (tx->cookie) { if (tx->cookie) {
chan->completed_cookie = tx->cookie; dma_cookie_complete(tx);
ioat3_dma_unmap(ioat, desc, idx + i); ioat3_dma_unmap(ioat, desc, idx + i);
tx->cookie = 0;
if (tx->callback) { if (tx->callback) {
tx->callback(tx->callback_param); tx->callback(tx->callback_param);
tx->callback = NULL; tx->callback = NULL;
@ -411,13 +411,15 @@ ioat3_tx_status(struct dma_chan *c, dma_cookie_t cookie,
struct dma_tx_state *txstate) struct dma_tx_state *txstate)
{ {
struct ioat2_dma_chan *ioat = to_ioat2_chan(c); 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); ioat3_cleanup(ioat);
return ioat_tx_status(c, cookie, txstate); return dma_cookie_status(c, cookie, txstate);
} }
static struct dma_async_tx_descriptor * static struct dma_async_tx_descriptor *

View File

@ -36,6 +36,8 @@
#include <mach/adma.h> #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_chan(chan) container_of(chan, struct iop_adma_chan, common)
#define to_iop_adma_device(dev) \ #define to_iop_adma_device(dev) \
container_of(dev, struct iop_adma_device, common) 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) { if (cookie > 0) {
iop_chan->completed_cookie = cookie; iop_chan->common.completed_cookie = cookie;
pr_debug("\tcompleted cookie %d\n", cookie); pr_debug("\tcompleted cookie %d\n", cookie);
} }
} }
@ -438,18 +440,6 @@ retry:
return NULL; 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) static void iop_adma_check_threshold(struct iop_adma_chan *iop_chan)
{ {
dev_dbg(iop_chan->device->common.dev, "pending: %d\n", 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; slots_per_op = grp_start->slots_per_op;
spin_lock_bh(&iop_chan->lock); 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, old_chain_tail = list_entry(iop_chan->chain.prev,
struct iop_adma_desc_slot, chain_node); 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 dma_tx_state *txstate)
{ {
struct iop_adma_chan *iop_chan = to_iop_adma_chan(chan); 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;
last_used = chan->cookie; ret = dma_cookie_status(chan, cookie, txstate);
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) if (ret == DMA_SUCCESS)
return ret; return ret;
iop_adma_slot_cleanup(iop_chan); 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) 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->chain);
INIT_LIST_HEAD(&iop_chan->all_slots); INIT_LIST_HEAD(&iop_chan->all_slots);
iop_chan->common.device = dma_dev; iop_chan->common.device = dma_dev;
dma_cookie_init(&iop_chan->common);
list_add_tail(&iop_chan->common.device_node, &dma_dev->channels); list_add_tail(&iop_chan->common.device_node, &dma_dev->channels);
if (dma_has_cap(DMA_MEMCPY, dma_dev->cap_mask)) { 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_dest_addr(grp_start, iop_chan, 0);
iop_desc_set_memcpy_src_addr(grp_start, 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 /* initialize the completed cookie to be less than
* the most recently used cookie * 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 */ /* channel should not be busy */
BUG_ON(iop_chan_is_busy(iop_chan)); 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, 0, 0);
iop_desc_set_xor_src_addr(grp_start, 1, 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 /* initialize the completed cookie to be less than
* the most recently used cookie * 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 */ /* channel should not be busy */
BUG_ON(iop_chan_is_busy(iop_chan)); BUG_ON(iop_chan_is_busy(iop_chan));

View File

@ -25,6 +25,7 @@
#include <mach/ipu.h> #include <mach/ipu.h>
#include "../dmaengine.h"
#include "ipu_intern.h" #include "ipu_intern.h"
#define FS_VF_IN_VALID 0x00000002 #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]); 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. */ /* ipu->lock can be taken under ichan->lock, but not v.v. */
spin_lock_irqsave(&ichan->lock, flags); 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 */ /* Flip the active buffer - even if update above failed */
ichan->active_buffer = !ichan->active_buffer; ichan->active_buffer = !ichan->active_buffer;
if (done) if (done)
ichan->completed = desc->txd.cookie; dma_cookie_complete(&desc->txd);
callback = desc->txd.callback; callback = desc->txd.callback;
callback_param = desc->txd.callback_param; 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); BUG_ON(chan->client_count > 1);
WARN_ON(ichan->status != IPU_CHANNEL_FREE); WARN_ON(ichan->status != IPU_CHANNEL_FREE);
chan->cookie = 1; dma_cookie_init(chan);
ichan->completed = -ENXIO;
ret = ipu_irq_map(chan->chan_id); ret = ipu_irq_map(chan->chan_id);
if (ret < 0) 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, static enum dma_status idmac_tx_status(struct dma_chan *chan,
dma_cookie_t cookie, struct dma_tx_state *txstate) 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) if (cookie != chan->cookie)
return DMA_ERROR; return DMA_ERROR;
return DMA_SUCCESS; return DMA_SUCCESS;
@ -1638,11 +1629,10 @@ static int __init ipu_idmac_init(struct ipu *ipu)
ichan->status = IPU_CHANNEL_FREE; ichan->status = IPU_CHANNEL_FREE;
ichan->sec_chan_en = false; ichan->sec_chan_en = false;
ichan->completed = -ENXIO;
snprintf(ichan->eof_name, sizeof(ichan->eof_name), "IDMAC EOF %d", i); snprintf(ichan->eof_name, sizeof(ichan->eof_name), "IDMAC EOF %d", i);
dma_chan->device = &idmac->dma; dma_chan->device = &idmac->dma;
dma_chan->cookie = 1; dma_cookie_init(dma_chan);
dma_chan->chan_id = i; dma_chan->chan_id = i;
list_add_tail(&dma_chan->device_node, &dma->channels); list_add_tail(&dma_chan->device_node, &dma->channels);
} }

View File

@ -44,6 +44,8 @@
#include <linux/random.h> #include <linux/random.h>
#include "dmaengine.h"
/* Number of DMA Transfer descriptors allocated per channel */ /* Number of DMA Transfer descriptors allocated per channel */
#define MPC_DMA_DESCRIPTORS 64 #define MPC_DMA_DESCRIPTORS 64
@ -188,7 +190,6 @@ struct mpc_dma_chan {
struct list_head completed; struct list_head completed;
struct mpc_dma_tcd *tcd; struct mpc_dma_tcd *tcd;
dma_addr_t tcd_paddr; dma_addr_t tcd_paddr;
dma_cookie_t completed_cookie;
/* Lock for this structure */ /* Lock for this structure */
spinlock_t lock; spinlock_t lock;
@ -365,7 +366,7 @@ static void mpc_dma_process_completed(struct mpc_dma *mdma)
/* Free descriptors */ /* Free descriptors */
spin_lock_irqsave(&mchan->lock, flags); spin_lock_irqsave(&mchan->lock, flags);
list_splice_tail_init(&list, &mchan->free); list_splice_tail_init(&list, &mchan->free);
mchan->completed_cookie = last_cookie; mchan->chan.completed_cookie = last_cookie;
spin_unlock_irqrestore(&mchan->lock, flags); 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); mpc_dma_execute(mchan);
/* Update cookie */ /* 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); spin_unlock_irqrestore(&mchan->lock, flags);
return cookie; return cookie;
@ -562,17 +557,14 @@ mpc_dma_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
struct dma_tx_state *txstate) struct dma_tx_state *txstate)
{ {
struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(chan); struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(chan);
enum dma_status ret;
unsigned long flags; unsigned long flags;
dma_cookie_t last_used;
dma_cookie_t last_complete;
spin_lock_irqsave(&mchan->lock, flags); 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); 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 */ /* 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 = &mdma->channels[i];
mchan->chan.device = dma; 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->free);
INIT_LIST_HEAD(&mchan->prepared); INIT_LIST_HEAD(&mchan->prepared);

View File

@ -26,6 +26,8 @@
#include <linux/platform_device.h> #include <linux/platform_device.h>
#include <linux/memory.h> #include <linux/memory.h>
#include <plat/mv_xor.h> #include <plat/mv_xor.h>
#include "dmaengine.h"
#include "mv_xor.h" #include "mv_xor.h"
static void mv_xor_issue_pending(struct dma_chan *chan); 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) if (cookie > 0)
mv_chan->completed_cookie = cookie; mv_chan->common.completed_cookie = cookie;
} }
static void static void
@ -534,18 +536,6 @@ retry:
return NULL; 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 ****************************/ /************************ DMA engine API functions ****************************/
static dma_cookie_t static dma_cookie_t
mv_xor_tx_submit(struct dma_async_tx_descriptor *tx) 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; grp_start = sw_desc->group_head;
spin_lock_bh(&mv_chan->lock); 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)) if (list_empty(&mv_chan->chain))
list_splice_init(&sw_desc->tx_list, &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 dma_tx_state *txstate)
{ {
struct mv_xor_chan *mv_chan = to_mv_xor_chan(chan); 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; 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) { if (ret == DMA_SUCCESS) {
mv_xor_clean_completed_slots(mv_chan); mv_xor_clean_completed_slots(mv_chan);
return ret; return ret;
} }
mv_xor_slot_cleanup(mv_chan); 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) 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->completed_slots);
INIT_LIST_HEAD(&mv_chan->all_slots); INIT_LIST_HEAD(&mv_chan->all_slots);
mv_chan->common.device = dma_dev; mv_chan->common.device = dma_dev;
dma_cookie_init(&mv_chan->common);
list_add_tail(&mv_chan->common.device_node, &dma_dev->channels); list_add_tail(&mv_chan->common.device_node, &dma_dev->channels);

View File

@ -78,7 +78,6 @@ struct mv_xor_device {
/** /**
* struct mv_xor_chan - internal representation of a XOR channel * struct mv_xor_chan - internal representation of a XOR channel
* @pending: allows batching of hardware operations * @pending: allows batching of hardware operations
* @completed_cookie: identifier for the most recently completed operation
* @lock: serializes enqueue/dequeue operations to the descriptors pool * @lock: serializes enqueue/dequeue operations to the descriptors pool
* @mmr_base: memory mapped register base * @mmr_base: memory mapped register base
* @idx: the index of the xor channel * @idx: the index of the xor channel
@ -93,7 +92,6 @@ struct mv_xor_device {
*/ */
struct mv_xor_chan { struct mv_xor_chan {
int pending; int pending;
dma_cookie_t completed_cookie;
spinlock_t lock; /* protects the descriptor slot pool */ spinlock_t lock; /* protects the descriptor slot pool */
void __iomem *mmr_base; void __iomem *mmr_base;
unsigned int idx; unsigned int idx;
@ -109,7 +107,6 @@ struct mv_xor_chan {
#ifdef USE_TIMER #ifdef USE_TIMER
unsigned long cleanup_time; unsigned long cleanup_time;
u32 current_on_last_cleanup; u32 current_on_last_cleanup;
dma_cookie_t is_complete_cookie;
#endif #endif
}; };

View File

@ -28,6 +28,8 @@
#include <mach/dma.h> #include <mach/dma.h>
#include <mach/common.h> #include <mach/common.h>
#include "dmaengine.h"
/* /*
* NOTE: The term "PIO" throughout the mxs-dma implementation means * NOTE: The term "PIO" throughout the mxs-dma implementation means
* PIO mode of mxs apbh-dma and apbx-dma. With this working mode, * 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; struct mxs_dma_ccw *ccw;
dma_addr_t ccw_phys; dma_addr_t ccw_phys;
int desc_count; int desc_count;
dma_cookie_t last_completed;
enum dma_status status; enum dma_status status;
unsigned int flags; unsigned int flags;
#define MXS_DMA_SG_LOOP (1 << 0) #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; 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) static struct mxs_dma_chan *to_mxs_dma_chan(struct dma_chan *chan)
{ {
return container_of(chan, struct mxs_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); 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) 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); stat1 &= ~(1 << channel);
if (mxs_chan->status == DMA_SUCCESS) 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 */ /* schedule tasklet on this channel */
tasklet_schedule(&mxs_chan->tasklet); 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; dma_cookie_t last_used;
last_used = chan->cookie; 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; 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->mxs_dma = mxs_dma;
mxs_chan->chan.device = &mxs_dma->dma_device; mxs_chan->chan.device = &mxs_dma->dma_device;
dma_cookie_init(&mxs_chan->chan);
tasklet_init(&mxs_chan->tasklet, mxs_dma_tasklet, tasklet_init(&mxs_chan->tasklet, mxs_dma_tasklet,
(unsigned long) mxs_chan); (unsigned long) mxs_chan);

View File

@ -25,6 +25,8 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/pch_dma.h> #include <linux/pch_dma.h>
#include "dmaengine.h"
#define DRV_NAME "pch-dma" #define DRV_NAME "pch-dma"
#define DMA_CTL0_DISABLE 0x0 #define DMA_CTL0_DISABLE 0x0
@ -105,7 +107,6 @@ struct pch_dma_chan {
spinlock_t lock; spinlock_t lock;
dma_cookie_t completed_cookie;
struct list_head active_list; struct list_head active_list;
struct list_head queue; struct list_head queue;
struct list_head free_list; 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) static dma_cookie_t pd_tx_submit(struct dma_async_tx_descriptor *txd)
{ {
struct pch_dma_desc *desc = to_pd_desc(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; dma_cookie_t cookie;
spin_lock(&pd_chan->lock); spin_lock(&pd_chan->lock);
cookie = pdc_assign_cookie(pd_chan, desc); cookie = dma_cookie_assign(txd);
if (list_empty(&pd_chan->active_list)) { if (list_empty(&pd_chan->active_list)) {
list_add_tail(&desc->desc_node, &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); spin_lock_irq(&pd_chan->lock);
list_splice(&tmp_list, &pd_chan->free_list); list_splice(&tmp_list, &pd_chan->free_list);
pd_chan->descs_allocated = i; pd_chan->descs_allocated = i;
pd_chan->completed_cookie = chan->cookie = 1; dma_cookie_init(chan);
spin_unlock_irq(&pd_chan->lock); spin_unlock_irq(&pd_chan->lock);
pdc_enable_irq(chan, 1); 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 dma_tx_state *txstate)
{ {
struct pch_dma_chan *pd_chan = to_pd_chan(chan); 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); 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); 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; 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]; struct pch_dma_chan *pd_chan = &pd->channels[i];
pd_chan->chan.device = &pd->dma; pd_chan->chan.device = &pd->dma;
pd_chan->chan.cookie = 1; dma_cookie_init(&pd_chan->chan);
pd_chan->membase = &regs->desc[i]; pd_chan->membase = &regs->desc[i];

View File

@ -28,6 +28,7 @@
#include <linux/scatterlist.h> #include <linux/scatterlist.h>
#include <linux/of.h> #include <linux/of.h>
#include "dmaengine.h"
#define PL330_MAX_CHAN 8 #define PL330_MAX_CHAN 8
#define PL330_MAX_IRQS 32 #define PL330_MAX_IRQS 32
#define PL330_MAX_PERI 32 #define PL330_MAX_PERI 32
@ -285,6 +286,7 @@ static unsigned cmd_line;
#endif #endif
/* The number of default descriptors */ /* The number of default descriptors */
#define NR_DEFAULT_DESC 16 #define NR_DEFAULT_DESC 16
/* Populated by the PL330 core driver for DMA API driver's info */ /* Populated by the PL330 core driver for DMA API driver's info */
@ -545,9 +547,6 @@ struct dma_pl330_chan {
/* DMA-Engine Channel */ /* DMA-Engine Channel */
struct dma_chan chan; struct dma_chan chan;
/* Last completed cookie */
dma_cookie_t completed;
/* List of to be xfered descriptors */ /* List of to be xfered descriptors */
struct list_head work_list; struct list_head work_list;
@ -2320,7 +2319,7 @@ static void pl330_tasklet(unsigned long data)
/* Pick up ripe tomatoes */ /* Pick up ripe tomatoes */
list_for_each_entry_safe(desc, _dt, &pch->work_list, node) list_for_each_entry_safe(desc, _dt, &pch->work_list, node)
if (desc->status == DONE) { if (desc->status == DONE) {
pch->completed = desc->txd.cookie; dma_cookie_complete(&desc->txd);
list_move_tail(&desc->node, &list); 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); spin_lock_irqsave(&pch->lock, flags);
pch->completed = chan->cookie = 1; dma_cookie_init(chan);
pch->cyclic = false; pch->cyclic = false;
pch->pl330_chid = pl330_request_channel(&pdmac->pif); 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 */ /* Mark all desc done */
list_for_each_entry_safe(desc, _dt, &pch->work_list , node) { list_for_each_entry_safe(desc, _dt, &pch->work_list , node) {
desc->status = DONE; desc->status = DONE;
pch->completed = desc->txd.cookie;
list_move_tail(&desc->node, &list); 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, pl330_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
struct dma_tx_state *txstate) 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) 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); spin_lock_irqsave(&pch->lock, flags);
/* Assign cookies to all nodes */ /* Assign cookies to all nodes */
cookie = tx->chan->cookie;
while (!list_empty(&last->node)) { while (!list_empty(&last->node)) {
desc = list_entry(last->node.next, struct dma_pl330_desc, 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); 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); list_add_tail(&last->node, &pch->work_list);
tx->chan->cookie = cookie;
spin_unlock_irqrestore(&pch->lock, flags); spin_unlock_irqrestore(&pch->lock, flags);
return cookie; return cookie;

View File

@ -46,6 +46,7 @@
#include <asm/dcr.h> #include <asm/dcr.h>
#include <asm/dcr-regs.h> #include <asm/dcr-regs.h>
#include "adma.h" #include "adma.h"
#include "../dmaengine.h"
enum ppc_adma_init_code { enum ppc_adma_init_code {
PPC_ADMA_INIT_OK = 0, 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) { if (end_of_chain && slot_cnt) {
/* Should wait for ZeroSum completion */ /* Should wait for ZeroSum completion */
if (cookie > 0) if (cookie > 0)
chan->completed_cookie = cookie; chan->common.completed_cookie = cookie;
return; return;
} }
@ -1960,7 +1961,7 @@ static void __ppc440spe_adma_slot_cleanup(struct ppc440spe_adma_chan *chan)
BUG_ON(!seen_current); BUG_ON(!seen_current);
if (cookie > 0) { if (cookie > 0) {
chan->completed_cookie = cookie; chan->common.completed_cookie = cookie;
pr_debug("\tcompleted cookie %d\n", cookie); pr_debug("\tcompleted cookie %d\n", cookie);
} }
@ -2149,22 +2150,6 @@ static int ppc440spe_adma_alloc_chan_resources(struct dma_chan *chan)
return (i > 0) ? i : -ENOMEM; return (i > 0) ? i : -ENOMEM;
} }
/**
* 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 - * ppc440spe_rxor_set_region_data -
*/ */
@ -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; slots_per_op = group_start->slots_per_op;
spin_lock_bh(&chan->lock); spin_lock_bh(&chan->lock);
cookie = dma_cookie_assign(tx);
cookie = ppc440spe_desc_assign_cookie(chan, sw_desc);
if (unlikely(list_empty(&chan->chain))) { if (unlikely(list_empty(&chan->chain))) {
/* first peer */ /* 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) dma_cookie_t cookie, struct dma_tx_state *txstate)
{ {
struct ppc440spe_adma_chan *ppc440spe_chan; struct ppc440spe_adma_chan *ppc440spe_chan;
dma_cookie_t last_used;
dma_cookie_t last_complete;
enum dma_status ret; enum dma_status ret;
ppc440spe_chan = to_ppc440spe_adma_chan(chan); 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) if (ret == DMA_SUCCESS)
return ret; return ret;
ppc440spe_adma_slot_cleanup(ppc440spe_chan); 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); async_tx_ack(&sw_desc->async_tx);
ppc440spe_desc_init_null_xor(group_start); 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 /* initialize the completed cookie to be less than
* the most recently used cookie * 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 */ /* channel should not be busy */
BUG_ON(ppc440spe_chan_is_busy(chan)); 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); INIT_LIST_HEAD(&chan->all_slots);
chan->device = adev; chan->device = adev;
chan->common.device = &adev->common; chan->common.device = &adev->common;
dma_cookie_init(&chan->common);
list_add_tail(&chan->common.device_node, &adev->common.channels); list_add_tail(&chan->common.device_node, &adev->common.channels);
tasklet_init(&chan->irq_tasklet, ppc440spe_adma_tasklet, tasklet_init(&chan->irq_tasklet, ppc440spe_adma_tasklet,
(unsigned long)chan); (unsigned long)chan);

View File

@ -81,7 +81,6 @@ struct ppc440spe_adma_device {
* @common: common dmaengine channel object members * @common: common dmaengine channel object members
* @all_slots: complete domain of slots usable by the channel * @all_slots: complete domain of slots usable by the channel
* @pending: allows batching of hardware operations * @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 * @slots_allocated: records the actual size of the descriptor slot pool
* @hw_chain_inited: h/w descriptor chain initialization flag * @hw_chain_inited: h/w descriptor chain initialization flag
* @irq_tasklet: bottom half where ppc440spe_adma_slot_cleanup runs * @irq_tasklet: bottom half where ppc440spe_adma_slot_cleanup runs
@ -99,7 +98,6 @@ struct ppc440spe_adma_chan {
struct list_head all_slots; struct list_head all_slots;
struct ppc440spe_adma_desc_slot *last_used; struct ppc440spe_adma_desc_slot *last_used;
int pending; int pending;
dma_cookie_t completed_cookie;
int slots_allocated; int slots_allocated;
int hw_chain_inited; int hw_chain_inited;
struct tasklet_struct irq_tasklet; struct tasklet_struct irq_tasklet;

View File

@ -30,6 +30,8 @@
#include <linux/kdebug.h> #include <linux/kdebug.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/rculist.h> #include <linux/rculist.h>
#include "dmaengine.h"
#include "shdma.h" #include "shdma.h"
/* DMA descriptor control */ /* DMA descriptor control */
@ -296,13 +298,7 @@ static dma_cookie_t sh_dmae_tx_submit(struct dma_async_tx_descriptor *tx)
else else
power_up = false; 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 */ /* Mark all chunks of this descriptor as submitted, move to the queue */
list_for_each_entry_safe(chunk, c, desc->node.prev, node) { 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; cookie = tx->cookie;
if (desc->mark == DESC_COMPLETED && desc->chunks == 1) { 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, dev_dbg(sh_chan->dev,
"Completing cookie %d, expected %d\n", "Completing cookie %d, expected %d\n",
desc->cookie, 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 */ /* 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 * Terminating and the loop completed normally: forgive
* uncompleted cookies * 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); 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 dma_tx_state *txstate)
{ {
struct sh_dmae_chan *sh_chan = to_sh_chan(chan); struct sh_dmae_chan *sh_chan = to_sh_chan(chan);
dma_cookie_t last_used;
dma_cookie_t last_complete;
enum dma_status status; enum dma_status status;
unsigned long flags; unsigned long flags;
sh_dmae_chan_ld_cleanup(sh_chan, false); 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); 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 * 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 */ /* reference struct dma_device */
new_sh_chan->common.device = &shdev->common; new_sh_chan->common.device = &shdev->common;
dma_cookie_init(&new_sh_chan->common);
new_sh_chan->dev = shdev->common.dev; new_sh_chan->dev = shdev->common.dev;
new_sh_chan->id = id; new_sh_chan->id = id;

View File

@ -30,7 +30,6 @@ enum dmae_pm_state {
}; };
struct sh_dmae_chan { struct sh_dmae_chan {
dma_cookie_t completed_cookie; /* The maximum cookie completed */
spinlock_t desc_lock; /* Descriptor operation lock */ spinlock_t desc_lock; /* Descriptor operation lock */
struct list_head ld_queue; /* Link descriptors queue */ struct list_head ld_queue; /* Link descriptors queue */
struct list_head ld_free; /* Link descriptors free */ struct list_head ld_free; /* Link descriptors free */

View File

@ -18,6 +18,8 @@
#include <linux/of_platform.h> #include <linux/of_platform.h>
#include <linux/sirfsoc_dma.h> #include <linux/sirfsoc_dma.h>
#include "dmaengine.h"
#define SIRFSOC_DMA_DESCRIPTORS 16 #define SIRFSOC_DMA_DESCRIPTORS 16
#define SIRFSOC_DMA_CHANNELS 16 #define SIRFSOC_DMA_CHANNELS 16
@ -59,7 +61,6 @@ struct sirfsoc_dma_chan {
struct list_head queued; struct list_head queued;
struct list_head active; struct list_head active;
struct list_head completed; struct list_head completed;
dma_cookie_t completed_cookie;
unsigned long happened_cyclic; unsigned long happened_cyclic;
unsigned long completed_cyclic; unsigned long completed_cyclic;
@ -208,7 +209,7 @@ static void sirfsoc_dma_process_completed(struct sirfsoc_dma *sdma)
/* Free descriptors */ /* Free descriptors */
spin_lock_irqsave(&schan->lock, flags); spin_lock_irqsave(&schan->lock, flags);
list_splice_tail_init(&list, &schan->free); list_splice_tail_init(&list, &schan->free);
schan->completed_cookie = last_cookie; schan->chan.completed_cookie = last_cookie;
spin_unlock_irqrestore(&schan->lock, flags); spin_unlock_irqrestore(&schan->lock, flags);
} else { } else {
/* for cyclic channel, desc is always in active list */ /* 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 */ /* Move descriptor to queue */
list_move_tail(&sdesc->node, &schan->queued); 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); 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); struct sirfsoc_dma_chan *schan = dma_chan_to_sirfsoc_dma_chan(chan);
unsigned long flags; unsigned long flags;
dma_cookie_t last_used; enum dma_status ret;
dma_cookie_t last_complete;
spin_lock_irqsave(&schan->lock, flags); 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); 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( 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 = &sdma->channels[i];
schan->chan.device = dma; 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->free);
INIT_LIST_HEAD(&schan->prepared); INIT_LIST_HEAD(&schan->prepared);

View File

@ -21,6 +21,7 @@
#include <plat/ste_dma40.h> #include <plat/ste_dma40.h>
#include "dmaengine.h"
#include "ste_dma40_ll.h" #include "ste_dma40_ll.h"
#define D40_NAME "dma40" #define D40_NAME "dma40"
@ -220,8 +221,6 @@ struct d40_base;
* *
* @lock: A spinlock to protect this struct. * @lock: A spinlock to protect this struct.
* @log_num: The logical number, if any of this channel. * @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 * @pending_tx: The number of pending transfers. Used between interrupt handler
* and tasklet. * and tasklet.
* @busy: Set to true when transfer is ongoing on this channel. * @busy: Set to true when transfer is ongoing on this channel.
@ -250,8 +249,6 @@ struct d40_base;
struct d40_chan { struct d40_chan {
spinlock_t lock; spinlock_t lock;
int log_num; int log_num;
/* ID of the most recent completed transfer */
int completed;
int pending_tx; int pending_tx;
bool busy; bool busy;
struct d40_phy_res *phy_chan; struct d40_phy_res *phy_chan;
@ -1223,21 +1220,14 @@ static dma_cookie_t d40_tx_submit(struct dma_async_tx_descriptor *tx)
chan); chan);
struct d40_desc *d40d = container_of(tx, struct d40_desc, txd); struct d40_desc *d40d = container_of(tx, struct d40_desc, txd);
unsigned long flags; unsigned long flags;
dma_cookie_t cookie;
spin_lock_irqsave(&d40c->lock, flags); 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); d40_desc_queue(d40c, d40d);
spin_unlock_irqrestore(&d40c->lock, flags); spin_unlock_irqrestore(&d40c->lock, flags);
return tx->cookie; return cookie;
} }
static int d40_start(struct d40_chan *d40c) static int d40_start(struct d40_chan *d40c)
@ -1357,7 +1347,7 @@ static void dma_tasklet(unsigned long data)
goto err; goto err;
if (!d40d->cyclic) if (!d40d->cyclic)
d40c->completed = d40d->txd.cookie; dma_cookie_complete(&d40d->txd);
/* /*
* If terminating a channel pending_tx is set to zero. * 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; bool is_free_phy;
spin_lock_irqsave(&d40c->lock, flags); 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 no dma configuration is set use default configuration (memcpy) */
if (!d40c->configured) { if (!d40c->configured) {
@ -2342,25 +2332,19 @@ static enum dma_status d40_tx_status(struct dma_chan *chan,
struct dma_tx_state *txstate) struct dma_tx_state *txstate)
{ {
struct d40_chan *d40c = container_of(chan, struct d40_chan, chan); 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) { if (d40c->phy_chan == NULL) {
chan_err(d40c, "Cannot read status of unallocated channel\n"); chan_err(d40c, "Cannot read status of unallocated channel\n");
return -EINVAL; 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)) if (d40_is_paused(d40c))
ret = DMA_PAUSED; 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; return ret;
} }

View File

@ -31,6 +31,8 @@
#include <linux/timb_dma.h> #include <linux/timb_dma.h>
#include "dmaengine.h"
#define DRIVER_NAME "timb-dma" #define DRIVER_NAME "timb-dma"
/* Global DMA registers */ /* Global DMA registers */
@ -84,7 +86,6 @@ struct timb_dma_chan {
especially the lists and descriptors, especially the lists and descriptors,
from races between the tasklet and calls from races between the tasklet and calls
from above */ from above */
dma_cookie_t last_completed_cookie;
bool ongoing; bool ongoing;
struct list_head active_list; struct list_head active_list;
struct list_head queue; struct list_head queue;
@ -284,7 +285,7 @@ static void __td_finish(struct timb_dma_chan *td_chan)
else else
iowrite32(0, td_chan->membase + TIMBDMA_OFFS_TX_DLAR); iowrite32(0, td_chan->membase + TIMBDMA_OFFS_TX_DLAR);
*/ */
td_chan->last_completed_cookie = txd->cookie; dma_cookie_complete(txd);
td_chan->ongoing = false; td_chan->ongoing = false;
callback = txd->callback; callback = txd->callback;
@ -349,12 +350,7 @@ static dma_cookie_t td_tx_submit(struct dma_async_tx_descriptor *txd)
dma_cookie_t cookie; dma_cookie_t cookie;
spin_lock_bh(&td_chan->lock); 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)) { if (list_empty(&td_chan->active_list)) {
dev_dbg(chan2dev(txd->chan), "%s: started %u\n", __func__, 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); 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); spin_unlock_bh(&td_chan->lock);
return 0; 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, static enum dma_status td_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
struct dma_tx_state *txstate) 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__); 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); dev_dbg(chan2dev(chan), "%s: exit, ret: %d\n", __func__, ret);
dma_set_tx_state(txstate, last_complete, last_used, 0);
dev_dbg(chan2dev(chan),
"%s: exit, ret: %d, last_complete: %d, last_used: %d\n",
__func__, ret, last_complete, last_used);
return ret; return ret;
} }
@ -766,7 +750,7 @@ static int __devinit td_probe(struct platform_device *pdev)
} }
td_chan->chan.device = &td->dma; td_chan->chan.device = &td->dma;
td_chan->chan.cookie = 1; dma_cookie_init(&td_chan->chan);
spin_lock_init(&td_chan->lock); spin_lock_init(&td_chan->lock);
INIT_LIST_HEAD(&td_chan->active_list); INIT_LIST_HEAD(&td_chan->active_list);
INIT_LIST_HEAD(&td_chan->queue); INIT_LIST_HEAD(&td_chan->queue);

View File

@ -15,6 +15,8 @@
#include <linux/platform_device.h> #include <linux/platform_device.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/scatterlist.h> #include <linux/scatterlist.h>
#include "dmaengine.h"
#include "txx9dmac.h" #include "txx9dmac.h"
static struct txx9dmac_chan *to_txx9dmac_chan(struct dma_chan *chan) 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) 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", dev_vdbg(chan2dev(&dc->chan), "descriptor %u %p complete\n",
txd->cookie, desc); txd->cookie, desc);
dc->completed = txd->cookie; dma_cookie_complete(txd);
callback = txd->callback; callback = txd->callback;
param = txd->callback_param; 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; dma_cookie_t cookie;
spin_lock_bh(&dc->lock); 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", dev_vdbg(chan2dev(tx->chan), "tx_submit: queued %u %p\n",
desc->txd.cookie, desc); 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 dma_tx_state *txstate)
{ {
struct txx9dmac_chan *dc = to_txx9dmac_chan(chan); 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) { if (ret != DMA_SUCCESS) {
spin_lock_bh(&dc->lock); spin_lock_bh(&dc->lock);
txx9dmac_scan_descriptors(dc); txx9dmac_scan_descriptors(dc);
spin_unlock_bh(&dc->lock); 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; return ret;
} }
@ -1057,7 +1034,7 @@ static int txx9dmac_alloc_chan_resources(struct dma_chan *chan)
return -EIO; return -EIO;
} }
dc->completed = chan->cookie = 1; dma_cookie_init(chan);
dc->ccr = TXX9_DMA_CCR_IMMCHN | TXX9_DMA_CCR_INTENE | CCR_LE; dc->ccr = TXX9_DMA_CCR_IMMCHN | TXX9_DMA_CCR_INTENE | CCR_LE;
txx9dmac_chan_set_SMPCHN(dc); 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->ddev->chan[ch] = dc;
dc->chan.device = &dc->dma; dc->chan.device = &dc->dma;
list_add_tail(&dc->chan.device_node, &dc->chan.device->channels); 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)) if (is_dmac64(dc))
dc->ch_regs = &__txx9dmac_regs(dc->ddev)->CHAN[ch]; dc->ch_regs = &__txx9dmac_regs(dc->ddev)->CHAN[ch];

View File

@ -172,7 +172,6 @@ struct txx9dmac_chan {
spinlock_t lock; spinlock_t lock;
/* these other elements are all protected by lock */ /* these other elements are all protected by lock */
dma_cookie_t completed;
struct list_head active_list; struct list_head active_list;
struct list_head queue; struct list_head queue;
struct list_head free_list; struct list_head free_list;

View File

@ -172,7 +172,6 @@ enum pl08x_dma_chan_state {
* @runtime_addr: address for RX/TX according to the runtime config * @runtime_addr: address for RX/TX according to the runtime config
* @runtime_direction: current direction of this channel according to * @runtime_direction: current direction of this channel according to
* runtime config * runtime config
* @lc: last completed transaction on this channel
* @pend_list: queued transactions pending on this channel * @pend_list: queued transactions pending on this channel
* @at: active transaction on this channel * @at: active transaction on this channel
* @lock: a lock for this channel data * @lock: a lock for this channel data
@ -197,7 +196,6 @@ struct pl08x_dma_chan {
u32 src_cctl; u32 src_cctl;
u32 dst_cctl; u32 dst_cctl;
enum dma_transfer_direction runtime_direction; enum dma_transfer_direction runtime_direction;
dma_cookie_t lc;
struct list_head pend_list; struct list_head pend_list;
struct pl08x_txd *at; struct pl08x_txd *at;
spinlock_t lock; spinlock_t lock;

View File

@ -18,8 +18,8 @@
* The full GNU General Public License is included in this distribution in the * The full GNU General Public License is included in this distribution in the
* file called COPYING. * file called COPYING.
*/ */
#ifndef DMAENGINE_H #ifndef LINUX_DMAENGINE_H
#define DMAENGINE_H #define LINUX_DMAENGINE_H
#include <linux/device.h> #include <linux/device.h>
#include <linux/uio.h> #include <linux/uio.h>
@ -258,6 +258,7 @@ struct dma_chan_percpu {
* struct dma_chan - devices supply DMA channels, clients use them * struct dma_chan - devices supply DMA channels, clients use them
* @device: ptr to the dma device who supplies this channel, always !%NULL * @device: ptr to the dma device who supplies this channel, always !%NULL
* @cookie: last cookie value returned to client * @cookie: last cookie value returned to client
* @completed_cookie: last completed cookie for this channel
* @chan_id: channel ID for sysfs * @chan_id: channel ID for sysfs
* @dev: class device for sysfs * @dev: class device for sysfs
* @device_node: used to add this to the device chan list * @device_node: used to add this to the device chan list
@ -269,6 +270,7 @@ struct dma_chan_percpu {
struct dma_chan { struct dma_chan {
struct dma_device *device; struct dma_device *device;
dma_cookie_t cookie; dma_cookie_t cookie;
dma_cookie_t completed_cookie;
/* sysfs */ /* sysfs */
int chan_id; int chan_id;