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