mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
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, &reg, 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, &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,
@@ -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, &reg, 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, &reg, 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


  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®