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 * Start ethernet Rx adapter. This callback is invoked if 562 * the caps returned from eventdev_eth_rx_adapter_caps_get(.., eth_port_id) 563 * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set and Rx queues 564 * from eth_port_id have been added to the event device. 565 * 566 * @param dev 567 * Event device pointer 568 * 569 * @param eth_dev 570 * Ethernet device pointer 571 * 572 * @return 573 * - 0: Success, ethernet Rx adapter started successfully. 574 * - <0: Error code returned by the driver function. 575 */ 576 typedef int (*eventdev_eth_rx_adapter_start_t) 577 (const struct rte_eventdev *dev, 578 const struct rte_eth_dev *eth_dev); 579 580 /** 581 * Stop ethernet Rx adapter. This callback is invoked if 582 * the caps returned from eventdev_eth_rx_adapter_caps_get(..,eth_port_id) 583 * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set and Rx queues 584 * from eth_port_id have been added to the event device. 585 * 586 * @param dev 587 * Event device pointer 588 * 589 * @param eth_dev 590 * Ethernet device pointer 591 * 592 * @return 593 * - 0: Success, ethernet Rx adapter stopped successfully. 594 * - <0: Error code returned by the driver function. 595 */ 596 typedef int (*eventdev_eth_rx_adapter_stop_t) 597 (const struct rte_eventdev *dev, 598 const struct rte_eth_dev *eth_dev); 599 600 struct rte_event_eth_rx_adapter_stats; 601 602 /** 603 * Retrieve ethernet Rx adapter statistics. 604 * 605 * @param dev 606 * Event device pointer 607 * 608 * @param eth_dev 609 * Ethernet device pointer 610 * 611 * @param[out] stats 612 * Pointer to stats structure 613 * 614 * @return 615 * Return 0 on success. 616 */ 617 618 typedef int (*eventdev_eth_rx_adapter_stats_get) 619 (const struct rte_eventdev *dev, 620 const struct rte_eth_dev *eth_dev, 621 struct rte_event_eth_rx_adapter_stats *stats); 622 /** 623 * Reset ethernet Rx adapter statistics. 624 * 625 * @param dev 626 * Event device pointer 627 * 628 * @param eth_dev 629 * Ethernet device pointer 630 * 631 * @return 632 * Return 0 on success. 633 */ 634 typedef int (*eventdev_eth_rx_adapter_stats_reset) 635 (const struct rte_eventdev *dev, 636 const struct rte_eth_dev *eth_dev); 637 /** 638 * Start eventdev selftest. 639 * 640 * @return 641 * Return 0 on success. 642 */ 643 typedef int (*eventdev_selftest)(void); 644 645 struct rte_event_eth_rx_adapter_vector_limits; 646 /** 647 * Get event vector limits for a given event, ethernet device pair. 648 * 649 * @param dev 650 * Event device pointer 651 * 652 * @param eth_dev 653 * Ethernet device pointer 654 * 655 * @param[out] limits 656 * Pointer to the limits structure to be filled. 657 * 658 * @return 659 * - 0: Success. 660 * - <0: Error code returned by the driver function. 661 */ 662 typedef int (*eventdev_eth_rx_adapter_vector_limits_get_t)( 663 const struct rte_eventdev *dev, const struct rte_eth_dev *eth_dev, 664 struct rte_event_eth_rx_adapter_vector_limits *limits); 665 666 typedef uint32_t rte_event_pmd_selftest_seqn_t; 667 extern int rte_event_pmd_selftest_seqn_dynfield_offset; 668 669 /** 670 * Read test sequence number from mbuf. 671 * 672 * @param mbuf Structure to read from. 673 * @return pointer to test sequence number. 674 */ 675 __rte_internal 676 static inline rte_event_pmd_selftest_seqn_t * 677 rte_event_pmd_selftest_seqn(struct rte_mbuf *mbuf) 678 { 679 return RTE_MBUF_DYNFIELD(mbuf, 680 rte_event_pmd_selftest_seqn_dynfield_offset, 681 rte_event_pmd_selftest_seqn_t *); 682 } 683 684 struct rte_cryptodev; 685 686 /** 687 * This API may change without prior notice 688 * 689 * Retrieve the event device's crypto adapter capabilities for the 690 * specified cryptodev 691 * 692 * @param dev 693 * Event device pointer 694 * 695 * @param cdev 696 * cryptodev pointer 697 * 698 * @param[out] caps 699 * A pointer to memory filled with event adapter capabilities. 700 * It is expected to be pre-allocated & initialized by caller. 701 * 702 * @return 703 * - 0: Success, driver provides event adapter capabilities for the 704 * cryptodev. 705 * - <0: Error code returned by the driver function. 706 * 707 */ 708 typedef int (*eventdev_crypto_adapter_caps_get_t) 709 (const struct rte_eventdev *dev, 710 const struct rte_cryptodev *cdev, 711 uint32_t *caps); 712 713 /** 714 * This API may change without prior notice 715 * 716 * Add crypto queue pair to event device. This callback is invoked if 717 * the caps returned from rte_event_crypto_adapter_caps_get(, cdev_id) 718 * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set. 719 * 720 * @param dev 721 * Event device pointer 722 * 723 * @param cdev 724 * cryptodev pointer 725 * 726 * @param queue_pair_id 727 * cryptodev queue pair identifier. 728 * 729 * @param event 730 * Event information required for binding cryptodev queue pair to event queue. 731 * This structure will have a valid value for only those HW PMDs supporting 732 * @see RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND capability. 733 * 734 * @return 735 * - 0: Success, cryptodev queue pair added successfully. 736 * - <0: Error code returned by the driver function. 737 * 738 */ 739 typedef int (*eventdev_crypto_adapter_queue_pair_add_t) 740 (const struct rte_eventdev *dev, 741 const struct rte_cryptodev *cdev, 742 int32_t queue_pair_id, 743 const struct rte_event *event); 744 745 746 /** 747 * This API may change without prior notice 748 * 749 * Delete crypto queue pair to event device. This callback is invoked if 750 * the caps returned from rte_event_crypto_adapter_caps_get(, cdev_id) 751 * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set. 752 * 753 * @param dev 754 * Event device pointer 755 * 756 * @param cdev 757 * cryptodev pointer 758 * 759 * @param queue_pair_id 760 * cryptodev queue pair identifier. 761 * 762 * @return 763 * - 0: Success, cryptodev queue pair deleted successfully. 764 * - <0: Error code returned by the driver function. 765 * 766 */ 767 typedef int (*eventdev_crypto_adapter_queue_pair_del_t) 768 (const struct rte_eventdev *dev, 769 const struct rte_cryptodev *cdev, 770 int32_t queue_pair_id); 771 772 /** 773 * Start crypto adapter. This callback is invoked if 774 * the caps returned from rte_event_crypto_adapter_caps_get(.., cdev_id) 775 * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set and queue pairs 776 * from cdev_id have been added to the event device. 777 * 778 * @param dev 779 * Event device pointer 780 * 781 * @param cdev 782 * Crypto device pointer 783 * 784 * @return 785 * - 0: Success, crypto adapter started successfully. 786 * - <0: Error code returned by the driver function. 787 */ 788 typedef int (*eventdev_crypto_adapter_start_t) 789 (const struct rte_eventdev *dev, 790 const struct rte_cryptodev *cdev); 791 792 /** 793 * Stop crypto adapter. This callback is invoked if 794 * the caps returned from rte_event_crypto_adapter_caps_get(.., cdev_id) 795 * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set and queue pairs 796 * from cdev_id have been added to the event device. 797 * 798 * @param dev 799 * Event device pointer 800 * 801 * @param cdev 802 * Crypto device pointer 803 * 804 * @return 805 * - 0: Success, crypto adapter stopped successfully. 806 * - <0: Error code returned by the driver function. 807 */ 808 typedef int (*eventdev_crypto_adapter_stop_t) 809 (const struct rte_eventdev *dev, 810 const struct rte_cryptodev *cdev); 811 812 struct rte_event_crypto_adapter_stats; 813 814 /** 815 * Retrieve crypto adapter statistics. 816 * 817 * @param dev 818 * Event device pointer 819 * 820 * @param cdev 821 * Crypto device pointer 822 * 823 * @param[out] stats 824 * Pointer to stats structure 825 * 826 * @return 827 * Return 0 on success. 828 */ 829 830 typedef int (*eventdev_crypto_adapter_stats_get) 831 (const struct rte_eventdev *dev, 832 const struct rte_cryptodev *cdev, 833 struct rte_event_crypto_adapter_stats *stats); 834 835 /** 836 * Reset crypto adapter statistics. 837 * 838 * @param dev 839 * Event device pointer 840 * 841 * @param cdev 842 * Crypto device pointer 843 * 844 * @return 845 * Return 0 on success. 846 */ 847 848 typedef int (*eventdev_crypto_adapter_stats_reset) 849 (const struct rte_eventdev *dev, 850 const struct rte_cryptodev *cdev); 851 852 /** 853 * Retrieve the event device's eth Tx adapter capabilities. 854 * 855 * @param dev 856 * Event device pointer 857 * 858 * @param eth_dev 859 * Ethernet device pointer 860 * 861 * @param[out] caps 862 * A pointer to memory filled with eth Tx adapter capabilities. 863 * 864 * @return 865 * - 0: Success, driver provides eth Tx adapter capabilities 866 * - <0: Error code returned by the driver function. 867 * 868 */ 869 typedef int (*eventdev_eth_tx_adapter_caps_get_t) 870 (const struct rte_eventdev *dev, 871 const struct rte_eth_dev *eth_dev, 872 uint32_t *caps); 873 874 /** 875 * Create adapter callback. 876 * 877 * @param id 878 * Adapter identifier 879 * 880 * @param dev 881 * Event device pointer 882 * 883 * @return 884 * - 0: Success. 885 * - <0: Error code on failure. 886 */ 887 typedef int (*eventdev_eth_tx_adapter_create_t)(uint8_t id, 888 const struct rte_eventdev *dev); 889 890 /** 891 * Free adapter callback. 892 * 893 * @param id 894 * Adapter identifier 895 * 896 * @param dev 897 * Event device pointer 898 * 899 * @return 900 * - 0: Success. 901 * - <0: Error code on failure. 902 */ 903 typedef int (*eventdev_eth_tx_adapter_free_t)(uint8_t id, 904 const struct rte_eventdev *dev); 905 906 /** 907 * Add a Tx queue to the adapter. 908 * A queue value of -1 is used to indicate all 909 * queues within the device. 910 * 911 * @param id 912 * Adapter identifier 913 * 914 * @param dev 915 * Event device pointer 916 * 917 * @param eth_dev 918 * Ethernet device pointer 919 * 920 * @param tx_queue_id 921 * Transmit queue index 922 * 923 * @return 924 * - 0: Success. 925 * - <0: Error code on failure. 926 */ 927 typedef int (*eventdev_eth_tx_adapter_queue_add_t)( 928 uint8_t id, 929 const struct rte_eventdev *dev, 930 const struct rte_eth_dev *eth_dev, 931 int32_t tx_queue_id); 932 933 /** 934 * Delete a Tx queue from the adapter. 935 * A queue value of -1 is used to indicate all 936 * queues within the device, that have been added to this 937 * adapter. 938 * 939 * @param id 940 * Adapter identifier 941 * 942 * @param dev 943 * Event device pointer 944 * 945 * @param eth_dev 946 * Ethernet device pointer 947 * 948 * @param tx_queue_id 949 * Transmit queue index 950 * 951 * @return 952 * - 0: Success, Queues deleted successfully. 953 * - <0: Error code on failure. 954 */ 955 typedef int (*eventdev_eth_tx_adapter_queue_del_t)( 956 uint8_t id, 957 const struct rte_eventdev *dev, 958 const struct rte_eth_dev *eth_dev, 959 int32_t tx_queue_id); 960 961 /** 962 * Start the adapter. 963 * 964 * @param id 965 * Adapter identifier 966 * 967 * @param dev 968 * Event device pointer 969 * 970 * @return 971 * - 0: Success, Adapter started correctly. 972 * - <0: Error code on failure. 973 */ 974 typedef int (*eventdev_eth_tx_adapter_start_t)(uint8_t id, 975 const struct rte_eventdev *dev); 976 977 /** 978 * Stop the adapter. 979 * 980 * @param id 981 * Adapter identifier 982 * 983 * @param dev 984 * Event device pointer 985 * 986 * @return 987 * - 0: Success. 988 * - <0: Error code on failure. 989 */ 990 typedef int (*eventdev_eth_tx_adapter_stop_t)(uint8_t id, 991 const struct rte_eventdev *dev); 992 993 struct rte_event_eth_tx_adapter_stats; 994 995 /** 996 * Retrieve statistics for an adapter 997 * 998 * @param id 999 * Adapter identifier 1000 * 1001 * @param dev 1002 * Event device pointer 1003 * 1004 * @param [out] stats 1005 * A pointer to structure used to retrieve statistics for an adapter 1006 * 1007 * @return 1008 * - 0: Success, statistics retrieved successfully. 1009 * - <0: Error code on failure. 1010 */ 1011 typedef int (*eventdev_eth_tx_adapter_stats_get_t)( 1012 uint8_t id, 1013 const struct rte_eventdev *dev, 1014 struct rte_event_eth_tx_adapter_stats *stats); 1015 1016 /** 1017 * Reset statistics for an adapter 1018 * 1019 * @param id 1020 * Adapter identifier 1021 * 1022 * @param dev 1023 * Event device pointer 1024 * 1025 * @return 1026 * - 0: Success, statistics retrieved successfully. 1027 * - <0: Error code on failure. 1028 */ 1029 typedef int (*eventdev_eth_tx_adapter_stats_reset_t)(uint8_t id, 1030 const struct rte_eventdev *dev); 1031 1032 /** Event device operations function pointer table */ 1033 struct rte_eventdev_ops { 1034 eventdev_info_get_t dev_infos_get; /**< Get device info. */ 1035 eventdev_configure_t dev_configure; /**< Configure device. */ 1036 eventdev_start_t dev_start; /**< Start device. */ 1037 eventdev_stop_t dev_stop; /**< Stop device. */ 1038 eventdev_close_t dev_close; /**< Close device. */ 1039 1040 eventdev_queue_default_conf_get_t queue_def_conf; 1041 /**< Get default queue configuration. */ 1042 eventdev_queue_setup_t queue_setup; 1043 /**< Set up an event queue. */ 1044 eventdev_queue_release_t queue_release; 1045 /**< Release an event queue. */ 1046 1047 eventdev_port_default_conf_get_t port_def_conf; 1048 /**< Get default port configuration. */ 1049 eventdev_port_setup_t port_setup; 1050 /**< Set up an event port. */ 1051 eventdev_port_release_t port_release; 1052 /**< Release an event port. */ 1053 1054 eventdev_port_link_t port_link; 1055 /**< Link event queues to an event port. */ 1056 eventdev_port_unlink_t port_unlink; 1057 /**< Unlink event queues from an event port. */ 1058 eventdev_port_unlinks_in_progress_t port_unlinks_in_progress; 1059 /**< Unlinks in progress on an event port. */ 1060 eventdev_dequeue_timeout_ticks_t timeout_ticks; 1061 /**< Converts ns to *timeout_ticks* value for rte_event_dequeue() */ 1062 eventdev_dump_t dump; 1063 /* Dump internal information */ 1064 1065 eventdev_xstats_get_t xstats_get; 1066 /**< Get extended device statistics. */ 1067 eventdev_xstats_get_names_t xstats_get_names; 1068 /**< Get names of extended stats. */ 1069 eventdev_xstats_get_by_name xstats_get_by_name; 1070 /**< Get one value by name. */ 1071 eventdev_xstats_reset_t xstats_reset; 1072 /**< Reset the statistics values in xstats. */ 1073 1074 eventdev_eth_rx_adapter_caps_get_t eth_rx_adapter_caps_get; 1075 /**< Get ethernet Rx adapter capabilities */ 1076 eventdev_eth_rx_adapter_queue_add_t eth_rx_adapter_queue_add; 1077 /**< Add Rx queues to ethernet Rx adapter */ 1078 eventdev_eth_rx_adapter_queue_del_t eth_rx_adapter_queue_del; 1079 /**< Delete Rx queues from ethernet Rx adapter */ 1080 eventdev_eth_rx_adapter_start_t eth_rx_adapter_start; 1081 /**< Start ethernet Rx adapter */ 1082 eventdev_eth_rx_adapter_stop_t eth_rx_adapter_stop; 1083 /**< Stop ethernet Rx adapter */ 1084 eventdev_eth_rx_adapter_stats_get eth_rx_adapter_stats_get; 1085 /**< Get ethernet Rx stats */ 1086 eventdev_eth_rx_adapter_stats_reset eth_rx_adapter_stats_reset; 1087 /**< Reset ethernet Rx stats */ 1088 eventdev_eth_rx_adapter_vector_limits_get_t 1089 eth_rx_adapter_vector_limits_get; 1090 /**< Get event vector limits for the Rx adapter */ 1091 1092 eventdev_timer_adapter_caps_get_t timer_adapter_caps_get; 1093 /**< Get timer adapter capabilities */ 1094 1095 eventdev_crypto_adapter_caps_get_t crypto_adapter_caps_get; 1096 /**< Get crypto adapter capabilities */ 1097 eventdev_crypto_adapter_queue_pair_add_t crypto_adapter_queue_pair_add; 1098 /**< Add queue pair to crypto adapter */ 1099 eventdev_crypto_adapter_queue_pair_del_t crypto_adapter_queue_pair_del; 1100 /**< Delete queue pair from crypto adapter */ 1101 eventdev_crypto_adapter_start_t crypto_adapter_start; 1102 /**< Start crypto adapter */ 1103 eventdev_crypto_adapter_stop_t crypto_adapter_stop; 1104 /**< Stop crypto adapter */ 1105 eventdev_crypto_adapter_stats_get crypto_adapter_stats_get; 1106 /**< Get crypto stats */ 1107 eventdev_crypto_adapter_stats_reset crypto_adapter_stats_reset; 1108 /**< Reset crypto stats */ 1109 1110 eventdev_eth_tx_adapter_caps_get_t eth_tx_adapter_caps_get; 1111 /**< Get ethernet Tx adapter capabilities */ 1112 1113 eventdev_eth_tx_adapter_create_t eth_tx_adapter_create; 1114 /**< Create adapter callback */ 1115 eventdev_eth_tx_adapter_free_t eth_tx_adapter_free; 1116 /**< Free adapter callback */ 1117 eventdev_eth_tx_adapter_queue_add_t eth_tx_adapter_queue_add; 1118 /**< Add Tx queues to the eth Tx adapter */ 1119 eventdev_eth_tx_adapter_queue_del_t eth_tx_adapter_queue_del; 1120 /**< Delete Tx queues from the eth Tx adapter */ 1121 eventdev_eth_tx_adapter_start_t eth_tx_adapter_start; 1122 /**< Start eth Tx adapter */ 1123 eventdev_eth_tx_adapter_stop_t eth_tx_adapter_stop; 1124 /**< Stop eth Tx adapter */ 1125 eventdev_eth_tx_adapter_stats_get_t eth_tx_adapter_stats_get; 1126 /**< Get eth Tx adapter statistics */ 1127 eventdev_eth_tx_adapter_stats_reset_t eth_tx_adapter_stats_reset; 1128 /**< Reset eth Tx adapter statistics */ 1129 1130 eventdev_selftest dev_selftest; 1131 /**< Start eventdev Selftest */ 1132 1133 eventdev_stop_flush_t dev_stop_flush; 1134 /**< User-provided event flush function */ 1135 }; 1136 1137 /** 1138 * Allocates a new eventdev slot for an event device and returns the pointer 1139 * to that slot for the driver to use. 1140 * 1141 * @param name 1142 * Unique identifier name for each device 1143 * @param socket_id 1144 * Socket to allocate resources on. 1145 * @return 1146 * - Slot in the rte_dev_devices array for a new device; 1147 */ 1148 struct rte_eventdev * 1149 rte_event_pmd_allocate(const char *name, int socket_id); 1150 1151 /** 1152 * Release the specified eventdev device. 1153 * 1154 * @param eventdev 1155 * The *eventdev* pointer is the address of the *rte_eventdev* structure. 1156 * @return 1157 * - 0 on success, negative on error 1158 */ 1159 int 1160 rte_event_pmd_release(struct rte_eventdev *eventdev); 1161 1162 #endif /* _RTE_EVENTDEV_PMD_H_ */ 1163