cdx: create sysfs bin files for cdx resources

Resource binary file contains the content of the memory regions.
These resources<x> devices can be used to mmap the MMIO regions in
the user-space.

Co-developed-by: Puneet Gupta <puneet.gupta@amd.com>
Signed-off-by: Puneet Gupta <puneet.gupta@amd.com>
Signed-off-by: Abhijit Gangurde <abhijit.gangurde@amd.com>
Link: https://lore.kernel.org/r/20231222064627.2828960-1-abhijit.gangurde@amd.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/Documentation/ABI/testing/sysfs-bus-cdx b/Documentation/ABI/testing/sysfs-bus-cdx
index 8c067ff99e54742bcf3c5d033ecda7d39b213a8f..e84277531414b12977374755fd225840bf8936d1 100644 (file)
--- a/Documentation/ABI/testing/sysfs-bus-cdx
+++ b/Documentation/ABI/testing/sysfs-bus-cdx
@@ -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

diff --git a/drivers/cdx/cdx.c b/drivers/cdx/cdx.c
index d84d153078d75eba1613f38a306dcc9606bf53da..2ec1846ff063c130a25ad37ccd907c936e72cde6 100644 (file)
--- a/drivers/cdx/cdx.c
+++ b/drivers/cdx/cdx.c
@@ -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

diff --git a/include/linux/cdx/cdx_bus.h b/include/linux/cdx/cdx_bus.h
index 94ad2c9017c9d839f22769fc18e9560f6b5d93dd..fab9e62c7e7d39786ad20d26b62497d153f8347e 100644 (file)
--- a/include/linux/cdx/cdx_bus.h
+++ b/include/linux/cdx/cdx_bus.h
@@ -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