Re: [PATCH 12/23] dmaengine: sdxi: Add descriptor ring management

[Frank Li]

On Fri, Apr 10, 2026 at 08:07:22AM -0500, Nathan Lynch wrote:
> Introduce a library for managing SDXI descriptor ring state. It
> encapsulates determining the next free space in the ring to deposit
> descriptors and performing the update of the write index correctly, as
> well as iterating over slices (reservations) of the ring without
> dealing directly with ring offsets/indexes.
>
> The central abstraction is sdxi_ring_state, which maintains the write
> index and a wait queue. An internal spin lock serializes checks for
> space in the ring and updates to the write index.
>
> Reservations (sdxi_ring_resv) are intended to be short-lived on-stack
> objects representing slices of the ring for callers to populate with
> descriptors. Both blocking and non-blocking reservation APIs are
> provided.
>
> Descriptor access within a reservation is provided via
> sdxi_ring_resv_next() and sdxi_ring_resv_foreach().
>
> Completion handlers must call sdxi_ring_wake_up() when descriptors
> have been consumed so that blocked reservations can proceed.
>
> Co-developed-by: Wei Huang <wei.huang2@xxxxxxx>
> Signed-off-by: Wei Huang <wei.huang2@xxxxxxx>
> Signed-off-by: Nathan Lynch <nathan.lynch@xxxxxxx>
> ---
>  drivers/dma/sdxi/Makefile |   3 +-
>  drivers/dma/sdxi/ring.c   | 158 ++++++++++++++++++++++++++++++++++++++++++++++
>  drivers/dma/sdxi/ring.h   |  84 ++++++++++++++++++++++++
>  3 files changed, 244 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/dma/sdxi/Makefile b/drivers/dma/sdxi/Makefile
> index 2178f274831c..23536a1defc3 100644
> --- a/drivers/dma/sdxi/Makefile
> +++ b/drivers/dma/sdxi/Makefile
> @@ -3,6 +3,7 @@ obj-$(CONFIG_SDXI) += sdxi.o
>
>  sdxi-objs += \
>  	context.o     \
> -	device.o
> +	device.o      \
> +	ring.o
>
>  sdxi-$(CONFIG_PCI_MSI) += pci.o
> diff --git a/drivers/dma/sdxi/ring.c b/drivers/dma/sdxi/ring.c
> new file mode 100644
> index 000000000000..d51b9e708a4f
> --- /dev/null
> +++ b/drivers/dma/sdxi/ring.c
> @@ -0,0 +1,158 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * SDXI descriptor ring state management. Handles advancing the write
> + * index correctly and supplies "reservations" i.e. slices of the ring
> + * to be filled with descriptors.
> + *
> + * Copyright Advanced Micro Devices, Inc.
> + */
> +#include <kunit/visibility.h>
> +#include <linux/io-64-nonatomic-lo-hi.h>
> +#include <linux/lockdep.h>
> +#include <linux/range.h>
> +#include <linux/sched.h>
> +#include <linux/spinlock.h>
> +#include <linux/types.h>
> +#include <linux/wait.h>
> +#include <asm/barrier.h>
> +#include <asm/byteorder.h>
> +#include <asm/div64.h>
> +#include <asm/rwonce.h>
> +
> +#include "ring.h"
> +#include "hw.h"
> +
> +/*
> + * Initialize ring management state. Caller is responsible for
> + * allocating, mapping, and initializing the actual control structures
> + * shared with hardware: the indexes and ring array.
> + */
> +void sdxi_ring_state_init(struct sdxi_ring_state *rs, const __le64 *read_index,
> +			  __le64 *write_index, u32 entries,
> +			  struct sdxi_desc descs[static SZ_1K])
> +{
> +	WARN_ON_ONCE(!read_index);
> +	WARN_ON_ONCE(!write_index);
> +	/*
> +	 * See SDXI 1.0 Table 3-1 Memory Structure Summary. Minimum
> +	 * descriptor ring size in bytes is 64KB; thus 1024 64-byte
> +	 * entries.
> +	 */
> +	WARN_ON_ONCE(entries < SZ_1K);
> +
> +	*rs = (typeof(*rs)) {
> +		.write_index = le64_to_cpu(*write_index),
> +		.write_index_ptr = write_index,
> +		.read_index_ptr = read_index,
> +		.entries = entries,
> +		.entry = descs,
> +	};
> +	spin_lock_init(&rs->lock);
> +	init_waitqueue_head(&rs->wqh);
> +}
> +EXPORT_SYMBOL_IF_KUNIT(sdxi_ring_state_init);
> +
> +static u64 sdxi_ring_state_load_ridx(struct sdxi_ring_state *rs)
> +{
> +	lockdep_assert_held(&rs->lock);
> +	return le64_to_cpu(READ_ONCE(*rs->read_index_ptr));
> +}
> +
> +static void sdxi_ring_state_store_widx(struct sdxi_ring_state *rs, u64 new_widx)
> +{
> +	lockdep_assert_held(&rs->lock);
> +	*rs->write_index_ptr = cpu_to_le64(rs->write_index = new_widx);

Does it need WRITE_ONCE() ? you load_ridx() use READ_ONCE. I just not sure

suppose doorbell will drain write buffer, most likely it is okay without
WRITE_ONCE()

Frank
>