Re: Resend [PATCH] intel_mid: Add Mrst & Mfld DMA Drivers

From: Linus Walleij
Date: Wed Jul 28 2010 - 18:51:42 EST

2010/7/28 Dan Williams <dan.j.williams@xxxxxxxxx>:
> On Wed, Jul 21, 2010 at 12:58 AM, Vinod Koul <vinod.koul@xxxxxxxxx> wrote:
> [..]
>> +/**
>> + * intel_mid_dma_prep_memcpy - Prep memcpy txn
>> + * @chan: chan for DMA transfer
>> + * @dest: destn address
>> + * @src: src address
>> + * @len: DMA transfer len
>> + * @flags: DMA flags
>> + *
>> + * Perform a DMA memcpy. Note we support slave periphral DMA transfers only
>> + * The periphral txn details should be filled in slave structure properly
>> + * Returns the descriptor for this txn
>> + */
>> +static struct dma_async_tx_descriptor *intel_mid_dma_prep_memcpy(
>> +                       struct dma_chan *chan, dma_addr_t dest,
>> +                       dma_addr_t src, size_t len, unsigned long flags)
>
> The use of the prep_dma_memcpy routine instead of prep_slave_sg is a
> bit odd for device-to-memory dma because the dma_addr_t type only
> describes the bus address view of host memory from the device
> perspective.  Other slave dma devices are using a backdoor method
> (since a good abstraction does not exist) to associate a known channel
> to a known device and then specifying the host address and a direction
> via prep_slave_sg.

I see two distinct problems this is trying to solve:

1) No runtime channel control (patch pending!)

2) lacking in the DMA engine is actually a prep_slave_buffer() hook that
takes a buffer to/from a certain channel, this is often preferable to
sglists for simple DMA jobs. I mean a little something like this:

From: Linus Walleij <linus.walleij@xxxxxxxxxxxxxx>
Date: Thu, 29 Jul 2010 00:14:06 +0200
Subject: [PATCH] DMAENGINE: add a slave buffer prep call

This makes it possible for engines to implement slave transfers
to be done to/from a simple kmalloc():ed memory buffer and not
just from scatterlists.

Signed-off-by: Linus Walleij <linus.walleij@xxxxxxxxxxxxxx>
---
include/linux/dmaengine.h | 9 ++++++++-
1 files changed, 8 insertions(+), 1 deletions(-)

diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index 5204f01..3caff1c 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -350,7 +350,10 @@ struct dma_tx_state {
* @device_prep_dma_pq_val: prepares a pqzero_sum operation
* @device_prep_dma_memset: prepares a memset operation
* @device_prep_dma_interrupt: prepares an end of chain interrupt operation
- * @device_prep_slave_sg: prepares a slave dma operation
+ * @device_prep_slave_buffer: prepares a slave DMA operation to/from a
+ * buffer
+ * @device_prep_slave_sg: prepares a slave dma operation to/from a
+ * scatterlist
* @device_control: manipulate all pending operations on a channel, returns
* zero or error code
* @device_tx_status: poll for transaction completion, the optional
@@ -403,6 +406,10 @@ struct dma_device {
struct dma_async_tx_descriptor *(*device_prep_dma_interrupt)(
struct dma_chan *chan, unsigned long flags);

+ struct dma_async_tx_descriptor *(*device_prep_slave_buffer)(
+ struct dma_chan *chan, char *buffer,
+ enum dma_data_direction direction,
+ unsigned long flags);
struct dma_async_tx_descriptor *(*device_prep_slave_sg)(
struct dma_chan *chan, struct scatterlist *sgl,
unsigned int sg_len, enum dma_data_direction direction,
--
1.7.2


Evidently the above function should be be possible to implement across
all drivers, and checked for in dmaengine.c. But it is probably best to make
this optional and make the fact that most engines only support sglists
a bit explicit, so we wrap up the buffer support like this:


From: Linus Walleij <linus.walleij@xxxxxxxxxxxxxx>
Date: Thu, 29 Jul 2010 00:42:58 +0200
Subject: [PATCH] DMAENGINE: slave sglists and buffers

This renames the DMA engine capability DMA_SLAVE to
DMA_SLAVE_SGLIST with the semantics that the current implementations
assume DMA_SLAVE means the slave supports only scatterlists for
inbound/outbound transfers. This completes the previous patch
by adding as specific single-buffer DMA capability to the API
and renaming all the old users as described.

Signed-off-by: Linus Walleij <linus.walleij@xxxxxxxxxxxxxx>
---
arch/arm/mach-at91/at91sam9g45_devices.c | 2 +-
drivers/dma/at_hdmac.c | 8 ++++----
drivers/dma/coh901318.c | 2 +-
drivers/dma/dmaengine.c | 9 ++++++---
drivers/dma/dw_dmac.c | 2 +-
drivers/dma/fsldma.c | 11 ++++++-----
drivers/dma/ipu/ipu_idmac.c | 4 ++--
drivers/dma/pl330.c | 2 +-
drivers/dma/shdma.c | 4 ++--
drivers/dma/ste_dma40.c | 9 +++++----
drivers/dma/timb_dma.c | 2 +-
drivers/dma/txx9dmac.c | 5 +++--
drivers/media/video/mx3_camera.c | 2 +-
drivers/mmc/host/atmel-mci.c | 2 +-
drivers/mmc/host/tmio_mmc.c | 2 +-
drivers/serial/sh-sci.c | 2 +-
drivers/video/mx3fb.c | 2 +-
include/linux/dmaengine.h | 5 +++--
sound/atmel/abdac.c | 2 +-
sound/atmel/ac97c.c | 4 ++--
sound/soc/sh/siu_pcm.c | 2 +-
sound/soc/txx9/txx9aclc.c | 2 +-
22 files changed, 46 insertions(+), 39 deletions(-)

diff --git a/arch/arm/mach-at91/at91sam9g45_devices.c
b/arch/arm/mach-at91/at91sam9g45_devices.c
index 809114d..a005bc9 100644
--- a/arch/arm/mach-at91/at91sam9g45_devices.c
+++ b/arch/arm/mach-at91/at91sam9g45_devices.c
@@ -68,7 +68,7 @@ static struct platform_device at_hdmac_device = {
void __init at91_add_device_hdmac(void)
{
dma_cap_set(DMA_MEMCPY, atdma_pdata.cap_mask);
- dma_cap_set(DMA_SLAVE, atdma_pdata.cap_mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, atdma_pdata.cap_mask);
platform_device_register(&at_hdmac_device);
}
#else
diff --git a/drivers/dma/at_hdmac.c b/drivers/dma/at_hdmac.c
index e880760..f94b9d1 100644
--- a/drivers/dma/at_hdmac.c
+++ b/drivers/dma/at_hdmac.c
@@ -615,7 +615,7 @@ err_desc_get:


/**
- * atc_prep_slave_sg - prepare descriptors for a DMA_SLAVE transaction
+ * atc_prep_slave_sg - prepare descriptors for a DMA_SLAVE_SGLIST transaction
* @chan: DMA channel
* @sgl: scatterlist to transfer to/from
* @sg_len: number of entries in @scatterlist
@@ -1093,7 +1093,7 @@ static int __init at_dma_probe(struct
platform_device *pdev)
if (dma_has_cap(DMA_MEMCPY, atdma->dma_common.cap_mask))
atdma->dma_common.device_prep_dma_memcpy = atc_prep_dma_memcpy;

- if (dma_has_cap(DMA_SLAVE, atdma->dma_common.cap_mask)) {
+ if (dma_has_cap(DMA_SLAVE_SGLIST, atdma->dma_common.cap_mask)) {
atdma->dma_common.device_prep_slave_sg = atc_prep_slave_sg;
atdma->dma_common.device_control = atc_control;
}
@@ -1102,8 +1102,8 @@ static int __init at_dma_probe(struct
platform_device *pdev)

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 " : "",
- atdma->dma_common.chancnt);
+ dma_has_cap(DMA_SLAVE_SGLIST, atdma->dma_common.cap_mask) ?
+ "slave " : "", atdma->dma_common.chancnt);

dma_async_device_register(&atdma->dma_common);

diff --git a/drivers/dma/coh901318.c b/drivers/dma/coh901318.c
index a724e6b..d744493 100644
--- a/drivers/dma/coh901318.c
+++ b/drivers/dma/coh901318.c
@@ -1349,7 +1349,7 @@ static int __init coh901318_probe(struct
platform_device *pdev)
base);

dma_cap_zero(base->dma_slave.cap_mask);
- dma_cap_set(DMA_SLAVE, base->dma_slave.cap_mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, base->dma_slave.cap_mask);

base->dma_slave.device_alloc_chan_resources = coh901318_alloc_chan_resources;
base->dma_slave.device_free_chan_resources = coh901318_free_chan_resources;
diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c
index 9d31d5e..0d37c76 100644
--- a/drivers/dma/dmaengine.c
+++ b/drivers/dma/dmaengine.c
@@ -300,7 +300,6 @@ static int __init dma_channel_table_init(void)
*/
clear_bit(DMA_INTERRUPT, dma_cap_mask_all.bits);
clear_bit(DMA_PRIVATE, dma_cap_mask_all.bits);
- clear_bit(DMA_SLAVE, dma_cap_mask_all.bits);

for_each_dma_cap_mask(cap, dma_cap_mask_all) {
channel_table[cap] = alloc_percpu(struct dma_chan_tbl_ent);
@@ -690,9 +689,13 @@ int dma_async_device_register(struct dma_device *device)
!device->device_prep_dma_memset);
BUG_ON(dma_has_cap(DMA_INTERRUPT, device->cap_mask) &&
!device->device_prep_dma_interrupt);
- BUG_ON(dma_has_cap(DMA_SLAVE, device->cap_mask) &&
+ BUG_ON(dma_has_cap(DMA_SLAVE_SGLIST, device->cap_mask) &&
!device->device_prep_slave_sg);
- BUG_ON(dma_has_cap(DMA_SLAVE, device->cap_mask) &&
+ BUG_ON(dma_has_cap(DMA_SLAVE_SGLIST, device->cap_mask) &&
+ !device->device_control);
+ BUG_ON(dma_has_cap(DMA_SLAVE_BUFFER, device->cap_mask) &&
+ !device->device_prep_slave_buffer);
+ BUG_ON(dma_has_cap(DMA_SLAVE_BUFFER, device->cap_mask) &&
!device->device_control);

BUG_ON(!device->device_alloc_chan_resources);
diff --git a/drivers/dma/dw_dmac.c b/drivers/dma/dw_dmac.c
index a3991ab..e38ea35 100644
--- a/drivers/dma/dw_dmac.c
+++ b/drivers/dma/dw_dmac.c
@@ -1334,7 +1334,7 @@ static int __init dw_probe(struct platform_device *pdev)
channel_clear_bit(dw, MASK.ERROR, dw->all_chan_mask);

dma_cap_set(DMA_MEMCPY, dw->dma.cap_mask);
- dma_cap_set(DMA_SLAVE, dw->dma.cap_mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, dw->dma.cap_mask);
dw->dma.dev = &pdev->dev;
dw->dma.device_alloc_chan_resources = dwc_alloc_chan_resources;
dw->dma.device_free_chan_resources = dwc_free_chan_resources;
diff --git a/drivers/dma/fsldma.c b/drivers/dma/fsldma.c
index 8088b14..1b9760a 100644
--- a/drivers/dma/fsldma.c
+++ b/drivers/dma/fsldma.c
@@ -584,16 +584,17 @@ fail:
}

/**
- * fsl_dma_prep_slave_sg - prepare descriptors for a DMA_SLAVE transaction
+ * fsl_dma_prep_slave_sg - prepare descriptors for a DMA_SLAVE_SGLIST
+ * 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.
+ * Prepare a set of descriptors for a DMA_SLAVE_SGLIST 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(
struct dma_chan *dchan, struct scatterlist *sgl, unsigned int sg_len,
@@ -1327,7 +1328,7 @@ static int __devinit fsldma_of_probe(struct of_device *op,

dma_cap_set(DMA_MEMCPY, fdev->common.cap_mask);
dma_cap_set(DMA_INTERRUPT, fdev->common.cap_mask);
- dma_cap_set(DMA_SLAVE, fdev->common.cap_mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, fdev->common.cap_mask);
fdev->common.device_alloc_chan_resources = fsl_dma_alloc_chan_resources;
fdev->common.device_free_chan_resources = fsl_dma_free_chan_resources;
fdev->common.device_prep_dma_interrupt = fsl_dma_prep_interrupt;
diff --git a/drivers/dma/ipu/ipu_idmac.c b/drivers/dma/ipu/ipu_idmac.c
index cb26ee9..27d8226 100644
--- a/drivers/dma/ipu/ipu_idmac.c
+++ b/drivers/dma/ipu/ipu_idmac.c
@@ -1665,7 +1665,7 @@ static int __init ipu_idmac_init(struct ipu *ipu)
struct dma_device *dma = &idmac->dma;
int i;

- dma_cap_set(DMA_SLAVE, dma->cap_mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, dma->cap_mask);
dma_cap_set(DMA_PRIVATE, dma->cap_mask);

/* Compulsory common fields */
@@ -1675,7 +1675,7 @@ static int __init ipu_idmac_init(struct ipu *ipu)
dma->device_tx_status = idmac_tx_status;
dma->device_issue_pending = idmac_issue_pending;

- /* Compulsory for DMA_SLAVE fields */
+ /* Compulsory for DMA_SLAVE_SGLIST fields */
dma->device_prep_slave_sg = idmac_prep_slave_sg;
dma->device_control = idmac_control;

diff --git a/drivers/dma/pl330.c b/drivers/dma/pl330.c
index 7c50f6d..3974357 100644
--- a/drivers/dma/pl330.c
+++ b/drivers/dma/pl330.c
@@ -727,7 +727,7 @@ pl330_probe(struct amba_device *adev, struct amba_id *id)
break;
case MEMTODEV:
case DEVTOMEM:
- dma_cap_set(DMA_SLAVE, pd->cap_mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, pd->cap_mask);
break;
default:
dev_err(&adev->dev, "DEVTODEV Not Supported\n");
diff --git a/drivers/dma/shdma.c b/drivers/dma/shdma.c
index fb64cf3..5b09f81 100644
--- a/drivers/dma/shdma.c
+++ b/drivers/dma/shdma.c
@@ -1040,7 +1040,7 @@ static int __init sh_dmae_probe(struct
platform_device *pdev)

dma_cap_set(DMA_MEMCPY, shdev->common.cap_mask);
if (dmars)
- dma_cap_set(DMA_SLAVE, shdev->common.cap_mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, shdev->common.cap_mask);

shdev->common.device_alloc_chan_resources
= sh_dmae_alloc_chan_resources;
@@ -1049,7 +1049,7 @@ static int __init sh_dmae_probe(struct
platform_device *pdev)
shdev->common.device_tx_status = sh_dmae_tx_status;
shdev->common.device_issue_pending = sh_dmae_memcpy_issue_pending;

- /* Compulsory for DMA_SLAVE fields */
+ /* Compulsory for DMA_SLAVE_SGLIST fields */
shdev->common.device_prep_slave_sg = sh_dmae_prep_slave_sg;
shdev->common.device_control = sh_dmae_control;

diff --git a/drivers/dma/ste_dma40.c b/drivers/dma/ste_dma40.c
index 21a7597..f153800 100644
--- a/drivers/dma/ste_dma40.c
+++ b/drivers/dma/ste_dma40.c
@@ -1210,14 +1210,15 @@ static int d40_config_memcpy(struct d40_chan *d40c)
{
dma_cap_mask_t cap = d40c->chan.device->cap_mask;

- if (dma_has_cap(DMA_MEMCPY, cap) && !dma_has_cap(DMA_SLAVE, cap)) {
+ if (dma_has_cap(DMA_MEMCPY, cap) &&
+ !dma_has_cap(DMA_SLAVE_SGLIST, cap)) {
d40c->dma_cfg = *d40c->base->plat_data->memcpy_conf_log;
d40c->dma_cfg.src_dev_type = STEDMA40_DEV_SRC_MEMORY;
d40c->dma_cfg.dst_dev_type = d40c->base->plat_data->
memcpy[d40c->chan.chan_id];

} else if (dma_has_cap(DMA_MEMCPY, cap) &&
- dma_has_cap(DMA_SLAVE, cap)) {
+ dma_has_cap(DMA_SLAVE_SGLIST, cap)) {
d40c->dma_cfg = *d40c->base->plat_data->memcpy_conf_phy;
} else {
dev_err(&d40c->chan.dev->device, "[%s] No memcpy\n",
@@ -2143,7 +2144,7 @@ static int __init d40_dmaengine_init(struct
d40_base *base,
0, base->num_log_chans);

dma_cap_zero(base->dma_slave.cap_mask);
- dma_cap_set(DMA_SLAVE, base->dma_slave.cap_mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, base->dma_slave.cap_mask);

base->dma_slave.device_alloc_chan_resources = d40_alloc_chan_resources;
base->dma_slave.device_free_chan_resources = d40_free_chan_resources;
@@ -2196,7 +2197,7 @@ static int __init d40_dmaengine_init(struct
d40_base *base,
0, num_reserved_chans);

dma_cap_zero(base->dma_both.cap_mask);
- dma_cap_set(DMA_SLAVE, base->dma_both.cap_mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, base->dma_both.cap_mask);
dma_cap_set(DMA_MEMCPY, base->dma_both.cap_mask);

base->dma_both.device_alloc_chan_resources = d40_alloc_chan_resources;
diff --git a/drivers/dma/timb_dma.c b/drivers/dma/timb_dma.c
index 2ec1ed5..75149883 100644
--- a/drivers/dma/timb_dma.c
+++ b/drivers/dma/timb_dma.c
@@ -744,7 +744,7 @@ static int __devinit td_probe(struct platform_device *pdev)
td->dma.device_tx_status = td_tx_status;
td->dma.device_issue_pending = td_issue_pending;

- dma_cap_set(DMA_SLAVE, td->dma.cap_mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, td->dma.cap_mask);
dma_cap_set(DMA_PRIVATE, td->dma.cap_mask);
td->dma.device_prep_slave_sg = td_prep_slave_sg;
td->dma.device_control = td_control;
diff --git a/drivers/dma/txx9dmac.c b/drivers/dma/txx9dmac.c
index cbd83e36..c2d1343 100644
--- a/drivers/dma/txx9dmac.c
+++ b/drivers/dma/txx9dmac.c
@@ -1164,7 +1164,7 @@ static int __init txx9dmac_chan_probe(struct
platform_device *pdev)
dma_cap_set(DMA_MEMCPY, dc->dma.cap_mask);
} else {
dc->dma.device_prep_slave_sg = txx9dmac_prep_slave_sg;
- dma_cap_set(DMA_SLAVE, dc->dma.cap_mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, dc->dma.cap_mask);
dma_cap_set(DMA_PRIVATE, dc->dma.cap_mask);
}

@@ -1208,7 +1208,8 @@ static int __init txx9dmac_chan_probe(struct
platform_device *pdev)
dev_dbg(&pdev->dev, "TXx9 DMA Channel (dma%d%s%s)\n",
dc->dma.dev_id,
dma_has_cap(DMA_MEMCPY, dc->dma.cap_mask) ? " memcpy" : "",
- dma_has_cap(DMA_SLAVE, dc->dma.cap_mask) ? " slave" : "");
+ dma_has_cap(DMA_SLAVE_SGLIST, dc->dma.cap_mask) ?
+ " slave" : "");

return 0;
}
diff --git a/drivers/media/video/mx3_camera.c b/drivers/media/video/mx3_camera.c
index a9be14c..fd6f735 100644
--- a/drivers/media/video/mx3_camera.c
+++ b/drivers/media/video/mx3_camera.c
@@ -780,7 +780,7 @@ static int acquire_dma_channel(struct
mx3_camera_dev *mx3_cam)
}

dma_cap_zero(mask);
- dma_cap_set(DMA_SLAVE, mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, mask);
dma_cap_set(DMA_PRIVATE, mask);
chan = dma_request_channel(mask, chan_filter, &rq);
if (!chan)
diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c
index 95ef864..fae4b39 100644
--- a/drivers/mmc/host/atmel-mci.c
+++ b/drivers/mmc/host/atmel-mci.c
@@ -1728,7 +1728,7 @@ static void atmci_configure_dma(struct atmel_mci *host)

/* Try to grab a DMA channel */
dma_cap_zero(mask);
- dma_cap_set(DMA_SLAVE, mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, mask);
host->dma.chan =
dma_request_channel(mask, filter, pdata->dma_slave);
}
diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index ee7d0a5..905ffb2 100644
--- a/drivers/mmc/host/tmio_mmc.c
+++ b/drivers/mmc/host/tmio_mmc.c
@@ -591,7 +591,7 @@ static void tmio_mmc_request_dma(struct tmio_mmc_host *host,
dma_cap_mask_t mask;

dma_cap_zero(mask);
- dma_cap_set(DMA_SLAVE, mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, mask);

host->chan_tx = dma_request_channel(mask, tmio_mmc_filter,
pdata->dma->chan_priv_tx);
diff --git a/drivers/serial/sh-sci.c b/drivers/serial/sh-sci.c
index c291b3a..0efab71 100644
--- a/drivers/serial/sh-sci.c
+++ b/drivers/serial/sh-sci.c
@@ -1316,7 +1316,7 @@ static void sci_request_dma(struct uart_port *port)
return;

dma_cap_zero(mask);
- dma_cap_set(DMA_SLAVE, mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, mask);

param = &s->param_tx;

diff --git a/drivers/video/mx3fb.c b/drivers/video/mx3fb.c
index 7cfc170..ced7d86 100644
--- a/drivers/video/mx3fb.c
+++ b/drivers/video/mx3fb.c
@@ -1482,7 +1482,7 @@ static int mx3fb_probe(struct platform_device *pdev)
rq.mx3fb = mx3fb;

dma_cap_zero(mask);
- dma_cap_set(DMA_SLAVE, mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, mask);
dma_cap_set(DMA_PRIVATE, mask);
rq.id = IDMAC_SDC_0;
chan = dma_request_channel(mask, chan_filter, &rq);
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index 3caff1c..b23be6e 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -66,11 +66,12 @@ enum dma_transaction_type {
DMA_INTERRUPT,
DMA_PRIVATE,
DMA_ASYNC_TX,
- DMA_SLAVE,
+ DMA_SLAVE_SGLIST,
+ DMA_SLAVE_BUFFER,
};

/* last transaction type for creation of the capabilities mask */
-#define DMA_TX_TYPE_END (DMA_SLAVE + 1)
+#define DMA_TX_TYPE_END (DMA_SLAVE_BUFFER + 1)


/**
diff --git a/sound/atmel/abdac.c b/sound/atmel/abdac.c
index f2f41c8..642bdea 100644
--- a/sound/atmel/abdac.c
+++ b/sound/atmel/abdac.c
@@ -473,7 +473,7 @@ static int __devinit atmel_abdac_probe(struct
platform_device *pdev)
dws->tx_reg = regs->start + DAC_DATA;

dma_cap_zero(mask);
- dma_cap_set(DMA_SLAVE, mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, mask);

dac->dma.chan = dma_request_channel(mask, filter, dws);
}
diff --git a/sound/atmel/ac97c.c b/sound/atmel/ac97c.c
index 10c3a87..1f0d328 100644
--- a/sound/atmel/ac97c.c
+++ b/sound/atmel/ac97c.c
@@ -1013,7 +1013,7 @@ static int __devinit atmel_ac97c_probe(struct
platform_device *pdev)
dws->rx_reg = regs->start + AC97C_CARHR + 2;

dma_cap_zero(mask);
- dma_cap_set(DMA_SLAVE, mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, mask);

chip->dma.rx_chan = dma_request_channel(mask, filter,
dws);
@@ -1030,7 +1030,7 @@ static int __devinit atmel_ac97c_probe(struct
platform_device *pdev)
dws->tx_reg = regs->start + AC97C_CATHR + 2;

dma_cap_zero(mask);
- dma_cap_set(DMA_SLAVE, mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, mask);

chip->dma.tx_chan = dma_request_channel(mask, filter,
dws);
diff --git a/sound/soc/sh/siu_pcm.c b/sound/soc/sh/siu_pcm.c
index 36170be..a8a8738 100644
--- a/sound/soc/sh/siu_pcm.c
+++ b/sound/soc/sh/siu_pcm.c
@@ -350,7 +350,7 @@ static int siu_pcm_open(struct snd_pcm_substream *ss)
struct sh_dmae_slave *param;

dma_cap_zero(mask);
- dma_cap_set(DMA_SLAVE, mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, mask);

dev_dbg(dev, "%s, port=%d@%p\n", __func__, port, port_info);

diff --git a/sound/soc/txx9/txx9aclc.c b/sound/soc/txx9/txx9aclc.c
index 0e345230..11c9525 100644
--- a/sound/soc/txx9/txx9aclc.c
+++ b/sound/soc/txx9/txx9aclc.c
@@ -331,7 +331,7 @@ static int txx9aclc_dma_init(struct
txx9aclc_soc_device *dev,

/* Try to grab a DMA channel */
dma_cap_zero(mask);
- dma_cap_set(DMA_SLAVE, mask);
+ dma_cap_set(DMA_SLAVE_SGLIST, mask);
dmadata->dma_chan = dma_request_channel(mask, filter, dmadata);
if (!dmadata->dma_chan) {
dev_err(dev->soc_dev.dev,
--
1.7.2


Both patches are also conveniently attached.


Yours,
Linus Walleij

Attachment: 0001-DMAENGINE-add-a-slave-buffer-prep-call.patch
Description: Binary data

Attachment: 0002-DMAENGINE-slave-sglists-and-buffers.patch
Description: Binary data