1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2016 Cavium, Inc 3 */ 4 5 #ifndef _RTE_EVENTDEV_PMD_H_ 6 #define _RTE_EVENTDEV_PMD_H_ 7 8 #ifdef __cplusplus 9 extern "C" { 10 #endif 11 12 /** @file 13 * RTE Event PMD APIs 14 * 15 * @note 16 * These API are from event PMD only and user applications should not call 17 * them directly. 18 */ 19 20 #include <string.h> 21 22 #include <rte_common.h> 23 #include <rte_compat.h> 24 #include <rte_config.h> 25 #include <dev_driver.h> 26 #include <rte_log.h> 27 #include <rte_malloc.h> 28 #include <rte_mbuf.h> 29 #include <rte_mbuf_dyn.h> 30 31 #include "event_timer_adapter_pmd.h" 32 #include "rte_eventdev.h" 33 34 /* Logging Macros */ 35 #define RTE_EDEV_LOG_ERR(...) \ 36 RTE_LOG(ERR, EVENTDEV, \ 37 RTE_FMT("%s() line %u: " RTE_FMT_HEAD(__VA_ARGS__,) "\n", \ 38 __func__, __LINE__, RTE_FMT_TAIL(__VA_ARGS__,))) 39 40 #ifdef RTE_LIBRTE_EVENTDEV_DEBUG 41 #define RTE_EDEV_LOG_DEBUG(...) \ 42 RTE_LOG(DEBUG, EVENTDEV, \ 43 RTE_FMT("%s() line %u: " RTE_FMT_HEAD(__VA_ARGS__,) "\n", \ 44 __func__, __LINE__, RTE_FMT_TAIL(__VA_ARGS__,))) 45 #else 46 #define RTE_EDEV_LOG_DEBUG(...) (void)0 47 #endif 48 49 /* Macros to check for valid device */ 50 #define RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, retval) do { \ 51 if (!rte_event_pmd_is_valid_dev((dev_id))) { \ 52 RTE_EDEV_LOG_ERR("Invalid dev_id=%d\n", dev_id); \ 53 return retval; \ 54 } \ 55 } while (0) 56 57 #define RTE_EVENTDEV_VALID_DEVID_OR_ERRNO_RET(dev_id, errno, retval) do { \ 58 if (!rte_event_pmd_is_valid_dev((dev_id))) { \ 59 RTE_EDEV_LOG_ERR("Invalid dev_id=%d\n", dev_id); \ 60 rte_errno = errno; \ 61 return retval; \ 62 } \ 63 } while (0) 64 65 #define RTE_EVENTDEV_VALID_DEVID_OR_RET(dev_id) do { \ 66 if (!rte_event_pmd_is_valid_dev((dev_id))) { \ 67 RTE_EDEV_LOG_ERR("Invalid dev_id=%d\n", dev_id); \ 68 return; \ 69 } \ 70 } while (0) 71 72 #define RTE_EVENT_ETH_RX_ADAPTER_SW_CAP \ 73 ((RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) | \ 74 (RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) | \ 75 (RTE_EVENT_ETH_RX_ADAPTER_CAP_EVENT_VECTOR)) 76 77 #define RTE_EVENT_CRYPTO_ADAPTER_SW_CAP \ 78 RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA 79 80 /**< Ethernet Rx adapter cap to return If the packet transfers from 81 * the ethdev to eventdev use a SW service function 82 */ 83 84 #define RTE_EVENT_TIMER_ADAPTER_SW_CAP \ 85 RTE_EVENT_TIMER_ADAPTER_CAP_PERIODIC 86 87 #define RTE_EVENTDEV_DETACHED (0) 88 #define RTE_EVENTDEV_ATTACHED (1) 89 90 #define RTE_EVENTDEV_NAME_MAX_LEN (64) 91 /**< @internal Max length of name of event PMD */ 92 93 struct rte_eth_dev; 94 95 /** Global structure used for maintaining state of allocated event devices */ 96 struct rte_eventdev_global { 97 uint8_t nb_devs; /**< Number of devices found */ 98 }; 99 100 /** 101 * @internal 102 * The data part, with no function pointers, associated with each device. 103 * 104 * This structure is safe to place in shared memory to be common among 105 * different processes in a multi-process configuration. 106 */ 107 struct rte_eventdev_data { 108 int socket_id; 109 /**< Socket ID where memory is allocated */ 110 uint8_t dev_id; 111 /**< Device ID for this instance */ 112 uint8_t nb_queues; 113 /**< Number of event queues. */ 114 uint8_t nb_ports; 115 /**< Number of event ports. */ 116 void *ports[RTE_EVENT_MAX_PORTS_PER_DEV]; 117 /**< Array of pointers to ports. */ 118 struct rte_event_port_conf ports_cfg[RTE_EVENT_MAX_PORTS_PER_DEV]; 119 /**< Array of port configuration structures. */ 120 struct rte_event_queue_conf queues_cfg[RTE_EVENT_MAX_QUEUES_PER_DEV]; 121 /**< Array of queue configuration structures. */ 122 uint16_t links_map[RTE_EVENT_MAX_PORTS_PER_DEV * 123 RTE_EVENT_MAX_QUEUES_PER_DEV]; 124 /**< Memory to store queues to port connections. */ 125 void *dev_private; 126 /**< PMD-specific private data */ 127 uint32_t event_dev_cap; 128 /**< Event device capabilities(RTE_EVENT_DEV_CAP_)*/ 129 struct rte_event_dev_config dev_conf; 130 /**< Configuration applied to device. */ 131 uint8_t service_inited; 132 /* Service initialization state */ 133 uint32_t service_id; 134 /* Service ID*/ 135 void *dev_stop_flush_arg; 136 /**< User-provided argument for event flush function */ 137 138 uint8_t dev_started : 1; 139 /**< Device state: STARTED(1)/STOPPED(0) */ 140 141 char name[RTE_EVENTDEV_NAME_MAX_LEN]; 142 /**< Unique identifier name */ 143 144 uint64_t reserved_64s[4]; /**< Reserved for future fields */ 145 void *reserved_ptrs[4]; /**< Reserved for future fields */ 146 } __rte_cache_aligned; 147 148 /** @internal The data structure associated with each event device. */ 149 struct rte_eventdev { 150 struct rte_eventdev_data *data; 151 /**< Pointer to device data */ 152 struct eventdev_ops *dev_ops; 153 /**< Functions exported by PMD */ 154 struct rte_device *dev; 155 /**< Device info. supplied by probing */ 156 157 uint8_t attached : 1; 158 /**< Flag indicating the device is attached */ 159 160 event_enqueue_t enqueue; 161 /**< Pointer to PMD enqueue function. */ 162 event_enqueue_burst_t enqueue_burst; 163 /**< Pointer to PMD enqueue burst function. */ 164 event_enqueue_burst_t enqueue_new_burst; 165 /**< Pointer to PMD enqueue burst function(op new variant) */ 166 event_enqueue_burst_t enqueue_forward_burst; 167 /**< Pointer to PMD enqueue burst function(op forward variant) */ 168 event_dequeue_t dequeue; 169 /**< Pointer to PMD dequeue function. */ 170 event_dequeue_burst_t dequeue_burst; 171 /**< Pointer to PMD dequeue burst function. */ 172 event_maintain_t maintain; 173 /**< Pointer to PMD port maintenance function. */ 174 event_tx_adapter_enqueue_t txa_enqueue_same_dest; 175 /**< Pointer to PMD eth Tx adapter burst enqueue function with 176 * events destined to same Eth port & Tx queue. 177 */ 178 event_tx_adapter_enqueue_t txa_enqueue; 179 /**< Pointer to PMD eth Tx adapter enqueue function. */ 180 event_crypto_adapter_enqueue_t ca_enqueue; 181 182 uint64_t reserved_64s[4]; /**< Reserved for future fields */ 183 void *reserved_ptrs[3]; /**< Reserved for future fields */ 184 } __rte_cache_aligned; 185 186 extern struct rte_eventdev *rte_eventdevs; 187 /** @internal The pool of rte_eventdev structures. */ 188 189 /** 190 * Get the rte_eventdev structure device pointer for the named device. 191 * 192 * @param name 193 * device name to select the device structure. 194 * 195 * @return 196 * - The rte_eventdev structure pointer for the given device ID. 197 */ 198 __rte_internal 199 static inline struct rte_eventdev * 200 rte_event_pmd_get_named_dev(const char *name) 201 { 202 struct rte_eventdev *dev; 203 unsigned int i; 204 205 if (name == NULL) 206 return NULL; 207 208 for (i = 0; i < RTE_EVENT_MAX_DEVS; i++) { 209 dev = &rte_eventdevs[i]; 210 if ((dev->attached == RTE_EVENTDEV_ATTACHED) && 211 (strcmp(dev->data->name, name) == 0)) 212 return dev; 213 } 214 215 return NULL; 216 } 217 218 /** 219 * Validate if the event device index is valid attached event device. 220 * 221 * @param dev_id 222 * Event device index. 223 * 224 * @return 225 * - If the device index is valid (1) or not (0). 226 */ 227 __rte_internal 228 static inline unsigned 229 rte_event_pmd_is_valid_dev(uint8_t dev_id) 230 { 231 struct rte_eventdev *dev; 232 233 if (dev_id >= RTE_EVENT_MAX_DEVS) 234 return 0; 235 236 dev = &rte_eventdevs[dev_id]; 237 if (dev->attached != RTE_EVENTDEV_ATTACHED) 238 return 0; 239 else 240 return 1; 241 } 242 243 /** 244 * Definitions of all functions exported by a driver through the 245 * generic structure of type *event_dev_ops* supplied in the 246 * *rte_eventdev* structure associated with a device. 247 */ 248 249 /** 250 * Get device information of a device. 251 * 252 * @param dev 253 * Event device pointer 254 * @param dev_info 255 * Event device information structure 256 */ 257 typedef void (*eventdev_info_get_t)(struct rte_eventdev *dev, 258 struct rte_event_dev_info *dev_info); 259 260 /** 261 * Configure a device. 262 * 263 * @param dev 264 * Event device pointer 265 * 266 * @return 267 * Returns 0 on success 268 */ 269 typedef int (*eventdev_configure_t)(const struct rte_eventdev *dev); 270 271 /** 272 * Start a configured device. 273 * 274 * @param dev 275 * Event device pointer 276 * 277 * @return 278 * Returns 0 on success 279 */ 280 typedef int (*eventdev_start_t)(struct rte_eventdev *dev); 281 282 /** 283 * Stop a configured device. 284 * 285 * @param dev 286 * Event device pointer 287 */ 288 typedef void (*eventdev_stop_t)(struct rte_eventdev *dev); 289 290 /** 291 * Close a configured device. 292 * 293 * @param dev 294 * Event device pointer 295 * 296 * @return 297 * - 0 on success 298 * - (-EAGAIN) if can't close as device is busy 299 */ 300 typedef int (*eventdev_close_t)(struct rte_eventdev *dev); 301 302 /** 303 * Retrieve the default event queue configuration. 304 * 305 * @param dev 306 * Event device pointer 307 * @param queue_id 308 * Event queue index 309 * @param[out] queue_conf 310 * Event queue configuration structure 311 */ 312 typedef void (*eventdev_queue_default_conf_get_t)(struct rte_eventdev *dev, 313 uint8_t queue_id, struct rte_event_queue_conf *queue_conf); 314 315 /** 316 * Setup an event queue. 317 * 318 * @param dev 319 * Event device pointer 320 * @param queue_id 321 * Event queue index 322 * @param queue_conf 323 * Event queue configuration structure 324 * 325 * @return 326 * Returns 0 on success. 327 */ 328 typedef int (*eventdev_queue_setup_t)(struct rte_eventdev *dev, 329 uint8_t queue_id, 330 const struct rte_event_queue_conf *queue_conf); 331 332 /** 333 * Release resources allocated by given event queue. 334 * 335 * @param dev 336 * Event device pointer 337 * @param queue_id 338 * Event queue index 339 */ 340 typedef void (*eventdev_queue_release_t)(struct rte_eventdev *dev, 341 uint8_t queue_id); 342 343 /** 344 * Set an event queue attribute at runtime. 345 * 346 * @param dev 347 * Event device pointer 348 * @param queue_id 349 * Event queue index 350 * @param attr_id 351 * Event queue attribute id 352 * @param attr_value 353 * Event queue attribute value 354 * 355 * @return 356 * - 0: Success. 357 * - <0: Error code on failure. 358 */ 359 typedef int (*eventdev_queue_attr_set_t)(struct rte_eventdev *dev, 360 uint8_t queue_id, uint32_t attr_id, 361 uint64_t attr_value); 362 363 /** 364 * Retrieve the default event port configuration. 365 * 366 * @param dev 367 * Event device pointer 368 * @param port_id 369 * Event port index 370 * @param[out] port_conf 371 * Event port configuration structure 372 */ 373 typedef void (*eventdev_port_default_conf_get_t)(struct rte_eventdev *dev, 374 uint8_t port_id, struct rte_event_port_conf *port_conf); 375 376 /** 377 * Setup an event port. 378 * 379 * @param dev 380 * Event device pointer 381 * @param port_id 382 * Event port index 383 * @param port_conf 384 * Event port configuration structure 385 * 386 * @return 387 * Returns 0 on success. 388 */ 389 typedef int (*eventdev_port_setup_t)(struct rte_eventdev *dev, 390 uint8_t port_id, 391 const struct rte_event_port_conf *port_conf); 392 393 /** 394 * Release memory resources allocated by given event port. 395 * 396 * @param port 397 * Event port pointer 398 */ 399 typedef void (*eventdev_port_release_t)(void *port); 400 401 /** 402 * Quiesce any core specific resources consumed by the event port 403 * 404 * @param dev 405 * Event device pointer. 406 * @param port 407 * Event port pointer. 408 * @param flush_cb 409 * User-provided event flush function. 410 * @param args 411 * Arguments to be passed to the user-provided event flush function. 412 */ 413 typedef void (*eventdev_port_quiesce_t)(struct rte_eventdev *dev, void *port, 414 rte_eventdev_port_flush_t flush_cb, 415 void *args); 416 417 /** 418 * Link multiple source event queues to destination event port. 419 * 420 * @param dev 421 * Event device pointer 422 * @param port 423 * Event port pointer 424 * @param queues 425 * Points to an array of *nb_links* event queues to be linked 426 * to the event port. 427 * @param priorities 428 * Points to an array of *nb_links* service priorities associated with each 429 * event queue link to event port. 430 * @param nb_links 431 * The number of links to establish 432 * 433 * @return 434 * Returns 0 on success. 435 */ 436 typedef int (*eventdev_port_link_t)(struct rte_eventdev *dev, void *port, 437 const uint8_t queues[], const uint8_t priorities[], 438 uint16_t nb_links); 439 440 /** 441 * Unlink multiple source event queues from destination event port. 442 * 443 * @param dev 444 * Event device pointer 445 * @param port 446 * Event port pointer 447 * @param queues 448 * An array of *nb_unlinks* event queues to be unlinked from the event port. 449 * @param nb_unlinks 450 * The number of unlinks to establish 451 * 452 * @return 453 * Returns 0 on success. 454 */ 455 typedef int (*eventdev_port_unlink_t)(struct rte_eventdev *dev, void *port, 456 uint8_t queues[], uint16_t nb_unlinks); 457 458 /** 459 * Unlinks in progress. Returns number of unlinks that the PMD is currently 460 * performing, but have not yet been completed. 461 * 462 * @param dev 463 * Event device pointer 464 * 465 * @param port 466 * Event port pointer 467 * 468 * @return 469 * Returns the number of in-progress unlinks. Zero is returned if none are 470 * in progress. 471 */ 472 typedef int (*eventdev_port_unlinks_in_progress_t)(struct rte_eventdev *dev, 473 void *port); 474 475 /** 476 * Converts nanoseconds to *timeout_ticks* value for rte_event_dequeue() 477 * 478 * @param dev 479 * Event device pointer 480 * @param ns 481 * Wait time in nanosecond 482 * @param[out] timeout_ticks 483 * Value for the *timeout_ticks* parameter in rte_event_dequeue() function 484 * 485 * @return 486 * Returns 0 on success. 487 */ 488 typedef int (*eventdev_dequeue_timeout_ticks_t)(struct rte_eventdev *dev, 489 uint64_t ns, uint64_t *timeout_ticks); 490 491 /** 492 * Dump internal information 493 * 494 * @param dev 495 * Event device pointer 496 * @param f 497 * A pointer to a file for output 498 */ 499 typedef void (*eventdev_dump_t)(struct rte_eventdev *dev, FILE *f); 500 501 /** 502 * Retrieve a set of statistics from device 503 * 504 * @param dev 505 * Event device pointer 506 * @param mode 507 * Level (device, port or queue) 508 * @param queue_port_id 509 * Queue or port number depending on mode 510 * @param ids 511 * The stat ids to retrieve 512 * @param values 513 * The returned stat values 514 * @param n 515 * The number of id values and entries in the values array 516 * @return 517 * The number of stat values successfully filled into the values array 518 */ 519 typedef int (*eventdev_xstats_get_t)(const struct rte_eventdev *dev, 520 enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id, 521 const uint64_t ids[], uint64_t values[], unsigned int n); 522 523 /** 524 * Resets the statistic values in xstats for the device, based on mode. 525 */ 526 typedef int (*eventdev_xstats_reset_t)(struct rte_eventdev *dev, 527 enum rte_event_dev_xstats_mode mode, 528 int16_t queue_port_id, 529 const uint64_t ids[], 530 uint32_t nb_ids); 531 532 /** 533 * Get names of extended stats of an event device 534 * 535 * @param dev 536 * Event device pointer 537 * @param mode 538 * Level (device, port or queue) 539 * @param queue_port_id 540 * Queue or port number depending on mode 541 * @param xstats_names 542 * Array of name values to be filled in 543 * @param ids 544 * The stat ids to retrieve 545 * @param size 546 * Number of values in the xstats_names array 547 * @return 548 * When size >= the number of stats, return the number of stat values filled 549 * into the array. 550 * When size < the number of available stats, return the number of stats 551 * values, and do not fill in any data into xstats_names. 552 */ 553 typedef int (*eventdev_xstats_get_names_t)(const struct rte_eventdev *dev, 554 enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id, 555 struct rte_event_dev_xstats_name *xstats_names, 556 uint64_t *ids, unsigned int size); 557 558 /** 559 * Get value of one stats and optionally return its id 560 * 561 * @param dev 562 * Event device pointer 563 * @param name 564 * The name of the stat to retrieve 565 * @param id 566 * Pointer to an unsigned int where we store the stat-id for future reference. 567 * This pointer may be null if the id is not required. 568 * @return 569 * The value of the stat, or (uint64_t)-1 if the stat is not found. 570 * If the stat is not found, the id value will be returned as (unsigned)-1, 571 * if id pointer is non-NULL 572 */ 573 typedef uint64_t (*eventdev_xstats_get_by_name)(const struct rte_eventdev *dev, 574 const char *name, uint64_t *id); 575 576 577 /** 578 * Retrieve the event device's ethdev Rx adapter capabilities for the 579 * specified ethernet port 580 * 581 * @param dev 582 * Event device pointer 583 * 584 * @param eth_dev 585 * Ethernet device pointer 586 * 587 * @param[out] caps 588 * A pointer to memory filled with Rx event adapter capabilities. 589 * 590 * @return 591 * - 0: Success, driver provides Rx event adapter capabilities for the 592 * ethernet device. 593 * - <0: Error code returned by the driver function. 594 */ 595 typedef int (*eventdev_eth_rx_adapter_caps_get_t) 596 (const struct rte_eventdev *dev, 597 const struct rte_eth_dev *eth_dev, 598 uint32_t *caps); 599 600 struct rte_event_eth_rx_adapter_queue_conf; 601 602 /** 603 * Retrieve the event device's timer adapter capabilities, as well as the ops 604 * structure that an event timer adapter should call through to enter the 605 * driver 606 * 607 * @param dev 608 * Event device pointer 609 * 610 * @param flags 611 * Flags that can be used to determine how to select an event timer 612 * adapter ops structure 613 * 614 * @param[out] caps 615 * A pointer to memory filled with Rx event adapter capabilities. 616 * 617 * @param[out] ops 618 * A pointer to the ops pointer to set with the address of the desired ops 619 * structure 620 * 621 * @return 622 * - 0: Success, driver provides Rx event adapter capabilities for the 623 * ethernet device. 624 * - <0: Error code returned by the driver function. 625 */ 626 typedef int (*eventdev_timer_adapter_caps_get_t)( 627 const struct rte_eventdev *dev, uint64_t flags, uint32_t *caps, 628 const struct event_timer_adapter_ops **ops); 629 630 /** 631 * Add ethernet Rx queues to event device. This callback is invoked if 632 * the caps returned from rte_eventdev_eth_rx_adapter_caps_get(, eth_port_id) 633 * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set. 634 * 635 * @param dev 636 * Event device pointer 637 * 638 * @param eth_dev 639 * Ethernet device pointer 640 * 641 * @param rx_queue_id 642 * Ethernet device receive queue index 643 * 644 * @param queue_conf 645 * Additional configuration structure 646 647 * @return 648 * - 0: Success, ethernet receive queue added successfully. 649 * - <0: Error code returned by the driver function. 650 */ 651 typedef int (*eventdev_eth_rx_adapter_queue_add_t)( 652 const struct rte_eventdev *dev, 653 const struct rte_eth_dev *eth_dev, 654 int32_t rx_queue_id, 655 const struct rte_event_eth_rx_adapter_queue_conf *queue_conf); 656 657 /** 658 * Delete ethernet Rx queues from event device. This callback is invoked if 659 * the caps returned from eventdev_eth_rx_adapter_caps_get(, eth_port_id) 660 * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set. 661 * 662 * @param dev 663 * Event device pointer 664 * 665 * @param eth_dev 666 * Ethernet device pointer 667 * 668 * @param rx_queue_id 669 * Ethernet device receive queue index 670 * 671 * @return 672 * - 0: Success, ethernet receive queue deleted successfully. 673 * - <0: Error code returned by the driver function. 674 */ 675 typedef int (*eventdev_eth_rx_adapter_queue_del_t) 676 (const struct rte_eventdev *dev, 677 const struct rte_eth_dev *eth_dev, 678 int32_t rx_queue_id); 679 680 /** 681 * Retrieve Rx adapter queue config information for the specified 682 * rx queue ID. 683 * 684 * @param dev 685 * Event device pointer 686 * 687 * @param eth_dev 688 * Ethernet device pointer 689 * 690 * @param rx_queue_id 691 * Ethernet device receive queue index. 692 * 693 * @param[out] queue_conf 694 * Pointer to rte_event_eth_rx_adapter_queue_conf structure 695 * 696 * @return 697 * - 0: Success 698 * - <0: Error code on failure. 699 */ 700 typedef int (*eventdev_eth_rx_adapter_queue_conf_get_t) 701 (const struct rte_eventdev *dev, 702 const struct rte_eth_dev *eth_dev, 703 uint16_t rx_queue_id, 704 struct rte_event_eth_rx_adapter_queue_conf *queue_conf); 705 706 /** 707 * Start ethernet Rx adapter. This callback is invoked if 708 * the caps returned from eventdev_eth_rx_adapter_caps_get(.., eth_port_id) 709 * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set and Rx queues 710 * from eth_port_id have been added to the event device. 711 * 712 * @param dev 713 * Event device pointer 714 * 715 * @param eth_dev 716 * Ethernet device pointer 717 * 718 * @return 719 * - 0: Success, ethernet Rx adapter started successfully. 720 * - <0: Error code returned by the driver function. 721 */ 722 typedef int (*eventdev_eth_rx_adapter_start_t) 723 (const struct rte_eventdev *dev, 724 const struct rte_eth_dev *eth_dev); 725 726 /** 727 * Stop ethernet Rx adapter. This callback is invoked if 728 * the caps returned from eventdev_eth_rx_adapter_caps_get(..,eth_port_id) 729 * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set and Rx queues 730 * from eth_port_id have been added to the event device. 731 * 732 * @param dev 733 * Event device pointer 734 * 735 * @param eth_dev 736 * Ethernet device pointer 737 * 738 * @return 739 * - 0: Success, ethernet Rx adapter stopped successfully. 740 * - <0: Error code returned by the driver function. 741 */ 742 typedef int (*eventdev_eth_rx_adapter_stop_t) 743 (const struct rte_eventdev *dev, 744 const struct rte_eth_dev *eth_dev); 745 746 struct rte_event_eth_rx_adapter_stats; 747 748 /** 749 * Retrieve ethernet Rx adapter statistics. 750 * 751 * @param dev 752 * Event device pointer 753 * 754 * @param eth_dev 755 * Ethernet device pointer 756 * 757 * @param[out] stats 758 * Pointer to stats structure 759 * 760 * @return 761 * Return 0 on success. 762 */ 763 764 typedef int (*eventdev_eth_rx_adapter_stats_get) 765 (const struct rte_eventdev *dev, 766 const struct rte_eth_dev *eth_dev, 767 struct rte_event_eth_rx_adapter_stats *stats); 768 /** 769 * Reset ethernet Rx adapter statistics. 770 * 771 * @param dev 772 * Event device pointer 773 * 774 * @param eth_dev 775 * Ethernet device pointer 776 * 777 * @return 778 * Return 0 on success. 779 */ 780 typedef int (*eventdev_eth_rx_adapter_stats_reset) 781 (const struct rte_eventdev *dev, 782 const struct rte_eth_dev *eth_dev); 783 784 struct rte_event_eth_rx_adapter_queue_stats; 785 786 /** 787 * Retrieve ethernet Rx adapter queue statistics. 788 * 789 * @param dev 790 * Event device pointer 791 * 792 * @param eth_dev 793 * Ethernet device pointer 794 * 795 * @param rx_queue_id 796 * Ethernet device receive queue index. 797 * 798 * @param[out] q_stats 799 * Pointer to queue stats structure 800 * 801 * @return 802 * Return 0 on success. 803 */ 804 typedef int (*eventdev_eth_rx_adapter_q_stats_get) 805 (const struct rte_eventdev *dev, 806 const struct rte_eth_dev *eth_dev, 807 uint16_t rx_queue_id, 808 struct rte_event_eth_rx_adapter_queue_stats *q_stats); 809 810 /** 811 * Reset ethernet Rx adapter queue statistics. 812 * 813 * @param dev 814 * Event device pointer 815 * 816 * @param eth_dev 817 * Ethernet device pointer 818 * 819 * @param rx_queue_id 820 * Ethernet device receive queue index. 821 * 822 * @return 823 * Return 0 on success. 824 */ 825 typedef int (*eventdev_eth_rx_adapter_q_stats_reset) 826 (const struct rte_eventdev *dev, 827 const struct rte_eth_dev *eth_dev, 828 uint16_t rx_queue_id); 829 830 /** 831 * Start eventdev selftest. 832 * 833 * @return 834 * Return 0 on success. 835 */ 836 typedef int (*eventdev_selftest)(void); 837 838 struct rte_event_eth_rx_adapter_vector_limits; 839 /** 840 * Get event vector limits for a given event, ethernet device pair. 841 * 842 * @param dev 843 * Event device pointer 844 * 845 * @param eth_dev 846 * Ethernet device pointer 847 * 848 * @param[out] limits 849 * Pointer to the limits structure to be filled. 850 * 851 * @return 852 * - 0: Success. 853 * - <0: Error code returned by the driver function. 854 */ 855 typedef int (*eventdev_eth_rx_adapter_vector_limits_get_t)( 856 const struct rte_eventdev *dev, const struct rte_eth_dev *eth_dev, 857 struct rte_event_eth_rx_adapter_vector_limits *limits); 858 859 /** 860 * Get Rx adapter instance ID for Rx queue 861 * 862 * @param eth_dev_id 863 * Port identifier of ethernet device 864 * 865 * @param rx_queue_id 866 * Ethernet device Rx queue index 867 * 868 * @param[out] rxa_inst_id 869 * Pointer to Rx adapter instance identifier. 870 * Contains valid Rx adapter instance ID when return value is 0 871 * 872 * @return 873 * - 0: Success 874 * - <0: Error code on failure 875 */ 876 typedef int (*eventdev_eth_rx_adapter_instance_get_t) 877 (uint16_t eth_dev_id, uint16_t rx_queue_id, uint8_t *rxa_inst_id); 878 879 typedef uint32_t rte_event_pmd_selftest_seqn_t; 880 extern int rte_event_pmd_selftest_seqn_dynfield_offset; 881 882 /** 883 * Read test sequence number from mbuf. 884 * 885 * @param mbuf Structure to read from. 886 * @return pointer to test sequence number. 887 */ 888 __rte_internal 889 static inline rte_event_pmd_selftest_seqn_t * 890 rte_event_pmd_selftest_seqn(struct rte_mbuf *mbuf) 891 { 892 return RTE_MBUF_DYNFIELD(mbuf, 893 rte_event_pmd_selftest_seqn_dynfield_offset, 894 rte_event_pmd_selftest_seqn_t *); 895 } 896 897 struct rte_cryptodev; 898 struct rte_event_crypto_adapter_queue_conf; 899 900 /** 901 * This API may change without prior notice 902 * 903 * Retrieve the event device's crypto adapter capabilities for the 904 * specified cryptodev 905 * 906 * @param dev 907 * Event device pointer 908 * 909 * @param cdev 910 * cryptodev pointer 911 * 912 * @param[out] caps 913 * A pointer to memory filled with event adapter capabilities. 914 * It is expected to be pre-allocated & initialized by caller. 915 * 916 * @return 917 * - 0: Success, driver provides event adapter capabilities for the 918 * cryptodev. 919 * - <0: Error code returned by the driver function. 920 */ 921 typedef int (*eventdev_crypto_adapter_caps_get_t) 922 (const struct rte_eventdev *dev, 923 const struct rte_cryptodev *cdev, 924 uint32_t *caps); 925 926 /** 927 * This API may change without prior notice 928 * 929 * Add crypto queue pair to event device. This callback is invoked if 930 * the caps returned from rte_event_crypto_adapter_caps_get(, cdev_id) 931 * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set. 932 * 933 * @param dev 934 * Event device pointer 935 * 936 * @param cdev 937 * cryptodev pointer 938 * 939 * @param queue_pair_id 940 * cryptodev queue pair identifier. 941 * 942 * @param event 943 * Event information required for binding cryptodev queue pair to event queue. 944 * This structure will have a valid value for only those HW PMDs supporting 945 * @see RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND capability. 946 * 947 * @return 948 * - 0: Success, cryptodev queue pair added successfully. 949 * - <0: Error code returned by the driver function. 950 */ 951 typedef int (*eventdev_crypto_adapter_queue_pair_add_t)( 952 const struct rte_eventdev *dev, 953 const struct rte_cryptodev *cdev, 954 int32_t queue_pair_id, 955 const struct rte_event_crypto_adapter_queue_conf *queue_conf); 956 957 958 /** 959 * This API may change without prior notice 960 * 961 * Delete crypto queue pair to event device. This callback is invoked if 962 * the caps returned from rte_event_crypto_adapter_caps_get(, cdev_id) 963 * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set. 964 * 965 * @param dev 966 * Event device pointer 967 * 968 * @param cdev 969 * cryptodev pointer 970 * 971 * @param queue_pair_id 972 * cryptodev queue pair identifier. 973 * 974 * @return 975 * - 0: Success, cryptodev queue pair deleted successfully. 976 * - <0: Error code returned by the driver function. 977 */ 978 typedef int (*eventdev_crypto_adapter_queue_pair_del_t) 979 (const struct rte_eventdev *dev, 980 const struct rte_cryptodev *cdev, 981 int32_t queue_pair_id); 982 983 /** 984 * Start crypto adapter. This callback is invoked if 985 * the caps returned from rte_event_crypto_adapter_caps_get(.., cdev_id) 986 * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set and queue pairs 987 * from cdev_id have been added to the event device. 988 * 989 * @param dev 990 * Event device pointer 991 * 992 * @param cdev 993 * Crypto device pointer 994 * 995 * @return 996 * - 0: Success, crypto adapter started successfully. 997 * - <0: Error code returned by the driver function. 998 */ 999 typedef int (*eventdev_crypto_adapter_start_t) 1000 (const struct rte_eventdev *dev, 1001 const struct rte_cryptodev *cdev); 1002 1003 /** 1004 * Stop crypto adapter. This callback is invoked if 1005 * the caps returned from rte_event_crypto_adapter_caps_get(.., cdev_id) 1006 * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set and queue pairs 1007 * from cdev_id have been added to the event device. 1008 * 1009 * @param dev 1010 * Event device pointer 1011 * 1012 * @param cdev 1013 * Crypto device pointer 1014 * 1015 * @return 1016 * - 0: Success, crypto adapter stopped successfully. 1017 * - <0: Error code returned by the driver function. 1018 */ 1019 typedef int (*eventdev_crypto_adapter_stop_t) 1020 (const struct rte_eventdev *dev, 1021 const struct rte_cryptodev *cdev); 1022 1023 struct rte_event_crypto_adapter_stats; 1024 1025 /** 1026 * Retrieve crypto adapter statistics. 1027 * 1028 * @param dev 1029 * Event device pointer 1030 * 1031 * @param cdev 1032 * Crypto device pointer 1033 * 1034 * @param[out] stats 1035 * Pointer to stats structure 1036 * 1037 * @return 1038 * Return 0 on success. 1039 */ 1040 1041 typedef int (*eventdev_crypto_adapter_stats_get) 1042 (const struct rte_eventdev *dev, 1043 const struct rte_cryptodev *cdev, 1044 struct rte_event_crypto_adapter_stats *stats); 1045 1046 /** 1047 * Reset crypto adapter statistics. 1048 * 1049 * @param dev 1050 * Event device pointer 1051 * 1052 * @param cdev 1053 * Crypto device pointer 1054 * 1055 * @return 1056 * Return 0 on success. 1057 */ 1058 1059 typedef int (*eventdev_crypto_adapter_stats_reset) 1060 (const struct rte_eventdev *dev, 1061 const struct rte_cryptodev *cdev); 1062 1063 struct rte_event_crypto_adapter_vector_limits; 1064 /** 1065 * Get event vector limits for a given event, crypto device pair. 1066 * 1067 * @param dev 1068 * Event device pointer 1069 * 1070 * @param cdev 1071 * Crypto device pointer 1072 * 1073 * @param[out] limits 1074 * Pointer to the limits structure to be filled. 1075 * 1076 * @return 1077 * - 0: Success. 1078 * - <0: Error code returned by the driver function. 1079 */ 1080 typedef int (*eventdev_crypto_adapter_vector_limits_get_t)( 1081 const struct rte_eventdev *dev, const struct rte_cryptodev *cdev, 1082 struct rte_event_crypto_adapter_vector_limits *limits); 1083 1084 /** 1085 * Retrieve the event device's eth Tx adapter capabilities. 1086 * 1087 * @param dev 1088 * Event device pointer 1089 * 1090 * @param eth_dev 1091 * Ethernet device pointer 1092 * 1093 * @param[out] caps 1094 * A pointer to memory filled with eth Tx adapter capabilities. 1095 * 1096 * @return 1097 * - 0: Success, driver provides eth Tx adapter capabilities 1098 * - <0: Error code returned by the driver function. 1099 */ 1100 typedef int (*eventdev_eth_tx_adapter_caps_get_t) 1101 (const struct rte_eventdev *dev, 1102 const struct rte_eth_dev *eth_dev, 1103 uint32_t *caps); 1104 1105 /** 1106 * Create adapter callback. 1107 * 1108 * @param id 1109 * Adapter identifier 1110 * 1111 * @param dev 1112 * Event device pointer 1113 * 1114 * @return 1115 * - 0: Success. 1116 * - <0: Error code on failure. 1117 */ 1118 typedef int (*eventdev_eth_tx_adapter_create_t)(uint8_t id, 1119 const struct rte_eventdev *dev); 1120 1121 /** 1122 * Free adapter callback. 1123 * 1124 * @param id 1125 * Adapter identifier 1126 * 1127 * @param dev 1128 * Event device pointer 1129 * 1130 * @return 1131 * - 0: Success. 1132 * - <0: Error code on failure. 1133 */ 1134 typedef int (*eventdev_eth_tx_adapter_free_t)(uint8_t id, 1135 const struct rte_eventdev *dev); 1136 1137 /** 1138 * Add a Tx queue to the adapter. 1139 * A queue value of -1 is used to indicate all 1140 * queues within the device. 1141 * 1142 * @param id 1143 * Adapter identifier 1144 * 1145 * @param dev 1146 * Event device pointer 1147 * 1148 * @param eth_dev 1149 * Ethernet device pointer 1150 * 1151 * @param tx_queue_id 1152 * Transmit queue index 1153 * 1154 * @return 1155 * - 0: Success. 1156 * - <0: Error code on failure. 1157 */ 1158 typedef int (*eventdev_eth_tx_adapter_queue_add_t)( 1159 uint8_t id, 1160 const struct rte_eventdev *dev, 1161 const struct rte_eth_dev *eth_dev, 1162 int32_t tx_queue_id); 1163 1164 /** 1165 * Delete a Tx queue from the adapter. 1166 * A queue value of -1 is used to indicate all 1167 * queues within the device, that have been added to this 1168 * adapter. 1169 * 1170 * @param id 1171 * Adapter identifier 1172 * 1173 * @param dev 1174 * Event device pointer 1175 * 1176 * @param eth_dev 1177 * Ethernet device pointer 1178 * 1179 * @param tx_queue_id 1180 * Transmit queue index 1181 * 1182 * @return 1183 * - 0: Success, Queues deleted successfully. 1184 * - <0: Error code on failure. 1185 */ 1186 typedef int (*eventdev_eth_tx_adapter_queue_del_t)( 1187 uint8_t id, 1188 const struct rte_eventdev *dev, 1189 const struct rte_eth_dev *eth_dev, 1190 int32_t tx_queue_id); 1191 1192 /** 1193 * Start the adapter. 1194 * 1195 * @param id 1196 * Adapter identifier 1197 * 1198 * @param dev 1199 * Event device pointer 1200 * 1201 * @return 1202 * - 0: Success, Adapter started correctly. 1203 * - <0: Error code on failure. 1204 */ 1205 typedef int (*eventdev_eth_tx_adapter_start_t)(uint8_t id, 1206 const struct rte_eventdev *dev); 1207 1208 /** 1209 * Stop the adapter. 1210 * 1211 * @param id 1212 * Adapter identifier 1213 * 1214 * @param dev 1215 * Event device pointer 1216 * 1217 * @return 1218 * - 0: Success. 1219 * - <0: Error code on failure. 1220 */ 1221 typedef int (*eventdev_eth_tx_adapter_stop_t)(uint8_t id, 1222 const struct rte_eventdev *dev); 1223 1224 struct rte_event_eth_tx_adapter_stats; 1225 1226 /** 1227 * Retrieve statistics for an adapter 1228 * 1229 * @param id 1230 * Adapter identifier 1231 * 1232 * @param dev 1233 * Event device pointer 1234 * 1235 * @param [out] stats 1236 * A pointer to structure used to retrieve statistics for an adapter 1237 * 1238 * @return 1239 * - 0: Success, statistics retrieved successfully. 1240 * - <0: Error code on failure. 1241 */ 1242 typedef int (*eventdev_eth_tx_adapter_stats_get_t)( 1243 uint8_t id, 1244 const struct rte_eventdev *dev, 1245 struct rte_event_eth_tx_adapter_stats *stats); 1246 1247 /** 1248 * Reset statistics for an adapter 1249 * 1250 * @param id 1251 * Adapter identifier 1252 * 1253 * @param dev 1254 * Event device pointer 1255 * 1256 * @return 1257 * - 0: Success, statistics retrieved successfully. 1258 * - <0: Error code on failure. 1259 */ 1260 typedef int (*eventdev_eth_tx_adapter_stats_reset_t)(uint8_t id, 1261 const struct rte_eventdev *dev); 1262 1263 /** 1264 * Get TX adapter instance ID for Tx queue 1265 * 1266 * @param eth_dev_id 1267 * Port identifier of Ethernet device 1268 * 1269 * @param tx_queue_id 1270 * Ethernet device Tx queue index 1271 * 1272 * @param[out] txa_inst_id 1273 * Pointer to Tx adapter instance identifier 1274 * Contains valid Tx adapter instance ID when return value is 0 1275 * 1276 * @return 1277 * - 0: Success 1278 * - <0: Error code on failure 1279 */ 1280 typedef int (*eventdev_eth_tx_adapter_instance_get_t) 1281 (uint16_t eth_dev_id, uint16_t tx_queue_id, uint8_t *txa_inst_id); 1282 1283 /** 1284 * Start a Tx queue that is assigned to Tx adapter instance 1285 * 1286 * @param id 1287 * Adapter identifier 1288 * 1289 * @param eth_dev_id 1290 * Port identifier of Ethernet device 1291 * 1292 * @param tx_queue_id 1293 * Ethernet device Tx queue index 1294 * 1295 * @return 1296 * - 0: Success 1297 * - <0: Error code on failure 1298 */ 1299 typedef int (*eventdev_eth_tx_adapter_queue_start) 1300 (uint8_t id, uint16_t eth_dev_id, uint16_t tx_queue_id); 1301 1302 /** 1303 * Stop a Tx queue that is assigned to Tx adapter instance 1304 * 1305 * @param id 1306 * Adapter identifier 1307 * 1308 * @param eth_dev_id 1309 * Port identifier of Ethernet device 1310 * 1311 * @param tx_queue_id 1312 * Ethernet device Tx queue index 1313 * 1314 * @return 1315 * - 0: Success 1316 * - <0: Error code on failure 1317 */ 1318 typedef int (*eventdev_eth_tx_adapter_queue_stop) 1319 (uint8_t id, uint16_t eth_dev_id, uint16_t tx_queue_id); 1320 1321 #define eventdev_stop_flush_t rte_eventdev_stop_flush_t 1322 1323 /** Event device operations function pointer table */ 1324 struct eventdev_ops { 1325 eventdev_info_get_t dev_infos_get; /**< Get device info. */ 1326 eventdev_configure_t dev_configure; /**< Configure device. */ 1327 eventdev_start_t dev_start; /**< Start device. */ 1328 eventdev_stop_t dev_stop; /**< Stop device. */ 1329 eventdev_close_t dev_close; /**< Close device. */ 1330 1331 eventdev_queue_default_conf_get_t queue_def_conf; 1332 /**< Get default queue configuration. */ 1333 eventdev_queue_setup_t queue_setup; 1334 /**< Set up an event queue. */ 1335 eventdev_queue_release_t queue_release; 1336 /**< Release an event queue. */ 1337 eventdev_queue_attr_set_t queue_attr_set; 1338 /**< Set an event queue attribute. */ 1339 1340 eventdev_port_default_conf_get_t port_def_conf; 1341 /**< Get default port configuration. */ 1342 eventdev_port_setup_t port_setup; 1343 /**< Set up an event port. */ 1344 eventdev_port_release_t port_release; 1345 /**< Release an event port. */ 1346 eventdev_port_quiesce_t port_quiesce; 1347 /**< Quiesce an event port. */ 1348 1349 eventdev_port_link_t port_link; 1350 /**< Link event queues to an event port. */ 1351 eventdev_port_unlink_t port_unlink; 1352 /**< Unlink event queues from an event port. */ 1353 eventdev_port_unlinks_in_progress_t port_unlinks_in_progress; 1354 /**< Unlinks in progress on an event port. */ 1355 eventdev_dequeue_timeout_ticks_t timeout_ticks; 1356 /**< Converts ns to *timeout_ticks* value for rte_event_dequeue() */ 1357 eventdev_dump_t dump; 1358 /* Dump internal information */ 1359 1360 eventdev_xstats_get_t xstats_get; 1361 /**< Get extended device statistics. */ 1362 eventdev_xstats_get_names_t xstats_get_names; 1363 /**< Get names of extended stats. */ 1364 eventdev_xstats_get_by_name xstats_get_by_name; 1365 /**< Get one value by name. */ 1366 eventdev_xstats_reset_t xstats_reset; 1367 /**< Reset the statistics values in xstats. */ 1368 1369 eventdev_eth_rx_adapter_caps_get_t eth_rx_adapter_caps_get; 1370 /**< Get ethernet Rx adapter capabilities */ 1371 eventdev_eth_rx_adapter_queue_add_t eth_rx_adapter_queue_add; 1372 /**< Add Rx queues to ethernet Rx adapter */ 1373 eventdev_eth_rx_adapter_queue_del_t eth_rx_adapter_queue_del; 1374 /**< Delete Rx queues from ethernet Rx adapter */ 1375 eventdev_eth_rx_adapter_queue_conf_get_t eth_rx_adapter_queue_conf_get; 1376 /**< Get Rx adapter queue info */ 1377 eventdev_eth_rx_adapter_start_t eth_rx_adapter_start; 1378 /**< Start ethernet Rx adapter */ 1379 eventdev_eth_rx_adapter_stop_t eth_rx_adapter_stop; 1380 /**< Stop ethernet Rx adapter */ 1381 eventdev_eth_rx_adapter_stats_get eth_rx_adapter_stats_get; 1382 /**< Get ethernet Rx stats */ 1383 eventdev_eth_rx_adapter_stats_reset eth_rx_adapter_stats_reset; 1384 /**< Reset ethernet Rx stats */ 1385 eventdev_eth_rx_adapter_vector_limits_get_t 1386 eth_rx_adapter_vector_limits_get; 1387 /**< Get event vector limits for the Rx adapter */ 1388 eventdev_eth_rx_adapter_instance_get_t eth_rx_adapter_instance_get; 1389 /**< Get Rx adapter instance ID for Rx queue */ 1390 1391 eventdev_timer_adapter_caps_get_t timer_adapter_caps_get; 1392 /**< Get timer adapter capabilities */ 1393 1394 eventdev_crypto_adapter_caps_get_t crypto_adapter_caps_get; 1395 /**< Get crypto adapter capabilities */ 1396 eventdev_crypto_adapter_queue_pair_add_t crypto_adapter_queue_pair_add; 1397 /**< Add queue pair to crypto adapter */ 1398 eventdev_crypto_adapter_queue_pair_del_t crypto_adapter_queue_pair_del; 1399 /**< Delete queue pair from crypto adapter */ 1400 eventdev_crypto_adapter_start_t crypto_adapter_start; 1401 /**< Start crypto adapter */ 1402 eventdev_crypto_adapter_stop_t crypto_adapter_stop; 1403 /**< Stop crypto adapter */ 1404 eventdev_crypto_adapter_stats_get crypto_adapter_stats_get; 1405 /**< Get crypto stats */ 1406 eventdev_crypto_adapter_stats_reset crypto_adapter_stats_reset; 1407 /**< Reset crypto stats */ 1408 eventdev_crypto_adapter_vector_limits_get_t 1409 crypto_adapter_vector_limits_get; 1410 /**< Get event vector limits for the crypto adapter */ 1411 1412 eventdev_eth_rx_adapter_q_stats_get eth_rx_adapter_queue_stats_get; 1413 /**< Get ethernet Rx queue stats */ 1414 eventdev_eth_rx_adapter_q_stats_reset eth_rx_adapter_queue_stats_reset; 1415 /**< Reset ethernet Rx queue stats */ 1416 1417 eventdev_eth_tx_adapter_caps_get_t eth_tx_adapter_caps_get; 1418 /**< Get ethernet Tx adapter capabilities */ 1419 1420 eventdev_eth_tx_adapter_create_t eth_tx_adapter_create; 1421 /**< Create adapter callback */ 1422 eventdev_eth_tx_adapter_free_t eth_tx_adapter_free; 1423 /**< Free adapter callback */ 1424 eventdev_eth_tx_adapter_queue_add_t eth_tx_adapter_queue_add; 1425 /**< Add Tx queues to the eth Tx adapter */ 1426 eventdev_eth_tx_adapter_queue_del_t eth_tx_adapter_queue_del; 1427 /**< Delete Tx queues from the eth Tx adapter */ 1428 eventdev_eth_tx_adapter_start_t eth_tx_adapter_start; 1429 /**< Start eth Tx adapter */ 1430 eventdev_eth_tx_adapter_stop_t eth_tx_adapter_stop; 1431 /**< Stop eth Tx adapter */ 1432 eventdev_eth_tx_adapter_stats_get_t eth_tx_adapter_stats_get; 1433 /**< Get eth Tx adapter statistics */ 1434 eventdev_eth_tx_adapter_stats_reset_t eth_tx_adapter_stats_reset; 1435 /**< Reset eth Tx adapter statistics */ 1436 eventdev_eth_tx_adapter_instance_get_t eth_tx_adapter_instance_get; 1437 /**< Get Tx adapter instance ID for Tx queue */ 1438 eventdev_eth_tx_adapter_queue_start eth_tx_adapter_queue_start; 1439 /**< Start Tx queue assigned to Tx adapter instance */ 1440 eventdev_eth_tx_adapter_queue_stop eth_tx_adapter_queue_stop; 1441 /**< Stop Tx queue assigned to Tx adapter instance */ 1442 1443 eventdev_selftest dev_selftest; 1444 /**< Start eventdev Selftest */ 1445 1446 eventdev_stop_flush_t dev_stop_flush; 1447 /**< User-provided event flush function */ 1448 }; 1449 1450 /** 1451 * Allocates a new eventdev slot for an event device and returns the pointer 1452 * to that slot for the driver to use. 1453 * 1454 * @param name 1455 * Unique identifier name for each device 1456 * @param socket_id 1457 * Socket to allocate resources on. 1458 * @return 1459 * - Slot in the rte_dev_devices array for a new device; 1460 */ 1461 __rte_internal 1462 struct rte_eventdev * 1463 rte_event_pmd_allocate(const char *name, int socket_id); 1464 1465 /** 1466 * Release the specified eventdev device. 1467 * 1468 * @param eventdev 1469 * The *eventdev* pointer is the address of the *rte_eventdev* structure. 1470 * @return 1471 * - 0 on success, negative on error 1472 */ 1473 __rte_internal 1474 int 1475 rte_event_pmd_release(struct rte_eventdev *eventdev); 1476 1477 /** 1478 * 1479 * @internal 1480 * This is the last step of device probing. 1481 * It must be called after a port is allocated and initialized successfully. 1482 * 1483 * @param eventdev 1484 * New event device. 1485 */ 1486 __rte_internal 1487 void 1488 event_dev_probing_finish(struct rte_eventdev *eventdev); 1489 1490 /** 1491 * Reset eventdevice fastpath APIs to dummy values. 1492 * 1493 * @param fp_ops 1494 * The *fp_ops* pointer to reset. 1495 */ 1496 __rte_internal 1497 void 1498 event_dev_fp_ops_reset(struct rte_event_fp_ops *fp_op); 1499 1500 /** 1501 * Set eventdevice fastpath APIs to event device values. 1502 * 1503 * @param fp_ops 1504 * The *fp_ops* pointer to set. 1505 */ 1506 __rte_internal 1507 void 1508 event_dev_fp_ops_set(struct rte_event_fp_ops *fp_ops, 1509 const struct rte_eventdev *dev); 1510 1511 #ifdef __cplusplus 1512 } 1513 #endif 1514 1515 #endif /* _RTE_EVENTDEV_PMD_H_ */ 1516