From: Wei Huang <wei.huang2@amd.com>
To: <dmaengine@vger.kernel.org>
Cc: <vkoul@kernel.org>, <Frank.Li@kernel.org>, <shuah@kernel.org>,
<nathan.lynch@amd.com>, <wei.huang2@amd.com>,
<mario.limonciello@amd.com>, <Stephen.Bates@amd.com>,
<tycho@kernel.org>, <suravee.suthikulpanit@amd.com>,
<rientjes@google.com>, <John.Kariuki@amd.com>, <jic23@kernel.org>,
<weixugc@google.com>, <bhelgaas@google.com>,
<Shyam.Iyer@dell.com>, <linux-kernel@vger.kernel.org>,
<linux-kselftest@vger.kernel.org>, <linux-pci@vger.kernel.org>
Subject: [PATCH v1 27/44] dmaengine: sdxi: support suspend and resume
Date: Thu, 19 Nov 2026 14:23:03 -0600 [thread overview]
Message-ID: <20261119202321.1734355-28-wei.huang2@amd.com> (raw)
In-Reply-To: <20261119202321.1734355-1-wei.huang2@amd.com>
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@amd.com>
---
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, ®, 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, ®, 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, ®, 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, ®, 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
next prev parent reply other threads:[~2026-11-19 20:29 UTC|newest]
Thread overview: 45+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-19 20:22 [PATCH v1 00/44] dmaengine: sdxi: add userspace control and management support Wei Huang
2026-11-19 20:22 ` [PATCH v1 01/44] dmaengine: sdxi: cache hardware version for feature gating Wei Huang
2026-11-19 20:22 ` [PATCH v1 02/44] dmaengine: sdxi: define key and error MMIO registers Wei Huang
2026-11-19 20:22 ` [PATCH v1 03/44] dmaengine: sdxi: define SDXI hardware layouts Wei Huang
2026-11-19 20:22 ` [PATCH v1 04/44] dmaengine: sdxi: encode admin descriptors Wei Huang
2026-11-19 20:22 ` [PATCH v1 05/44] dmaengine: sdxi: support timeout-aware completion waits Wei Huang
2026-11-19 20:22 ` [PATCH v1 06/44] dmaengine: sdxi: support the full context table hierarchy Wei Huang
2026-11-19 20:22 ` [PATCH v1 07/44] dmaengine: sdxi: implement synchronous admin operations Wei Huang
2026-11-19 20:22 ` [PATCH v1 08/44] dmaengine: sdxi: add core RKey table management Wei Huang
2026-11-19 20:22 ` [PATCH v1 09/44] dmaengine: sdxi: handle hardware error logs Wei Huang
2026-11-19 20:22 ` [PATCH v1 10/44] dmaengine: sdxi: separate context and submission resources Wei Huang
2026-11-19 20:22 ` [PATCH v1 11/44] dmaengine: sdxi: support userspace context lifetimes Wei Huang
2026-11-19 20:22 ` [PATCH v1 12/44] dmaengine: sdxi: route context interrupts to eventfd Wei Huang
2026-11-19 20:22 ` [PATCH v1 13/44] dmaengine: sdxi: kill user contexts on fatal errors Wei Huang
2026-11-19 20:22 ` [PATCH v1 14/44] dmaengine: sdxi: define the ioctl UAPI surface Wei Huang
2026-11-19 20:22 ` [PATCH v1 15/44] dmaengine: sdxi: add internal ioctl definitions Wei Huang
2026-11-19 20:22 ` [PATCH v1 16/44] dmaengine: sdxi: register core character devices Wei Huang
2026-11-19 20:22 ` [PATCH v1 17/44] dmaengine: sdxi: implement fixed-size ioctl dispatch Wei Huang
2026-11-19 20:22 ` [PATCH v1 18/44] dmaengine: sdxi: implement userspace context file operations Wei Huang
2026-11-19 20:22 ` [PATCH v1 19/44] dmaengine: sdxi: validate and copy key ioctl payloads Wei Huang
2026-11-19 20:22 ` [PATCH v1 20/44] dmaengine: sdxi: implement RKey management ioctls Wei Huang
2026-11-19 20:22 ` [PATCH v1 21/44] dmaengine: sdxi: implement AKey " Wei Huang
2026-11-19 20:22 ` [PATCH v1 22/44] dmaengine: sdxi: expose operation-group discovery Wei Huang
2026-11-19 20:22 ` [PATCH v1 23/44] dmaengine: sdxi: implement typed vendor admin transport Wei Huang
2026-11-19 20:23 ` [PATCH v1 24/44] dmaengine: sdxi: expose character device attributes Wei Huang
2026-11-19 20:23 ` [PATCH v1 25/44] dmaengine: sdxi: add PF and VF device naming Wei Huang
2026-11-19 20:23 ` [PATCH v1 26/44] dmaengine: sdxi: add SDXI trace events Wei Huang
2026-11-19 20:23 ` Wei Huang [this message]
2026-11-19 20:23 ` [PATCH v1 28/44] dmaengine: sdxi: amd: define QoS request formats Wei Huang
2026-11-19 20:23 ` [PATCH v1 29/44] dmaengine: sdxi: amd: add QoS validation scaffolding Wei Huang
2026-11-19 20:23 ` [PATCH v1 30/44] dmaengine: sdxi: amd: build QoS admin descriptors Wei Huang
2026-11-19 20:23 ` [PATCH v1 31/44] dmaengine: sdxi: amd: prevalidate QoS operations Wei Huang
2026-11-19 20:23 ` [PATCH v1 32/44] dmaengine: sdxi: amd: execute QoS vendor operations Wei Huang
2026-11-19 20:23 ` [PATCH v1 33/44] dmaengine: sdxi: amd: register QoS vendor handler Wei Huang
2026-11-19 20:23 ` [PATCH v1 34/44] dmaengine: sdxi: amd: test QoS validation with KUnit Wei Huang
2026-11-19 20:23 ` [PATCH v1 35/44] selftests: sdxi: add build scaffold Wei Huang
2026-11-19 20:23 ` [PATCH v1 36/44] selftests: sdxi: add shared descriptor and context helpers Wei Huang
2026-11-19 20:23 ` [PATCH v1 37/44] selftests: sdxi: test context creation Wei Huang
2026-11-19 20:23 ` [PATCH v1 38/44] selftests: sdxi: test NOP descriptor submission Wei Huang
2026-11-19 20:23 ` [PATCH v1 39/44] selftests: sdxi: test copy submission and ring wrap Wei Huang
2026-11-19 20:23 ` [PATCH v1 40/44] selftests: sdxi: exercise dataplane error paths Wei Huang
2026-11-19 20:23 ` [PATCH v1 41/44] selftests: sdxi: test device ioctls Wei Huang
2026-11-19 20:23 ` [PATCH v1 42/44] selftests: sdxi: test vendor admin ioctls Wei Huang
2026-11-19 20:23 ` [PATCH v1 43/44] selftests: sdxi: test RKey ioctls Wei Huang
2026-11-19 20:23 ` [PATCH v1 44/44] MAINTAINERS: cover SDXI UAPI, vendor files, and selftests Wei Huang
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261119202321.1734355-28-wei.huang2@amd.com \
--to=wei.huang2@amd.com \
--cc=Frank.Li@kernel.org \
--cc=John.Kariuki@amd.com \
--cc=Shyam.Iyer@dell.com \
--cc=Stephen.Bates@amd.com \
--cc=bhelgaas@google.com \
--cc=dmaengine@vger.kernel.org \
--cc=jic23@kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-kselftest@vger.kernel.org \
--cc=linux-pci@vger.kernel.org \
--cc=mario.limonciello@amd.com \
--cc=nathan.lynch@amd.com \
--cc=rientjes@google.com \
--cc=shuah@kernel.org \
--cc=suravee.suthikulpanit@amd.com \
--cc=tycho@kernel.org \
--cc=vkoul@kernel.org \
--cc=weixugc@google.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®