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