1 /* SPDX-License-Identifier: GPL-2.0 2 * 3 * CDX bus public interface 4 * 5 * Copyright (C) 2022-2023, Advanced Micro Devices, Inc. 6 * 7 */ 8 9 #ifndef _CDX_BUS_H_ 10 #define _CDX_BUS_H_ 11 12 #include <linux/device.h> 13 #include <linux/list.h> 14 #include <linux/mod_devicetable.h> 15 16 #define MAX_CDX_DEV_RESOURCES 4 17 #define CDX_CONTROLLER_ID_SHIFT 4 18 #define CDX_BUS_NUM_MASK 0xF 19 20 /* Forward declaration for CDX controller */ 21 struct cdx_controller; 22 23 enum { 24 CDX_DEV_BUS_MASTER_CONF, 25 CDX_DEV_RESET_CONF, 26 }; 27 28 struct cdx_device_config { 29 u8 type; 30 bool bus_master_enable; 31 }; 32 33 typedef int (*cdx_scan_cb)(struct cdx_controller *cdx); 34 35 typedef int (*cdx_dev_configure_cb)(struct cdx_controller *cdx, 36 u8 bus_num, u8 dev_num, 37 struct cdx_device_config *dev_config); 38 39 /** 40 * CDX_DEVICE_DRIVER_OVERRIDE - macro used to describe a CDX device with 41 * override_only flags. 42 * @vend: the 16 bit CDX Vendor ID 43 * @dev: the 16 bit CDX Device ID 44 * @driver_override: the 32 bit CDX Device override_only 45 * 46 * This macro is used to create a struct cdx_device_id that matches only a 47 * driver_override device. 48 */ 49 #define CDX_DEVICE_DRIVER_OVERRIDE(vend, dev, driver_override) \ 50 .vendor = (vend), .device = (dev), .override_only = (driver_override) 51 52 /** 53 * struct cdx_ops - Callbacks supported by CDX controller. 54 * @scan: scan the devices on the controller 55 * @dev_configure: configuration like reset, master_enable, 56 * msi_config etc for a CDX device 57 */ 58 struct cdx_ops { 59 cdx_scan_cb scan; 60 cdx_dev_configure_cb dev_configure; 61 }; 62 63 /** 64 * struct cdx_controller: CDX controller object 65 * @dev: Linux device associated with the CDX controller. 66 * @priv: private data 67 * @id: Controller ID 68 * @ops: CDX controller ops 69 */ 70 struct cdx_controller { 71 struct device *dev; 72 void *priv; 73 u32 id; 74 struct cdx_ops *ops; 75 }; 76 77 /** 78 * struct cdx_device - CDX device object 79 * @dev: Linux driver model device object 80 * @cdx: CDX controller associated with the device 81 * @vendor: Vendor ID for CDX device 82 * @device: Device ID for CDX device 83 * @bus_num: Bus number for this CDX device 84 * @dev_num: Device number for this device 85 * @res: array of MMIO region entries 86 * @res_attr: resource binary attribute 87 * @res_count: number of valid MMIO regions 88 * @dma_mask: Default DMA mask 89 * @flags: CDX device flags 90 * @req_id: Requestor ID associated with CDX device 91 * @driver_override: driver name to force a match; do not set directly, 92 * because core frees it; use driver_set_override() to 93 * set or clear it. 94 */ 95 struct cdx_device { 96 struct device dev; 97 struct cdx_controller *cdx; 98 u16 vendor; 99 u16 device; 100 u8 bus_num; 101 u8 dev_num; 102 struct resource res[MAX_CDX_DEV_RESOURCES]; 103 u8 res_count; 104 u64 dma_mask; 105 u16 flags; 106 u32 req_id; 107 const char *driver_override; 108 }; 109 110 #define to_cdx_device(_dev) \ 111 container_of(_dev, struct cdx_device, dev) 112 113 /** 114 * struct cdx_driver - CDX device driver 115 * @driver: Generic device driver 116 * @match_id_table: table of supported device matching Ids 117 * @probe: Function called when a device is added 118 * @remove: Function called when a device is removed 119 * @shutdown: Function called at shutdown time to quiesce the device 120 * @reset_prepare: Function called before is reset to notify driver 121 * @reset_done: Function called after reset is complete to notify driver 122 * @driver_managed_dma: Device driver doesn't use kernel DMA API for DMA. 123 * For most device drivers, no need to care about this flag 124 * as long as all DMAs are handled through the kernel DMA API. 125 * For some special ones, for example VFIO drivers, they know 126 * how to manage the DMA themselves and set this flag so that 127 * the IOMMU layer will allow them to setup and manage their 128 * own I/O address space. 129 */ 130 struct cdx_driver { 131 struct device_driver driver; 132 const struct cdx_device_id *match_id_table; 133 int (*probe)(struct cdx_device *dev); 134 int (*remove)(struct cdx_device *dev); 135 void (*shutdown)(struct cdx_device *dev); 136 void (*reset_prepare)(struct cdx_device *dev); 137 void (*reset_done)(struct cdx_device *dev); 138 bool driver_managed_dma; 139 }; 140 141 #define to_cdx_driver(_drv) \ 142 container_of(_drv, struct cdx_driver, driver) 143 144 /* Macro to avoid include chaining to get THIS_MODULE */ 145 #define cdx_driver_register(drv) \ 146 __cdx_driver_register(drv, THIS_MODULE) 147 148 /** 149 * __cdx_driver_register - registers a CDX device driver 150 * @cdx_driver: CDX driver to register 151 * @owner: module owner 152 * 153 * Return: -errno on failure, 0 on success. 154 */ 155 int __must_check __cdx_driver_register(struct cdx_driver *cdx_driver, 156 struct module *owner); 157 158 /** 159 * cdx_driver_unregister - unregisters a device driver from the 160 * CDX bus. 161 * @cdx_driver: CDX driver to register 162 */ 163 void cdx_driver_unregister(struct cdx_driver *cdx_driver); 164 165 extern struct bus_type cdx_bus_type; 166 167 /** 168 * cdx_dev_reset - Reset CDX device 169 * @dev: device pointer 170 * 171 * Return: 0 for success, -errno on failure 172 */ 173 int cdx_dev_reset(struct device *dev); 174 175 /** 176 * cdx_set_master - enables bus-mastering for CDX device 177 * @cdx_dev: the CDX device to enable 178 * 179 * Return: 0 for success, -errno on failure 180 */ 181 int cdx_set_master(struct cdx_device *cdx_dev); 182 183 /** 184 * cdx_clear_master - disables bus-mastering for CDX device 185 * @cdx_dev: the CDX device to disable 186 * 187 * Return: 0 for success, -errno on failure 188 */ 189 int cdx_clear_master(struct cdx_device *cdx_dev); 190 191 #endif /* _CDX_BUS_H_ */ 192