Re: [PATCH v4 20/25] dmaengine: sdxi: Add client context release with update and sync

[Frank Li <Frank.li@oss.nxp.com>]

On Tue, Nov 03, 2026 at 08:50:01PM -0600, Nathan Lynch wrote:
> Invalidate an unused, stopped client context and synchronize hardware
> caches before freeing its resources. Add administrative update, reservation, and
> completion-polling helpers.
>
> Claim completion-status storage before making an irrevocable ring
> reservation. Return the claim if reservation fails, and release it after
> consuming a terminal result. A timeout leaves hardware ownership
> unresolved, so retain that block in the administrative pool until context
> teardown, even if the device writes its terminal signal later. Repeated
> timeouts can exhaust the pool, causing further claims to time out rather
> than reuse outstanding status blocks.
>
> If update or synchronization fails, retain the context and its ID for
> cleanup after function shutdown. Device-wide teardown frees clients after
> the best-effort function stop/reset path without submitting additional
> administrative operations.
>
> Signed-off-by: Nathan Lynch <nathan.lynch@amd.com>
> ---
>  drivers/dma/sdxi/context.c | 128 +++++++++++++++++++++++++++++++++++++++++++++
>  drivers/dma/sdxi/context.h |   6 +++
>  2 files changed, 134 insertions(+)
>
> diff --git a/drivers/dma/sdxi/context.c b/drivers/dma/sdxi/context.c
> index 679c5cfab19d..5ca99ac8080c 100644
> --- a/drivers/dma/sdxi/context.c
> +++ b/drivers/dma/sdxi/context.c
> @@ -106,6 +106,78 @@ static struct sdxi_cxt *sdxi_alloc_cxt(struct sdxi_dev *sdxi)
>  	return_ptr(cxt);
>  }
>
> +/* Claim completion storage before making a ring reservation irrevocable. */
> +static int sdxi_cxt_reserve(struct sdxi_cxt *cxt, size_t nr,
> +			    struct sdxi_ring_resv *resv,
> +			    struct sdxi_completion *comp)
> +{
> +	int err;
> +
> +	err = sdxi_cst_pool_get_wait(cxt->cst_pool, comp);
> +	if (err)
> +		return err;
> +
> +	err = sdxi_ring_reserve(cxt->ring_state, nr, resv);
> +	if (err)
> +		sdxi_cst_pool_put(cxt->cst_pool, comp->cst_blk);
> +
> +	return err;
> +}
> +
> +static int sdxi_cxt_poll_completion(struct sdxi_cxt *cxt,
> +				    const struct sdxi_completion *comp)
> +{
> +	int err = sdxi_cst_blk_poll(comp->cst_blk);
> +
> +	/*
> +	 * A timeout does not end hardware ownership. Keep these administrative
> +	 * blocks claimed until context teardown, even if they complete later.
> +	 * Repeated timeouts can exhaust the pool; allocation then times out too.
> +	 */
> +	if (err != -ETIMEDOUT)
> +		sdxi_cst_pool_put(cxt->cst_pool, comp->cst_blk);
> +	sdxi_ring_wake_up(cxt->ring_state);
> +
> +	return err;
> +}
> +
> +/*
> + * Signal the function that a client context's control structures have
> + * been modified so it discards any privately cached copies of them.
> + * DSC_SYNC.CXT is required before the operation can be considered
> + * complete.
> + */
> +static int sdxi_cxt_update(const struct sdxi_cxt *cxt)
> +{
> +	struct sdxi_cxt *adm = to_admin_cxt(cxt);
> +	struct sdxi_slot upd, sync;
> +	struct sdxi_ring_resv resv;
> +	struct sdxi_completion comp;
> +	int err;
> +
> +	might_sleep();
> +
> +	err = sdxi_cxt_reserve(adm, 2, &resv, &comp);
> +	if (err)
> +		return err;
> +
> +	upd = sdxi_ring_resv_slot(&resv, 0);
> +	sync = sdxi_ring_resv_slot(&resv, 1);
> +
> +	sdxi_encode_cxt_upd(sdxi_slot_desc(upd), &(const struct sdxi_cxt_upd) {
> +			.level = SDXI_CXT_UPD_LVL_L1,
> +			.range = sdxi_cxt_range_single(cxt->id),
> +		});
> +	sdxi_encode_sync(sdxi_slot_desc(sync), &(const struct sdxi_sync) {
> +			.filter = SDXI_SYNC_FLT_CXT,
> +			.range = sdxi_cxt_range_single(cxt->id),
> +		});
> +	sdxi_cxt_submit(adm, upd, NULL, 0);
> +	sdxi_cxt_submit(adm, sync, &comp, SDXI_CXT_SUBMIT_KICK);
> +
> +	return sdxi_cxt_poll_completion(adm, &comp);
> +}
> +
>  struct sdxi_cxt_ctl_cfg {
>  	dma_addr_t ds_ring_ptr;
>  	dma_addr_t cxt_sts_ptr;
> @@ -144,6 +216,16 @@ static int configure_cxt_ctl(struct sdxi_cxt_ctl *ctl, const struct sdxi_cxt_ctl
>  	return 0;
>  }
>
> +static void invalidate_cxt_ctl(struct sdxi_cxt_ctl *ctl)
> +{
> +	u64 ds_ring_ptr = le64_to_cpu(ctl->ds_ring_ptr);
> +
> +	FIELD_MODIFY(SDXI_CXT_CTL_VL, &ds_ring_ptr, 0);
> +	WRITE_ONCE(ctl->ds_ring_ptr, cpu_to_le64(ds_ring_ptr));
> +	dma_wmb();

all memory barrier need comments.

Frank
> +	*ctl = (typeof(*ctl)) { 0 };
> +}
> +
>  /*
>   * Logical representation of CXT_L1_ENT subfields.
>   */
> @@ -194,6 +276,17 @@ static int configure_L1_entry(struct sdxi_cxt_L1_ent *ent,
>  	return 0;
>  }
>
> +static void invalidate_L1_entry(struct sdxi_cxt_L1_ent *ent)
> +{
> +	u64 cxt_ctl_ptr = le64_to_cpu(ent->cxt_ctl_ptr);
> +
> +	FIELD_MODIFY(SDXI_CXT_L1_ENT_VL, &cxt_ctl_ptr, 0);
> +	WRITE_ONCE(ent->cxt_ctl_ptr, cpu_to_le64(cxt_ctl_ptr));
> +	dma_wmb();
> +	*ent = (typeof(*ent)) { 0 };
> +}
> +
> +
>  /* Publish the context control block and L1 entry to hardware. */
>  static int sdxi_publish_cxt(const struct sdxi_cxt *cxt)
>  {
> @@ -398,3 +491,38 @@ void sdxi_cxt_submit(struct sdxi_cxt *cxt, struct sdxi_slot slot,
>  	if (flags & SDXI_CXT_SUBMIT_KICK)
>  		sdxi_cxt_kick(cxt);
>  }
> +
> +/*
> + * Release an unused, stopped client context. On update/sync failure the
> + * context remains owned by the device and its resources are retained for
> + * cleanup after function shutdown; the caller must not reuse it.
> + */
> +int sdxi_cxt_exit(struct sdxi_cxt *cxt)
> +{
> +	struct sdxi_dev *sdxi = cxt->sdxi;
> +	struct sdxi_cxt_L1_ent *ent;
> +	u8 state;
> +	int err;
> +
> +	if (WARN_ON(sdxi_cxt_is_admin(cxt)))
> +		return -EINVAL;
> +
> +	state = FIELD_GET(SDXI_CXT_STS_STATE, READ_ONCE(cxt->sq->cxt_sts.state));
> +	if (state != CXTV_STOP_SW && state != CXTV_STOP_FN && state != CXTV_ERR_FN)
> +		return -EBUSY;
> +
> +	ent = &sdxi->L1_table->entry[ID_TO_L1_INDEX(cxt->id)];
> +	invalidate_L1_entry(ent);
> +	invalidate_cxt_ctl(cxt->cxt_ctl);
> +
> +	err = sdxi_cxt_update(cxt);
> +	if (err) {
> +		dev_err(sdxi->dev,
> +			"context %u release failed (%d), retaining resources until function shutdown\n",
> +			cxt->id, err);
> +		return err;
> +	}
> +
> +	sdxi_free_cxt(cxt);
> +	return 0;
> +}
> diff --git a/drivers/dma/sdxi/context.h b/drivers/dma/sdxi/context.h
> index f048e298f6de..71eef2c6243b 100644
> --- a/drivers/dma/sdxi/context.h
> +++ b/drivers/dma/sdxi/context.h
> @@ -52,6 +52,12 @@ struct sdxi_cxt {
>
>  int sdxi_admin_cxt_init(struct sdxi_dev *sdxi);
>  struct sdxi_cxt *sdxi_cxt_new(struct sdxi_dev *sdxi);
> +/*
> + * Caller must exclude users and stop the client before release. An update or
> + * synchronization failure retains the invalidated context for device teardown;
> + * the caller must not reuse it.
> + */
> +int sdxi_cxt_exit(struct sdxi_cxt *cxt);
>  void sdxi_client_cxts_exit(struct sdxi_dev *sdxi);
>
>  enum sdxi_submit_flags {
>
> --
> 2.56.0
>