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 17/44] dmaengine: sdxi: implement fixed-size ioctl dispatch
Date: Thu, 19 Nov 2026 14:22:53 -0600 [thread overview]
Message-ID: <20261119202321.1734355-18-wei.huang2@amd.com> (raw)
In-Reply-To: <20261119202321.1734355-1-wei.huang2@amd.com>
Add the final ioctl table and access-class checks, with unsupported
rows for features that are not wired yet. Implement UAPI discovery,
device information UAPI, and bounded device attributes while advertising
only those alive capabilities.
Signed-off-by: Wei Huang <wei.huang2@amd.com>
---
drivers/dma/sdxi/device.c | 9 +-
drivers/dma/sdxi/error.c | 4 +
drivers/dma/sdxi/ioctl.c | 413 +++++++++++++++++++++++++++++++++++++-
drivers/dma/sdxi/ioctl.h | 1 -
drivers/dma/sdxi/sdxi.h | 1 +
5 files changed, 420 insertions(+), 8 deletions(-)
diff --git a/drivers/dma/sdxi/device.c b/drivers/dma/sdxi/device.c
index ff5b5d932bc9..b5960619d511 100644
--- a/drivers/dma/sdxi/device.c
+++ b/drivers/dma/sdxi/device.c
@@ -110,12 +110,14 @@ static const unsigned long gsv_transition_timeout_us = USEC_PER_SEC * 1;
static void sdxi_write_fn_gsr(struct sdxi_dev *sdxi, enum sdxi_fn_gsr cmd)
{
- u64 ctl0 = sdxi_read64(sdxi, SDXI_MMIO_CTL0);
+ u64 ctl0;
+ mutex_lock(&sdxi->reg_lock);
+ ctl0 = sdxi_read64(sdxi, SDXI_MMIO_CTL0);
dev_dbg(sdxi->dev, "MMIO_CTL0.fn_gsr = %#x (%s)\n", cmd, gsr_str(cmd));
-
FIELD_MODIFY(SDXI_MMIO_CTL0_FN_GSR, &ctl0, cmd);
sdxi_write64(sdxi, SDXI_MMIO_CTL0, ctl0);
+ mutex_unlock(&sdxi->reg_lock);
}
/*
@@ -319,11 +321,13 @@ static int sdxi_fn_prepare(struct sdxi_dev *sdxi)
if (err)
return err;
+ mutex_lock(&sdxi->reg_lock);
ctl0 = sdxi_read64(sdxi, SDXI_MMIO_CTL0);
FIELD_MODIFY(SDXI_MMIO_CTL0_FN_ERR_INTR_EN, &ctl0, 0);
FIELD_MODIFY(SDXI_MMIO_CTL0_FN_PASID_VL, &ctl0, 0);
FIELD_MODIFY(SDXI_MMIO_CTL0_FN_PASID, &ctl0, 0);
sdxi_write64(sdxi, SDXI_MMIO_CTL0, ctl0);
+ mutex_unlock(&sdxi->reg_lock);
/* Restore CTL2's reset limits, with operation groups disabled. */
cap1 = sdxi_read64(sdxi, SDXI_MMIO_CAP1);
@@ -534,6 +538,7 @@ int sdxi_register(struct device *dev, const struct sdxi_bus_ops *ops)
ida_init(&sdxi->vectors);
xa_init_flags(&sdxi->client_cxts, XA_FLAGS_ALLOC1);
mutex_init(&sdxi->cxt_lock);
+ mutex_init(&sdxi->reg_lock);
mutex_init(&sdxi->admin_lock);
mutex_init(&sdxi->rkey_lock);
sdxi->error_irq = -1;
diff --git a/drivers/dma/sdxi/error.c b/drivers/dma/sdxi/error.c
index 4d8607b3bbec..d4c1e64dbf2b 100644
--- a/drivers/dma/sdxi/error.c
+++ b/drivers/dma/sdxi/error.c
@@ -267,6 +267,7 @@ int sdxi_error_init(struct sdxi_dev *sdxi)
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);
@@ -274,6 +275,7 @@ int sdxi_error_init(struct sdxi_dev *sdxi)
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,
@@ -294,6 +296,7 @@ void sdxi_error_exit(struct sdxi_dev *sdxi)
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);
@@ -301,6 +304,7 @@ void sdxi_error_exit(struct sdxi_dev *sdxi)
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);
if (sdxi->error_irq >= 0)
devm_free_irq(sdxi->dev, sdxi->error_irq, sdxi);
diff --git a/drivers/dma/sdxi/ioctl.c b/drivers/dma/sdxi/ioctl.c
index 17661fca54a7..b25f8bc273c8 100644
--- a/drivers/dma/sdxi/ioctl.c
+++ b/drivers/dma/sdxi/ioctl.c
@@ -6,13 +6,21 @@
*/
#include <linux/cdev.h>
+#include <linux/bitfield.h>
+#include <linux/capability.h>
+#include <linux/compat.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/idr.h>
+#include <linux/mm.h>
+#include <linux/minmax.h>
#include <linux/module.h>
#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <uapi/linux/sdxi.h>
#include "ioctl.h"
+#include "mmio.h"
#include "process.h"
#include "sdxi.h"
@@ -22,10 +30,405 @@ static dev_t sdxi_devt;
static struct class *sdxi_class;
static DEFINE_IDA(sdxi_minor_ida);
-static long sdxi_ioctl_unsupported(struct file *file, unsigned int cmd,
- unsigned long arg)
+static int sdxi_file_check_owner(const struct sdxi_process *process)
{
- return -ENOTTY;
+ if (process->lead_thread != current->group_leader ||
+ process->mm != current->mm)
+ return -EBADF;
+
+ return 0;
+}
+
+static int sdxi_ioctl_unsupported(struct file *file, struct sdxi_file *sf,
+ void *data)
+{
+ return -EOPNOTSUPP;
+}
+
+static int sdxi_ioctl_get_uapi_info(struct file *file, struct sdxi_file *sf,
+ void *data)
+{
+ struct sdxi_uapi_info_args *args = data;
+
+ if (args->argsz < sizeof(*args) || args->flags || args->rsvd0)
+ return -EINVAL;
+
+ *args = (typeof(*args)) {
+ .argsz = sizeof(*args),
+ .uapi_major = SDXI_UAPI_MAJOR,
+ .uapi_minor = SDXI_UAPI_MINOR,
+ .cap_words = SDXI_UAPI_CAP_WORDS,
+ .caps = {
+ SDXI_UAPI_CAP_DEV_INFO |
+ SDXI_UAPI_CAP_DEV_ATTR_MGMT,
+ },
+ };
+
+ return 0;
+}
+
+static int sdxi_ioctl_get_dev_info(struct file *file, struct sdxi_file *sf,
+ void *data)
+{
+ struct sdxi_dev_info_args *args = data;
+ struct sdxi_dev *sdxi = sf->process->sdxi;
+ size_t i;
+
+ if (args->argsz < sizeof(*args) || args->flags)
+ return -EINVAL;
+ if (args->rsvd0)
+ return -EINVAL;
+ for (i = 0; i < ARRAY_SIZE(args->rsvd1); i++)
+ if (args->rsvd1[i])
+ return -EINVAL;
+
+ *args = (typeof(*args)) {
+ .argsz = sizeof(*args),
+ .hw_major = sdxi->sdxi_version.major,
+ .hw_minor = sdxi->sdxi_version.minor,
+ .cap0 = sdxi_read64(sdxi, SDXI_MMIO_CAP0),
+ .cap1 = sdxi_read64(sdxi, SDXI_MMIO_CAP1),
+ .sts0 = sdxi_read64(sdxi, SDXI_MMIO_STS0),
+ };
+
+ return 0;
+}
+
+enum {
+ SDXI_DEV_ATTR_F_RO = BIT(0),
+};
+
+struct sdxi_dev_attr_desc {
+ u32 reg;
+ u64 mask;
+ u32 cap_reg;
+ u64 cap_mask;
+ unsigned int flags;
+ int (*get)(struct sdxi_dev *sdxi, u64 *value);
+};
+
+static int sdxi_dev_attr_get_rkey_entries(struct sdxi_dev *sdxi, u64 *value)
+{
+ *value = sdxi->rkey_cap ? sdxi->rkey_entries : 0;
+ return 0;
+}
+
+static const struct sdxi_dev_attr_desc sdxi_dev_attrs[] = {
+ [SDXI_DEV_ATTR_GSR] = {
+ .reg = SDXI_MMIO_CTL0,
+ .mask = SDXI_MMIO_CTL0_FN_GSR,
+ .flags = SDXI_DEV_ATTR_F_RO,
+ },
+ [SDXI_DEV_ATTR_GRP_ID] = {
+ .reg = SDXI_MMIO_CTL0,
+ .mask = SDXI_MMIO_CTL0_FN_GRP_ID,
+ },
+ [SDXI_DEV_ATTR_MAX_BUFFER] = {
+ .reg = SDXI_MMIO_CTL2,
+ .mask = SDXI_MMIO_CTL2_MAX_BUFFER,
+ .cap_reg = SDXI_MMIO_CAP1,
+ .cap_mask = SDXI_MMIO_CAP1_MAX_BUFFER,
+ },
+ [SDXI_DEV_ATTR_MAX_AKEY_SZ] = {
+ .reg = SDXI_MMIO_CTL2,
+ .mask = SDXI_MMIO_CTL2_MAX_AKEY_SZ,
+ .cap_reg = SDXI_MMIO_CAP1,
+ .cap_mask = SDXI_MMIO_CAP1_MAX_AKEY_SZ,
+ },
+ [SDXI_DEV_ATTR_MAX_RKEY_SZ] = {
+ .flags = SDXI_DEV_ATTR_F_RO,
+ .get = sdxi_dev_attr_get_rkey_entries,
+ },
+ [SDXI_DEV_ATTR_MAX_CXT] = {
+ .reg = SDXI_MMIO_CTL2,
+ .mask = SDXI_MMIO_CTL2_MAX_CXT,
+ .cap_reg = SDXI_MMIO_CAP1,
+ .cap_mask = SDXI_MMIO_CAP1_MAX_CXT,
+ },
+};
+
+static const struct sdxi_dev_attr_desc *sdxi_dev_attr_lookup(u64 attr)
+{
+ const struct sdxi_dev_attr_desc *desc;
+
+ if (!attr || attr >= ARRAY_SIZE(sdxi_dev_attrs))
+ return NULL;
+
+ desc = &sdxi_dev_attrs[attr];
+ if (!desc->mask && !desc->get)
+ return NULL;
+
+ return desc;
+}
+
+static int sdxi_dev_attr_read(struct sdxi_dev *sdxi,
+ const struct sdxi_dev_attr_desc *desc, u64 *value)
+{
+ unsigned int shift;
+
+ if (desc->get)
+ return desc->get(sdxi, value);
+
+ shift = __ffs64(desc->mask);
+ *value = (sdxi_read64(sdxi, desc->reg) & desc->mask) >> shift;
+ return 0;
+}
+
+static int sdxi_dev_attr_write(struct sdxi_dev *sdxi,
+ const struct sdxi_dev_attr_desc *desc, u64 value)
+{
+ unsigned int shift;
+ u64 maximum;
+ u64 register_value;
+
+ if (desc->flags & SDXI_DEV_ATTR_F_RO)
+ return -EOPNOTSUPP;
+
+ shift = __ffs64(desc->mask);
+ maximum = desc->mask >> shift;
+ if (value > maximum)
+ return -EINVAL;
+
+ mutex_lock(&sdxi->reg_lock);
+ if (desc->cap_reg) {
+ u64 capability;
+
+ capability = (sdxi_read64(sdxi, desc->cap_reg) &
+ desc->cap_mask) >> __ffs64(desc->cap_mask);
+ if (value > capability) {
+ mutex_unlock(&sdxi->reg_lock);
+ return -EINVAL;
+ }
+ }
+
+ register_value = sdxi_read64(sdxi, desc->reg);
+ register_value &= ~desc->mask;
+ register_value |= (value << shift) & desc->mask;
+ sdxi_write64(sdxi, desc->reg, register_value);
+ mutex_unlock(&sdxi->reg_lock);
+ return 0;
+}
+
+static bool sdxi_dev_attr_args_valid(const struct sdxi_dev_attr_args *args)
+{
+ size_t i;
+
+ if (args->argsz < sizeof(*args) || args->flags)
+ return false;
+ for (i = 0; i < ARRAY_SIZE(args->rsvd0); i++)
+ if (args->rsvd0[i])
+ return false;
+
+ return true;
+}
+
+static int sdxi_ioctl_get_dev_attr(struct file *file, struct sdxi_file *sf,
+ void *data)
+{
+ struct sdxi_dev_attr_args *args = data;
+ const struct sdxi_dev_attr_desc *desc;
+ int ret;
+
+ if (!sdxi_dev_attr_args_valid(args))
+ return -EINVAL;
+
+ desc = sdxi_dev_attr_lookup(args->attr);
+ if (!desc)
+ return -EOPNOTSUPP;
+
+ ret = sdxi_dev_attr_read(sf->process->sdxi, desc, &args->val);
+ if (!ret)
+ args->argsz = sizeof(*args);
+ return ret;
+}
+
+static int sdxi_ioctl_set_dev_attr(struct file *file, struct sdxi_file *sf,
+ void *data)
+{
+ struct sdxi_dev_attr_args *args = data;
+ const struct sdxi_dev_attr_desc *desc;
+ int ret;
+
+ if (!sdxi_dev_attr_args_valid(args))
+ return -EINVAL;
+
+ desc = sdxi_dev_attr_lookup(args->attr);
+ if (!desc)
+ return -EOPNOTSUPP;
+
+ ret = sdxi_dev_attr_write(sf->process->sdxi, desc, args->val);
+ if (ret)
+ return ret;
+
+ args->argsz = sizeof(*args);
+ return sdxi_dev_attr_read(sf->process->sdxi, desc, &args->val);
+}
+
+#define SDXI_IOCTL_DEF(_nr, _cmd, _func, _files, _access) \
+ [_nr] = { \
+ .cmd = (_cmd), \
+ .file_flags = (_files), \
+ .access = (_access), \
+ .func = (_func), \
+ }
+
+static const struct sdxi_ioctl_desc sdxi_ioctls[] = {
+ SDXI_IOCTL_DEF(0x01, SDXI_GET_UAPI_INFO, sdxi_ioctl_get_uapi_info,
+ SDXI_IOCTL_F_DEVICE | SDXI_IOCTL_F_CONTEXT,
+ SDXI_IOCTL_A_PUBLIC_DEVICE),
+ SDXI_IOCTL_DEF(0x02, SDXI_GET_DEV_INFO, sdxi_ioctl_get_dev_info,
+ SDXI_IOCTL_F_DEVICE | SDXI_IOCTL_F_CONTEXT,
+ SDXI_IOCTL_A_PUBLIC_DEVICE),
+ SDXI_IOCTL_DEF(0x03, SDXI_GET_DEV_ATTR, sdxi_ioctl_get_dev_attr,
+ SDXI_IOCTL_F_DEVICE | SDXI_IOCTL_F_CONTEXT,
+ SDXI_IOCTL_A_PUBLIC_DEVICE),
+ SDXI_IOCTL_DEF(0x04, SDXI_SET_DEV_ATTR, sdxi_ioctl_set_dev_attr,
+ SDXI_IOCTL_F_DEVICE, SDXI_IOCTL_A_ADMIN_DEVICE),
+ SDXI_IOCTL_DEF(0x05, SDXI_GET_RKEY_LIST, sdxi_ioctl_unsupported,
+ SDXI_IOCTL_F_DEVICE, SDXI_IOCTL_A_ADMIN_DEVICE),
+ SDXI_IOCTL_DEF(0x06, SDXI_GET_RKEYS, sdxi_ioctl_unsupported,
+ SDXI_IOCTL_F_DEVICE, SDXI_IOCTL_A_ADMIN_DEVICE),
+ SDXI_IOCTL_DEF(0x07, SDXI_SET_RKEYS, sdxi_ioctl_unsupported,
+ SDXI_IOCTL_F_DEVICE, SDXI_IOCTL_A_ADMIN_DEVICE),
+ SDXI_IOCTL_DEF(0x08, SDXI_CREATE_CXT, sdxi_ioctl_unsupported,
+ SDXI_IOCTL_F_DEVICE, SDXI_IOCTL_A_PUBLIC_DEVICE),
+ SDXI_IOCTL_DEF(0x09, SDXI_CXT_EVENTFD, sdxi_ioctl_unsupported,
+ SDXI_IOCTL_F_CONTEXT, SDXI_IOCTL_A_CONTEXT_OWNER),
+ SDXI_IOCTL_DEF(0x0a, SDXI_GET_AKEY_LIST, sdxi_ioctl_unsupported,
+ SDXI_IOCTL_F_CONTEXT, SDXI_IOCTL_A_CONTEXT_OWNER),
+ SDXI_IOCTL_DEF(0x0b, SDXI_GET_AKEYS, sdxi_ioctl_unsupported,
+ SDXI_IOCTL_F_CONTEXT, SDXI_IOCTL_A_CONTEXT_OWNER),
+ SDXI_IOCTL_DEF(0x0c, SDXI_SET_AKEYS, sdxi_ioctl_unsupported,
+ SDXI_IOCTL_F_CONTEXT, SDXI_IOCTL_A_CONTEXT_OWNER),
+ SDXI_IOCTL_DEF(0x0d, SDXI_ADMIN_DISC, sdxi_ioctl_unsupported,
+ SDXI_IOCTL_F_DEVICE, SDXI_IOCTL_A_PUBLIC_DEVICE),
+ SDXI_IOCTL_DEF(0x0e, SDXI_ADMIN_VENDOR, sdxi_ioctl_unsupported,
+ SDXI_IOCTL_F_DEVICE, SDXI_IOCTL_A_VENDOR_HANDLER),
+ SDXI_IOCTL_DEF(0x0f, SDXI_QUIESCE_CXT, sdxi_ioctl_unsupported,
+ SDXI_IOCTL_F_CONTEXT, SDXI_IOCTL_A_CONTEXT_OWNER),
+};
+
+static int sdxi_ioctl_permit(const struct sdxi_ioctl_desc *desc)
+{
+ switch (desc->access) {
+ case SDXI_IOCTL_A_PUBLIC_DEVICE:
+ case SDXI_IOCTL_A_CONTEXT_OWNER:
+ return 0;
+ case SDXI_IOCTL_A_ADMIN_DEVICE:
+ return capable(CAP_SYS_ADMIN) ? 0 : -EPERM;
+ case SDXI_IOCTL_A_VENDOR_HANDLER:
+ return -EOPNOTSUPP;
+ }
+
+ return -EINVAL;
+}
+
+static bool sdxi_ioctl_has_trailing_payload(unsigned int cmd)
+{
+ return cmd == SDXI_GET_RKEY_LIST || cmd == SDXI_GET_RKEYS ||
+ cmd == SDXI_SET_RKEYS || cmd == SDXI_GET_AKEY_LIST ||
+ cmd == SDXI_GET_AKEYS || cmd == SDXI_SET_AKEYS;
+}
+
+static long sdxi_ioctl_live(struct file *file, unsigned int cmd,
+ unsigned long arg)
+{
+ const struct sdxi_ioctl_desc *desc;
+ struct sdxi_file *sf = file->private_data;
+ unsigned int canonical_size;
+ unsigned int user_size;
+ unsigned int size;
+ unsigned int nr;
+ char stack_data[128];
+ void *data = stack_data;
+ bool allowed;
+ int ret;
+
+ if (_IOC_TYPE(cmd) != SDXI_IOCTL_BASE)
+ return -ENOTTY;
+
+ nr = _IOC_NR(cmd);
+ if (nr >= ARRAY_SIZE(sdxi_ioctls) || !sdxi_ioctls[nr].cmd)
+ return -ENOTTY;
+
+ desc = &sdxi_ioctls[nr];
+ if (_IOC_DIR(cmd) != _IOC_DIR(desc->cmd))
+ return -ENOTTY;
+ if (!sf || !sf->process)
+ return -EINVAL;
+
+ ret = sdxi_file_check_owner(sf->process);
+ if (ret)
+ return ret;
+
+ switch (sf->type) {
+ case SDXI_FILE_DEVICE:
+ allowed = desc->file_flags & SDXI_IOCTL_F_DEVICE;
+ break;
+ case SDXI_FILE_CONTEXT:
+ allowed = desc->file_flags & SDXI_IOCTL_F_CONTEXT;
+ break;
+ default:
+ allowed = false;
+ break;
+ }
+ if (!allowed)
+ return -ENOTTY;
+
+ ret = sdxi_ioctl_permit(desc);
+ if (ret)
+ return ret;
+
+ canonical_size = _IOC_SIZE(desc->cmd);
+ user_size = _IOC_SIZE(cmd);
+ size = max(canonical_size, user_size);
+ if (size > PAGE_SIZE)
+ return -E2BIG;
+
+ if (size > sizeof(stack_data)) {
+ data = kzalloc(size, GFP_KERNEL);
+ if (!data)
+ return -ENOMEM;
+ } else {
+ memset(data, 0, size);
+ }
+
+ if ((_IOC_DIR(cmd) & _IOC_WRITE) &&
+ copy_from_user(data, (void __user *)arg, user_size)) {
+ ret = -EFAULT;
+ goto out;
+ }
+
+ ret = desc->func(file, sf, data);
+
+ if ((_IOC_DIR(cmd) & _IOC_READ) && user_size > canonical_size &&
+ !sdxi_ioctl_has_trailing_payload(desc->cmd))
+ memset((u8 *)data + canonical_size, 0,
+ user_size - canonical_size);
+ if ((_IOC_DIR(cmd) & _IOC_READ) &&
+ copy_to_user((void __user *)arg, data, user_size))
+ ret = -EFAULT;
+
+out:
+ if (data != stack_data)
+ kfree(data);
+ return ret;
+}
+
+static long sdxi_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+ struct sdxi_file *sf = file->private_data;
+ struct sdxi_dev *sdxi;
+ long ret;
+
+ if (!sf || !sf->process)
+ return -EINVAL;
+ sdxi = sf->process->sdxi;
+
+ down_read(&sdxi->state_lock);
+ ret = sdxi->online ? sdxi_ioctl_live(file, cmd, arg) : -ENODEV;
+ up_read(&sdxi->state_lock);
+ return ret;
}
static int sdxi_open(struct inode *inode, struct file *file)
@@ -77,8 +480,8 @@ static const struct file_operations sdxi_fops = {
.owner = THIS_MODULE,
.open = sdxi_open,
.release = sdxi_release,
- .unlocked_ioctl = sdxi_ioctl_unsupported,
- .compat_ioctl = sdxi_ioctl_unsupported,
+ .unlocked_ioctl = sdxi_ioctl,
+ .compat_ioctl = compat_ptr_ioctl,
};
int sdxi_chardev_init(void)
diff --git a/drivers/dma/sdxi/ioctl.h b/drivers/dma/sdxi/ioctl.h
index 8677f3e62e93..a6c53758c8b9 100644
--- a/drivers/dma/sdxi/ioctl.h
+++ b/drivers/dma/sdxi/ioctl.h
@@ -42,7 +42,6 @@ struct sdxi_ioctl_desc {
unsigned int file_flags;
enum sdxi_ioctl_access_class access;
sdxi_ioctl_t *func;
- const char *name;
};
#define SDXI_IOCTL_F_DEVICE BIT(0)
diff --git a/drivers/dma/sdxi/sdxi.h b/drivers/dma/sdxi/sdxi.h
index 98d2baffbbdf..03a85a1575e7 100644
--- a/drivers/dma/sdxi/sdxi.h
+++ b/drivers/dma/sdxi/sdxi.h
@@ -96,6 +96,7 @@ struct sdxi_dev {
dma_addr_t L1_dma[SDXI_L2_TABLE_ENTRIES];
u16 L1_users[SDXI_L2_TABLE_ENTRIES];
struct mutex cxt_lock; /* context table serialization */
+ struct mutex reg_lock; /* MMIO register updates */
/* RKey table */
struct mutex rkey_lock;
--
2.56.1
next prev parent reply other threads:[~2026-11-19 20:26 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 ` Wei Huang [this message]
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 ` [PATCH v1 27/44] dmaengine: sdxi: support suspend and resume Wei Huang
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-18-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®