include/linux/cdx/cdx_bus.h

   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 #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  * @driver_override: driver name to force a match; do not set directly,
 141  *                   because core frees it; use driver_set_override() to
 142  *                   set or clear it.
 143  * @irqchip_lock: lock to synchronize irq/msi configuration
 144  * @msi_write_pending: MSI write pending for this device
 145  */
 146 struct cdx_device {
 147         struct device dev;
 148         struct cdx_controller *cdx;
 149         u16 vendor;
 150         u16 device;
 151         u16 subsystem_vendor;
 152         u16 subsystem_device;
 153         u32 class;
 154         u8 revision;
 155         u8 bus_num;
 156         u8 dev_num;
 157         struct resource res[MAX_CDX_DEV_RESOURCES];
 158         struct bin_attribute *res_attr[MAX_CDX_DEV_RESOURCES];
 159         struct dentry *debugfs_dir;
 160         u8 res_count;
 161         u64 dma_mask;
 162         u16 flags;
 163         u32 req_id;
 164         bool is_bus;
 165         bool enabled;
 166         u32 msi_dev_id;
 167         u32 num_msi;
 168         const char *driver_override;
 169         struct mutex irqchip_lock;
 170         bool msi_write_pending;
 171 };
 172
 173 #define to_cdx_device(_dev) \
 174         container_of(_dev, struct cdx_device, dev)
 175
 176 #define cdx_resource_start(dev, num)    ((dev)->res[(num)].start)
 177 #define cdx_resource_end(dev, num)      ((dev)->res[(num)].end)
 178 #define cdx_resource_flags(dev, num)    ((dev)->res[(num)].flags)
 179 #define cdx_resource_len(dev, num) \
 180         ((cdx_resource_start((dev), (num)) == 0 &&      \
 181           cdx_resource_end((dev), (num)) ==             \
 182           cdx_resource_start((dev), (num))) ? 0 :       \
 183          (cdx_resource_end((dev), (num)) -              \
 184           cdx_resource_start((dev), (num)) + 1))
 185 /**
 186  * struct cdx_driver - CDX device driver
 187  * @driver: Generic device driver
 188  * @match_id_table: table of supported device matching Ids
 189  * @probe: Function called when a device is added
 190  * @remove: Function called when a device is removed
 191  * @shutdown: Function called at shutdown time to quiesce the device
 192  * @reset_prepare: Function called before is reset to notify driver
 193  * @reset_done: Function called after reset is complete to notify driver
 194  * @driver_managed_dma: Device driver doesn't use kernel DMA API for DMA.
 195  *              For most device drivers, no need to care about this flag
 196  *              as long as all DMAs are handled through the kernel DMA API.
 197  *              For some special ones, for example VFIO drivers, they know
 198  *              how to manage the DMA themselves and set this flag so that
 199  *              the IOMMU layer will allow them to setup and manage their
 200  *              own I/O address space.
 201  */
 202 struct cdx_driver {
 203         struct device_driver driver;
 204         const struct cdx_device_id *match_id_table;
 205         int (*probe)(struct cdx_device *dev);
 206         int (*remove)(struct cdx_device *dev);
 207         void (*shutdown)(struct cdx_device *dev);
 208         void (*reset_prepare)(struct cdx_device *dev);
 209         void (*reset_done)(struct cdx_device *dev);
 210         bool driver_managed_dma;
 211 };
 212
 213 #define to_cdx_driver(_drv) \
 214         container_of(_drv, struct cdx_driver, driver)
 215
 216 /* Macro to avoid include chaining to get THIS_MODULE */
 217 #define cdx_driver_register(drv) \
 218         __cdx_driver_register(drv, THIS_MODULE)
 219
 220 /**
 221  * __cdx_driver_register - registers a CDX device driver
 222  * @cdx_driver: CDX driver to register
 223  * @owner: module owner
 224  *
 225  * Return: -errno on failure, 0 on success.
 226  */
 227 int __must_check __cdx_driver_register(struct cdx_driver *cdx_driver,
 228                                        struct module *owner);
 229
 230 /**
 231  * cdx_driver_unregister - unregisters a device driver from the
 232  * CDX bus.
 233  * @cdx_driver: CDX driver to register
 234  */
 235 void cdx_driver_unregister(struct cdx_driver *cdx_driver);
 236
 237 extern struct bus_type cdx_bus_type;
 238
 239 /**
 240  * cdx_dev_reset - Reset CDX device
 241  * @dev: device pointer
 242  *
 243  * Return: 0 for success, -errno on failure
 244  */
 245 int cdx_dev_reset(struct device *dev);
 246
 247 /**
 248  * cdx_set_master - enables bus-mastering for CDX device
 249  * @cdx_dev: the CDX device to enable
 250  *
 251  * Return: 0 for success, -errno on failure
 252  */
 253 int cdx_set_master(struct cdx_device *cdx_dev);
 254
 255 /**
 256  * cdx_clear_master - disables bus-mastering for CDX device
 257  * @cdx_dev: the CDX device to disable
 258  *
 259  * Return: 0 for success, -errno on failure
 260  */
 261 int cdx_clear_master(struct cdx_device *cdx_dev);
 262
 263 #ifdef CONFIG_GENERIC_MSI_IRQ
 264 /**
 265  * cdx_enable_msi - Enable MSI for the CDX device.
 266  * @cdx_dev: device pointer
 267  *
 268  * Return: 0 for success, -errno on failure
 269  */
 270 int cdx_enable_msi(struct cdx_device *cdx_dev);
 271
 272 /**
 273  * cdx_disable_msi - Disable MSI for the CDX device.
 274  * @cdx_dev: device pointer
 275  */
 276 void cdx_disable_msi(struct cdx_device *cdx_dev);
 277
 278 #else /* CONFIG_GENERIC_MSI_IRQ */
 279
 280 static inline int cdx_enable_msi(struct cdx_device *cdx_dev)
 281 {
 282         return -ENODEV;
 283 }
 284
 285 static inline void cdx_disable_msi(struct cdx_device *cdx_dev)
 286 {
 287 }
 288
 289 #endif /* CONFIG_GENERIC_MSI_IRQ */
 290
 291 #endif /* _CDX_BUS_H_ */