ceph/src/spdk/dpdk/lib/librte_eventdev/rte_eventdev_pmd.h

   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_ */