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  * Retrieve the default event port configuration.
 346  *
 347  * @param dev
 348  *   Event device pointer
 349  * @param port_id
 350  *   Event port index
 351  * @param[out] port_conf
 352  *   Event port configuration structure
 353  *
 354  */
 355 typedef void (*eventdev_port_default_conf_get_t)(struct rte_eventdev *dev,
 356                 uint8_t port_id, struct rte_event_port_conf *port_conf);
 357
 358 /**
 359  * Setup an event port.
 360  *
 361  * @param dev
 362  *   Event device pointer
 363  * @param port_id
 364  *   Event port index
 365  * @param port_conf
 366  *   Event port configuration structure
 367  *
 368  * @return
 369  *   Returns 0 on success.
 370  */
 371 typedef int (*eventdev_port_setup_t)(struct rte_eventdev *dev,
 372                 uint8_t port_id,
 373                 const struct rte_event_port_conf *port_conf);
 374
 375 /**
 376  * Release memory resources allocated by given event port.
 377  *
 378  * @param port
 379  *   Event port pointer
 380  *
 381  */
 382 typedef void (*eventdev_port_release_t)(void *port);
 383
 384 /**
 385  * Link multiple source event queues to destination event port.
 386  *
 387  * @param dev
 388  *   Event device pointer
 389  * @param port
 390  *   Event port pointer
 391  * @param queues
 392  *   Points to an array of *nb_links* event queues to be linked
 393  *   to the event port.
 394  * @param priorities
 395  *   Points to an array of *nb_links* service priorities associated with each
 396  *   event queue link to event port.
 397  * @param nb_links
 398  *   The number of links to establish
 399  *
 400  * @return
 401  *   Returns 0 on success.
 402  *
 403  */
 404 typedef int (*eventdev_port_link_t)(struct rte_eventdev *dev, void *port,
 405                 const uint8_t queues[], const uint8_t priorities[],
 406                 uint16_t nb_links);
 407
 408 /**
 409  * Unlink multiple source event queues from destination event port.
 410  *
 411  * @param dev
 412  *   Event device pointer
 413  * @param port
 414  *   Event port pointer
 415  * @param queues
 416  *   An array of *nb_unlinks* event queues to be unlinked from the event port.
 417  * @param nb_unlinks
 418  *   The number of unlinks to establish
 419  *
 420  * @return
 421  *   Returns 0 on success.
 422  *
 423  */
 424 typedef int (*eventdev_port_unlink_t)(struct rte_eventdev *dev, void *port,
 425                 uint8_t queues[], uint16_t nb_unlinks);
 426
 427 /**
 428  * Unlinks in progress. Returns number of unlinks that the PMD is currently
 429  * performing, but have not yet been completed.
 430  *
 431  * @param dev
 432  *   Event device pointer
 433  *
 434  * @param port
 435  *   Event port pointer
 436  *
 437  * @return
 438  *   Returns the number of in-progress unlinks. Zero is returned if none are
 439  *   in progress.
 440  */
 441 typedef int (*eventdev_port_unlinks_in_progress_t)(struct rte_eventdev *dev,
 442                 void *port);
 443
 444 /**
 445  * Converts nanoseconds to *timeout_ticks* value for rte_event_dequeue()
 446  *
 447  * @param dev
 448  *   Event device pointer
 449  * @param ns
 450  *   Wait time in nanosecond
 451  * @param[out] timeout_ticks
 452  *   Value for the *timeout_ticks* parameter in rte_event_dequeue() function
 453  *
 454  * @return
 455  *   Returns 0 on success.
 456  *
 457  */
 458 typedef int (*eventdev_dequeue_timeout_ticks_t)(struct rte_eventdev *dev,
 459                 uint64_t ns, uint64_t *timeout_ticks);
 460
 461 /**
 462  * Dump internal information
 463  *
 464  * @param dev
 465  *   Event device pointer
 466  * @param f
 467  *   A pointer to a file for output
 468  *
 469  */
 470 typedef void (*eventdev_dump_t)(struct rte_eventdev *dev, FILE *f);
 471
 472 /**
 473  * Retrieve a set of statistics from device
 474  *
 475  * @param dev
 476  *   Event device pointer
 477  * @param mode
 478  *   Level (device, port or queue)
 479  * @param queue_port_id
 480  *   Queue or port number depending on mode
 481  * @param ids
 482  *   The stat ids to retrieve
 483  * @param values
 484  *   The returned stat values
 485  * @param n
 486  *   The number of id values and entries in the values array
 487  * @return
 488  *   The number of stat values successfully filled into the values array
 489  */
 490 typedef int (*eventdev_xstats_get_t)(const struct rte_eventdev *dev,
 491                 enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id,
 492                 const unsigned int ids[], uint64_t values[], unsigned int n);
 493
 494 /**
 495  * Resets the statistic values in xstats for the device, based on mode.
 496  */
 497 typedef int (*eventdev_xstats_reset_t)(struct rte_eventdev *dev,
 498                 enum rte_event_dev_xstats_mode mode,
 499                 int16_t queue_port_id,
 500                 const uint32_t ids[],
 501                 uint32_t nb_ids);
 502
 503 /**
 504  * Get names of extended stats of an event device
 505  *
 506  * @param dev
 507  *   Event device pointer
 508  * @param mode
 509  *   Level (device, port or queue)
 510  * @param queue_port_id
 511  *   Queue or port number depending on mode
 512  * @param xstats_names
 513  *   Array of name values to be filled in
 514  * @param ids
 515  *   The stat ids to retrieve
 516  * @param size
 517  *   Number of values in the xstats_names array
 518  * @return
 519  *   When size >= the number of stats, return the number of stat values filled
 520  *   into the array.
 521  *   When size < the number of available stats, return the number of stats
 522  *   values, and do not fill in any data into xstats_names.
 523  */
 524 typedef int (*eventdev_xstats_get_names_t)(const struct rte_eventdev *dev,
 525                 enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id,
 526                 struct rte_event_dev_xstats_name *xstats_names,
 527                 unsigned int *ids, unsigned int size);
 528
 529 /**
 530  * Get value of one stats and optionally return its id
 531  *
 532  * @param dev
 533  *   Event device pointer
 534  * @param name
 535  *   The name of the stat to retrieve
 536  * @param id
 537  *   Pointer to an unsigned int where we store the stat-id for future reference.
 538  *   This pointer may be null if the id is not required.
 539  * @return
 540  *   The value of the stat, or (uint64_t)-1 if the stat is not found.
 541  *   If the stat is not found, the id value will be returned as (unsigned)-1,
 542  *   if id pointer is non-NULL
 543  */
 544 typedef uint64_t (*eventdev_xstats_get_by_name)(const struct rte_eventdev *dev,
 545                 const char *name, unsigned int *id);
 546
 547
 548 /**
 549  * Retrieve the event device's ethdev Rx adapter capabilities for the
 550  * specified ethernet port
 551  *
 552  * @param dev
 553  *   Event device pointer
 554  *
 555  * @param eth_dev
 556  *   Ethernet device pointer
 557  *
 558  * @param[out] caps
 559  *   A pointer to memory filled with Rx event adapter capabilities.
 560  *
 561  * @return
 562  *   - 0: Success, driver provides Rx event adapter capabilities for the
 563  *      ethernet device.
 564  *   - <0: Error code returned by the driver function.
 565  *
 566  */
 567 typedef int (*eventdev_eth_rx_adapter_caps_get_t)
 568                                         (const struct rte_eventdev *dev,
 569                                         const struct rte_eth_dev *eth_dev,
 570                                         uint32_t *caps);
 571
 572 struct rte_event_eth_rx_adapter_queue_conf;
 573
 574 /**
 575  * Retrieve the event device's timer adapter capabilities, as well as the ops
 576  * structure that an event timer adapter should call through to enter the
 577  * driver
 578  *
 579  * @param dev
 580  *   Event device pointer
 581  *
 582  * @param flags
 583  *   Flags that can be used to determine how to select an event timer
 584  *   adapter ops structure
 585  *
 586  * @param[out] caps
 587  *   A pointer to memory filled with Rx event adapter capabilities.
 588  *
 589  * @param[out] ops
 590  *   A pointer to the ops pointer to set with the address of the desired ops
 591  *   structure
 592  *
 593  * @return
 594  *   - 0: Success, driver provides Rx event adapter capabilities for the
 595  *      ethernet device.
 596  *   - <0: Error code returned by the driver function.
 597  *
 598  */
 599 typedef int (*eventdev_timer_adapter_caps_get_t)(
 600         const struct rte_eventdev *dev, uint64_t flags, uint32_t *caps,
 601         const struct event_timer_adapter_ops **ops);
 602
 603 /**
 604  * Add ethernet Rx queues to event device. This callback is invoked if
 605  * the caps returned from rte_eventdev_eth_rx_adapter_caps_get(, eth_port_id)
 606  * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set.
 607  *
 608  * @param dev
 609  *   Event device pointer
 610  *
 611  * @param eth_dev
 612  *   Ethernet device pointer
 613  *
 614  * @param rx_queue_id
 615  *   Ethernet device receive queue index
 616  *
 617  * @param queue_conf
 618  *  Additional configuration structure
 619
 620  * @return
 621  *   - 0: Success, ethernet receive queue added successfully.
 622  *   - <0: Error code returned by the driver function.
 623  *
 624  */
 625 typedef int (*eventdev_eth_rx_adapter_queue_add_t)(
 626                 const struct rte_eventdev *dev,
 627                 const struct rte_eth_dev *eth_dev,
 628                 int32_t rx_queue_id,
 629                 const struct rte_event_eth_rx_adapter_queue_conf *queue_conf);
 630
 631 /**
 632  * Delete ethernet Rx queues from event device. This callback is invoked if
 633  * the caps returned from eventdev_eth_rx_adapter_caps_get(, eth_port_id)
 634  * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set.
 635  *
 636  * @param dev
 637  *   Event device pointer
 638  *
 639  * @param eth_dev
 640  *   Ethernet device pointer
 641  *
 642  * @param rx_queue_id
 643  *   Ethernet device receive queue index
 644  *
 645  * @return
 646  *   - 0: Success, ethernet receive queue deleted successfully.
 647  *   - <0: Error code returned by the driver function.
 648  *
 649  */
 650 typedef int (*eventdev_eth_rx_adapter_queue_del_t)
 651                                         (const struct rte_eventdev *dev,
 652                                         const struct rte_eth_dev *eth_dev,
 653                                         int32_t rx_queue_id);
 654
 655 /**
 656  * Retrieve Rx adapter queue config information for the specified
 657  * rx queue ID.
 658  *
 659  * @param dev
 660  *  Event device pointer
 661  *
 662  * @param eth_dev
 663  *  Ethernet device pointer
 664  *
 665  * @param rx_queue_id
 666  *  Ethernet device receive queue index.
 667  *
 668  * @param[out] queue_conf
 669  *  Pointer to rte_event_eth_rx_adapter_queue_conf structure
 670  *
 671  * @return
 672  *  - 0: Success
 673  *  - <0: Error code on failure.
 674  */
 675 typedef int (*eventdev_eth_rx_adapter_queue_conf_get_t)
 676                         (const struct rte_eventdev *dev,
 677                         const struct rte_eth_dev *eth_dev,
 678                         uint16_t rx_queue_id,
 679                         struct rte_event_eth_rx_adapter_queue_conf *queue_conf);
 680
 681 /**
 682  * Start ethernet Rx adapter. This callback is invoked if
 683  * the caps returned from eventdev_eth_rx_adapter_caps_get(.., eth_port_id)
 684  * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set and Rx queues
 685  * from eth_port_id have been added to the event device.
 686  *
 687  * @param dev
 688  *   Event device pointer
 689  *
 690  * @param eth_dev
 691  *   Ethernet device pointer
 692  *
 693  * @return
 694  *   - 0: Success, ethernet Rx adapter started successfully.
 695  *   - <0: Error code returned by the driver function.
 696  */
 697 typedef int (*eventdev_eth_rx_adapter_start_t)
 698                                         (const struct rte_eventdev *dev,
 699                                         const struct rte_eth_dev *eth_dev);
 700
 701 /**
 702  * Stop ethernet Rx adapter. This callback is invoked if
 703  * the caps returned from eventdev_eth_rx_adapter_caps_get(..,eth_port_id)
 704  * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set and Rx queues
 705  * from eth_port_id have been added to the event device.
 706  *
 707  * @param dev
 708  *   Event device pointer
 709  *
 710  * @param eth_dev
 711  *   Ethernet device pointer
 712  *
 713  * @return
 714  *   - 0: Success, ethernet Rx adapter stopped successfully.
 715  *   - <0: Error code returned by the driver function.
 716  */
 717 typedef int (*eventdev_eth_rx_adapter_stop_t)
 718                                         (const struct rte_eventdev *dev,
 719                                         const struct rte_eth_dev *eth_dev);
 720
 721 struct rte_event_eth_rx_adapter_stats;
 722
 723 /**
 724  * Retrieve ethernet Rx adapter statistics.
 725  *
 726  * @param dev
 727  *   Event device pointer
 728  *
 729  * @param eth_dev
 730  *   Ethernet device pointer
 731  *
 732  * @param[out] stats
 733  *   Pointer to stats structure
 734  *
 735  * @return
 736  *   Return 0 on success.
 737  */
 738
 739 typedef int (*eventdev_eth_rx_adapter_stats_get)
 740                         (const struct rte_eventdev *dev,
 741                         const struct rte_eth_dev *eth_dev,
 742                         struct rte_event_eth_rx_adapter_stats *stats);
 743 /**
 744  * Reset ethernet Rx adapter statistics.
 745  *
 746  * @param dev
 747  *   Event device pointer
 748  *
 749  * @param eth_dev
 750  *   Ethernet device pointer
 751  *
 752  * @return
 753  *   Return 0 on success.
 754  */
 755 typedef int (*eventdev_eth_rx_adapter_stats_reset)
 756                         (const struct rte_eventdev *dev,
 757                         const struct rte_eth_dev *eth_dev);
 758
 759 struct rte_event_eth_rx_adapter_queue_stats;
 760
 761 /**
 762  * Retrieve ethernet Rx adapter queue statistics.
 763  *
 764  * @param dev
 765  *   Event device pointer
 766  *
 767  * @param eth_dev
 768  *   Ethernet device pointer
 769  *
 770  * @param rx_queue_id
 771  *  Ethernet device receive queue index.
 772  *
 773  * @param[out] q_stats
 774  *   Pointer to queue stats structure
 775  *
 776  * @return
 777  *   Return 0 on success.
 778  */
 779 typedef int (*eventdev_eth_rx_adapter_q_stats_get)
 780                         (const struct rte_eventdev *dev,
 781                          const struct rte_eth_dev *eth_dev,
 782                          uint16_t rx_queue_id,
 783                          struct rte_event_eth_rx_adapter_queue_stats *q_stats);
 784
 785 /**
 786  * Reset ethernet Rx adapter queue statistics.
 787  *
 788  * @param dev
 789  *   Event device pointer
 790  *
 791  * @param eth_dev
 792  *   Ethernet device pointer
 793  *
 794  * @param rx_queue_id
 795  *  Ethernet device receive queue index.
 796  *
 797  * @return
 798  *   Return 0 on success.
 799  */
 800 typedef int (*eventdev_eth_rx_adapter_q_stats_reset)
 801                         (const struct rte_eventdev *dev,
 802                          const struct rte_eth_dev *eth_dev,
 803                          uint16_t rx_queue_id);
 804
 805 /**
 806  * Start eventdev selftest.
 807  *
 808  * @return
 809  *   Return 0 on success.
 810  */
 811 typedef int (*eventdev_selftest)(void);
 812
 813 struct rte_event_eth_rx_adapter_vector_limits;
 814 /**
 815  * Get event vector limits for a given event, ethernet device pair.
 816  *
 817  * @param dev
 818  *   Event device pointer
 819  *
 820  * @param eth_dev
 821  *   Ethernet device pointer
 822  *
 823  * @param[out] limits
 824  *   Pointer to the limits structure to be filled.
 825  *
 826  * @return
 827  *   - 0: Success.
 828  *   - <0: Error code returned by the driver function.
 829  */
 830 typedef int (*eventdev_eth_rx_adapter_vector_limits_get_t)(
 831         const struct rte_eventdev *dev, const struct rte_eth_dev *eth_dev,
 832         struct rte_event_eth_rx_adapter_vector_limits *limits);
 833
 834 typedef uint32_t rte_event_pmd_selftest_seqn_t;
 835 extern int rte_event_pmd_selftest_seqn_dynfield_offset;
 836
 837 /**
 838  * Read test sequence number from mbuf.
 839  *
 840  * @param mbuf Structure to read from.
 841  * @return pointer to test sequence number.
 842  */
 843 __rte_internal
 844 static inline rte_event_pmd_selftest_seqn_t *
 845 rte_event_pmd_selftest_seqn(struct rte_mbuf *mbuf)
 846 {
 847         return RTE_MBUF_DYNFIELD(mbuf,
 848                 rte_event_pmd_selftest_seqn_dynfield_offset,
 849                 rte_event_pmd_selftest_seqn_t *);
 850 }
 851
 852 struct rte_cryptodev;
 853
 854 /**
 855  * This API may change without prior notice
 856  *
 857  * Retrieve the event device's crypto adapter capabilities for the
 858  * specified cryptodev
 859  *
 860  * @param dev
 861  *   Event device pointer
 862  *
 863  * @param cdev
 864  *   cryptodev pointer
 865  *
 866  * @param[out] caps
 867  *   A pointer to memory filled with event adapter capabilities.
 868  *   It is expected to be pre-allocated & initialized by caller.
 869  *
 870  * @return
 871  *   - 0: Success, driver provides event adapter capabilities for the
 872  *      cryptodev.
 873  *   - <0: Error code returned by the driver function.
 874  *
 875  */
 876 typedef int (*eventdev_crypto_adapter_caps_get_t)
 877                                         (const struct rte_eventdev *dev,
 878                                          const struct rte_cryptodev *cdev,
 879                                          uint32_t *caps);
 880
 881 /**
 882  * This API may change without prior notice
 883  *
 884  * Add crypto queue pair to event device. This callback is invoked if
 885  * the caps returned from rte_event_crypto_adapter_caps_get(, cdev_id)
 886  * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set.
 887  *
 888  * @param dev
 889  *   Event device pointer
 890  *
 891  * @param cdev
 892  *   cryptodev pointer
 893  *
 894  * @param queue_pair_id
 895  *   cryptodev queue pair identifier.
 896  *
 897  * @param event
 898  *  Event information required for binding cryptodev queue pair to event queue.
 899  *  This structure will have a valid value for only those HW PMDs supporting
 900  *  @see RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND capability.
 901  *
 902  * @return
 903  *   - 0: Success, cryptodev queue pair added successfully.
 904  *   - <0: Error code returned by the driver function.
 905  *
 906  */
 907 typedef int (*eventdev_crypto_adapter_queue_pair_add_t)
 908                         (const struct rte_eventdev *dev,
 909                          const struct rte_cryptodev *cdev,
 910                          int32_t queue_pair_id,
 911                          const struct rte_event *event);
 912
 913
 914 /**
 915  * This API may change without prior notice
 916  *
 917  * Delete crypto queue pair to event device. This callback is invoked if
 918  * the caps returned from rte_event_crypto_adapter_caps_get(, cdev_id)
 919  * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set.
 920  *
 921  * @param dev
 922  *   Event device pointer
 923  *
 924  * @param cdev
 925  *   cryptodev pointer
 926  *
 927  * @param queue_pair_id
 928  *   cryptodev queue pair identifier.
 929  *
 930  * @return
 931  *   - 0: Success, cryptodev queue pair deleted successfully.
 932  *   - <0: Error code returned by the driver function.
 933  *
 934  */
 935 typedef int (*eventdev_crypto_adapter_queue_pair_del_t)
 936                                         (const struct rte_eventdev *dev,
 937                                          const struct rte_cryptodev *cdev,
 938                                          int32_t queue_pair_id);
 939
 940 /**
 941  * Start crypto adapter. 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 and queue pairs
 944  * from cdev_id have been added to the event device.
 945  *
 946  * @param dev
 947  *   Event device pointer
 948  *
 949  * @param cdev
 950  *   Crypto device pointer
 951  *
 952  * @return
 953  *   - 0: Success, crypto adapter started successfully.
 954  *   - <0: Error code returned by the driver function.
 955  */
 956 typedef int (*eventdev_crypto_adapter_start_t)
 957                                         (const struct rte_eventdev *dev,
 958                                          const struct rte_cryptodev *cdev);
 959
 960 /**
 961  * Stop crypto adapter. This callback is invoked if
 962  * the caps returned from rte_event_crypto_adapter_caps_get(.., cdev_id)
 963  * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set and queue pairs
 964  * from cdev_id have been added to the event device.
 965  *
 966  * @param dev
 967  *   Event device pointer
 968  *
 969  * @param cdev
 970  *   Crypto device pointer
 971  *
 972  * @return
 973  *   - 0: Success, crypto adapter stopped successfully.
 974  *   - <0: Error code returned by the driver function.
 975  */
 976 typedef int (*eventdev_crypto_adapter_stop_t)
 977                                         (const struct rte_eventdev *dev,
 978                                          const struct rte_cryptodev *cdev);
 979
 980 struct rte_event_crypto_adapter_stats;
 981
 982 /**
 983  * Retrieve crypto adapter statistics.
 984  *
 985  * @param dev
 986  *   Event device pointer
 987  *
 988  * @param cdev
 989  *   Crypto device pointer
 990  *
 991  * @param[out] stats
 992  *   Pointer to stats structure
 993  *
 994  * @return
 995  *   Return 0 on success.
 996  */
 997
 998 typedef int (*eventdev_crypto_adapter_stats_get)
 999                         (const struct rte_eventdev *dev,
1000                          const struct rte_cryptodev *cdev,
1001                          struct rte_event_crypto_adapter_stats *stats);
1002
1003 /**
1004  * Reset crypto adapter statistics.
1005  *
1006  * @param dev
1007  *   Event device pointer
1008  *
1009  * @param cdev
1010  *   Crypto device pointer
1011  *
1012  * @return
1013  *   Return 0 on success.
1014  */
1015
1016 typedef int (*eventdev_crypto_adapter_stats_reset)
1017                         (const struct rte_eventdev *dev,
1018                          const struct rte_cryptodev *cdev);
1019
1020 /**
1021  * Retrieve the event device's eth Tx adapter capabilities.
1022  *
1023  * @param dev
1024  *   Event device pointer
1025  *
1026  * @param eth_dev
1027  *   Ethernet device pointer
1028  *
1029  * @param[out] caps
1030  *   A pointer to memory filled with eth Tx adapter capabilities.
1031  *
1032  * @return
1033  *   - 0: Success, driver provides eth Tx adapter capabilities
1034  *   - <0: Error code returned by the driver function.
1035  *
1036  */
1037 typedef int (*eventdev_eth_tx_adapter_caps_get_t)
1038                                         (const struct rte_eventdev *dev,
1039                                         const struct rte_eth_dev *eth_dev,
1040                                         uint32_t *caps);
1041
1042 /**
1043  * Create adapter callback.
1044  *
1045  * @param id
1046  *   Adapter identifier
1047  *
1048  * @param dev
1049  *   Event device pointer
1050  *
1051  * @return
1052  *   - 0: Success.
1053  *   - <0: Error code on failure.
1054  */
1055 typedef int (*eventdev_eth_tx_adapter_create_t)(uint8_t id,
1056                                         const struct rte_eventdev *dev);
1057
1058 /**
1059  * Free adapter callback.
1060  *
1061  * @param id
1062  *   Adapter identifier
1063  *
1064  * @param dev
1065  *   Event device pointer
1066  *
1067  * @return
1068  *   - 0: Success.
1069  *   - <0: Error code on failure.
1070  */
1071 typedef int (*eventdev_eth_tx_adapter_free_t)(uint8_t id,
1072                                         const struct rte_eventdev *dev);
1073
1074 /**
1075  * Add a Tx queue to the adapter.
1076  * A queue value of -1 is used to indicate all
1077  * queues within the device.
1078  *
1079  * @param id
1080  *   Adapter identifier
1081  *
1082  * @param dev
1083  *   Event device pointer
1084  *
1085  * @param eth_dev
1086  *   Ethernet device pointer
1087  *
1088  * @param tx_queue_id
1089  *   Transmit queue index
1090  *
1091  * @return
1092  *   - 0: Success.
1093  *   - <0: Error code on failure.
1094  */
1095 typedef int (*eventdev_eth_tx_adapter_queue_add_t)(
1096                                         uint8_t id,
1097                                         const struct rte_eventdev *dev,
1098                                         const struct rte_eth_dev *eth_dev,
1099                                         int32_t tx_queue_id);
1100
1101 /**
1102  * Delete a Tx queue from the adapter.
1103  * A queue value of -1 is used to indicate all
1104  * queues within the device, that have been added to this
1105  * adapter.
1106  *
1107  * @param id
1108  *   Adapter identifier
1109  *
1110  * @param dev
1111  *   Event device pointer
1112  *
1113  * @param eth_dev
1114  *   Ethernet device pointer
1115  *
1116  * @param tx_queue_id
1117  *   Transmit queue index
1118  *
1119  * @return
1120  *  - 0: Success, Queues deleted successfully.
1121  *  - <0: Error code on failure.
1122  */
1123 typedef int (*eventdev_eth_tx_adapter_queue_del_t)(
1124                                         uint8_t id,
1125                                         const struct rte_eventdev *dev,
1126                                         const struct rte_eth_dev *eth_dev,
1127                                         int32_t tx_queue_id);
1128
1129 /**
1130  * Start the adapter.
1131  *
1132  * @param id
1133  *   Adapter identifier
1134  *
1135  * @param dev
1136  *   Event device pointer
1137  *
1138  * @return
1139  *  - 0: Success, Adapter started correctly.
1140  *  - <0: Error code on failure.
1141  */
1142 typedef int (*eventdev_eth_tx_adapter_start_t)(uint8_t id,
1143                                         const struct rte_eventdev *dev);
1144
1145 /**
1146  * Stop the adapter.
1147  *
1148  * @param id
1149  *  Adapter identifier
1150  *
1151  * @param dev
1152  *   Event device pointer
1153  *
1154  * @return
1155  *  - 0: Success.
1156  *  - <0: Error code on failure.
1157  */
1158 typedef int (*eventdev_eth_tx_adapter_stop_t)(uint8_t id,
1159                                         const struct rte_eventdev *dev);
1160
1161 struct rte_event_eth_tx_adapter_stats;
1162
1163 /**
1164  * Retrieve statistics for an adapter
1165  *
1166  * @param id
1167  *  Adapter identifier
1168  *
1169  * @param dev
1170  *   Event device pointer
1171  *
1172  * @param [out] stats
1173  *  A pointer to structure used to retrieve statistics for an adapter
1174  *
1175  * @return
1176  *  - 0: Success, statistics retrieved successfully.
1177  *  - <0: Error code on failure.
1178  */
1179 typedef int (*eventdev_eth_tx_adapter_stats_get_t)(
1180                                 uint8_t id,
1181                                 const struct rte_eventdev *dev,
1182                                 struct rte_event_eth_tx_adapter_stats *stats);
1183
1184 /**
1185  * Reset statistics for an adapter
1186  *
1187  * @param id
1188  *  Adapter identifier
1189  *
1190  * @param dev
1191  *   Event device pointer
1192  *
1193  * @return
1194  *  - 0: Success, statistics retrieved successfully.
1195  *  - <0: Error code on failure.
1196  */
1197 typedef int (*eventdev_eth_tx_adapter_stats_reset_t)(uint8_t id,
1198                                         const struct rte_eventdev *dev);
1199
1200 /** Event device operations function pointer table */
1201 struct eventdev_ops {
1202         eventdev_info_get_t dev_infos_get;      /**< Get device info. */
1203         eventdev_configure_t dev_configure;     /**< Configure device. */
1204         eventdev_start_t dev_start;             /**< Start device. */
1205         eventdev_stop_t dev_stop;               /**< Stop device. */
1206         eventdev_close_t dev_close;             /**< Close device. */
1207
1208         eventdev_queue_default_conf_get_t queue_def_conf;
1209         /**< Get default queue configuration. */
1210         eventdev_queue_setup_t queue_setup;
1211         /**< Set up an event queue. */
1212         eventdev_queue_release_t queue_release;
1213         /**< Release an event queue. */
1214
1215         eventdev_port_default_conf_get_t port_def_conf;
1216         /**< Get default port configuration. */
1217         eventdev_port_setup_t port_setup;
1218         /**< Set up an event port. */
1219         eventdev_port_release_t port_release;
1220         /**< Release an event port. */
1221
1222         eventdev_port_link_t port_link;
1223         /**< Link event queues to an event port. */
1224         eventdev_port_unlink_t port_unlink;
1225         /**< Unlink event queues from an event port. */
1226         eventdev_port_unlinks_in_progress_t port_unlinks_in_progress;
1227         /**< Unlinks in progress on an event port. */
1228         eventdev_dequeue_timeout_ticks_t timeout_ticks;
1229         /**< Converts ns to *timeout_ticks* value for rte_event_dequeue() */
1230         eventdev_dump_t dump;
1231         /* Dump internal information */
1232
1233         eventdev_xstats_get_t xstats_get;
1234         /**< Get extended device statistics. */
1235         eventdev_xstats_get_names_t xstats_get_names;
1236         /**< Get names of extended stats. */
1237         eventdev_xstats_get_by_name xstats_get_by_name;
1238         /**< Get one value by name. */
1239         eventdev_xstats_reset_t xstats_reset;
1240         /**< Reset the statistics values in xstats. */
1241
1242         eventdev_eth_rx_adapter_caps_get_t eth_rx_adapter_caps_get;
1243         /**< Get ethernet Rx adapter capabilities */
1244         eventdev_eth_rx_adapter_queue_add_t eth_rx_adapter_queue_add;
1245         /**< Add Rx queues to ethernet Rx adapter */
1246         eventdev_eth_rx_adapter_queue_del_t eth_rx_adapter_queue_del;
1247         /**< Delete Rx queues from ethernet Rx adapter */
1248         eventdev_eth_rx_adapter_queue_conf_get_t eth_rx_adapter_queue_conf_get;
1249         /**< Get Rx adapter queue info */
1250         eventdev_eth_rx_adapter_start_t eth_rx_adapter_start;
1251         /**< Start ethernet Rx adapter */
1252         eventdev_eth_rx_adapter_stop_t eth_rx_adapter_stop;
1253         /**< Stop ethernet Rx adapter */
1254         eventdev_eth_rx_adapter_stats_get eth_rx_adapter_stats_get;
1255         /**< Get ethernet Rx stats */
1256         eventdev_eth_rx_adapter_stats_reset eth_rx_adapter_stats_reset;
1257         /**< Reset ethernet Rx stats */
1258         eventdev_eth_rx_adapter_vector_limits_get_t
1259                 eth_rx_adapter_vector_limits_get;
1260         /**< Get event vector limits for the Rx adapter */
1261
1262         eventdev_timer_adapter_caps_get_t timer_adapter_caps_get;
1263         /**< Get timer adapter capabilities */
1264
1265         eventdev_crypto_adapter_caps_get_t crypto_adapter_caps_get;
1266         /**< Get crypto adapter capabilities */
1267         eventdev_crypto_adapter_queue_pair_add_t crypto_adapter_queue_pair_add;
1268         /**< Add queue pair to crypto adapter */
1269         eventdev_crypto_adapter_queue_pair_del_t crypto_adapter_queue_pair_del;
1270         /**< Delete queue pair from crypto adapter */
1271         eventdev_crypto_adapter_start_t crypto_adapter_start;
1272         /**< Start crypto adapter */
1273         eventdev_crypto_adapter_stop_t crypto_adapter_stop;
1274         /**< Stop crypto adapter */
1275         eventdev_crypto_adapter_stats_get crypto_adapter_stats_get;
1276         /**< Get crypto stats */
1277         eventdev_crypto_adapter_stats_reset crypto_adapter_stats_reset;
1278         /**< Reset crypto stats */
1279
1280         eventdev_eth_rx_adapter_q_stats_get eth_rx_adapter_queue_stats_get;
1281         /**< Get ethernet Rx queue stats */
1282         eventdev_eth_rx_adapter_q_stats_reset eth_rx_adapter_queue_stats_reset;
1283         /**< Reset ethernet Rx queue stats */
1284
1285         eventdev_eth_tx_adapter_caps_get_t eth_tx_adapter_caps_get;
1286         /**< Get ethernet Tx adapter capabilities */
1287
1288         eventdev_eth_tx_adapter_create_t eth_tx_adapter_create;
1289         /**< Create adapter callback */
1290         eventdev_eth_tx_adapter_free_t eth_tx_adapter_free;
1291         /**< Free adapter callback */
1292         eventdev_eth_tx_adapter_queue_add_t eth_tx_adapter_queue_add;
1293         /**< Add Tx queues to the eth Tx adapter */
1294         eventdev_eth_tx_adapter_queue_del_t eth_tx_adapter_queue_del;
1295         /**< Delete Tx queues from the eth Tx adapter */
1296         eventdev_eth_tx_adapter_start_t eth_tx_adapter_start;
1297         /**< Start eth Tx adapter */
1298         eventdev_eth_tx_adapter_stop_t eth_tx_adapter_stop;
1299         /**< Stop eth Tx adapter */
1300         eventdev_eth_tx_adapter_stats_get_t eth_tx_adapter_stats_get;
1301         /**< Get eth Tx adapter statistics */
1302         eventdev_eth_tx_adapter_stats_reset_t eth_tx_adapter_stats_reset;
1303         /**< Reset eth Tx adapter statistics */
1304
1305         eventdev_selftest dev_selftest;
1306         /**< Start eventdev Selftest */
1307
1308         eventdev_stop_flush_t dev_stop_flush;
1309         /**< User-provided event flush function */
1310 };
1311
1312 /**
1313  * Allocates a new eventdev slot for an event device and returns the pointer
1314  * to that slot for the driver to use.
1315  *
1316  * @param name
1317  *   Unique identifier name for each device
1318  * @param socket_id
1319  *   Socket to allocate resources on.
1320  * @return
1321  *   - Slot in the rte_dev_devices array for a new device;
1322  */
1323 __rte_internal
1324 struct rte_eventdev *
1325 rte_event_pmd_allocate(const char *name, int socket_id);
1326
1327 /**
1328  * Release the specified eventdev device.
1329  *
1330  * @param eventdev
1331  * The *eventdev* pointer is the address of the *rte_eventdev* structure.
1332  * @return
1333  *   - 0 on success, negative on error
1334  */
1335 __rte_internal
1336 int
1337 rte_event_pmd_release(struct rte_eventdev *eventdev);
1338
1339 /**
1340  *
1341  * @internal
1342  * This is the last step of device probing.
1343  * It must be called after a port is allocated and initialized successfully.
1344  *
1345  * @param eventdev
1346  *  New event device.
1347  */
1348 __rte_internal
1349 void
1350 event_dev_probing_finish(struct rte_eventdev *eventdev);
1351
1352 /**
1353  * Reset eventdevice fastpath APIs to dummy values.
1354  *
1355  * @param fp_ops
1356  * The *fp_ops* pointer to reset.
1357  */
1358 __rte_internal
1359 void
1360 event_dev_fp_ops_reset(struct rte_event_fp_ops *fp_op);
1361
1362 /**
1363  * Set eventdevice fastpath APIs to event device values.
1364  *
1365  * @param fp_ops
1366  * The *fp_ops* pointer to set.
1367  */
1368 __rte_internal
1369 void
1370 event_dev_fp_ops_set(struct rte_event_fp_ops *fp_ops,
1371                      const struct rte_eventdev *dev);
1372
1373 #ifdef __cplusplus
1374 }
1375 #endif
1376
1377 #endif /* _RTE_EVENTDEV_PMD_H_ */