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