2008-03-01 07:42:48 -07:00
|
|
|
/*
|
|
|
|
* Freescale MPC85xx, MPC83xx DMA Engine support
|
|
|
|
*
|
2010-11-11 05:16:29 -07:00
|
|
|
* Copyright (C) 2007-2010 Freescale Semiconductor, Inc. All rights reserved.
|
2008-03-01 07:42:48 -07:00
|
|
|
*
|
|
|
|
* Author:
|
|
|
|
* Zhang Wei <wei.zhang@freescale.com>, Jul 2007
|
|
|
|
* Ebony Zhu <ebony.zhu@freescale.com>, May 2007
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* DMA engine driver for Freescale MPC8540 DMA controller, which is
|
|
|
|
* also fit for MPC8560, MPC8555, MPC8548, MPC8641, and etc.
|
2010-08-03 11:44:52 -06:00
|
|
|
* The support for MPC8349 DMA controller is also added.
|
2008-03-01 07:42:48 -07:00
|
|
|
*
|
2009-04-23 17:17:54 -06:00
|
|
|
* This driver instructs the DMA controller to issue the PCI Read Multiple
|
|
|
|
* command for PCI read operations, instead of using the default PCI Read Line
|
|
|
|
* command. Please be aware that this setting may result in read pre-fetching
|
|
|
|
* on some platforms.
|
|
|
|
*
|
2008-03-01 07:42:48 -07:00
|
|
|
* This 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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/pci.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 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2008-03-01 07:42:48 -07:00
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/dmaengine.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/dmapool.h>
|
|
|
|
#include <linux/of_platform.h>
|
|
|
|
|
|
|
|
#include "fsldma.h"
|
|
|
|
|
2011-03-03 00:54:55 -07:00
|
|
|
#define chan_dbg(chan, fmt, arg...) \
|
|
|
|
dev_dbg(chan->dev, "%s: " fmt, chan->name, ##arg)
|
|
|
|
#define chan_err(chan, fmt, arg...) \
|
|
|
|
dev_err(chan->dev, "%s: " fmt, chan->name, ##arg)
|
2010-09-30 05:46:45 -06:00
|
|
|
|
2011-03-03 00:54:55 -07:00
|
|
|
static const char msg_ld_oom[] = "No free memory for link descriptor";
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2011-03-03 00:54:54 -07:00
|
|
|
/*
|
|
|
|
* Register Helpers
|
|
|
|
*/
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
static void set_sr(struct fsldma_chan *chan, u32 val)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:34:05 -07:00
|
|
|
DMA_OUT(chan, &chan->regs->sr, val, 32);
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
static u32 get_sr(struct fsldma_chan *chan)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:34:05 -07:00
|
|
|
return DMA_IN(chan, &chan->regs->sr, 32);
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2011-03-03 00:54:54 -07:00
|
|
|
static void set_cdar(struct fsldma_chan *chan, dma_addr_t addr)
|
|
|
|
{
|
|
|
|
DMA_OUT(chan, &chan->regs->cdar, addr | FSL_DMA_SNEN, 64);
|
|
|
|
}
|
|
|
|
|
|
|
|
static dma_addr_t get_cdar(struct fsldma_chan *chan)
|
|
|
|
{
|
|
|
|
return DMA_IN(chan, &chan->regs->cdar, 64) & ~FSL_DMA_SNEN;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 get_bcr(struct fsldma_chan *chan)
|
|
|
|
{
|
|
|
|
return DMA_IN(chan, &chan->regs->bcr, 32);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Descriptor Helpers
|
|
|
|
*/
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
static void set_desc_cnt(struct fsldma_chan *chan,
|
2008-03-01 07:42:48 -07:00
|
|
|
struct fsl_dma_ld_hw *hw, u32 count)
|
|
|
|
{
|
2010-01-06 06:34:05 -07:00
|
|
|
hw->count = CPU_TO_DMA(chan, count, 32);
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2011-03-03 00:54:59 -07:00
|
|
|
static u32 get_desc_cnt(struct fsldma_chan *chan, struct fsl_desc_sw *desc)
|
|
|
|
{
|
|
|
|
return DMA_TO_CPU(chan, desc->hw.count, 32);
|
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
static void set_desc_src(struct fsldma_chan *chan,
|
2011-03-03 00:54:57 -07:00
|
|
|
struct fsl_dma_ld_hw *hw, dma_addr_t src)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
|
|
|
u64 snoop_bits;
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
snoop_bits = ((chan->feature & FSL_DMA_IP_MASK) == FSL_DMA_IP_85XX)
|
2008-03-01 07:42:48 -07:00
|
|
|
? ((u64)FSL_DMA_SATR_SREADTYPE_SNOOP_READ << 32) : 0;
|
2010-01-06 06:34:05 -07:00
|
|
|
hw->src_addr = CPU_TO_DMA(chan, snoop_bits | src, 64);
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2011-03-03 00:54:59 -07:00
|
|
|
static dma_addr_t get_desc_src(struct fsldma_chan *chan,
|
|
|
|
struct fsl_desc_sw *desc)
|
|
|
|
{
|
|
|
|
u64 snoop_bits;
|
|
|
|
|
|
|
|
snoop_bits = ((chan->feature & FSL_DMA_IP_MASK) == FSL_DMA_IP_85XX)
|
|
|
|
? ((u64)FSL_DMA_SATR_SREADTYPE_SNOOP_READ << 32) : 0;
|
|
|
|
return DMA_TO_CPU(chan, desc->hw.src_addr, 64) & ~snoop_bits;
|
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
static void set_desc_dst(struct fsldma_chan *chan,
|
2011-03-03 00:54:57 -07:00
|
|
|
struct fsl_dma_ld_hw *hw, dma_addr_t dst)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
|
|
|
u64 snoop_bits;
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
snoop_bits = ((chan->feature & FSL_DMA_IP_MASK) == FSL_DMA_IP_85XX)
|
2008-03-01 07:42:48 -07:00
|
|
|
? ((u64)FSL_DMA_DATR_DWRITETYPE_SNOOP_WRITE << 32) : 0;
|
2010-01-06 06:34:05 -07:00
|
|
|
hw->dst_addr = CPU_TO_DMA(chan, snoop_bits | dst, 64);
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2011-03-03 00:54:59 -07:00
|
|
|
static dma_addr_t get_desc_dst(struct fsldma_chan *chan,
|
|
|
|
struct fsl_desc_sw *desc)
|
|
|
|
{
|
|
|
|
u64 snoop_bits;
|
|
|
|
|
|
|
|
snoop_bits = ((chan->feature & FSL_DMA_IP_MASK) == FSL_DMA_IP_85XX)
|
|
|
|
? ((u64)FSL_DMA_DATR_DWRITETYPE_SNOOP_WRITE << 32) : 0;
|
|
|
|
return DMA_TO_CPU(chan, desc->hw.dst_addr, 64) & ~snoop_bits;
|
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
static void set_desc_next(struct fsldma_chan *chan,
|
2011-03-03 00:54:57 -07:00
|
|
|
struct fsl_dma_ld_hw *hw, dma_addr_t next)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
|
|
|
u64 snoop_bits;
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
snoop_bits = ((chan->feature & FSL_DMA_IP_MASK) == FSL_DMA_IP_83XX)
|
2008-03-01 07:42:48 -07:00
|
|
|
? FSL_DMA_SNEN : 0;
|
2010-01-06 06:34:05 -07:00
|
|
|
hw->next_ln_addr = CPU_TO_DMA(chan, snoop_bits | next, 64);
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2011-03-03 00:54:57 -07:00
|
|
|
static void set_ld_eol(struct fsldma_chan *chan, struct fsl_desc_sw *desc)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2011-03-03 00:54:54 -07:00
|
|
|
u64 snoop_bits;
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2011-03-03 00:54:54 -07:00
|
|
|
snoop_bits = ((chan->feature & FSL_DMA_IP_MASK) == FSL_DMA_IP_83XX)
|
|
|
|
? FSL_DMA_SNEN : 0;
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2011-03-03 00:54:54 -07:00
|
|
|
desc->hw.next_ln_addr = CPU_TO_DMA(chan,
|
|
|
|
DMA_TO_CPU(chan, desc->hw.next_ln_addr, 64) | FSL_DMA_EOL
|
|
|
|
| snoop_bits, 64);
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2011-03-03 00:54:54 -07:00
|
|
|
/*
|
|
|
|
* DMA Engine Hardware Control Helpers
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void dma_init(struct fsldma_chan *chan)
|
2008-03-18 19:45:00 -06:00
|
|
|
{
|
2011-03-03 00:54:54 -07:00
|
|
|
/* Reset the channel */
|
|
|
|
DMA_OUT(chan, &chan->regs->mr, 0, 32);
|
|
|
|
|
|
|
|
switch (chan->feature & FSL_DMA_IP_MASK) {
|
|
|
|
case FSL_DMA_IP_85XX:
|
|
|
|
/* Set the channel to below modes:
|
|
|
|
* EIE - Error interrupt enable
|
|
|
|
* EOLNIE - End of links interrupt enable
|
|
|
|
* BWC - Bandwidth sharing among channels
|
|
|
|
*/
|
|
|
|
DMA_OUT(chan, &chan->regs->mr, FSL_DMA_MR_BWC
|
2011-03-03 00:54:58 -07:00
|
|
|
| FSL_DMA_MR_EIE | FSL_DMA_MR_EOLNIE, 32);
|
2011-03-03 00:54:54 -07:00
|
|
|
break;
|
|
|
|
case FSL_DMA_IP_83XX:
|
|
|
|
/* Set the channel to below modes:
|
|
|
|
* EOTIE - End-of-transfer interrupt enable
|
|
|
|
* PRC_RM - PCI read multiple
|
|
|
|
*/
|
|
|
|
DMA_OUT(chan, &chan->regs->mr, FSL_DMA_MR_EOTIE
|
|
|
|
| FSL_DMA_MR_PRC_RM, 32);
|
|
|
|
break;
|
|
|
|
}
|
2008-03-18 19:45:00 -06:00
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
static int dma_is_idle(struct fsldma_chan *chan)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:34:05 -07:00
|
|
|
u32 sr = get_sr(chan);
|
2008-03-01 07:42:48 -07:00
|
|
|
return (!(sr & FSL_DMA_SR_CB)) || (sr & FSL_DMA_SR_CH);
|
|
|
|
}
|
|
|
|
|
2011-03-03 00:54:58 -07:00
|
|
|
/*
|
|
|
|
* Start the DMA controller
|
|
|
|
*
|
|
|
|
* Preconditions:
|
|
|
|
* - the CDAR register must point to the start descriptor
|
|
|
|
* - the MRn[CS] bit must be cleared
|
|
|
|
*/
|
2010-01-06 06:34:05 -07:00
|
|
|
static void dma_start(struct fsldma_chan *chan)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:33:59 -07:00
|
|
|
u32 mode;
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
mode = DMA_IN(chan, &chan->regs->mr, 32);
|
2010-01-06 06:33:59 -07:00
|
|
|
|
2011-03-03 00:54:58 -07:00
|
|
|
if (chan->feature & FSL_DMA_CHAN_PAUSE_EXT) {
|
|
|
|
DMA_OUT(chan, &chan->regs->bcr, 0, 32);
|
|
|
|
mode |= FSL_DMA_MR_EMP_EN;
|
|
|
|
} else {
|
|
|
|
mode &= ~FSL_DMA_MR_EMP_EN;
|
2009-05-28 03:26:40 -06:00
|
|
|
}
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2011-03-03 00:54:58 -07:00
|
|
|
if (chan->feature & FSL_DMA_CHAN_START_EXT) {
|
2010-01-06 06:33:59 -07:00
|
|
|
mode |= FSL_DMA_MR_EMS_EN;
|
2011-03-03 00:54:58 -07:00
|
|
|
} else {
|
|
|
|
mode &= ~FSL_DMA_MR_EMS_EN;
|
2010-01-06 06:33:59 -07:00
|
|
|
mode |= FSL_DMA_MR_CS;
|
2011-03-03 00:54:58 -07:00
|
|
|
}
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
DMA_OUT(chan, &chan->regs->mr, mode, 32);
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
static void dma_halt(struct fsldma_chan *chan)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:33:59 -07:00
|
|
|
u32 mode;
|
2009-03-02 15:33:46 -07:00
|
|
|
int i;
|
|
|
|
|
2011-03-03 00:55:01 -07:00
|
|
|
/* read the mode register */
|
2010-01-06 06:34:05 -07:00
|
|
|
mode = DMA_IN(chan, &chan->regs->mr, 32);
|
2010-01-06 06:33:59 -07:00
|
|
|
|
2011-03-03 00:55:01 -07:00
|
|
|
/*
|
|
|
|
* The 85xx controller supports channel abort, which will stop
|
|
|
|
* the current transfer. On 83xx, this bit is the transfer error
|
|
|
|
* mask bit, which should not be changed.
|
|
|
|
*/
|
|
|
|
if ((chan->feature & FSL_DMA_IP_MASK) == FSL_DMA_IP_85XX) {
|
|
|
|
mode |= FSL_DMA_MR_CA;
|
|
|
|
DMA_OUT(chan, &chan->regs->mr, mode, 32);
|
|
|
|
|
|
|
|
mode &= ~FSL_DMA_MR_CA;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* stop the DMA controller */
|
|
|
|
mode &= ~(FSL_DMA_MR_CS | FSL_DMA_MR_EMS_EN);
|
2010-01-06 06:34:05 -07:00
|
|
|
DMA_OUT(chan, &chan->regs->mr, mode, 32);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2011-03-03 00:55:01 -07:00
|
|
|
/* wait for the DMA controller to become idle */
|
2009-03-02 15:33:46 -07:00
|
|
|
for (i = 0; i < 100; i++) {
|
2010-01-06 06:34:05 -07:00
|
|
|
if (dma_is_idle(chan))
|
2010-01-06 06:34:06 -07:00
|
|
|
return;
|
|
|
|
|
2008-03-01 07:42:48 -07:00
|
|
|
udelay(10);
|
2009-03-02 15:33:46 -07:00
|
|
|
}
|
2010-01-06 06:33:59 -07:00
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
if (!dma_is_idle(chan))
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_err(chan, "DMA halt timeout!\n");
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* fsl_chan_set_src_loop_size - Set source address hold transfer size
|
2010-01-06 06:34:05 -07:00
|
|
|
* @chan : Freescale DMA channel
|
2008-03-01 07:42:48 -07:00
|
|
|
* @size : Address loop size, 0 for disable loop
|
|
|
|
*
|
|
|
|
* The set source address hold transfer size. The source
|
|
|
|
* address hold or loop transfer size is when the DMA transfer
|
|
|
|
* data from source address (SA), if the loop size is 4, the DMA will
|
|
|
|
* read data from SA, SA + 1, SA + 2, SA + 3, then loop back to SA,
|
|
|
|
* SA + 1 ... and so on.
|
|
|
|
*/
|
2010-01-06 06:34:05 -07:00
|
|
|
static void fsl_chan_set_src_loop_size(struct fsldma_chan *chan, int size)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:33:59 -07:00
|
|
|
u32 mode;
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
mode = DMA_IN(chan, &chan->regs->mr, 32);
|
2010-01-06 06:33:59 -07:00
|
|
|
|
2008-03-01 07:42:48 -07:00
|
|
|
switch (size) {
|
|
|
|
case 0:
|
2010-01-06 06:33:59 -07:00
|
|
|
mode &= ~FSL_DMA_MR_SAHE;
|
2008-03-01 07:42:48 -07:00
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
case 2:
|
|
|
|
case 4:
|
|
|
|
case 8:
|
2010-01-06 06:33:59 -07:00
|
|
|
mode |= FSL_DMA_MR_SAHE | (__ilog2(size) << 14);
|
2008-03-01 07:42:48 -07:00
|
|
|
break;
|
|
|
|
}
|
2010-01-06 06:33:59 -07:00
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
DMA_OUT(chan, &chan->regs->mr, mode, 32);
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-01-06 06:34:02 -07:00
|
|
|
* fsl_chan_set_dst_loop_size - Set destination address hold transfer size
|
2010-01-06 06:34:05 -07:00
|
|
|
* @chan : Freescale DMA channel
|
2008-03-01 07:42:48 -07:00
|
|
|
* @size : Address loop size, 0 for disable loop
|
|
|
|
*
|
|
|
|
* The set destination address hold transfer size. The destination
|
|
|
|
* address hold or loop transfer size is when the DMA transfer
|
|
|
|
* data to destination address (TA), if the loop size is 4, the DMA will
|
|
|
|
* write data to TA, TA + 1, TA + 2, TA + 3, then loop back to TA,
|
|
|
|
* TA + 1 ... and so on.
|
|
|
|
*/
|
2010-01-06 06:34:05 -07:00
|
|
|
static void fsl_chan_set_dst_loop_size(struct fsldma_chan *chan, int size)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:33:59 -07:00
|
|
|
u32 mode;
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
mode = DMA_IN(chan, &chan->regs->mr, 32);
|
2010-01-06 06:33:59 -07:00
|
|
|
|
2008-03-01 07:42:48 -07:00
|
|
|
switch (size) {
|
|
|
|
case 0:
|
2010-01-06 06:33:59 -07:00
|
|
|
mode &= ~FSL_DMA_MR_DAHE;
|
2008-03-01 07:42:48 -07:00
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
case 2:
|
|
|
|
case 4:
|
|
|
|
case 8:
|
2010-01-06 06:33:59 -07:00
|
|
|
mode |= FSL_DMA_MR_DAHE | (__ilog2(size) << 16);
|
2008-03-01 07:42:48 -07:00
|
|
|
break;
|
|
|
|
}
|
2010-01-06 06:33:59 -07:00
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
DMA_OUT(chan, &chan->regs->mr, mode, 32);
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-09-08 18:53:04 -06:00
|
|
|
* fsl_chan_set_request_count - Set DMA Request Count for external control
|
2010-01-06 06:34:05 -07:00
|
|
|
* @chan : Freescale DMA channel
|
2009-09-08 18:53:04 -06:00
|
|
|
* @size : Number of bytes to transfer in a single request
|
|
|
|
*
|
|
|
|
* The Freescale DMA channel can be controlled by the external signal DREQ#.
|
|
|
|
* The DMA request count is how many bytes are allowed to transfer before
|
|
|
|
* pausing the channel, after which a new assertion of DREQ# resumes channel
|
|
|
|
* operation.
|
2008-03-01 07:42:48 -07:00
|
|
|
*
|
2009-09-08 18:53:04 -06:00
|
|
|
* A size of 0 disables external pause control. The maximum size is 1024.
|
2008-03-01 07:42:48 -07:00
|
|
|
*/
|
2010-01-06 06:34:05 -07:00
|
|
|
static void fsl_chan_set_request_count(struct fsldma_chan *chan, int size)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:33:59 -07:00
|
|
|
u32 mode;
|
|
|
|
|
2009-09-08 18:53:04 -06:00
|
|
|
BUG_ON(size > 1024);
|
2010-01-06 06:33:59 -07:00
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
mode = DMA_IN(chan, &chan->regs->mr, 32);
|
2010-01-06 06:33:59 -07:00
|
|
|
mode |= (__ilog2(size) << 24) & 0x0f000000;
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
DMA_OUT(chan, &chan->regs->mr, mode, 32);
|
2009-09-08 18:53:04 -06:00
|
|
|
}
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2009-09-08 18:53:04 -06:00
|
|
|
/**
|
|
|
|
* fsl_chan_toggle_ext_pause - Toggle channel external pause status
|
2010-01-06 06:34:05 -07:00
|
|
|
* @chan : Freescale DMA channel
|
2009-09-08 18:53:04 -06:00
|
|
|
* @enable : 0 is disabled, 1 is enabled.
|
|
|
|
*
|
|
|
|
* The Freescale DMA channel can be controlled by the external signal DREQ#.
|
|
|
|
* The DMA Request Count feature should be used in addition to this feature
|
|
|
|
* to set the number of bytes to transfer before pausing the channel.
|
|
|
|
*/
|
2010-01-06 06:34:05 -07:00
|
|
|
static void fsl_chan_toggle_ext_pause(struct fsldma_chan *chan, int enable)
|
2009-09-08 18:53:04 -06:00
|
|
|
{
|
|
|
|
if (enable)
|
2010-01-06 06:34:05 -07:00
|
|
|
chan->feature |= FSL_DMA_CHAN_PAUSE_EXT;
|
2009-09-08 18:53:04 -06:00
|
|
|
else
|
2010-01-06 06:34:05 -07:00
|
|
|
chan->feature &= ~FSL_DMA_CHAN_PAUSE_EXT;
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* fsl_chan_toggle_ext_start - Toggle channel external start status
|
2010-01-06 06:34:05 -07:00
|
|
|
* @chan : Freescale DMA channel
|
2008-03-01 07:42:48 -07:00
|
|
|
* @enable : 0 is disabled, 1 is enabled.
|
|
|
|
*
|
|
|
|
* If enable the external start, the channel can be started by an
|
|
|
|
* external DMA start pin. So the dma_start() does not start the
|
|
|
|
* transfer immediately. The DMA channel will wait for the
|
|
|
|
* control pin asserted.
|
|
|
|
*/
|
2010-01-06 06:34:05 -07:00
|
|
|
static void fsl_chan_toggle_ext_start(struct fsldma_chan *chan, int enable)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
|
|
|
if (enable)
|
2010-01-06 06:34:05 -07:00
|
|
|
chan->feature |= FSL_DMA_CHAN_START_EXT;
|
2008-03-01 07:42:48 -07:00
|
|
|
else
|
2010-01-06 06:34:05 -07:00
|
|
|
chan->feature &= ~FSL_DMA_CHAN_START_EXT;
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2011-03-03 00:54:57 -07:00
|
|
|
static void append_ld_queue(struct fsldma_chan *chan, struct fsl_desc_sw *desc)
|
2010-01-06 06:34:06 -07:00
|
|
|
{
|
|
|
|
struct fsl_desc_sw *tail = to_fsl_desc(chan->ld_pending.prev);
|
|
|
|
|
|
|
|
if (list_empty(&chan->ld_pending))
|
|
|
|
goto out_splice;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add the hardware descriptor to the chain of hardware descriptors
|
|
|
|
* that already exists in memory.
|
|
|
|
*
|
|
|
|
* This will un-set the EOL bit of the existing transaction, and the
|
|
|
|
* last link in this transaction will become the EOL descriptor.
|
|
|
|
*/
|
|
|
|
set_desc_next(chan, &tail->hw, desc->async_tx.phys);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add the software descriptor and all children to the list
|
|
|
|
* of pending transactions
|
|
|
|
*/
|
|
|
|
out_splice:
|
|
|
|
list_splice_tail_init(&desc->tx_list, &chan->ld_pending);
|
|
|
|
}
|
|
|
|
|
2008-03-01 07:42:48 -07:00
|
|
|
static dma_cookie_t fsl_dma_tx_submit(struct dma_async_tx_descriptor *tx)
|
|
|
|
{
|
2010-01-06 06:34:05 -07:00
|
|
|
struct fsldma_chan *chan = to_fsl_chan(tx->chan);
|
2009-09-08 18:53:02 -06:00
|
|
|
struct fsl_desc_sw *desc = tx_to_fsl_desc(tx);
|
|
|
|
struct fsl_desc_sw *child;
|
2008-03-01 07:42:48 -07:00
|
|
|
unsigned long flags;
|
|
|
|
dma_cookie_t cookie;
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
spin_lock_irqsave(&chan->desc_lock, flags);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
/*
|
|
|
|
* assign cookies to all of the software descriptors
|
|
|
|
* that make up this transaction
|
|
|
|
*/
|
2010-01-06 06:34:05 -07:00
|
|
|
cookie = chan->common.cookie;
|
2009-09-08 18:53:02 -06:00
|
|
|
list_for_each_entry(child, &desc->tx_list, node) {
|
fsldma: fix infinite loop on multi-descriptor DMA chain completion
When creating a DMA transaction with multiple descriptors, the async_tx
cookie is set to 0 for each descriptor in the chain, excluding the last
descriptor, whose cookie is set to -EBUSY.
When fsl_dma_tx_submit() is run, it only assigns a cookie to the first
descriptor. All of the remaining descriptors keep their original value,
including the last descriptor, which is set to -EBUSY.
After the DMA completes, the driver will update the last completed cookie
to be -EBUSY, which is an error code instead of a valid cookie. This causes
dma_async_is_complete() to always return DMA_IN_PROGRESS.
This causes the fsldma driver to never cleanup the queue of link
descriptors, and the driver will re-run the DMA transaction on the hardware
each time it receives the End-of-Chain interrupt. This causes an infinite
loop.
With this patch, fsl_dma_tx_submit() is changed to assign a cookie to every
descriptor in the chain. The rest of the code then works without problems.
Signed-off-by: Ira W. Snyder <iws@ovro.caltech.edu>
Signed-off-by: Li Yang <leoli@freescale.com>
2009-05-15 15:27:16 -06:00
|
|
|
cookie++;
|
2011-03-03 00:54:57 -07:00
|
|
|
if (cookie < DMA_MIN_COOKIE)
|
|
|
|
cookie = DMA_MIN_COOKIE;
|
fsldma: fix infinite loop on multi-descriptor DMA chain completion
When creating a DMA transaction with multiple descriptors, the async_tx
cookie is set to 0 for each descriptor in the chain, excluding the last
descriptor, whose cookie is set to -EBUSY.
When fsl_dma_tx_submit() is run, it only assigns a cookie to the first
descriptor. All of the remaining descriptors keep their original value,
including the last descriptor, which is set to -EBUSY.
After the DMA completes, the driver will update the last completed cookie
to be -EBUSY, which is an error code instead of a valid cookie. This causes
dma_async_is_complete() to always return DMA_IN_PROGRESS.
This causes the fsldma driver to never cleanup the queue of link
descriptors, and the driver will re-run the DMA transaction on the hardware
each time it receives the End-of-Chain interrupt. This causes an infinite
loop.
With this patch, fsl_dma_tx_submit() is changed to assign a cookie to every
descriptor in the chain. The rest of the code then works without problems.
Signed-off-by: Ira W. Snyder <iws@ovro.caltech.edu>
Signed-off-by: Li Yang <leoli@freescale.com>
2009-05-15 15:27:16 -06:00
|
|
|
|
2010-02-25 12:39:30 -07:00
|
|
|
child->async_tx.cookie = cookie;
|
fsldma: fix infinite loop on multi-descriptor DMA chain completion
When creating a DMA transaction with multiple descriptors, the async_tx
cookie is set to 0 for each descriptor in the chain, excluding the last
descriptor, whose cookie is set to -EBUSY.
When fsl_dma_tx_submit() is run, it only assigns a cookie to the first
descriptor. All of the remaining descriptors keep their original value,
including the last descriptor, which is set to -EBUSY.
After the DMA completes, the driver will update the last completed cookie
to be -EBUSY, which is an error code instead of a valid cookie. This causes
dma_async_is_complete() to always return DMA_IN_PROGRESS.
This causes the fsldma driver to never cleanup the queue of link
descriptors, and the driver will re-run the DMA transaction on the hardware
each time it receives the End-of-Chain interrupt. This causes an infinite
loop.
With this patch, fsl_dma_tx_submit() is changed to assign a cookie to every
descriptor in the chain. The rest of the code then works without problems.
Signed-off-by: Ira W. Snyder <iws@ovro.caltech.edu>
Signed-off-by: Li Yang <leoli@freescale.com>
2009-05-15 15:27:16 -06:00
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
chan->common.cookie = cookie;
|
2010-01-06 06:34:06 -07:00
|
|
|
|
|
|
|
/* put this transaction onto the tail of the pending queue */
|
2010-01-06 06:34:05 -07:00
|
|
|
append_ld_queue(chan, desc);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
spin_unlock_irqrestore(&chan->desc_lock, flags);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
|
|
|
return cookie;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* fsl_dma_alloc_descriptor - Allocate descriptor from channel's DMA pool.
|
2010-01-06 06:34:05 -07:00
|
|
|
* @chan : Freescale DMA channel
|
2008-03-01 07:42:48 -07:00
|
|
|
*
|
|
|
|
* Return - The descriptor allocated. NULL for failed.
|
|
|
|
*/
|
2011-03-03 00:54:57 -07:00
|
|
|
static struct fsl_desc_sw *fsl_dma_alloc_descriptor(struct fsldma_chan *chan)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:34:06 -07:00
|
|
|
struct fsl_desc_sw *desc;
|
2008-03-01 07:42:48 -07:00
|
|
|
dma_addr_t pdesc;
|
2010-01-06 06:34:06 -07:00
|
|
|
|
|
|
|
desc = dma_pool_alloc(chan->desc_pool, GFP_ATOMIC, &pdesc);
|
|
|
|
if (!desc) {
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_dbg(chan, "out of memory for link descriptor\n");
|
2010-01-06 06:34:06 -07:00
|
|
|
return NULL;
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
memset(desc, 0, sizeof(*desc));
|
|
|
|
INIT_LIST_HEAD(&desc->tx_list);
|
|
|
|
dma_async_tx_descriptor_init(&desc->async_tx, &chan->common);
|
|
|
|
desc->async_tx.tx_submit = fsl_dma_tx_submit;
|
|
|
|
desc->async_tx.phys = pdesc;
|
|
|
|
|
2011-03-03 00:54:56 -07:00
|
|
|
#ifdef FSL_DMA_LD_DEBUG
|
|
|
|
chan_dbg(chan, "LD %p allocated\n", desc);
|
|
|
|
#endif
|
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
return desc;
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* fsl_dma_alloc_chan_resources - Allocate resources for DMA channel.
|
2010-01-06 06:34:05 -07:00
|
|
|
* @chan : Freescale DMA channel
|
2008-03-01 07:42:48 -07:00
|
|
|
*
|
|
|
|
* This function will create a dma pool for descriptor allocation.
|
|
|
|
*
|
|
|
|
* Return - The number of descriptors allocated.
|
|
|
|
*/
|
2010-01-06 06:34:05 -07:00
|
|
|
static int fsl_dma_alloc_chan_resources(struct dma_chan *dchan)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:34:05 -07:00
|
|
|
struct fsldma_chan *chan = to_fsl_chan(dchan);
|
2008-09-26 18:00:11 -06:00
|
|
|
|
|
|
|
/* Has this channel already been allocated? */
|
2010-01-06 06:34:05 -07:00
|
|
|
if (chan->desc_pool)
|
2008-09-26 18:00:11 -06:00
|
|
|
return 1;
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
/*
|
|
|
|
* We need the descriptor to be aligned to 32bytes
|
2008-03-01 07:42:48 -07:00
|
|
|
* for meeting FSL DMA specification requirement.
|
|
|
|
*/
|
2011-03-03 00:54:55 -07:00
|
|
|
chan->desc_pool = dma_pool_create(chan->name, chan->dev,
|
2010-01-06 06:34:06 -07:00
|
|
|
sizeof(struct fsl_desc_sw),
|
|
|
|
__alignof__(struct fsl_desc_sw), 0);
|
2010-01-06 06:34:05 -07:00
|
|
|
if (!chan->desc_pool) {
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_err(chan, "unable to allocate descriptor pool\n");
|
2010-01-06 06:34:06 -07:00
|
|
|
return -ENOMEM;
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
/* there is at least one descriptor free to be allocated */
|
2008-03-01 07:42:48 -07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
/**
|
|
|
|
* fsldma_free_desc_list - Free all descriptors in a queue
|
|
|
|
* @chan: Freescae DMA channel
|
|
|
|
* @list: the list to free
|
|
|
|
*
|
|
|
|
* LOCKING: must hold chan->desc_lock
|
|
|
|
*/
|
|
|
|
static void fsldma_free_desc_list(struct fsldma_chan *chan,
|
|
|
|
struct list_head *list)
|
|
|
|
{
|
|
|
|
struct fsl_desc_sw *desc, *_desc;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(desc, _desc, list, node) {
|
|
|
|
list_del(&desc->node);
|
2011-03-03 00:54:56 -07:00
|
|
|
#ifdef FSL_DMA_LD_DEBUG
|
|
|
|
chan_dbg(chan, "LD %p free\n", desc);
|
|
|
|
#endif
|
2010-01-06 06:34:06 -07:00
|
|
|
dma_pool_free(chan->desc_pool, desc, desc->async_tx.phys);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void fsldma_free_desc_list_reverse(struct fsldma_chan *chan,
|
|
|
|
struct list_head *list)
|
|
|
|
{
|
|
|
|
struct fsl_desc_sw *desc, *_desc;
|
|
|
|
|
|
|
|
list_for_each_entry_safe_reverse(desc, _desc, list, node) {
|
|
|
|
list_del(&desc->node);
|
2011-03-03 00:54:56 -07:00
|
|
|
#ifdef FSL_DMA_LD_DEBUG
|
|
|
|
chan_dbg(chan, "LD %p free\n", desc);
|
|
|
|
#endif
|
2010-01-06 06:34:06 -07:00
|
|
|
dma_pool_free(chan->desc_pool, desc, desc->async_tx.phys);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-03-01 07:42:48 -07:00
|
|
|
/**
|
|
|
|
* fsl_dma_free_chan_resources - Free all resources of the channel.
|
2010-01-06 06:34:05 -07:00
|
|
|
* @chan : Freescale DMA channel
|
2008-03-01 07:42:48 -07:00
|
|
|
*/
|
2010-01-06 06:34:05 -07:00
|
|
|
static void fsl_dma_free_chan_resources(struct dma_chan *dchan)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:34:05 -07:00
|
|
|
struct fsldma_chan *chan = to_fsl_chan(dchan);
|
2008-03-01 07:42:48 -07:00
|
|
|
unsigned long flags;
|
|
|
|
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_dbg(chan, "free all channel resources\n");
|
2010-01-06 06:34:05 -07:00
|
|
|
spin_lock_irqsave(&chan->desc_lock, flags);
|
2010-01-06 06:34:06 -07:00
|
|
|
fsldma_free_desc_list(chan, &chan->ld_pending);
|
|
|
|
fsldma_free_desc_list(chan, &chan->ld_running);
|
2010-01-06 06:34:05 -07:00
|
|
|
spin_unlock_irqrestore(&chan->desc_lock, flags);
|
2008-09-26 18:00:11 -06:00
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
dma_pool_destroy(chan->desc_pool);
|
2010-01-06 06:34:05 -07:00
|
|
|
chan->desc_pool = NULL;
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2008-03-13 18:45:28 -06:00
|
|
|
static struct dma_async_tx_descriptor *
|
2010-01-06 06:34:05 -07:00
|
|
|
fsl_dma_prep_interrupt(struct dma_chan *dchan, unsigned long flags)
|
2008-03-13 18:45:28 -06:00
|
|
|
{
|
2010-01-06 06:34:05 -07:00
|
|
|
struct fsldma_chan *chan;
|
2008-03-13 18:45:28 -06:00
|
|
|
struct fsl_desc_sw *new;
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
if (!dchan)
|
2008-03-13 18:45:28 -06:00
|
|
|
return NULL;
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
chan = to_fsl_chan(dchan);
|
2008-03-13 18:45:28 -06:00
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
new = fsl_dma_alloc_descriptor(chan);
|
2008-03-13 18:45:28 -06:00
|
|
|
if (!new) {
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_err(chan, "%s\n", msg_ld_oom);
|
2008-03-13 18:45:28 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
new->async_tx.cookie = -EBUSY;
|
2008-04-17 21:17:26 -06:00
|
|
|
new->async_tx.flags = flags;
|
2008-03-13 18:45:28 -06:00
|
|
|
|
2008-03-18 19:45:00 -06:00
|
|
|
/* Insert the link descriptor to the LD ring */
|
2009-09-08 18:53:02 -06:00
|
|
|
list_add_tail(&new->node, &new->tx_list);
|
2008-03-18 19:45:00 -06:00
|
|
|
|
2011-03-03 00:54:57 -07:00
|
|
|
/* Set End-of-link to the last link descriptor of new list */
|
2010-01-06 06:34:05 -07:00
|
|
|
set_ld_eol(chan, new);
|
2008-03-13 18:45:28 -06:00
|
|
|
|
|
|
|
return &new->async_tx;
|
|
|
|
}
|
|
|
|
|
2011-03-03 00:54:57 -07:00
|
|
|
static struct dma_async_tx_descriptor *
|
|
|
|
fsl_dma_prep_memcpy(struct dma_chan *dchan,
|
|
|
|
dma_addr_t dma_dst, dma_addr_t dma_src,
|
2008-03-01 07:42:48 -07:00
|
|
|
size_t len, unsigned long flags)
|
|
|
|
{
|
2010-01-06 06:34:05 -07:00
|
|
|
struct fsldma_chan *chan;
|
2008-03-01 07:42:48 -07:00
|
|
|
struct fsl_desc_sw *first = NULL, *prev = NULL, *new;
|
|
|
|
size_t copy;
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
if (!dchan)
|
2008-03-01 07:42:48 -07:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!len)
|
|
|
|
return NULL;
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
chan = to_fsl_chan(dchan);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
|
|
|
do {
|
|
|
|
|
|
|
|
/* Allocate the link descriptor from DMA pool */
|
2010-01-06 06:34:05 -07:00
|
|
|
new = fsl_dma_alloc_descriptor(chan);
|
2008-03-01 07:42:48 -07:00
|
|
|
if (!new) {
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_err(chan, "%s\n", msg_ld_oom);
|
2009-05-15 10:59:46 -06:00
|
|
|
goto fail;
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2008-03-13 11:45:27 -06:00
|
|
|
copy = min(len, (size_t)FSL_DMA_BCR_MAX_CNT);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
set_desc_cnt(chan, &new->hw, copy);
|
|
|
|
set_desc_src(chan, &new->hw, dma_src);
|
|
|
|
set_desc_dst(chan, &new->hw, dma_dst);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
|
|
|
if (!first)
|
|
|
|
first = new;
|
|
|
|
else
|
2010-01-06 06:34:05 -07:00
|
|
|
set_desc_next(chan, &prev->hw, new->async_tx.phys);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
|
|
|
new->async_tx.cookie = 0;
|
2008-04-17 21:17:26 -06:00
|
|
|
async_tx_ack(&new->async_tx);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
|
|
|
prev = new;
|
|
|
|
len -= copy;
|
|
|
|
dma_src += copy;
|
2010-01-06 06:34:02 -07:00
|
|
|
dma_dst += copy;
|
2008-03-01 07:42:48 -07:00
|
|
|
|
|
|
|
/* Insert the link descriptor to the LD ring */
|
2009-09-08 18:53:02 -06:00
|
|
|
list_add_tail(&new->node, &first->tx_list);
|
2008-03-01 07:42:48 -07:00
|
|
|
} while (len);
|
|
|
|
|
2008-04-17 21:17:26 -06:00
|
|
|
new->async_tx.flags = flags; /* client is in control of this ack */
|
2008-03-01 07:42:48 -07:00
|
|
|
new->async_tx.cookie = -EBUSY;
|
|
|
|
|
2011-03-03 00:54:57 -07:00
|
|
|
/* Set End-of-link to the last link descriptor of new list */
|
2010-01-06 06:34:05 -07:00
|
|
|
set_ld_eol(chan, new);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2009-05-15 10:59:46 -06:00
|
|
|
return &first->async_tx;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
if (!first)
|
|
|
|
return NULL;
|
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
fsldma_free_desc_list_reverse(chan, &first->tx_list);
|
2009-05-15 10:59:46 -06:00
|
|
|
return NULL;
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2010-09-30 05:46:45 -06:00
|
|
|
static struct dma_async_tx_descriptor *fsl_dma_prep_sg(struct dma_chan *dchan,
|
|
|
|
struct scatterlist *dst_sg, unsigned int dst_nents,
|
|
|
|
struct scatterlist *src_sg, unsigned int src_nents,
|
|
|
|
unsigned long flags)
|
|
|
|
{
|
|
|
|
struct fsl_desc_sw *first = NULL, *prev = NULL, *new = NULL;
|
|
|
|
struct fsldma_chan *chan = to_fsl_chan(dchan);
|
|
|
|
size_t dst_avail, src_avail;
|
|
|
|
dma_addr_t dst, src;
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
/* basic sanity checks */
|
|
|
|
if (dst_nents == 0 || src_nents == 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (dst_sg == NULL || src_sg == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TODO: should we check that both scatterlists have the same
|
|
|
|
* TODO: number of bytes in total? Is that really an error?
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* get prepared for the loop */
|
|
|
|
dst_avail = sg_dma_len(dst_sg);
|
|
|
|
src_avail = sg_dma_len(src_sg);
|
|
|
|
|
|
|
|
/* run until we are out of scatterlist entries */
|
|
|
|
while (true) {
|
|
|
|
|
|
|
|
/* create the largest transaction possible */
|
|
|
|
len = min_t(size_t, src_avail, dst_avail);
|
|
|
|
len = min_t(size_t, len, FSL_DMA_BCR_MAX_CNT);
|
|
|
|
if (len == 0)
|
|
|
|
goto fetch;
|
|
|
|
|
|
|
|
dst = sg_dma_address(dst_sg) + sg_dma_len(dst_sg) - dst_avail;
|
|
|
|
src = sg_dma_address(src_sg) + sg_dma_len(src_sg) - src_avail;
|
|
|
|
|
|
|
|
/* allocate and populate the descriptor */
|
|
|
|
new = fsl_dma_alloc_descriptor(chan);
|
|
|
|
if (!new) {
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_err(chan, "%s\n", msg_ld_oom);
|
2010-09-30 05:46:45 -06:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
set_desc_cnt(chan, &new->hw, len);
|
|
|
|
set_desc_src(chan, &new->hw, src);
|
|
|
|
set_desc_dst(chan, &new->hw, dst);
|
|
|
|
|
|
|
|
if (!first)
|
|
|
|
first = new;
|
|
|
|
else
|
|
|
|
set_desc_next(chan, &prev->hw, new->async_tx.phys);
|
|
|
|
|
|
|
|
new->async_tx.cookie = 0;
|
|
|
|
async_tx_ack(&new->async_tx);
|
|
|
|
prev = new;
|
|
|
|
|
|
|
|
/* Insert the link descriptor to the LD ring */
|
|
|
|
list_add_tail(&new->node, &first->tx_list);
|
|
|
|
|
|
|
|
/* update metadata */
|
|
|
|
dst_avail -= len;
|
|
|
|
src_avail -= len;
|
|
|
|
|
|
|
|
fetch:
|
|
|
|
/* fetch the next dst scatterlist entry */
|
|
|
|
if (dst_avail == 0) {
|
|
|
|
|
|
|
|
/* no more entries: we're done */
|
|
|
|
if (dst_nents == 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* fetch the next entry: if there are no more: done */
|
|
|
|
dst_sg = sg_next(dst_sg);
|
|
|
|
if (dst_sg == NULL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
dst_nents--;
|
|
|
|
dst_avail = sg_dma_len(dst_sg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fetch the next src scatterlist entry */
|
|
|
|
if (src_avail == 0) {
|
|
|
|
|
|
|
|
/* no more entries: we're done */
|
|
|
|
if (src_nents == 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* fetch the next entry: if there are no more: done */
|
|
|
|
src_sg = sg_next(src_sg);
|
|
|
|
if (src_sg == NULL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
src_nents--;
|
|
|
|
src_avail = sg_dma_len(src_sg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
new->async_tx.flags = flags; /* client is in control of this ack */
|
|
|
|
new->async_tx.cookie = -EBUSY;
|
|
|
|
|
|
|
|
/* Set End-of-link to the last link descriptor of new list */
|
|
|
|
set_ld_eol(chan, new);
|
|
|
|
|
|
|
|
return &first->async_tx;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
if (!first)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
fsldma_free_desc_list_reverse(chan, &first->tx_list);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-09-08 18:53:04 -06:00
|
|
|
/**
|
|
|
|
* fsl_dma_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: DMAEngine flags
|
|
|
|
*
|
|
|
|
* Prepare a set of descriptors for a DMA_SLAVE transaction. Following the
|
|
|
|
* DMA_SLAVE API, this gets the device-specific information from the
|
|
|
|
* chan->private variable.
|
|
|
|
*/
|
|
|
|
static struct dma_async_tx_descriptor *fsl_dma_prep_slave_sg(
|
2010-01-06 06:34:05 -07:00
|
|
|
struct dma_chan *dchan, struct scatterlist *sgl, unsigned int sg_len,
|
2009-09-08 18:53:04 -06:00
|
|
|
enum dma_data_direction direction, unsigned long flags)
|
|
|
|
{
|
|
|
|
/*
|
2010-09-30 05:46:46 -06:00
|
|
|
* This operation is not supported on the Freescale DMA controller
|
2009-09-08 18:53:04 -06:00
|
|
|
*
|
2010-09-30 05:46:46 -06:00
|
|
|
* However, we need to provide the function pointer to allow the
|
|
|
|
* device_control() method to work.
|
2009-09-08 18:53:04 -06:00
|
|
|
*/
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-03-26 17:44:01 -06:00
|
|
|
static int fsl_dma_device_control(struct dma_chan *dchan,
|
2010-05-17 17:30:42 -06:00
|
|
|
enum dma_ctrl_cmd cmd, unsigned long arg)
|
2009-09-08 18:53:04 -06:00
|
|
|
{
|
2010-09-30 05:46:46 -06:00
|
|
|
struct dma_slave_config *config;
|
2010-01-06 06:34:05 -07:00
|
|
|
struct fsldma_chan *chan;
|
2009-09-08 18:53:04 -06:00
|
|
|
unsigned long flags;
|
2010-09-30 05:46:46 -06:00
|
|
|
int size;
|
2010-03-26 17:44:01 -06:00
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
if (!dchan)
|
2010-03-26 17:44:01 -06:00
|
|
|
return -EINVAL;
|
2009-09-08 18:53:04 -06:00
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
chan = to_fsl_chan(dchan);
|
2009-09-08 18:53:04 -06:00
|
|
|
|
2010-09-30 05:46:46 -06:00
|
|
|
switch (cmd) {
|
|
|
|
case DMA_TERMINATE_ALL:
|
2011-03-03 00:54:58 -07:00
|
|
|
spin_lock_irqsave(&chan->desc_lock, flags);
|
|
|
|
|
2010-09-30 05:46:46 -06:00
|
|
|
/* Halt the DMA engine */
|
|
|
|
dma_halt(chan);
|
2009-09-08 18:53:04 -06:00
|
|
|
|
2010-09-30 05:46:46 -06:00
|
|
|
/* Remove and free all of the descriptors in the LD queue */
|
|
|
|
fsldma_free_desc_list(chan, &chan->ld_pending);
|
|
|
|
fsldma_free_desc_list(chan, &chan->ld_running);
|
2011-03-03 00:54:58 -07:00
|
|
|
chan->idle = true;
|
2009-09-08 18:53:04 -06:00
|
|
|
|
2010-09-30 05:46:46 -06:00
|
|
|
spin_unlock_irqrestore(&chan->desc_lock, flags);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case DMA_SLAVE_CONFIG:
|
|
|
|
config = (struct dma_slave_config *)arg;
|
|
|
|
|
|
|
|
/* make sure the channel supports setting burst size */
|
|
|
|
if (!chan->set_request_count)
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
/* we set the controller burst size depending on direction */
|
|
|
|
if (config->direction == DMA_TO_DEVICE)
|
|
|
|
size = config->dst_addr_width * config->dst_maxburst;
|
|
|
|
else
|
|
|
|
size = config->src_addr_width * config->src_maxburst;
|
|
|
|
|
|
|
|
chan->set_request_count(chan, size);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case FSLDMA_EXTERNAL_START:
|
|
|
|
|
|
|
|
/* make sure the channel supports external start */
|
|
|
|
if (!chan->toggle_ext_start)
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
chan->toggle_ext_start(chan, arg);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -ENXIO;
|
|
|
|
}
|
2010-03-26 17:44:01 -06:00
|
|
|
|
|
|
|
return 0;
|
2009-09-08 18:53:04 -06:00
|
|
|
}
|
|
|
|
|
2008-03-01 07:42:48 -07:00
|
|
|
/**
|
2011-03-03 00:54:59 -07:00
|
|
|
* fsldma_cleanup_descriptor - cleanup and free a single link descriptor
|
2010-01-06 06:34:06 -07:00
|
|
|
* @chan: Freescale DMA channel
|
2011-03-03 00:54:59 -07:00
|
|
|
* @desc: descriptor to cleanup and free
|
2008-03-01 07:42:48 -07:00
|
|
|
*
|
2011-03-03 00:54:59 -07:00
|
|
|
* This function is used on a descriptor which has been executed by the DMA
|
|
|
|
* controller. It will run any callbacks, submit any dependencies, and then
|
|
|
|
* free the descriptor.
|
2008-03-01 07:42:48 -07:00
|
|
|
*/
|
2011-03-03 00:54:59 -07:00
|
|
|
static void fsldma_cleanup_descriptor(struct fsldma_chan *chan,
|
|
|
|
struct fsl_desc_sw *desc)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2011-03-03 00:54:59 -07:00
|
|
|
struct dma_async_tx_descriptor *txd = &desc->async_tx;
|
|
|
|
struct device *dev = chan->common.device->dev;
|
|
|
|
dma_addr_t src = get_desc_src(chan, desc);
|
|
|
|
dma_addr_t dst = get_desc_dst(chan, desc);
|
|
|
|
u32 len = get_desc_cnt(chan, desc);
|
|
|
|
|
|
|
|
/* Run the link descriptor callback function */
|
|
|
|
if (txd->callback) {
|
|
|
|
#ifdef FSL_DMA_LD_DEBUG
|
|
|
|
chan_dbg(chan, "LD %p callback\n", desc);
|
|
|
|
#endif
|
|
|
|
txd->callback(txd->callback_param);
|
|
|
|
}
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2011-03-03 00:54:59 -07:00
|
|
|
/* Run any dependencies */
|
|
|
|
dma_run_dependencies(txd);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2011-03-03 00:54:59 -07:00
|
|
|
/* Unmap the dst buffer, if requested */
|
|
|
|
if (!(txd->flags & DMA_COMPL_SKIP_DEST_UNMAP)) {
|
|
|
|
if (txd->flags & DMA_COMPL_DEST_UNMAP_SINGLE)
|
|
|
|
dma_unmap_single(dev, dst, len, DMA_FROM_DEVICE);
|
|
|
|
else
|
|
|
|
dma_unmap_page(dev, dst, len, DMA_FROM_DEVICE);
|
|
|
|
}
|
2010-01-06 06:34:06 -07:00
|
|
|
|
2011-03-03 00:54:59 -07:00
|
|
|
/* Unmap the src buffer, if requested */
|
|
|
|
if (!(txd->flags & DMA_COMPL_SKIP_SRC_UNMAP)) {
|
|
|
|
if (txd->flags & DMA_COMPL_SRC_UNMAP_SINGLE)
|
|
|
|
dma_unmap_single(dev, src, len, DMA_TO_DEVICE);
|
|
|
|
else
|
|
|
|
dma_unmap_page(dev, src, len, DMA_TO_DEVICE);
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
2010-01-06 06:34:06 -07:00
|
|
|
|
2011-03-03 00:54:59 -07:00
|
|
|
#ifdef FSL_DMA_LD_DEBUG
|
|
|
|
chan_dbg(chan, "LD %p free\n", desc);
|
|
|
|
#endif
|
|
|
|
dma_pool_free(chan->desc_pool, desc, txd->phys);
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-01-06 06:34:06 -07:00
|
|
|
* fsl_chan_xfer_ld_queue - transfer any pending transactions
|
2010-01-06 06:34:05 -07:00
|
|
|
* @chan : Freescale DMA channel
|
2010-01-06 06:34:06 -07:00
|
|
|
*
|
2011-03-03 00:54:58 -07:00
|
|
|
* HARDWARE STATE: idle
|
2011-03-03 00:55:00 -07:00
|
|
|
* LOCKING: must hold chan->desc_lock
|
2008-03-01 07:42:48 -07:00
|
|
|
*/
|
2010-01-06 06:34:05 -07:00
|
|
|
static void fsl_chan_xfer_ld_queue(struct fsldma_chan *chan)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:34:06 -07:00
|
|
|
struct fsl_desc_sw *desc;
|
2009-05-19 16:42:13 -06:00
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
/*
|
|
|
|
* If the list of pending descriptors is empty, then we
|
|
|
|
* don't need to do any work at all
|
|
|
|
*/
|
|
|
|
if (list_empty(&chan->ld_pending)) {
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_dbg(chan, "no pending LDs\n");
|
2011-03-03 00:55:00 -07:00
|
|
|
return;
|
2010-01-06 06:34:06 -07:00
|
|
|
}
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
/*
|
2011-03-03 00:54:58 -07:00
|
|
|
* The DMA controller is not idle, which means that the interrupt
|
|
|
|
* handler will start any queued transactions when it runs after
|
|
|
|
* this transaction finishes
|
2010-01-06 06:34:06 -07:00
|
|
|
*/
|
2011-03-03 00:54:58 -07:00
|
|
|
if (!chan->idle) {
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_dbg(chan, "DMA controller still busy\n");
|
2011-03-03 00:55:00 -07:00
|
|
|
return;
|
2010-01-06 06:34:06 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there are some link descriptors which have not been
|
|
|
|
* transferred, we need to start the controller
|
2008-03-01 07:42:48 -07:00
|
|
|
*/
|
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
/*
|
|
|
|
* Move all elements from the queue of pending transactions
|
|
|
|
* onto the list of running transactions
|
|
|
|
*/
|
2011-03-03 00:54:58 -07:00
|
|
|
chan_dbg(chan, "idle, starting controller\n");
|
2010-01-06 06:34:06 -07:00
|
|
|
desc = list_first_entry(&chan->ld_pending, struct fsl_desc_sw, node);
|
|
|
|
list_splice_tail_init(&chan->ld_pending, &chan->ld_running);
|
|
|
|
|
2011-03-03 00:54:58 -07:00
|
|
|
/*
|
|
|
|
* The 85xx DMA controller doesn't clear the channel start bit
|
|
|
|
* automatically at the end of a transfer. Therefore we must clear
|
|
|
|
* it in software before starting the transfer.
|
|
|
|
*/
|
|
|
|
if ((chan->feature & FSL_DMA_IP_MASK) == FSL_DMA_IP_85XX) {
|
|
|
|
u32 mode;
|
|
|
|
|
|
|
|
mode = DMA_IN(chan, &chan->regs->mr, 32);
|
|
|
|
mode &= ~FSL_DMA_MR_CS;
|
|
|
|
DMA_OUT(chan, &chan->regs->mr, mode, 32);
|
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
/*
|
|
|
|
* Program the descriptor's address into the DMA controller,
|
|
|
|
* then start the DMA transaction
|
|
|
|
*/
|
|
|
|
set_cdar(chan, desc->async_tx.phys);
|
2011-03-03 00:54:58 -07:00
|
|
|
get_cdar(chan);
|
2009-05-19 16:42:13 -06:00
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
dma_start(chan);
|
2011-03-03 00:54:58 -07:00
|
|
|
chan->idle = false;
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* fsl_dma_memcpy_issue_pending - Issue the DMA start command
|
2010-01-06 06:34:05 -07:00
|
|
|
* @chan : Freescale DMA channel
|
2008-03-01 07:42:48 -07:00
|
|
|
*/
|
2010-01-06 06:34:05 -07:00
|
|
|
static void fsl_dma_memcpy_issue_pending(struct dma_chan *dchan)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:34:05 -07:00
|
|
|
struct fsldma_chan *chan = to_fsl_chan(dchan);
|
2011-03-03 00:55:00 -07:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&chan->desc_lock, flags);
|
2010-01-06 06:34:05 -07:00
|
|
|
fsl_chan_xfer_ld_queue(chan);
|
2011-03-03 00:55:00 -07:00
|
|
|
spin_unlock_irqrestore(&chan->desc_lock, flags);
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-03-26 17:50:49 -06:00
|
|
|
* fsl_tx_status - Determine the DMA status
|
2010-01-06 06:34:05 -07:00
|
|
|
* @chan : Freescale DMA channel
|
2008-03-01 07:42:48 -07:00
|
|
|
*/
|
2010-03-26 17:50:49 -06:00
|
|
|
static enum dma_status fsl_tx_status(struct dma_chan *dchan,
|
2008-03-01 07:42:48 -07:00
|
|
|
dma_cookie_t cookie,
|
2010-03-26 17:50:49 -06:00
|
|
|
struct dma_tx_state *txstate)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:34:05 -07:00
|
|
|
struct fsldma_chan *chan = to_fsl_chan(dchan);
|
2008-03-01 07:42:48 -07:00
|
|
|
dma_cookie_t last_complete;
|
2011-03-03 00:54:58 -07:00
|
|
|
dma_cookie_t last_used;
|
|
|
|
unsigned long flags;
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2011-03-03 00:54:58 -07:00
|
|
|
spin_lock_irqsave(&chan->desc_lock, flags);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
last_complete = chan->completed_cookie;
|
2011-03-03 00:54:58 -07:00
|
|
|
last_used = dchan->cookie;
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2011-03-03 00:54:58 -07:00
|
|
|
spin_unlock_irqrestore(&chan->desc_lock, flags);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2011-03-03 00:54:58 -07:00
|
|
|
dma_set_tx_state(txstate, last_complete, last_used, 0);
|
2008-03-01 07:42:48 -07:00
|
|
|
return dma_async_is_complete(cookie, last_complete, last_used);
|
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:04 -07:00
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
/* Interrupt Handling */
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
|
2010-01-06 06:34:03 -07:00
|
|
|
static irqreturn_t fsldma_chan_irq(int irq, void *data)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:34:05 -07:00
|
|
|
struct fsldma_chan *chan = data;
|
|
|
|
u32 stat;
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
/* save and clear the status register */
|
2010-01-06 06:34:05 -07:00
|
|
|
stat = get_sr(chan);
|
2010-01-06 06:34:06 -07:00
|
|
|
set_sr(chan, stat);
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_dbg(chan, "irq: stat = 0x%x\n", stat);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2011-03-03 00:54:58 -07:00
|
|
|
/* check that this was really our device */
|
2008-03-01 07:42:48 -07:00
|
|
|
stat &= ~(FSL_DMA_SR_CB | FSL_DMA_SR_CH);
|
|
|
|
if (!stat)
|
|
|
|
return IRQ_NONE;
|
|
|
|
|
|
|
|
if (stat & FSL_DMA_SR_TE)
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_err(chan, "Transfer Error!\n");
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
/*
|
|
|
|
* Programming Error
|
2008-03-18 19:45:00 -06:00
|
|
|
* The DMA_INTERRUPT async_tx is a NULL transfer, which will
|
|
|
|
* triger a PE interrupt.
|
|
|
|
*/
|
|
|
|
if (stat & FSL_DMA_SR_PE) {
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_dbg(chan, "irq: Programming Error INT\n");
|
2008-03-18 19:45:00 -06:00
|
|
|
stat &= ~FSL_DMA_SR_PE;
|
2011-03-03 00:54:58 -07:00
|
|
|
if (get_bcr(chan) != 0)
|
|
|
|
chan_err(chan, "Programming Error!\n");
|
2008-04-17 21:17:25 -06:00
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
/*
|
|
|
|
* For MPC8349, EOCDI event need to update cookie
|
2008-04-17 21:17:25 -06:00
|
|
|
* and start the next transfer if it exist.
|
|
|
|
*/
|
|
|
|
if (stat & FSL_DMA_SR_EOCDI) {
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_dbg(chan, "irq: End-of-Chain link INT\n");
|
2008-04-17 21:17:25 -06:00
|
|
|
stat &= ~FSL_DMA_SR_EOCDI;
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:06 -07:00
|
|
|
/*
|
|
|
|
* If it current transfer is the end-of-transfer,
|
2008-03-01 07:42:48 -07:00
|
|
|
* we should clear the Channel Start bit for
|
|
|
|
* prepare next transfer.
|
|
|
|
*/
|
2008-04-17 21:17:25 -06:00
|
|
|
if (stat & FSL_DMA_SR_EOLNI) {
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_dbg(chan, "irq: End-of-link INT\n");
|
2008-03-01 07:42:48 -07:00
|
|
|
stat &= ~FSL_DMA_SR_EOLNI;
|
|
|
|
}
|
|
|
|
|
2011-03-03 00:54:58 -07:00
|
|
|
/* check that the DMA controller is really idle */
|
|
|
|
if (!dma_is_idle(chan))
|
|
|
|
chan_err(chan, "irq: controller not idle!\n");
|
|
|
|
|
|
|
|
/* check that we handled all of the bits */
|
2008-03-01 07:42:48 -07:00
|
|
|
if (stat)
|
2011-03-03 00:54:58 -07:00
|
|
|
chan_err(chan, "irq: unhandled sr 0x%08x\n", stat);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2011-03-03 00:54:58 -07:00
|
|
|
/*
|
|
|
|
* Schedule the tasklet to handle all cleanup of the current
|
|
|
|
* transaction. It will start a new transaction if there is
|
|
|
|
* one pending.
|
|
|
|
*/
|
2010-01-06 06:34:05 -07:00
|
|
|
tasklet_schedule(&chan->tasklet);
|
2011-03-03 00:54:58 -07:00
|
|
|
chan_dbg(chan, "irq: Exit\n");
|
2008-03-01 07:42:48 -07:00
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:04 -07:00
|
|
|
static void dma_do_tasklet(unsigned long data)
|
|
|
|
{
|
2010-01-06 06:34:05 -07:00
|
|
|
struct fsldma_chan *chan = (struct fsldma_chan *)data;
|
2011-03-03 00:55:00 -07:00
|
|
|
struct fsl_desc_sw *desc, *_desc;
|
|
|
|
LIST_HEAD(ld_cleanup);
|
2011-03-03 00:54:58 -07:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
chan_dbg(chan, "tasklet entry\n");
|
|
|
|
|
|
|
|
spin_lock_irqsave(&chan->desc_lock, flags);
|
2011-03-03 00:55:00 -07:00
|
|
|
|
|
|
|
/* update the cookie if we have some descriptors to cleanup */
|
|
|
|
if (!list_empty(&chan->ld_running)) {
|
|
|
|
dma_cookie_t cookie;
|
|
|
|
|
|
|
|
desc = to_fsl_desc(chan->ld_running.prev);
|
|
|
|
cookie = desc->async_tx.cookie;
|
|
|
|
|
|
|
|
chan->completed_cookie = cookie;
|
|
|
|
chan_dbg(chan, "completed_cookie=%d\n", cookie);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* move the descriptors to a temporary list so we can drop the lock
|
|
|
|
* during the entire cleanup operation
|
|
|
|
*/
|
|
|
|
list_splice_tail_init(&chan->ld_running, &ld_cleanup);
|
|
|
|
|
|
|
|
/* the hardware is now idle and ready for more */
|
2011-03-03 00:54:58 -07:00
|
|
|
chan->idle = true;
|
|
|
|
|
2011-03-03 00:55:00 -07:00
|
|
|
/*
|
|
|
|
* Start any pending transactions automatically
|
|
|
|
*
|
|
|
|
* In the ideal case, we keep the DMA controller busy while we go
|
|
|
|
* ahead and free the descriptors below.
|
|
|
|
*/
|
2011-03-03 00:54:58 -07:00
|
|
|
fsl_chan_xfer_ld_queue(chan);
|
2011-03-03 00:55:00 -07:00
|
|
|
spin_unlock_irqrestore(&chan->desc_lock, flags);
|
|
|
|
|
|
|
|
/* Run the callback for each descriptor, in order */
|
|
|
|
list_for_each_entry_safe(desc, _desc, &ld_cleanup, node) {
|
|
|
|
|
|
|
|
/* Remove from the list of transactions */
|
|
|
|
list_del(&desc->node);
|
|
|
|
|
|
|
|
/* Run all cleanup for this descriptor */
|
|
|
|
fsldma_cleanup_descriptor(chan, desc);
|
|
|
|
}
|
|
|
|
|
2011-03-03 00:54:58 -07:00
|
|
|
chan_dbg(chan, "tasklet exit\n");
|
2010-01-06 06:34:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static irqreturn_t fsldma_ctrl_irq(int irq, void *data)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:34:01 -07:00
|
|
|
struct fsldma_device *fdev = data;
|
2010-01-06 06:34:04 -07:00
|
|
|
struct fsldma_chan *chan;
|
|
|
|
unsigned int handled = 0;
|
|
|
|
u32 gsr, mask;
|
|
|
|
int i;
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:03 -07:00
|
|
|
gsr = (fdev->feature & FSL_DMA_BIG_ENDIAN) ? in_be32(fdev->regs)
|
2010-01-06 06:34:04 -07:00
|
|
|
: in_le32(fdev->regs);
|
|
|
|
mask = 0xff000000;
|
|
|
|
dev_dbg(fdev->dev, "IRQ: gsr 0x%.8x\n", gsr);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:04 -07:00
|
|
|
for (i = 0; i < FSL_DMA_MAX_CHANS_PER_DEVICE; i++) {
|
|
|
|
chan = fdev->chan[i];
|
|
|
|
if (!chan)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (gsr & mask) {
|
|
|
|
dev_dbg(fdev->dev, "IRQ: chan %d\n", chan->id);
|
|
|
|
fsldma_chan_irq(irq, chan);
|
|
|
|
handled++;
|
|
|
|
}
|
|
|
|
|
|
|
|
gsr &= ~mask;
|
|
|
|
mask >>= 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
return IRQ_RETVAL(handled);
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:04 -07:00
|
|
|
static void fsldma_free_irqs(struct fsldma_device *fdev)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:34:04 -07:00
|
|
|
struct fsldma_chan *chan;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (fdev->irq != NO_IRQ) {
|
|
|
|
dev_dbg(fdev->dev, "free per-controller IRQ\n");
|
|
|
|
free_irq(fdev->irq, fdev);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < FSL_DMA_MAX_CHANS_PER_DEVICE; i++) {
|
|
|
|
chan = fdev->chan[i];
|
|
|
|
if (chan && chan->irq != NO_IRQ) {
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_dbg(chan, "free per-channel IRQ\n");
|
2010-01-06 06:34:04 -07:00
|
|
|
free_irq(chan->irq, chan);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fsldma_request_irqs(struct fsldma_device *fdev)
|
|
|
|
{
|
|
|
|
struct fsldma_chan *chan;
|
|
|
|
int ret;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* if we have a per-controller IRQ, use that */
|
|
|
|
if (fdev->irq != NO_IRQ) {
|
|
|
|
dev_dbg(fdev->dev, "request per-controller IRQ\n");
|
|
|
|
ret = request_irq(fdev->irq, fsldma_ctrl_irq, IRQF_SHARED,
|
|
|
|
"fsldma-controller", fdev);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* no per-controller IRQ, use the per-channel IRQs */
|
|
|
|
for (i = 0; i < FSL_DMA_MAX_CHANS_PER_DEVICE; i++) {
|
|
|
|
chan = fdev->chan[i];
|
|
|
|
if (!chan)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (chan->irq == NO_IRQ) {
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_err(chan, "interrupts property missing in device tree\n");
|
2010-01-06 06:34:04 -07:00
|
|
|
ret = -ENODEV;
|
|
|
|
goto out_unwind;
|
|
|
|
}
|
|
|
|
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_dbg(chan, "request per-channel IRQ\n");
|
2010-01-06 06:34:04 -07:00
|
|
|
ret = request_irq(chan->irq, fsldma_chan_irq, IRQF_SHARED,
|
|
|
|
"fsldma-chan", chan);
|
|
|
|
if (ret) {
|
2011-03-03 00:54:55 -07:00
|
|
|
chan_err(chan, "unable to request per-channel IRQ\n");
|
2010-01-06 06:34:04 -07:00
|
|
|
goto out_unwind;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_unwind:
|
|
|
|
for (/* none */; i >= 0; i--) {
|
|
|
|
chan = fdev->chan[i];
|
|
|
|
if (!chan)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (chan->irq == NO_IRQ)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
free_irq(chan->irq, chan);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:01 -07:00
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
/* OpenFirmware Subsystem */
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
static int __devinit fsl_dma_chan_probe(struct fsldma_device *fdev,
|
2008-09-26 18:00:11 -06:00
|
|
|
struct device_node *node, u32 feature, const char *compatible)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:34:05 -07:00
|
|
|
struct fsldma_chan *chan;
|
2010-01-06 06:34:00 -07:00
|
|
|
struct resource res;
|
2008-03-01 07:42:48 -07:00
|
|
|
int err;
|
|
|
|
|
|
|
|
/* alloc channel */
|
2010-01-06 06:34:05 -07:00
|
|
|
chan = kzalloc(sizeof(*chan), GFP_KERNEL);
|
|
|
|
if (!chan) {
|
2010-01-06 06:34:03 -07:00
|
|
|
dev_err(fdev->dev, "no free memory for DMA channels!\n");
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto out_return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ioremap registers for use */
|
2010-01-06 06:34:05 -07:00
|
|
|
chan->regs = of_iomap(node, 0);
|
|
|
|
if (!chan->regs) {
|
2010-01-06 06:34:03 -07:00
|
|
|
dev_err(fdev->dev, "unable to ioremap registers\n");
|
|
|
|
err = -ENOMEM;
|
2010-01-06 06:34:05 -07:00
|
|
|
goto out_free_chan;
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:00 -07:00
|
|
|
err = of_address_to_resource(node, 0, &res);
|
2008-03-01 07:42:48 -07:00
|
|
|
if (err) {
|
2010-01-06 06:34:03 -07:00
|
|
|
dev_err(fdev->dev, "unable to find 'reg' property\n");
|
|
|
|
goto out_iounmap_regs;
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
chan->feature = feature;
|
2008-03-01 07:42:48 -07:00
|
|
|
if (!fdev->feature)
|
2010-01-06 06:34:05 -07:00
|
|
|
fdev->feature = chan->feature;
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:03 -07:00
|
|
|
/*
|
|
|
|
* If the DMA device's feature is different than the feature
|
|
|
|
* of its channels, report the bug
|
2008-03-01 07:42:48 -07:00
|
|
|
*/
|
2010-01-06 06:34:05 -07:00
|
|
|
WARN_ON(fdev->feature != chan->feature);
|
2010-01-06 06:34:03 -07:00
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
chan->dev = fdev->dev;
|
|
|
|
chan->id = ((res.start - 0x100) & 0xfff) >> 7;
|
|
|
|
if (chan->id >= FSL_DMA_MAX_CHANS_PER_DEVICE) {
|
2010-01-06 06:34:03 -07:00
|
|
|
dev_err(fdev->dev, "too many channels for device\n");
|
2008-03-01 07:42:48 -07:00
|
|
|
err = -EINVAL;
|
2010-01-06 06:34:03 -07:00
|
|
|
goto out_iounmap_regs;
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
fdev->chan[chan->id] = chan;
|
|
|
|
tasklet_init(&chan->tasklet, dma_do_tasklet, (unsigned long)chan);
|
2011-03-03 00:54:55 -07:00
|
|
|
snprintf(chan->name, sizeof(chan->name), "chan%d", chan->id);
|
2010-01-06 06:34:03 -07:00
|
|
|
|
|
|
|
/* Initialize the channel */
|
2010-01-06 06:34:05 -07:00
|
|
|
dma_init(chan);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
|
|
|
/* Clear cdar registers */
|
2010-01-06 06:34:05 -07:00
|
|
|
set_cdar(chan, 0);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
switch (chan->feature & FSL_DMA_IP_MASK) {
|
2008-03-01 07:42:48 -07:00
|
|
|
case FSL_DMA_IP_85XX:
|
2010-01-06 06:34:05 -07:00
|
|
|
chan->toggle_ext_pause = fsl_chan_toggle_ext_pause;
|
2008-03-01 07:42:48 -07:00
|
|
|
case FSL_DMA_IP_83XX:
|
2010-01-06 06:34:05 -07:00
|
|
|
chan->toggle_ext_start = fsl_chan_toggle_ext_start;
|
|
|
|
chan->set_src_loop_size = fsl_chan_set_src_loop_size;
|
|
|
|
chan->set_dst_loop_size = fsl_chan_set_dst_loop_size;
|
|
|
|
chan->set_request_count = fsl_chan_set_request_count;
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
spin_lock_init(&chan->desc_lock);
|
2010-01-06 06:34:06 -07:00
|
|
|
INIT_LIST_HEAD(&chan->ld_pending);
|
|
|
|
INIT_LIST_HEAD(&chan->ld_running);
|
2011-03-03 00:54:58 -07:00
|
|
|
chan->idle = true;
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
chan->common.device = &fdev->common;
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:04 -07:00
|
|
|
/* find the IRQ line, if it exists in the device tree */
|
2010-01-06 06:34:05 -07:00
|
|
|
chan->irq = irq_of_parse_and_map(node, 0);
|
2010-01-06 06:34:04 -07:00
|
|
|
|
2008-03-01 07:42:48 -07:00
|
|
|
/* Add the channel to DMA device channel list */
|
2010-01-06 06:34:05 -07:00
|
|
|
list_add_tail(&chan->common.device_node, &fdev->common.channels);
|
2008-03-01 07:42:48 -07:00
|
|
|
fdev->common.chancnt++;
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
dev_info(fdev->dev, "#%d (%s), irq %d\n", chan->id, compatible,
|
|
|
|
chan->irq != NO_IRQ ? chan->irq : fdev->irq);
|
2008-03-01 07:42:48 -07:00
|
|
|
|
|
|
|
return 0;
|
2008-05-30 00:25:45 -06:00
|
|
|
|
2010-01-06 06:34:03 -07:00
|
|
|
out_iounmap_regs:
|
2010-01-06 06:34:05 -07:00
|
|
|
iounmap(chan->regs);
|
|
|
|
out_free_chan:
|
|
|
|
kfree(chan);
|
2010-01-06 06:34:03 -07:00
|
|
|
out_return:
|
2008-03-01 07:42:48 -07:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:05 -07:00
|
|
|
static void fsl_dma_chan_remove(struct fsldma_chan *chan)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:34:05 -07:00
|
|
|
irq_dispose_mapping(chan->irq);
|
|
|
|
list_del(&chan->common.device_node);
|
|
|
|
iounmap(chan->regs);
|
|
|
|
kfree(chan);
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2011-02-22 19:59:54 -07:00
|
|
|
static int __devinit fsldma_of_probe(struct platform_device *op)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2010-01-06 06:34:01 -07:00
|
|
|
struct fsldma_device *fdev;
|
2008-09-26 18:00:11 -06:00
|
|
|
struct device_node *child;
|
2010-01-06 06:34:03 -07:00
|
|
|
int err;
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:01 -07:00
|
|
|
fdev = kzalloc(sizeof(*fdev), GFP_KERNEL);
|
2008-03-01 07:42:48 -07:00
|
|
|
if (!fdev) {
|
2010-01-06 06:34:03 -07:00
|
|
|
dev_err(&op->dev, "No enough memory for 'priv'\n");
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto out_return;
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
2010-01-06 06:34:03 -07:00
|
|
|
|
|
|
|
fdev->dev = &op->dev;
|
2008-03-01 07:42:48 -07:00
|
|
|
INIT_LIST_HEAD(&fdev->common.channels);
|
|
|
|
|
2010-01-06 06:34:03 -07:00
|
|
|
/* ioremap the registers for use */
|
2010-04-13 17:12:29 -06:00
|
|
|
fdev->regs = of_iomap(op->dev.of_node, 0);
|
2010-01-06 06:34:03 -07:00
|
|
|
if (!fdev->regs) {
|
|
|
|
dev_err(&op->dev, "unable to ioremap registers\n");
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto out_free_fdev;
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:04 -07:00
|
|
|
/* map the channel IRQ if it exists, but don't hookup the handler yet */
|
2010-04-13 17:12:29 -06:00
|
|
|
fdev->irq = irq_of_parse_and_map(op->dev.of_node, 0);
|
2010-01-06 06:34:04 -07:00
|
|
|
|
2008-03-01 07:42:48 -07:00
|
|
|
dma_cap_set(DMA_MEMCPY, fdev->common.cap_mask);
|
|
|
|
dma_cap_set(DMA_INTERRUPT, fdev->common.cap_mask);
|
2010-09-30 05:46:45 -06:00
|
|
|
dma_cap_set(DMA_SG, fdev->common.cap_mask);
|
2009-09-08 18:53:04 -06:00
|
|
|
dma_cap_set(DMA_SLAVE, fdev->common.cap_mask);
|
2008-03-01 07:42:48 -07:00
|
|
|
fdev->common.device_alloc_chan_resources = fsl_dma_alloc_chan_resources;
|
|
|
|
fdev->common.device_free_chan_resources = fsl_dma_free_chan_resources;
|
2008-03-13 18:45:28 -06:00
|
|
|
fdev->common.device_prep_dma_interrupt = fsl_dma_prep_interrupt;
|
2008-03-01 07:42:48 -07:00
|
|
|
fdev->common.device_prep_dma_memcpy = fsl_dma_prep_memcpy;
|
2010-09-30 05:46:45 -06:00
|
|
|
fdev->common.device_prep_dma_sg = fsl_dma_prep_sg;
|
2010-03-26 17:50:49 -06:00
|
|
|
fdev->common.device_tx_status = fsl_tx_status;
|
2008-03-01 07:42:48 -07:00
|
|
|
fdev->common.device_issue_pending = fsl_dma_memcpy_issue_pending;
|
2009-09-08 18:53:04 -06:00
|
|
|
fdev->common.device_prep_slave_sg = fsl_dma_prep_slave_sg;
|
2010-03-26 17:44:01 -06:00
|
|
|
fdev->common.device_control = fsl_dma_device_control;
|
2010-01-06 06:34:03 -07:00
|
|
|
fdev->common.dev = &op->dev;
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-11-11 05:16:29 -07:00
|
|
|
dma_set_mask(&(op->dev), DMA_BIT_MASK(36));
|
|
|
|
|
2010-01-06 06:34:03 -07:00
|
|
|
dev_set_drvdata(&op->dev, fdev);
|
2008-09-26 18:00:11 -06:00
|
|
|
|
2010-01-06 06:34:03 -07:00
|
|
|
/*
|
|
|
|
* We cannot use of_platform_bus_probe() because there is no
|
|
|
|
* of_platform_bus_remove(). Instead, we manually instantiate every DMA
|
2008-09-26 18:00:11 -06:00
|
|
|
* channel object.
|
|
|
|
*/
|
2010-04-13 17:12:29 -06:00
|
|
|
for_each_child_of_node(op->dev.of_node, child) {
|
2010-01-06 06:34:03 -07:00
|
|
|
if (of_device_is_compatible(child, "fsl,eloplus-dma-channel")) {
|
2008-09-26 18:00:11 -06:00
|
|
|
fsl_dma_chan_probe(fdev, child,
|
|
|
|
FSL_DMA_IP_85XX | FSL_DMA_BIG_ENDIAN,
|
|
|
|
"fsl,eloplus-dma-channel");
|
2010-01-06 06:34:03 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (of_device_is_compatible(child, "fsl,elo-dma-channel")) {
|
2008-09-26 18:00:11 -06:00
|
|
|
fsl_dma_chan_probe(fdev, child,
|
|
|
|
FSL_DMA_IP_83XX | FSL_DMA_LITTLE_ENDIAN,
|
|
|
|
"fsl,elo-dma-channel");
|
2010-01-06 06:34:03 -07:00
|
|
|
}
|
2008-09-26 18:00:11 -06:00
|
|
|
}
|
2008-03-01 07:42:48 -07:00
|
|
|
|
2010-01-06 06:34:04 -07:00
|
|
|
/*
|
|
|
|
* Hookup the IRQ handler(s)
|
|
|
|
*
|
|
|
|
* If we have a per-controller interrupt, we prefer that to the
|
|
|
|
* per-channel interrupts to reduce the number of shared interrupt
|
|
|
|
* handlers on the same IRQ line
|
|
|
|
*/
|
|
|
|
err = fsldma_request_irqs(fdev);
|
|
|
|
if (err) {
|
|
|
|
dev_err(fdev->dev, "unable to request IRQs\n");
|
|
|
|
goto out_free_fdev;
|
|
|
|
}
|
|
|
|
|
2008-03-01 07:42:48 -07:00
|
|
|
dma_async_device_register(&fdev->common);
|
|
|
|
return 0;
|
|
|
|
|
2010-01-06 06:34:03 -07:00
|
|
|
out_free_fdev:
|
2010-01-06 06:34:04 -07:00
|
|
|
irq_dispose_mapping(fdev->irq);
|
2008-03-01 07:42:48 -07:00
|
|
|
kfree(fdev);
|
2010-01-06 06:34:03 -07:00
|
|
|
out_return:
|
2008-03-01 07:42:48 -07:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-08-06 09:25:50 -06:00
|
|
|
static int fsldma_of_remove(struct platform_device *op)
|
2008-09-26 18:00:11 -06:00
|
|
|
{
|
2010-01-06 06:34:01 -07:00
|
|
|
struct fsldma_device *fdev;
|
2008-09-26 18:00:11 -06:00
|
|
|
unsigned int i;
|
|
|
|
|
2010-01-06 06:34:03 -07:00
|
|
|
fdev = dev_get_drvdata(&op->dev);
|
2008-09-26 18:00:11 -06:00
|
|
|
dma_async_device_unregister(&fdev->common);
|
|
|
|
|
2010-01-06 06:34:04 -07:00
|
|
|
fsldma_free_irqs(fdev);
|
|
|
|
|
2010-01-06 06:34:03 -07:00
|
|
|
for (i = 0; i < FSL_DMA_MAX_CHANS_PER_DEVICE; i++) {
|
2008-09-26 18:00:11 -06:00
|
|
|
if (fdev->chan[i])
|
|
|
|
fsl_dma_chan_remove(fdev->chan[i]);
|
2010-01-06 06:34:03 -07:00
|
|
|
}
|
2008-09-26 18:00:11 -06:00
|
|
|
|
2010-01-06 06:34:03 -07:00
|
|
|
iounmap(fdev->regs);
|
|
|
|
dev_set_drvdata(&op->dev, NULL);
|
2008-09-26 18:00:11 -06:00
|
|
|
kfree(fdev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-02-02 23:41:06 -07:00
|
|
|
static const struct of_device_id fsldma_of_ids[] = {
|
2008-03-31 10:13:21 -06:00
|
|
|
{ .compatible = "fsl,eloplus-dma", },
|
|
|
|
{ .compatible = "fsl,elo-dma", },
|
2008-03-01 07:42:48 -07:00
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
2010-01-06 06:34:01 -07:00
|
|
|
static struct of_platform_driver fsldma_of_driver = {
|
2010-04-13 17:13:02 -06:00
|
|
|
.driver = {
|
|
|
|
.name = "fsl-elo-dma",
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.of_match_table = fsldma_of_ids,
|
|
|
|
},
|
|
|
|
.probe = fsldma_of_probe,
|
|
|
|
.remove = fsldma_of_remove,
|
2008-03-01 07:42:48 -07:00
|
|
|
};
|
|
|
|
|
2010-01-06 06:34:01 -07:00
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
/* Module Init / Exit */
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
static __init int fsldma_init(void)
|
2008-03-01 07:42:48 -07:00
|
|
|
{
|
2008-09-26 18:00:11 -06:00
|
|
|
pr_info("Freescale Elo / Elo Plus DMA driver\n");
|
2011-02-22 19:59:54 -07:00
|
|
|
return platform_driver_register(&fsldma_of_driver);
|
2008-09-26 18:00:11 -06:00
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:01 -07:00
|
|
|
static void __exit fsldma_exit(void)
|
2008-09-26 18:00:11 -06:00
|
|
|
{
|
2011-02-22 19:59:54 -07:00
|
|
|
platform_driver_unregister(&fsldma_of_driver);
|
2008-03-01 07:42:48 -07:00
|
|
|
}
|
|
|
|
|
2010-01-06 06:34:01 -07:00
|
|
|
subsys_initcall(fsldma_init);
|
|
|
|
module_exit(fsldma_exit);
|
2008-09-26 18:00:11 -06:00
|
|
|
|
|
|
|
MODULE_DESCRIPTION("Freescale Elo / Elo Plus DMA driver");
|
|
|
|
MODULE_LICENSE("GPL");
|