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