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