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