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