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