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