lib/librte_eventdev/rte_eventdev_pmd.h

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