Lines Matching +full:versal +full:- +full:net +full:- +full:cdx
1 // SPDX-License-Identifier: GPL-2.0
3 * CDX bus driver.
5 * Copyright (C) 2022-2023, Advanced Micro Devices, Inc.
11 * CDX is a Hardware Architecture designed for AMD FPGA devices. It
16 * the FPGA program manager and the APUs. The RPU provides memory-mapped
19 * The diagram below shows an overview of the CDX architecture:
21 * +--------------------------------------+
24 * | CDX device drivers|
26 * | CDX bus |
28 * | CDX controller |
30 * +-----------------------------|--------+
34 * +------------------------| RPU if |----+
39 * +--------------------------------------+
41 * +---------------------|----------------+
43 * | +-----------------------+ |
45 * | +-------+ +-------+ +-------+ |
47 * | +-------+ +-------+ +-------+ |
48 * +--------------------------------------+
68 #include <linux/cdx/cdx_bus.h>
70 #include <linux/dma-map-ops.h>
72 #include "cdx.h"
74 /* Default DMA mask for devices on a CDX bus */
78 /* IDA for CDX controllers registered with the CDX bus */
82 /* Debugfs dir for cdx bus */
85 static char *compat_node_name = "xlnx,versal-net-cdx";
90 * cdx_dev_reset - Reset a CDX device
91 * @dev: CDX device
93 * Return: -errno on failure, 0 on success.
98 struct cdx_controller *cdx = cdx_dev->cdx;
103 cdx_drv = to_cdx_driver(dev->driver);
105 if (cdx_drv && cdx_drv->reset_prepare)
106 cdx_drv->reset_prepare(cdx_dev);
109 ret = cdx->ops->dev_configure(cdx, cdx_dev->bus_num,
110 cdx_dev->dev_num, &dev_config);
112 dev_err(dev, "cdx device reset failed\n");
115 if (cdx_drv && cdx_drv->reset_done)
116 cdx_drv->reset_done(cdx_dev);
123 * reset_cdx_device - Reset a CDX device
124 * @dev: CDX device
129 * Return: -errno on failure, 0 on success.
137 * cdx_unregister_device - Unregister a CDX device
138 * @dev: CDX device
150 struct cdx_controller *cdx = cdx_dev->cdx;
152 if (cdx_dev->is_bus) {
154 if (cdx_dev->enabled && cdx->ops->bus_disable)
155 cdx->ops->bus_disable(cdx, cdx_dev->bus_num);
158 debugfs_remove_recursive(cdx_dev->debugfs_dir);
159 kfree(cdx_dev->driver_override);
160 cdx_dev->driver_override = NULL;
167 device_del(&cdx_dev->dev);
168 put_device(&cdx_dev->dev);
175 /* Reset all the devices attached to cdx bus */
180 * cdx_match_one_device - Tell if a CDX device structure has a matching
181 * CDX device id structure
182 * @id: single CDX device id structure to match
183 * @dev: the CDX device structure to match against
192 if ((id->vendor == CDX_ANY_ID || id->vendor == dev->vendor) &&
193 (id->device == CDX_ANY_ID || id->device == dev->device) &&
194 (id->subvendor == CDX_ANY_ID || id->subvendor == dev->subsystem_vendor) &&
195 (id->subdevice == CDX_ANY_ID || id->subdevice == dev->subsystem_device) &&
196 !((id->class ^ dev->class) & id->class_mask))
202 * cdx_match_id - See if a CDX device matches a given cdx_id table
203 * @ids: array of CDX device ID structures to search in
204 * @dev: the CDX device structure to match against.
206 * Used by a driver to check whether a CDX device is in its list of
216 while (ids->vendor || ids->device) {
227 struct cdx_controller *cdx = cdx_dev->cdx;
229 int ret = -EOPNOTSUPP;
233 if (cdx->ops->dev_configure)
234 ret = cdx->ops->dev_configure(cdx, cdx_dev->bus_num,
235 cdx_dev->dev_num, &dev_config);
243 struct cdx_controller *cdx = cdx_dev->cdx;
245 int ret = -EOPNOTSUPP;
249 if (cdx->ops->dev_configure)
250 ret = cdx->ops->dev_configure(cdx, cdx_dev->bus_num,
251 cdx_dev->dev_num, &dev_config);
258 * cdx_bus_match - device to driver matching callback
259 * @dev: the cdx device to match against
260 * @drv: the device driver to search for matching cdx device
272 if (cdx_dev->is_bus)
275 ids = cdx_drv->match_id_table;
278 if (cdx_dev->driver_override && strcmp(cdx_dev->driver_override, drv->name))
290 if (!found_id->override_only)
292 if (cdx_dev->driver_override)
304 struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver);
306 struct cdx_controller *cdx = cdx_dev->cdx;
313 if (cdx->msi_domain) {
314 error = msi_setup_device_data(&cdx_dev->dev);
319 error = cdx_drv->probe(cdx_dev);
330 struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver);
333 if (cdx_drv && cdx_drv->remove)
334 cdx_drv->remove(cdx_dev);
339 struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver);
341 struct cdx_controller *cdx = cdx_dev->cdx;
343 if (cdx_dev->is_bus && cdx_dev->enabled && cdx->ops->bus_disable)
344 cdx->ops->bus_disable(cdx, cdx_dev->bus_num);
345 if (cdx_drv && cdx_drv->shutdown)
346 cdx_drv->shutdown(cdx_dev);
351 struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver);
353 struct cdx_controller *cdx = cdx_dev->cdx;
354 u32 input_id = cdx_dev->req_id;
357 ret = of_dma_configure_id(dev, cdx->dev->of_node, 0, &input_id);
358 if (ret && ret != -EPROBE_DEFER) {
363 if (!ret && !cdx_drv->driver_managed_dma) {
374 struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver);
376 if (!cdx_drv->driver_managed_dma)
386 return sysfs_emit(buf, format_string, cdx_dev->field); \
404 return -EINVAL;
407 return -EINVAL;
429 return -EINVAL;
432 return -EINVAL;
434 if (cdx_dev->is_bus)
435 /* Reset all the devices attached to cdx bus */
449 return sprintf(buf, "cdx:v%04Xd%04Xsv%04Xsd%04Xc%06X\n", cdx_dev->vendor,
450 cdx_dev->device, cdx_dev->subsystem_vendor, cdx_dev->subsystem_device,
451 cdx_dev->class);
462 if (WARN_ON(dev->bus != &cdx_bus_type))
463 return -EINVAL;
465 ret = driver_set_override(dev, &cdx_dev->driver_override, buf, count);
479 len = sysfs_emit(buf, "%s\n", cdx_dev->driver_override);
489 struct cdx_controller *cdx = cdx_dev->cdx;
494 return -EINVAL;
496 if (enable == cdx_dev->enabled)
499 if (enable && cdx->ops->bus_enable)
500 ret = cdx->ops->bus_enable(cdx, cdx_dev->bus_num);
501 else if (!enable && cdx->ops->bus_disable)
502 ret = cdx->ops->bus_disable(cdx, cdx_dev->bus_num);
504 ret = -EOPNOTSUPP;
507 cdx_dev->enabled = enable;
516 return sysfs_emit(buf, "%u\n", cdx_dev->enabled);
526 if (!cdx_dev->is_bus)
527 return a->mode;
538 if (cdx_dev->is_bus)
539 return a->mode;
582 struct cdx_device *cdx_dev = s->private;
586 struct resource *res = &cdx_dev->res[i];
597 cdx_dev->debugfs_dir = debugfs_create_dir(dev_name(&cdx_dev->dev), cdx_debugfs_dir);
598 if (IS_ERR(cdx_dev->debugfs_dir))
601 debugfs_create_file("resource", 0444, cdx_dev->debugfs_dir, cdx_dev,
608 struct cdx_controller *cdx;
614 return -EINVAL;
617 return -EINVAL;
629 count = -EINVAL;
633 cdx = platform_get_drvdata(pd);
634 if (cdx && cdx->controller_registered && cdx->ops->scan)
635 cdx->ops->scan(cdx);
637 put_device(&pd->dev);
654 .name = "cdx",
671 cdx_driver->driver.owner = owner;
672 cdx_driver->driver.bus = &cdx_bus_type;
674 error = driver_register(&cdx_driver->driver);
677 cdx_driver->driver.name, error);
687 driver_unregister(&cdx_driver->driver);
705 * cdx_mmap_resource - map a CDX resource into user memory space
712 * Use the regular CDX mapping routines to map a CDX resource into userspace.
721 int num = (unsigned long)attr->private;
725 res = &cdx_dev->res[num];
726 if (iomem_is_exclusive(res->start))
727 return -EINVAL;
730 size = ((cdx_resource_len(cdx_dev, num) - 1) >> PAGE_SHIFT) + 1;
731 if (vma->vm_pgoff + vma_pages(vma) > size)
732 return -EINVAL;
735 * Map memory region and vm->vm_pgoff is expected to be an
738 vma->vm_page_prot = pgprot_device(vma->vm_page_prot);
739 vma->vm_pgoff += (cdx_resource_start(cdx_dev, num) >> PAGE_SHIFT);
740 vma->vm_ops = &cdx_phys_vm_ops;
741 return io_remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
742 vma->vm_end - vma->vm_start,
743 vma->vm_page_prot);
754 res_attr = cdx_dev->res_attr[i];
756 sysfs_remove_bin_file(&cdx_dev->dev.kobj, res_attr);
771 return -ENOMEM;
777 cdx_dev->res_attr[num] = res_attr;
780 res_attr->mmap = cdx_mmap_resource;
781 res_attr->attr.name = res_attr_name;
782 res_attr->attr.mode = 0600;
783 res_attr->size = cdx_resource_len(cdx_dev, num);
784 res_attr->private = (void *)(unsigned long)num;
785 ret = sysfs_create_bin_file(&cdx_dev->dev.kobj, res_attr);
794 struct cdx_controller *cdx = dev_params->cdx;
800 return -ENOMEM;
803 memcpy(cdx_dev->res, dev_params->res, sizeof(struct resource) *
804 dev_params->res_count);
805 cdx_dev->res_count = dev_params->res_count;
807 /* Populate CDX dev params */
808 cdx_dev->req_id = dev_params->req_id;
809 cdx_dev->msi_dev_id = dev_params->msi_dev_id;
810 cdx_dev->vendor = dev_params->vendor;
811 cdx_dev->device = dev_params->device;
812 cdx_dev->subsystem_vendor = dev_params->subsys_vendor;
813 cdx_dev->subsystem_device = dev_params->subsys_device;
814 cdx_dev->class = dev_params->class;
815 cdx_dev->revision = dev_params->revision;
816 cdx_dev->bus_num = dev_params->bus_num;
817 cdx_dev->dev_num = dev_params->dev_num;
818 cdx_dev->cdx = dev_params->cdx;
819 cdx_dev->dma_mask = CDX_DEFAULT_DMA_MASK;
822 device_initialize(&cdx_dev->dev);
823 cdx_dev->dev.parent = dev_params->parent;
824 cdx_dev->dev.bus = &cdx_bus_type;
825 cdx_dev->dev.dma_mask = &cdx_dev->dma_mask;
826 cdx_dev->dev.release = cdx_device_release;
827 cdx_dev->msi_write_pending = false;
828 mutex_init(&cdx_dev->irqchip_lock);
831 dev_set_name(&cdx_dev->dev, "cdx-%02x:%02x",
832 ((cdx->id << CDX_CONTROLLER_ID_SHIFT) | (cdx_dev->bus_num & CDX_BUS_NUM_MASK)),
833 cdx_dev->dev_num);
835 if (cdx->msi_domain) {
836 cdx_dev->num_msi = dev_params->num_msi;
837 dev_set_msi_domain(&cdx_dev->dev, cdx->msi_domain);
840 ret = device_add(&cdx_dev->dev);
842 dev_err(&cdx_dev->dev,
843 "cdx device add failed: %d", ret);
856 dev_err(&cdx_dev->dev,
857 "cdx device resource<%d> file creation failed: %d", i, ret);
868 device_del(&cdx_dev->dev);
874 put_device(&cdx_dev->dev);
880 struct device *cdx_bus_add(struct cdx_controller *cdx, u8 bus_num)
889 device_initialize(&cdx_dev->dev);
890 cdx_dev->cdx = cdx;
892 cdx_dev->dev.parent = cdx->dev;
893 cdx_dev->dev.bus = &cdx_bus_type;
894 cdx_dev->dev.release = cdx_device_release;
895 cdx_dev->is_bus = true;
896 cdx_dev->bus_num = bus_num;
898 dev_set_name(&cdx_dev->dev, "cdx-%02x",
899 ((cdx->id << CDX_CONTROLLER_ID_SHIFT) | (bus_num & CDX_BUS_NUM_MASK)));
901 ret = device_add(&cdx_dev->dev);
903 dev_err(&cdx_dev->dev, "cdx bus device add failed: %d\n", ret);
907 if (cdx->ops->bus_enable) {
908 ret = cdx->ops->bus_enable(cdx, bus_num);
909 if (ret && ret != -EALREADY) {
910 dev_err(cdx->dev, "cdx bus enable failed: %d\n", ret);
915 cdx_dev->enabled = true;
916 return &cdx_dev->dev;
919 device_del(&cdx_dev->dev);
921 put_device(&cdx_dev->dev);
927 int cdx_register_controller(struct cdx_controller *cdx)
931 ret = ida_alloc_range(&cdx_controller_ida, 0, MAX_CDX_CONTROLLERS - 1, GFP_KERNEL);
933 dev_err(cdx->dev,
935 cdx->id = (u8)MAX_CDX_CONTROLLERS;
940 cdx->id = ret;
943 if (cdx->ops->scan)
944 cdx->ops->scan(cdx);
945 cdx->controller_registered = true;
952 void cdx_unregister_controller(struct cdx_controller *cdx)
954 if (cdx->id >= MAX_CDX_CONTROLLERS)
959 cdx->controller_registered = false;
960 device_for_each_child(cdx->dev, NULL, cdx_unregister_device);
961 ida_free(&cdx_controller_ida, cdx->id);