[RFC PATCH v2 5/6] vfio: platform: reset: add reset for cdx devices

Nipun Gupta
2022-08-17T15:06:56Z

This patch adds a VFIO reset module that registers and
implements basic reset functionality for CDX based platform
devices. It interfaces with the CDX bus controller to
register all the types of devices supported on the CDX bus,
and uses CDX bus interface to reset the device.

Signed-off-by: Nipun Gupta <nipun.gupta@amd.com>
---
MAINTAINERS | 1 +
drivers/bus/cdx/cdx.c | 42 +++++++
drivers/vfio/platform/reset/Kconfig | 8 ++
drivers/vfio/platform/reset/Makefile | 1 +
.../vfio/platform/reset/vfio_platform_cdx.c | 106 ++++++++++++++++++
include/linux/cdx/cdx_bus.h | 27 +++++
6 files changed, 185 insertions(+)
create mode 100644 drivers/vfio/platform/reset/vfio_platform_cdx.c

diff --git a/MAINTAINERS b/MAINTAINERS
index b0eea32dbb39..4794401f07c1 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -22302,6 +22302,7 @@ M: Nikhil Agarwal <nikhil.agarwal@amd.com>
S: Maintained
F: Documentation/devicetree/bindings/bus/xlnx,cdx.yaml
F: drivers/bus/cdx/*
+F: drivers/vfio/platform/reset/vfio_platform_cdx.c

XILINX GPIO DRIVER
M: Shubhrajyoti Datta <shubhrajyoti.datta@xilinx.com>
diff --git a/drivers/bus/cdx/cdx.c b/drivers/bus/cdx/cdx.c
index 5fb9a99b3c97..262db9071108 100644
--- a/drivers/bus/cdx/cdx.c
+++ b/drivers/bus/cdx/cdx.c
@@ -72,6 +72,48 @@ static ssize_t reset_store(struct device *dev, struct device_attribute *attr,
}
static DEVICE_ATTR_WO(reset);

+int cdx_get_num_device_types(void)
+{
+ int i;
+
+ for (i = 0; i < MAX_CDX_DEVICE_TYPES; i++)
+ if (strlen(dev_types[i].compat) == 0)
+ break;
+
+ return i;
+}
+
+int cdx_get_device_types(struct cdx_device_types_t *cdx_dev_types)
+{
+ int num_dev_types;
+
+ if (cdx_dev_types == NULL) {
+ pr_err("Invalid argument to %s\n", __func__);
+ return -EINVAL;
+ }
+
+ num_dev_types = cdx_get_num_device_types();
+
+ memcpy(cdx_dev_types, &dev_types[0], (num_dev_types *
+ sizeof(struct cdx_device_types_t)));
+
+ return num_dev_types;
+}
+
+int cdx_dev_reset(struct device *dev)
+{
+ return reset_cdx_device(dev, NULL);
+}
+
+int cdx_dev_num_msi(struct device *dev)
+{
+ struct cdx_device_data *dev_data;
+
+ /* Retrieve number of MSI from platform data */
+ dev_data = dev->platform_data;
+ return dev_data->num_msi;
+}
+
static int cdx_populate_one(struct platform_device *pdev_parent,
struct cdx_dev_params_t *dev_params)
{
diff --git a/drivers/vfio/platform/reset/Kconfig b/drivers/vfio/platform/reset/Kconfig
index 12f5f3d80387..bbbee3f7f5ca 100644
--- a/drivers/vfio/platform/reset/Kconfig
+++ b/drivers/vfio/platform/reset/Kconfig
@@ -21,3 +21,11 @@ config VFIO_PLATFORM_BCMFLEXRM_RESET
Enables the VFIO platform driver to handle reset for Broadcom FlexRM

If you don't know what to do here, say N.
+
+config VFIO_PLATFORM_CDXDEV_RESET
+ tristate "VFIO support for cdx devices reset"
+ default n
+ help
+ Enables the VFIO platform driver to handle reset for devices on CDX bus
+
+ If you don't know what to do here, say N.
diff --git a/drivers/vfio/platform/reset/Makefile b/drivers/vfio/platform/reset/Makefile
index 7294c5ea122e..1b1f65945934 100644
--- a/drivers/vfio/platform/reset/Makefile
+++ b/drivers/vfio/platform/reset/Makefile
@@ -5,3 +5,4 @@ vfio-platform-amdxgbe-y := vfio_platform_amdxgbe.o
obj-$(CONFIG_VFIO_PLATFORM_CALXEDAXGMAC_RESET) += vfio-platform-calxedaxgmac.o
obj-$(CONFIG_VFIO_PLATFORM_AMDXGBE_RESET) += vfio-platform-amdxgbe.o
obj-$(CONFIG_VFIO_PLATFORM_BCMFLEXRM_RESET) += vfio_platform_bcmflexrm.o
+obj-$(CONFIG_VFIO_PLATFORM_CDXDEV_RESET) += vfio_platform_cdx.o
diff --git a/drivers/vfio/platform/reset/vfio_platform_cdx.c b/drivers/vfio/platform/reset/vfio_platform_cdx.c
new file mode 100644
index 000000000000..10bb27379205
--- /dev/null
+++ b/drivers/vfio/platform/reset/vfio_platform_cdx.c
@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * VFIO platform driver specialized for reset of devices on AMD CDX bus.
+ *
+ * Copyright(C) 2022 Xilinx Inc.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <uapi/linux/mdio.h>
+#include <linux/cdx/cdx_bus.h>
+
+#include "../vfio_platform_private.h"
+
+static int vfio_platform_cdxdev_reset(struct vfio_platform_device *vdev)
+{
+ return cdx_dev_reset(vdev->device);
+}
+
+static struct vfio_platform_reset_node *vfio_platform_cdxdev_reset_nodes;
+
+static int __init vfio_platform_cdxdev_reset_module_init(void)
+{
+ struct cdx_device_types_t *cdx_dev_types;
+ struct vfio_platform_reset_node *reset_node;
+ int num_dev_types, ret, i;
+
+ ret = cdx_get_num_device_types();
+ if (ret < 0) {
+ pr_err("cdx_get_num_device_types failed: %d\n", ret);
+ return ret;
+ }
+ num_dev_types = ret;
+
+ vfio_platform_cdxdev_reset_nodes = kcalloc(num_dev_types,
+ sizeof(struct vfio_platform_reset_node), GFP_KERNEL);
+ if (IS_ERR_OR_NULL(vfio_platform_cdxdev_reset_nodes)) {
+ pr_err("memory allocation for cdxdev_reset_nodes failed\n");
+ return -ENOMEM;
+ }
+
+ cdx_dev_types = kcalloc(num_dev_types,
+ sizeof(struct cdx_device_types_t), GFP_KERNEL);
+ if (IS_ERR_OR_NULL(cdx_dev_types)) {
+ pr_err("memory allocation for cdx_dev_types failed\n");
+ kfree(vfio_platform_cdxdev_reset_nodes);
+ return -ENOMEM;
+ }
+
+ ret = cdx_get_device_types(cdx_dev_types);
+ if (ret < 0) {
+ pr_err("cdx_get_devices_info failed: %d\n", ret);
+ kfree(vfio_platform_cdxdev_reset_nodes);
+ kfree(cdx_dev_types);
+ return ret;
+ }
+
+ for (i = 0; i < num_dev_types; i++) {
+ reset_node = &vfio_platform_cdxdev_reset_nodes[i];
+ reset_node->owner = THIS_MODULE;
+
+ reset_node->compat =
+ kzalloc(strlen(cdx_dev_types[i].compat + 1),
+ GFP_KERNEL);
+ memcpy(reset_node->compat, cdx_dev_types[i].compat,
+ MAX_CDX_COMPAT_LEN);
+
+ reset_node->of_reset = vfio_platform_cdxdev_reset;
+
+ __vfio_platform_register_reset(reset_node);
+ }
+ kfree(cdx_dev_types);
+
+ return 0;
+}
+
+static void __exit vfio_platform_cdxdev_reset_module_exit(void)
+{
+ struct vfio_platform_reset_node *reset_node;
+ int num_dev_types, ret, i;
+
+ ret = cdx_get_num_device_types();
+ if (ret < 0) {
+ pr_err("cdx_get_num_device_types failed: %d\n", ret);
+ return;
+ }
+
+ num_dev_types = ret;
+ for (i = 0; i < num_dev_types; i++) {
+ reset_node = &vfio_platform_cdxdev_reset_nodes[i];
+ vfio_platform_unregister_reset(reset_node->compat,
+ vfio_platform_cdxdev_reset);
+ kfree(reset_node->compat);
+ }
+ kfree(vfio_platform_cdxdev_reset_nodes);
+}
+
+module_init(vfio_platform_cdxdev_reset_module_init);
+module_exit(vfio_platform_cdxdev_reset_module_exit);
+
+MODULE_VERSION("0.1");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Nipun Gupta<nipun.gupta@amd.com>");
+MODULE_DESCRIPTION("Reset support for cdx devices");
diff --git a/include/linux/cdx/cdx_bus.h b/include/linux/cdx/cdx_bus.h
index 7c6ad7dfe97a..47c60edb49fd 100644
--- a/include/linux/cdx/cdx_bus.h
+++ b/include/linux/cdx/cdx_bus.h
@@ -23,4 +23,31 @@ struct cdx_device_types_t {
char compat[MAX_CDX_COMPAT_LEN];
};

+/**
+ * cdx_get_num_device_types - Get total number of CDX device types.
+ *
+ * Return number of types of devices, -errno on failure
+ */
+int cdx_get_num_device_types(void);
+
+/**
+ * cdx_get_device_types - Get info related to all types of devices
+ * supported on the CDX bus.
+ * @cdx_dev_types: Pointer to cdx_devices_type_t structure.
+ * Memory for this structure should be allocated by the
+ * caller, where the memory allocated should be more than
+ * available_device_types * sizeof(struct cdx_device_types_t).
+ *
+ * Return number of types of devices, -errno on failure
+ */
+int cdx_get_device_types(struct cdx_device_types_t *cdx_dev_types);
+
+/**
+ * cdx_dev_reset - Reset CDX device
+ * @dev: device pointer
+ *
+ * Return 0 for success, -errno on failure
+ */
+int cdx_dev_reset(struct device *dev);
+
#endif /* _CDX_H_ */
--
2.25.1