2009-07-04 00:24:33 +07:00
|
|
|
/*
|
|
|
|
* Driver for the Atmel AHB DMA Controller (aka HDMA or DMAC on AT91 systems)
|
|
|
|
*
|
|
|
|
* Copyright (C) 2008 Atmel Corporation
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
*
|
2012-06-12 15:44:55 +07:00
|
|
|
* This supports the Atmel AHB DMA Controller found in several Atmel SoCs.
|
|
|
|
* The only Atmel DMA Controller that is not covered by this driver is the one
|
|
|
|
* found on AT91SAM9263.
|
2009-07-04 00:24:33 +07:00
|
|
|
*/
|
|
|
|
|
2013-06-13 15:39:39 +07:00
|
|
|
#include <dt-bindings/dma/at91.h>
|
2009-07-04 00:24:33 +07:00
|
|
|
#include <linux/clk.h>
|
|
|
|
#include <linux/dmaengine.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/dmapool.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/platform_device.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2011-10-17 19:56:41 +07:00
|
|
|
#include <linux/of.h>
|
|
|
|
#include <linux/of_device.h>
|
2013-04-19 16:11:18 +07:00
|
|
|
#include <linux/of_dma.h>
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
#include "at_hdmac_regs.h"
|
2012-03-07 05:34:26 +07:00
|
|
|
#include "dmaengine.h"
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Glossary
|
|
|
|
* --------
|
|
|
|
*
|
|
|
|
* at_hdmac : Name of the ATmel AHB DMA Controller
|
|
|
|
* at_dma_ / atdma : ATmel DMA controller entity related
|
|
|
|
* atc_ / atchan : ATmel DMA Channel entity related
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define ATC_DEFAULT_CFG (ATC_FIFOCFG_HALFFIFO)
|
2011-04-30 21:57:49 +07:00
|
|
|
#define ATC_DEFAULT_CTRLB (ATC_SIF(AT_DMA_MEM_IF) \
|
|
|
|
|ATC_DIF(AT_DMA_MEM_IF))
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Initial number of descriptors to allocate for each channel. This could
|
|
|
|
* be increased during dma usage.
|
|
|
|
*/
|
|
|
|
static unsigned int init_nr_desc_per_channel = 64;
|
|
|
|
module_param(init_nr_desc_per_channel, uint, 0644);
|
|
|
|
MODULE_PARM_DESC(init_nr_desc_per_channel,
|
|
|
|
"initial descriptors per channel (default: 64)");
|
|
|
|
|
|
|
|
|
|
|
|
/* prototypes */
|
|
|
|
static dma_cookie_t atc_tx_submit(struct dma_async_tx_descriptor *tx);
|
2013-05-10 10:01:46 +07:00
|
|
|
static void atc_issue_pending(struct dma_chan *chan);
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
static struct at_desc *atc_first_active(struct at_dma_chan *atchan)
|
|
|
|
{
|
|
|
|
return list_first_entry(&atchan->active_list,
|
|
|
|
struct at_desc, desc_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct at_desc *atc_first_queued(struct at_dma_chan *atchan)
|
|
|
|
{
|
|
|
|
return list_first_entry(&atchan->queue,
|
|
|
|
struct at_desc, desc_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-06-11 17:17:00 +07:00
|
|
|
* atc_alloc_descriptor - allocate and return an initialized descriptor
|
2009-07-04 00:24:33 +07:00
|
|
|
* @chan: the channel to allocate descriptors for
|
|
|
|
* @gfp_flags: GFP allocation flags
|
|
|
|
*
|
|
|
|
* Note: The ack-bit is positioned in the descriptor flag at creation time
|
|
|
|
* to make initial allocation more convenient. This bit will be cleared
|
|
|
|
* and control will be given to client at usage time (during
|
|
|
|
* preparation functions).
|
|
|
|
*/
|
|
|
|
static struct at_desc *atc_alloc_descriptor(struct dma_chan *chan,
|
|
|
|
gfp_t gfp_flags)
|
|
|
|
{
|
|
|
|
struct at_desc *desc = NULL;
|
|
|
|
struct at_dma *atdma = to_at_dma(chan->device);
|
|
|
|
dma_addr_t phys;
|
|
|
|
|
|
|
|
desc = dma_pool_alloc(atdma->dma_desc_pool, gfp_flags, &phys);
|
|
|
|
if (desc) {
|
|
|
|
memset(desc, 0, sizeof(struct at_desc));
|
2009-09-09 07:53:03 +07:00
|
|
|
INIT_LIST_HEAD(&desc->tx_list);
|
2009-07-04 00:24:33 +07:00
|
|
|
dma_async_tx_descriptor_init(&desc->txd, chan);
|
|
|
|
/* txd.flags will be overwritten in prep functions */
|
|
|
|
desc->txd.flags = DMA_CTRL_ACK;
|
|
|
|
desc->txd.tx_submit = atc_tx_submit;
|
|
|
|
desc->txd.phys = phys;
|
|
|
|
}
|
|
|
|
|
|
|
|
return desc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
tree-wide: fix assorted typos all over the place
That is "success", "unknown", "through", "performance", "[re|un]mapping"
, "access", "default", "reasonable", "[con]currently", "temperature"
, "channel", "[un]used", "application", "example","hierarchy", "therefore"
, "[over|under]flow", "contiguous", "threshold", "enough" and others.
Signed-off-by: André Goddard Rosa <andre.goddard@gmail.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2009-11-14 22:09:05 +07:00
|
|
|
* atc_desc_get - get an unused descriptor from free_list
|
2009-07-04 00:24:33 +07:00
|
|
|
* @atchan: channel we want a new descriptor for
|
|
|
|
*/
|
|
|
|
static struct at_desc *atc_desc_get(struct at_dma_chan *atchan)
|
|
|
|
{
|
|
|
|
struct at_desc *desc, *_desc;
|
|
|
|
struct at_desc *ret = NULL;
|
2011-07-27 19:21:28 +07:00
|
|
|
unsigned long flags;
|
2009-07-04 00:24:33 +07:00
|
|
|
unsigned int i = 0;
|
|
|
|
LIST_HEAD(tmp_list);
|
|
|
|
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_lock_irqsave(&atchan->lock, flags);
|
2009-07-04 00:24:33 +07:00
|
|
|
list_for_each_entry_safe(desc, _desc, &atchan->free_list, desc_node) {
|
|
|
|
i++;
|
|
|
|
if (async_tx_test_ack(&desc->txd)) {
|
|
|
|
list_del(&desc->desc_node);
|
|
|
|
ret = desc;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
dev_dbg(chan2dev(&atchan->chan_common),
|
|
|
|
"desc %p not ACKed\n", desc);
|
|
|
|
}
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_unlock_irqrestore(&atchan->lock, flags);
|
2009-07-04 00:24:33 +07:00
|
|
|
dev_vdbg(chan2dev(&atchan->chan_common),
|
|
|
|
"scanned %u descriptors on freelist\n", i);
|
|
|
|
|
|
|
|
/* no more descriptor available in initial pool: create one more */
|
|
|
|
if (!ret) {
|
|
|
|
ret = atc_alloc_descriptor(&atchan->chan_common, GFP_ATOMIC);
|
|
|
|
if (ret) {
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_lock_irqsave(&atchan->lock, flags);
|
2009-07-04 00:24:33 +07:00
|
|
|
atchan->descs_allocated++;
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_unlock_irqrestore(&atchan->lock, flags);
|
2009-07-04 00:24:33 +07:00
|
|
|
} else {
|
|
|
|
dev_err(chan2dev(&atchan->chan_common),
|
|
|
|
"not enough descriptors available\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* atc_desc_put - move a descriptor, including any children, to the free list
|
|
|
|
* @atchan: channel we work on
|
|
|
|
* @desc: descriptor, at the head of a chain, to move to free list
|
|
|
|
*/
|
|
|
|
static void atc_desc_put(struct at_dma_chan *atchan, struct at_desc *desc)
|
|
|
|
{
|
|
|
|
if (desc) {
|
|
|
|
struct at_desc *child;
|
2011-07-27 19:21:28 +07:00
|
|
|
unsigned long flags;
|
2009-07-04 00:24:33 +07:00
|
|
|
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_lock_irqsave(&atchan->lock, flags);
|
2009-09-09 07:53:03 +07:00
|
|
|
list_for_each_entry(child, &desc->tx_list, desc_node)
|
2009-07-04 00:24:33 +07:00
|
|
|
dev_vdbg(chan2dev(&atchan->chan_common),
|
|
|
|
"moving child desc %p to freelist\n",
|
|
|
|
child);
|
2009-09-09 07:53:03 +07:00
|
|
|
list_splice_init(&desc->tx_list, &atchan->free_list);
|
2009-07-04 00:24:33 +07:00
|
|
|
dev_vdbg(chan2dev(&atchan->chan_common),
|
|
|
|
"moving desc %p to freelist\n", desc);
|
|
|
|
list_add(&desc->desc_node, &atchan->free_list);
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_unlock_irqrestore(&atchan->lock, flags);
|
2009-07-04 00:24:33 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-30 21:57:46 +07:00
|
|
|
/**
|
2012-08-04 21:37:53 +07:00
|
|
|
* atc_desc_chain - build chain adding a descriptor
|
|
|
|
* @first: address of first descriptor of the chain
|
|
|
|
* @prev: address of previous descriptor of the chain
|
2011-04-30 21:57:46 +07:00
|
|
|
* @desc: descriptor to queue
|
|
|
|
*
|
|
|
|
* Called from prep_* functions
|
|
|
|
*/
|
|
|
|
static void atc_desc_chain(struct at_desc **first, struct at_desc **prev,
|
|
|
|
struct at_desc *desc)
|
|
|
|
{
|
|
|
|
if (!(*first)) {
|
|
|
|
*first = desc;
|
|
|
|
} else {
|
|
|
|
/* inform the HW lli about chaining */
|
|
|
|
(*prev)->lli.dscr = desc->txd.phys;
|
|
|
|
/* insert the link descriptor to the LD ring */
|
|
|
|
list_add_tail(&desc->desc_node,
|
|
|
|
&(*first)->tx_list);
|
|
|
|
}
|
|
|
|
*prev = desc;
|
|
|
|
}
|
|
|
|
|
2009-07-04 00:24:33 +07:00
|
|
|
/**
|
|
|
|
* atc_dostart - starts the DMA engine for real
|
|
|
|
* @atchan: the channel we want to start
|
|
|
|
* @first: first descriptor in the list we want to begin with
|
|
|
|
*
|
|
|
|
* Called with atchan->lock held and bh disabled
|
|
|
|
*/
|
|
|
|
static void atc_dostart(struct at_dma_chan *atchan, struct at_desc *first)
|
|
|
|
{
|
|
|
|
struct at_dma *atdma = to_at_dma(atchan->chan_common.device);
|
|
|
|
|
|
|
|
/* ASSERT: channel is idle */
|
|
|
|
if (atc_chan_is_enabled(atchan)) {
|
|
|
|
dev_err(chan2dev(&atchan->chan_common),
|
|
|
|
"BUG: Attempted to start non-idle channel\n");
|
|
|
|
dev_err(chan2dev(&atchan->chan_common),
|
|
|
|
" channel: s0x%x d0x%x ctrl0x%x:0x%x l0x%x\n",
|
|
|
|
channel_readl(atchan, SADDR),
|
|
|
|
channel_readl(atchan, DADDR),
|
|
|
|
channel_readl(atchan, CTRLA),
|
|
|
|
channel_readl(atchan, CTRLB),
|
|
|
|
channel_readl(atchan, DSCR));
|
|
|
|
|
|
|
|
/* The tasklet will hopefully advance the queue... */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
vdbg_dump_regs(atchan);
|
|
|
|
|
|
|
|
channel_writel(atchan, SADDR, 0);
|
|
|
|
channel_writel(atchan, DADDR, 0);
|
|
|
|
channel_writel(atchan, CTRLA, 0);
|
|
|
|
channel_writel(atchan, CTRLB, 0);
|
|
|
|
channel_writel(atchan, DSCR, first->txd.phys);
|
|
|
|
dma_writel(atdma, CHER, atchan->mask);
|
|
|
|
|
|
|
|
vdbg_dump_regs(atchan);
|
|
|
|
}
|
|
|
|
|
2013-05-10 10:01:46 +07:00
|
|
|
/*
|
|
|
|
* atc_get_current_descriptors -
|
|
|
|
* locate the descriptor which equal to physical address in DSCR
|
|
|
|
* @atchan: the channel we want to start
|
|
|
|
* @dscr_addr: physical descriptor address in DSCR
|
|
|
|
*/
|
|
|
|
static struct at_desc *atc_get_current_descriptors(struct at_dma_chan *atchan,
|
|
|
|
u32 dscr_addr)
|
|
|
|
{
|
|
|
|
struct at_desc *desc, *_desc, *child, *desc_cur = NULL;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(desc, _desc, &atchan->active_list, desc_node) {
|
|
|
|
if (desc->lli.dscr == dscr_addr) {
|
|
|
|
desc_cur = desc;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry(child, &desc->tx_list, desc_node) {
|
|
|
|
if (child->lli.dscr == dscr_addr) {
|
|
|
|
desc_cur = child;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return desc_cur;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* atc_get_bytes_left -
|
|
|
|
* Get the number of bytes residue in dma buffer,
|
|
|
|
* @chan: the channel we want to start
|
|
|
|
*/
|
|
|
|
static int atc_get_bytes_left(struct dma_chan *chan)
|
|
|
|
{
|
|
|
|
struct at_dma_chan *atchan = to_at_dma_chan(chan);
|
|
|
|
struct at_dma *atdma = to_at_dma(chan->device);
|
|
|
|
int chan_id = atchan->chan_common.chan_id;
|
|
|
|
struct at_desc *desc_first = atc_first_active(atchan);
|
|
|
|
struct at_desc *desc_cur;
|
|
|
|
int ret = 0, count = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize necessary values in the first time.
|
|
|
|
* remain_desc record remain desc length.
|
|
|
|
*/
|
|
|
|
if (atchan->remain_desc == 0)
|
|
|
|
/* First descriptor embedds the transaction length */
|
|
|
|
atchan->remain_desc = desc_first->len;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This happens when current descriptor transfer complete.
|
|
|
|
* The residual buffer size should reduce current descriptor length.
|
|
|
|
*/
|
|
|
|
if (unlikely(test_bit(ATC_IS_BTC, &atchan->status))) {
|
|
|
|
clear_bit(ATC_IS_BTC, &atchan->status);
|
|
|
|
desc_cur = atc_get_current_descriptors(atchan,
|
|
|
|
channel_readl(atchan, DSCR));
|
|
|
|
if (!desc_cur) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
atchan->remain_desc -= (desc_cur->lli.ctrla & ATC_BTSIZE_MAX)
|
|
|
|
<< (desc_first->tx_width);
|
|
|
|
if (atchan->remain_desc < 0) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
2013-06-07 22:26:14 +07:00
|
|
|
} else {
|
2013-05-10 10:01:46 +07:00
|
|
|
ret = atchan->remain_desc;
|
2013-06-07 22:26:14 +07:00
|
|
|
}
|
2013-05-10 10:01:46 +07:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Get residual bytes when current
|
|
|
|
* descriptor transfer in progress.
|
|
|
|
*/
|
|
|
|
count = (channel_readl(atchan, CTRLA) & ATC_BTSIZE_MAX)
|
|
|
|
<< (desc_first->tx_width);
|
|
|
|
ret = atchan->remain_desc - count;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Check fifo empty.
|
|
|
|
*/
|
|
|
|
if (!(dma_readl(atdma, CHSR) & AT_DMA_EMPT(chan_id)))
|
|
|
|
atc_issue_pending(chan);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-07-04 00:24:33 +07:00
|
|
|
/**
|
|
|
|
* atc_chain_complete - finish work for one transaction chain
|
|
|
|
* @atchan: channel we work on
|
|
|
|
* @desc: descriptor at the head of the chain we want do complete
|
|
|
|
*
|
|
|
|
* Called with atchan->lock held and bh disabled */
|
|
|
|
static void
|
|
|
|
atc_chain_complete(struct at_dma_chan *atchan, struct at_desc *desc)
|
|
|
|
{
|
|
|
|
struct dma_async_tx_descriptor *txd = &desc->txd;
|
|
|
|
|
|
|
|
dev_vdbg(chan2dev(&atchan->chan_common),
|
|
|
|
"descriptor %u complete\n", txd->cookie);
|
|
|
|
|
2012-05-11 13:18:21 +07:00
|
|
|
/* mark the descriptor as complete for non cyclic cases only */
|
|
|
|
if (!atc_chan_is_cyclic(atchan))
|
|
|
|
dma_cookie_complete(txd);
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
/* move children to free_list */
|
2009-09-09 07:53:03 +07:00
|
|
|
list_splice_init(&desc->tx_list, &atchan->free_list);
|
2009-07-04 00:24:33 +07:00
|
|
|
/* move myself to free_list */
|
|
|
|
list_move(&desc->desc_node, &atchan->free_list);
|
|
|
|
|
2011-01-12 21:39:06 +07:00
|
|
|
/* unmap dma addresses (not on slave channels) */
|
2009-09-09 07:53:05 +07:00
|
|
|
if (!atchan->chan_common.private) {
|
|
|
|
struct device *parent = chan2parent(&atchan->chan_common);
|
|
|
|
if (!(txd->flags & DMA_COMPL_SKIP_DEST_UNMAP)) {
|
|
|
|
if (txd->flags & DMA_COMPL_DEST_UNMAP_SINGLE)
|
|
|
|
dma_unmap_single(parent,
|
|
|
|
desc->lli.daddr,
|
|
|
|
desc->len, DMA_FROM_DEVICE);
|
|
|
|
else
|
|
|
|
dma_unmap_page(parent,
|
|
|
|
desc->lli.daddr,
|
|
|
|
desc->len, DMA_FROM_DEVICE);
|
|
|
|
}
|
|
|
|
if (!(txd->flags & DMA_COMPL_SKIP_SRC_UNMAP)) {
|
|
|
|
if (txd->flags & DMA_COMPL_SRC_UNMAP_SINGLE)
|
|
|
|
dma_unmap_single(parent,
|
|
|
|
desc->lli.saddr,
|
|
|
|
desc->len, DMA_TO_DEVICE);
|
|
|
|
else
|
|
|
|
dma_unmap_page(parent,
|
|
|
|
desc->lli.saddr,
|
|
|
|
desc->len, DMA_TO_DEVICE);
|
|
|
|
}
|
2009-07-04 00:24:33 +07:00
|
|
|
}
|
|
|
|
|
2011-04-30 21:57:46 +07:00
|
|
|
/* for cyclic transfers,
|
|
|
|
* no need to replay callback function while stopping */
|
2011-07-26 04:09:23 +07:00
|
|
|
if (!atc_chan_is_cyclic(atchan)) {
|
2011-04-30 21:57:46 +07:00
|
|
|
dma_async_tx_callback callback = txd->callback;
|
|
|
|
void *param = txd->callback_param;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The API requires that no submissions are done from a
|
|
|
|
* callback, so we don't need to drop the lock here
|
|
|
|
*/
|
|
|
|
if (callback)
|
|
|
|
callback(param);
|
|
|
|
}
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
dma_run_dependencies(txd);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* atc_complete_all - finish work for all transactions
|
|
|
|
* @atchan: channel to complete transactions for
|
|
|
|
*
|
|
|
|
* Eventually submit queued descriptors if any
|
|
|
|
*
|
|
|
|
* Assume channel is idle while calling this function
|
|
|
|
* Called with atchan->lock held and bh disabled
|
|
|
|
*/
|
|
|
|
static void atc_complete_all(struct at_dma_chan *atchan)
|
|
|
|
{
|
|
|
|
struct at_desc *desc, *_desc;
|
|
|
|
LIST_HEAD(list);
|
|
|
|
|
|
|
|
dev_vdbg(chan2dev(&atchan->chan_common), "complete all\n");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Submit queued descriptors ASAP, i.e. before we go through
|
|
|
|
* the completed ones.
|
|
|
|
*/
|
|
|
|
if (!list_empty(&atchan->queue))
|
|
|
|
atc_dostart(atchan, atc_first_queued(atchan));
|
|
|
|
/* empty active_list now it is completed */
|
|
|
|
list_splice_init(&atchan->active_list, &list);
|
|
|
|
/* empty queue list by moving descriptors (if any) to active_list */
|
|
|
|
list_splice_init(&atchan->queue, &atchan->active_list);
|
|
|
|
|
|
|
|
list_for_each_entry_safe(desc, _desc, &list, desc_node)
|
|
|
|
atc_chain_complete(atchan, desc);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* atc_advance_work - at the end of a transaction, move forward
|
|
|
|
* @atchan: channel where the transaction ended
|
|
|
|
*
|
|
|
|
* Called with atchan->lock held and bh disabled
|
|
|
|
*/
|
|
|
|
static void atc_advance_work(struct at_dma_chan *atchan)
|
|
|
|
{
|
|
|
|
dev_vdbg(chan2dev(&atchan->chan_common), "advance_work\n");
|
|
|
|
|
2013-04-18 14:52:59 +07:00
|
|
|
if (atc_chan_is_enabled(atchan))
|
|
|
|
return;
|
|
|
|
|
2009-07-04 00:24:33 +07:00
|
|
|
if (list_empty(&atchan->active_list) ||
|
|
|
|
list_is_singular(&atchan->active_list)) {
|
|
|
|
atc_complete_all(atchan);
|
|
|
|
} else {
|
|
|
|
atc_chain_complete(atchan, atc_first_active(atchan));
|
|
|
|
/* advance work */
|
|
|
|
atc_dostart(atchan, atc_first_active(atchan));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* atc_handle_error - handle errors reported by DMA controller
|
|
|
|
* @atchan: channel where error occurs
|
|
|
|
*
|
|
|
|
* Called with atchan->lock held and bh disabled
|
|
|
|
*/
|
|
|
|
static void atc_handle_error(struct at_dma_chan *atchan)
|
|
|
|
{
|
|
|
|
struct at_desc *bad_desc;
|
|
|
|
struct at_desc *child;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The descriptor currently at the head of the active list is
|
|
|
|
* broked. Since we don't have any way to report errors, we'll
|
|
|
|
* just have to scream loudly and try to carry on.
|
|
|
|
*/
|
|
|
|
bad_desc = atc_first_active(atchan);
|
|
|
|
list_del_init(&bad_desc->desc_node);
|
|
|
|
|
|
|
|
/* As we are stopped, take advantage to push queued descriptors
|
|
|
|
* in active_list */
|
|
|
|
list_splice_init(&atchan->queue, atchan->active_list.prev);
|
|
|
|
|
|
|
|
/* Try to restart the controller */
|
|
|
|
if (!list_empty(&atchan->active_list))
|
|
|
|
atc_dostart(atchan, atc_first_active(atchan));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* KERN_CRITICAL may seem harsh, but since this only happens
|
|
|
|
* when someone submits a bad physical address in a
|
|
|
|
* descriptor, we should consider ourselves lucky that the
|
|
|
|
* controller flagged an error instead of scribbling over
|
|
|
|
* random memory locations.
|
|
|
|
*/
|
|
|
|
dev_crit(chan2dev(&atchan->chan_common),
|
|
|
|
"Bad descriptor submitted for DMA!\n");
|
|
|
|
dev_crit(chan2dev(&atchan->chan_common),
|
|
|
|
" cookie: %d\n", bad_desc->txd.cookie);
|
|
|
|
atc_dump_lli(atchan, &bad_desc->lli);
|
2009-09-09 07:53:03 +07:00
|
|
|
list_for_each_entry(child, &bad_desc->tx_list, desc_node)
|
2009-07-04 00:24:33 +07:00
|
|
|
atc_dump_lli(atchan, &child->lli);
|
|
|
|
|
|
|
|
/* Pretend the descriptor completed successfully */
|
|
|
|
atc_chain_complete(atchan, bad_desc);
|
|
|
|
}
|
|
|
|
|
2011-04-30 21:57:46 +07:00
|
|
|
/**
|
|
|
|
* atc_handle_cyclic - at the end of a period, run callback function
|
|
|
|
* @atchan: channel used for cyclic operations
|
|
|
|
*
|
|
|
|
* Called with atchan->lock held and bh disabled
|
|
|
|
*/
|
|
|
|
static void atc_handle_cyclic(struct at_dma_chan *atchan)
|
|
|
|
{
|
|
|
|
struct at_desc *first = atc_first_active(atchan);
|
|
|
|
struct dma_async_tx_descriptor *txd = &first->txd;
|
|
|
|
dma_async_tx_callback callback = txd->callback;
|
|
|
|
void *param = txd->callback_param;
|
|
|
|
|
|
|
|
dev_vdbg(chan2dev(&atchan->chan_common),
|
|
|
|
"new cyclic period llp 0x%08x\n",
|
|
|
|
channel_readl(atchan, DSCR));
|
|
|
|
|
|
|
|
if (callback)
|
|
|
|
callback(param);
|
|
|
|
}
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
/*-- IRQ & Tasklet ---------------------------------------------------*/
|
|
|
|
|
|
|
|
static void atc_tasklet(unsigned long data)
|
|
|
|
{
|
|
|
|
struct at_dma_chan *atchan = (struct at_dma_chan *)data;
|
2011-07-27 19:21:28 +07:00
|
|
|
unsigned long flags;
|
2009-07-04 00:24:33 +07:00
|
|
|
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_lock_irqsave(&atchan->lock, flags);
|
2011-04-30 21:57:46 +07:00
|
|
|
if (test_and_clear_bit(ATC_IS_ERROR, &atchan->status))
|
2009-07-04 00:24:33 +07:00
|
|
|
atc_handle_error(atchan);
|
2011-07-26 04:09:23 +07:00
|
|
|
else if (atc_chan_is_cyclic(atchan))
|
2011-04-30 21:57:46 +07:00
|
|
|
atc_handle_cyclic(atchan);
|
2009-07-04 00:24:33 +07:00
|
|
|
else
|
|
|
|
atc_advance_work(atchan);
|
|
|
|
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_unlock_irqrestore(&atchan->lock, flags);
|
2009-07-04 00:24:33 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static irqreturn_t at_dma_interrupt(int irq, void *dev_id)
|
|
|
|
{
|
|
|
|
struct at_dma *atdma = (struct at_dma *)dev_id;
|
|
|
|
struct at_dma_chan *atchan;
|
|
|
|
int i;
|
|
|
|
u32 status, pending, imr;
|
|
|
|
int ret = IRQ_NONE;
|
|
|
|
|
|
|
|
do {
|
|
|
|
imr = dma_readl(atdma, EBCIMR);
|
|
|
|
status = dma_readl(atdma, EBCISR);
|
|
|
|
pending = status & imr;
|
|
|
|
|
|
|
|
if (!pending)
|
|
|
|
break;
|
|
|
|
|
|
|
|
dev_vdbg(atdma->dma_common.dev,
|
|
|
|
"interrupt: status = 0x%08x, 0x%08x, 0x%08x\n",
|
|
|
|
status, imr, pending);
|
|
|
|
|
|
|
|
for (i = 0; i < atdma->dma_common.chancnt; i++) {
|
|
|
|
atchan = &atdma->chan[i];
|
2011-04-30 21:57:45 +07:00
|
|
|
if (pending & (AT_DMA_BTC(i) | AT_DMA_ERR(i))) {
|
2009-07-04 00:24:33 +07:00
|
|
|
if (pending & AT_DMA_ERR(i)) {
|
|
|
|
/* Disable channel on AHB error */
|
2011-05-07 00:56:52 +07:00
|
|
|
dma_writel(atdma, CHDR,
|
|
|
|
AT_DMA_RES(i) | atchan->mask);
|
2009-07-04 00:24:33 +07:00
|
|
|
/* Give information to tasklet */
|
2011-04-30 21:57:46 +07:00
|
|
|
set_bit(ATC_IS_ERROR, &atchan->status);
|
2009-07-04 00:24:33 +07:00
|
|
|
}
|
2013-05-10 10:01:46 +07:00
|
|
|
if (pending & AT_DMA_BTC(i))
|
|
|
|
set_bit(ATC_IS_BTC, &atchan->status);
|
2009-07-04 00:24:33 +07:00
|
|
|
tasklet_schedule(&atchan->tasklet);
|
|
|
|
ret = IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} while (pending);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*-- DMA Engine API --------------------------------------------------*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* atc_tx_submit - set the prepared descriptor(s) to be executed by the engine
|
|
|
|
* @desc: descriptor at the head of the transaction chain
|
|
|
|
*
|
|
|
|
* Queue chain if DMA engine is working already
|
|
|
|
*
|
|
|
|
* Cookie increment and adding to active_list or queue must be atomic
|
|
|
|
*/
|
|
|
|
static dma_cookie_t atc_tx_submit(struct dma_async_tx_descriptor *tx)
|
|
|
|
{
|
|
|
|
struct at_desc *desc = txd_to_at_desc(tx);
|
|
|
|
struct at_dma_chan *atchan = to_at_dma_chan(tx->chan);
|
|
|
|
dma_cookie_t cookie;
|
2011-07-27 19:21:28 +07:00
|
|
|
unsigned long flags;
|
2009-07-04 00:24:33 +07:00
|
|
|
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_lock_irqsave(&atchan->lock, flags);
|
2012-03-07 05:34:46 +07:00
|
|
|
cookie = dma_cookie_assign(tx);
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
if (list_empty(&atchan->active_list)) {
|
|
|
|
dev_vdbg(chan2dev(tx->chan), "tx_submit: started %u\n",
|
|
|
|
desc->txd.cookie);
|
|
|
|
atc_dostart(atchan, desc);
|
|
|
|
list_add_tail(&desc->desc_node, &atchan->active_list);
|
|
|
|
} else {
|
|
|
|
dev_vdbg(chan2dev(tx->chan), "tx_submit: queued %u\n",
|
|
|
|
desc->txd.cookie);
|
|
|
|
list_add_tail(&desc->desc_node, &atchan->queue);
|
|
|
|
}
|
|
|
|
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_unlock_irqrestore(&atchan->lock, flags);
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
return cookie;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* atc_prep_dma_memcpy - prepare a memcpy operation
|
|
|
|
* @chan: the channel to prepare operation on
|
|
|
|
* @dest: operation virtual destination address
|
|
|
|
* @src: operation virtual source address
|
|
|
|
* @len: operation length
|
|
|
|
* @flags: tx descriptor status flags
|
|
|
|
*/
|
|
|
|
static struct dma_async_tx_descriptor *
|
|
|
|
atc_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
|
|
|
|
size_t len, unsigned long flags)
|
|
|
|
{
|
|
|
|
struct at_dma_chan *atchan = to_at_dma_chan(chan);
|
|
|
|
struct at_desc *desc = NULL;
|
|
|
|
struct at_desc *first = NULL;
|
|
|
|
struct at_desc *prev = NULL;
|
|
|
|
size_t xfer_count;
|
|
|
|
size_t offset;
|
|
|
|
unsigned int src_width;
|
|
|
|
unsigned int dst_width;
|
|
|
|
u32 ctrla;
|
|
|
|
u32 ctrlb;
|
|
|
|
|
|
|
|
dev_vdbg(chan2dev(chan), "prep_dma_memcpy: d0x%x s0x%x l0x%zx f0x%lx\n",
|
|
|
|
dest, src, len, flags);
|
|
|
|
|
|
|
|
if (unlikely(!len)) {
|
|
|
|
dev_dbg(chan2dev(chan), "prep_dma_memcpy: length is zero!\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-04-30 21:57:45 +07:00
|
|
|
ctrlb = ATC_DEFAULT_CTRLB | ATC_IEN
|
2009-07-04 00:24:33 +07:00
|
|
|
| ATC_SRC_ADDR_MODE_INCR
|
|
|
|
| ATC_DST_ADDR_MODE_INCR
|
|
|
|
| ATC_FC_MEM2MEM;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We can be a lot more clever here, but this should take care
|
|
|
|
* of the most common optimization.
|
|
|
|
*/
|
|
|
|
if (!((src | dest | len) & 3)) {
|
2012-05-10 17:17:40 +07:00
|
|
|
ctrla = ATC_SRC_WIDTH_WORD | ATC_DST_WIDTH_WORD;
|
2009-07-04 00:24:33 +07:00
|
|
|
src_width = dst_width = 2;
|
|
|
|
} else if (!((src | dest | len) & 1)) {
|
2012-05-10 17:17:40 +07:00
|
|
|
ctrla = ATC_SRC_WIDTH_HALFWORD | ATC_DST_WIDTH_HALFWORD;
|
2009-07-04 00:24:33 +07:00
|
|
|
src_width = dst_width = 1;
|
|
|
|
} else {
|
2012-05-10 17:17:40 +07:00
|
|
|
ctrla = ATC_SRC_WIDTH_BYTE | ATC_DST_WIDTH_BYTE;
|
2009-07-04 00:24:33 +07:00
|
|
|
src_width = dst_width = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (offset = 0; offset < len; offset += xfer_count << src_width) {
|
|
|
|
xfer_count = min_t(size_t, (len - offset) >> src_width,
|
|
|
|
ATC_BTSIZE_MAX);
|
|
|
|
|
|
|
|
desc = atc_desc_get(atchan);
|
|
|
|
if (!desc)
|
|
|
|
goto err_desc_get;
|
|
|
|
|
|
|
|
desc->lli.saddr = src + offset;
|
|
|
|
desc->lli.daddr = dest + offset;
|
|
|
|
desc->lli.ctrla = ctrla | xfer_count;
|
|
|
|
desc->lli.ctrlb = ctrlb;
|
|
|
|
|
|
|
|
desc->txd.cookie = 0;
|
|
|
|
|
2011-05-07 00:56:53 +07:00
|
|
|
atc_desc_chain(&first, &prev, desc);
|
2009-07-04 00:24:33 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* First descriptor of the chain embedds additional information */
|
|
|
|
first->txd.cookie = -EBUSY;
|
|
|
|
first->len = len;
|
2013-05-10 10:00:50 +07:00
|
|
|
first->tx_width = src_width;
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
/* set end-of-link to the last link descriptor of list*/
|
|
|
|
set_desc_eol(desc);
|
|
|
|
|
2011-01-12 21:39:09 +07:00
|
|
|
first->txd.flags = flags; /* client is in control of this ack */
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
return &first->txd;
|
|
|
|
|
|
|
|
err_desc_get:
|
|
|
|
atc_desc_put(atchan, first);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-07-23 01:04:45 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* atc_prep_slave_sg - prepare descriptors for a DMA_SLAVE transaction
|
|
|
|
* @chan: DMA channel
|
|
|
|
* @sgl: scatterlist to transfer to/from
|
|
|
|
* @sg_len: number of entries in @scatterlist
|
|
|
|
* @direction: DMA direction
|
|
|
|
* @flags: tx descriptor status flags
|
2012-03-09 03:35:13 +07:00
|
|
|
* @context: transaction context (ignored)
|
2009-07-23 01:04:45 +07:00
|
|
|
*/
|
|
|
|
static struct dma_async_tx_descriptor *
|
|
|
|
atc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
|
2011-10-14 00:04:23 +07:00
|
|
|
unsigned int sg_len, enum dma_transfer_direction direction,
|
2012-03-09 03:35:13 +07:00
|
|
|
unsigned long flags, void *context)
|
2009-07-23 01:04:45 +07:00
|
|
|
{
|
|
|
|
struct at_dma_chan *atchan = to_at_dma_chan(chan);
|
|
|
|
struct at_dma_slave *atslave = chan->private;
|
2012-03-14 18:41:43 +07:00
|
|
|
struct dma_slave_config *sconfig = &atchan->dma_sconfig;
|
2009-07-23 01:04:45 +07:00
|
|
|
struct at_desc *first = NULL;
|
|
|
|
struct at_desc *prev = NULL;
|
|
|
|
u32 ctrla;
|
|
|
|
u32 ctrlb;
|
|
|
|
dma_addr_t reg;
|
|
|
|
unsigned int reg_width;
|
|
|
|
unsigned int mem_width;
|
|
|
|
unsigned int i;
|
|
|
|
struct scatterlist *sg;
|
|
|
|
size_t total_len = 0;
|
|
|
|
|
2011-04-30 21:57:47 +07:00
|
|
|
dev_vdbg(chan2dev(chan), "prep_slave_sg (%d): %s f0x%lx\n",
|
|
|
|
sg_len,
|
2011-10-14 00:04:23 +07:00
|
|
|
direction == DMA_MEM_TO_DEV ? "TO DEVICE" : "FROM DEVICE",
|
2009-07-23 01:04:45 +07:00
|
|
|
flags);
|
|
|
|
|
|
|
|
if (unlikely(!atslave || !sg_len)) {
|
2012-09-11 22:21:44 +07:00
|
|
|
dev_dbg(chan2dev(chan), "prep_slave_sg: sg length is zero!\n");
|
2009-07-23 01:04:45 +07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-05-10 17:17:41 +07:00
|
|
|
ctrla = ATC_SCSIZE(sconfig->src_maxburst)
|
|
|
|
| ATC_DCSIZE(sconfig->dst_maxburst);
|
2011-04-30 21:57:49 +07:00
|
|
|
ctrlb = ATC_IEN;
|
2009-07-23 01:04:45 +07:00
|
|
|
|
|
|
|
switch (direction) {
|
2011-10-14 00:04:23 +07:00
|
|
|
case DMA_MEM_TO_DEV:
|
2012-03-14 18:41:43 +07:00
|
|
|
reg_width = convert_buswidth(sconfig->dst_addr_width);
|
2009-07-23 01:04:45 +07:00
|
|
|
ctrla |= ATC_DST_WIDTH(reg_width);
|
|
|
|
ctrlb |= ATC_DST_ADDR_MODE_FIXED
|
|
|
|
| ATC_SRC_ADDR_MODE_INCR
|
2011-04-30 21:57:49 +07:00
|
|
|
| ATC_FC_MEM2PER
|
2013-04-19 16:11:18 +07:00
|
|
|
| ATC_SIF(atchan->mem_if) | ATC_DIF(atchan->per_if);
|
2012-03-14 18:41:43 +07:00
|
|
|
reg = sconfig->dst_addr;
|
2009-07-23 01:04:45 +07:00
|
|
|
for_each_sg(sgl, sg, sg_len, i) {
|
|
|
|
struct at_desc *desc;
|
|
|
|
u32 len;
|
|
|
|
u32 mem;
|
|
|
|
|
|
|
|
desc = atc_desc_get(atchan);
|
|
|
|
if (!desc)
|
|
|
|
goto err_desc_get;
|
|
|
|
|
2010-12-16 00:50:16 +07:00
|
|
|
mem = sg_dma_address(sg);
|
2009-07-23 01:04:45 +07:00
|
|
|
len = sg_dma_len(sg);
|
2012-09-11 22:21:45 +07:00
|
|
|
if (unlikely(!len)) {
|
|
|
|
dev_dbg(chan2dev(chan),
|
|
|
|
"prep_slave_sg: sg(%d) data length is zero\n", i);
|
|
|
|
goto err;
|
|
|
|
}
|
2009-07-23 01:04:45 +07:00
|
|
|
mem_width = 2;
|
|
|
|
if (unlikely(mem & 3 || len & 3))
|
|
|
|
mem_width = 0;
|
|
|
|
|
|
|
|
desc->lli.saddr = mem;
|
|
|
|
desc->lli.daddr = reg;
|
|
|
|
desc->lli.ctrla = ctrla
|
|
|
|
| ATC_SRC_WIDTH(mem_width)
|
|
|
|
| len >> mem_width;
|
|
|
|
desc->lli.ctrlb = ctrlb;
|
|
|
|
|
2011-05-07 00:56:53 +07:00
|
|
|
atc_desc_chain(&first, &prev, desc);
|
2009-07-23 01:04:45 +07:00
|
|
|
total_len += len;
|
|
|
|
}
|
|
|
|
break;
|
2011-10-14 00:04:23 +07:00
|
|
|
case DMA_DEV_TO_MEM:
|
2012-03-14 18:41:43 +07:00
|
|
|
reg_width = convert_buswidth(sconfig->src_addr_width);
|
2009-07-23 01:04:45 +07:00
|
|
|
ctrla |= ATC_SRC_WIDTH(reg_width);
|
|
|
|
ctrlb |= ATC_DST_ADDR_MODE_INCR
|
|
|
|
| ATC_SRC_ADDR_MODE_FIXED
|
2011-04-30 21:57:49 +07:00
|
|
|
| ATC_FC_PER2MEM
|
2013-04-19 16:11:18 +07:00
|
|
|
| ATC_SIF(atchan->per_if) | ATC_DIF(atchan->mem_if);
|
2009-07-23 01:04:45 +07:00
|
|
|
|
2012-03-14 18:41:43 +07:00
|
|
|
reg = sconfig->src_addr;
|
2009-07-23 01:04:45 +07:00
|
|
|
for_each_sg(sgl, sg, sg_len, i) {
|
|
|
|
struct at_desc *desc;
|
|
|
|
u32 len;
|
|
|
|
u32 mem;
|
|
|
|
|
|
|
|
desc = atc_desc_get(atchan);
|
|
|
|
if (!desc)
|
|
|
|
goto err_desc_get;
|
|
|
|
|
2010-12-16 00:50:16 +07:00
|
|
|
mem = sg_dma_address(sg);
|
2009-07-23 01:04:45 +07:00
|
|
|
len = sg_dma_len(sg);
|
2012-09-11 22:21:45 +07:00
|
|
|
if (unlikely(!len)) {
|
|
|
|
dev_dbg(chan2dev(chan),
|
|
|
|
"prep_slave_sg: sg(%d) data length is zero\n", i);
|
|
|
|
goto err;
|
|
|
|
}
|
2009-07-23 01:04:45 +07:00
|
|
|
mem_width = 2;
|
|
|
|
if (unlikely(mem & 3 || len & 3))
|
|
|
|
mem_width = 0;
|
|
|
|
|
|
|
|
desc->lli.saddr = reg;
|
|
|
|
desc->lli.daddr = mem;
|
|
|
|
desc->lli.ctrla = ctrla
|
|
|
|
| ATC_DST_WIDTH(mem_width)
|
2010-12-13 19:48:41 +07:00
|
|
|
| len >> reg_width;
|
2009-07-23 01:04:45 +07:00
|
|
|
desc->lli.ctrlb = ctrlb;
|
|
|
|
|
2011-05-07 00:56:53 +07:00
|
|
|
atc_desc_chain(&first, &prev, desc);
|
2009-07-23 01:04:45 +07:00
|
|
|
total_len += len;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set end-of-link to the last link descriptor of list*/
|
|
|
|
set_desc_eol(prev);
|
|
|
|
|
|
|
|
/* First descriptor of the chain embedds additional information */
|
|
|
|
first->txd.cookie = -EBUSY;
|
|
|
|
first->len = total_len;
|
2013-05-10 10:00:50 +07:00
|
|
|
first->tx_width = reg_width;
|
2009-07-23 01:04:45 +07:00
|
|
|
|
2011-01-12 21:39:09 +07:00
|
|
|
/* first link descriptor of list is responsible of flags */
|
|
|
|
first->txd.flags = flags; /* client is in control of this ack */
|
2009-07-23 01:04:45 +07:00
|
|
|
|
|
|
|
return &first->txd;
|
|
|
|
|
|
|
|
err_desc_get:
|
|
|
|
dev_err(chan2dev(chan), "not enough descriptors available\n");
|
2012-09-11 22:21:45 +07:00
|
|
|
err:
|
2009-07-23 01:04:45 +07:00
|
|
|
atc_desc_put(atchan, first);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-04-30 21:57:46 +07:00
|
|
|
/**
|
|
|
|
* atc_dma_cyclic_check_values
|
|
|
|
* Check for too big/unaligned periods and unaligned DMA buffer
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
atc_dma_cyclic_check_values(unsigned int reg_width, dma_addr_t buf_addr,
|
2013-01-10 15:52:57 +07:00
|
|
|
size_t period_len)
|
2011-04-30 21:57:46 +07:00
|
|
|
{
|
|
|
|
if (period_len > (ATC_BTSIZE_MAX << reg_width))
|
|
|
|
goto err_out;
|
|
|
|
if (unlikely(period_len & ((1 << reg_width) - 1)))
|
|
|
|
goto err_out;
|
|
|
|
if (unlikely(buf_addr & ((1 << reg_width) - 1)))
|
|
|
|
goto err_out;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_out:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-08-04 21:37:53 +07:00
|
|
|
* atc_dma_cyclic_fill_desc - Fill one period descriptor
|
2011-04-30 21:57:46 +07:00
|
|
|
*/
|
|
|
|
static int
|
2012-03-14 18:41:43 +07:00
|
|
|
atc_dma_cyclic_fill_desc(struct dma_chan *chan, struct at_desc *desc,
|
2011-04-30 21:57:46 +07:00
|
|
|
unsigned int period_index, dma_addr_t buf_addr,
|
2012-03-14 18:41:43 +07:00
|
|
|
unsigned int reg_width, size_t period_len,
|
|
|
|
enum dma_transfer_direction direction)
|
2011-04-30 21:57:46 +07:00
|
|
|
{
|
2012-03-14 18:41:43 +07:00
|
|
|
struct at_dma_chan *atchan = to_at_dma_chan(chan);
|
|
|
|
struct dma_slave_config *sconfig = &atchan->dma_sconfig;
|
|
|
|
u32 ctrla;
|
2011-04-30 21:57:46 +07:00
|
|
|
|
|
|
|
/* prepare common CRTLA value */
|
2012-05-10 17:17:41 +07:00
|
|
|
ctrla = ATC_SCSIZE(sconfig->src_maxburst)
|
|
|
|
| ATC_DCSIZE(sconfig->dst_maxburst)
|
2011-04-30 21:57:46 +07:00
|
|
|
| ATC_DST_WIDTH(reg_width)
|
|
|
|
| ATC_SRC_WIDTH(reg_width)
|
|
|
|
| period_len >> reg_width;
|
|
|
|
|
|
|
|
switch (direction) {
|
2011-10-14 00:04:23 +07:00
|
|
|
case DMA_MEM_TO_DEV:
|
2011-04-30 21:57:46 +07:00
|
|
|
desc->lli.saddr = buf_addr + (period_len * period_index);
|
2012-03-14 18:41:43 +07:00
|
|
|
desc->lli.daddr = sconfig->dst_addr;
|
2011-04-30 21:57:46 +07:00
|
|
|
desc->lli.ctrla = ctrla;
|
2011-04-30 21:57:49 +07:00
|
|
|
desc->lli.ctrlb = ATC_DST_ADDR_MODE_FIXED
|
2011-04-30 21:57:46 +07:00
|
|
|
| ATC_SRC_ADDR_MODE_INCR
|
2011-04-30 21:57:49 +07:00
|
|
|
| ATC_FC_MEM2PER
|
2013-04-19 16:11:18 +07:00
|
|
|
| ATC_SIF(atchan->mem_if)
|
|
|
|
| ATC_DIF(atchan->per_if);
|
2011-04-30 21:57:46 +07:00
|
|
|
break;
|
|
|
|
|
2011-10-14 00:04:23 +07:00
|
|
|
case DMA_DEV_TO_MEM:
|
2012-03-14 18:41:43 +07:00
|
|
|
desc->lli.saddr = sconfig->src_addr;
|
2011-04-30 21:57:46 +07:00
|
|
|
desc->lli.daddr = buf_addr + (period_len * period_index);
|
|
|
|
desc->lli.ctrla = ctrla;
|
2011-04-30 21:57:49 +07:00
|
|
|
desc->lli.ctrlb = ATC_DST_ADDR_MODE_INCR
|
2011-04-30 21:57:46 +07:00
|
|
|
| ATC_SRC_ADDR_MODE_FIXED
|
2011-04-30 21:57:49 +07:00
|
|
|
| ATC_FC_PER2MEM
|
2013-04-19 16:11:18 +07:00
|
|
|
| ATC_SIF(atchan->per_if)
|
|
|
|
| ATC_DIF(atchan->mem_if);
|
2011-04-30 21:57:46 +07:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* atc_prep_dma_cyclic - prepare the cyclic DMA transfer
|
|
|
|
* @chan: the DMA channel to prepare
|
|
|
|
* @buf_addr: physical DMA address where the buffer starts
|
|
|
|
* @buf_len: total number of bytes for the entire buffer
|
|
|
|
* @period_len: number of bytes for each period
|
|
|
|
* @direction: transfer direction, to or from device
|
2012-09-14 19:05:47 +07:00
|
|
|
* @flags: tx descriptor status flags
|
2012-03-09 03:35:13 +07:00
|
|
|
* @context: transfer context (ignored)
|
2011-04-30 21:57:46 +07:00
|
|
|
*/
|
|
|
|
static struct dma_async_tx_descriptor *
|
|
|
|
atc_prep_dma_cyclic(struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len,
|
2012-03-09 03:35:13 +07:00
|
|
|
size_t period_len, enum dma_transfer_direction direction,
|
2012-09-14 19:05:47 +07:00
|
|
|
unsigned long flags, void *context)
|
2011-04-30 21:57:46 +07:00
|
|
|
{
|
|
|
|
struct at_dma_chan *atchan = to_at_dma_chan(chan);
|
|
|
|
struct at_dma_slave *atslave = chan->private;
|
2012-03-14 18:41:43 +07:00
|
|
|
struct dma_slave_config *sconfig = &atchan->dma_sconfig;
|
2011-04-30 21:57:46 +07:00
|
|
|
struct at_desc *first = NULL;
|
|
|
|
struct at_desc *prev = NULL;
|
|
|
|
unsigned long was_cyclic;
|
2012-03-14 18:41:43 +07:00
|
|
|
unsigned int reg_width;
|
2011-04-30 21:57:46 +07:00
|
|
|
unsigned int periods = buf_len / period_len;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
dev_vdbg(chan2dev(chan), "prep_dma_cyclic: %s buf@0x%08x - %d (%d/%d)\n",
|
2011-10-14 00:04:23 +07:00
|
|
|
direction == DMA_MEM_TO_DEV ? "TO DEVICE" : "FROM DEVICE",
|
2011-04-30 21:57:46 +07:00
|
|
|
buf_addr,
|
|
|
|
periods, buf_len, period_len);
|
|
|
|
|
|
|
|
if (unlikely(!atslave || !buf_len || !period_len)) {
|
|
|
|
dev_dbg(chan2dev(chan), "prep_dma_cyclic: length is zero!\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
was_cyclic = test_and_set_bit(ATC_IS_CYCLIC, &atchan->status);
|
|
|
|
if (was_cyclic) {
|
|
|
|
dev_dbg(chan2dev(chan), "prep_dma_cyclic: channel in use!\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-01-10 15:52:57 +07:00
|
|
|
if (unlikely(!is_slave_direction(direction)))
|
|
|
|
goto err_out;
|
|
|
|
|
2012-03-14 18:41:43 +07:00
|
|
|
if (sconfig->direction == DMA_MEM_TO_DEV)
|
|
|
|
reg_width = convert_buswidth(sconfig->dst_addr_width);
|
|
|
|
else
|
|
|
|
reg_width = convert_buswidth(sconfig->src_addr_width);
|
|
|
|
|
2011-04-30 21:57:46 +07:00
|
|
|
/* Check for too big/unaligned periods and unaligned DMA buffer */
|
2013-01-10 15:52:57 +07:00
|
|
|
if (atc_dma_cyclic_check_values(reg_width, buf_addr, period_len))
|
2011-04-30 21:57:46 +07:00
|
|
|
goto err_out;
|
|
|
|
|
|
|
|
/* build cyclic linked list */
|
|
|
|
for (i = 0; i < periods; i++) {
|
|
|
|
struct at_desc *desc;
|
|
|
|
|
|
|
|
desc = atc_desc_get(atchan);
|
|
|
|
if (!desc)
|
|
|
|
goto err_desc_get;
|
|
|
|
|
2012-03-14 18:41:43 +07:00
|
|
|
if (atc_dma_cyclic_fill_desc(chan, desc, i, buf_addr,
|
|
|
|
reg_width, period_len, direction))
|
2011-04-30 21:57:46 +07:00
|
|
|
goto err_desc_get;
|
|
|
|
|
|
|
|
atc_desc_chain(&first, &prev, desc);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* lets make a cyclic list */
|
|
|
|
prev->lli.dscr = first->txd.phys;
|
|
|
|
|
|
|
|
/* First descriptor of the chain embedds additional information */
|
|
|
|
first->txd.cookie = -EBUSY;
|
|
|
|
first->len = buf_len;
|
2013-05-10 10:00:50 +07:00
|
|
|
first->tx_width = reg_width;
|
2011-04-30 21:57:46 +07:00
|
|
|
|
|
|
|
return &first->txd;
|
|
|
|
|
|
|
|
err_desc_get:
|
|
|
|
dev_err(chan2dev(chan), "not enough descriptors available\n");
|
|
|
|
atc_desc_put(atchan, first);
|
|
|
|
err_out:
|
|
|
|
clear_bit(ATC_IS_CYCLIC, &atchan->status);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-03-14 18:41:43 +07:00
|
|
|
static int set_runtime_config(struct dma_chan *chan,
|
|
|
|
struct dma_slave_config *sconfig)
|
|
|
|
{
|
|
|
|
struct at_dma_chan *atchan = to_at_dma_chan(chan);
|
|
|
|
|
|
|
|
/* Check if it is chan is configured for slave transfers */
|
|
|
|
if (!chan->private)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
memcpy(&atchan->dma_sconfig, sconfig, sizeof(*sconfig));
|
|
|
|
|
|
|
|
convert_burst(&atchan->dma_sconfig.src_maxburst);
|
|
|
|
convert_burst(&atchan->dma_sconfig.dst_maxburst);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-04-30 21:57:46 +07:00
|
|
|
|
2010-05-18 06:30:42 +07:00
|
|
|
static int atc_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
|
|
|
|
unsigned long arg)
|
2009-07-23 01:04:45 +07:00
|
|
|
{
|
|
|
|
struct at_dma_chan *atchan = to_at_dma_chan(chan);
|
|
|
|
struct at_dma *atdma = to_at_dma(chan->device);
|
2011-05-07 00:56:52 +07:00
|
|
|
int chan_id = atchan->chan_common.chan_id;
|
2011-07-27 19:21:28 +07:00
|
|
|
unsigned long flags;
|
2011-05-07 00:56:52 +07:00
|
|
|
|
2009-07-23 01:04:45 +07:00
|
|
|
LIST_HEAD(list);
|
|
|
|
|
2011-05-07 00:56:52 +07:00
|
|
|
dev_vdbg(chan2dev(chan), "atc_control (%d)\n", cmd);
|
2010-03-27 06:44:01 +07:00
|
|
|
|
2011-05-07 00:56:52 +07:00
|
|
|
if (cmd == DMA_PAUSE) {
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_lock_irqsave(&atchan->lock, flags);
|
2009-07-23 01:04:45 +07:00
|
|
|
|
2011-05-07 00:56:52 +07:00
|
|
|
dma_writel(atdma, CHER, AT_DMA_SUSP(chan_id));
|
|
|
|
set_bit(ATC_IS_PAUSED, &atchan->status);
|
2009-07-23 01:04:45 +07:00
|
|
|
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_unlock_irqrestore(&atchan->lock, flags);
|
2011-05-07 00:56:52 +07:00
|
|
|
} else if (cmd == DMA_RESUME) {
|
2011-07-26 04:09:23 +07:00
|
|
|
if (!atc_chan_is_paused(atchan))
|
2011-05-07 00:56:52 +07:00
|
|
|
return 0;
|
2009-07-23 01:04:45 +07:00
|
|
|
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_lock_irqsave(&atchan->lock, flags);
|
2009-07-23 01:04:45 +07:00
|
|
|
|
2011-05-07 00:56:52 +07:00
|
|
|
dma_writel(atdma, CHDR, AT_DMA_RES(chan_id));
|
|
|
|
clear_bit(ATC_IS_PAUSED, &atchan->status);
|
2010-03-27 06:44:01 +07:00
|
|
|
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_unlock_irqrestore(&atchan->lock, flags);
|
2011-05-07 00:56:52 +07:00
|
|
|
} else if (cmd == DMA_TERMINATE_ALL) {
|
|
|
|
struct at_desc *desc, *_desc;
|
|
|
|
/*
|
|
|
|
* This is only called when something went wrong elsewhere, so
|
|
|
|
* we don't really care about the data. Just disable the
|
|
|
|
* channel. We still have to poll the channel enable bit due
|
|
|
|
* to AHB/HSB limitations.
|
|
|
|
*/
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_lock_irqsave(&atchan->lock, flags);
|
2011-05-07 00:56:52 +07:00
|
|
|
|
|
|
|
/* disabling channel: must also remove suspend state */
|
|
|
|
dma_writel(atdma, CHDR, AT_DMA_RES(chan_id) | atchan->mask);
|
|
|
|
|
|
|
|
/* confirm that this channel is disabled */
|
|
|
|
while (dma_readl(atdma, CHSR) & atchan->mask)
|
|
|
|
cpu_relax();
|
|
|
|
|
|
|
|
/* active_list entries will end up before queued entries */
|
|
|
|
list_splice_init(&atchan->queue, &list);
|
|
|
|
list_splice_init(&atchan->active_list, &list);
|
|
|
|
|
|
|
|
/* Flush all pending and queued descriptors */
|
|
|
|
list_for_each_entry_safe(desc, _desc, &list, desc_node)
|
|
|
|
atc_chain_complete(atchan, desc);
|
|
|
|
|
|
|
|
clear_bit(ATC_IS_PAUSED, &atchan->status);
|
|
|
|
/* if channel dedicated to cyclic operations, free it */
|
|
|
|
clear_bit(ATC_IS_CYCLIC, &atchan->status);
|
|
|
|
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_unlock_irqrestore(&atchan->lock, flags);
|
2012-03-14 18:41:43 +07:00
|
|
|
} else if (cmd == DMA_SLAVE_CONFIG) {
|
|
|
|
return set_runtime_config(chan, (struct dma_slave_config *)arg);
|
2011-05-07 00:56:52 +07:00
|
|
|
} else {
|
|
|
|
return -ENXIO;
|
|
|
|
}
|
2010-08-05 09:40:08 +07:00
|
|
|
|
2010-03-27 06:44:01 +07:00
|
|
|
return 0;
|
2009-07-23 01:04:45 +07:00
|
|
|
}
|
|
|
|
|
2009-07-04 00:24:33 +07:00
|
|
|
/**
|
2010-03-27 06:50:49 +07:00
|
|
|
* atc_tx_status - poll for transaction completion
|
2009-07-04 00:24:33 +07:00
|
|
|
* @chan: DMA channel
|
|
|
|
* @cookie: transaction identifier to check status of
|
2010-03-27 06:50:49 +07:00
|
|
|
* @txstate: if not %NULL updated with transaction state
|
2009-07-04 00:24:33 +07:00
|
|
|
*
|
2010-03-27 06:50:49 +07:00
|
|
|
* If @txstate is passed in, upon return it reflect the driver
|
2009-07-04 00:24:33 +07:00
|
|
|
* internal state and can be used with dma_async_is_complete() to check
|
|
|
|
* the status of multiple cookies without re-checking hardware state.
|
|
|
|
*/
|
|
|
|
static enum dma_status
|
2010-03-27 06:50:49 +07:00
|
|
|
atc_tx_status(struct dma_chan *chan,
|
2009-07-04 00:24:33 +07:00
|
|
|
dma_cookie_t cookie,
|
2010-03-27 06:50:49 +07:00
|
|
|
struct dma_tx_state *txstate)
|
2009-07-04 00:24:33 +07:00
|
|
|
{
|
|
|
|
struct at_dma_chan *atchan = to_at_dma_chan(chan);
|
2011-07-27 19:21:28 +07:00
|
|
|
unsigned long flags;
|
2009-07-04 00:24:33 +07:00
|
|
|
enum dma_status ret;
|
2013-05-10 10:01:46 +07:00
|
|
|
int bytes = 0;
|
2009-07-04 00:24:33 +07:00
|
|
|
|
2012-03-07 05:35:27 +07:00
|
|
|
ret = dma_cookie_status(chan, cookie, txstate);
|
2013-05-10 10:01:46 +07:00
|
|
|
if (ret == DMA_SUCCESS)
|
|
|
|
return ret;
|
|
|
|
/*
|
|
|
|
* There's no point calculating the residue if there's
|
|
|
|
* no txstate to store the value.
|
|
|
|
*/
|
|
|
|
if (!txstate)
|
|
|
|
return DMA_ERROR;
|
2009-07-04 00:24:33 +07:00
|
|
|
|
2013-05-10 10:01:46 +07:00
|
|
|
spin_lock_irqsave(&atchan->lock, flags);
|
2009-07-04 00:24:33 +07:00
|
|
|
|
2013-05-10 10:01:46 +07:00
|
|
|
/* Get number of bytes left in the active transactions */
|
|
|
|
bytes = atc_get_bytes_left(chan);
|
2012-03-07 05:35:27 +07:00
|
|
|
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_unlock_irqrestore(&atchan->lock, flags);
|
2009-07-04 00:24:33 +07:00
|
|
|
|
2013-05-10 10:01:46 +07:00
|
|
|
if (unlikely(bytes < 0)) {
|
|
|
|
dev_vdbg(chan2dev(chan), "get residual bytes error\n");
|
|
|
|
return DMA_ERROR;
|
2013-06-07 22:26:14 +07:00
|
|
|
} else {
|
2013-05-10 10:01:46 +07:00
|
|
|
dma_set_residue(txstate, bytes);
|
2013-06-07 22:26:14 +07:00
|
|
|
}
|
2011-05-07 00:56:52 +07:00
|
|
|
|
2013-05-10 10:01:46 +07:00
|
|
|
dev_vdbg(chan2dev(chan), "tx_status %d: cookie = %d residue = %d\n",
|
|
|
|
ret, cookie, bytes);
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* atc_issue_pending - try to finish work
|
|
|
|
* @chan: target DMA channel
|
|
|
|
*/
|
|
|
|
static void atc_issue_pending(struct dma_chan *chan)
|
|
|
|
{
|
|
|
|
struct at_dma_chan *atchan = to_at_dma_chan(chan);
|
2011-07-27 19:21:28 +07:00
|
|
|
unsigned long flags;
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
dev_vdbg(chan2dev(chan), "issue_pending\n");
|
|
|
|
|
2011-04-30 21:57:46 +07:00
|
|
|
/* Not needed for cyclic transfers */
|
2011-07-26 04:09:23 +07:00
|
|
|
if (atc_chan_is_cyclic(atchan))
|
2011-04-30 21:57:46 +07:00
|
|
|
return;
|
|
|
|
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_lock_irqsave(&atchan->lock, flags);
|
2013-04-18 14:52:59 +07:00
|
|
|
atc_advance_work(atchan);
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_unlock_irqrestore(&atchan->lock, flags);
|
2009-07-04 00:24:33 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* atc_alloc_chan_resources - allocate resources for DMA channel
|
|
|
|
* @chan: allocate descriptor resources for this channel
|
|
|
|
* @client: current client requesting the channel be ready for requests
|
|
|
|
*
|
|
|
|
* return - the number of allocated descriptors
|
|
|
|
*/
|
|
|
|
static int atc_alloc_chan_resources(struct dma_chan *chan)
|
|
|
|
{
|
|
|
|
struct at_dma_chan *atchan = to_at_dma_chan(chan);
|
|
|
|
struct at_dma *atdma = to_at_dma(chan->device);
|
|
|
|
struct at_desc *desc;
|
2009-07-23 01:04:45 +07:00
|
|
|
struct at_dma_slave *atslave;
|
2011-07-27 19:21:28 +07:00
|
|
|
unsigned long flags;
|
2009-07-04 00:24:33 +07:00
|
|
|
int i;
|
2009-07-23 01:04:45 +07:00
|
|
|
u32 cfg;
|
2009-07-04 00:24:33 +07:00
|
|
|
LIST_HEAD(tmp_list);
|
|
|
|
|
|
|
|
dev_vdbg(chan2dev(chan), "alloc_chan_resources\n");
|
|
|
|
|
|
|
|
/* ASSERT: channel is idle */
|
|
|
|
if (atc_chan_is_enabled(atchan)) {
|
|
|
|
dev_dbg(chan2dev(chan), "DMA channel not idle ?\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2009-07-23 01:04:45 +07:00
|
|
|
cfg = ATC_DEFAULT_CFG;
|
|
|
|
|
|
|
|
atslave = chan->private;
|
|
|
|
if (atslave) {
|
|
|
|
/*
|
|
|
|
* We need controller-specific data to set up slave
|
|
|
|
* transfers.
|
|
|
|
*/
|
|
|
|
BUG_ON(!atslave->dma_dev || atslave->dma_dev != atdma->dma_common.dev);
|
|
|
|
|
2013-05-10 20:19:13 +07:00
|
|
|
/* if cfg configuration specified take it instead of default */
|
2009-07-23 01:04:45 +07:00
|
|
|
if (atslave->cfg)
|
|
|
|
cfg = atslave->cfg;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* have we already been set up?
|
|
|
|
* reconfigure channel but no need to reallocate descriptors */
|
2009-07-04 00:24:33 +07:00
|
|
|
if (!list_empty(&atchan->free_list))
|
|
|
|
return atchan->descs_allocated;
|
|
|
|
|
|
|
|
/* Allocate initial pool of descriptors */
|
|
|
|
for (i = 0; i < init_nr_desc_per_channel; i++) {
|
|
|
|
desc = atc_alloc_descriptor(chan, GFP_KERNEL);
|
|
|
|
if (!desc) {
|
|
|
|
dev_err(atdma->dma_common.dev,
|
|
|
|
"Only %d initial descriptors\n", i);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
list_add_tail(&desc->desc_node, &tmp_list);
|
|
|
|
}
|
|
|
|
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_lock_irqsave(&atchan->lock, flags);
|
2009-07-04 00:24:33 +07:00
|
|
|
atchan->descs_allocated = i;
|
2013-05-10 10:01:46 +07:00
|
|
|
atchan->remain_desc = 0;
|
2009-07-04 00:24:33 +07:00
|
|
|
list_splice(&tmp_list, &atchan->free_list);
|
2012-03-07 05:35:47 +07:00
|
|
|
dma_cookie_init(chan);
|
2011-07-27 19:21:28 +07:00
|
|
|
spin_unlock_irqrestore(&atchan->lock, flags);
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
/* channel parameters */
|
2009-07-23 01:04:45 +07:00
|
|
|
channel_writel(atchan, CFG, cfg);
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
dev_dbg(chan2dev(chan),
|
|
|
|
"alloc_chan_resources: allocated %d descriptors\n",
|
|
|
|
atchan->descs_allocated);
|
|
|
|
|
|
|
|
return atchan->descs_allocated;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* atc_free_chan_resources - free all channel resources
|
|
|
|
* @chan: DMA channel
|
|
|
|
*/
|
|
|
|
static void atc_free_chan_resources(struct dma_chan *chan)
|
|
|
|
{
|
|
|
|
struct at_dma_chan *atchan = to_at_dma_chan(chan);
|
|
|
|
struct at_dma *atdma = to_at_dma(chan->device);
|
|
|
|
struct at_desc *desc, *_desc;
|
|
|
|
LIST_HEAD(list);
|
|
|
|
|
|
|
|
dev_dbg(chan2dev(chan), "free_chan_resources: (descs allocated=%u)\n",
|
|
|
|
atchan->descs_allocated);
|
|
|
|
|
|
|
|
/* ASSERT: channel is idle */
|
|
|
|
BUG_ON(!list_empty(&atchan->active_list));
|
|
|
|
BUG_ON(!list_empty(&atchan->queue));
|
|
|
|
BUG_ON(atc_chan_is_enabled(atchan));
|
|
|
|
|
|
|
|
list_for_each_entry_safe(desc, _desc, &atchan->free_list, desc_node) {
|
|
|
|
dev_vdbg(chan2dev(chan), " freeing descriptor %p\n", desc);
|
|
|
|
list_del(&desc->desc_node);
|
|
|
|
/* free link descriptor */
|
|
|
|
dma_pool_free(atdma->dma_desc_pool, desc, desc->txd.phys);
|
|
|
|
}
|
|
|
|
list_splice_init(&atchan->free_list, &list);
|
|
|
|
atchan->descs_allocated = 0;
|
2011-04-30 21:57:46 +07:00
|
|
|
atchan->status = 0;
|
2013-05-10 10:01:46 +07:00
|
|
|
atchan->remain_desc = 0;
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
dev_vdbg(chan2dev(chan), "free_chan_resources: done\n");
|
|
|
|
}
|
|
|
|
|
2013-04-19 16:11:18 +07:00
|
|
|
#ifdef CONFIG_OF
|
|
|
|
static bool at_dma_filter(struct dma_chan *chan, void *slave)
|
|
|
|
{
|
|
|
|
struct at_dma_slave *atslave = slave;
|
|
|
|
|
|
|
|
if (atslave->dma_dev == chan->device->dev) {
|
|
|
|
chan->private = atslave;
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dma_chan *at_dma_xlate(struct of_phandle_args *dma_spec,
|
|
|
|
struct of_dma *of_dma)
|
|
|
|
{
|
|
|
|
struct dma_chan *chan;
|
|
|
|
struct at_dma_chan *atchan;
|
|
|
|
struct at_dma_slave *atslave;
|
|
|
|
dma_cap_mask_t mask;
|
|
|
|
unsigned int per_id;
|
|
|
|
struct platform_device *dmac_pdev;
|
|
|
|
|
|
|
|
if (dma_spec->args_count != 2)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
dmac_pdev = of_find_device_by_node(dma_spec->np);
|
|
|
|
|
|
|
|
dma_cap_zero(mask);
|
|
|
|
dma_cap_set(DMA_SLAVE, mask);
|
|
|
|
|
|
|
|
atslave = devm_kzalloc(&dmac_pdev->dev, sizeof(*atslave), GFP_KERNEL);
|
|
|
|
if (!atslave)
|
|
|
|
return NULL;
|
2013-06-13 15:39:39 +07:00
|
|
|
|
|
|
|
atslave->cfg = ATC_DST_H2SEL_HW | ATC_SRC_H2SEL_HW;
|
2013-04-19 16:11:18 +07:00
|
|
|
/*
|
|
|
|
* We can fill both SRC_PER and DST_PER, one of these fields will be
|
|
|
|
* ignored depending on DMA transfer direction.
|
|
|
|
*/
|
2013-06-13 15:39:39 +07:00
|
|
|
per_id = dma_spec->args[1] & AT91_DMA_CFG_PER_ID_MASK;
|
|
|
|
atslave->cfg |= ATC_DST_PER_MSB(per_id) | ATC_DST_PER(per_id)
|
2013-05-10 20:19:15 +07:00
|
|
|
| ATC_SRC_PER_MSB(per_id) | ATC_SRC_PER(per_id);
|
2013-06-13 15:39:39 +07:00
|
|
|
/*
|
|
|
|
* We have to translate the value we get from the device tree since
|
|
|
|
* the half FIFO configuration value had to be 0 to keep backward
|
|
|
|
* compatibility.
|
|
|
|
*/
|
|
|
|
switch (dma_spec->args[1] & AT91_DMA_CFG_FIFOCFG_MASK) {
|
|
|
|
case AT91_DMA_CFG_FIFOCFG_ALAP:
|
|
|
|
atslave->cfg |= ATC_FIFOCFG_LARGESTBURST;
|
|
|
|
break;
|
|
|
|
case AT91_DMA_CFG_FIFOCFG_ASAP:
|
|
|
|
atslave->cfg |= ATC_FIFOCFG_ENOUGHSPACE;
|
|
|
|
break;
|
|
|
|
case AT91_DMA_CFG_FIFOCFG_HALF:
|
|
|
|
default:
|
|
|
|
atslave->cfg |= ATC_FIFOCFG_HALFFIFO;
|
|
|
|
}
|
2013-04-19 16:11:18 +07:00
|
|
|
atslave->dma_dev = &dmac_pdev->dev;
|
|
|
|
|
|
|
|
chan = dma_request_channel(mask, at_dma_filter, atslave);
|
|
|
|
if (!chan)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
atchan = to_at_dma_chan(chan);
|
|
|
|
atchan->per_if = dma_spec->args[0] & 0xff;
|
|
|
|
atchan->mem_if = (dma_spec->args[0] >> 16) & 0xff;
|
|
|
|
|
|
|
|
return chan;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static struct dma_chan *at_dma_xlate(struct of_phandle_args *dma_spec,
|
|
|
|
struct of_dma *of_dma)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
#endif
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
/*-- Module Management -----------------------------------------------*/
|
|
|
|
|
2011-11-22 17:55:54 +07:00
|
|
|
/* cap_mask is a multi-u32 bitfield, fill it with proper C code. */
|
|
|
|
static struct at_dma_platform_data at91sam9rl_config = {
|
|
|
|
.nr_channels = 2,
|
|
|
|
};
|
|
|
|
static struct at_dma_platform_data at91sam9g45_config = {
|
|
|
|
.nr_channels = 8,
|
|
|
|
};
|
|
|
|
|
2011-10-17 19:56:41 +07:00
|
|
|
#if defined(CONFIG_OF)
|
|
|
|
static const struct of_device_id atmel_dma_dt_ids[] = {
|
|
|
|
{
|
|
|
|
.compatible = "atmel,at91sam9rl-dma",
|
2011-11-22 17:55:54 +07:00
|
|
|
.data = &at91sam9rl_config,
|
2011-10-17 19:56:41 +07:00
|
|
|
}, {
|
|
|
|
.compatible = "atmel,at91sam9g45-dma",
|
2011-11-22 17:55:54 +07:00
|
|
|
.data = &at91sam9g45_config,
|
2011-11-22 17:55:53 +07:00
|
|
|
}, {
|
|
|
|
/* sentinel */
|
|
|
|
}
|
2011-10-17 19:56:41 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
MODULE_DEVICE_TABLE(of, atmel_dma_dt_ids);
|
|
|
|
#endif
|
|
|
|
|
2011-11-22 17:55:52 +07:00
|
|
|
static const struct platform_device_id atdma_devtypes[] = {
|
2011-10-17 19:56:40 +07:00
|
|
|
{
|
|
|
|
.name = "at91sam9rl_dma",
|
2011-11-22 17:55:54 +07:00
|
|
|
.driver_data = (unsigned long) &at91sam9rl_config,
|
2011-10-17 19:56:40 +07:00
|
|
|
}, {
|
|
|
|
.name = "at91sam9g45_dma",
|
2011-11-22 17:55:54 +07:00
|
|
|
.driver_data = (unsigned long) &at91sam9g45_config,
|
2011-10-17 19:56:40 +07:00
|
|
|
}, {
|
|
|
|
/* sentinel */
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-07-13 19:32:10 +07:00
|
|
|
static inline const struct at_dma_platform_data * __init at_dma_get_driver_data(
|
2011-11-22 17:55:54 +07:00
|
|
|
struct platform_device *pdev)
|
2011-10-17 19:56:41 +07:00
|
|
|
{
|
|
|
|
if (pdev->dev.of_node) {
|
|
|
|
const struct of_device_id *match;
|
|
|
|
match = of_match_node(atmel_dma_dt_ids, pdev->dev.of_node);
|
|
|
|
if (match == NULL)
|
2011-11-22 17:55:54 +07:00
|
|
|
return NULL;
|
|
|
|
return match->data;
|
2011-10-17 19:56:41 +07:00
|
|
|
}
|
2011-11-22 17:55:54 +07:00
|
|
|
return (struct at_dma_platform_data *)
|
|
|
|
platform_get_device_id(pdev)->driver_data;
|
2011-10-17 19:56:41 +07:00
|
|
|
}
|
|
|
|
|
2009-07-04 00:24:33 +07:00
|
|
|
/**
|
|
|
|
* at_dma_off - disable DMA controller
|
|
|
|
* @atdma: the Atmel HDAMC device
|
|
|
|
*/
|
|
|
|
static void at_dma_off(struct at_dma *atdma)
|
|
|
|
{
|
|
|
|
dma_writel(atdma, EN, 0);
|
|
|
|
|
|
|
|
/* disable all interrupts */
|
|
|
|
dma_writel(atdma, EBCIDR, -1L);
|
|
|
|
|
|
|
|
/* confirm that all channels are disabled */
|
|
|
|
while (dma_readl(atdma, CHSR) & atdma->all_chan_mask)
|
|
|
|
cpu_relax();
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init at_dma_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct resource *io;
|
|
|
|
struct at_dma *atdma;
|
|
|
|
size_t size;
|
|
|
|
int irq;
|
|
|
|
int err;
|
|
|
|
int i;
|
2012-07-13 19:32:10 +07:00
|
|
|
const struct at_dma_platform_data *plat_dat;
|
2011-10-17 19:56:40 +07:00
|
|
|
|
2011-11-22 17:55:54 +07:00
|
|
|
/* setup platform data for each SoC */
|
|
|
|
dma_cap_set(DMA_MEMCPY, at91sam9rl_config.cap_mask);
|
|
|
|
dma_cap_set(DMA_MEMCPY, at91sam9g45_config.cap_mask);
|
|
|
|
dma_cap_set(DMA_SLAVE, at91sam9g45_config.cap_mask);
|
2011-10-17 19:56:40 +07:00
|
|
|
|
|
|
|
/* get DMA parameters from controller type */
|
2011-11-22 17:55:54 +07:00
|
|
|
plat_dat = at_dma_get_driver_data(pdev);
|
|
|
|
if (!plat_dat)
|
|
|
|
return -ENODEV;
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
io = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
if (!io)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
irq = platform_get_irq(pdev, 0);
|
|
|
|
if (irq < 0)
|
|
|
|
return irq;
|
|
|
|
|
|
|
|
size = sizeof(struct at_dma);
|
2011-11-22 17:55:54 +07:00
|
|
|
size += plat_dat->nr_channels * sizeof(struct at_dma_chan);
|
2009-07-04 00:24:33 +07:00
|
|
|
atdma = kzalloc(size, GFP_KERNEL);
|
|
|
|
if (!atdma)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2011-10-17 19:56:40 +07:00
|
|
|
/* discover transaction capabilities */
|
2011-11-22 17:55:54 +07:00
|
|
|
atdma->dma_common.cap_mask = plat_dat->cap_mask;
|
|
|
|
atdma->all_chan_mask = (1 << plat_dat->nr_channels) - 1;
|
2009-07-04 00:24:33 +07:00
|
|
|
|
2011-06-02 05:16:09 +07:00
|
|
|
size = resource_size(io);
|
2009-07-04 00:24:33 +07:00
|
|
|
if (!request_mem_region(io->start, size, pdev->dev.driver->name)) {
|
|
|
|
err = -EBUSY;
|
|
|
|
goto err_kfree;
|
|
|
|
}
|
|
|
|
|
|
|
|
atdma->regs = ioremap(io->start, size);
|
|
|
|
if (!atdma->regs) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto err_release_r;
|
|
|
|
}
|
|
|
|
|
|
|
|
atdma->clk = clk_get(&pdev->dev, "dma_clk");
|
|
|
|
if (IS_ERR(atdma->clk)) {
|
|
|
|
err = PTR_ERR(atdma->clk);
|
|
|
|
goto err_clk;
|
|
|
|
}
|
2013-06-19 18:14:54 +07:00
|
|
|
err = clk_prepare_enable(atdma->clk);
|
|
|
|
if (err)
|
|
|
|
goto err_clk_prepare;
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
/* force dma off, just in case */
|
|
|
|
at_dma_off(atdma);
|
|
|
|
|
|
|
|
err = request_irq(irq, at_dma_interrupt, 0, "at_hdmac", atdma);
|
|
|
|
if (err)
|
|
|
|
goto err_irq;
|
|
|
|
|
|
|
|
platform_set_drvdata(pdev, atdma);
|
|
|
|
|
|
|
|
/* create a pool of consistent memory blocks for hardware descriptors */
|
|
|
|
atdma->dma_desc_pool = dma_pool_create("at_hdmac_desc_pool",
|
|
|
|
&pdev->dev, sizeof(struct at_desc),
|
|
|
|
4 /* word alignment */, 0);
|
|
|
|
if (!atdma->dma_desc_pool) {
|
|
|
|
dev_err(&pdev->dev, "No memory for descriptors dma pool\n");
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto err_pool_create;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* clear any pending interrupt */
|
|
|
|
while (dma_readl(atdma, EBCISR))
|
|
|
|
cpu_relax();
|
|
|
|
|
|
|
|
/* initialize channels related values */
|
|
|
|
INIT_LIST_HEAD(&atdma->dma_common.channels);
|
2011-11-22 17:55:54 +07:00
|
|
|
for (i = 0; i < plat_dat->nr_channels; i++) {
|
2009-07-04 00:24:33 +07:00
|
|
|
struct at_dma_chan *atchan = &atdma->chan[i];
|
|
|
|
|
2013-04-19 16:11:18 +07:00
|
|
|
atchan->mem_if = AT_DMA_MEM_IF;
|
|
|
|
atchan->per_if = AT_DMA_PER_IF;
|
2009-07-04 00:24:33 +07:00
|
|
|
atchan->chan_common.device = &atdma->dma_common;
|
2012-03-07 05:35:47 +07:00
|
|
|
dma_cookie_init(&atchan->chan_common);
|
2009-07-04 00:24:33 +07:00
|
|
|
list_add_tail(&atchan->chan_common.device_node,
|
|
|
|
&atdma->dma_common.channels);
|
|
|
|
|
|
|
|
atchan->ch_regs = atdma->regs + ch_regs(i);
|
|
|
|
spin_lock_init(&atchan->lock);
|
|
|
|
atchan->mask = 1 << i;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&atchan->active_list);
|
|
|
|
INIT_LIST_HEAD(&atchan->queue);
|
|
|
|
INIT_LIST_HEAD(&atchan->free_list);
|
|
|
|
|
|
|
|
tasklet_init(&atchan->tasklet, atc_tasklet,
|
|
|
|
(unsigned long)atchan);
|
2012-01-17 16:28:33 +07:00
|
|
|
atc_enable_chan_irq(atdma, i);
|
2009-07-04 00:24:33 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* set base routines */
|
|
|
|
atdma->dma_common.device_alloc_chan_resources = atc_alloc_chan_resources;
|
|
|
|
atdma->dma_common.device_free_chan_resources = atc_free_chan_resources;
|
2010-03-27 06:50:49 +07:00
|
|
|
atdma->dma_common.device_tx_status = atc_tx_status;
|
2009-07-04 00:24:33 +07:00
|
|
|
atdma->dma_common.device_issue_pending = atc_issue_pending;
|
|
|
|
atdma->dma_common.dev = &pdev->dev;
|
|
|
|
|
|
|
|
/* set prep routines based on capability */
|
|
|
|
if (dma_has_cap(DMA_MEMCPY, atdma->dma_common.cap_mask))
|
|
|
|
atdma->dma_common.device_prep_dma_memcpy = atc_prep_dma_memcpy;
|
|
|
|
|
2011-08-05 18:43:44 +07:00
|
|
|
if (dma_has_cap(DMA_SLAVE, atdma->dma_common.cap_mask)) {
|
2009-07-23 01:04:45 +07:00
|
|
|
atdma->dma_common.device_prep_slave_sg = atc_prep_slave_sg;
|
2011-08-05 18:43:44 +07:00
|
|
|
/* controller can do slave DMA: can trigger cyclic transfers */
|
|
|
|
dma_cap_set(DMA_CYCLIC, atdma->dma_common.cap_mask);
|
2011-04-30 21:57:46 +07:00
|
|
|
atdma->dma_common.device_prep_dma_cyclic = atc_prep_dma_cyclic;
|
2010-03-27 06:44:01 +07:00
|
|
|
atdma->dma_common.device_control = atc_control;
|
2011-08-05 18:43:44 +07:00
|
|
|
}
|
2009-07-23 01:04:45 +07:00
|
|
|
|
2009-07-04 00:24:33 +07:00
|
|
|
dma_writel(atdma, EN, AT_DMA_ENABLE);
|
|
|
|
|
|
|
|
dev_info(&pdev->dev, "Atmel AHB DMA Controller ( %s%s), %d channels\n",
|
|
|
|
dma_has_cap(DMA_MEMCPY, atdma->dma_common.cap_mask) ? "cpy " : "",
|
|
|
|
dma_has_cap(DMA_SLAVE, atdma->dma_common.cap_mask) ? "slave " : "",
|
2011-11-22 17:55:54 +07:00
|
|
|
plat_dat->nr_channels);
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
dma_async_device_register(&atdma->dma_common);
|
|
|
|
|
2013-04-19 16:11:18 +07:00
|
|
|
/*
|
|
|
|
* Do not return an error if the dmac node is not present in order to
|
|
|
|
* not break the existing way of requesting channel with
|
|
|
|
* dma_request_channel().
|
|
|
|
*/
|
|
|
|
if (pdev->dev.of_node) {
|
|
|
|
err = of_dma_controller_register(pdev->dev.of_node,
|
|
|
|
at_dma_xlate, atdma);
|
|
|
|
if (err) {
|
|
|
|
dev_err(&pdev->dev, "could not register of_dma_controller\n");
|
|
|
|
goto err_of_dma_controller_register;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-04 00:24:33 +07:00
|
|
|
return 0;
|
|
|
|
|
2013-04-19 16:11:18 +07:00
|
|
|
err_of_dma_controller_register:
|
|
|
|
dma_async_device_unregister(&atdma->dma_common);
|
|
|
|
dma_pool_destroy(atdma->dma_desc_pool);
|
2009-07-04 00:24:33 +07:00
|
|
|
err_pool_create:
|
|
|
|
free_irq(platform_get_irq(pdev, 0), atdma);
|
|
|
|
err_irq:
|
2013-06-19 18:14:54 +07:00
|
|
|
clk_disable_unprepare(atdma->clk);
|
|
|
|
err_clk_prepare:
|
2009-07-04 00:24:33 +07:00
|
|
|
clk_put(atdma->clk);
|
|
|
|
err_clk:
|
|
|
|
iounmap(atdma->regs);
|
|
|
|
atdma->regs = NULL;
|
|
|
|
err_release_r:
|
|
|
|
release_mem_region(io->start, size);
|
|
|
|
err_kfree:
|
|
|
|
kfree(atdma);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-02-20 07:07:04 +07:00
|
|
|
static int at_dma_remove(struct platform_device *pdev)
|
2009-07-04 00:24:33 +07:00
|
|
|
{
|
|
|
|
struct at_dma *atdma = platform_get_drvdata(pdev);
|
|
|
|
struct dma_chan *chan, *_chan;
|
|
|
|
struct resource *io;
|
|
|
|
|
|
|
|
at_dma_off(atdma);
|
|
|
|
dma_async_device_unregister(&atdma->dma_common);
|
|
|
|
|
|
|
|
dma_pool_destroy(atdma->dma_desc_pool);
|
|
|
|
free_irq(platform_get_irq(pdev, 0), atdma);
|
|
|
|
|
|
|
|
list_for_each_entry_safe(chan, _chan, &atdma->dma_common.channels,
|
|
|
|
device_node) {
|
|
|
|
struct at_dma_chan *atchan = to_at_dma_chan(chan);
|
|
|
|
|
|
|
|
/* Disable interrupts */
|
2012-01-17 16:28:33 +07:00
|
|
|
atc_disable_chan_irq(atdma, chan->chan_id);
|
2009-07-04 00:24:33 +07:00
|
|
|
tasklet_disable(&atchan->tasklet);
|
|
|
|
|
|
|
|
tasklet_kill(&atchan->tasklet);
|
|
|
|
list_del(&chan->device_node);
|
|
|
|
}
|
|
|
|
|
2013-06-19 18:14:54 +07:00
|
|
|
clk_disable_unprepare(atdma->clk);
|
2009-07-04 00:24:33 +07:00
|
|
|
clk_put(atdma->clk);
|
|
|
|
|
|
|
|
iounmap(atdma->regs);
|
|
|
|
atdma->regs = NULL;
|
|
|
|
|
|
|
|
io = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
2011-06-02 05:16:09 +07:00
|
|
|
release_mem_region(io->start, resource_size(io));
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
kfree(atdma);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void at_dma_shutdown(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct at_dma *atdma = platform_get_drvdata(pdev);
|
|
|
|
|
|
|
|
at_dma_off(platform_get_drvdata(pdev));
|
2013-06-19 18:14:54 +07:00
|
|
|
clk_disable_unprepare(atdma->clk);
|
2009-07-04 00:24:33 +07:00
|
|
|
}
|
|
|
|
|
2011-07-27 19:21:29 +07:00
|
|
|
static int at_dma_prepare(struct device *dev)
|
|
|
|
{
|
|
|
|
struct platform_device *pdev = to_platform_device(dev);
|
|
|
|
struct at_dma *atdma = platform_get_drvdata(pdev);
|
|
|
|
struct dma_chan *chan, *_chan;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(chan, _chan, &atdma->dma_common.channels,
|
|
|
|
device_node) {
|
|
|
|
struct at_dma_chan *atchan = to_at_dma_chan(chan);
|
|
|
|
/* wait for transaction completion (except in cyclic case) */
|
2011-07-26 04:09:23 +07:00
|
|
|
if (atc_chan_is_enabled(atchan) && !atc_chan_is_cyclic(atchan))
|
2011-07-27 19:21:29 +07:00
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void atc_suspend_cyclic(struct at_dma_chan *atchan)
|
|
|
|
{
|
|
|
|
struct dma_chan *chan = &atchan->chan_common;
|
|
|
|
|
|
|
|
/* Channel should be paused by user
|
|
|
|
* do it anyway even if it is not done already */
|
2011-07-26 04:09:23 +07:00
|
|
|
if (!atc_chan_is_paused(atchan)) {
|
2011-07-27 19:21:29 +07:00
|
|
|
dev_warn(chan2dev(chan),
|
|
|
|
"cyclic channel not paused, should be done by channel user\n");
|
|
|
|
atc_control(chan, DMA_PAUSE, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* now preserve additional data for cyclic operations */
|
|
|
|
/* next descriptor address in the cyclic list */
|
|
|
|
atchan->save_dscr = channel_readl(atchan, DSCR);
|
|
|
|
|
|
|
|
vdbg_dump_regs(atchan);
|
|
|
|
}
|
|
|
|
|
2009-09-10 05:06:44 +07:00
|
|
|
static int at_dma_suspend_noirq(struct device *dev)
|
2009-07-04 00:24:33 +07:00
|
|
|
{
|
2009-09-10 05:06:44 +07:00
|
|
|
struct platform_device *pdev = to_platform_device(dev);
|
|
|
|
struct at_dma *atdma = platform_get_drvdata(pdev);
|
2011-07-27 19:21:29 +07:00
|
|
|
struct dma_chan *chan, *_chan;
|
2009-07-04 00:24:33 +07:00
|
|
|
|
2011-07-27 19:21:29 +07:00
|
|
|
/* preserve data */
|
|
|
|
list_for_each_entry_safe(chan, _chan, &atdma->dma_common.channels,
|
|
|
|
device_node) {
|
|
|
|
struct at_dma_chan *atchan = to_at_dma_chan(chan);
|
|
|
|
|
2011-07-26 04:09:23 +07:00
|
|
|
if (atc_chan_is_cyclic(atchan))
|
2011-07-27 19:21:29 +07:00
|
|
|
atc_suspend_cyclic(atchan);
|
|
|
|
atchan->save_cfg = channel_readl(atchan, CFG);
|
|
|
|
}
|
|
|
|
atdma->save_imr = dma_readl(atdma, EBCIMR);
|
|
|
|
|
|
|
|
/* disable DMA controller */
|
|
|
|
at_dma_off(atdma);
|
2013-06-19 18:14:54 +07:00
|
|
|
clk_disable_unprepare(atdma->clk);
|
2009-07-04 00:24:33 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-27 19:21:29 +07:00
|
|
|
static void atc_resume_cyclic(struct at_dma_chan *atchan)
|
|
|
|
{
|
|
|
|
struct at_dma *atdma = to_at_dma(atchan->chan_common.device);
|
|
|
|
|
|
|
|
/* restore channel status for cyclic descriptors list:
|
|
|
|
* next descriptor in the cyclic list at the time of suspend */
|
|
|
|
channel_writel(atchan, SADDR, 0);
|
|
|
|
channel_writel(atchan, DADDR, 0);
|
|
|
|
channel_writel(atchan, CTRLA, 0);
|
|
|
|
channel_writel(atchan, CTRLB, 0);
|
|
|
|
channel_writel(atchan, DSCR, atchan->save_dscr);
|
|
|
|
dma_writel(atdma, CHER, atchan->mask);
|
|
|
|
|
|
|
|
/* channel pause status should be removed by channel user
|
|
|
|
* We cannot take the initiative to do it here */
|
|
|
|
|
|
|
|
vdbg_dump_regs(atchan);
|
|
|
|
}
|
|
|
|
|
2009-09-10 05:06:44 +07:00
|
|
|
static int at_dma_resume_noirq(struct device *dev)
|
2009-07-04 00:24:33 +07:00
|
|
|
{
|
2009-09-10 05:06:44 +07:00
|
|
|
struct platform_device *pdev = to_platform_device(dev);
|
|
|
|
struct at_dma *atdma = platform_get_drvdata(pdev);
|
2011-07-27 19:21:29 +07:00
|
|
|
struct dma_chan *chan, *_chan;
|
2009-07-04 00:24:33 +07:00
|
|
|
|
2011-07-27 19:21:29 +07:00
|
|
|
/* bring back DMA controller */
|
2013-06-19 18:14:54 +07:00
|
|
|
clk_prepare_enable(atdma->clk);
|
2009-07-04 00:24:33 +07:00
|
|
|
dma_writel(atdma, EN, AT_DMA_ENABLE);
|
2011-07-27 19:21:29 +07:00
|
|
|
|
|
|
|
/* clear any pending interrupt */
|
|
|
|
while (dma_readl(atdma, EBCISR))
|
|
|
|
cpu_relax();
|
|
|
|
|
|
|
|
/* restore saved data */
|
|
|
|
dma_writel(atdma, EBCIER, atdma->save_imr);
|
|
|
|
list_for_each_entry_safe(chan, _chan, &atdma->dma_common.channels,
|
|
|
|
device_node) {
|
|
|
|
struct at_dma_chan *atchan = to_at_dma_chan(chan);
|
|
|
|
|
|
|
|
channel_writel(atchan, CFG, atchan->save_cfg);
|
2011-07-26 04:09:23 +07:00
|
|
|
if (atc_chan_is_cyclic(atchan))
|
2011-07-27 19:21:29 +07:00
|
|
|
atc_resume_cyclic(atchan);
|
|
|
|
}
|
2009-07-04 00:24:33 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-15 09:00:08 +07:00
|
|
|
static const struct dev_pm_ops at_dma_dev_pm_ops = {
|
2011-07-27 19:21:29 +07:00
|
|
|
.prepare = at_dma_prepare,
|
2009-09-10 05:06:44 +07:00
|
|
|
.suspend_noirq = at_dma_suspend_noirq,
|
|
|
|
.resume_noirq = at_dma_resume_noirq,
|
|
|
|
};
|
|
|
|
|
2009-07-04 00:24:33 +07:00
|
|
|
static struct platform_driver at_dma_driver = {
|
2013-02-20 07:07:04 +07:00
|
|
|
.remove = at_dma_remove,
|
2009-07-04 00:24:33 +07:00
|
|
|
.shutdown = at_dma_shutdown,
|
2011-10-17 19:56:40 +07:00
|
|
|
.id_table = atdma_devtypes,
|
2009-07-04 00:24:33 +07:00
|
|
|
.driver = {
|
|
|
|
.name = "at_hdmac",
|
2009-09-10 05:06:44 +07:00
|
|
|
.pm = &at_dma_dev_pm_ops,
|
2011-10-17 19:56:41 +07:00
|
|
|
.of_match_table = of_match_ptr(atmel_dma_dt_ids),
|
2009-07-04 00:24:33 +07:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init at_dma_init(void)
|
|
|
|
{
|
|
|
|
return platform_driver_probe(&at_dma_driver, at_dma_probe);
|
|
|
|
}
|
2011-01-12 21:39:08 +07:00
|
|
|
subsys_initcall(at_dma_init);
|
2009-07-04 00:24:33 +07:00
|
|
|
|
|
|
|
static void __exit at_dma_exit(void)
|
|
|
|
{
|
|
|
|
platform_driver_unregister(&at_dma_driver);
|
|
|
|
}
|
|
|
|
module_exit(at_dma_exit);
|
|
|
|
|
|
|
|
MODULE_DESCRIPTION("Atmel AHB DMA Controller driver");
|
|
|
|
MODULE_AUTHOR("Nicolas Ferre <nicolas.ferre@atmel.com>");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_ALIAS("platform:at_hdmac");
|