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