1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Thunderbolt service API 4 * 5 * Copyright (C) 2014 Andreas Noever <andreas.noever@gmail.com> 6 * Copyright (C) 2017, Intel Corporation 7 * Authors: Michael Jamet <michael.jamet@intel.com> 8 * Mika Westerberg <mika.westerberg@linux.intel.com> 9 */ 10 11 #ifndef THUNDERBOLT_H_ 12 #define THUNDERBOLT_H_ 13 14 #include <linux/device.h> 15 #include <linux/idr.h> 16 #include <linux/list.h> 17 #include <linux/mutex.h> 18 #include <linux/mod_devicetable.h> 19 #include <linux/pci.h> 20 #include <linux/uuid.h> 21 #include <linux/workqueue.h> 22 23 enum tb_cfg_pkg_type { 24 TB_CFG_PKG_READ = 1, 25 TB_CFG_PKG_WRITE = 2, 26 TB_CFG_PKG_ERROR = 3, 27 TB_CFG_PKG_NOTIFY_ACK = 4, 28 TB_CFG_PKG_EVENT = 5, 29 TB_CFG_PKG_XDOMAIN_REQ = 6, 30 TB_CFG_PKG_XDOMAIN_RESP = 7, 31 TB_CFG_PKG_OVERRIDE = 8, 32 TB_CFG_PKG_RESET = 9, 33 TB_CFG_PKG_ICM_EVENT = 10, 34 TB_CFG_PKG_ICM_CMD = 11, 35 TB_CFG_PKG_ICM_RESP = 12, 36 }; 37 38 /** 39 * enum tb_security_level - Thunderbolt security level 40 * @TB_SECURITY_NONE: No security, legacy mode 41 * @TB_SECURITY_USER: User approval required at minimum 42 * @TB_SECURITY_SECURE: One time saved key required at minimum 43 * @TB_SECURITY_DPONLY: Only tunnel Display port (and USB) 44 * @TB_SECURITY_USBONLY: Only tunnel USB controller of the connected 45 * Thunderbolt dock (and Display Port). All PCIe 46 * links downstream of the dock are removed. 47 * @TB_SECURITY_NOPCIE: For USB4 systems this level is used when the 48 * PCIe tunneling is disabled from the BIOS. 49 */ 50 enum tb_security_level { 51 TB_SECURITY_NONE, 52 TB_SECURITY_USER, 53 TB_SECURITY_SECURE, 54 TB_SECURITY_DPONLY, 55 TB_SECURITY_USBONLY, 56 TB_SECURITY_NOPCIE, 57 }; 58 59 /** 60 * struct tb - main thunderbolt bus structure 61 * @dev: Domain device 62 * @lock: Big lock. Must be held when accessing any struct 63 * tb_switch / struct tb_port. 64 * @nhi: Pointer to the NHI structure 65 * @ctl: Control channel for this domain 66 * @wq: Ordered workqueue for all domain specific work 67 * @root_switch: Root switch of this domain 68 * @cm_ops: Connection manager specific operations vector 69 * @index: Linux assigned domain number 70 * @security_level: Current security level 71 * @nboot_acl: Number of boot ACLs the domain supports 72 * @privdata: Private connection manager specific data 73 */ 74 struct tb { 75 struct device dev; 76 struct mutex lock; 77 struct tb_nhi *nhi; 78 struct tb_ctl *ctl; 79 struct workqueue_struct *wq; 80 struct tb_switch *root_switch; 81 const struct tb_cm_ops *cm_ops; 82 int index; 83 enum tb_security_level security_level; 84 size_t nboot_acl; 85 unsigned long privdata[]; 86 }; 87 88 extern const struct bus_type tb_bus_type; 89 extern const struct device_type tb_service_type; 90 extern const struct device_type tb_xdomain_type; 91 92 #define TB_LINKS_PER_PHY_PORT 2 93 94 static inline unsigned int tb_phy_port_from_link(unsigned int link) 95 { 96 return (link - 1) / TB_LINKS_PER_PHY_PORT; 97 } 98 99 /** 100 * struct tb_property_dir - XDomain property directory 101 * @uuid: Directory UUID or %NULL if root directory 102 * @properties: List of properties in this directory 103 * 104 * User needs to provide serialization if needed. 105 */ 106 struct tb_property_dir { 107 const uuid_t *uuid; 108 struct list_head properties; 109 }; 110 111 enum tb_property_type { 112 TB_PROPERTY_TYPE_UNKNOWN = 0x00, 113 TB_PROPERTY_TYPE_DIRECTORY = 0x44, 114 TB_PROPERTY_TYPE_DATA = 0x64, 115 TB_PROPERTY_TYPE_TEXT = 0x74, 116 TB_PROPERTY_TYPE_VALUE = 0x76, 117 }; 118 119 #define TB_PROPERTY_KEY_SIZE 8 120 121 /** 122 * struct tb_property - XDomain property 123 * @list: Used to link properties together in a directory 124 * @key: Key for the property (always terminated). 125 * @type: Type of the property 126 * @length: Length of the property data in dwords 127 * @value: Property value 128 * 129 * Users use @type to determine which field in @value is filled. 130 */ 131 struct tb_property { 132 struct list_head list; 133 char key[TB_PROPERTY_KEY_SIZE + 1]; 134 enum tb_property_type type; 135 size_t length; 136 union { 137 struct tb_property_dir *dir; 138 u8 *data; 139 char *text; 140 u32 immediate; 141 } value; 142 }; 143 144 struct tb_property_dir *tb_property_parse_dir(const u32 *block, 145 size_t block_len); 146 ssize_t tb_property_format_dir(const struct tb_property_dir *dir, u32 *block, 147 size_t block_len); 148 struct tb_property_dir *tb_property_copy_dir(const struct tb_property_dir *dir); 149 struct tb_property_dir *tb_property_create_dir(const uuid_t *uuid); 150 void tb_property_free_dir(struct tb_property_dir *dir); 151 int tb_property_add_immediate(struct tb_property_dir *parent, const char *key, 152 u32 value); 153 int tb_property_add_data(struct tb_property_dir *parent, const char *key, 154 const void *buf, size_t buflen); 155 int tb_property_add_text(struct tb_property_dir *parent, const char *key, 156 const char *text); 157 int tb_property_add_dir(struct tb_property_dir *parent, const char *key, 158 struct tb_property_dir *dir); 159 void tb_property_remove(struct tb_property *tb_property); 160 struct tb_property *tb_property_find(struct tb_property_dir *dir, 161 const char *key, enum tb_property_type type); 162 struct tb_property *tb_property_get_next(struct tb_property_dir *dir, 163 struct tb_property *prev); 164 165 #define tb_property_for_each(dir, property) \ 166 for (property = tb_property_get_next(dir, NULL); \ 167 property; \ 168 property = tb_property_get_next(dir, property)) 169 170 int tb_register_property_dir(const char *key, struct tb_property_dir *dir); 171 void tb_unregister_property_dir(const char *key, struct tb_property_dir *dir); 172 173 /** 174 * enum tb_link_width - Thunderbolt/USB4 link width 175 * @TB_LINK_WIDTH_SINGLE: Single lane link 176 * @TB_LINK_WIDTH_DUAL: Dual lane symmetric link 177 * @TB_LINK_WIDTH_ASYM_TX: Dual lane asymmetric Gen 4 link with 3 transmitters 178 * @TB_LINK_WIDTH_ASYM_RX: Dual lane asymmetric Gen 4 link with 3 receivers 179 */ 180 enum tb_link_width { 181 TB_LINK_WIDTH_SINGLE = BIT(0), 182 TB_LINK_WIDTH_DUAL = BIT(1), 183 TB_LINK_WIDTH_ASYM_TX = BIT(2), 184 TB_LINK_WIDTH_ASYM_RX = BIT(3), 185 }; 186 187 /** 188 * struct tb_xdomain - Cross-domain (XDomain) connection 189 * @dev: XDomain device 190 * @tb: Pointer to the domain 191 * @remote_uuid: UUID of the remote domain (host) 192 * @local_uuid: Cached local UUID 193 * @route: Route string the other domain can be reached 194 * @vendor: Vendor ID of the remote domain 195 * @device: Device ID of the demote domain 196 * @local_max_hopid: Maximum input HopID of this host 197 * @remote_max_hopid: Maximum input HopID of the remote host 198 * @lock: Lock to serialize access to the following fields of this structure 199 * @vendor_name: Name of the vendor (or %NULL if not known) 200 * @device_name: Name of the device (or %NULL if not known) 201 * @link_speed: Speed of the link in Gb/s 202 * @link_width: Width of the downstream facing link 203 * @link_usb4: Downstream link is USB4 204 * @is_unplugged: The XDomain is unplugged 205 * @needs_uuid: If the XDomain does not have @remote_uuid it will be 206 * queried first 207 * @service_ids: Used to generate IDs for the services 208 * @in_hopids: Input HopIDs for DMA tunneling 209 * @out_hopids; Output HopIDs for DMA tunneling 210 * @local_property_block: Local block of properties 211 * @local_property_block_gen: Generation of @local_property_block 212 * @local_property_block_len: Length of the @local_property_block in dwords 213 * @remote_properties: Properties exported by the remote domain 214 * @remote_property_block_gen: Generation of @remote_properties 215 * @state: Next XDomain discovery state to run 216 * @state_work: Work used to run the next state 217 * @state_retries: Number of retries remain for the state 218 * @properties_changed_work: Work used to notify the remote domain that 219 * our properties have changed 220 * @properties_changed_retries: Number of times left to send properties 221 * changed notification 222 * @bonding_possible: True if lane bonding is possible on local side 223 * @target_link_width: Target link width from the remote host 224 * @link: Root switch link the remote domain is connected (ICM only) 225 * @depth: Depth in the chain the remote domain is connected (ICM only) 226 * 227 * This structure represents connection across two domains (hosts). 228 * Each XDomain contains zero or more services which are exposed as 229 * &struct tb_service objects. 230 * 231 * Service drivers may access this structure if they need to enumerate 232 * non-standard properties but they need hold @lock when doing so 233 * because properties can be changed asynchronously in response to 234 * changes in the remote domain. 235 */ 236 struct tb_xdomain { 237 struct device dev; 238 struct tb *tb; 239 uuid_t *remote_uuid; 240 const uuid_t *local_uuid; 241 u64 route; 242 u16 vendor; 243 u16 device; 244 unsigned int local_max_hopid; 245 unsigned int remote_max_hopid; 246 struct mutex lock; 247 const char *vendor_name; 248 const char *device_name; 249 unsigned int link_speed; 250 enum tb_link_width link_width; 251 bool link_usb4; 252 bool is_unplugged; 253 bool needs_uuid; 254 struct ida service_ids; 255 struct ida in_hopids; 256 struct ida out_hopids; 257 u32 *local_property_block; 258 u32 local_property_block_gen; 259 u32 local_property_block_len; 260 struct tb_property_dir *remote_properties; 261 u32 remote_property_block_gen; 262 int state; 263 struct delayed_work state_work; 264 int state_retries; 265 struct delayed_work properties_changed_work; 266 int properties_changed_retries; 267 bool bonding_possible; 268 u8 target_link_width; 269 u8 link; 270 u8 depth; 271 }; 272 273 int tb_xdomain_lane_bonding_enable(struct tb_xdomain *xd); 274 void tb_xdomain_lane_bonding_disable(struct tb_xdomain *xd); 275 int tb_xdomain_alloc_in_hopid(struct tb_xdomain *xd, int hopid); 276 void tb_xdomain_release_in_hopid(struct tb_xdomain *xd, int hopid); 277 int tb_xdomain_alloc_out_hopid(struct tb_xdomain *xd, int hopid); 278 void tb_xdomain_release_out_hopid(struct tb_xdomain *xd, int hopid); 279 int tb_xdomain_enable_paths(struct tb_xdomain *xd, int transmit_path, 280 int transmit_ring, int receive_path, 281 int receive_ring); 282 int tb_xdomain_disable_paths(struct tb_xdomain *xd, int transmit_path, 283 int transmit_ring, int receive_path, 284 int receive_ring); 285 286 static inline int tb_xdomain_disable_all_paths(struct tb_xdomain *xd) 287 { 288 return tb_xdomain_disable_paths(xd, -1, -1, -1, -1); 289 } 290 291 struct tb_xdomain *tb_xdomain_find_by_uuid(struct tb *tb, const uuid_t *uuid); 292 struct tb_xdomain *tb_xdomain_find_by_route(struct tb *tb, u64 route); 293 294 static inline struct tb_xdomain * 295 tb_xdomain_find_by_uuid_locked(struct tb *tb, const uuid_t *uuid) 296 { 297 struct tb_xdomain *xd; 298 299 mutex_lock(&tb->lock); 300 xd = tb_xdomain_find_by_uuid(tb, uuid); 301 mutex_unlock(&tb->lock); 302 303 return xd; 304 } 305 306 static inline struct tb_xdomain * 307 tb_xdomain_find_by_route_locked(struct tb *tb, u64 route) 308 { 309 struct tb_xdomain *xd; 310 311 mutex_lock(&tb->lock); 312 xd = tb_xdomain_find_by_route(tb, route); 313 mutex_unlock(&tb->lock); 314 315 return xd; 316 } 317 318 static inline struct tb_xdomain *tb_xdomain_get(struct tb_xdomain *xd) 319 { 320 if (xd) 321 get_device(&xd->dev); 322 return xd; 323 } 324 325 static inline void tb_xdomain_put(struct tb_xdomain *xd) 326 { 327 if (xd) 328 put_device(&xd->dev); 329 } 330 331 static inline bool tb_is_xdomain(const struct device *dev) 332 { 333 return dev->type == &tb_xdomain_type; 334 } 335 336 static inline struct tb_xdomain *tb_to_xdomain(struct device *dev) 337 { 338 if (tb_is_xdomain(dev)) 339 return container_of(dev, struct tb_xdomain, dev); 340 return NULL; 341 } 342 343 int tb_xdomain_response(struct tb_xdomain *xd, const void *response, 344 size_t size, enum tb_cfg_pkg_type type); 345 int tb_xdomain_request(struct tb_xdomain *xd, const void *request, 346 size_t request_size, enum tb_cfg_pkg_type request_type, 347 void *response, size_t response_size, 348 enum tb_cfg_pkg_type response_type, 349 unsigned int timeout_msec); 350 351 /** 352 * tb_protocol_handler - Protocol specific handler 353 * @uuid: XDomain messages with this UUID are dispatched to this handler 354 * @callback: Callback called with the XDomain message. Returning %1 355 * here tells the XDomain core that the message was handled 356 * by this handler and should not be forwared to other 357 * handlers. 358 * @data: Data passed with the callback 359 * @list: Handlers are linked using this 360 * 361 * Thunderbolt services can hook into incoming XDomain requests by 362 * registering protocol handler. Only limitation is that the XDomain 363 * discovery protocol UUID cannot be registered since it is handled by 364 * the core XDomain code. 365 * 366 * The @callback must check that the message is really directed to the 367 * service the driver implements. 368 */ 369 struct tb_protocol_handler { 370 const uuid_t *uuid; 371 int (*callback)(const void *buf, size_t size, void *data); 372 void *data; 373 struct list_head list; 374 }; 375 376 int tb_register_protocol_handler(struct tb_protocol_handler *handler); 377 void tb_unregister_protocol_handler(struct tb_protocol_handler *handler); 378 379 /** 380 * struct tb_service - Thunderbolt service 381 * @dev: XDomain device 382 * @id: ID of the service (shown in sysfs) 383 * @key: Protocol key from the properties directory 384 * @prtcid: Protocol ID from the properties directory 385 * @prtcvers: Protocol version from the properties directory 386 * @prtcrevs: Protocol software revision from the properties directory 387 * @prtcstns: Protocol settings mask from the properties directory 388 * @debugfs_dir: Pointer to the service debugfs directory. Always created 389 * when debugfs is enabled. Can be used by service drivers to 390 * add their own entries under the service. 391 * 392 * Each domain exposes set of services it supports as collection of 393 * properties. For each service there will be one corresponding 394 * &struct tb_service. Service drivers are bound to these. 395 */ 396 struct tb_service { 397 struct device dev; 398 int id; 399 const char *key; 400 u32 prtcid; 401 u32 prtcvers; 402 u32 prtcrevs; 403 u32 prtcstns; 404 struct dentry *debugfs_dir; 405 }; 406 407 static inline struct tb_service *tb_service_get(struct tb_service *svc) 408 { 409 if (svc) 410 get_device(&svc->dev); 411 return svc; 412 } 413 414 static inline void tb_service_put(struct tb_service *svc) 415 { 416 if (svc) 417 put_device(&svc->dev); 418 } 419 420 static inline bool tb_is_service(const struct device *dev) 421 { 422 return dev->type == &tb_service_type; 423 } 424 425 static inline struct tb_service *tb_to_service(struct device *dev) 426 { 427 if (tb_is_service(dev)) 428 return container_of(dev, struct tb_service, dev); 429 return NULL; 430 } 431 432 /** 433 * tb_service_driver - Thunderbolt service driver 434 * @driver: Driver structure 435 * @probe: Called when the driver is probed 436 * @remove: Called when the driver is removed (optional) 437 * @shutdown: Called at shutdown time to stop the service (optional) 438 * @id_table: Table of service identifiers the driver supports 439 */ 440 struct tb_service_driver { 441 struct device_driver driver; 442 int (*probe)(struct tb_service *svc, const struct tb_service_id *id); 443 void (*remove)(struct tb_service *svc); 444 void (*shutdown)(struct tb_service *svc); 445 const struct tb_service_id *id_table; 446 }; 447 448 #define TB_SERVICE(key, id) \ 449 .match_flags = TBSVC_MATCH_PROTOCOL_KEY | \ 450 TBSVC_MATCH_PROTOCOL_ID, \ 451 .protocol_key = (key), \ 452 .protocol_id = (id) 453 454 int tb_register_service_driver(struct tb_service_driver *drv); 455 void tb_unregister_service_driver(struct tb_service_driver *drv); 456 457 static inline void *tb_service_get_drvdata(const struct tb_service *svc) 458 { 459 return dev_get_drvdata(&svc->dev); 460 } 461 462 static inline void tb_service_set_drvdata(struct tb_service *svc, void *data) 463 { 464 dev_set_drvdata(&svc->dev, data); 465 } 466 467 static inline struct tb_xdomain *tb_service_parent(struct tb_service *svc) 468 { 469 return tb_to_xdomain(svc->dev.parent); 470 } 471 472 /** 473 * struct tb_nhi - thunderbolt native host interface 474 * @lock: Must be held during ring creation/destruction. Is acquired by 475 * interrupt_work when dispatching interrupts to individual rings. 476 * @pdev: Pointer to the PCI device 477 * @ops: NHI specific optional ops 478 * @iobase: MMIO space of the NHI 479 * @tx_rings: All Tx rings available on this host controller 480 * @rx_rings: All Rx rings available on this host controller 481 * @msix_ida: Used to allocate MSI-X vectors for rings 482 * @going_away: The host controller device is about to disappear so when 483 * this flag is set, avoid touching the hardware anymore. 484 * @iommu_dma_protection: An IOMMU will isolate external-facing ports. 485 * @interrupt_work: Work scheduled to handle ring interrupt when no 486 * MSI-X is used. 487 * @hop_count: Number of rings (end point hops) supported by NHI. 488 * @quirks: NHI specific quirks if any 489 */ 490 struct tb_nhi { 491 spinlock_t lock; 492 struct pci_dev *pdev; 493 const struct tb_nhi_ops *ops; 494 void __iomem *iobase; 495 struct tb_ring **tx_rings; 496 struct tb_ring **rx_rings; 497 struct ida msix_ida; 498 bool going_away; 499 bool iommu_dma_protection; 500 struct work_struct interrupt_work; 501 u32 hop_count; 502 unsigned long quirks; 503 }; 504 505 /** 506 * struct tb_ring - thunderbolt TX or RX ring associated with a NHI 507 * @lock: Lock serializing actions to this ring. Must be acquired after 508 * nhi->lock. 509 * @nhi: Pointer to the native host controller interface 510 * @size: Size of the ring 511 * @hop: Hop (DMA channel) associated with this ring 512 * @head: Head of the ring (write next descriptor here) 513 * @tail: Tail of the ring (complete next descriptor here) 514 * @descriptors: Allocated descriptors for this ring 515 * @queue: Queue holding frames to be transferred over this ring 516 * @in_flight: Queue holding frames that are currently in flight 517 * @work: Interrupt work structure 518 * @is_tx: Is the ring Tx or Rx 519 * @running: Is the ring running 520 * @irq: MSI-X irq number if the ring uses MSI-X. %0 otherwise. 521 * @vector: MSI-X vector number the ring uses (only set if @irq is > 0) 522 * @flags: Ring specific flags 523 * @e2e_tx_hop: Transmit HopID when E2E is enabled. Only applicable to 524 * RX ring. For TX ring this should be set to %0. 525 * @sof_mask: Bit mask used to detect start of frame PDF 526 * @eof_mask: Bit mask used to detect end of frame PDF 527 * @start_poll: Called when ring interrupt is triggered to start 528 * polling. Passing %NULL keeps the ring in interrupt mode. 529 * @poll_data: Data passed to @start_poll 530 */ 531 struct tb_ring { 532 spinlock_t lock; 533 struct tb_nhi *nhi; 534 int size; 535 int hop; 536 int head; 537 int tail; 538 struct ring_desc *descriptors; 539 dma_addr_t descriptors_dma; 540 struct list_head queue; 541 struct list_head in_flight; 542 struct work_struct work; 543 bool is_tx:1; 544 bool running:1; 545 int irq; 546 u8 vector; 547 unsigned int flags; 548 int e2e_tx_hop; 549 u16 sof_mask; 550 u16 eof_mask; 551 void (*start_poll)(void *data); 552 void *poll_data; 553 }; 554 555 /* Leave ring interrupt enabled on suspend */ 556 #define RING_FLAG_NO_SUSPEND BIT(0) 557 /* Configure the ring to be in frame mode */ 558 #define RING_FLAG_FRAME BIT(1) 559 /* Enable end-to-end flow control */ 560 #define RING_FLAG_E2E BIT(2) 561 562 struct ring_frame; 563 typedef void (*ring_cb)(struct tb_ring *, struct ring_frame *, bool canceled); 564 565 /** 566 * enum ring_desc_flags - Flags for DMA ring descriptor 567 * %RING_DESC_ISOCH: Enable isonchronous DMA (Tx only) 568 * %RING_DESC_CRC_ERROR: In frame mode CRC check failed for the frame (Rx only) 569 * %RING_DESC_COMPLETED: Descriptor completed (set by NHI) 570 * %RING_DESC_POSTED: Always set this 571 * %RING_DESC_BUFFER_OVERRUN: RX buffer overrun 572 * %RING_DESC_INTERRUPT: Request an interrupt on completion 573 */ 574 enum ring_desc_flags { 575 RING_DESC_ISOCH = 0x1, 576 RING_DESC_CRC_ERROR = 0x1, 577 RING_DESC_COMPLETED = 0x2, 578 RING_DESC_POSTED = 0x4, 579 RING_DESC_BUFFER_OVERRUN = 0x04, 580 RING_DESC_INTERRUPT = 0x8, 581 }; 582 583 /** 584 * struct ring_frame - For use with ring_rx/ring_tx 585 * @buffer_phy: DMA mapped address of the frame 586 * @callback: Callback called when the frame is finished (optional) 587 * @list: Frame is linked to a queue using this 588 * @size: Size of the frame in bytes (%0 means %4096) 589 * @flags: Flags for the frame (see &enum ring_desc_flags) 590 * @eof: End of frame protocol defined field 591 * @sof: Start of frame protocol defined field 592 */ 593 struct ring_frame { 594 dma_addr_t buffer_phy; 595 ring_cb callback; 596 struct list_head list; 597 u32 size:12; 598 u32 flags:12; 599 u32 eof:4; 600 u32 sof:4; 601 }; 602 603 /* Minimum size for ring_rx */ 604 #define TB_FRAME_SIZE 0x100 605 606 struct tb_ring *tb_ring_alloc_tx(struct tb_nhi *nhi, int hop, int size, 607 unsigned int flags); 608 struct tb_ring *tb_ring_alloc_rx(struct tb_nhi *nhi, int hop, int size, 609 unsigned int flags, int e2e_tx_hop, 610 u16 sof_mask, u16 eof_mask, 611 void (*start_poll)(void *), void *poll_data); 612 void tb_ring_start(struct tb_ring *ring); 613 void tb_ring_stop(struct tb_ring *ring); 614 void tb_ring_free(struct tb_ring *ring); 615 616 int __tb_ring_enqueue(struct tb_ring *ring, struct ring_frame *frame); 617 618 /** 619 * tb_ring_rx() - enqueue a frame on an RX ring 620 * @ring: Ring to enqueue the frame 621 * @frame: Frame to enqueue 622 * 623 * @frame->buffer, @frame->buffer_phy have to be set. The buffer must 624 * contain at least %TB_FRAME_SIZE bytes. 625 * 626 * @frame->callback will be invoked with @frame->size, @frame->flags, 627 * @frame->eof, @frame->sof set once the frame has been received. 628 * 629 * If ring_stop() is called after the packet has been enqueued 630 * @frame->callback will be called with canceled set to true. 631 * 632 * Return: Returns %-ESHUTDOWN if ring_stop has been called. Zero otherwise. 633 */ 634 static inline int tb_ring_rx(struct tb_ring *ring, struct ring_frame *frame) 635 { 636 WARN_ON(ring->is_tx); 637 return __tb_ring_enqueue(ring, frame); 638 } 639 640 /** 641 * tb_ring_tx() - enqueue a frame on an TX ring 642 * @ring: Ring the enqueue the frame 643 * @frame: Frame to enqueue 644 * 645 * @frame->buffer, @frame->buffer_phy, @frame->size, @frame->eof and 646 * @frame->sof have to be set. 647 * 648 * @frame->callback will be invoked with once the frame has been transmitted. 649 * 650 * If ring_stop() is called after the packet has been enqueued @frame->callback 651 * will be called with canceled set to true. 652 * 653 * Return: Returns %-ESHUTDOWN if ring_stop has been called. Zero otherwise. 654 */ 655 static inline int tb_ring_tx(struct tb_ring *ring, struct ring_frame *frame) 656 { 657 WARN_ON(!ring->is_tx); 658 return __tb_ring_enqueue(ring, frame); 659 } 660 661 /* Used only when the ring is in polling mode */ 662 struct ring_frame *tb_ring_poll(struct tb_ring *ring); 663 void tb_ring_poll_complete(struct tb_ring *ring); 664 665 /** 666 * tb_ring_dma_device() - Return device used for DMA mapping 667 * @ring: Ring whose DMA device is retrieved 668 * 669 * Use this function when you are mapping DMA for buffers that are 670 * passed to the ring for sending/receiving. 671 */ 672 static inline struct device *tb_ring_dma_device(struct tb_ring *ring) 673 { 674 return &ring->nhi->pdev->dev; 675 } 676 677 #endif /* THUNDERBOLT_H_ */ 678