Hi,
This patch set adds a device node validation in DMA engine core, that will
help some drivers to remove the duplicate device node validation in each
driver.
Any comments are welcome. Thanks.
Baolin Wang (8):
dmaengine: Add matching device node validation in
__dma_request_channel()
soc: tegra: fuse: Change to the correct __dma_request_channel()
prototype
dmaengine: imx-sdma: Let the core do the device node validation
dmaengine: dma-jz4780: Let the core do the device node validation
dmaengine: mmp_tdma: Let the core do the device node validation
dmaengine: mxs-dma: Let the core do the device node validation
dmaengine: sh: rcar-dmac: Let the core do the device node validation
dmaengine: sh: usb-dmac: Let the core do the device node validation
drivers/dma/dma-jz4780.c | 7 ++-----
drivers/dma/dmaengine.c | 10 ++++++++--
drivers/dma/imx-sdma.c | 9 ++-------
drivers/dma/mmp_tdma.c | 10 ++--------
drivers/dma/mxs-dma.c | 8 ++------
drivers/dma/of-dma.c | 4 ++--
drivers/dma/sh/rcar-dmac.c | 6 +++---
drivers/dma/sh/usb-dmac.c | 6 ++----
drivers/soc/tegra/fuse/fuse-tegra20.c | 2 +-
include/linux/dmaengine.h | 12 ++++++++----
include/linux/platform_data/dma-imx.h | 1 -
11 files changed, 32 insertions(+), 43 deletions(-)
--
1.7.9.5
When user try to request one DMA channel by __dma_request_channel(), it won't
validate if it is the correct DMA device to request, that will lead each DMA
engine driver to validate the correct device node in their filter function
if it is necessary.
Thus we can add the matching device node validation in the DMA engine core,
to remove all of device node validation in the drivers.
Signed-off-by: Baolin Wang <[email protected]>
---
drivers/dma/dmaengine.c | 10 ++++++++--
drivers/dma/of-dma.c | 4 ++--
include/linux/dmaengine.h | 12 ++++++++----
3 files changed, 18 insertions(+), 8 deletions(-)
diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c
index 3a11b10..610080c 100644
--- a/drivers/dma/dmaengine.c
+++ b/drivers/dma/dmaengine.c
@@ -641,11 +641,13 @@ struct dma_chan *dma_get_any_slave_channel(struct dma_device *device)
* @mask: capabilities that the channel must satisfy
* @fn: optional callback to disposition available channels
* @fn_param: opaque parameter to pass to dma_filter_fn
+ * @np: device node to look for DMA channels
*
* Returns pointer to appropriate DMA channel on success or NULL.
*/
struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
- dma_filter_fn fn, void *fn_param)
+ dma_filter_fn fn, void *fn_param,
+ struct device_node *np)
{
struct dma_device *device, *_d;
struct dma_chan *chan = NULL;
@@ -653,6 +655,10 @@ struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
/* Find a channel */
mutex_lock(&dma_list_mutex);
list_for_each_entry_safe(device, _d, &dma_device_list, global_node) {
+ /* Finds a DMA controller with matching device node */
+ if (np && device->dev->of_node && np != device->dev->of_node)
+ continue;
+
chan = find_candidate(device, mask, fn, fn_param);
if (!IS_ERR(chan))
break;
@@ -769,7 +775,7 @@ struct dma_chan *dma_request_chan_by_mask(const dma_cap_mask_t *mask)
if (!mask)
return ERR_PTR(-ENODEV);
- chan = __dma_request_channel(mask, NULL, NULL);
+ chan = __dma_request_channel(mask, NULL, NULL, NULL);
if (!chan) {
mutex_lock(&dma_list_mutex);
if (list_empty(&dma_device_list))
diff --git a/drivers/dma/of-dma.c b/drivers/dma/of-dma.c
index 91fd395..6b43d04 100644
--- a/drivers/dma/of-dma.c
+++ b/drivers/dma/of-dma.c
@@ -316,8 +316,8 @@ struct dma_chan *of_dma_simple_xlate(struct of_phandle_args *dma_spec,
if (count != 1)
return NULL;
- return dma_request_channel(info->dma_cap, info->filter_fn,
- &dma_spec->args[0]);
+ return __dma_request_channel(&info->dma_cap, info->filter_fn,
+ &dma_spec->args[0], dma_spec->np);
}
EXPORT_SYMBOL_GPL(of_dma_simple_xlate);
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index d49ec5c..504085b 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -1314,7 +1314,8 @@ static inline enum dma_status dma_async_is_complete(dma_cookie_t cookie,
enum dma_status dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx);
void dma_issue_pending_all(void);
struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
- dma_filter_fn fn, void *fn_param);
+ dma_filter_fn fn, void *fn_param,
+ struct device_node *np);
struct dma_chan *dma_request_slave_channel(struct device *dev, const char *name);
struct dma_chan *dma_request_chan(struct device *dev, const char *name);
@@ -1339,7 +1340,9 @@ static inline void dma_issue_pending_all(void)
{
}
static inline struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
- dma_filter_fn fn, void *fn_param)
+ dma_filter_fn fn,
+ void *fn_param,
+ struct device_node *np)
{
return NULL;
}
@@ -1411,7 +1414,8 @@ static inline int dmaengine_desc_free(struct dma_async_tx_descriptor *desc)
void dma_run_dependencies(struct dma_async_tx_descriptor *tx);
struct dma_chan *dma_get_slave_channel(struct dma_chan *chan);
struct dma_chan *dma_get_any_slave_channel(struct dma_device *device);
-#define dma_request_channel(mask, x, y) __dma_request_channel(&(mask), x, y)
+#define dma_request_channel(mask, x, y) \
+ __dma_request_channel(&(mask), x, y, NULL)
#define dma_request_slave_channel_compat(mask, x, y, dev, name) \
__dma_request_slave_channel_compat(&(mask), x, y, dev, name)
@@ -1429,6 +1433,6 @@ static inline int dmaengine_desc_free(struct dma_async_tx_descriptor *desc)
if (!fn || !fn_param)
return NULL;
- return __dma_request_channel(mask, fn, fn_param);
+ return __dma_request_channel(mask, fn, fn_param, NULL);
}
#endif /* DMAENGINE_H */
--
1.7.9.5
Let the DMA engine core do the device node validation instead of drivers.
Signed-off-by: Baolin Wang <[email protected]>
---
drivers/dma/dma-jz4780.c | 7 ++-----
1 file changed, 2 insertions(+), 5 deletions(-)
diff --git a/drivers/dma/dma-jz4780.c b/drivers/dma/dma-jz4780.c
index 9ce0a38..7e1d381 100644
--- a/drivers/dma/dma-jz4780.c
+++ b/drivers/dma/dma-jz4780.c
@@ -160,7 +160,6 @@ struct jz4780_dma_dev {
};
struct jz4780_dma_filter_data {
- struct device_node *of_node;
uint32_t transfer_type;
int channel;
};
@@ -765,8 +764,6 @@ static bool jz4780_dma_filter_fn(struct dma_chan *chan, void *param)
struct jz4780_dma_dev *jzdma = jz4780_dma_chan_parent(jzchan);
struct jz4780_dma_filter_data *data = param;
- if (jzdma->dma_device.dev->of_node != data->of_node)
- return false;
if (data->channel > -1) {
if (data->channel != jzchan->id)
@@ -790,7 +787,6 @@ static struct dma_chan *jz4780_of_dma_xlate(struct of_phandle_args *dma_spec,
if (dma_spec->args_count != 2)
return NULL;
- data.of_node = ofdma->of_node;
data.transfer_type = dma_spec->args[0];
data.channel = dma_spec->args[1];
@@ -815,7 +811,8 @@ static struct dma_chan *jz4780_of_dma_xlate(struct of_phandle_args *dma_spec,
return dma_get_slave_channel(
&jzdma->chan[data.channel].vchan.chan);
} else {
- return dma_request_channel(mask, jz4780_dma_filter_fn, &data);
+ return __dma_request_channel(&mask, jz4780_dma_filter_fn, &data,
+ ofdma->of_node);
}
}
--
1.7.9.5
Let the DMA engine core do the device node validation instead of drivers.
Signed-off-by: Baolin Wang <[email protected]>
---
drivers/dma/mmp_tdma.c | 10 ++--------
1 file changed, 2 insertions(+), 8 deletions(-)
diff --git a/drivers/dma/mmp_tdma.c b/drivers/dma/mmp_tdma.c
index 0c56faa0..e76858b 100644
--- a/drivers/dma/mmp_tdma.c
+++ b/drivers/dma/mmp_tdma.c
@@ -586,18 +586,12 @@ static int mmp_tdma_chan_init(struct mmp_tdma_device *tdev,
}
struct mmp_tdma_filter_param {
- struct device_node *of_node;
unsigned int chan_id;
};
static bool mmp_tdma_filter_fn(struct dma_chan *chan, void *fn_param)
{
struct mmp_tdma_filter_param *param = fn_param;
- struct mmp_tdma_chan *tdmac = to_mmp_tdma_chan(chan);
- struct dma_device *pdma_device = tdmac->chan.device;
-
- if (pdma_device->dev->of_node != param->of_node)
- return false;
if (chan->chan_id != param->chan_id)
return false;
@@ -615,13 +609,13 @@ static struct dma_chan *mmp_tdma_xlate(struct of_phandle_args *dma_spec,
if (dma_spec->args_count != 1)
return NULL;
- param.of_node = ofdma->of_node;
param.chan_id = dma_spec->args[0];
if (param.chan_id >= TDMA_CHANNEL_NUM)
return NULL;
- return dma_request_channel(mask, mmp_tdma_filter_fn, ¶m);
+ return __dma_request_channel(&mask, mmp_tdma_filter_fn, ¶m,
+ ofdma->of_node);
}
static const struct of_device_id mmp_tdma_dt_ids[] = {
--
1.7.9.5
Let the DMA engine core do the device node validation instead of drivers.
Signed-off-by: Baolin Wang <[email protected]>
---
drivers/dma/sh/rcar-dmac.c | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/drivers/dma/sh/rcar-dmac.c b/drivers/dma/sh/rcar-dmac.c
index 2b4f256..9474d5b 100644
--- a/drivers/dma/sh/rcar-dmac.c
+++ b/drivers/dma/sh/rcar-dmac.c
@@ -1632,8 +1632,7 @@ static bool rcar_dmac_chan_filter(struct dma_chan *chan, void *arg)
* Forcing it to call dma_request_channel() and iterate through all
* channels from all controllers is just pointless.
*/
- if (chan->device->device_config != rcar_dmac_device_config ||
- dma_spec->np != chan->device->dev->of_node)
+ if (chan->device->device_config != rcar_dmac_device_config)
return false;
return !test_and_set_bit(dma_spec->args[0], dmac->modules);
@@ -1653,7 +1652,8 @@ static struct dma_chan *rcar_dmac_of_xlate(struct of_phandle_args *dma_spec,
dma_cap_zero(mask);
dma_cap_set(DMA_SLAVE, mask);
- chan = dma_request_channel(mask, rcar_dmac_chan_filter, dma_spec);
+ chan = __dma_request_channel(&mask, rcar_dmac_chan_filter, dma_spec,
+ ofdma->of_node);
if (!chan)
return NULL;
--
1.7.9.5
Let the DMA engine core do the device node validation instead of drivers.
Signed-off-by: Baolin Wang <[email protected]>
---
drivers/dma/sh/usb-dmac.c | 6 ++----
1 file changed, 2 insertions(+), 4 deletions(-)
diff --git a/drivers/dma/sh/usb-dmac.c b/drivers/dma/sh/usb-dmac.c
index 59403f6..0afabf3 100644
--- a/drivers/dma/sh/usb-dmac.c
+++ b/drivers/dma/sh/usb-dmac.c
@@ -636,9 +636,6 @@ static bool usb_dmac_chan_filter(struct dma_chan *chan, void *arg)
struct usb_dmac_chan *uchan = to_usb_dmac_chan(chan);
struct of_phandle_args *dma_spec = arg;
- if (dma_spec->np != chan->device->dev->of_node)
- return false;
-
/* USB-DMAC should be used with fixed usb controller's FIFO */
if (uchan->index != dma_spec->args[0])
return false;
@@ -659,7 +656,8 @@ static struct dma_chan *usb_dmac_of_xlate(struct of_phandle_args *dma_spec,
dma_cap_zero(mask);
dma_cap_set(DMA_SLAVE, mask);
- chan = dma_request_channel(mask, usb_dmac_chan_filter, dma_spec);
+ chan = __dma_request_channel(&mask, usb_dmac_chan_filter, dma_spec,
+ ofdma->of_node);
if (!chan)
return NULL;
--
1.7.9.5
Hi,
On 07/05/2019 9.09, Baolin Wang wrote:
> When user try to request one DMA channel by __dma_request_channel(), it won't
> validate if it is the correct DMA device to request, that will lead each DMA
> engine driver to validate the correct device node in their filter function
> if it is necessary.
>
> Thus we can add the matching device node validation in the DMA engine core,
> to remove all of device node validation in the drivers.
I have picked this patch to my TI UDMA series and with
__dma_request_channel() it works as expected - picking the channel from
the correct DMA device.
Tested-by: Peter Ujfalusi <[email protected]>
>
> Signed-off-by: Baolin Wang <[email protected]>
> ---
> drivers/dma/dmaengine.c | 10 ++++++++--
> drivers/dma/of-dma.c | 4 ++--
> include/linux/dmaengine.h | 12 ++++++++----
> 3 files changed, 18 insertions(+), 8 deletions(-)
>
> diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c
> index 3a11b10..610080c 100644
> --- a/drivers/dma/dmaengine.c
> +++ b/drivers/dma/dmaengine.c
> @@ -641,11 +641,13 @@ struct dma_chan *dma_get_any_slave_channel(struct dma_device *device)
> * @mask: capabilities that the channel must satisfy
> * @fn: optional callback to disposition available channels
> * @fn_param: opaque parameter to pass to dma_filter_fn
> + * @np: device node to look for DMA channels
> *
> * Returns pointer to appropriate DMA channel on success or NULL.
> */
> struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
> - dma_filter_fn fn, void *fn_param)
> + dma_filter_fn fn, void *fn_param,
> + struct device_node *np)
> {
> struct dma_device *device, *_d;
> struct dma_chan *chan = NULL;
> @@ -653,6 +655,10 @@ struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
> /* Find a channel */
> mutex_lock(&dma_list_mutex);
> list_for_each_entry_safe(device, _d, &dma_device_list, global_node) {
> + /* Finds a DMA controller with matching device node */
> + if (np && device->dev->of_node && np != device->dev->of_node)
> + continue;
> +
> chan = find_candidate(device, mask, fn, fn_param);
> if (!IS_ERR(chan))
> break;
> @@ -769,7 +775,7 @@ struct dma_chan *dma_request_chan_by_mask(const dma_cap_mask_t *mask)
> if (!mask)
> return ERR_PTR(-ENODEV);
>
> - chan = __dma_request_channel(mask, NULL, NULL);
> + chan = __dma_request_channel(mask, NULL, NULL, NULL);
> if (!chan) {
> mutex_lock(&dma_list_mutex);
> if (list_empty(&dma_device_list))
> diff --git a/drivers/dma/of-dma.c b/drivers/dma/of-dma.c
> index 91fd395..6b43d04 100644
> --- a/drivers/dma/of-dma.c
> +++ b/drivers/dma/of-dma.c
> @@ -316,8 +316,8 @@ struct dma_chan *of_dma_simple_xlate(struct of_phandle_args *dma_spec,
> if (count != 1)
> return NULL;
>
> - return dma_request_channel(info->dma_cap, info->filter_fn,
> - &dma_spec->args[0]);
> + return __dma_request_channel(&info->dma_cap, info->filter_fn,
> + &dma_spec->args[0], dma_spec->np);
> }
> EXPORT_SYMBOL_GPL(of_dma_simple_xlate);
>
> diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
> index d49ec5c..504085b 100644
> --- a/include/linux/dmaengine.h
> +++ b/include/linux/dmaengine.h
> @@ -1314,7 +1314,8 @@ static inline enum dma_status dma_async_is_complete(dma_cookie_t cookie,
> enum dma_status dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx);
> void dma_issue_pending_all(void);
> struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
> - dma_filter_fn fn, void *fn_param);
> + dma_filter_fn fn, void *fn_param,
> + struct device_node *np);
> struct dma_chan *dma_request_slave_channel(struct device *dev, const char *name);
>
> struct dma_chan *dma_request_chan(struct device *dev, const char *name);
> @@ -1339,7 +1340,9 @@ static inline void dma_issue_pending_all(void)
> {
> }
> static inline struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
> - dma_filter_fn fn, void *fn_param)
> + dma_filter_fn fn,
> + void *fn_param,
> + struct device_node *np)
> {
> return NULL;
> }
> @@ -1411,7 +1414,8 @@ static inline int dmaengine_desc_free(struct dma_async_tx_descriptor *desc)
> void dma_run_dependencies(struct dma_async_tx_descriptor *tx);
> struct dma_chan *dma_get_slave_channel(struct dma_chan *chan);
> struct dma_chan *dma_get_any_slave_channel(struct dma_device *device);
> -#define dma_request_channel(mask, x, y) __dma_request_channel(&(mask), x, y)
> +#define dma_request_channel(mask, x, y) \
> + __dma_request_channel(&(mask), x, y, NULL)
> #define dma_request_slave_channel_compat(mask, x, y, dev, name) \
> __dma_request_slave_channel_compat(&(mask), x, y, dev, name)
>
> @@ -1429,6 +1433,6 @@ static inline int dmaengine_desc_free(struct dma_async_tx_descriptor *desc)
> if (!fn || !fn_param)
> return NULL;
>
> - return __dma_request_channel(mask, fn, fn_param);
> + return __dma_request_channel(mask, fn, fn_param, NULL);
> }
> #endif /* DMAENGINE_H */
>
- Péter
Texas Instruments Finland Oy, Porkkalankatu 22, 00180 Helsinki.
Y-tunnus/Business ID: 0615521-4. Kotipaikka/Domicile: Helsinki
On Tue, 7 May 2019 at 16:37, Peter Ujfalusi <[email protected]> wrote:
>
> Hi,
>
> On 07/05/2019 9.09, Baolin Wang wrote:
> > When user try to request one DMA channel by __dma_request_channel(), it won't
> > validate if it is the correct DMA device to request, that will lead each DMA
> > engine driver to validate the correct device node in their filter function
> > if it is necessary.
> >
> > Thus we can add the matching device node validation in the DMA engine core,
> > to remove all of device node validation in the drivers.
>
> I have picked this patch to my TI UDMA series and with
> __dma_request_channel() it works as expected - picking the channel from
> the correct DMA device.
>
> Tested-by: Peter Ujfalusi <[email protected]>
Thanks Peter.
>
> >
> > Signed-off-by: Baolin Wang <[email protected]>
> > ---
> > drivers/dma/dmaengine.c | 10 ++++++++--
> > drivers/dma/of-dma.c | 4 ++--
> > include/linux/dmaengine.h | 12 ++++++++----
> > 3 files changed, 18 insertions(+), 8 deletions(-)
> >
> > diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c
> > index 3a11b10..610080c 100644
> > --- a/drivers/dma/dmaengine.c
> > +++ b/drivers/dma/dmaengine.c
> > @@ -641,11 +641,13 @@ struct dma_chan *dma_get_any_slave_channel(struct dma_device *device)
> > * @mask: capabilities that the channel must satisfy
> > * @fn: optional callback to disposition available channels
> > * @fn_param: opaque parameter to pass to dma_filter_fn
> > + * @np: device node to look for DMA channels
> > *
> > * Returns pointer to appropriate DMA channel on success or NULL.
> > */
> > struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
> > - dma_filter_fn fn, void *fn_param)
> > + dma_filter_fn fn, void *fn_param,
> > + struct device_node *np)
> > {
> > struct dma_device *device, *_d;
> > struct dma_chan *chan = NULL;
> > @@ -653,6 +655,10 @@ struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
> > /* Find a channel */
> > mutex_lock(&dma_list_mutex);
> > list_for_each_entry_safe(device, _d, &dma_device_list, global_node) {
> > + /* Finds a DMA controller with matching device node */
> > + if (np && device->dev->of_node && np != device->dev->of_node)
> > + continue;
> > +
> > chan = find_candidate(device, mask, fn, fn_param);
> > if (!IS_ERR(chan))
> > break;
> > @@ -769,7 +775,7 @@ struct dma_chan *dma_request_chan_by_mask(const dma_cap_mask_t *mask)
> > if (!mask)
> > return ERR_PTR(-ENODEV);
> >
> > - chan = __dma_request_channel(mask, NULL, NULL);
> > + chan = __dma_request_channel(mask, NULL, NULL, NULL);
> > if (!chan) {
> > mutex_lock(&dma_list_mutex);
> > if (list_empty(&dma_device_list))
> > diff --git a/drivers/dma/of-dma.c b/drivers/dma/of-dma.c
> > index 91fd395..6b43d04 100644
> > --- a/drivers/dma/of-dma.c
> > +++ b/drivers/dma/of-dma.c
> > @@ -316,8 +316,8 @@ struct dma_chan *of_dma_simple_xlate(struct of_phandle_args *dma_spec,
> > if (count != 1)
> > return NULL;
> >
> > - return dma_request_channel(info->dma_cap, info->filter_fn,
> > - &dma_spec->args[0]);
> > + return __dma_request_channel(&info->dma_cap, info->filter_fn,
> > + &dma_spec->args[0], dma_spec->np);
> > }
> > EXPORT_SYMBOL_GPL(of_dma_simple_xlate);
> >
> > diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
> > index d49ec5c..504085b 100644
> > --- a/include/linux/dmaengine.h
> > +++ b/include/linux/dmaengine.h
> > @@ -1314,7 +1314,8 @@ static inline enum dma_status dma_async_is_complete(dma_cookie_t cookie,
> > enum dma_status dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx);
> > void dma_issue_pending_all(void);
> > struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
> > - dma_filter_fn fn, void *fn_param);
> > + dma_filter_fn fn, void *fn_param,
> > + struct device_node *np);
> > struct dma_chan *dma_request_slave_channel(struct device *dev, const char *name);
> >
> > struct dma_chan *dma_request_chan(struct device *dev, const char *name);
> > @@ -1339,7 +1340,9 @@ static inline void dma_issue_pending_all(void)
> > {
> > }
> > static inline struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
> > - dma_filter_fn fn, void *fn_param)
> > + dma_filter_fn fn,
> > + void *fn_param,
> > + struct device_node *np)
> > {
> > return NULL;
> > }
> > @@ -1411,7 +1414,8 @@ static inline int dmaengine_desc_free(struct dma_async_tx_descriptor *desc)
> > void dma_run_dependencies(struct dma_async_tx_descriptor *tx);
> > struct dma_chan *dma_get_slave_channel(struct dma_chan *chan);
> > struct dma_chan *dma_get_any_slave_channel(struct dma_device *device);
> > -#define dma_request_channel(mask, x, y) __dma_request_channel(&(mask), x, y)
> > +#define dma_request_channel(mask, x, y) \
> > + __dma_request_channel(&(mask), x, y, NULL)
> > #define dma_request_slave_channel_compat(mask, x, y, dev, name) \
> > __dma_request_slave_channel_compat(&(mask), x, y, dev, name)
> >
> > @@ -1429,6 +1433,6 @@ static inline int dmaengine_desc_free(struct dma_async_tx_descriptor *desc)
> > if (!fn || !fn_param)
> > return NULL;
> >
> > - return __dma_request_channel(mask, fn, fn_param);
> > + return __dma_request_channel(mask, fn, fn_param, NULL);
> > }
> > #endif /* DMAENGINE_H */
> >
>
> - Péter
>
> Texas Instruments Finland Oy, Porkkalankatu 22, 00180 Helsinki.
> Y-tunnus/Business ID: 0615521-4. Kotipaikka/Domicile: Helsinki
--
Baolin Wang
Best Regards