shell bypass 403
UnknownSec Shell
:
/
usr
/
src
/
linux-headers-6.8.0-83-generic
/
include
/
linux
/
cdx
/ [
drwxr-xr-x
]
upload
mass deface
mass delete
console
info server
name :
cdx_bus.h
/* SPDX-License-Identifier: GPL-2.0 * * CDX bus public interface * * Copyright (C) 2022-2023, Advanced Micro Devices, Inc. * */ #ifndef _CDX_BUS_H_ #define _CDX_BUS_H_ #include <linux/device.h> #include <linux/list.h> #include <linux/mod_devicetable.h> #define MAX_CDX_DEV_RESOURCES 4 #define CDX_CONTROLLER_ID_SHIFT 4 #define CDX_BUS_NUM_MASK 0xF /* Forward declaration for CDX controller */ struct cdx_controller; enum { CDX_DEV_BUS_MASTER_CONF, CDX_DEV_RESET_CONF, }; struct cdx_device_config { u8 type; bool bus_master_enable; }; typedef int (*cdx_bus_enable_cb)(struct cdx_controller *cdx, u8 bus_num); typedef int (*cdx_bus_disable_cb)(struct cdx_controller *cdx, u8 bus_num); typedef int (*cdx_scan_cb)(struct cdx_controller *cdx); typedef int (*cdx_dev_configure_cb)(struct cdx_controller *cdx, u8 bus_num, u8 dev_num, struct cdx_device_config *dev_config); /** * CDX_DEVICE - macro used to describe a specific CDX device * @vend: the 16 bit CDX Vendor ID * @dev: the 16 bit CDX Device ID * * This macro is used to create a struct cdx_device_id that matches a * specific device. The subvendor and subdevice fields will be set to * CDX_ANY_ID. */ #define CDX_DEVICE(vend, dev) \ .vendor = (vend), .device = (dev), \ .subvendor = CDX_ANY_ID, .subdevice = CDX_ANY_ID /** * CDX_DEVICE_DRIVER_OVERRIDE - macro used to describe a CDX device with * override_only flags. * @vend: the 16 bit CDX Vendor ID * @dev: the 16 bit CDX Device ID * @driver_override: the 32 bit CDX Device override_only * * This macro is used to create a struct cdx_device_id that matches only a * driver_override device. The subvendor and subdevice fields will be set to * CDX_ANY_ID. */ #define CDX_DEVICE_DRIVER_OVERRIDE(vend, dev, driver_override) \ .vendor = (vend), .device = (dev), .subvendor = CDX_ANY_ID,\ .subdevice = CDX_ANY_ID, .override_only = (driver_override) /** * struct cdx_ops - Callbacks supported by CDX controller. * @bus_enable: enable bus on the controller * @bus_disable: disable bus on the controller * @scan: scan the devices on the controller * @dev_configure: configuration like reset, master_enable, * msi_config etc for a CDX device */ struct cdx_ops { cdx_bus_enable_cb bus_enable; cdx_bus_disable_cb bus_disable; cdx_scan_cb scan; cdx_dev_configure_cb dev_configure; }; /** * struct cdx_controller: CDX controller object * @dev: Linux device associated with the CDX controller. * @priv: private data * @id: Controller ID * @controller_registered: controller registered with bus * @ops: CDX controller ops */ struct cdx_controller { struct device *dev; void *priv; u32 id; bool controller_registered; struct cdx_ops *ops; }; /** * struct cdx_device - CDX device object * @dev: Linux driver model device object * @cdx: CDX controller associated with the device * @vendor: Vendor ID for CDX device * @device: Device ID for CDX device * @subsystem_vendor: Subsystem Vendor ID for CDX device * @subsystem_device: Subsystem Device ID for CDX device * @class: Class for the CDX device * @revision: Revision of the CDX device * @bus_num: Bus number for this CDX device * @dev_num: Device number for this device * @res: array of MMIO region entries * @res_attr: resource binary attribute * @debugfs_dir: debugfs directory for this device * @res_count: number of valid MMIO regions * @dma_mask: Default DMA mask * @flags: CDX device flags * @req_id: Requestor ID associated with CDX device * @is_bus: Is this bus device * @enabled: is this bus enabled * @driver_override: driver name to force a match; do not set directly, * because core frees it; use driver_set_override() to * set or clear it. */ struct cdx_device { struct device dev; struct cdx_controller *cdx; u16 vendor; u16 device; u16 subsystem_vendor; u16 subsystem_device; u32 class; u8 revision; u8 bus_num; u8 dev_num; struct resource res[MAX_CDX_DEV_RESOURCES]; struct bin_attribute *res_attr[MAX_CDX_DEV_RESOURCES]; struct dentry *debugfs_dir; u8 res_count; u64 dma_mask; u16 flags; u32 req_id; bool is_bus; bool enabled; const char *driver_override; }; #define to_cdx_device(_dev) \ container_of(_dev, struct cdx_device, dev) #define cdx_resource_start(dev, num) ((dev)->res[(num)].start) #define cdx_resource_end(dev, num) ((dev)->res[(num)].end) #define cdx_resource_flags(dev, num) ((dev)->res[(num)].flags) #define cdx_resource_len(dev, num) \ ((cdx_resource_start((dev), (num)) == 0 && \ cdx_resource_end((dev), (num)) == \ cdx_resource_start((dev), (num))) ? 0 : \ (cdx_resource_end((dev), (num)) - \ cdx_resource_start((dev), (num)) + 1)) /** * struct cdx_driver - CDX device driver * @driver: Generic device driver * @match_id_table: table of supported device matching Ids * @probe: Function called when a device is added * @remove: Function called when a device is removed * @shutdown: Function called at shutdown time to quiesce the device * @reset_prepare: Function called before is reset to notify driver * @reset_done: Function called after reset is complete to notify driver * @driver_managed_dma: Device driver doesn't use kernel DMA API for DMA. * For most device drivers, no need to care about this flag * as long as all DMAs are handled through the kernel DMA API. * For some special ones, for example VFIO drivers, they know * how to manage the DMA themselves and set this flag so that * the IOMMU layer will allow them to setup and manage their * own I/O address space. */ struct cdx_driver { struct device_driver driver; const struct cdx_device_id *match_id_table; int (*probe)(struct cdx_device *dev); int (*remove)(struct cdx_device *dev); void (*shutdown)(struct cdx_device *dev); void (*reset_prepare)(struct cdx_device *dev); void (*reset_done)(struct cdx_device *dev); bool driver_managed_dma; }; #define to_cdx_driver(_drv) \ container_of(_drv, struct cdx_driver, driver) /* Macro to avoid include chaining to get THIS_MODULE */ #define cdx_driver_register(drv) \ __cdx_driver_register(drv, THIS_MODULE) /** * __cdx_driver_register - registers a CDX device driver * @cdx_driver: CDX driver to register * @owner: module owner * * Return: -errno on failure, 0 on success. */ int __must_check __cdx_driver_register(struct cdx_driver *cdx_driver, struct module *owner); /** * cdx_driver_unregister - unregisters a device driver from the * CDX bus. * @cdx_driver: CDX driver to register */ void cdx_driver_unregister(struct cdx_driver *cdx_driver); extern struct bus_type cdx_bus_type; /** * cdx_dev_reset - Reset CDX device * @dev: device pointer * * Return: 0 for success, -errno on failure */ int cdx_dev_reset(struct device *dev); /** * cdx_set_master - enables bus-mastering for CDX device * @cdx_dev: the CDX device to enable * * Return: 0 for success, -errno on failure */ int cdx_set_master(struct cdx_device *cdx_dev); /** * cdx_clear_master - disables bus-mastering for CDX device * @cdx_dev: the CDX device to disable * * Return: 0 for success, -errno on failure */ int cdx_clear_master(struct cdx_device *cdx_dev); #endif /* _CDX_BUS_H_ */
© 2026 UnknownSec