* [PATCH v3 1/5] dmaengine: add dmaengine_prep_dma_(pq|pq_val|interrupt|xor)() API
2026-10-05 9:37 [PATCH v3 0/5] dmaengine: Add dmaengine API to avoid call DMA Engine callback directly Frank.Li
@ 2026-10-05 9:37 ` Frank.Li
2026-10-05 9:46 ` sashiko-bot
2026-10-05 9:37 ` [PATCH v3 2/5] dmaengine: add dmaengine_is_*_aligned() helpers for DMA consumers Frank.Li
` (4 subsequent siblings)
5 siblings, 1 reply; 8+ messages in thread
From: Frank.Li @ 2026-10-05 9:37 UTC (permalink / raw)
To: Vinod Koul, Frank Li, Herbert Xu, David S. Miller
Cc: dmaengine, linux-kernel, linux-crypto, imx, Frank Li
From: Frank Li <Frank.Li@nxp.com>
Add dmaengine_prep_dma_(pq|pq_val|interrupt|xor)() as an inline
wrapper around the device_prep_dma_(pq|pq_val|interrupt|xor)() callback,
consistent with how other dmaengine prep helpers like
dmaengine_prep_dma_memcpy() are structured.
Provide a clean public API that hides the direct callback access and add
proper NULL-checks on chan, chan->device, and the callback pointer.
Assisted-by: LLM
Signed-off-by: Frank Li <Frank.Li@nxp.com>
---
include/linux/dmaengine.h | 134 ++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 134 insertions(+)
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index c3a49a33307c6..6a187136f9493 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -1232,6 +1232,122 @@ static inline struct dma_async_tx_descriptor *dmaengine_prep_dma_memcpy(
len, flags);
}
+/**
+ * dmaengine_prep_dma_xor - prepare a DMA XOR operation
+ * @chan: the channel to use for this operation
+ * @dst: destination buffer address
+ * @src: array of source buffer addresses
+ * @src_cnt: number of source buffers
+ * @len: length in bytes of each source and destination buffer
+ * @flags: DMA engine flags (e.g. DMA_PREP_INTERRUPT)
+ *
+ * Prepare an XOR parity generation transaction. The engine computes:
+ * dst = src[0] XOR src[1] XOR ... XOR src[src_cnt - 1]
+ *
+ * Returns a descriptor on success, or NULL if the channel does not support
+ * this operation or the request could not be queued.
+ */
+static inline struct dma_async_tx_descriptor *
+dmaengine_prep_dma_xor(struct dma_chan *chan, dma_addr_t dst, dma_addr_t *src,
+ unsigned int src_cnt, size_t len, unsigned long flags)
+{
+ if (!chan || !chan->device || !chan->device->device_prep_dma_xor)
+ return NULL;
+
+ return chan->device->device_prep_dma_xor(chan, dst, src,
+ src_cnt, len, flags);
+}
+
+/**
+ * dmaengine_prep_dma_xor_val - prepare a DMA XOR zero-sum validation operation
+ * @chan: the channel to use for this operation
+ * @src: array of source buffer addresses
+ * @src_cnt: number of source buffers
+ * @len: length in bytes of each source buffer
+ * @result: output flag set to SUM_CHECK_P_RESULT if the XOR of all sources
+ * is non-zero (i.e. parity error), cleared otherwise
+ * @flags: DMA engine flags (e.g. DMA_PREP_INTERRUPT)
+ *
+ * Prepare an XOR zero-sum validation transaction. The engine XORs all
+ * source buffers and checks whether the result is zero. The outcome is
+ * written to @result on completion.
+ *
+ * Returns a descriptor on success, or NULL if the channel does not support
+ * this operation or the request could not be queued.
+ */
+static inline struct dma_async_tx_descriptor *
+dmaengine_prep_dma_xor_val(struct dma_chan *chan, dma_addr_t *src,
+ unsigned int src_cnt, size_t len,
+ enum sum_check_flags *result, unsigned long flags)
+{
+ if (!chan || !chan->device || !chan->device->device_prep_dma_xor_val)
+ return NULL;
+
+ return chan->device->device_prep_dma_xor_val(chan, src, src_cnt,
+ len, result, flags);
+}
+
+/**
+ * dmaengine_prep_dma_pq - prepare a DMA PQ (RAID-6 P+Q) operation
+ * @chan: the channel to use for this operation
+ * @dst: array of two destination addresses: dst[0] for P, dst[1] for Q
+ * @src: array of source buffer addresses
+ * @src_cnt: number of source buffers
+ * @scf: array of scaling coefficients, one per source buffer
+ * @len: length in bytes of each source and destination buffer
+ * @flags: DMA engine flags (e.g. DMA_PREP_INTERRUPT)
+ *
+ * Prepare a P+Q parity generation transaction. The engine computes:
+ * P = XOR of all source buffers
+ * Q = Galois field sum of (scf[i] * src[i]) over all sources
+ *
+ * Returns a descriptor on success, or NULL if the channel does not support
+ * this operation or the request could not be queued.
+ */
+static inline struct dma_async_tx_descriptor *
+dmaengine_prep_dma_pq(struct dma_chan *chan, dma_addr_t *dst, dma_addr_t *src,
+ unsigned int src_cnt, const unsigned char *scf,
+ size_t len, unsigned long flags)
+{
+ if (!chan || !chan->device || !chan->device->device_prep_dma_pq)
+ return NULL;
+
+ return chan->device->device_prep_dma_pq(chan, dst, src,
+ src_cnt, scf, len, flags);
+}
+
+/**
+ * dmaengine_prep_dma_pq_val - prepare a DMA PQ validation operation
+ * @chan: the channel to use for this operation
+ * @pq: array of two addresses holding existing P and Q parity buffers
+ * @src: array of source buffer addresses
+ * @src_cnt: number of source buffers
+ * @scf: array of scaling coefficients, one per source buffer
+ * @len: length in bytes of each buffer
+ * @pqres: output flags indicating P and/or Q check results (SUM_CHECK_P_VALID,
+ * SUM_CHECK_Q_VALID)
+ * @flags: DMA engine flags (e.g. DMA_PREP_INTERRUPT)
+ *
+ * Prepare a PQ validation transaction. The engine recomputes P and Q from the
+ * source buffers and compares them against the existing parity stored at @pq.
+ * The result of each comparison is reported through @pqres.
+ *
+ * Returns a descriptor on success, or NULL if the channel does not support
+ * this operation or the request could not be queued.
+ */
+static inline struct dma_async_tx_descriptor *
+dmaengine_prep_dma_pq_val(struct dma_chan *chan, dma_addr_t *pq, dma_addr_t *src,
+ unsigned int src_cnt, const unsigned char *scf,
+ size_t len, enum sum_check_flags *pqres, unsigned long flags)
+{
+ if (!chan || !chan->device || !chan->device->device_prep_dma_pq_val)
+ return NULL;
+
+ return chan->device->device_prep_dma_pq_val(chan, pq, src,
+ src_cnt, scf, len,
+ pqres, flags);
+}
+
static inline bool dmaengine_is_metadata_mode_supported(struct dma_chan *chan,
enum dma_desc_metadata_mode mode)
{
@@ -1585,6 +1701,24 @@ __dma_has_cap(enum dma_transaction_type tx_type, dma_cap_mask_t *srcp)
#define for_each_dma_cap_mask(cap, mask) \
for_each_set_bit(cap, mask.bits, DMA_TX_TYPE_END)
+/**
+ * dmaengine_prep_dma_interrupt() - Prepare a DMA interrupt descriptor.
+ * @chan: The channel to be used for this descriptor
+ * @flags: DMA engine flags
+ *
+ * Returns a descriptor for an interrupt transaction, or NULL if the
+ * channel does not support DMA_INTERRUPT.
+ */
+static inline struct dma_async_tx_descriptor *
+dmaengine_prep_dma_interrupt(struct dma_chan *chan, unsigned long flags)
+{
+ if (!chan || !chan->device || !chan->device->device_prep_dma_interrupt ||
+ !dma_has_cap(DMA_INTERRUPT, chan->device->cap_mask))
+ return NULL;
+
+ return chan->device->device_prep_dma_interrupt(chan, flags);
+}
+
/**
* dma_async_issue_pending - flush pending transactions to HW
* @chan: target DMA channel
--
2.43.0
^ permalink raw reply related [flat|nested] 8+ messages in thread* Re: [PATCH v3 1/5] dmaengine: add dmaengine_prep_dma_(pq|pq_val|interrupt|xor)() API
2026-10-05 9:37 ` [PATCH v3 1/5] dmaengine: add dmaengine_prep_dma_(pq|pq_val|interrupt|xor)() API Frank.Li
@ 2026-10-05 9:46 ` sashiko-bot
0 siblings, 0 replies; 8+ messages in thread
From: sashiko-bot @ 2026-10-05 9:46 UTC (permalink / raw)
To: Frank.Li; +Cc: Frank.Li, vkoul, dmaengine, imx
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] doc: incorrect flag names in dmaengine_prep_dma_pq_val() comment
--
commit f5c4a27207edbbbf16dc41d215bb04c300d1dd66
Author: Frank Li <Frank.Li@nxp.com>
dmaengine: add dmaengine_prep_dma_(pq|pq_val|interrupt|xor)() API
This commit adds inline wrappers for several DMA engine preparation
functions to provide a clean public API. It also incorporates proper
pointer checks before accessing the underlying device callbacks.
> diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
> index c3a49a33307c6..6a187136f9493 100644
> --- a/include/linux/dmaengine.h
> +++ b/include/linux/dmaengine.h
[ ... ]
> +/**
> + * dmaengine_prep_dma_pq_val - prepare a DMA PQ validation operation
> + * @chan: the channel to use for this operation
> + * @pq: array of two addresses holding existing P and Q parity buffers
> + * @src: array of source buffer addresses
> + * @src_cnt: number of source buffers
> + * @scf: array of scaling coefficients, one per source buffer
> + * @len: length in bytes of each buffer
> + * @pqres: output flags indicating P and/or Q check results (SUM_CHECK_P_VALID,
> + * SUM_CHECK_Q_VALID)
[Severity: Low]
This isn't a bug, but the documentation refers to non-existent constants.
Should this instead reference the correct SUM_CHECK_P_RESULT and
SUM_CHECK_Q_RESULT flags?
> + * @flags: DMA engine flags (e.g. DMA_PREP_INTERRUPT)
> + *
> + * Prepare a PQ validation transaction. The engine recomputes P and Q from the
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261005-dmaengine_prep_dma_pq-v3-0-a4a241f26fa7@nxp.com?part=1
^ permalink raw reply [flat|nested] 8+ messages in thread
* [PATCH v3 2/5] dmaengine: add dmaengine_is_*_aligned() helpers for DMA consumers
2026-10-05 9:37 [PATCH v3 0/5] dmaengine: Add dmaengine API to avoid call DMA Engine callback directly Frank.Li
2026-10-05 9:37 ` [PATCH v3 1/5] dmaengine: add dmaengine_prep_dma_(pq|pq_val|interrupt|xor)() API Frank.Li
@ 2026-10-05 9:37 ` Frank.Li
2026-10-05 9:37 ` [PATCH v3 3/5] dmaengine: add dmaengine_get_copy_align() and related alignment getter helpers Frank.Li
` (3 subsequent siblings)
5 siblings, 0 replies; 8+ messages in thread
From: Frank.Li @ 2026-10-05 9:37 UTC (permalink / raw)
To: Vinod Koul, Frank Li, Herbert Xu, David S. Miller
Cc: dmaengine, linux-kernel, linux-crypto, imx, Frank Li
From: Frank Li <Frank.Li@nxp.com>
DMA engine consumers typically hold a struct dma_chan pointer and should
not need to reach into struct dma_device directly to check alignment
requirements. Add dmaengine_is_copy_aligned(), dmaengine_is_xor_aligned(),
dmaengine_is_pq_aligned() and dmaengine_is_fill_aligned() as channel-based
counterparts to the existing is_dma_*_aligned() family.
Each wrapper calls dmaengine_check_align() directly with the alignment
value from chan->device, keeping struct dma_device opaque to consumers.
Signed-off-by: Frank Li <Frank.Li@nxp.com>
---
include/linux/dmaengine.h | 64 +++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 64 insertions(+)
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index 6a187136f9493..1efb04e137673 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -1537,6 +1537,70 @@ static inline bool is_dma_fill_aligned(struct dma_device *dev, size_t off1,
return dmaengine_check_align(dev->fill_align, off1, off2, len);
}
+/**
+ * dmaengine_is_copy_aligned - test copy alignment
+ * @chan: DMA channel
+ * @off1: first buffer offset
+ * @off2: second buffer offset
+ * @len: transfer length
+ *
+ * Return true if off1, off2 and len satisfy the copy alignment requirement of
+ * the DMA channel, false otherwise.
+ */
+static inline bool dmaengine_is_copy_aligned(struct dma_chan *chan, size_t off1,
+ size_t off2, size_t len)
+{
+ return dmaengine_check_align(chan->device->copy_align, off1, off2, len);
+}
+
+/**
+ * dmaengine_is_xor_aligned - test xor alignment
+ * @chan: DMA channel
+ * @off1: first buffer offset
+ * @off2: second buffer offset
+ * @len: transfer length
+ *
+ * Return true if off1, off2 and len satisfy the xor alignment requirement of
+ * the DMA channel, false otherwise.
+ */
+static inline bool dmaengine_is_xor_aligned(struct dma_chan *chan, size_t off1,
+ size_t off2, size_t len)
+{
+ return dmaengine_check_align(chan->device->xor_align, off1, off2, len);
+}
+
+/**
+ * dmaengine_is_pq_aligned - test pq alignment
+ * @chan: DMA channel
+ * @off1: first buffer offset
+ * @off2: second buffer offset
+ * @len: transfer length
+ *
+ * Return true if off1, off2 and len satisfy the pq alignment requirement of
+ * the DMA channel, false otherwise.
+ */
+static inline bool dmaengine_is_pq_aligned(struct dma_chan *chan, size_t off1,
+ size_t off2, size_t len)
+{
+ return dmaengine_check_align(chan->device->pq_align, off1, off2, len);
+}
+
+/**
+ * dmaengine_is_fill_aligned - test fill alignment
+ * @chan: DMA channel
+ * @off1: first buffer offset
+ * @off2: second buffer offset
+ * @len: transfer length
+ *
+ * Return true if off1, off2 and len satisfy the fill alignment requirement of
+ * the DMA channel, false otherwise.
+ */
+static inline bool dmaengine_is_fill_aligned(struct dma_chan *chan, size_t off1,
+ size_t off2, size_t len)
+{
+ return dmaengine_check_align(chan->device->fill_align, off1, off2, len);
+}
+
static inline void
dma_set_maxpq(struct dma_device *dma, int maxpq, int has_pq_continue)
{
--
2.43.0
^ permalink raw reply related [flat|nested] 8+ messages in thread* [PATCH v3 3/5] dmaengine: add dmaengine_get_copy_align() and related alignment getter helpers
2026-10-05 9:37 [PATCH v3 0/5] dmaengine: Add dmaengine API to avoid call DMA Engine callback directly Frank.Li
2026-10-05 9:37 ` [PATCH v3 1/5] dmaengine: add dmaengine_prep_dma_(pq|pq_val|interrupt|xor)() API Frank.Li
2026-10-05 9:37 ` [PATCH v3 2/5] dmaengine: add dmaengine_is_*_aligned() helpers for DMA consumers Frank.Li
@ 2026-10-05 9:37 ` Frank.Li
2026-10-05 9:37 ` [PATCH v3 4/5] dmaengine: add dmaengine_get_cap_mask() and dmaengine_has_cap() helpers Frank.Li
` (2 subsequent siblings)
5 siblings, 0 replies; 8+ messages in thread
From: Frank.Li @ 2026-10-05 9:37 UTC (permalink / raw)
To: Vinod Koul, Frank Li, Herbert Xu, David S. Miller
Cc: dmaengine, linux-kernel, linux-crypto, imx, Frank Li
From: Frank Li <Frank.Li@nxp.com>
Add dmaengine_get_copy_align(), dmaengine_get_xor_align(),
dmaengine_get_pq_align(), and dmaengine_get_fill_align() inline
helpers to retrieve the alignment requirement of a DMA channel as
a power-of-2 exponent.
These complement the existing dmaengine_is_*_aligned() test helpers
by providing direct access to the alignment value, which is useful
when callers need to propagate or compare alignment constraints.
Signed-off-by: Frank Li <Frank.Li@nxp.com>
---
include/linux/dmaengine.h | 48 +++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 48 insertions(+)
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index 1efb04e137673..615eeb708dcda 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -1537,6 +1537,54 @@ static inline bool is_dma_fill_aligned(struct dma_device *dev, size_t off1,
return dmaengine_check_align(dev->fill_align, off1, off2, len);
}
+/**
+ * dmaengine_get_copy_align - get copy alignment requirement of a DMA channel
+ * @chan: DMA channel
+ *
+ * Return the copy alignment requirement of @chan as a power-of-2 exponent.
+ */
+static inline enum dmaengine_alignment
+dmaengine_get_copy_align(struct dma_chan *chan)
+{
+ return chan->device->copy_align;
+}
+
+/**
+ * dmaengine_get_xor_align - get xor alignment requirement of a DMA channel
+ * @chan: DMA channel
+ *
+ * Return the xor alignment requirement of @chan as a power-of-2 exponent.
+ */
+static inline enum dmaengine_alignment
+dmaengine_get_xor_align(struct dma_chan *chan)
+{
+ return chan->device->xor_align;
+}
+
+/**
+ * dmaengine_get_pq_align - get pq alignment requirement of a DMA channel
+ * @chan: DMA channel
+ *
+ * Return the pq alignment requirement of @chan as a power-of-2 exponent.
+ */
+static inline enum dmaengine_alignment
+dmaengine_get_pq_align(struct dma_chan *chan)
+{
+ return chan->device->pq_align;
+}
+
+/**
+ * dmaengine_get_fill_align - get fill alignment requirement of a DMA channel
+ * @chan: DMA channel
+ *
+ * Return the fill alignment requirement of @chan as a power-of-2 exponent.
+ */
+static inline enum dmaengine_alignment
+dmaengine_get_fill_align(struct dma_chan *chan)
+{
+ return chan->device->fill_align;
+}
+
/**
* dmaengine_is_copy_aligned - test copy alignment
* @chan: DMA channel
--
2.43.0
^ permalink raw reply related [flat|nested] 8+ messages in thread* [PATCH v3 4/5] dmaengine: add dmaengine_get_cap_mask() and dmaengine_has_cap() helpers
2026-10-05 9:37 [PATCH v3 0/5] dmaengine: Add dmaengine API to avoid call DMA Engine callback directly Frank.Li
` (2 preceding siblings ...)
2026-10-05 9:37 ` [PATCH v3 3/5] dmaengine: add dmaengine_get_copy_align() and related alignment getter helpers Frank.Li
@ 2026-10-05 9:37 ` Frank.Li
2026-10-05 9:37 ` [PATCH v3 5/5] dmaengine: add dmaengine_get_max_xor() helper Frank.Li
2026-10-09 10:14 ` [PATCH v3 0/5] dmaengine: Add dmaengine API to avoid call DMA Engine callback directly Vinod Koul
5 siblings, 0 replies; 8+ messages in thread
From: Frank.Li @ 2026-10-05 9:37 UTC (permalink / raw)
To: Vinod Koul, Frank Li, Herbert Xu, David S. Miller
Cc: dmaengine, linux-kernel, linux-crypto, imx, Frank Li
From: Frank Li <Frank.Li@nxp.com>
Add two new inline helpers to query DMA channel capabilities without
directly accessing the internal dma_device pointer:
dmaengine_get_cap_mask(chan) - returns a const pointer to the
capability mask of the DMA device backing the channel.
dmaengine_has_cap(chan, tx_type) - returns true if the channel
supports the given transaction type.
These complement the existing dma_has_cap() macro which operates on
a dma_cap_mask_t directly.
Signed-off-by: Frank Li <Frank.Li@nxp.com>
---
include/linux/dmaengine.h | 25 +++++++++++++++++++++++++
1 file changed, 25 insertions(+)
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index 615eeb708dcda..7fce44bd7c049 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -1585,6 +1585,18 @@ dmaengine_get_fill_align(struct dma_chan *chan)
return chan->device->fill_align;
}
+/**
+ * dmaengine_get_cap_mask - get capability mask of a DMA channel
+ * @chan: DMA channel
+ *
+ * Return a pointer to the capability mask of the DMA device backing @chan.
+ */
+static inline const dma_cap_mask_t *
+dmaengine_get_cap_mask(struct dma_chan *chan)
+{
+ return &chan->device->cap_mask;
+}
+
/**
* dmaengine_is_copy_aligned - test copy alignment
* @chan: DMA channel
@@ -1810,6 +1822,19 @@ __dma_has_cap(enum dma_transaction_type tx_type, dma_cap_mask_t *srcp)
return test_bit(tx_type, srcp->bits);
}
+/**
+ * dmaengine_has_cap - test whether a DMA channel supports a transaction type
+ * @chan: DMA channel
+ * @tx_type: transaction type to test
+ *
+ * Return true if @chan supports @tx_type, false otherwise.
+ */
+static inline bool
+dmaengine_has_cap(struct dma_chan *chan, enum dma_transaction_type tx_type)
+{
+ return dma_has_cap(tx_type, chan->device->cap_mask);
+}
+
#define for_each_dma_cap_mask(cap, mask) \
for_each_set_bit(cap, mask.bits, DMA_TX_TYPE_END)
--
2.43.0
^ permalink raw reply related [flat|nested] 8+ messages in thread* [PATCH v3 5/5] dmaengine: add dmaengine_get_max_xor() helper
2026-10-05 9:37 [PATCH v3 0/5] dmaengine: Add dmaengine API to avoid call DMA Engine callback directly Frank.Li
` (3 preceding siblings ...)
2026-10-05 9:37 ` [PATCH v3 4/5] dmaengine: add dmaengine_get_cap_mask() and dmaengine_has_cap() helpers Frank.Li
@ 2026-10-05 9:37 ` Frank.Li
2026-10-09 10:14 ` [PATCH v3 0/5] dmaengine: Add dmaengine API to avoid call DMA Engine callback directly Vinod Koul
5 siblings, 0 replies; 8+ messages in thread
From: Frank.Li @ 2026-10-05 9:37 UTC (permalink / raw)
To: Vinod Koul, Frank Li, Herbert Xu, David S. Miller
Cc: dmaengine, linux-kernel, linux-crypto, imx, Frank Li
From: Frank Li <Frank.Li@nxp.com>
Add a new inline helper dmaengine_get_max_xor() that returns the maximum
number of XOR source buffers supported by the DMA channel's device.
Returns 0 if the channel is NULL or does not support XOR operations.
Signed-off-by: Frank Li <Frank.Li@nxp.com>
---
include/linux/dmaengine.h | 15 +++++++++++++++
1 file changed, 15 insertions(+)
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index 7fce44bd7c049..a4c9eef369cb4 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -1232,6 +1232,21 @@ static inline struct dma_async_tx_descriptor *dmaengine_prep_dma_memcpy(
len, flags);
}
+/**
+ * dmaengine_get_max_xor - get the maximum number of XOR sources for a channel
+ * @chan: DMA channel
+ *
+ * Returns the maximum number of source buffers supported by the XOR engine
+ * behind @chan, or 0 if the channel does not support XOR operations.
+ */
+static inline unsigned int dmaengine_get_max_xor(struct dma_chan *chan)
+{
+ if (!chan || !chan->device)
+ return 0;
+
+ return chan->device->max_xor;
+}
+
/**
* dmaengine_prep_dma_xor - prepare a DMA XOR operation
* @chan: the channel to use for this operation
--
2.43.0
^ permalink raw reply related [flat|nested] 8+ messages in thread* Re: [PATCH v3 0/5] dmaengine: Add dmaengine API to avoid call DMA Engine callback directly
2026-10-05 9:37 [PATCH v3 0/5] dmaengine: Add dmaengine API to avoid call DMA Engine callback directly Frank.Li
` (4 preceding siblings ...)
2026-10-05 9:37 ` [PATCH v3 5/5] dmaengine: add dmaengine_get_max_xor() helper Frank.Li
@ 2026-10-09 10:14 ` Vinod Koul
5 siblings, 0 replies; 8+ messages in thread
From: Vinod Koul @ 2026-10-09 10:14 UTC (permalink / raw)
To: Frank Li, Herbert Xu, David S. Miller, Frank.Li
Cc: dmaengine, linux-kernel, linux-crypto, imx, Frank Li
On Mon, 05 Oct 2026 05:37:13 -0400, Frank.Li@oss.nxp.com wrote:
> Add dmaengine APIs to avoid call DMA Engine callback directly. Prepare to
> make dmaengine provider private.
>
>
Applied, thanks!
[1/5] dmaengine: add dmaengine_prep_dma_(pq|pq_val|interrupt|xor)() API
commit: 4bdb88eb5496cb09902b9778ca7f4628c43b0d77
[2/5] dmaengine: add dmaengine_is_*_aligned() helpers for DMA consumers
commit: 11e801ccaca78c9d92b1f3a9733772bf9d2c079c
[3/5] dmaengine: add dmaengine_get_copy_align() and related alignment getter helpers
commit: 072975a8a578a62ea68ec1ceb8d2d7dcfb5dfefa
[4/5] dmaengine: add dmaengine_get_cap_mask() and dmaengine_has_cap() helpers
commit: bbc109e0e686266d784483df108af206bc52e120
[5/5] dmaengine: add dmaengine_get_max_xor() helper
commit: bff69558d64a98bc8d03f373d1331223c3428a2c
Best regards,
--
~Vinod
^ permalink raw reply [flat|nested] 8+ messages in thread