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