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