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 * Set 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 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_set_t)(struct rte_eventdev *dev, 361 uint8_t queue_id, uint32_t attr_id, 362 uint64_t attr_value); 363 364 /** 365 * Retrieve the default event port configuration. 366 * 367 * @param dev 368 * Event device pointer 369 * @param port_id 370 * Event port index 371 * @param[out] port_conf 372 * Event port configuration structure 373 * 374 */ 375 typedef void (*eventdev_port_default_conf_get_t)(struct rte_eventdev *dev, 376 uint8_t port_id, struct rte_event_port_conf *port_conf); 377 378 /** 379 * Setup an event port. 380 * 381 * @param dev 382 * Event device pointer 383 * @param port_id 384 * Event port index 385 * @param port_conf 386 * Event port configuration structure 387 * 388 * @return 389 * Returns 0 on success. 390 */ 391 typedef int (*eventdev_port_setup_t)(struct rte_eventdev *dev, 392 uint8_t port_id, 393 const struct rte_event_port_conf *port_conf); 394 395 /** 396 * Release memory resources allocated by given event port. 397 * 398 * @param port 399 * Event port pointer 400 * 401 */ 402 typedef void (*eventdev_port_release_t)(void *port); 403 404 /** 405 * Quiesce any core specific resources consumed by the event port 406 * 407 * @param dev 408 * Event device pointer. 409 * @param port 410 * Event port pointer. 411 * @param flush_cb 412 * User-provided event flush function. 413 * @param args 414 * Arguments to be passed to the user-provided event flush function. 415 * 416 */ 417 typedef void (*eventdev_port_quiesce_t)(struct rte_eventdev *dev, void *port, 418 rte_eventdev_port_flush_t flush_cb, 419 void *args); 420 421 /** 422 * Link multiple source event queues to destination event port. 423 * 424 * @param dev 425 * Event device pointer 426 * @param port 427 * Event port pointer 428 * @param queues 429 * Points to an array of *nb_links* event queues to be linked 430 * to the event port. 431 * @param priorities 432 * Points to an array of *nb_links* service priorities associated with each 433 * event queue link to event port. 434 * @param nb_links 435 * The number of links to establish 436 * 437 * @return 438 * Returns 0 on success. 439 * 440 */ 441 typedef int (*eventdev_port_link_t)(struct rte_eventdev *dev, void *port, 442 const uint8_t queues[], const uint8_t priorities[], 443 uint16_t nb_links); 444 445 /** 446 * Unlink multiple source event queues from destination event port. 447 * 448 * @param dev 449 * Event device pointer 450 * @param port 451 * Event port pointer 452 * @param queues 453 * An array of *nb_unlinks* event queues to be unlinked from the event port. 454 * @param nb_unlinks 455 * The number of unlinks to establish 456 * 457 * @return 458 * Returns 0 on success. 459 * 460 */ 461 typedef int (*eventdev_port_unlink_t)(struct rte_eventdev *dev, void *port, 462 uint8_t queues[], uint16_t nb_unlinks); 463 464 /** 465 * Unlinks in progress. Returns number of unlinks that the PMD is currently 466 * performing, but have not yet been completed. 467 * 468 * @param dev 469 * Event device pointer 470 * 471 * @param port 472 * Event port pointer 473 * 474 * @return 475 * Returns the number of in-progress unlinks. Zero is returned if none are 476 * in progress. 477 */ 478 typedef int (*eventdev_port_unlinks_in_progress_t)(struct rte_eventdev *dev, 479 void *port); 480 481 /** 482 * Converts nanoseconds to *timeout_ticks* value for rte_event_dequeue() 483 * 484 * @param dev 485 * Event device pointer 486 * @param ns 487 * Wait time in nanosecond 488 * @param[out] timeout_ticks 489 * Value for the *timeout_ticks* parameter in rte_event_dequeue() function 490 * 491 * @return 492 * Returns 0 on success. 493 * 494 */ 495 typedef int (*eventdev_dequeue_timeout_ticks_t)(struct rte_eventdev *dev, 496 uint64_t ns, uint64_t *timeout_ticks); 497 498 /** 499 * Dump internal information 500 * 501 * @param dev 502 * Event device pointer 503 * @param f 504 * A pointer to a file for output 505 * 506 */ 507 typedef void (*eventdev_dump_t)(struct rte_eventdev *dev, FILE *f); 508 509 /** 510 * Retrieve a set of statistics from device 511 * 512 * @param dev 513 * Event device pointer 514 * @param mode 515 * Level (device, port or queue) 516 * @param queue_port_id 517 * Queue or port number depending on mode 518 * @param ids 519 * The stat ids to retrieve 520 * @param values 521 * The returned stat values 522 * @param n 523 * The number of id values and entries in the values array 524 * @return 525 * The number of stat values successfully filled into the values array 526 */ 527 typedef int (*eventdev_xstats_get_t)(const struct rte_eventdev *dev, 528 enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id, 529 const unsigned int ids[], uint64_t values[], unsigned int n); 530 531 /** 532 * Resets the statistic values in xstats for the device, based on mode. 533 */ 534 typedef int (*eventdev_xstats_reset_t)(struct rte_eventdev *dev, 535 enum rte_event_dev_xstats_mode mode, 536 int16_t queue_port_id, 537 const uint32_t ids[], 538 uint32_t nb_ids); 539 540 /** 541 * Get names of extended stats of an event device 542 * 543 * @param dev 544 * Event device pointer 545 * @param mode 546 * Level (device, port or queue) 547 * @param queue_port_id 548 * Queue or port number depending on mode 549 * @param xstats_names 550 * Array of name values to be filled in 551 * @param ids 552 * The stat ids to retrieve 553 * @param size 554 * Number of values in the xstats_names array 555 * @return 556 * When size >= the number of stats, return the number of stat values filled 557 * into the array. 558 * When size < the number of available stats, return the number of stats 559 * values, and do not fill in any data into xstats_names. 560 */ 561 typedef int (*eventdev_xstats_get_names_t)(const struct rte_eventdev *dev, 562 enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id, 563 struct rte_event_dev_xstats_name *xstats_names, 564 unsigned int *ids, unsigned int size); 565 566 /** 567 * Get value of one stats and optionally return its id 568 * 569 * @param dev 570 * Event device pointer 571 * @param name 572 * The name of the stat to retrieve 573 * @param id 574 * Pointer to an unsigned int where we store the stat-id for future reference. 575 * This pointer may be null if the id is not required. 576 * @return 577 * The value of the stat, or (uint64_t)-1 if the stat is not found. 578 * If the stat is not found, the id value will be returned as (unsigned)-1, 579 * if id pointer is non-NULL 580 */ 581 typedef uint64_t (*eventdev_xstats_get_by_name)(const struct rte_eventdev *dev, 582 const char *name, unsigned int *id); 583 584 585 /** 586 * Retrieve the event device's ethdev Rx adapter capabilities for the 587 * specified ethernet port 588 * 589 * @param dev 590 * Event device pointer 591 * 592 * @param eth_dev 593 * Ethernet device pointer 594 * 595 * @param[out] caps 596 * A pointer to memory filled with Rx event adapter capabilities. 597 * 598 * @return 599 * - 0: Success, driver provides Rx event adapter capabilities for the 600 * ethernet device. 601 * - <0: Error code returned by the driver function. 602 * 603 */ 604 typedef int (*eventdev_eth_rx_adapter_caps_get_t) 605 (const struct rte_eventdev *dev, 606 const struct rte_eth_dev *eth_dev, 607 uint32_t *caps); 608 609 struct rte_event_eth_rx_adapter_queue_conf; 610 611 /** 612 * Retrieve the event device's timer adapter capabilities, as well as the ops 613 * structure that an event timer adapter should call through to enter the 614 * driver 615 * 616 * @param dev 617 * Event device pointer 618 * 619 * @param flags 620 * Flags that can be used to determine how to select an event timer 621 * adapter ops structure 622 * 623 * @param[out] caps 624 * A pointer to memory filled with Rx event adapter capabilities. 625 * 626 * @param[out] ops 627 * A pointer to the ops pointer to set with the address of the desired ops 628 * structure 629 * 630 * @return 631 * - 0: Success, driver provides Rx event adapter capabilities for the 632 * ethernet device. 633 * - <0: Error code returned by the driver function. 634 * 635 */ 636 typedef int (*eventdev_timer_adapter_caps_get_t)( 637 const struct rte_eventdev *dev, uint64_t flags, uint32_t *caps, 638 const struct event_timer_adapter_ops **ops); 639 640 /** 641 * Add ethernet Rx queues to event device. This callback is invoked if 642 * the caps returned from rte_eventdev_eth_rx_adapter_caps_get(, eth_port_id) 643 * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set. 644 * 645 * @param dev 646 * Event device pointer 647 * 648 * @param eth_dev 649 * Ethernet device pointer 650 * 651 * @param rx_queue_id 652 * Ethernet device receive queue index 653 * 654 * @param queue_conf 655 * Additional configuration structure 656 657 * @return 658 * - 0: Success, ethernet receive queue added successfully. 659 * - <0: Error code returned by the driver function. 660 * 661 */ 662 typedef int (*eventdev_eth_rx_adapter_queue_add_t)( 663 const struct rte_eventdev *dev, 664 const struct rte_eth_dev *eth_dev, 665 int32_t rx_queue_id, 666 const struct rte_event_eth_rx_adapter_queue_conf *queue_conf); 667 668 /** 669 * Delete ethernet Rx queues from event device. This callback is invoked if 670 * the caps returned from eventdev_eth_rx_adapter_caps_get(, eth_port_id) 671 * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set. 672 * 673 * @param dev 674 * Event device pointer 675 * 676 * @param eth_dev 677 * Ethernet device pointer 678 * 679 * @param rx_queue_id 680 * Ethernet device receive queue index 681 * 682 * @return 683 * - 0: Success, ethernet receive queue deleted successfully. 684 * - <0: Error code returned by the driver function. 685 * 686 */ 687 typedef int (*eventdev_eth_rx_adapter_queue_del_t) 688 (const struct rte_eventdev *dev, 689 const struct rte_eth_dev *eth_dev, 690 int32_t rx_queue_id); 691 692 /** 693 * Retrieve Rx adapter queue config information for the specified 694 * rx queue ID. 695 * 696 * @param dev 697 * Event device pointer 698 * 699 * @param eth_dev 700 * Ethernet device pointer 701 * 702 * @param rx_queue_id 703 * Ethernet device receive queue index. 704 * 705 * @param[out] queue_conf 706 * Pointer to rte_event_eth_rx_adapter_queue_conf structure 707 * 708 * @return 709 * - 0: Success 710 * - <0: Error code on failure. 711 */ 712 typedef int (*eventdev_eth_rx_adapter_queue_conf_get_t) 713 (const struct rte_eventdev *dev, 714 const struct rte_eth_dev *eth_dev, 715 uint16_t rx_queue_id, 716 struct rte_event_eth_rx_adapter_queue_conf *queue_conf); 717 718 /** 719 * Start ethernet Rx adapter. This callback is invoked if 720 * the caps returned from eventdev_eth_rx_adapter_caps_get(.., eth_port_id) 721 * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set and Rx queues 722 * from eth_port_id have been added to the event device. 723 * 724 * @param dev 725 * Event device pointer 726 * 727 * @param eth_dev 728 * Ethernet device pointer 729 * 730 * @return 731 * - 0: Success, ethernet Rx adapter started successfully. 732 * - <0: Error code returned by the driver function. 733 */ 734 typedef int (*eventdev_eth_rx_adapter_start_t) 735 (const struct rte_eventdev *dev, 736 const struct rte_eth_dev *eth_dev); 737 738 /** 739 * Stop 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 stopped successfully. 752 * - <0: Error code returned by the driver function. 753 */ 754 typedef int (*eventdev_eth_rx_adapter_stop_t) 755 (const struct rte_eventdev *dev, 756 const struct rte_eth_dev *eth_dev); 757 758 struct rte_event_eth_rx_adapter_stats; 759 760 /** 761 * Retrieve ethernet Rx adapter statistics. 762 * 763 * @param dev 764 * Event device pointer 765 * 766 * @param eth_dev 767 * Ethernet device pointer 768 * 769 * @param[out] stats 770 * Pointer to stats structure 771 * 772 * @return 773 * Return 0 on success. 774 */ 775 776 typedef int (*eventdev_eth_rx_adapter_stats_get) 777 (const struct rte_eventdev *dev, 778 const struct rte_eth_dev *eth_dev, 779 struct rte_event_eth_rx_adapter_stats *stats); 780 /** 781 * Reset ethernet Rx adapter statistics. 782 * 783 * @param dev 784 * Event device pointer 785 * 786 * @param eth_dev 787 * Ethernet device pointer 788 * 789 * @return 790 * Return 0 on success. 791 */ 792 typedef int (*eventdev_eth_rx_adapter_stats_reset) 793 (const struct rte_eventdev *dev, 794 const struct rte_eth_dev *eth_dev); 795 796 struct rte_event_eth_rx_adapter_queue_stats; 797 798 /** 799 * Retrieve ethernet Rx adapter queue statistics. 800 * 801 * @param dev 802 * Event device pointer 803 * 804 * @param eth_dev 805 * Ethernet device pointer 806 * 807 * @param rx_queue_id 808 * Ethernet device receive queue index. 809 * 810 * @param[out] q_stats 811 * Pointer to queue stats structure 812 * 813 * @return 814 * Return 0 on success. 815 */ 816 typedef int (*eventdev_eth_rx_adapter_q_stats_get) 817 (const struct rte_eventdev *dev, 818 const struct rte_eth_dev *eth_dev, 819 uint16_t rx_queue_id, 820 struct rte_event_eth_rx_adapter_queue_stats *q_stats); 821 822 /** 823 * Reset ethernet Rx adapter queue statistics. 824 * 825 * @param dev 826 * Event device pointer 827 * 828 * @param eth_dev 829 * Ethernet device pointer 830 * 831 * @param rx_queue_id 832 * Ethernet device receive queue index. 833 * 834 * @return 835 * Return 0 on success. 836 */ 837 typedef int (*eventdev_eth_rx_adapter_q_stats_reset) 838 (const struct rte_eventdev *dev, 839 const struct rte_eth_dev *eth_dev, 840 uint16_t rx_queue_id); 841 842 /** 843 * Start eventdev selftest. 844 * 845 * @return 846 * Return 0 on success. 847 */ 848 typedef int (*eventdev_selftest)(void); 849 850 struct rte_event_eth_rx_adapter_vector_limits; 851 /** 852 * Get event vector limits for a given event, ethernet device pair. 853 * 854 * @param dev 855 * Event device pointer 856 * 857 * @param eth_dev 858 * Ethernet device pointer 859 * 860 * @param[out] limits 861 * Pointer to the limits structure to be filled. 862 * 863 * @return 864 * - 0: Success. 865 * - <0: Error code returned by the driver function. 866 */ 867 typedef int (*eventdev_eth_rx_adapter_vector_limits_get_t)( 868 const struct rte_eventdev *dev, const struct rte_eth_dev *eth_dev, 869 struct rte_event_eth_rx_adapter_vector_limits *limits); 870 871 typedef uint32_t rte_event_pmd_selftest_seqn_t; 872 extern int rte_event_pmd_selftest_seqn_dynfield_offset; 873 874 /** 875 * Read test sequence number from mbuf. 876 * 877 * @param mbuf Structure to read from. 878 * @return pointer to test sequence number. 879 */ 880 __rte_internal 881 static inline rte_event_pmd_selftest_seqn_t * 882 rte_event_pmd_selftest_seqn(struct rte_mbuf *mbuf) 883 { 884 return RTE_MBUF_DYNFIELD(mbuf, 885 rte_event_pmd_selftest_seqn_dynfield_offset, 886 rte_event_pmd_selftest_seqn_t *); 887 } 888 889 struct rte_cryptodev; 890 891 /** 892 * This API may change without prior notice 893 * 894 * Retrieve the event device's crypto adapter capabilities for the 895 * specified cryptodev 896 * 897 * @param dev 898 * Event device pointer 899 * 900 * @param cdev 901 * cryptodev pointer 902 * 903 * @param[out] caps 904 * A pointer to memory filled with event adapter capabilities. 905 * It is expected to be pre-allocated & initialized by caller. 906 * 907 * @return 908 * - 0: Success, driver provides event adapter capabilities for the 909 * cryptodev. 910 * - <0: Error code returned by the driver function. 911 * 912 */ 913 typedef int (*eventdev_crypto_adapter_caps_get_t) 914 (const struct rte_eventdev *dev, 915 const struct rte_cryptodev *cdev, 916 uint32_t *caps); 917 918 /** 919 * This API may change without prior notice 920 * 921 * Add crypto queue pair to event device. This callback is invoked if 922 * the caps returned from rte_event_crypto_adapter_caps_get(, cdev_id) 923 * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set. 924 * 925 * @param dev 926 * Event device pointer 927 * 928 * @param cdev 929 * cryptodev pointer 930 * 931 * @param queue_pair_id 932 * cryptodev queue pair identifier. 933 * 934 * @param event 935 * Event information required for binding cryptodev queue pair to event queue. 936 * This structure will have a valid value for only those HW PMDs supporting 937 * @see RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND capability. 938 * 939 * @return 940 * - 0: Success, cryptodev queue pair added successfully. 941 * - <0: Error code returned by the driver function. 942 * 943 */ 944 typedef int (*eventdev_crypto_adapter_queue_pair_add_t) 945 (const struct rte_eventdev *dev, 946 const struct rte_cryptodev *cdev, 947 int32_t queue_pair_id, 948 const struct rte_event *event); 949 950 951 /** 952 * This API may change without prior notice 953 * 954 * Delete crypto queue pair to event device. This callback is invoked if 955 * the caps returned from rte_event_crypto_adapter_caps_get(, cdev_id) 956 * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set. 957 * 958 * @param dev 959 * Event device pointer 960 * 961 * @param cdev 962 * cryptodev pointer 963 * 964 * @param queue_pair_id 965 * cryptodev queue pair identifier. 966 * 967 * @return 968 * - 0: Success, cryptodev queue pair deleted successfully. 969 * - <0: Error code returned by the driver function. 970 * 971 */ 972 typedef int (*eventdev_crypto_adapter_queue_pair_del_t) 973 (const struct rte_eventdev *dev, 974 const struct rte_cryptodev *cdev, 975 int32_t queue_pair_id); 976 977 /** 978 * Start crypto adapter. This callback is invoked if 979 * the caps returned from rte_event_crypto_adapter_caps_get(.., cdev_id) 980 * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set and queue pairs 981 * from cdev_id have been added to the event device. 982 * 983 * @param dev 984 * Event device pointer 985 * 986 * @param cdev 987 * Crypto device pointer 988 * 989 * @return 990 * - 0: Success, crypto adapter started successfully. 991 * - <0: Error code returned by the driver function. 992 */ 993 typedef int (*eventdev_crypto_adapter_start_t) 994 (const struct rte_eventdev *dev, 995 const struct rte_cryptodev *cdev); 996 997 /** 998 * Stop 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 stopped successfully. 1011 * - <0: Error code returned by the driver function. 1012 */ 1013 typedef int (*eventdev_crypto_adapter_stop_t) 1014 (const struct rte_eventdev *dev, 1015 const struct rte_cryptodev *cdev); 1016 1017 struct rte_event_crypto_adapter_stats; 1018 1019 /** 1020 * Retrieve crypto adapter statistics. 1021 * 1022 * @param dev 1023 * Event device pointer 1024 * 1025 * @param cdev 1026 * Crypto device pointer 1027 * 1028 * @param[out] stats 1029 * Pointer to stats structure 1030 * 1031 * @return 1032 * Return 0 on success. 1033 */ 1034 1035 typedef int (*eventdev_crypto_adapter_stats_get) 1036 (const struct rte_eventdev *dev, 1037 const struct rte_cryptodev *cdev, 1038 struct rte_event_crypto_adapter_stats *stats); 1039 1040 /** 1041 * Reset crypto adapter statistics. 1042 * 1043 * @param dev 1044 * Event device pointer 1045 * 1046 * @param cdev 1047 * Crypto device pointer 1048 * 1049 * @return 1050 * Return 0 on success. 1051 */ 1052 1053 typedef int (*eventdev_crypto_adapter_stats_reset) 1054 (const struct rte_eventdev *dev, 1055 const struct rte_cryptodev *cdev); 1056 1057 /** 1058 * Retrieve the event device's eth Tx adapter capabilities. 1059 * 1060 * @param dev 1061 * Event device pointer 1062 * 1063 * @param eth_dev 1064 * Ethernet device pointer 1065 * 1066 * @param[out] caps 1067 * A pointer to memory filled with eth Tx adapter capabilities. 1068 * 1069 * @return 1070 * - 0: Success, driver provides eth Tx adapter capabilities 1071 * - <0: Error code returned by the driver function. 1072 * 1073 */ 1074 typedef int (*eventdev_eth_tx_adapter_caps_get_t) 1075 (const struct rte_eventdev *dev, 1076 const struct rte_eth_dev *eth_dev, 1077 uint32_t *caps); 1078 1079 /** 1080 * Create adapter callback. 1081 * 1082 * @param id 1083 * Adapter identifier 1084 * 1085 * @param dev 1086 * Event device pointer 1087 * 1088 * @return 1089 * - 0: Success. 1090 * - <0: Error code on failure. 1091 */ 1092 typedef int (*eventdev_eth_tx_adapter_create_t)(uint8_t id, 1093 const struct rte_eventdev *dev); 1094 1095 /** 1096 * Free adapter callback. 1097 * 1098 * @param id 1099 * Adapter identifier 1100 * 1101 * @param dev 1102 * Event device pointer 1103 * 1104 * @return 1105 * - 0: Success. 1106 * - <0: Error code on failure. 1107 */ 1108 typedef int (*eventdev_eth_tx_adapter_free_t)(uint8_t id, 1109 const struct rte_eventdev *dev); 1110 1111 /** 1112 * Add a Tx queue to the adapter. 1113 * A queue value of -1 is used to indicate all 1114 * queues within the device. 1115 * 1116 * @param id 1117 * Adapter identifier 1118 * 1119 * @param dev 1120 * Event device pointer 1121 * 1122 * @param eth_dev 1123 * Ethernet device pointer 1124 * 1125 * @param tx_queue_id 1126 * Transmit queue index 1127 * 1128 * @return 1129 * - 0: Success. 1130 * - <0: Error code on failure. 1131 */ 1132 typedef int (*eventdev_eth_tx_adapter_queue_add_t)( 1133 uint8_t id, 1134 const struct rte_eventdev *dev, 1135 const struct rte_eth_dev *eth_dev, 1136 int32_t tx_queue_id); 1137 1138 /** 1139 * Delete a Tx queue from the adapter. 1140 * A queue value of -1 is used to indicate all 1141 * queues within the device, that have been added to this 1142 * adapter. 1143 * 1144 * @param id 1145 * Adapter identifier 1146 * 1147 * @param dev 1148 * Event device pointer 1149 * 1150 * @param eth_dev 1151 * Ethernet device pointer 1152 * 1153 * @param tx_queue_id 1154 * Transmit queue index 1155 * 1156 * @return 1157 * - 0: Success, Queues deleted successfully. 1158 * - <0: Error code on failure. 1159 */ 1160 typedef int (*eventdev_eth_tx_adapter_queue_del_t)( 1161 uint8_t id, 1162 const struct rte_eventdev *dev, 1163 const struct rte_eth_dev *eth_dev, 1164 int32_t tx_queue_id); 1165 1166 /** 1167 * Start the adapter. 1168 * 1169 * @param id 1170 * Adapter identifier 1171 * 1172 * @param dev 1173 * Event device pointer 1174 * 1175 * @return 1176 * - 0: Success, Adapter started correctly. 1177 * - <0: Error code on failure. 1178 */ 1179 typedef int (*eventdev_eth_tx_adapter_start_t)(uint8_t id, 1180 const struct rte_eventdev *dev); 1181 1182 /** 1183 * Stop the adapter. 1184 * 1185 * @param id 1186 * Adapter identifier 1187 * 1188 * @param dev 1189 * Event device pointer 1190 * 1191 * @return 1192 * - 0: Success. 1193 * - <0: Error code on failure. 1194 */ 1195 typedef int (*eventdev_eth_tx_adapter_stop_t)(uint8_t id, 1196 const struct rte_eventdev *dev); 1197 1198 struct rte_event_eth_tx_adapter_stats; 1199 1200 /** 1201 * Retrieve statistics for an adapter 1202 * 1203 * @param id 1204 * Adapter identifier 1205 * 1206 * @param dev 1207 * Event device pointer 1208 * 1209 * @param [out] stats 1210 * A pointer to structure used to retrieve statistics for an adapter 1211 * 1212 * @return 1213 * - 0: Success, statistics retrieved successfully. 1214 * - <0: Error code on failure. 1215 */ 1216 typedef int (*eventdev_eth_tx_adapter_stats_get_t)( 1217 uint8_t id, 1218 const struct rte_eventdev *dev, 1219 struct rte_event_eth_tx_adapter_stats *stats); 1220 1221 /** 1222 * Reset statistics for an adapter 1223 * 1224 * @param id 1225 * Adapter identifier 1226 * 1227 * @param dev 1228 * Event device pointer 1229 * 1230 * @return 1231 * - 0: Success, statistics retrieved successfully. 1232 * - <0: Error code on failure. 1233 */ 1234 typedef int (*eventdev_eth_tx_adapter_stats_reset_t)(uint8_t id, 1235 const struct rte_eventdev *dev); 1236 1237 /** Event device operations function pointer table */ 1238 struct eventdev_ops { 1239 eventdev_info_get_t dev_infos_get; /**< Get device info. */ 1240 eventdev_configure_t dev_configure; /**< Configure device. */ 1241 eventdev_start_t dev_start; /**< Start device. */ 1242 eventdev_stop_t dev_stop; /**< Stop device. */ 1243 eventdev_close_t dev_close; /**< Close device. */ 1244 1245 eventdev_queue_default_conf_get_t queue_def_conf; 1246 /**< Get default queue configuration. */ 1247 eventdev_queue_setup_t queue_setup; 1248 /**< Set up an event queue. */ 1249 eventdev_queue_release_t queue_release; 1250 /**< Release an event queue. */ 1251 eventdev_queue_attr_set_t queue_attr_set; 1252 /**< Set an event queue attribute. */ 1253 1254 eventdev_port_default_conf_get_t port_def_conf; 1255 /**< Get default port configuration. */ 1256 eventdev_port_setup_t port_setup; 1257 /**< Set up an event port. */ 1258 eventdev_port_release_t port_release; 1259 /**< Release an event port. */ 1260 eventdev_port_quiesce_t port_quiesce; 1261 /**< Quiesce an event port. */ 1262 1263 eventdev_port_link_t port_link; 1264 /**< Link event queues to an event port. */ 1265 eventdev_port_unlink_t port_unlink; 1266 /**< Unlink event queues from an event port. */ 1267 eventdev_port_unlinks_in_progress_t port_unlinks_in_progress; 1268 /**< Unlinks in progress on an event port. */ 1269 eventdev_dequeue_timeout_ticks_t timeout_ticks; 1270 /**< Converts ns to *timeout_ticks* value for rte_event_dequeue() */ 1271 eventdev_dump_t dump; 1272 /* Dump internal information */ 1273 1274 eventdev_xstats_get_t xstats_get; 1275 /**< Get extended device statistics. */ 1276 eventdev_xstats_get_names_t xstats_get_names; 1277 /**< Get names of extended stats. */ 1278 eventdev_xstats_get_by_name xstats_get_by_name; 1279 /**< Get one value by name. */ 1280 eventdev_xstats_reset_t xstats_reset; 1281 /**< Reset the statistics values in xstats. */ 1282 1283 eventdev_eth_rx_adapter_caps_get_t eth_rx_adapter_caps_get; 1284 /**< Get ethernet Rx adapter capabilities */ 1285 eventdev_eth_rx_adapter_queue_add_t eth_rx_adapter_queue_add; 1286 /**< Add Rx queues to ethernet Rx adapter */ 1287 eventdev_eth_rx_adapter_queue_del_t eth_rx_adapter_queue_del; 1288 /**< Delete Rx queues from ethernet Rx adapter */ 1289 eventdev_eth_rx_adapter_queue_conf_get_t eth_rx_adapter_queue_conf_get; 1290 /**< Get Rx adapter queue info */ 1291 eventdev_eth_rx_adapter_start_t eth_rx_adapter_start; 1292 /**< Start ethernet Rx adapter */ 1293 eventdev_eth_rx_adapter_stop_t eth_rx_adapter_stop; 1294 /**< Stop ethernet Rx adapter */ 1295 eventdev_eth_rx_adapter_stats_get eth_rx_adapter_stats_get; 1296 /**< Get ethernet Rx stats */ 1297 eventdev_eth_rx_adapter_stats_reset eth_rx_adapter_stats_reset; 1298 /**< Reset ethernet Rx stats */ 1299 eventdev_eth_rx_adapter_vector_limits_get_t 1300 eth_rx_adapter_vector_limits_get; 1301 /**< Get event vector limits for the Rx adapter */ 1302 1303 eventdev_timer_adapter_caps_get_t timer_adapter_caps_get; 1304 /**< Get timer adapter capabilities */ 1305 1306 eventdev_crypto_adapter_caps_get_t crypto_adapter_caps_get; 1307 /**< Get crypto adapter capabilities */ 1308 eventdev_crypto_adapter_queue_pair_add_t crypto_adapter_queue_pair_add; 1309 /**< Add queue pair to crypto adapter */ 1310 eventdev_crypto_adapter_queue_pair_del_t crypto_adapter_queue_pair_del; 1311 /**< Delete queue pair from crypto adapter */ 1312 eventdev_crypto_adapter_start_t crypto_adapter_start; 1313 /**< Start crypto adapter */ 1314 eventdev_crypto_adapter_stop_t crypto_adapter_stop; 1315 /**< Stop crypto adapter */ 1316 eventdev_crypto_adapter_stats_get crypto_adapter_stats_get; 1317 /**< Get crypto stats */ 1318 eventdev_crypto_adapter_stats_reset crypto_adapter_stats_reset; 1319 /**< Reset crypto stats */ 1320 1321 eventdev_eth_rx_adapter_q_stats_get eth_rx_adapter_queue_stats_get; 1322 /**< Get ethernet Rx queue stats */ 1323 eventdev_eth_rx_adapter_q_stats_reset eth_rx_adapter_queue_stats_reset; 1324 /**< Reset ethernet Rx queue stats */ 1325 1326 eventdev_eth_tx_adapter_caps_get_t eth_tx_adapter_caps_get; 1327 /**< Get ethernet Tx adapter capabilities */ 1328 1329 eventdev_eth_tx_adapter_create_t eth_tx_adapter_create; 1330 /**< Create adapter callback */ 1331 eventdev_eth_tx_adapter_free_t eth_tx_adapter_free; 1332 /**< Free adapter callback */ 1333 eventdev_eth_tx_adapter_queue_add_t eth_tx_adapter_queue_add; 1334 /**< Add Tx queues to the eth Tx adapter */ 1335 eventdev_eth_tx_adapter_queue_del_t eth_tx_adapter_queue_del; 1336 /**< Delete Tx queues from the eth Tx adapter */ 1337 eventdev_eth_tx_adapter_start_t eth_tx_adapter_start; 1338 /**< Start eth Tx adapter */ 1339 eventdev_eth_tx_adapter_stop_t eth_tx_adapter_stop; 1340 /**< Stop eth Tx adapter */ 1341 eventdev_eth_tx_adapter_stats_get_t eth_tx_adapter_stats_get; 1342 /**< Get eth Tx adapter statistics */ 1343 eventdev_eth_tx_adapter_stats_reset_t eth_tx_adapter_stats_reset; 1344 /**< Reset eth Tx adapter statistics */ 1345 1346 eventdev_selftest dev_selftest; 1347 /**< Start eventdev Selftest */ 1348 1349 eventdev_stop_flush_t dev_stop_flush; 1350 /**< User-provided event flush function */ 1351 }; 1352 1353 /** 1354 * Allocates a new eventdev slot for an event device and returns the pointer 1355 * to that slot for the driver to use. 1356 * 1357 * @param name 1358 * Unique identifier name for each device 1359 * @param socket_id 1360 * Socket to allocate resources on. 1361 * @return 1362 * - Slot in the rte_dev_devices array for a new device; 1363 */ 1364 __rte_internal 1365 struct rte_eventdev * 1366 rte_event_pmd_allocate(const char *name, int socket_id); 1367 1368 /** 1369 * Release the specified eventdev device. 1370 * 1371 * @param eventdev 1372 * The *eventdev* pointer is the address of the *rte_eventdev* structure. 1373 * @return 1374 * - 0 on success, negative on error 1375 */ 1376 __rte_internal 1377 int 1378 rte_event_pmd_release(struct rte_eventdev *eventdev); 1379 1380 /** 1381 * 1382 * @internal 1383 * This is the last step of device probing. 1384 * It must be called after a port is allocated and initialized successfully. 1385 * 1386 * @param eventdev 1387 * New event device. 1388 */ 1389 __rte_internal 1390 void 1391 event_dev_probing_finish(struct rte_eventdev *eventdev); 1392 1393 /** 1394 * Reset eventdevice fastpath APIs to dummy values. 1395 * 1396 * @param fp_ops 1397 * The *fp_ops* pointer to reset. 1398 */ 1399 __rte_internal 1400 void 1401 event_dev_fp_ops_reset(struct rte_event_fp_ops *fp_op); 1402 1403 /** 1404 * Set eventdevice fastpath APIs to event device values. 1405 * 1406 * @param fp_ops 1407 * The *fp_ops* pointer to set. 1408 */ 1409 __rte_internal 1410 void 1411 event_dev_fp_ops_set(struct rte_event_fp_ops *fp_ops, 1412 const struct rte_eventdev *dev); 1413 1414 #ifdef __cplusplus 1415 } 1416 #endif 1417 1418 #endif /* _RTE_EVENTDEV_PMD_H_ */ 1419