[PATCH v1 27/44] dmaengine: sdxi: support suspend and resume

From: Wei Huang

Date: Thu Nov 19 2026 - 15:31:24 EST


During suspend, save function control state, stop the function with
error interrupts disabled. Similarly restore context tables, RKeys,
error logging, the admin context, and previously running client contexts
on resume. Keep PCI responsible for wiring the core PM callbacks.

Signed-off-by: Wei Huang <wei.huang2@xxxxxxx>
---
drivers/dma/sdxi/context.c | 11 +++
drivers/dma/sdxi/context.h | 1 +
drivers/dma/sdxi/device.c | 186 +++++++++++++++++++++++++++++++++++++
drivers/dma/sdxi/error.c | 56 +++++++++++
drivers/dma/sdxi/error.h | 2 +
drivers/dma/sdxi/keys.c | 14 +++
drivers/dma/sdxi/keys.h | 1 +
drivers/dma/sdxi/pci.c | 5 +
drivers/dma/sdxi/sdxi.h | 8 ++
9 files changed, 284 insertions(+)

diff --git a/drivers/dma/sdxi/context.c b/drivers/dma/sdxi/context.c
index 91c2837bbe82..12502021600d 100644
--- a/drivers/dma/sdxi/context.c
+++ b/drivers/dma/sdxi/context.c
@@ -1245,6 +1245,17 @@ int sdxi_cxt_notify_mm_release(struct sdxi_cxt *cxt)
return ret;
}

+void sdxi_cxt_resume_cleanup(struct sdxi_cxt *cxt)
+{
+ if (!cxt)
+ return;
+
+ mutex_lock(&cxt->cleanup_lock);
+ if (sdxi_cxt_is_user(cxt) && sdxi_cxt_cleanup_requested(cxt))
+ sdxi_cxt_queue_cleanup_locked(cxt, 0);
+ mutex_unlock(&cxt->cleanup_lock);
+}
+
void sdxi_cxt_vma_open(struct sdxi_cxt *cxt)
{
if (!cxt)
diff --git a/drivers/dma/sdxi/context.h b/drivers/dma/sdxi/context.h
index 22a33291020f..c3f3353874a0 100644
--- a/drivers/dma/sdxi/context.h
+++ b/drivers/dma/sdxi/context.h
@@ -116,6 +116,7 @@ void sdxi_cxt_kill(struct sdxi_cxt *cxt);
void sdxi_cxt_kill_stopped(struct sdxi_cxt *cxt);
void sdxi_cxt_release_user_handle(struct sdxi_cxt *cxt);
int sdxi_cxt_notify_mm_release(struct sdxi_cxt *cxt);
+void sdxi_cxt_resume_cleanup(struct sdxi_cxt *cxt);
void sdxi_cxt_vma_open(struct sdxi_cxt *cxt);
int sdxi_cxt_vma_acquire(struct sdxi_cxt *cxt);
void sdxi_cxt_vma_close(struct sdxi_cxt *cxt);
diff --git a/drivers/dma/sdxi/device.c b/drivers/dma/sdxi/device.c
index cb7056916c3d..f0e447e7a81b 100644
--- a/drivers/dma/sdxi/device.c
+++ b/drivers/dma/sdxi/device.c
@@ -22,6 +22,7 @@
#include <linux/time.h>
#include <linux/xarray.h>

+#include "admin.h"
#include "context.h"
#include "dma.h"
#include "error.h"
@@ -526,6 +527,190 @@ static void sdxi_dev_release(struct device *chardev)
kfree(sdxi);
}

+static void sdxi_restore_admin_cxt(struct sdxi_dev *sdxi)
+{
+ struct sdxi_cxt *adm = sdxi->admin_cxt;
+ u64 doorbell;
+
+ if (!adm || !adm->sq)
+ return;
+
+ WRITE_ONCE(adm->sq->cxt_sts.state,
+ FIELD_PREP(SDXI_CXT_STS_STATE, CXTV_RUN));
+ dma_wmb();
+ doorbell = le64_to_cpu(READ_ONCE(adm->sq->write_index));
+ writeq(doorbell, adm->sq->doorbell);
+}
+
+static int sdxi_restart_contexts(struct sdxi_dev *sdxi)
+{
+ struct sdxi_cxt *entry;
+ unsigned long index;
+ int result = 0;
+
+ xa_for_each(&sdxi->client_cxts, index, entry) {
+ struct sdxi_cxt *cxt;
+ int ret;
+
+ if (!entry)
+ continue;
+ cxt = sdxi_cxt_get_by_id(sdxi, index);
+ if (!cxt)
+ continue;
+
+ mutex_lock(&cxt->cleanup_lock);
+ if (cxt->fatal || cxt->handle_closed || cxt->mm_dead ||
+ cxt->cleanup_stopping ||
+ cxt->resources_released || !cxt->started) {
+ mutex_unlock(&cxt->cleanup_lock);
+ sdxi_cxt_put(cxt);
+ continue;
+ }
+
+ ret = sdxi_adm_start_cxt(cxt);
+ mutex_unlock(&cxt->cleanup_lock);
+ if (ret) {
+ dev_err(sdxi->dev, "failed to restart context %u: %d\n",
+ cxt->id, ret);
+ sdxi_cxt_kill(cxt);
+ result = ret;
+ }
+ sdxi_cxt_put(cxt);
+ }
+
+ return result;
+}
+
+static void sdxi_resume_cleanup_contexts(struct sdxi_dev *sdxi)
+{
+ struct sdxi_cxt *entry;
+ unsigned long index;
+
+ xa_for_each(&sdxi->client_cxts, index, entry) {
+ struct sdxi_cxt *cxt;
+
+ if (!entry)
+ continue;
+ cxt = sdxi_cxt_get_by_id(sdxi, index);
+ if (!cxt)
+ continue;
+ sdxi_cxt_resume_cleanup(cxt);
+ sdxi_cxt_put(cxt);
+ }
+}
+
+int sdxi_suspend(struct device *dev)
+{
+ struct sdxi_dev *sdxi = dev_get_drvdata(dev);
+ int ret;
+
+ if (!sdxi)
+ return -ENODEV;
+
+ mutex_lock(&sdxi->pm_lock);
+ if (sdxi->pm_suspended) {
+ ret = 0;
+ goto out_unlock;
+ }
+ down_write(&sdxi->state_lock);
+ if (!sdxi->online) {
+ up_write(&sdxi->state_lock);
+ ret = -EIO;
+ goto out_unlock;
+ }
+ sdxi->online = false;
+
+ mutex_lock(&sdxi->reg_lock);
+ sdxi->pm_ctl0 = sdxi_read64(sdxi, SDXI_MMIO_CTL0);
+ sdxi->pm_ctl2 = sdxi_read64(sdxi, SDXI_MMIO_CTL2);
+ mutex_unlock(&sdxi->reg_lock);
+ sdxi->pm_fn_was_active = sdxi_dev_gsv(sdxi) == SDXI_GSV_ACTIVE;
+
+ sdxi_error_suspend(sdxi);
+ ret = sdxi_dev_stop(sdxi);
+ if (ret) {
+ /* Recovery failed; keep users out and fence DMA. */
+ sdxi_dev_force_quiesce(sdxi);
+ } else {
+ sdxi->pm_suspended = true;
+ }
+ up_write(&sdxi->state_lock);
+
+out_unlock:
+ mutex_unlock(&sdxi->pm_lock);
+ return ret;
+}
+EXPORT_SYMBOL_NS_GPL(sdxi_suspend, "SDXI");
+
+int sdxi_resume(struct device *dev)
+{
+ struct sdxi_dev *sdxi = dev_get_drvdata(dev);
+ u64 cxt_l2;
+ u64 ctl0;
+ bool error_resumed = false;
+ bool make_online = false;
+ bool state_locked = false;
+ int ret = 0;
+
+ if (!sdxi)
+ return -ENODEV;
+
+ mutex_lock(&sdxi->pm_lock);
+ if (!sdxi->pm_suspended)
+ goto out_unlock;
+ down_write(&sdxi->state_lock);
+ state_locked = true;
+
+ ctl0 = sdxi->pm_ctl0;
+ FIELD_MODIFY(SDXI_MMIO_CTL0_FN_GSR, &ctl0, SDXI_GSRV_STOP_SF);
+ mutex_lock(&sdxi->reg_lock);
+ sdxi_write64(sdxi, SDXI_MMIO_CTL0, ctl0);
+ mutex_unlock(&sdxi->reg_lock);
+
+ ret = sdxi_dev_stop(sdxi);
+ if (ret)
+ goto resume_failed;
+
+ mutex_lock(&sdxi->reg_lock);
+ sdxi_write64(sdxi, SDXI_MMIO_CTL2, sdxi->pm_ctl2);
+ mutex_unlock(&sdxi->reg_lock);
+ cxt_l2 = FIELD_PREP(SDXI_MMIO_CXT_L2_PTR,
+ sdxi->L2_dma >> ilog2(SZ_4K));
+ sdxi_write64(sdxi, SDXI_MMIO_CXT_L2, cxt_l2);
+ sdxi_keys_resume(sdxi);
+ sdxi_error_resume(sdxi);
+ error_resumed = true;
+
+ if (sdxi->pm_fn_was_active) {
+ ret = sdxi_dev_start(sdxi);
+ if (ret)
+ goto resume_failed;
+ sdxi_restore_admin_cxt(sdxi);
+ ret = sdxi_restart_contexts(sdxi);
+ if (ret)
+ goto resume_failed;
+ }
+ sdxi->pm_suspended = false;
+ sdxi->online = true;
+ make_online = true;
+ goto out_unlock;
+
+resume_failed:
+ if (error_resumed)
+ sdxi_error_suspend(sdxi);
+ if (sdxi_dev_stop(sdxi))
+ sdxi_dev_force_quiesce(sdxi);
+
+out_unlock:
+ if (state_locked)
+ up_write(&sdxi->state_lock);
+ mutex_unlock(&sdxi->pm_lock);
+ if (make_online)
+ sdxi_resume_cleanup_contexts(sdxi);
+ return ret;
+}
+EXPORT_SYMBOL_NS_GPL(sdxi_resume, "SDXI");
+
int sdxi_register(struct device *dev, const struct sdxi_bus_ops *ops)
{
struct sdxi_dev *sdxi;
@@ -546,6 +731,7 @@ int sdxi_register(struct device *dev, const struct sdxi_bus_ops *ops)
mutex_init(&sdxi->reg_lock);
mutex_init(&sdxi->admin_lock);
mutex_init(&sdxi->rkey_lock);
+ mutex_init(&sdxi->pm_lock);
sdxi->error_irq = -1;
sdxi->minor = -1;
dev_set_drvdata(dev, sdxi);
diff --git a/drivers/dma/sdxi/error.c b/drivers/dma/sdxi/error.c
index d4c1e64dbf2b..ae649985a424 100644
--- a/drivers/dma/sdxi/error.c
+++ b/drivers/dma/sdxi/error.c
@@ -313,3 +313,59 @@ void sdxi_error_exit(struct sdxi_dev *sdxi)
sdxi->err_log = NULL;
sdxi->err_log_dma = 0;
}
+
+void sdxi_error_suspend(struct sdxi_dev *sdxi)
+{
+ u64 reg;
+
+ if (!sdxi->err_log)
+ return;
+
+ disable_irq(sdxi->error_irq);
+ sdxi_write64(sdxi, SDXI_MMIO_ERR_CFG, 0);
+
+ mutex_lock(&sdxi->reg_lock);
+ reg = sdxi_read64(sdxi, SDXI_MMIO_ERR_CTL);
+ FIELD_MODIFY(SDXI_MMIO_ERR_CTL_EN, &reg, 0);
+ sdxi_write64(sdxi, SDXI_MMIO_ERR_CTL, reg);
+
+ reg = sdxi_read64(sdxi, SDXI_MMIO_CTL0);
+ FIELD_MODIFY(SDXI_MMIO_CTL0_FN_ERR_INTR_EN, &reg, 0);
+ sdxi_write64(sdxi, SDXI_MMIO_CTL0, reg);
+ mutex_unlock(&sdxi->reg_lock);
+}
+
+void sdxi_error_resume(struct sdxi_dev *sdxi)
+{
+ unsigned int size_order;
+ u64 reg;
+
+ if (!sdxi->err_log)
+ return;
+
+ sdxi_write64(sdxi, SDXI_MMIO_ERR_CFG, 0);
+ sdxi_write64(sdxi, SDXI_MMIO_ERR_STS,
+ SDXI_MMIO_ERR_STS_STS_BIT |
+ SDXI_MMIO_ERR_STS_OVF_BIT |
+ SDXI_MMIO_ERR_STS_ERR_BIT);
+ sdxi_write64(sdxi, SDXI_MMIO_ERR_WRT, 0);
+ sdxi_write64(sdxi, SDXI_MMIO_ERR_RD, 0);
+
+ mutex_lock(&sdxi->reg_lock);
+ reg = sdxi_read64(sdxi, SDXI_MMIO_ERR_CTL);
+ FIELD_MODIFY(SDXI_MMIO_ERR_CTL_EN, &reg, 1);
+ sdxi_write64(sdxi, SDXI_MMIO_ERR_CTL, reg);
+
+ reg = sdxi_read64(sdxi, SDXI_MMIO_CTL0);
+ FIELD_MODIFY(SDXI_MMIO_CTL0_FN_ERR_INTR_EN, &reg, 1);
+ sdxi_write64(sdxi, SDXI_MMIO_CTL0, reg);
+ mutex_unlock(&sdxi->reg_lock);
+
+ size_order = ilog2(SDXI_ERRLOG_SIZE) - ilog2(SZ_4K);
+ reg = FIELD_PREP(SDXI_MMIO_ERR_CFG_PTR,
+ sdxi->err_log_dma >> ilog2(SZ_4K)) |
+ FIELD_PREP(SDXI_MMIO_ERR_CFG_SZ, size_order) |
+ SDXI_MMIO_ERR_CFG_EN;
+ sdxi_write64(sdxi, SDXI_MMIO_ERR_CFG, reg);
+ enable_irq(sdxi->error_irq);
+}
diff --git a/drivers/dma/sdxi/error.h b/drivers/dma/sdxi/error.h
index 756a4fe45158..866117559aa3 100644
--- a/drivers/dma/sdxi/error.h
+++ b/drivers/dma/sdxi/error.h
@@ -12,5 +12,7 @@ struct sdxi_dev;

int sdxi_error_init(struct sdxi_dev *sdxi);
void sdxi_error_exit(struct sdxi_dev *sdxi);
+void sdxi_error_suspend(struct sdxi_dev *sdxi);
+void sdxi_error_resume(struct sdxi_dev *sdxi);

#endif /* DMA_SDXI_ERROR_H */
diff --git a/drivers/dma/sdxi/keys.c b/drivers/dma/sdxi/keys.c
index 0d570daefd34..8397d575c06a 100644
--- a/drivers/dma/sdxi/keys.c
+++ b/drivers/dma/sdxi/keys.c
@@ -289,6 +289,20 @@ void sdxi_keys_exit(struct sdxi_dev *sdxi)
sdxi->rkey_cap = false;
}

+void sdxi_keys_resume(struct sdxi_dev *sdxi)
+{
+ u64 reg;
+
+ if (!sdxi->rkey_cap || !sdxi->rkey_table)
+ return;
+
+ reg = FIELD_PREP(SDXI_MMIO_RKEY_PTR,
+ sdxi->rkey_table_dma >> ilog2(SZ_4K)) |
+ FIELD_PREP(SDXI_MMIO_RKEY_SZ, sdxi->rkey_order) |
+ SDXI_MMIO_RKEY_EN;
+ sdxi_write64(sdxi, SDXI_MMIO_RKEY, reg);
+}
+
int sdxi_ioctl_get_rkey_list(struct file *file, struct sdxi_file *sf,
void *data)
{
diff --git a/drivers/dma/sdxi/keys.h b/drivers/dma/sdxi/keys.h
index 6e36527b610a..775dd381e3f3 100644
--- a/drivers/dma/sdxi/keys.h
+++ b/drivers/dma/sdxi/keys.h
@@ -16,6 +16,7 @@ struct sdxi_file;

int sdxi_keys_init(struct sdxi_dev *sdxi, u64 cap1);
void sdxi_keys_exit(struct sdxi_dev *sdxi);
+void sdxi_keys_resume(struct sdxi_dev *sdxi);
int sdxi_ioctl_get_rkey_list(struct file *file, struct sdxi_file *sf,
void *data);
int sdxi_ioctl_get_rkeys(struct file *file, struct sdxi_file *sf, void *data);
diff --git a/drivers/dma/sdxi/pci.c b/drivers/dma/sdxi/pci.c
index abef318cfd7c..fa080dc004ab 100644
--- a/drivers/dma/sdxi/pci.c
+++ b/drivers/dma/sdxi/pci.c
@@ -221,12 +221,17 @@ static const struct pci_device_id sdxi_id_table[] = {
};
MODULE_DEVICE_TABLE(pci, sdxi_id_table);

+static const struct dev_pm_ops sdxi_pm_ops = {
+ SYSTEM_SLEEP_PM_OPS(sdxi_suspend, sdxi_resume)
+};
+
static struct pci_driver sdxi_driver = {
.name = "sdxi",
.id_table = sdxi_id_table,
.probe = sdxi_pci_probe,
.remove = sdxi_pci_remove,
.sriov_configure = pci_sriov_configure_simple,
+ .driver.pm = pm_sleep_ptr(&sdxi_pm_ops),
};

MODULE_IMPORT_NS("SDXI");
diff --git a/drivers/dma/sdxi/sdxi.h b/drivers/dma/sdxi/sdxi.h
index 93b4eb80358c..ce0959bbed90 100644
--- a/drivers/dma/sdxi/sdxi.h
+++ b/drivers/dma/sdxi/sdxi.h
@@ -146,6 +146,12 @@ struct sdxi_dev {
bool online;
struct rw_semaphore state_lock; /* online state and user operations */

+ struct mutex pm_lock; /* suspend and resume serialization */
+ bool pm_suspended;
+ bool pm_fn_was_active;
+ u64 pm_ctl0;
+ u64 pm_ctl2;
+
const struct sdxi_bus_ops *bus_ops;
};

@@ -202,6 +208,8 @@ void sdxi_unregister(struct device *dev);
bool sdxi_dev_in_error(const struct sdxi_dev *sdxi);
void sdxi_dev_force_quiesce(struct sdxi_dev *sdxi);
void sdxi_dev_fail(struct sdxi_dev *sdxi);
+int sdxi_suspend(struct device *dev);
+int sdxi_resume(struct device *dev);
int sdxi_chardev_init(void);
void sdxi_chardev_exit(void);
int sdxi_chardev_register(struct sdxi_dev *sdxi);
--
2.56.1