cdx: create sysfs bin files for cdx resources (aeda33ab) · Commits · git / linux-nf

Documentation/ABI/testing/sysfs-bus-cdx

+7 −0

Original line number	Diff line number	Diff line
		@@ -98,6 +98,13 @@ Description:

		# echo 1 > /sys/bus/cdx/devices/.../remove

		What: /sys/bus/cdx/devices/.../resource<N>
		Date: July 2023
		Contact: puneet.gupta@amd.com
		Description:
		The resource binary file contains the content of the memory
		regions. These files can be m'maped from userspace.

		What: /sys/bus/cdx/devices/.../modalias
		Date: July 2023
		Contact: nipun.gupta@amd.com

drivers/cdx/cdx.c

+117 −1

Original line number	Diff line number	Diff line
		@@ -80,6 +80,8 @@ static DEFINE_MUTEX(cdx_controller_lock);

		static char *compat_node_name = "xlnx,versal-net-cdx";

		static void cdx_destroy_res_attr(struct cdx_device *cdx_dev, int num);

		/**
		* cdx_dev_reset - Reset a CDX device
		* @dev: CDX device
		@@ -148,6 +150,7 @@ static int cdx_unregister_device(struct device *dev,
		if (cdx_dev->enabled && cdx->ops->bus_disable)
		cdx->ops->bus_disable(cdx, cdx_dev->bus_num);
		} else {
		cdx_destroy_res_attr(cdx_dev, MAX_CDX_DEV_RESOURCES);
		kfree(cdx_dev->driver_override);
		cdx_dev->driver_override = NULL;
		}
		@@ -643,11 +646,105 @@ static void cdx_device_release(struct device *dev)
		kfree(cdx_dev);
		}

		static const struct vm_operations_struct cdx_phys_vm_ops = {
		#ifdef CONFIG_HAVE_IOREMAP_PROT
		.access = generic_access_phys,
		#endif
		};

		/**
		* cdx_mmap_resource - map a CDX resource into user memory space
		* @fp: File pointer. Not used in this function, but required where
		* this API is registered as a callback.
		* @kobj: kobject for mapping
		* @attr: struct bin_attribute for the file being mapped
		* @vma: struct vm_area_struct passed into the mmap
		*
		* Use the regular CDX mapping routines to map a CDX resource into userspace.
		*
		* Return: true on success, false otherwise.
		*/
		static int cdx_mmap_resource(struct file fp, struct kobject kobj,
		struct bin_attribute *attr,
		struct vm_area_struct *vma)
		{
		struct cdx_device *cdx_dev = to_cdx_device(kobj_to_dev(kobj));
		int num = (unsigned long)attr->private;
		struct resource *res;
		unsigned long size;

		res = &cdx_dev->res[num];
		if (iomem_is_exclusive(res->start))
		return -EINVAL;

		/* Make sure the caller is mapping a valid resource for this device */
		size = ((cdx_resource_len(cdx_dev, num) - 1) >> PAGE_SHIFT) + 1;
		if (vma->vm_pgoff + vma_pages(vma) > size)
		return -EINVAL;

		/*
		* Map memory region and vm->vm_pgoff is expected to be an
		* offset within that region.
		*/
		vma->vm_page_prot = pgprot_device(vma->vm_page_prot);
		vma->vm_pgoff += (cdx_resource_start(cdx_dev, num) >> PAGE_SHIFT);
		vma->vm_ops = &cdx_phys_vm_ops;
		return io_remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
		vma->vm_end - vma->vm_start,
		vma->vm_page_prot);
		}

		static void cdx_destroy_res_attr(struct cdx_device *cdx_dev, int num)
		{
		int i;

		/* removing the bin attributes */
		for (i = 0; i < num; i++) {
		struct bin_attribute *res_attr;

		res_attr = cdx_dev->res_attr[i];
		if (res_attr) {
		sysfs_remove_bin_file(&cdx_dev->dev.kobj, res_attr);
		kfree(res_attr);
		}
		}
		}

		#define CDX_RES_ATTR_NAME_LEN 10
		static int cdx_create_res_attr(struct cdx_device *cdx_dev, int num)
		{
		struct bin_attribute *res_attr;
		char *res_attr_name;
		int ret;

		res_attr = kzalloc(sizeof(*res_attr) + CDX_RES_ATTR_NAME_LEN, GFP_ATOMIC);
		if (!res_attr)
		return -ENOMEM;

		res_attr_name = (char *)(res_attr + 1);

		sysfs_bin_attr_init(res_attr);

		cdx_dev->res_attr[num] = res_attr;
		sprintf(res_attr_name, "resource%d", num);

		res_attr->mmap = cdx_mmap_resource;
		res_attr->attr.name = res_attr_name;
		res_attr->attr.mode = 0600;
		res_attr->size = cdx_resource_len(cdx_dev, num);
		res_attr->private = (void *)(unsigned long)num;
		ret = sysfs_create_bin_file(&cdx_dev->dev.kobj, res_attr);
		if (ret)
		kfree(res_attr);

		return ret;
		}

		int cdx_device_add(struct cdx_dev_params *dev_params)
		{
		struct cdx_controller *cdx = dev_params->cdx;
		struct cdx_device *cdx_dev;
		int ret;
		int ret, i;

		cdx_dev = kzalloc(sizeof(*cdx_dev), GFP_KERNEL);
		if (!cdx_dev)
		@@ -690,7 +787,26 @@ int cdx_device_add(struct cdx_dev_params *dev_params)
		goto fail;
		}

		/* Create resource<N> attributes */
		for (i = 0; i < MAX_CDX_DEV_RESOURCES; i++) {
		if (cdx_resource_flags(cdx_dev, i) & IORESOURCE_MEM) {
		/* skip empty resources */
		if (!cdx_resource_len(cdx_dev, i))
		continue;

		ret = cdx_create_res_attr(cdx_dev, i);
		if (ret != 0) {
		dev_err(&cdx_dev->dev,
		"cdx device resource<%d> file creation failed: %d", i, ret);
		goto resource_create_fail;
		}
		}
		}

		return 0;
		resource_create_fail:
		cdx_destroy_res_attr(cdx_dev, i);
		device_del(&cdx_dev->dev);
		fail:
		/*
		* Do not free cdx_dev here as it would be freed in

include/linux/cdx/cdx_bus.h

+10 −0

Original line number	Diff line number	Diff line
		@@ -135,6 +135,7 @@ struct cdx_device {
		u8 bus_num;
		u8 dev_num;
		struct resource res[MAX_CDX_DEV_RESOURCES];
		struct bin_attribute *res_attr[MAX_CDX_DEV_RESOURCES];
		u8 res_count;
		u64 dma_mask;
		u16 flags;
		@@ -147,6 +148,15 @@ struct cdx_device {
		#define to_cdx_device(_dev) \
		container_of(_dev, struct cdx_device, dev)

		#define cdx_resource_start(dev, num) ((dev)->res[(num)].start)
		#define cdx_resource_end(dev, num) ((dev)->res[(num)].end)
		#define cdx_resource_flags(dev, num) ((dev)->res[(num)].flags)
		#define cdx_resource_len(dev, num) \
		((cdx_resource_start((dev), (num)) == 0 && \
		cdx_resource_end((dev), (num)) == \
		cdx_resource_start((dev), (num))) ? 0 : \
		(cdx_resource_end((dev), (num)) - \
		cdx_resource_start((dev), (num)) + 1))
		/**
		* struct cdx_driver - CDX device driver
		* @driver: Generic device driver