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