lib/eventdev/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 #ifdef __cplusplus
   9 extern "C" {
  10 #endif
  11
  12 /** @file
  13  * RTE Event PMD APIs
  14  *
  15  * @note
  16  * These API are from event PMD only and user applications should not call
  17  * them directly.
  18  */
  19
  20 #include <string.h>
  21
  22 #include <rte_common.h>
  23 #include <rte_compat.h>
  24 #include <rte_config.h>
  25 #include <rte_dev.h>
  26 #include <rte_log.h>
  27 #include <rte_malloc.h>
  28 #include <rte_mbuf.h>
  29 #include <rte_mbuf_dyn.h>
  30
  31 #include "event_timer_adapter_pmd.h"
  32 #include "rte_eventdev.h"
  33
  34 /* Logging Macros */
  35 #define RTE_EDEV_LOG_ERR(...) \
  36         RTE_LOG(ERR, EVENTDEV, \
  37                 RTE_FMT("%s() line %u: " RTE_FMT_HEAD(__VA_ARGS__,) "\n", \
  38                         __func__, __LINE__, RTE_FMT_TAIL(__VA_ARGS__,)))
  39
  40 #ifdef RTE_LIBRTE_EVENTDEV_DEBUG
  41 #define RTE_EDEV_LOG_DEBUG(...) \
  42         RTE_LOG(DEBUG, EVENTDEV, \
  43                 RTE_FMT("%s() line %u: " RTE_FMT_HEAD(__VA_ARGS__,) "\n", \
  44                         __func__, __LINE__, RTE_FMT_TAIL(__VA_ARGS__,)))
  45 #else
  46 #define RTE_EDEV_LOG_DEBUG(...) (void)0
  47 #endif
  48
  49 /* Macros to check for valid device */
  50 #define RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, retval) do { \
  51         if (!rte_event_pmd_is_valid_dev((dev_id))) { \
  52                 RTE_EDEV_LOG_ERR("Invalid dev_id=%d\n", dev_id); \
  53                 return retval; \
  54         } \
  55 } while (0)
  56
  57 #define RTE_EVENTDEV_VALID_DEVID_OR_ERRNO_RET(dev_id, errno, retval) do { \
  58         if (!rte_event_pmd_is_valid_dev((dev_id))) { \
  59                 RTE_EDEV_LOG_ERR("Invalid dev_id=%d\n", dev_id); \
  60                 rte_errno = errno; \
  61                 return retval; \
  62         } \
  63 } while (0)
  64
  65 #define RTE_EVENTDEV_VALID_DEVID_OR_RET(dev_id) do { \
  66         if (!rte_event_pmd_is_valid_dev((dev_id))) { \
  67                 RTE_EDEV_LOG_ERR("Invalid dev_id=%d\n", dev_id); \
  68                 return; \
  69         } \
  70 } while (0)
  71
  72 #define RTE_EVENT_ETH_RX_ADAPTER_SW_CAP                                        \
  73         ((RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) |                     \
  74          (RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) |                         \
  75          (RTE_EVENT_ETH_RX_ADAPTER_CAP_EVENT_VECTOR))
  76
  77 #define RTE_EVENT_CRYPTO_ADAPTER_SW_CAP \
  78                 RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA
  79
  80 /**< Ethernet Rx adapter cap to return If the packet transfers from
  81  * the ethdev to eventdev use a SW service function
  82  */
  83
  84 #define RTE_EVENTDEV_DETACHED  (0)
  85 #define RTE_EVENTDEV_ATTACHED  (1)
  86
  87 #define RTE_EVENTDEV_NAME_MAX_LEN (64)
  88 /**< @internal Max length of name of event PMD */
  89
  90 struct rte_eth_dev;
  91
  92 /** Global structure used for maintaining state of allocated event devices */
  93 struct rte_eventdev_global {
  94         uint8_t nb_devs;        /**< Number of devices found */
  95 };
  96
  97 /**
  98  * @internal
  99  * The data part, with no function pointers, associated with each device.
 100  *
 101  * This structure is safe to place in shared memory to be common among
 102  * different processes in a multi-process configuration.
 103  */
 104 struct rte_eventdev_data {
 105         int socket_id;
 106         /**< Socket ID where memory is allocated */
 107         uint8_t dev_id;
 108         /**< Device ID for this instance */
 109         uint8_t nb_queues;
 110         /**< Number of event queues. */
 111         uint8_t nb_ports;
 112         /**< Number of event ports. */
 113         void *ports[RTE_EVENT_MAX_PORTS_PER_DEV];
 114         /**< Array of pointers to ports. */
 115         struct rte_event_port_conf ports_cfg[RTE_EVENT_MAX_PORTS_PER_DEV];
 116         /**< Array of port configuration structures. */
 117         struct rte_event_queue_conf queues_cfg[RTE_EVENT_MAX_QUEUES_PER_DEV];
 118         /**< Array of queue configuration structures. */
 119         uint16_t links_map[RTE_EVENT_MAX_PORTS_PER_DEV *
 120                            RTE_EVENT_MAX_QUEUES_PER_DEV];
 121         /**< Memory to store queues to port connections. */
 122         void *dev_private;
 123         /**< PMD-specific private data */
 124         uint32_t event_dev_cap;
 125         /**< Event device capabilities(RTE_EVENT_DEV_CAP_)*/
 126         struct rte_event_dev_config dev_conf;
 127         /**< Configuration applied to device. */
 128         uint8_t service_inited;
 129         /* Service initialization state */
 130         uint32_t service_id;
 131         /* Service ID*/
 132         void *dev_stop_flush_arg;
 133         /**< User-provided argument for event flush function */
 134
 135         RTE_STD_C11
 136         uint8_t dev_started : 1;
 137         /**< Device state: STARTED(1)/STOPPED(0) */
 138
 139         char name[RTE_EVENTDEV_NAME_MAX_LEN];
 140         /**< Unique identifier name */
 141
 142         uint64_t reserved_64s[4]; /**< Reserved for future fields */
 143         void *reserved_ptrs[4];   /**< Reserved for future fields */
 144 } __rte_cache_aligned;
 145
 146 /** @internal The data structure associated with each event device. */
 147 struct rte_eventdev {
 148         struct rte_eventdev_data *data;
 149         /**< Pointer to device data */
 150         struct eventdev_ops *dev_ops;
 151         /**< Functions exported by PMD */
 152         struct rte_device *dev;
 153         /**< Device info. supplied by probing */
 154
 155         RTE_STD_C11
 156         uint8_t attached : 1;
 157         /**< Flag indicating the device is attached */
 158
 159         event_enqueue_t enqueue;
 160         /**< Pointer to PMD enqueue function. */
 161         event_enqueue_burst_t enqueue_burst;
 162         /**< Pointer to PMD enqueue burst function. */
 163         event_enqueue_burst_t enqueue_new_burst;
 164         /**< Pointer to PMD enqueue burst function(op new variant) */
 165         event_enqueue_burst_t enqueue_forward_burst;
 166         /**< Pointer to PMD enqueue burst function(op forward variant) */
 167         event_dequeue_t dequeue;
 168         /**< Pointer to PMD dequeue function. */
 169         event_dequeue_burst_t dequeue_burst;
 170         /**< Pointer to PMD dequeue burst function. */
 171         event_maintain_t maintain;
 172         /**< Pointer to PMD port maintenance function. */
 173         event_tx_adapter_enqueue_t txa_enqueue_same_dest;
 174         /**< Pointer to PMD eth Tx adapter burst enqueue function with
 175          * events destined to same Eth port & Tx queue.
 176          */
 177         event_tx_adapter_enqueue_t txa_enqueue;
 178         /**< Pointer to PMD eth Tx adapter enqueue function. */
 179         event_crypto_adapter_enqueue_t ca_enqueue;
 180
 181         uint64_t reserved_64s[4]; /**< Reserved for future fields */
 182         void *reserved_ptrs[3];   /**< Reserved for future fields */
 183 } __rte_cache_aligned;
 184
 185 extern struct rte_eventdev *rte_eventdevs;
 186 /** @internal The pool of rte_eventdev structures. */
 187
 188 /**
 189  * Get the rte_eventdev structure device pointer for the named device.
 190  *
 191  * @param name
 192  *   device name to select the device structure.
 193  *
 194  * @return
 195  *   - The rte_eventdev structure pointer for the given device ID.
 196  */
 197 __rte_internal
 198 static inline struct rte_eventdev *
 199 rte_event_pmd_get_named_dev(const char *name)
 200 {
 201         struct rte_eventdev *dev;
 202         unsigned int i;
 203
 204         if (name == NULL)
 205                 return NULL;
 206
 207         for (i = 0; i < RTE_EVENT_MAX_DEVS; i++) {
 208                 dev = &rte_eventdevs[i];
 209                 if ((dev->attached == RTE_EVENTDEV_ATTACHED) &&
 210                                 (strcmp(dev->data->name, name) == 0))
 211                         return dev;
 212         }
 213
 214         return NULL;
 215 }
 216
 217 /**
 218  * Validate if the event device index is valid attached event device.
 219  *
 220  * @param dev_id
 221  *   Event device index.
 222  *
 223  * @return
 224  *   - If the device index is valid (1) or not (0).
 225  */
 226 __rte_internal
 227 static inline unsigned
 228 rte_event_pmd_is_valid_dev(uint8_t dev_id)
 229 {
 230         struct rte_eventdev *dev;
 231
 232         if (dev_id >= RTE_EVENT_MAX_DEVS)
 233                 return 0;
 234
 235         dev = &rte_eventdevs[dev_id];
 236         if (dev->attached != RTE_EVENTDEV_ATTACHED)
 237                 return 0;
 238         else
 239                 return 1;
 240 }
 241
 242 /**
 243  * Definitions of all functions exported by a driver through the
 244  * generic structure of type *event_dev_ops* supplied in the
 245  * *rte_eventdev* structure associated with a device.
 246  */
 247
 248 /**
 249  * Get device information of a device.
 250  *
 251  * @param dev
 252  *   Event device pointer
 253  * @param dev_info
 254  *   Event device information structure
 255  */
 256 typedef void (*eventdev_info_get_t)(struct rte_eventdev *dev,
 257                 struct rte_event_dev_info *dev_info);
 258
 259 /**
 260  * Configure a device.
 261  *
 262  * @param dev
 263  *   Event device pointer
 264  *
 265  * @return
 266  *   Returns 0 on success
 267  */
 268 typedef int (*eventdev_configure_t)(const struct rte_eventdev *dev);
 269
 270 /**
 271  * Start a configured device.
 272  *
 273  * @param dev
 274  *   Event device pointer
 275  *
 276  * @return
 277  *   Returns 0 on success
 278  */
 279 typedef int (*eventdev_start_t)(struct rte_eventdev *dev);
 280
 281 /**
 282  * Stop a configured device.
 283  *
 284  * @param dev
 285  *   Event device pointer
 286  */
 287 typedef void (*eventdev_stop_t)(struct rte_eventdev *dev);
 288
 289 /**
 290  * Close a configured device.
 291  *
 292  * @param dev
 293  *   Event device pointer
 294  *
 295  * @return
 296  * - 0 on success
 297  * - (-EAGAIN) if can't close as device is busy
 298  */
 299 typedef int (*eventdev_close_t)(struct rte_eventdev *dev);
 300
 301 /**
 302  * Retrieve the default event queue configuration.
 303  *
 304  * @param dev
 305  *   Event device pointer
 306  * @param queue_id
 307  *   Event queue index
 308  * @param[out] queue_conf
 309  *   Event queue configuration structure
 310  *
 311  */
 312 typedef void (*eventdev_queue_default_conf_get_t)(struct rte_eventdev *dev,
 313                 uint8_t queue_id, struct rte_event_queue_conf *queue_conf);
 314
 315 /**
 316  * Setup an event queue.
 317  *
 318  * @param dev
 319  *   Event device pointer
 320  * @param queue_id
 321  *   Event queue index
 322  * @param queue_conf
 323  *   Event queue configuration structure
 324  *
 325  * @return
 326  *   Returns 0 on success.
 327  */
 328 typedef int (*eventdev_queue_setup_t)(struct rte_eventdev *dev,
 329                 uint8_t queue_id,
 330                 const struct rte_event_queue_conf *queue_conf);
 331
 332 /**
 333  * Release resources allocated by given event queue.
 334  *
 335  * @param dev
 336  *   Event device pointer
 337  * @param queue_id
 338  *   Event queue index
 339  *
 340  */
 341 typedef void (*eventdev_queue_release_t)(struct rte_eventdev *dev,
 342                 uint8_t queue_id);
 343
 344 /**
 345  * Get an event queue attribute at runtime.
 346  *
 347  * @param dev
 348  *   Event device pointer
 349  * @param queue_id
 350  *   Event queue index
 351  * @param attr_id
 352  *   Event queue attribute id
 353  * @param[out] attr_value
 354  *   Event queue attribute value
 355  *
 356  * @return
 357  *  - 0: Success.
 358  *  - <0: Error code on failure.
 359  */
 360 typedef int (*eventdev_queue_attr_get_t)(struct rte_eventdev *dev,
 361                                          uint8_t queue_id, uint32_t attr_id,
 362                                          uint32_t *attr_value);
 363
 364 /**
 365  * Set an event queue attribute at runtime.
 366  *
 367  * @param dev
 368  *   Event device pointer
 369  * @param queue_id
 370  *   Event queue index
 371  * @param attr_id
 372  *   Event queue attribute id
 373  * @param attr_value
 374  *   Event queue attribute value
 375  *
 376  * @return
 377  *  - 0: Success.
 378  *  - <0: Error code on failure.
 379  */
 380 typedef int (*eventdev_queue_attr_set_t)(struct rte_eventdev *dev,
 381                                          uint8_t queue_id, uint32_t attr_id,
 382                                          uint64_t attr_value);
 383
 384 /**
 385  * Retrieve the default event port configuration.
 386  *
 387  * @param dev
 388  *   Event device pointer
 389  * @param port_id
 390  *   Event port index
 391  * @param[out] port_conf
 392  *   Event port configuration structure
 393  *
 394  */
 395 typedef void (*eventdev_port_default_conf_get_t)(struct rte_eventdev *dev,
 396                 uint8_t port_id, struct rte_event_port_conf *port_conf);
 397
 398 /**
 399  * Setup an event port.
 400  *
 401  * @param dev
 402  *   Event device pointer
 403  * @param port_id
 404  *   Event port index
 405  * @param port_conf
 406  *   Event port configuration structure
 407  *
 408  * @return
 409  *   Returns 0 on success.
 410  */
 411 typedef int (*eventdev_port_setup_t)(struct rte_eventdev *dev,
 412                 uint8_t port_id,
 413                 const struct rte_event_port_conf *port_conf);
 414
 415 /**
 416  * Release memory resources allocated by given event port.
 417  *
 418  * @param port
 419  *   Event port pointer
 420  *
 421  */
 422 typedef void (*eventdev_port_release_t)(void *port);
 423
 424 /**
 425  * Quiesce any core specific resources consumed by the event port
 426  *
 427  * @param dev
 428  *   Event device pointer.
 429  * @param port
 430  *   Event port pointer.
 431  * @param flush_cb
 432  *   User-provided event flush function.
 433  * @param args
 434  *   Arguments to be passed to the user-provided event flush function.
 435  *
 436  */
 437 typedef void (*eventdev_port_quiesce_t)(struct rte_eventdev *dev, void *port,
 438                                         rte_eventdev_port_flush_t flush_cb,
 439                                         void *args);
 440
 441 /**
 442  * Link multiple source event queues to destination event port.
 443  *
 444  * @param dev
 445  *   Event device pointer
 446  * @param port
 447  *   Event port pointer
 448  * @param queues
 449  *   Points to an array of *nb_links* event queues to be linked
 450  *   to the event port.
 451  * @param priorities
 452  *   Points to an array of *nb_links* service priorities associated with each
 453  *   event queue link to event port.
 454  * @param nb_links
 455  *   The number of links to establish
 456  *
 457  * @return
 458  *   Returns 0 on success.
 459  *
 460  */
 461 typedef int (*eventdev_port_link_t)(struct rte_eventdev *dev, void *port,
 462                 const uint8_t queues[], const uint8_t priorities[],
 463                 uint16_t nb_links);
 464
 465 /**
 466  * Unlink multiple source event queues from destination event port.
 467  *
 468  * @param dev
 469  *   Event device pointer
 470  * @param port
 471  *   Event port pointer
 472  * @param queues
 473  *   An array of *nb_unlinks* event queues to be unlinked from the event port.
 474  * @param nb_unlinks
 475  *   The number of unlinks to establish
 476  *
 477  * @return
 478  *   Returns 0 on success.
 479  *
 480  */
 481 typedef int (*eventdev_port_unlink_t)(struct rte_eventdev *dev, void *port,
 482                 uint8_t queues[], uint16_t nb_unlinks);
 483
 484 /**
 485  * Unlinks in progress. Returns number of unlinks that the PMD is currently
 486  * performing, but have not yet been completed.
 487  *
 488  * @param dev
 489  *   Event device pointer
 490  *
 491  * @param port
 492  *   Event port pointer
 493  *
 494  * @return
 495  *   Returns the number of in-progress unlinks. Zero is returned if none are
 496  *   in progress.
 497  */
 498 typedef int (*eventdev_port_unlinks_in_progress_t)(struct rte_eventdev *dev,
 499                 void *port);
 500
 501 /**
 502  * Converts nanoseconds to *timeout_ticks* value for rte_event_dequeue()
 503  *
 504  * @param dev
 505  *   Event device pointer
 506  * @param ns
 507  *   Wait time in nanosecond
 508  * @param[out] timeout_ticks
 509  *   Value for the *timeout_ticks* parameter in rte_event_dequeue() function
 510  *
 511  * @return
 512  *   Returns 0 on success.
 513  *
 514  */
 515 typedef int (*eventdev_dequeue_timeout_ticks_t)(struct rte_eventdev *dev,
 516                 uint64_t ns, uint64_t *timeout_ticks);
 517
 518 /**
 519  * Dump internal information
 520  *
 521  * @param dev
 522  *   Event device pointer
 523  * @param f
 524  *   A pointer to a file for output
 525  *
 526  */
 527 typedef void (*eventdev_dump_t)(struct rte_eventdev *dev, FILE *f);
 528
 529 /**
 530  * Retrieve a set of statistics from device
 531  *
 532  * @param dev
 533  *   Event device pointer
 534  * @param mode
 535  *   Level (device, port or queue)
 536  * @param queue_port_id
 537  *   Queue or port number depending on mode
 538  * @param ids
 539  *   The stat ids to retrieve
 540  * @param values
 541  *   The returned stat values
 542  * @param n
 543  *   The number of id values and entries in the values array
 544  * @return
 545  *   The number of stat values successfully filled into the values array
 546  */
 547 typedef int (*eventdev_xstats_get_t)(const struct rte_eventdev *dev,
 548                 enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id,
 549                 const unsigned int ids[], uint64_t values[], unsigned int n);
 550
 551 /**
 552  * Resets the statistic values in xstats for the device, based on mode.
 553  */
 554 typedef int (*eventdev_xstats_reset_t)(struct rte_eventdev *dev,
 555                 enum rte_event_dev_xstats_mode mode,
 556                 int16_t queue_port_id,
 557                 const uint32_t ids[],
 558                 uint32_t nb_ids);
 559
 560 /**
 561  * Get names of extended stats of an event device
 562  *
 563  * @param dev
 564  *   Event device pointer
 565  * @param mode
 566  *   Level (device, port or queue)
 567  * @param queue_port_id
 568  *   Queue or port number depending on mode
 569  * @param xstats_names
 570  *   Array of name values to be filled in
 571  * @param ids
 572  *   The stat ids to retrieve
 573  * @param size
 574  *   Number of values in the xstats_names array
 575  * @return
 576  *   When size >= the number of stats, return the number of stat values filled
 577  *   into the array.
 578  *   When size < the number of available stats, return the number of stats
 579  *   values, and do not fill in any data into xstats_names.
 580  */
 581 typedef int (*eventdev_xstats_get_names_t)(const struct rte_eventdev *dev,
 582                 enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id,
 583                 struct rte_event_dev_xstats_name *xstats_names,
 584                 unsigned int *ids, unsigned int size);
 585
 586 /**
 587  * Get value of one stats and optionally return its id
 588  *
 589  * @param dev
 590  *   Event device pointer
 591  * @param name
 592  *   The name of the stat to retrieve
 593  * @param id
 594  *   Pointer to an unsigned int where we store the stat-id for future reference.
 595  *   This pointer may be null if the id is not required.
 596  * @return
 597  *   The value of the stat, or (uint64_t)-1 if the stat is not found.
 598  *   If the stat is not found, the id value will be returned as (unsigned)-1,
 599  *   if id pointer is non-NULL
 600  */
 601 typedef uint64_t (*eventdev_xstats_get_by_name)(const struct rte_eventdev *dev,
 602                 const char *name, unsigned int *id);
 603
 604
 605 /**
 606  * Retrieve the event device's ethdev Rx adapter capabilities for the
 607  * specified ethernet port
 608  *
 609  * @param dev
 610  *   Event device pointer
 611  *
 612  * @param eth_dev
 613  *   Ethernet device pointer
 614  *
 615  * @param[out] caps
 616  *   A pointer to memory filled with Rx event adapter capabilities.
 617  *
 618  * @return
 619  *   - 0: Success, driver provides Rx event adapter capabilities for the
 620  *      ethernet device.
 621  *   - <0: Error code returned by the driver function.
 622  *
 623  */
 624 typedef int (*eventdev_eth_rx_adapter_caps_get_t)
 625                                         (const struct rte_eventdev *dev,
 626                                         const struct rte_eth_dev *eth_dev,
 627                                         uint32_t *caps);
 628
 629 struct rte_event_eth_rx_adapter_queue_conf;
 630
 631 /**
 632  * Retrieve the event device's timer adapter capabilities, as well as the ops
 633  * structure that an event timer adapter should call through to enter the
 634  * driver
 635  *
 636  * @param dev
 637  *   Event device pointer
 638  *
 639  * @param flags
 640  *   Flags that can be used to determine how to select an event timer
 641  *   adapter ops structure
 642  *
 643  * @param[out] caps
 644  *   A pointer to memory filled with Rx event adapter capabilities.
 645  *
 646  * @param[out] ops
 647  *   A pointer to the ops pointer to set with the address of the desired ops
 648  *   structure
 649  *
 650  * @return
 651  *   - 0: Success, driver provides Rx event adapter capabilities for the
 652  *      ethernet device.
 653  *   - <0: Error code returned by the driver function.
 654  *
 655  */
 656 typedef int (*eventdev_timer_adapter_caps_get_t)(
 657         const struct rte_eventdev *dev, uint64_t flags, uint32_t *caps,
 658         const struct event_timer_adapter_ops **ops);
 659
 660 /**
 661  * Add ethernet Rx queues to event device. This callback is invoked if
 662  * the caps returned from rte_eventdev_eth_rx_adapter_caps_get(, eth_port_id)
 663  * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set.
 664  *
 665  * @param dev
 666  *   Event device pointer
 667  *
 668  * @param eth_dev
 669  *   Ethernet device pointer
 670  *
 671  * @param rx_queue_id
 672  *   Ethernet device receive queue index
 673  *
 674  * @param queue_conf
 675  *  Additional configuration structure
 676
 677  * @return
 678  *   - 0: Success, ethernet receive queue added successfully.
 679  *   - <0: Error code returned by the driver function.
 680  *
 681  */
 682 typedef int (*eventdev_eth_rx_adapter_queue_add_t)(
 683                 const struct rte_eventdev *dev,
 684                 const struct rte_eth_dev *eth_dev,
 685                 int32_t rx_queue_id,
 686                 const struct rte_event_eth_rx_adapter_queue_conf *queue_conf);
 687
 688 /**
 689  * Delete ethernet Rx queues from event device. This callback is invoked if
 690  * the caps returned from eventdev_eth_rx_adapter_caps_get(, eth_port_id)
 691  * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set.
 692  *
 693  * @param dev
 694  *   Event device pointer
 695  *
 696  * @param eth_dev
 697  *   Ethernet device pointer
 698  *
 699  * @param rx_queue_id
 700  *   Ethernet device receive queue index
 701  *
 702  * @return
 703  *   - 0: Success, ethernet receive queue deleted successfully.
 704  *   - <0: Error code returned by the driver function.
 705  *
 706  */
 707 typedef int (*eventdev_eth_rx_adapter_queue_del_t)
 708                                         (const struct rte_eventdev *dev,
 709                                         const struct rte_eth_dev *eth_dev,
 710                                         int32_t rx_queue_id);
 711
 712 /**
 713  * Retrieve Rx adapter queue config information for the specified
 714  * rx queue ID.
 715  *
 716  * @param dev
 717  *  Event device pointer
 718  *
 719  * @param eth_dev
 720  *  Ethernet device pointer
 721  *
 722  * @param rx_queue_id
 723  *  Ethernet device receive queue index.
 724  *
 725  * @param[out] queue_conf
 726  *  Pointer to rte_event_eth_rx_adapter_queue_conf structure
 727  *
 728  * @return
 729  *  - 0: Success
 730  *  - <0: Error code on failure.
 731  */
 732 typedef int (*eventdev_eth_rx_adapter_queue_conf_get_t)
 733                         (const struct rte_eventdev *dev,
 734                         const struct rte_eth_dev *eth_dev,
 735                         uint16_t rx_queue_id,
 736                         struct rte_event_eth_rx_adapter_queue_conf *queue_conf);
 737
 738 /**
 739  * Start ethernet Rx adapter. This callback is invoked if
 740  * the caps returned from eventdev_eth_rx_adapter_caps_get(.., eth_port_id)
 741  * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set and Rx queues
 742  * from eth_port_id have been added to the event device.
 743  *
 744  * @param dev
 745  *   Event device pointer
 746  *
 747  * @param eth_dev
 748  *   Ethernet device pointer
 749  *
 750  * @return
 751  *   - 0: Success, ethernet Rx adapter started successfully.
 752  *   - <0: Error code returned by the driver function.
 753  */
 754 typedef int (*eventdev_eth_rx_adapter_start_t)
 755                                         (const struct rte_eventdev *dev,
 756                                         const struct rte_eth_dev *eth_dev);
 757
 758 /**
 759  * Stop ethernet Rx adapter. This callback is invoked if
 760  * the caps returned from eventdev_eth_rx_adapter_caps_get(..,eth_port_id)
 761  * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set and Rx queues
 762  * from eth_port_id have been added to the event device.
 763  *
 764  * @param dev
 765  *   Event device pointer
 766  *
 767  * @param eth_dev
 768  *   Ethernet device pointer
 769  *
 770  * @return
 771  *   - 0: Success, ethernet Rx adapter stopped successfully.
 772  *   - <0: Error code returned by the driver function.
 773  */
 774 typedef int (*eventdev_eth_rx_adapter_stop_t)
 775                                         (const struct rte_eventdev *dev,
 776                                         const struct rte_eth_dev *eth_dev);
 777
 778 struct rte_event_eth_rx_adapter_stats;
 779
 780 /**
 781  * Retrieve ethernet Rx adapter statistics.
 782  *
 783  * @param dev
 784  *   Event device pointer
 785  *
 786  * @param eth_dev
 787  *   Ethernet device pointer
 788  *
 789  * @param[out] stats
 790  *   Pointer to stats structure
 791  *
 792  * @return
 793  *   Return 0 on success.
 794  */
 795
 796 typedef int (*eventdev_eth_rx_adapter_stats_get)
 797                         (const struct rte_eventdev *dev,
 798                         const struct rte_eth_dev *eth_dev,
 799                         struct rte_event_eth_rx_adapter_stats *stats);
 800 /**
 801  * Reset ethernet Rx adapter statistics.
 802  *
 803  * @param dev
 804  *   Event device pointer
 805  *
 806  * @param eth_dev
 807  *   Ethernet device pointer
 808  *
 809  * @return
 810  *   Return 0 on success.
 811  */
 812 typedef int (*eventdev_eth_rx_adapter_stats_reset)
 813                         (const struct rte_eventdev *dev,
 814                         const struct rte_eth_dev *eth_dev);
 815
 816 struct rte_event_eth_rx_adapter_queue_stats;
 817
 818 /**
 819  * Retrieve ethernet Rx adapter queue statistics.
 820  *
 821  * @param dev
 822  *   Event device pointer
 823  *
 824  * @param eth_dev
 825  *   Ethernet device pointer
 826  *
 827  * @param rx_queue_id
 828  *  Ethernet device receive queue index.
 829  *
 830  * @param[out] q_stats
 831  *   Pointer to queue stats structure
 832  *
 833  * @return
 834  *   Return 0 on success.
 835  */
 836 typedef int (*eventdev_eth_rx_adapter_q_stats_get)
 837                         (const struct rte_eventdev *dev,
 838                          const struct rte_eth_dev *eth_dev,
 839                          uint16_t rx_queue_id,
 840                          struct rte_event_eth_rx_adapter_queue_stats *q_stats);
 841
 842 /**
 843  * Reset ethernet Rx adapter queue statistics.
 844  *
 845  * @param dev
 846  *   Event device pointer
 847  *
 848  * @param eth_dev
 849  *   Ethernet device pointer
 850  *
 851  * @param rx_queue_id
 852  *  Ethernet device receive queue index.
 853  *
 854  * @return
 855  *   Return 0 on success.
 856  */
 857 typedef int (*eventdev_eth_rx_adapter_q_stats_reset)
 858                         (const struct rte_eventdev *dev,
 859                          const struct rte_eth_dev *eth_dev,
 860                          uint16_t rx_queue_id);
 861
 862 /**
 863  * Start eventdev selftest.
 864  *
 865  * @return
 866  *   Return 0 on success.
 867  */
 868 typedef int (*eventdev_selftest)(void);
 869
 870 struct rte_event_eth_rx_adapter_vector_limits;
 871 /**
 872  * Get event vector limits for a given event, ethernet device pair.
 873  *
 874  * @param dev
 875  *   Event device pointer
 876  *
 877  * @param eth_dev
 878  *   Ethernet device pointer
 879  *
 880  * @param[out] limits
 881  *   Pointer to the limits structure to be filled.
 882  *
 883  * @return
 884  *   - 0: Success.
 885  *   - <0: Error code returned by the driver function.
 886  */
 887 typedef int (*eventdev_eth_rx_adapter_vector_limits_get_t)(
 888         const struct rte_eventdev *dev, const struct rte_eth_dev *eth_dev,
 889         struct rte_event_eth_rx_adapter_vector_limits *limits);
 890
 891 typedef uint32_t rte_event_pmd_selftest_seqn_t;
 892 extern int rte_event_pmd_selftest_seqn_dynfield_offset;
 893
 894 /**
 895  * Read test sequence number from mbuf.
 896  *
 897  * @param mbuf Structure to read from.
 898  * @return pointer to test sequence number.
 899  */
 900 __rte_internal
 901 static inline rte_event_pmd_selftest_seqn_t *
 902 rte_event_pmd_selftest_seqn(struct rte_mbuf *mbuf)
 903 {
 904         return RTE_MBUF_DYNFIELD(mbuf,
 905                 rte_event_pmd_selftest_seqn_dynfield_offset,
 906                 rte_event_pmd_selftest_seqn_t *);
 907 }
 908
 909 struct rte_cryptodev;
 910
 911 /**
 912  * This API may change without prior notice
 913  *
 914  * Retrieve the event device's crypto adapter capabilities for the
 915  * specified cryptodev
 916  *
 917  * @param dev
 918  *   Event device pointer
 919  *
 920  * @param cdev
 921  *   cryptodev pointer
 922  *
 923  * @param[out] caps
 924  *   A pointer to memory filled with event adapter capabilities.
 925  *   It is expected to be pre-allocated & initialized by caller.
 926  *
 927  * @return
 928  *   - 0: Success, driver provides event adapter capabilities for the
 929  *      cryptodev.
 930  *   - <0: Error code returned by the driver function.
 931  *
 932  */
 933 typedef int (*eventdev_crypto_adapter_caps_get_t)
 934                                         (const struct rte_eventdev *dev,
 935                                          const struct rte_cryptodev *cdev,
 936                                          uint32_t *caps);
 937
 938 /**
 939  * This API may change without prior notice
 940  *
 941  * Add crypto queue pair to event device. This callback is invoked if
 942  * the caps returned from rte_event_crypto_adapter_caps_get(, cdev_id)
 943  * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set.
 944  *
 945  * @param dev
 946  *   Event device pointer
 947  *
 948  * @param cdev
 949  *   cryptodev pointer
 950  *
 951  * @param queue_pair_id
 952  *   cryptodev queue pair identifier.
 953  *
 954  * @param event
 955  *  Event information required for binding cryptodev queue pair to event queue.
 956  *  This structure will have a valid value for only those HW PMDs supporting
 957  *  @see RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND capability.
 958  *
 959  * @return
 960  *   - 0: Success, cryptodev queue pair added successfully.
 961  *   - <0: Error code returned by the driver function.
 962  *
 963  */
 964 typedef int (*eventdev_crypto_adapter_queue_pair_add_t)
 965                         (const struct rte_eventdev *dev,
 966                          const struct rte_cryptodev *cdev,
 967                          int32_t queue_pair_id,
 968                          const struct rte_event *event);
 969
 970
 971 /**
 972  * This API may change without prior notice
 973  *
 974  * Delete crypto queue pair to event device. This callback is invoked if
 975  * the caps returned from rte_event_crypto_adapter_caps_get(, cdev_id)
 976  * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set.
 977  *
 978  * @param dev
 979  *   Event device pointer
 980  *
 981  * @param cdev
 982  *   cryptodev pointer
 983  *
 984  * @param queue_pair_id
 985  *   cryptodev queue pair identifier.
 986  *
 987  * @return
 988  *   - 0: Success, cryptodev queue pair deleted successfully.
 989  *   - <0: Error code returned by the driver function.
 990  *
 991  */
 992 typedef int (*eventdev_crypto_adapter_queue_pair_del_t)
 993                                         (const struct rte_eventdev *dev,
 994                                          const struct rte_cryptodev *cdev,
 995                                          int32_t queue_pair_id);
 996
 997 /**
 998  * Start crypto adapter. This callback is invoked if
 999  * the caps returned from rte_event_crypto_adapter_caps_get(.., cdev_id)
1000  * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set and queue pairs
1001  * from cdev_id have been added to the event device.
1002  *
1003  * @param dev
1004  *   Event device pointer
1005  *
1006  * @param cdev
1007  *   Crypto device pointer
1008  *
1009  * @return
1010  *   - 0: Success, crypto adapter started successfully.
1011  *   - <0: Error code returned by the driver function.
1012  */
1013 typedef int (*eventdev_crypto_adapter_start_t)
1014                                         (const struct rte_eventdev *dev,
1015                                          const struct rte_cryptodev *cdev);
1016
1017 /**
1018  * Stop crypto adapter. This callback is invoked if
1019  * the caps returned from rte_event_crypto_adapter_caps_get(.., cdev_id)
1020  * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set and queue pairs
1021  * from cdev_id have been added to the event device.
1022  *
1023  * @param dev
1024  *   Event device pointer
1025  *
1026  * @param cdev
1027  *   Crypto device pointer
1028  *
1029  * @return
1030  *   - 0: Success, crypto adapter stopped successfully.
1031  *   - <0: Error code returned by the driver function.
1032  */
1033 typedef int (*eventdev_crypto_adapter_stop_t)
1034                                         (const struct rte_eventdev *dev,
1035                                          const struct rte_cryptodev *cdev);
1036
1037 struct rte_event_crypto_adapter_stats;
1038
1039 /**
1040  * Retrieve crypto adapter statistics.
1041  *
1042  * @param dev
1043  *   Event device pointer
1044  *
1045  * @param cdev
1046  *   Crypto device pointer
1047  *
1048  * @param[out] stats
1049  *   Pointer to stats structure
1050  *
1051  * @return
1052  *   Return 0 on success.
1053  */
1054
1055 typedef int (*eventdev_crypto_adapter_stats_get)
1056                         (const struct rte_eventdev *dev,
1057                          const struct rte_cryptodev *cdev,
1058                          struct rte_event_crypto_adapter_stats *stats);
1059
1060 /**
1061  * Reset crypto adapter statistics.
1062  *
1063  * @param dev
1064  *   Event device pointer
1065  *
1066  * @param cdev
1067  *   Crypto device pointer
1068  *
1069  * @return
1070  *   Return 0 on success.
1071  */
1072
1073 typedef int (*eventdev_crypto_adapter_stats_reset)
1074                         (const struct rte_eventdev *dev,
1075                          const struct rte_cryptodev *cdev);
1076
1077 /**
1078  * Retrieve the event device's eth Tx adapter capabilities.
1079  *
1080  * @param dev
1081  *   Event device pointer
1082  *
1083  * @param eth_dev
1084  *   Ethernet device pointer
1085  *
1086  * @param[out] caps
1087  *   A pointer to memory filled with eth Tx adapter capabilities.
1088  *
1089  * @return
1090  *   - 0: Success, driver provides eth Tx adapter capabilities
1091  *   - <0: Error code returned by the driver function.
1092  *
1093  */
1094 typedef int (*eventdev_eth_tx_adapter_caps_get_t)
1095                                         (const struct rte_eventdev *dev,
1096                                         const struct rte_eth_dev *eth_dev,
1097                                         uint32_t *caps);
1098
1099 /**
1100  * Create adapter callback.
1101  *
1102  * @param id
1103  *   Adapter identifier
1104  *
1105  * @param dev
1106  *   Event device pointer
1107  *
1108  * @return
1109  *   - 0: Success.
1110  *   - <0: Error code on failure.
1111  */
1112 typedef int (*eventdev_eth_tx_adapter_create_t)(uint8_t id,
1113                                         const struct rte_eventdev *dev);
1114
1115 /**
1116  * Free adapter callback.
1117  *
1118  * @param id
1119  *   Adapter identifier
1120  *
1121  * @param dev
1122  *   Event device pointer
1123  *
1124  * @return
1125  *   - 0: Success.
1126  *   - <0: Error code on failure.
1127  */
1128 typedef int (*eventdev_eth_tx_adapter_free_t)(uint8_t id,
1129                                         const struct rte_eventdev *dev);
1130
1131 /**
1132  * Add a Tx queue to the adapter.
1133  * A queue value of -1 is used to indicate all
1134  * queues within the device.
1135  *
1136  * @param id
1137  *   Adapter identifier
1138  *
1139  * @param dev
1140  *   Event device pointer
1141  *
1142  * @param eth_dev
1143  *   Ethernet device pointer
1144  *
1145  * @param tx_queue_id
1146  *   Transmit queue index
1147  *
1148  * @return
1149  *   - 0: Success.
1150  *   - <0: Error code on failure.
1151  */
1152 typedef int (*eventdev_eth_tx_adapter_queue_add_t)(
1153                                         uint8_t id,
1154                                         const struct rte_eventdev *dev,
1155                                         const struct rte_eth_dev *eth_dev,
1156                                         int32_t tx_queue_id);
1157
1158 /**
1159  * Delete a Tx queue from the adapter.
1160  * A queue value of -1 is used to indicate all
1161  * queues within the device, that have been added to this
1162  * adapter.
1163  *
1164  * @param id
1165  *   Adapter identifier
1166  *
1167  * @param dev
1168  *   Event device pointer
1169  *
1170  * @param eth_dev
1171  *   Ethernet device pointer
1172  *
1173  * @param tx_queue_id
1174  *   Transmit queue index
1175  *
1176  * @return
1177  *  - 0: Success, Queues deleted successfully.
1178  *  - <0: Error code on failure.
1179  */
1180 typedef int (*eventdev_eth_tx_adapter_queue_del_t)(
1181                                         uint8_t id,
1182                                         const struct rte_eventdev *dev,
1183                                         const struct rte_eth_dev *eth_dev,
1184                                         int32_t tx_queue_id);
1185
1186 /**
1187  * Start the adapter.
1188  *
1189  * @param id
1190  *   Adapter identifier
1191  *
1192  * @param dev
1193  *   Event device pointer
1194  *
1195  * @return
1196  *  - 0: Success, Adapter started correctly.
1197  *  - <0: Error code on failure.
1198  */
1199 typedef int (*eventdev_eth_tx_adapter_start_t)(uint8_t id,
1200                                         const struct rte_eventdev *dev);
1201
1202 /**
1203  * Stop the adapter.
1204  *
1205  * @param id
1206  *  Adapter identifier
1207  *
1208  * @param dev
1209  *   Event device pointer
1210  *
1211  * @return
1212  *  - 0: Success.
1213  *  - <0: Error code on failure.
1214  */
1215 typedef int (*eventdev_eth_tx_adapter_stop_t)(uint8_t id,
1216                                         const struct rte_eventdev *dev);
1217
1218 struct rte_event_eth_tx_adapter_stats;
1219
1220 /**
1221  * Retrieve statistics for an adapter
1222  *
1223  * @param id
1224  *  Adapter identifier
1225  *
1226  * @param dev
1227  *   Event device pointer
1228  *
1229  * @param [out] stats
1230  *  A pointer to structure used to retrieve statistics for an adapter
1231  *
1232  * @return
1233  *  - 0: Success, statistics retrieved successfully.
1234  *  - <0: Error code on failure.
1235  */
1236 typedef int (*eventdev_eth_tx_adapter_stats_get_t)(
1237                                 uint8_t id,
1238                                 const struct rte_eventdev *dev,
1239                                 struct rte_event_eth_tx_adapter_stats *stats);
1240
1241 /**
1242  * Reset statistics for an adapter
1243  *
1244  * @param id
1245  *  Adapter identifier
1246  *
1247  * @param dev
1248  *   Event device pointer
1249  *
1250  * @return
1251  *  - 0: Success, statistics retrieved successfully.
1252  *  - <0: Error code on failure.
1253  */
1254 typedef int (*eventdev_eth_tx_adapter_stats_reset_t)(uint8_t id,
1255                                         const struct rte_eventdev *dev);
1256
1257 /** Event device operations function pointer table */
1258 struct eventdev_ops {
1259         eventdev_info_get_t dev_infos_get;      /**< Get device info. */
1260         eventdev_configure_t dev_configure;     /**< Configure device. */
1261         eventdev_start_t dev_start;             /**< Start device. */
1262         eventdev_stop_t dev_stop;               /**< Stop device. */
1263         eventdev_close_t dev_close;             /**< Close device. */
1264
1265         eventdev_queue_default_conf_get_t queue_def_conf;
1266         /**< Get default queue configuration. */
1267         eventdev_queue_setup_t queue_setup;
1268         /**< Set up an event queue. */
1269         eventdev_queue_release_t queue_release;
1270         /**< Release an event queue. */
1271         eventdev_queue_attr_get_t queue_attr_get;
1272         /**< Get an event queue attribute. */
1273         eventdev_queue_attr_set_t queue_attr_set;
1274         /**< Set an event queue attribute. */
1275
1276         eventdev_port_default_conf_get_t port_def_conf;
1277         /**< Get default port configuration. */
1278         eventdev_port_setup_t port_setup;
1279         /**< Set up an event port. */
1280         eventdev_port_release_t port_release;
1281         /**< Release an event port. */
1282         eventdev_port_quiesce_t port_quiesce;
1283         /**< Quiesce an event port. */
1284
1285         eventdev_port_link_t port_link;
1286         /**< Link event queues to an event port. */
1287         eventdev_port_unlink_t port_unlink;
1288         /**< Unlink event queues from an event port. */
1289         eventdev_port_unlinks_in_progress_t port_unlinks_in_progress;
1290         /**< Unlinks in progress on an event port. */
1291         eventdev_dequeue_timeout_ticks_t timeout_ticks;
1292         /**< Converts ns to *timeout_ticks* value for rte_event_dequeue() */
1293         eventdev_dump_t dump;
1294         /* Dump internal information */
1295
1296         eventdev_xstats_get_t xstats_get;
1297         /**< Get extended device statistics. */
1298         eventdev_xstats_get_names_t xstats_get_names;
1299         /**< Get names of extended stats. */
1300         eventdev_xstats_get_by_name xstats_get_by_name;
1301         /**< Get one value by name. */
1302         eventdev_xstats_reset_t xstats_reset;
1303         /**< Reset the statistics values in xstats. */
1304
1305         eventdev_eth_rx_adapter_caps_get_t eth_rx_adapter_caps_get;
1306         /**< Get ethernet Rx adapter capabilities */
1307         eventdev_eth_rx_adapter_queue_add_t eth_rx_adapter_queue_add;
1308         /**< Add Rx queues to ethernet Rx adapter */
1309         eventdev_eth_rx_adapter_queue_del_t eth_rx_adapter_queue_del;
1310         /**< Delete Rx queues from ethernet Rx adapter */
1311         eventdev_eth_rx_adapter_queue_conf_get_t eth_rx_adapter_queue_conf_get;
1312         /**< Get Rx adapter queue info */
1313         eventdev_eth_rx_adapter_start_t eth_rx_adapter_start;
1314         /**< Start ethernet Rx adapter */
1315         eventdev_eth_rx_adapter_stop_t eth_rx_adapter_stop;
1316         /**< Stop ethernet Rx adapter */
1317         eventdev_eth_rx_adapter_stats_get eth_rx_adapter_stats_get;
1318         /**< Get ethernet Rx stats */
1319         eventdev_eth_rx_adapter_stats_reset eth_rx_adapter_stats_reset;
1320         /**< Reset ethernet Rx stats */
1321         eventdev_eth_rx_adapter_vector_limits_get_t
1322                 eth_rx_adapter_vector_limits_get;
1323         /**< Get event vector limits for the Rx adapter */
1324
1325         eventdev_timer_adapter_caps_get_t timer_adapter_caps_get;
1326         /**< Get timer adapter capabilities */
1327
1328         eventdev_crypto_adapter_caps_get_t crypto_adapter_caps_get;
1329         /**< Get crypto adapter capabilities */
1330         eventdev_crypto_adapter_queue_pair_add_t crypto_adapter_queue_pair_add;
1331         /**< Add queue pair to crypto adapter */
1332         eventdev_crypto_adapter_queue_pair_del_t crypto_adapter_queue_pair_del;
1333         /**< Delete queue pair from crypto adapter */
1334         eventdev_crypto_adapter_start_t crypto_adapter_start;
1335         /**< Start crypto adapter */
1336         eventdev_crypto_adapter_stop_t crypto_adapter_stop;
1337         /**< Stop crypto adapter */
1338         eventdev_crypto_adapter_stats_get crypto_adapter_stats_get;
1339         /**< Get crypto stats */
1340         eventdev_crypto_adapter_stats_reset crypto_adapter_stats_reset;
1341         /**< Reset crypto stats */
1342
1343         eventdev_eth_rx_adapter_q_stats_get eth_rx_adapter_queue_stats_get;
1344         /**< Get ethernet Rx queue stats */
1345         eventdev_eth_rx_adapter_q_stats_reset eth_rx_adapter_queue_stats_reset;
1346         /**< Reset ethernet Rx queue stats */
1347
1348         eventdev_eth_tx_adapter_caps_get_t eth_tx_adapter_caps_get;
1349         /**< Get ethernet Tx adapter capabilities */
1350
1351         eventdev_eth_tx_adapter_create_t eth_tx_adapter_create;
1352         /**< Create adapter callback */
1353         eventdev_eth_tx_adapter_free_t eth_tx_adapter_free;
1354         /**< Free adapter callback */
1355         eventdev_eth_tx_adapter_queue_add_t eth_tx_adapter_queue_add;
1356         /**< Add Tx queues to the eth Tx adapter */
1357         eventdev_eth_tx_adapter_queue_del_t eth_tx_adapter_queue_del;
1358         /**< Delete Tx queues from the eth Tx adapter */
1359         eventdev_eth_tx_adapter_start_t eth_tx_adapter_start;
1360         /**< Start eth Tx adapter */
1361         eventdev_eth_tx_adapter_stop_t eth_tx_adapter_stop;
1362         /**< Stop eth Tx adapter */
1363         eventdev_eth_tx_adapter_stats_get_t eth_tx_adapter_stats_get;
1364         /**< Get eth Tx adapter statistics */
1365         eventdev_eth_tx_adapter_stats_reset_t eth_tx_adapter_stats_reset;
1366         /**< Reset eth Tx adapter statistics */
1367
1368         eventdev_selftest dev_selftest;
1369         /**< Start eventdev Selftest */
1370
1371         eventdev_stop_flush_t dev_stop_flush;
1372         /**< User-provided event flush function */
1373 };
1374
1375 /**
1376  * Allocates a new eventdev slot for an event device and returns the pointer
1377  * to that slot for the driver to use.
1378  *
1379  * @param name
1380  *   Unique identifier name for each device
1381  * @param socket_id
1382  *   Socket to allocate resources on.
1383  * @return
1384  *   - Slot in the rte_dev_devices array for a new device;
1385  */
1386 __rte_internal
1387 struct rte_eventdev *
1388 rte_event_pmd_allocate(const char *name, int socket_id);
1389
1390 /**
1391  * Release the specified eventdev device.
1392  *
1393  * @param eventdev
1394  * The *eventdev* pointer is the address of the *rte_eventdev* structure.
1395  * @return
1396  *   - 0 on success, negative on error
1397  */
1398 __rte_internal
1399 int
1400 rte_event_pmd_release(struct rte_eventdev *eventdev);
1401
1402 /**
1403  *
1404  * @internal
1405  * This is the last step of device probing.
1406  * It must be called after a port is allocated and initialized successfully.
1407  *
1408  * @param eventdev
1409  *  New event device.
1410  */
1411 __rte_internal
1412 void
1413 event_dev_probing_finish(struct rte_eventdev *eventdev);
1414
1415 /**
1416  * Reset eventdevice fastpath APIs to dummy values.
1417  *
1418  * @param fp_ops
1419  * The *fp_ops* pointer to reset.
1420  */
1421 __rte_internal
1422 void
1423 event_dev_fp_ops_reset(struct rte_event_fp_ops *fp_op);
1424
1425 /**
1426  * Set eventdevice fastpath APIs to event device values.
1427  *
1428  * @param fp_ops
1429  * The *fp_ops* pointer to set.
1430  */
1431 __rte_internal
1432 void
1433 event_dev_fp_ops_set(struct rte_event_fp_ops *fp_ops,
1434                      const struct rte_eventdev *dev);
1435
1436 #ifdef __cplusplus
1437 }
1438 #endif
1439
1440 #endif /* _RTE_EVENTDEV_PMD_H_ */