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