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_bus_enable_cb)(struct cdx_controller *cdx, u8 bus_num); 34 35 typedef int (*cdx_bus_disable_cb)(struct cdx_controller *cdx, u8 bus_num); 36 37 typedef int (*cdx_scan_cb)(struct cdx_controller *cdx); 38 39 typedef int (*cdx_dev_configure_cb)(struct cdx_controller *cdx, 40 u8 bus_num, u8 dev_num, 41 struct cdx_device_config *dev_config); 42 43 /** 44 * CDX_DEVICE - macro used to describe a specific CDX device 45 * @vend: the 16 bit CDX Vendor ID 46 * @dev: the 16 bit CDX Device ID 47 * 48 * This macro is used to create a struct cdx_device_id that matches a 49 * specific device. The subvendor and subdevice fields will be set to 50 * CDX_ANY_ID. 51 */ 52 #define CDX_DEVICE(vend, dev) \ 53 .vendor = (vend), .device = (dev), \ 54 .subvendor = CDX_ANY_ID, .subdevice = CDX_ANY_ID 55 56 /** 57 * CDX_DEVICE_DRIVER_OVERRIDE - macro used to describe a CDX device with 58 * override_only flags. 59 * @vend: the 16 bit CDX Vendor ID 60 * @dev: the 16 bit CDX Device ID 61 * @driver_override: the 32 bit CDX Device override_only 62 * 63 * This macro is used to create a struct cdx_device_id that matches only a 64 * driver_override device. The subvendor and subdevice fields will be set to 65 * CDX_ANY_ID. 66 */ 67 #define CDX_DEVICE_DRIVER_OVERRIDE(vend, dev, driver_override) \ 68 .vendor = (vend), .device = (dev), .subvendor = CDX_ANY_ID,\ 69 .subdevice = CDX_ANY_ID, .override_only = (driver_override) 70 71 /** 72 * struct cdx_ops - Callbacks supported by CDX controller. 73 * @bus_enable: enable bus on the controller 74 * @bus_disable: disable bus on the controller 75 * @scan: scan the devices on the controller 76 * @dev_configure: configuration like reset, master_enable, 77 * msi_config etc for a CDX device 78 */ 79 struct cdx_ops { 80 cdx_bus_enable_cb bus_enable; 81 cdx_bus_disable_cb bus_disable; 82 cdx_scan_cb scan; 83 cdx_dev_configure_cb dev_configure; 84 }; 85 86 /** 87 * struct cdx_controller: CDX controller object 88 * @dev: Linux device associated with the CDX controller. 89 * @priv: private data 90 * @id: Controller ID 91 * @controller_registered: controller registered with bus 92 * @ops: CDX controller ops 93 */ 94 struct cdx_controller { 95 struct device *dev; 96 void *priv; 97 u32 id; 98 bool controller_registered; 99 struct cdx_ops *ops; 100 }; 101 102 /** 103 * struct cdx_device - CDX device object 104 * @dev: Linux driver model device object 105 * @cdx: CDX controller associated with the device 106 * @vendor: Vendor ID for CDX device 107 * @device: Device ID for CDX device 108 * @subsystem_vendor: Subsystem Vendor ID for CDX device 109 * @subsystem_device: Subsystem Device ID for CDX device 110 * @class: Class for the CDX device 111 * @revision: Revision of the CDX device 112 * @bus_num: Bus number for this CDX device 113 * @dev_num: Device number for this device 114 * @res: array of MMIO region entries 115 * @res_attr: resource binary attribute 116 * @debugfs_dir: debugfs directory for this device 117 * @res_count: number of valid MMIO regions 118 * @dma_mask: Default DMA mask 119 * @flags: CDX device flags 120 * @req_id: Requestor ID associated with CDX device 121 * @is_bus: Is this bus device 122 * @enabled: is this bus enabled 123 * @driver_override: driver name to force a match; do not set directly, 124 * because core frees it; use driver_set_override() to 125 * set or clear it. 126 */ 127 struct cdx_device { 128 struct device dev; 129 struct cdx_controller *cdx; 130 u16 vendor; 131 u16 device; 132 u16 subsystem_vendor; 133 u16 subsystem_device; 134 u32 class; 135 u8 revision; 136 u8 bus_num; 137 u8 dev_num; 138 struct resource res[MAX_CDX_DEV_RESOURCES]; 139 struct bin_attribute *res_attr[MAX_CDX_DEV_RESOURCES]; 140 struct dentry *debugfs_dir; 141 u8 res_count; 142 u64 dma_mask; 143 u16 flags; 144 u32 req_id; 145 bool is_bus; 146 bool enabled; 147 const char *driver_override; 148 }; 149 150 #define to_cdx_device(_dev) \ 151 container_of(_dev, struct cdx_device, dev) 152 153 #define cdx_resource_start(dev, num) ((dev)->res[(num)].start) 154 #define cdx_resource_end(dev, num) ((dev)->res[(num)].end) 155 #define cdx_resource_flags(dev, num) ((dev)->res[(num)].flags) 156 #define cdx_resource_len(dev, num) \ 157 ((cdx_resource_start((dev), (num)) == 0 && \ 158 cdx_resource_end((dev), (num)) == \ 159 cdx_resource_start((dev), (num))) ? 0 : \ 160 (cdx_resource_end((dev), (num)) - \ 161 cdx_resource_start((dev), (num)) + 1)) 162 /** 163 * struct cdx_driver - CDX device driver 164 * @driver: Generic device driver 165 * @match_id_table: table of supported device matching Ids 166 * @probe: Function called when a device is added 167 * @remove: Function called when a device is removed 168 * @shutdown: Function called at shutdown time to quiesce the device 169 * @reset_prepare: Function called before is reset to notify driver 170 * @reset_done: Function called after reset is complete to notify driver 171 * @driver_managed_dma: Device driver doesn't use kernel DMA API for DMA. 172 * For most device drivers, no need to care about this flag 173 * as long as all DMAs are handled through the kernel DMA API. 174 * For some special ones, for example VFIO drivers, they know 175 * how to manage the DMA themselves and set this flag so that 176 * the IOMMU layer will allow them to setup and manage their 177 * own I/O address space. 178 */ 179 struct cdx_driver { 180 struct device_driver driver; 181 const struct cdx_device_id *match_id_table; 182 int (*probe)(struct cdx_device *dev); 183 int (*remove)(struct cdx_device *dev); 184 void (*shutdown)(struct cdx_device *dev); 185 void (*reset_prepare)(struct cdx_device *dev); 186 void (*reset_done)(struct cdx_device *dev); 187 bool driver_managed_dma; 188 }; 189 190 #define to_cdx_driver(_drv) \ 191 container_of(_drv, struct cdx_driver, driver) 192 193 /* Macro to avoid include chaining to get THIS_MODULE */ 194 #define cdx_driver_register(drv) \ 195 __cdx_driver_register(drv, THIS_MODULE) 196 197 /** 198 * __cdx_driver_register - registers a CDX device driver 199 * @cdx_driver: CDX driver to register 200 * @owner: module owner 201 * 202 * Return: -errno on failure, 0 on success. 203 */ 204 int __must_check __cdx_driver_register(struct cdx_driver *cdx_driver, 205 struct module *owner); 206 207 /** 208 * cdx_driver_unregister - unregisters a device driver from the 209 * CDX bus. 210 * @cdx_driver: CDX driver to register 211 */ 212 void cdx_driver_unregister(struct cdx_driver *cdx_driver); 213 214 extern struct bus_type cdx_bus_type; 215 216 /** 217 * cdx_dev_reset - Reset CDX device 218 * @dev: device pointer 219 * 220 * Return: 0 for success, -errno on failure 221 */ 222 int cdx_dev_reset(struct device *dev); 223 224 /** 225 * cdx_set_master - enables bus-mastering for CDX device 226 * @cdx_dev: the CDX device to enable 227 * 228 * Return: 0 for success, -errno on failure 229 */ 230 int cdx_set_master(struct cdx_device *cdx_dev); 231 232 /** 233 * cdx_clear_master - disables bus-mastering for CDX device 234 * @cdx_dev: the CDX device to disable 235 * 236 * Return: 0 for success, -errno on failure 237 */ 238 int cdx_clear_master(struct cdx_device *cdx_dev); 239 240 #endif /* _CDX_BUS_H_ */ 241