Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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 */
21struct cdx_controller;
22
23enum {
24 CDX_DEV_BUS_MASTER_CONF,
25 CDX_DEV_RESET_CONF,
26};
27
28struct cdx_device_config {
29 u8 type;
30 bool bus_master_enable;
31};
32
33typedef int (*cdx_bus_enable_cb)(struct cdx_controller *cdx, u8 bus_num);
34
35typedef int (*cdx_bus_disable_cb)(struct cdx_controller *cdx, u8 bus_num);
36
37typedef int (*cdx_scan_cb)(struct cdx_controller *cdx);
38
39typedef 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 */
79struct 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 */
94struct 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 */
127struct 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 */
179struct 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 */
204int __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 */
212void cdx_driver_unregister(struct cdx_driver *cdx_driver);
213
214extern 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 */
222int 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 */
230int 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 */
238int cdx_clear_master(struct cdx_device *cdx_dev);
239
240#endif /* _CDX_BUS_H_ */