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