Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
C
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757/* SPDX-License-Identifier: GPL-2.0 *//* * Thunderbolt service API * * Copyright (C) 2014 Andreas Noever <andreas.noever@gmail.com> * Copyright (C) 2017, Intel Corporation * Authors: Michael Jamet <michael.jamet@intel.com> * Mika Westerberg <mika.westerberg@linux.intel.com> */
#ifndef THUNDERBOLT_H_#define THUNDERBOLT_H_
#include <linux/types.h>
struct config_group;struct fwnode_handle;struct device;
#if IS_REACHABLE(CONFIG_USB4)
#include <linux/device.h>#include <linux/idr.h>#include <linux/list.h>#include <linux/lockdep.h>#include <linux/mutex.h>#include <linux/device-id/tb.h>#include <linux/pci.h>#include <linux/uuid.h>#include <linux/workqueue.h>
enum tb_cfg_pkg_type { TB_CFG_PKG_READ = 1, TB_CFG_PKG_WRITE = 2, TB_CFG_PKG_ERROR = 3, TB_CFG_PKG_NOTIFY_ACK = 4, TB_CFG_PKG_EVENT = 5, TB_CFG_PKG_XDOMAIN_REQ = 6, TB_CFG_PKG_XDOMAIN_RESP = 7, TB_CFG_PKG_OVERRIDE = 8, TB_CFG_PKG_RESET = 9, TB_CFG_PKG_ICM_EVENT = 10, TB_CFG_PKG_ICM_CMD = 11, TB_CFG_PKG_ICM_RESP = 12,};
/** * enum tb_security_level - Thunderbolt security level * @TB_SECURITY_NONE: No security, legacy mode * @TB_SECURITY_USER: User approval required at minimum * @TB_SECURITY_SECURE: One time saved key required at minimum * @TB_SECURITY_DPONLY: Only tunnel Display port (and USB) * @TB_SECURITY_USBONLY: Only tunnel USB controller of the connected * Thunderbolt dock (and Display Port). All PCIe * links downstream of the dock are removed. * @TB_SECURITY_NOPCIE: For USB4 systems this level is used when the * PCIe tunneling is disabled from the BIOS. */enum tb_security_level { TB_SECURITY_NONE, TB_SECURITY_USER, TB_SECURITY_SECURE, TB_SECURITY_DPONLY, TB_SECURITY_USBONLY, TB_SECURITY_NOPCIE,};
/** * struct tb - main thunderbolt bus structure * @dev: Domain device * @lock: Big lock. Must be held when accessing any struct * tb_switch / struct tb_port. * @nhi: Pointer to the NHI structure * @ctl: Control channel for this domain * @wq: Ordered workqueue for all domain specific work * @root_switch: Root switch of this domain * @cm_ops: Connection manager specific operations vector * @index: Linux assigned domain number * @security_level: Current security level * @nboot_acl: Number of boot ACLs the domain supports * @privdata: Private connection manager specific data */struct tb { struct device dev; struct mutex lock; struct tb_nhi *nhi; struct tb_ctl *ctl; struct workqueue_struct *wq; struct tb_switch *root_switch; const struct tb_cm_ops *cm_ops; int index; enum tb_security_level security_level; size_t nboot_acl; unsigned long privdata[];};
extern const struct bus_type tb_bus_type;extern const struct device_type tb_service_type;extern const struct device_type tb_xdomain_type;
#define TB_LINKS_PER_PHY_PORT 2
static inline unsigned int tb_phy_port_from_link(unsigned int link){ return (link - 1) / TB_LINKS_PER_PHY_PORT;}
/** * struct tb_property_dir - XDomain property directory * @uuid: Directory UUID or %NULL if root directory * @properties: List of properties in this directory * * User needs to provide serialization if needed. */struct tb_property_dir { const uuid_t *uuid; struct list_head properties;};
enum tb_property_type { TB_PROPERTY_TYPE_UNKNOWN = 0x00, TB_PROPERTY_TYPE_DIRECTORY = 0x44, TB_PROPERTY_TYPE_DATA = 0x64, TB_PROPERTY_TYPE_TEXT = 0x74, TB_PROPERTY_TYPE_VALUE = 0x76,};
#define TB_PROPERTY_KEY_SIZE 8
/** * struct tb_property - XDomain property * @list: Used to link properties together in a directory * @key: Key for the property (always terminated). * @type: Type of the property * @length: Length of the property data in dwords * @value: Property value * * Users use @type to determine which field in @value is filled. */struct tb_property { struct list_head list; char key[TB_PROPERTY_KEY_SIZE + 1]; enum tb_property_type type; size_t length; union { struct tb_property_dir *dir; u8 *data; char *text; u32 immediate; } value;};
struct tb_property_dir *tb_property_parse_dir(const u32 *block, size_t block_len);ssize_t tb_property_format_dir(const struct tb_property_dir *dir, u32 *block, size_t block_len);struct tb_property_dir *tb_property_copy_dir(const struct tb_property_dir *dir);int tb_property_merge_dir(struct tb_property_dir *parent, const struct tb_property_dir *dir, bool replace);struct tb_property_dir *tb_property_create_dir(const uuid_t *uuid);void tb_property_free_dir(struct tb_property_dir *dir);int tb_property_add_immediate(struct tb_property_dir *parent, const char *key, u32 value);int tb_property_add_data(struct tb_property_dir *parent, const char *key, const void *buf, size_t buflen);int tb_property_add_text(struct tb_property_dir *parent, const char *key, const char *text);int tb_property_add_dir(struct tb_property_dir *parent, const char *key, struct tb_property_dir *dir);void tb_property_remove(struct tb_property *tb_property);struct tb_property *tb_property_find(struct tb_property_dir *dir, const char *key, enum tb_property_type type);struct tb_property *tb_property_get_next(struct tb_property_dir *dir, struct tb_property *prev);
#define tb_property_for_each(dir, property) \ for (property = tb_property_get_next(dir, NULL); \ property; \ property = tb_property_get_next(dir, property))
int tb_register_property_dir(const char *key, struct tb_property_dir *dir);void tb_unregister_property_dir(const char *key, struct tb_property_dir *dir);
/** * enum tb_link_width - Thunderbolt/USB4 link width * @TB_LINK_WIDTH_SINGLE: Single lane link * @TB_LINK_WIDTH_DUAL: Dual lane symmetric link * @TB_LINK_WIDTH_ASYM_TX: Dual lane asymmetric Gen 4 link with 3 transmitters * @TB_LINK_WIDTH_ASYM_RX: Dual lane asymmetric Gen 4 link with 3 receivers */enum tb_link_width { TB_LINK_WIDTH_SINGLE = BIT(0), TB_LINK_WIDTH_DUAL = BIT(1), TB_LINK_WIDTH_ASYM_TX = BIT(2), TB_LINK_WIDTH_ASYM_RX = BIT(3),};
/** * struct tb_xdomain - Cross-domain (XDomain) connection * @dev: XDomain device * @tb: Pointer to the domain * @remote_uuid: UUID of the remote domain (host) * @local_uuid: Cached local UUID * @route: Route string the other domain can be reached * @vendor: Vendor ID of the remote domain * @device: Device ID of the demote domain * @local_max_hopid: Maximum input HopID of this host * @remote_max_hopid: Maximum input HopID of the remote host * @lock: Lock to serialize access to the following fields of this structure * @vendor_name: Name of the vendor (or %NULL if not known) * @device_name: Name of the device (or %NULL if not known) * @link_speed: Speed of the link in Gb/s * @link_width: Width of the downstream facing link * @link_usb4: Downstream link is USB4 * @is_unplugged: The XDomain is unplugged * @removing: Set by tb_xdomain_remove() under @lock to prevent * concurrent delayed work queueing * @needs_uuid: If the XDomain does not have @remote_uuid it will be * queried first * @service_ids: Used to generate IDs for the services * @in_hopids: Input HopIDs for DMA tunneling * @out_hopids: Output HopIDs for DMA tunneling * @local_property_block: Local block of properties * @local_property_block_gen: Generation of @local_property_block * @local_property_block_len: Length of the @local_property_block in dwords * @remote_properties: Properties exported by the remote domain * @remote_property_block_gen: Generation of @remote_properties * @state: Next XDomain discovery state to run * @state_work: Work used to run the next state * @state_retries: Number of retries remain for the state * @properties_changed_work: Work used to notify the remote domain that * our properties have changed * @properties_changed_retries: Number of times left to send properties * changed notification * @bonding_possible: True if lane bonding is possible on local side * @target_link_width: Target link width from the remote host * @ntunnels: Keeps track of how many tunnels go through this XDomain * @link: Root switch link the remote domain is connected (ICM only) * @depth: Depth in the chain the remote domain is connected (ICM only) * * This structure represents connection across two domains (hosts). * Each XDomain contains zero or more services which are exposed as * &struct tb_service objects. * * Service drivers may access this structure if they need to enumerate * non-standard properties but they need hold @lock when doing so * because properties can be changed asynchronously in response to * changes in the remote domain. */struct tb_xdomain { struct device dev; struct tb *tb; uuid_t *remote_uuid; const uuid_t *local_uuid; u64 route; u16 vendor; u16 device; unsigned int local_max_hopid; unsigned int remote_max_hopid; struct mutex lock; const char *vendor_name; const char *device_name; unsigned int link_speed; enum tb_link_width link_width; bool link_usb4; bool is_unplugged; bool removing; bool needs_uuid; struct ida service_ids; struct ida in_hopids; struct ida out_hopids; u32 *local_property_block; u32 local_property_block_gen; u32 local_property_block_len; struct tb_property_dir *remote_properties; u32 remote_property_block_gen; int state; struct delayed_work state_work; int state_retries; struct delayed_work properties_changed_work; int properties_changed_retries; bool bonding_possible; u8 target_link_width; atomic_t ntunnels; u8 link; u8 depth;};
int tb_xdomain_lane_bonding_enable(struct tb_xdomain *xd);void tb_xdomain_lane_bonding_disable(struct tb_xdomain *xd);int tb_xdomain_alloc_in_hopid(struct tb_xdomain *xd, int hopid);void tb_xdomain_release_in_hopid(struct tb_xdomain *xd, int hopid);int tb_xdomain_alloc_out_hopid(struct tb_xdomain *xd, int hopid);void tb_xdomain_release_out_hopid(struct tb_xdomain *xd, int hopid);int tb_xdomain_enable_paths(struct tb_xdomain *xd, int transmit_path, int transmit_ring, int receive_path, int receive_ring);int tb_xdomain_disable_paths(struct tb_xdomain *xd, int transmit_path, int transmit_ring, int receive_path, int receive_ring);
static inline int tb_xdomain_disable_all_paths(struct tb_xdomain *xd){ return tb_xdomain_disable_paths(xd, -1, -1, -1, -1);}
struct tb_xdomain *tb_xdomain_find_by_uuid(struct tb *tb, const uuid_t *uuid);struct tb_xdomain *tb_xdomain_find_by_route(struct tb *tb, u64 route);
static inline struct tb_xdomain *tb_xdomain_find_by_uuid_locked(struct tb *tb, const uuid_t *uuid){ struct tb_xdomain *xd;
mutex_lock(&tb->lock); xd = tb_xdomain_find_by_uuid(tb, uuid); mutex_unlock(&tb->lock);
return xd;}
static inline struct tb_xdomain *tb_xdomain_find_by_route_locked(struct tb *tb, u64 route){ struct tb_xdomain *xd;
mutex_lock(&tb->lock); xd = tb_xdomain_find_by_route(tb, route); mutex_unlock(&tb->lock);
return xd;}
static inline struct tb_xdomain *tb_xdomain_get(struct tb_xdomain *xd){ if (xd) get_device(&xd->dev); return xd;}
static inline void tb_xdomain_put(struct tb_xdomain *xd){ if (xd) put_device(&xd->dev);}
static inline bool tb_is_xdomain(const struct device *dev){ return dev->type == &tb_xdomain_type;}
static inline struct tb_xdomain *tb_to_xdomain(struct device *dev){ if (tb_is_xdomain(dev)) return container_of(dev, struct tb_xdomain, dev); return NULL;}
int tb_xdomain_response(struct tb_xdomain *xd, const void *response, size_t size, enum tb_cfg_pkg_type type);int tb_xdomain_request(struct tb_xdomain *xd, const void *request, size_t request_size, enum tb_cfg_pkg_type request_type, void *response, size_t response_size, enum tb_cfg_pkg_type response_type, unsigned int timeout_msec);
/** * struct tb_protocol_handler - Protocol specific handler * @uuid: XDomain messages with this UUID are dispatched to this handler * @callback: Callback called with the XDomain message. Returning %1 * here tells the XDomain core that the message was handled * by this handler and should not be forwared to other * handlers. * @data: Data passed with the callback * @list: Handlers are linked using this * * Thunderbolt services can hook into incoming XDomain requests by * registering protocol handler. Only limitation is that the XDomain * discovery protocol UUID cannot be registered since it is handled by * the core XDomain code. * * The @callback must check that the message is really directed to the * service the driver implements. */struct tb_protocol_handler { const uuid_t *uuid; int (*callback)(const void *buf, size_t size, void *data); void *data; struct list_head list;};
int tb_register_protocol_handler(struct tb_protocol_handler *handler);void tb_unregister_protocol_handler(struct tb_protocol_handler *handler);
/** * struct tb_service - Thunderbolt service * @dev: XDomain device * @id: ID of the service (shown in sysfs) * @key: Protocol key from the properties directory * @prtcid: Protocol ID from the properties directory * @prtcvers: Protocol version from the properties directory * @prtcrevs: Protocol software revision from the properties directory * @prtcstns: Protocol settings mask from the properties directory * @lock: Protects this structure * @local_properties: Properties owned by the service driver * @remote_properties: Properties read from the remote service. These * are read-only. * @debugfs_dir: Pointer to the service debugfs directory. Always created * when debugfs is enabled. Can be used by service drivers to * add their own entries under the service. * * Each domain exposes set of services it supports as collection of * properties. For each service there will be one corresponding * &struct tb_service. Service drivers are bound to these. * * Service drivers can add their own dynamic properties to * @local_properties but whenever they do so @lock must be held. */struct tb_service { struct device dev; int id; const char *key; u32 prtcid; u32 prtcvers; u32 prtcrevs; u32 prtcstns; struct mutex lock; struct tb_property_dir *local_properties; struct tb_property_dir *remote_properties; struct dentry *debugfs_dir;};
static inline struct tb_service *tb_service_get(struct tb_service *svc){ if (svc) get_device(&svc->dev); return svc;}
static inline void tb_service_put(struct tb_service *svc){ if (svc) put_device(&svc->dev);}
static inline bool tb_is_service(const struct device *dev){ return dev->type == &tb_service_type;}
static inline struct tb_service *tb_to_service(struct device *dev){ if (tb_is_service(dev)) return container_of(dev, struct tb_service, dev); return NULL;}
/** * struct tb_service_driver - Thunderbolt service driver * @driver: Driver structure * @probe: Called when the driver is probed * @remove: Called when the driver is removed (optional) * @shutdown: Called at shutdown time to stop the service (optional) * @id_table: Table of service identifiers the driver supports */struct tb_service_driver { struct device_driver driver; int (*probe)(struct tb_service *svc); void (*remove)(struct tb_service *svc); void (*shutdown)(struct tb_service *svc); const struct tb_service_id *id_table;};
#define TB_SERVICE(key, id) \ .match_flags = TBSVC_MATCH_PROTOCOL_KEY | \ TBSVC_MATCH_PROTOCOL_ID, \ .protocol_key = (key), \ .protocol_id = (id)
int tb_register_service_driver(struct tb_service_driver *drv);void tb_unregister_service_driver(struct tb_service_driver *drv);
static inline void *tb_service_get_drvdata(const struct tb_service *svc){ return dev_get_drvdata(&svc->dev);}
static inline void tb_service_set_drvdata(struct tb_service *svc, void *data){ dev_set_drvdata(&svc->dev, data);}
static inline struct tb_xdomain *tb_service_parent(struct tb_service *svc){ return tb_to_xdomain(svc->dev.parent);}
void tb_service_properties_changed(struct tb_service *svc);
/** * struct tb_nhi - thunderbolt native host interface * @lock: Must be held during ring creation/destruction. Is acquired by * interrupt_work when dispatching interrupts to individual rings. * @dev: Device associated with this NHI instance * @ops: NHI specific optional ops * @iobase: MMIO space of the NHI * @tx_rings: All Tx rings available on this host controller * @rx_rings: All Rx rings available on this host controller * @going_away: The host controller device is about to disappear so when * this flag is set, avoid touching the hardware anymore. * @iommu_dma_protection: An IOMMU will isolate external-facing ports. * @interrupt_work: Work scheduled to handle ring interrupt when no * MSI-X is used. * @hop_count: Number of rings (end point hops) supported by NHI. * @quirks: NHI specific quirks if any * @domain_released: Completed when domain has been fully released * @host_reset: Host router was reset on driver load, or forced on system * shutdown/reboot. When set, tb_stop() asserts DPR on connected * downstream ports to signal disconnect before tearing down the * router tree. Only Thunderbolt 3 devices are reset; USB4 * routers are skipped. */struct tb_nhi { spinlock_t lock; struct device *dev; const struct tb_nhi_ops *ops; void __iomem *iobase; struct tb_ring **tx_rings; struct tb_ring **rx_rings; bool going_away; bool iommu_dma_protection; struct work_struct interrupt_work; u32 hop_count; unsigned long quirks; struct completion domain_released; bool host_reset;};
/** * struct tb_ring - thunderbolt TX or RX ring associated with a NHI * @lock: Lock serializing actions to this ring. Must be acquired after * nhi->lock. * @nhi: Pointer to the native host controller interface * @size: Size of the ring * @hop: Hop (DMA channel) associated with this ring * @head: Head of the ring (write next descriptor here) * @tail: Tail of the ring (complete next descriptor here) * @descriptors: Allocated descriptors for this ring * @descriptors_dma: DMA address of descriptors for this ring * @queue: Queue holding frames to be transferred over this ring * @in_flight: Queue holding frames that are currently in flight * @work: Interrupt work structure * @is_tx: Is the ring Tx or Rx * @running: Is the ring running * @irq: MSI-X irq number if the ring uses MSI-X. %0 otherwise. * @vector: MSI-X vector number the ring uses (only set if @irq is > 0) * @flags: Ring specific flags * @e2e_tx_hop: Transmit HopID when E2E is enabled. Only applicable to * RX ring. For TX ring this should be set to %0. * @sof_mask: Bit mask used to detect start of frame PDF * @eof_mask: Bit mask used to detect end of frame PDF * @start_poll: Called when ring interrupt is triggered to start * polling. Passing %NULL keeps the ring in interrupt mode. * @poll_data: Data passed to @start_poll * @interval_nsec: Interval counter if interrupt throttling is to be * used with this ring (in ns) * @wait: Used to signal that the ring may be empty now * @lock_key: Lock validator class key per-ring */struct tb_ring { spinlock_t lock; struct tb_nhi *nhi; int size; int hop; int head; int tail; struct ring_desc *descriptors; dma_addr_t descriptors_dma; struct list_head queue; struct list_head in_flight; struct work_struct work; bool is_tx:1; bool running:1; int irq; u8 vector; unsigned int flags; int e2e_tx_hop; u16 sof_mask; u16 eof_mask; void (*start_poll)(void *data); void *poll_data; unsigned int interval_nsec; wait_queue_head_t wait; struct lock_class_key lock_key;};
/* Leave ring interrupt enabled on suspend */#define RING_FLAG_NO_SUSPEND BIT(0)/* Configure the ring to be in frame mode */#define RING_FLAG_FRAME BIT(1)/* Enable end-to-end flow control */#define RING_FLAG_E2E BIT(2)/* Do not enable interrupt for the ring */#define RING_FLAG_NO_INTERRUPT BIT(3)
struct ring_frame;typedef void (*ring_cb)(struct tb_ring *, struct ring_frame *, bool canceled);
/** * enum ring_desc_flags - Flags for DMA ring descriptor * @RING_DESC_ISOCH: Enable isonchronous DMA (Tx only) * @RING_DESC_CRC_ERROR: In frame mode CRC check failed for the frame (Rx only) * @RING_DESC_COMPLETED: Descriptor completed (set by NHI) * @RING_DESC_POSTED: Always set this * @RING_DESC_BUFFER_OVERRUN: RX buffer overrun * @RING_DESC_INTERRUPT: Request an interrupt on completion */enum ring_desc_flags { RING_DESC_ISOCH = 0x1, RING_DESC_CRC_ERROR = 0x1, RING_DESC_COMPLETED = 0x2, RING_DESC_POSTED = 0x4, RING_DESC_BUFFER_OVERRUN = 0x04, RING_DESC_INTERRUPT = 0x8,};
/** * struct ring_frame - For use with ring_rx/ring_tx * @buffer_phy: DMA mapped address of the frame * @callback: Callback called when the frame is finished (optional) * @list: Frame is linked to a queue using this * @size: Size of the frame in bytes (%0 means %4096) * @flags: Flags for the frame (see &enum ring_desc_flags) * @eof: End of frame protocol defined field * @sof: Start of frame protocol defined field */struct ring_frame { dma_addr_t buffer_phy; ring_cb callback; struct list_head list; u32 size:12; u32 flags:12; u32 eof:4; u32 sof:4;};
/* Minimum size for ring_rx */#define TB_FRAME_SIZE 256#define TB_MAX_FRAME_SIZE 4096
static inline size_t tb_ring_frame_size(const struct ring_frame *frame){ if (frame->size) return frame->size; return TB_MAX_FRAME_SIZE;}
static inline size_t tb_ring_size(const struct tb_ring *ring){ return ring->size;}
struct tb_ring *tb_ring_alloc_tx(struct tb_nhi *nhi, int hop, int size, unsigned int flags);struct tb_ring *tb_ring_alloc_rx(struct tb_nhi *nhi, int hop, int size, unsigned int flags, int e2e_tx_hop, u16 sof_mask, u16 eof_mask, void (*start_poll)(void *), void *poll_data);void tb_ring_start(struct tb_ring *ring);bool tb_ring_flush(struct tb_ring *ring, unsigned int timeout_msec);void tb_ring_stop(struct tb_ring *ring);void tb_ring_free(struct tb_ring *ring);
int __tb_ring_enqueue(struct tb_ring *ring, struct ring_frame *frame);
/** * tb_ring_rx() - enqueue a frame on an RX ring * @ring: Ring to enqueue the frame * @frame: Frame to enqueue * * @frame->buffer, @frame->buffer_phy have to be set. The buffer must * contain at least %TB_FRAME_SIZE bytes. * * @frame->callback will be invoked with @frame->size, @frame->flags, * @frame->eof, @frame->sof set once the frame has been received. * * If ring_stop() is called after the packet has been enqueued * @frame->callback will be called with canceled set to true. * * Return: %-ESHUTDOWN if ring_stop() has been called, %0 otherwise. */static inline int tb_ring_rx(struct tb_ring *ring, struct ring_frame *frame){ WARN_ON(ring->is_tx); return __tb_ring_enqueue(ring, frame);}
/** * tb_ring_tx() - enqueue a frame on an TX ring * @ring: Ring the enqueue the frame * @frame: Frame to enqueue * * @frame->buffer, @frame->buffer_phy, @frame->size, @frame->eof and * @frame->sof have to be set. * * @frame->callback will be invoked with once the frame has been transmitted. * * If ring_stop() is called after the packet has been enqueued @frame->callback * will be called with canceled set to true. * * Return: %-ESHUTDOWN if ring_stop has been called, %0 otherwise. */static inline int tb_ring_tx(struct tb_ring *ring, struct ring_frame *frame){ WARN_ON(!ring->is_tx); return __tb_ring_enqueue(ring, frame);}
/* Used only when the ring is in polling mode */struct ring_frame *tb_ring_poll(struct tb_ring *ring);void tb_ring_poll_complete(struct tb_ring *ring);
int tb_ring_throttling(struct tb_ring *ring, unsigned int interval_nsec);
/** * tb_ring_dma_device() - Return device used for DMA mapping * @ring: Ring whose DMA device is retrieved * * Use this function when you are mapping DMA for buffers that are * passed to the ring for sending/receiving. * * Return: Pointer to device used for DMA mapping. */static inline struct device *tb_ring_dma_device(struct tb_ring *ring){ return ring->nhi->dev;}
bool usb4_usb3_port_match(struct device *usb4_port_dev, const struct fwnode_handle *usb3_port_fwnode);
#if IS_REACHABLE(CONFIG_CONFIGFS_FS)int tb_configfs_register_group(struct config_group *group);void tb_configfs_unregister_group(struct config_group *group);#endif
#else /* CONFIG_USB4 */static inline bool usb4_usb3_port_match(struct device *usb4_port_dev, const struct fwnode_handle *usb3_port_fwnode){ return false;}#endif /* CONFIG_USB4 */
#endif /* THUNDERBOLT_H_ */