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