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