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