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/device-id/cdx.h>
15 #include <linux/msi.h>
16
17 #define MAX_CDX_DEV_RESOURCES 4
18 #define CDX_CONTROLLER_ID_SHIFT 4
19 #define CDX_BUS_NUM_MASK 0xF
20
21 /* Forward declaration for CDX controller */
22 struct cdx_controller;
23
24 enum {
25 CDX_DEV_MSI_CONF,
26 CDX_DEV_BUS_MASTER_CONF,
27 CDX_DEV_RESET_CONF,
28 CDX_DEV_MSI_ENABLE,
29 };
30
31 struct cdx_msi_config {
32 u64 addr;
33 u32 data;
34 u16 msi_index;
35 };
36
37 struct cdx_device_config {
38 u8 type;
39 union {
40 struct cdx_msi_config msi;
41 bool bus_master_enable;
42 bool msi_enable;
43 };
44 };
45
46 typedef int (*cdx_bus_enable_cb)(struct cdx_controller *cdx, u8 bus_num);
47
48 typedef int (*cdx_bus_disable_cb)(struct cdx_controller *cdx, u8 bus_num);
49
50 typedef int (*cdx_scan_cb)(struct cdx_controller *cdx);
51
52 typedef int (*cdx_dev_configure_cb)(struct cdx_controller *cdx,
53 u8 bus_num, u8 dev_num,
54 struct cdx_device_config *dev_config);
55
56 /**
57 * CDX_DEVICE - macro used to describe a specific CDX device
58 * @vend: the 16 bit CDX Vendor ID
59 * @dev: the 16 bit CDX Device ID
60 *
61 * This macro is used to create a struct cdx_device_id that matches a
62 * specific device. The subvendor and subdevice fields will be set to
63 * CDX_ANY_ID.
64 */
65 #define CDX_DEVICE(vend, dev) \
66 .vendor = (vend), .device = (dev), \
67 .subvendor = CDX_ANY_ID, .subdevice = CDX_ANY_ID
68
69 /**
70 * CDX_DEVICE_DRIVER_OVERRIDE - macro used to describe a CDX device with
71 * override_only flags.
72 * @vend: the 16 bit CDX Vendor ID
73 * @dev: the 16 bit CDX Device ID
74 * @driver_override: the 32 bit CDX Device override_only
75 *
76 * This macro is used to create a struct cdx_device_id that matches only a
77 * driver_override device. The subvendor and subdevice fields will be set to
78 * CDX_ANY_ID.
79 */
80 #define CDX_DEVICE_DRIVER_OVERRIDE(vend, dev, driver_override) \
81 .vendor = (vend), .device = (dev), .subvendor = CDX_ANY_ID,\
82 .subdevice = CDX_ANY_ID, .override_only = (driver_override)
83
84 /**
85 * struct cdx_ops - Callbacks supported by CDX controller.
86 * @bus_enable: enable bus on the controller
87 * @bus_disable: disable bus on the controller
88 * @scan: scan the devices on the controller
89 * @dev_configure: configuration like reset, master_enable,
90 * msi_config etc for a CDX device
91 */
92 struct cdx_ops {
93 cdx_bus_enable_cb bus_enable;
94 cdx_bus_disable_cb bus_disable;
95 cdx_scan_cb scan;
96 cdx_dev_configure_cb dev_configure;
97 };
98
99 /**
100 * struct cdx_controller: CDX controller object
101 * @dev: Linux device associated with the CDX controller.
102 * @priv: private data
103 * @msi_domain: MSI domain
104 * @id: Controller ID
105 * @controller_registered: controller registered with bus
106 * @ops: CDX controller ops
107 */
108 struct cdx_controller {
109 struct device *dev;
110 void *priv;
111 struct irq_domain *msi_domain;
112 u32 id;
113 bool controller_registered;
114 struct cdx_ops *ops;
115 };
116
117 /**
118 * struct cdx_device - CDX device object
119 * @dev: Linux driver model device object
120 * @cdx: CDX controller associated with the device
121 * @vendor: Vendor ID for CDX device
122 * @device: Device ID for CDX device
123 * @subsystem_vendor: Subsystem Vendor ID for CDX device
124 * @subsystem_device: Subsystem Device ID for CDX device
125 * @class: Class for the CDX device
126 * @revision: Revision of the CDX device
127 * @bus_num: Bus number for this CDX device
128 * @dev_num: Device number for this device
129 * @res: array of MMIO region entries
130 * @res_attr: resource binary attribute
131 * @debugfs_dir: debugfs directory for this device
132 * @res_count: number of valid MMIO regions
133 * @dma_mask: Default DMA mask
134 * @flags: CDX device flags
135 * @req_id: Requestor ID associated with CDX device
136 * @is_bus: Is this bus device
137 * @enabled: is this bus enabled
138 * @msi_dev_id: MSI Device ID associated with CDX device
139 * @num_msi: Number of MSI's supported by the device
140 * @irqchip_lock: lock to synchronize irq/msi configuration
141 * @msi_write_pending: MSI write pending for this device
142 */
143 struct cdx_device {
144 struct device dev;
145 struct cdx_controller *cdx;
146 u16 vendor;
147 u16 device;
148 u16 subsystem_vendor;
149 u16 subsystem_device;
150 u32 class;
151 u8 revision;
152 u8 bus_num;
153 u8 dev_num;
154 struct resource res[MAX_CDX_DEV_RESOURCES];
155 struct bin_attribute *res_attr[MAX_CDX_DEV_RESOURCES];
156 struct dentry *debugfs_dir;
157 u8 res_count;
158 u64 dma_mask;
159 u16 flags;
160 u32 req_id;
161 bool is_bus;
162 bool enabled;
163 u32 msi_dev_id;
164 u32 num_msi;
165 struct mutex irqchip_lock;
166 bool msi_write_pending;
167 };
168
169 #define to_cdx_device(_dev) \
170 container_of(_dev, struct cdx_device, dev)
171
172 #define cdx_resource_start(dev, num) ((dev)->res[(num)].start)
173 #define cdx_resource_end(dev, num) ((dev)->res[(num)].end)
174 #define cdx_resource_flags(dev, num) ((dev)->res[(num)].flags)
175 #define cdx_resource_len(dev, num) \
176 ((cdx_resource_start((dev), (num)) == 0 && \
177 cdx_resource_end((dev), (num)) == \
178 cdx_resource_start((dev), (num))) ? 0 : \
179 (cdx_resource_end((dev), (num)) - \
180 cdx_resource_start((dev), (num)) + 1))
181 /**
182 * struct cdx_driver - CDX device driver
183 * @driver: Generic device driver
184 * @match_id_table: table of supported device matching Ids
185 * @probe: Function called when a device is added
186 * @remove: Function called when a device is removed
187 * @shutdown: Function called at shutdown time to quiesce the device
188 * @reset_prepare: Function called before is reset to notify driver
189 * @reset_done: Function called after reset is complete to notify driver
190 * @driver_managed_dma: Device driver doesn't use kernel DMA API for DMA.
191 * For most device drivers, no need to care about this flag
192 * as long as all DMAs are handled through the kernel DMA API.
193 * For some special ones, for example VFIO drivers, they know
194 * how to manage the DMA themselves and set this flag so that
195 * the IOMMU layer will allow them to setup and manage their
196 * own I/O address space.
197 */
198 struct cdx_driver {
199 struct device_driver driver;
200 const struct cdx_device_id *match_id_table;
201 int (*probe)(struct cdx_device *dev);
202 int (*remove)(struct cdx_device *dev);
203 void (*shutdown)(struct cdx_device *dev);
204 void (*reset_prepare)(struct cdx_device *dev);
205 void (*reset_done)(struct cdx_device *dev);
206 bool driver_managed_dma;
207 };
208
209 #define to_cdx_driver(_drv) \
210 container_of_const(_drv, struct cdx_driver, driver)
211
212 /* Macro to avoid include chaining to get THIS_MODULE */
213 #define cdx_driver_register(drv) \
214 __cdx_driver_register(drv, THIS_MODULE)
215
216 /**
217 * __cdx_driver_register - registers a CDX device driver
218 * @cdx_driver: CDX driver to register
219 * @owner: module owner
220 *
221 * Return: -errno on failure, 0 on success.
222 */
223 int __must_check __cdx_driver_register(struct cdx_driver *cdx_driver,
224 struct module *owner);
225
226 /**
227 * cdx_driver_unregister - unregisters a device driver from the
228 * CDX bus.
229 * @cdx_driver: CDX driver to register
230 */
231 void cdx_driver_unregister(struct cdx_driver *cdx_driver);
232
233 extern const struct bus_type cdx_bus_type;
234
235 /**
236 * cdx_dev_reset - Reset CDX device
237 * @dev: device pointer
238 *
239 * Return: 0 for success, -errno on failure
240 */
241 int cdx_dev_reset(struct device *dev);
242
243 /**
244 * cdx_set_master - enables bus-mastering for CDX device
245 * @cdx_dev: the CDX device to enable
246 *
247 * Return: 0 for success, -errno on failure
248 */
249 int cdx_set_master(struct cdx_device *cdx_dev);
250
251 /**
252 * cdx_clear_master - disables bus-mastering for CDX device
253 * @cdx_dev: the CDX device to disable
254 *
255 * Return: 0 for success, -errno on failure
256 */
257 int cdx_clear_master(struct cdx_device *cdx_dev);
258
259 #ifdef CONFIG_GENERIC_MSI_IRQ
260 /**
261 * cdx_enable_msi - Enable MSI for the CDX device.
262 * @cdx_dev: device pointer
263 *
264 * Return: 0 for success, -errno on failure
265 */
266 int cdx_enable_msi(struct cdx_device *cdx_dev);
267
268 /**
269 * cdx_disable_msi - Disable MSI for the CDX device.
270 * @cdx_dev: device pointer
271 */
272 void cdx_disable_msi(struct cdx_device *cdx_dev);
273
274 #else /* CONFIG_GENERIC_MSI_IRQ */
275
cdx_enable_msi(struct cdx_device * cdx_dev)276 static inline int cdx_enable_msi(struct cdx_device *cdx_dev)
277 {
278 return -ENODEV;
279 }
280
cdx_disable_msi(struct cdx_device * cdx_dev)281 static inline void cdx_disable_msi(struct cdx_device *cdx_dev)
282 {
283 }
284
285 #endif /* CONFIG_GENERIC_MSI_IRQ */
286
287 #endif /* _CDX_BUS_H_ */
288