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