LCOV - code coverage report
Current view: top level - lib/eventdev - eventdev_pmd.h (source / functions) Hit Total Coverage
Test: Code coverage Lines: 11 11 100.0 %
Date: 2024-02-14 00:53:57 Functions: 1 1 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 67 184 36.4 %

           Branch data     Line data    Source code
       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                 :            : #ifdef __cplusplus
       9                 :            : extern "C" {
      10                 :            : #endif
      11                 :            : 
      12                 :            : /** @file
      13                 :            :  * RTE Event PMD APIs
      14                 :            :  *
      15                 :            :  * @note
      16                 :            :  * These API are from event PMD only and user applications should not call
      17                 :            :  * them directly.
      18                 :            :  */
      19                 :            : 
      20                 :            : #include <string.h>
      21                 :            : 
      22                 :            : #include <rte_common.h>
      23                 :            : #include <rte_compat.h>
      24                 :            : #include <rte_config.h>
      25                 :            : #include <dev_driver.h>
      26                 :            : #include <rte_log.h>
      27                 :            : #include <rte_malloc.h>
      28                 :            : #include <rte_mbuf.h>
      29                 :            : #include <rte_mbuf_dyn.h>
      30                 :            : 
      31                 :            : #include "event_timer_adapter_pmd.h"
      32                 :            : #include "rte_eventdev.h"
      33                 :            : 
      34                 :            : extern int rte_event_logtype;
      35                 :            : #define RTE_LOGTYPE_EVENTDEV rte_event_logtype
      36                 :            : 
      37                 :            : /* Logging Macros */
      38                 :            : #define RTE_EDEV_LOG_ERR(...) \
      39                 :            :         RTE_LOG_LINE(ERR, EVENTDEV, \
      40                 :            :                 RTE_FMT("%s() line %u: " RTE_FMT_HEAD(__VA_ARGS__ ,), \
      41                 :            :                         __func__, __LINE__, RTE_FMT_TAIL(__VA_ARGS__ ,)))
      42                 :            : 
      43                 :            : #ifdef RTE_LIBRTE_EVENTDEV_DEBUG
      44                 :            : #define RTE_EDEV_LOG_DEBUG(...) \
      45                 :            :         RTE_LOG_LINE(DEBUG, EVENTDEV, \
      46                 :            :                 RTE_FMT("%s() line %u: " RTE_FMT_HEAD(__VA_ARGS__ ,), \
      47                 :            :                         __func__, __LINE__, RTE_FMT_TAIL(__VA_ARGS__ ,)))
      48                 :            : #else
      49                 :            : #define RTE_EDEV_LOG_DEBUG(...) (void)0
      50                 :            : #endif
      51                 :            : 
      52                 :            : /* Macros to check for valid device */
      53                 :            : #define RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, retval) do { \
      54                 :            :         if (!rte_event_pmd_is_valid_dev((dev_id))) { \
      55                 :            :                 RTE_EDEV_LOG_ERR("Invalid dev_id=%d", dev_id); \
      56                 :            :                 return retval; \
      57                 :            :         } \
      58                 :            : } while (0)
      59                 :            : 
      60                 :            : #define RTE_EVENTDEV_VALID_DEVID_OR_ERRNO_RET(dev_id, errno, retval) do { \
      61                 :            :         if (!rte_event_pmd_is_valid_dev((dev_id))) { \
      62                 :            :                 RTE_EDEV_LOG_ERR("Invalid dev_id=%d", dev_id); \
      63                 :            :                 rte_errno = errno; \
      64                 :            :                 return retval; \
      65                 :            :         } \
      66                 :            : } while (0)
      67                 :            : 
      68                 :            : #define RTE_EVENTDEV_VALID_DEVID_OR_RET(dev_id) do { \
      69                 :            :         if (!rte_event_pmd_is_valid_dev((dev_id))) { \
      70                 :            :                 RTE_EDEV_LOG_ERR("Invalid dev_id=%d", dev_id); \
      71                 :            :                 return; \
      72                 :            :         } \
      73                 :            : } while (0)
      74                 :            : 
      75                 :            : #define RTE_EVENT_ETH_RX_ADAPTER_SW_CAP                                        \
      76                 :            :         ((RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) |                     \
      77                 :            :          (RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) |                         \
      78                 :            :          (RTE_EVENT_ETH_RX_ADAPTER_CAP_EVENT_VECTOR))
      79                 :            : 
      80                 :            : #define RTE_EVENT_CRYPTO_ADAPTER_SW_CAP \
      81                 :            :                 RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA
      82                 :            : 
      83                 :            : /**< Ethernet Rx adapter cap to return If the packet transfers from
      84                 :            :  * the ethdev to eventdev use a SW service function
      85                 :            :  */
      86                 :            : 
      87                 :            : #define RTE_EVENT_TIMER_ADAPTER_SW_CAP \
      88                 :            :                 RTE_EVENT_TIMER_ADAPTER_CAP_PERIODIC
      89                 :            : 
      90                 :            : #define RTE_EVENTDEV_DETACHED  (0)
      91                 :            : #define RTE_EVENTDEV_ATTACHED  (1)
      92                 :            : 
      93                 :            : #define RTE_EVENTDEV_NAME_MAX_LEN (64)
      94                 :            : /**< @internal Max length of name of event PMD */
      95                 :            : 
      96                 :            : struct rte_eth_dev;
      97                 :            : 
      98                 :            : /** Global structure used for maintaining state of allocated event devices */
      99                 :            : struct rte_eventdev_global {
     100                 :            :         uint8_t nb_devs;        /**< Number of devices found */
     101                 :            : };
     102                 :            : 
     103                 :            : /**
     104                 :            :  * @internal
     105                 :            :  * The data part, with no function pointers, associated with each device.
     106                 :            :  *
     107                 :            :  * This structure is safe to place in shared memory to be common among
     108                 :            :  * different processes in a multi-process configuration.
     109                 :            :  */
     110                 :            : struct rte_eventdev_data {
     111                 :            :         int socket_id;
     112                 :            :         /**< Socket ID where memory is allocated */
     113                 :            :         uint8_t dev_id;
     114                 :            :         /**< Device ID for this instance */
     115                 :            :         uint8_t nb_queues;
     116                 :            :         /**< Number of event queues. */
     117                 :            :         uint8_t nb_ports;
     118                 :            :         /**< Number of event ports. */
     119                 :            :         void *ports[RTE_EVENT_MAX_PORTS_PER_DEV];
     120                 :            :         /**< Array of pointers to ports. */
     121                 :            :         struct rte_event_port_conf ports_cfg[RTE_EVENT_MAX_PORTS_PER_DEV];
     122                 :            :         /**< Array of port configuration structures. */
     123                 :            :         struct rte_event_queue_conf queues_cfg[RTE_EVENT_MAX_QUEUES_PER_DEV];
     124                 :            :         /**< Array of queue configuration structures. */
     125                 :            :         uint16_t links_map[RTE_EVENT_MAX_PROFILES_PER_PORT]
     126                 :            :                           [RTE_EVENT_MAX_PORTS_PER_DEV * RTE_EVENT_MAX_QUEUES_PER_DEV];
     127                 :            :         /**< Memory to store queues to port connections. */
     128                 :            :         void *dev_private;
     129                 :            :         /**< PMD-specific private data */
     130                 :            :         uint32_t event_dev_cap;
     131                 :            :         /**< Event device capabilities(RTE_EVENT_DEV_CAP_)*/
     132                 :            :         struct rte_event_dev_config dev_conf;
     133                 :            :         /**< Configuration applied to device. */
     134                 :            :         uint8_t service_inited;
     135                 :            :         /* Service initialization state */
     136                 :            :         uint32_t service_id;
     137                 :            :         /* Service ID*/
     138                 :            :         void *dev_stop_flush_arg;
     139                 :            :         /**< User-provided argument for event flush function */
     140                 :            : 
     141                 :            :         uint8_t dev_started : 1;
     142                 :            :         /**< Device state: STARTED(1)/STOPPED(0) */
     143                 :            : 
     144                 :            :         char name[RTE_EVENTDEV_NAME_MAX_LEN];
     145                 :            :         /**< Unique identifier name */
     146                 :            : 
     147                 :            :         uint64_t reserved_64s[4]; /**< Reserved for future fields */
     148                 :            :         void *reserved_ptrs[4];   /**< Reserved for future fields */
     149                 :            : } __rte_cache_aligned;
     150                 :            : 
     151                 :            : /** @internal The data structure associated with each event device. */
     152                 :            : struct rte_eventdev {
     153                 :            :         struct rte_eventdev_data *data;
     154                 :            :         /**< Pointer to device data */
     155                 :            :         struct eventdev_ops *dev_ops;
     156                 :            :         /**< Functions exported by PMD */
     157                 :            :         struct rte_device *dev;
     158                 :            :         /**< Device info. supplied by probing */
     159                 :            : 
     160                 :            :         uint8_t attached : 1;
     161                 :            :         /**< Flag indicating the device is attached */
     162                 :            : 
     163                 :            :         event_enqueue_t enqueue;
     164                 :            :         /**< Pointer to PMD enqueue function. */
     165                 :            :         event_enqueue_burst_t enqueue_burst;
     166                 :            :         /**< Pointer to PMD enqueue burst function. */
     167                 :            :         event_enqueue_burst_t enqueue_new_burst;
     168                 :            :         /**< Pointer to PMD enqueue burst function(op new variant) */
     169                 :            :         event_enqueue_burst_t enqueue_forward_burst;
     170                 :            :         /**< Pointer to PMD enqueue burst function(op forward variant) */
     171                 :            :         event_dequeue_t dequeue;
     172                 :            :         /**< Pointer to PMD dequeue function. */
     173                 :            :         event_dequeue_burst_t dequeue_burst;
     174                 :            :         /**< Pointer to PMD dequeue burst function. */
     175                 :            :         event_maintain_t maintain;
     176                 :            :         /**< Pointer to PMD port maintenance function. */
     177                 :            :         event_tx_adapter_enqueue_t txa_enqueue_same_dest;
     178                 :            :         /**< Pointer to PMD eth Tx adapter burst enqueue function with
     179                 :            :          * events destined to same Eth port & Tx queue.
     180                 :            :          */
     181                 :            :         event_tx_adapter_enqueue_t txa_enqueue;
     182                 :            :         /**< Pointer to PMD eth Tx adapter enqueue function. */
     183                 :            :         event_crypto_adapter_enqueue_t ca_enqueue;
     184                 :            :         /**< Pointer to PMD crypto adapter enqueue function. */
     185                 :            :         event_dma_adapter_enqueue_t dma_enqueue;
     186                 :            :         /**< Pointer to PMD DMA adapter enqueue function. */
     187                 :            :         event_profile_switch_t profile_switch;
     188                 :            :         /**< Pointer to PMD Event switch profile function. */
     189                 :            : 
     190                 :            :         uint64_t reserved_64s[3]; /**< Reserved for future fields */
     191                 :            :         void *reserved_ptrs[3];   /**< Reserved for future fields */
     192                 :            : } __rte_cache_aligned;
     193                 :            : 
     194                 :            : extern struct rte_eventdev *rte_eventdevs;
     195                 :            : /** @internal The pool of rte_eventdev structures. */
     196                 :            : 
     197                 :            : /**
     198                 :            :  * Get the rte_eventdev structure device pointer for the named device.
     199                 :            :  *
     200                 :            :  * @param name
     201                 :            :  *   device name to select the device structure.
     202                 :            :  *
     203                 :            :  * @return
     204                 :            :  *   - The rte_eventdev structure pointer for the given device ID.
     205                 :            :  */
     206                 :            : __rte_internal
     207                 :            : static inline struct rte_eventdev *
     208                 :          8 : rte_event_pmd_get_named_dev(const char *name)
     209                 :            : {
     210                 :            :         struct rte_eventdev *dev;
     211                 :            :         unsigned int i;
     212                 :            : 
     213         [ +  - ]:          8 :         if (name == NULL)
     214                 :            :                 return NULL;
     215                 :            : 
     216         [ +  + ]:         72 :         for (i = 0; i < RTE_EVENT_MAX_DEVS; i++) {
     217                 :         68 :                 dev = &rte_eventdevs[i];
     218         [ +  + ]:         68 :                 if ((dev->attached == RTE_EVENTDEV_ATTACHED) &&
     219         [ +  - ]:          4 :                                 (strcmp(dev->data->name, name) == 0))
     220                 :          4 :                         return dev;
     221                 :            :         }
     222                 :            : 
     223                 :            :         return NULL;
     224                 :            : }
     225                 :            : 
     226                 :            : /**
     227                 :            :  * Validate if the event device index is valid attached event device.
     228                 :            :  *
     229                 :            :  * @param dev_id
     230                 :            :  *   Event device index.
     231                 :            :  *
     232                 :            :  * @return
     233                 :            :  *   - If the device index is valid (1) or not (0).
     234                 :            :  */
     235                 :            : __rte_internal
     236                 :            : static inline unsigned
     237                 :            : rte_event_pmd_is_valid_dev(uint8_t dev_id)
     238                 :            : {
     239                 :            :         struct rte_eventdev *dev;
     240                 :            : 
     241   [ -  -  +  -  :       6280 :         if (dev_id >= RTE_EVENT_MAX_DEVS)
          -  -  -  -  -  
          -  -  -  -  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  -  -  
          +  -  +  -  +  
          -  +  -  -  -  
          +  -  +  -  +  
          -  -  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          -  -  -  -  -  
          -  +  -  +  +  
          -  -  +  -  +  
                -  -  - ]
     242                 :            :                 return 0;
     243                 :            : 
     244                 :       6279 :         dev = &rte_eventdevs[dev_id];
     245   [ -  -  +  -  :       6279 :         if (dev->attached != RTE_EVENTDEV_ATTACHED)
          -  -  -  -  -  
          -  -  -  -  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  -  -  
          +  -  +  -  +  
          -  +  -  -  -  
          +  -  +  -  +  
          -  -  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          -  -  -  -  -  
          -  +  -  +  -  
          -  -  +  -  +  
                -  -  - ]
     246                 :            :                 return 0;
     247                 :            :         else
     248                 :            :                 return 1;
     249                 :            : }
     250                 :            : 
     251                 :            : /**
     252                 :            :  * Definitions of all functions exported by a driver through the
     253                 :            :  * generic structure of type *event_dev_ops* supplied in the
     254                 :            :  * *rte_eventdev* structure associated with a device.
     255                 :            :  */
     256                 :            : 
     257                 :            : /**
     258                 :            :  * Get device information of a device.
     259                 :            :  *
     260                 :            :  * @param dev
     261                 :            :  *   Event device pointer
     262                 :            :  * @param dev_info
     263                 :            :  *   Event device information structure
     264                 :            :  */
     265                 :            : typedef void (*eventdev_info_get_t)(struct rte_eventdev *dev,
     266                 :            :                 struct rte_event_dev_info *dev_info);
     267                 :            : 
     268                 :            : /**
     269                 :            :  * Configure a device.
     270                 :            :  *
     271                 :            :  * @param dev
     272                 :            :  *   Event device pointer
     273                 :            :  *
     274                 :            :  * @return
     275                 :            :  *   Returns 0 on success
     276                 :            :  */
     277                 :            : typedef int (*eventdev_configure_t)(const struct rte_eventdev *dev);
     278                 :            : 
     279                 :            : /**
     280                 :            :  * Start a configured device.
     281                 :            :  *
     282                 :            :  * @param dev
     283                 :            :  *   Event device pointer
     284                 :            :  *
     285                 :            :  * @return
     286                 :            :  *   Returns 0 on success
     287                 :            :  */
     288                 :            : typedef int (*eventdev_start_t)(struct rte_eventdev *dev);
     289                 :            : 
     290                 :            : /**
     291                 :            :  * Stop a configured device.
     292                 :            :  *
     293                 :            :  * @param dev
     294                 :            :  *   Event device pointer
     295                 :            :  */
     296                 :            : typedef void (*eventdev_stop_t)(struct rte_eventdev *dev);
     297                 :            : 
     298                 :            : /**
     299                 :            :  * Close a configured device.
     300                 :            :  *
     301                 :            :  * @param dev
     302                 :            :  *   Event device pointer
     303                 :            :  *
     304                 :            :  * @return
     305                 :            :  * - 0 on success
     306                 :            :  * - (-EAGAIN) if can't close as device is busy
     307                 :            :  */
     308                 :            : typedef int (*eventdev_close_t)(struct rte_eventdev *dev);
     309                 :            : 
     310                 :            : /**
     311                 :            :  * Retrieve the default event queue configuration.
     312                 :            :  *
     313                 :            :  * @param dev
     314                 :            :  *   Event device pointer
     315                 :            :  * @param queue_id
     316                 :            :  *   Event queue index
     317                 :            :  * @param[out] queue_conf
     318                 :            :  *   Event queue configuration structure
     319                 :            :  */
     320                 :            : typedef void (*eventdev_queue_default_conf_get_t)(struct rte_eventdev *dev,
     321                 :            :                 uint8_t queue_id, struct rte_event_queue_conf *queue_conf);
     322                 :            : 
     323                 :            : /**
     324                 :            :  * Setup an event queue.
     325                 :            :  *
     326                 :            :  * @param dev
     327                 :            :  *   Event device pointer
     328                 :            :  * @param queue_id
     329                 :            :  *   Event queue index
     330                 :            :  * @param queue_conf
     331                 :            :  *   Event queue configuration structure
     332                 :            :  *
     333                 :            :  * @return
     334                 :            :  *   Returns 0 on success.
     335                 :            :  */
     336                 :            : typedef int (*eventdev_queue_setup_t)(struct rte_eventdev *dev,
     337                 :            :                 uint8_t queue_id,
     338                 :            :                 const struct rte_event_queue_conf *queue_conf);
     339                 :            : 
     340                 :            : /**
     341                 :            :  * Release resources allocated by given event queue.
     342                 :            :  *
     343                 :            :  * @param dev
     344                 :            :  *   Event device pointer
     345                 :            :  * @param queue_id
     346                 :            :  *   Event queue index
     347                 :            :  */
     348                 :            : typedef void (*eventdev_queue_release_t)(struct rte_eventdev *dev,
     349                 :            :                 uint8_t queue_id);
     350                 :            : 
     351                 :            : /**
     352                 :            :  * Set an event queue attribute at runtime.
     353                 :            :  *
     354                 :            :  * @param dev
     355                 :            :  *   Event device pointer
     356                 :            :  * @param queue_id
     357                 :            :  *   Event queue index
     358                 :            :  * @param attr_id
     359                 :            :  *   Event queue attribute id
     360                 :            :  * @param attr_value
     361                 :            :  *   Event queue attribute value
     362                 :            :  *
     363                 :            :  * @return
     364                 :            :  *  - 0: Success.
     365                 :            :  *  - <0: Error code on failure.
     366                 :            :  */
     367                 :            : typedef int (*eventdev_queue_attr_set_t)(struct rte_eventdev *dev,
     368                 :            :                                          uint8_t queue_id, uint32_t attr_id,
     369                 :            :                                          uint64_t attr_value);
     370                 :            : 
     371                 :            : /**
     372                 :            :  * Retrieve the default event port configuration.
     373                 :            :  *
     374                 :            :  * @param dev
     375                 :            :  *   Event device pointer
     376                 :            :  * @param port_id
     377                 :            :  *   Event port index
     378                 :            :  * @param[out] port_conf
     379                 :            :  *   Event port configuration structure
     380                 :            :  */
     381                 :            : typedef void (*eventdev_port_default_conf_get_t)(struct rte_eventdev *dev,
     382                 :            :                 uint8_t port_id, struct rte_event_port_conf *port_conf);
     383                 :            : 
     384                 :            : /**
     385                 :            :  * Setup an event port.
     386                 :            :  *
     387                 :            :  * @param dev
     388                 :            :  *   Event device pointer
     389                 :            :  * @param port_id
     390                 :            :  *   Event port index
     391                 :            :  * @param port_conf
     392                 :            :  *   Event port configuration structure
     393                 :            :  *
     394                 :            :  * @return
     395                 :            :  *   Returns 0 on success.
     396                 :            :  */
     397                 :            : typedef int (*eventdev_port_setup_t)(struct rte_eventdev *dev,
     398                 :            :                 uint8_t port_id,
     399                 :            :                 const struct rte_event_port_conf *port_conf);
     400                 :            : 
     401                 :            : /**
     402                 :            :  * Release memory resources allocated by given event port.
     403                 :            :  *
     404                 :            :  * @param port
     405                 :            :  *   Event port pointer
     406                 :            :  */
     407                 :            : typedef void (*eventdev_port_release_t)(void *port);
     408                 :            : 
     409                 :            : /**
     410                 :            :  * Quiesce any core specific resources consumed by the event port
     411                 :            :  *
     412                 :            :  * @param dev
     413                 :            :  *   Event device pointer.
     414                 :            :  * @param port
     415                 :            :  *   Event port pointer.
     416                 :            :  * @param flush_cb
     417                 :            :  *   User-provided event flush function.
     418                 :            :  * @param args
     419                 :            :  *   Arguments to be passed to the user-provided event flush function.
     420                 :            :  */
     421                 :            : typedef void (*eventdev_port_quiesce_t)(struct rte_eventdev *dev, void *port,
     422                 :            :                                         rte_eventdev_port_flush_t flush_cb,
     423                 :            :                                         void *args);
     424                 :            : 
     425                 :            : /**
     426                 :            :  * Link multiple source event queues to destination event port.
     427                 :            :  *
     428                 :            :  * @param dev
     429                 :            :  *   Event device pointer
     430                 :            :  * @param port
     431                 :            :  *   Event port pointer
     432                 :            :  * @param queues
     433                 :            :  *   Points to an array of *nb_links* event queues to be linked
     434                 :            :  *   to the event port.
     435                 :            :  * @param priorities
     436                 :            :  *   Points to an array of *nb_links* service priorities associated with each
     437                 :            :  *   event queue link to event port.
     438                 :            :  * @param nb_links
     439                 :            :  *   The number of links to establish
     440                 :            :  *
     441                 :            :  * @return
     442                 :            :  *   Returns 0 on success.
     443                 :            :  */
     444                 :            : typedef int (*eventdev_port_link_t)(struct rte_eventdev *dev, void *port,
     445                 :            :                 const uint8_t queues[], const uint8_t priorities[],
     446                 :            :                 uint16_t nb_links);
     447                 :            : 
     448                 :            : /**
     449                 :            :  * Link multiple source event queues associated with a link profile to a
     450                 :            :  * destination event port.
     451                 :            :  *
     452                 :            :  * @param dev
     453                 :            :  *   Event device pointer
     454                 :            :  * @param port
     455                 :            :  *   Event port pointer
     456                 :            :  * @param queues
     457                 :            :  *   Points to an array of *nb_links* event queues to be linked
     458                 :            :  *   to the event port.
     459                 :            :  * @param priorities
     460                 :            :  *   Points to an array of *nb_links* service priorities associated with each
     461                 :            :  *   event queue link to event port.
     462                 :            :  * @param nb_links
     463                 :            :  *   The number of links to establish.
     464                 :            :  * @param profile_id
     465                 :            :  *   The profile ID to associate the links.
     466                 :            :  *
     467                 :            :  * @return
     468                 :            :  *   Returns 0 on success.
     469                 :            :  */
     470                 :            : typedef int (*eventdev_port_link_profile_t)(struct rte_eventdev *dev, void *port,
     471                 :            :                                             const uint8_t queues[], const uint8_t priorities[],
     472                 :            :                                             uint16_t nb_links, uint8_t profile_id);
     473                 :            : 
     474                 :            : /**
     475                 :            :  * Unlink multiple source event queues from destination event port.
     476                 :            :  *
     477                 :            :  * @param dev
     478                 :            :  *   Event device pointer
     479                 :            :  * @param port
     480                 :            :  *   Event port pointer
     481                 :            :  * @param queues
     482                 :            :  *   An array of *nb_unlinks* event queues to be unlinked from the event port.
     483                 :            :  * @param nb_unlinks
     484                 :            :  *   The number of unlinks to establish
     485                 :            :  *
     486                 :            :  * @return
     487                 :            :  *   Returns 0 on success.
     488                 :            :  */
     489                 :            : typedef int (*eventdev_port_unlink_t)(struct rte_eventdev *dev, void *port,
     490                 :            :                 uint8_t queues[], uint16_t nb_unlinks);
     491                 :            : 
     492                 :            : /**
     493                 :            :  * Unlink multiple source event queues associated with a link profile from
     494                 :            :  * destination event port.
     495                 :            :  *
     496                 :            :  * @param dev
     497                 :            :  *   Event device pointer
     498                 :            :  * @param port
     499                 :            :  *   Event port pointer
     500                 :            :  * @param queues
     501                 :            :  *   An array of *nb_unlinks* event queues to be unlinked from the event port.
     502                 :            :  * @param nb_unlinks
     503                 :            :  *   The number of unlinks to establish
     504                 :            :  * @param profile_id
     505                 :            :  *   The profile ID of the associated links.
     506                 :            :  *
     507                 :            :  * @return
     508                 :            :  *   Returns 0 on success.
     509                 :            :  */
     510                 :            : typedef int (*eventdev_port_unlink_profile_t)(struct rte_eventdev *dev, void *port,
     511                 :            :                                               uint8_t queues[], uint16_t nb_unlinks,
     512                 :            :                                               uint8_t profile_id);
     513                 :            : 
     514                 :            : /**
     515                 :            :  * Unlinks in progress. Returns number of unlinks that the PMD is currently
     516                 :            :  * performing, but have not yet been completed.
     517                 :            :  *
     518                 :            :  * @param dev
     519                 :            :  *   Event device pointer
     520                 :            :  *
     521                 :            :  * @param port
     522                 :            :  *   Event port pointer
     523                 :            :  *
     524                 :            :  * @return
     525                 :            :  *   Returns the number of in-progress unlinks. Zero is returned if none are
     526                 :            :  *   in progress.
     527                 :            :  */
     528                 :            : typedef int (*eventdev_port_unlinks_in_progress_t)(struct rte_eventdev *dev,
     529                 :            :                 void *port);
     530                 :            : 
     531                 :            : /**
     532                 :            :  * Converts nanoseconds to *timeout_ticks* value for rte_event_dequeue()
     533                 :            :  *
     534                 :            :  * @param dev
     535                 :            :  *   Event device pointer
     536                 :            :  * @param ns
     537                 :            :  *   Wait time in nanosecond
     538                 :            :  * @param[out] timeout_ticks
     539                 :            :  *   Value for the *timeout_ticks* parameter in rte_event_dequeue() function
     540                 :            :  *
     541                 :            :  * @return
     542                 :            :  *   Returns 0 on success.
     543                 :            :  */
     544                 :            : typedef int (*eventdev_dequeue_timeout_ticks_t)(struct rte_eventdev *dev,
     545                 :            :                 uint64_t ns, uint64_t *timeout_ticks);
     546                 :            : 
     547                 :            : /**
     548                 :            :  * Dump internal information
     549                 :            :  *
     550                 :            :  * @param dev
     551                 :            :  *   Event device pointer
     552                 :            :  * @param f
     553                 :            :  *   A pointer to a file for output
     554                 :            :  */
     555                 :            : typedef void (*eventdev_dump_t)(struct rte_eventdev *dev, FILE *f);
     556                 :            : 
     557                 :            : /**
     558                 :            :  * Retrieve a set of statistics from device
     559                 :            :  *
     560                 :            :  * @param dev
     561                 :            :  *   Event device pointer
     562                 :            :  * @param mode
     563                 :            :  *   Level (device, port or queue)
     564                 :            :  * @param queue_port_id
     565                 :            :  *   Queue or port number depending on mode
     566                 :            :  * @param ids
     567                 :            :  *   The stat ids to retrieve
     568                 :            :  * @param values
     569                 :            :  *   The returned stat values
     570                 :            :  * @param n
     571                 :            :  *   The number of id values and entries in the values array
     572                 :            :  * @return
     573                 :            :  *   The number of stat values successfully filled into the values array
     574                 :            :  */
     575                 :            : typedef int (*eventdev_xstats_get_t)(const struct rte_eventdev *dev,
     576                 :            :                 enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id,
     577                 :            :                 const uint64_t ids[], uint64_t values[], unsigned int n);
     578                 :            : 
     579                 :            : /**
     580                 :            :  * Resets the statistic values in xstats for the device, based on mode.
     581                 :            :  */
     582                 :            : typedef int (*eventdev_xstats_reset_t)(struct rte_eventdev *dev,
     583                 :            :                 enum rte_event_dev_xstats_mode mode,
     584                 :            :                 int16_t queue_port_id,
     585                 :            :                 const uint64_t ids[],
     586                 :            :                 uint32_t nb_ids);
     587                 :            : 
     588                 :            : /**
     589                 :            :  * Get names of extended stats of an event device
     590                 :            :  *
     591                 :            :  * @param dev
     592                 :            :  *   Event device pointer
     593                 :            :  * @param mode
     594                 :            :  *   Level (device, port or queue)
     595                 :            :  * @param queue_port_id
     596                 :            :  *   Queue or port number depending on mode
     597                 :            :  * @param xstats_names
     598                 :            :  *   Array of name values to be filled in
     599                 :            :  * @param ids
     600                 :            :  *   The stat ids to retrieve
     601                 :            :  * @param size
     602                 :            :  *   Number of values in the xstats_names array
     603                 :            :  * @return
     604                 :            :  *   When size >= the number of stats, return the number of stat values filled
     605                 :            :  *   into the array.
     606                 :            :  *   When size < the number of available stats, return the number of stats
     607                 :            :  *   values, and do not fill in any data into xstats_names.
     608                 :            :  */
     609                 :            : typedef int (*eventdev_xstats_get_names_t)(const struct rte_eventdev *dev,
     610                 :            :                 enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id,
     611                 :            :                 struct rte_event_dev_xstats_name *xstats_names,
     612                 :            :                 uint64_t *ids, unsigned int size);
     613                 :            : 
     614                 :            : /**
     615                 :            :  * Get value of one stats and optionally return its id
     616                 :            :  *
     617                 :            :  * @param dev
     618                 :            :  *   Event device pointer
     619                 :            :  * @param name
     620                 :            :  *   The name of the stat to retrieve
     621                 :            :  * @param id
     622                 :            :  *   Pointer to an unsigned int where we store the stat-id for future reference.
     623                 :            :  *   This pointer may be null if the id is not required.
     624                 :            :  * @return
     625                 :            :  *   The value of the stat, or (uint64_t)-1 if the stat is not found.
     626                 :            :  *   If the stat is not found, the id value will be returned as (unsigned)-1,
     627                 :            :  *   if id pointer is non-NULL
     628                 :            :  */
     629                 :            : typedef uint64_t (*eventdev_xstats_get_by_name)(const struct rte_eventdev *dev,
     630                 :            :                 const char *name, uint64_t *id);
     631                 :            : 
     632                 :            : 
     633                 :            : /**
     634                 :            :  * Retrieve the event device's ethdev Rx adapter capabilities for the
     635                 :            :  * specified ethernet port
     636                 :            :  *
     637                 :            :  * @param dev
     638                 :            :  *   Event device pointer
     639                 :            :  *
     640                 :            :  * @param eth_dev
     641                 :            :  *   Ethernet device pointer
     642                 :            :  *
     643                 :            :  * @param[out] caps
     644                 :            :  *   A pointer to memory filled with Rx event adapter capabilities.
     645                 :            :  *
     646                 :            :  * @return
     647                 :            :  *   - 0: Success, driver provides Rx event adapter capabilities for the
     648                 :            :  *      ethernet device.
     649                 :            :  *   - <0: Error code returned by the driver function.
     650                 :            :  */
     651                 :            : typedef int (*eventdev_eth_rx_adapter_caps_get_t)
     652                 :            :                                         (const struct rte_eventdev *dev,
     653                 :            :                                         const struct rte_eth_dev *eth_dev,
     654                 :            :                                         uint32_t *caps);
     655                 :            : 
     656                 :            : struct rte_event_eth_rx_adapter_queue_conf;
     657                 :            : 
     658                 :            : /**
     659                 :            :  * Retrieve the event device's timer adapter capabilities, as well as the ops
     660                 :            :  * structure that an event timer adapter should call through to enter the
     661                 :            :  * driver
     662                 :            :  *
     663                 :            :  * @param dev
     664                 :            :  *   Event device pointer
     665                 :            :  *
     666                 :            :  * @param flags
     667                 :            :  *   Flags that can be used to determine how to select an event timer
     668                 :            :  *   adapter ops structure
     669                 :            :  *
     670                 :            :  * @param[out] caps
     671                 :            :  *   A pointer to memory filled with Rx event adapter capabilities.
     672                 :            :  *
     673                 :            :  * @param[out] ops
     674                 :            :  *   A pointer to the ops pointer to set with the address of the desired ops
     675                 :            :  *   structure
     676                 :            :  *
     677                 :            :  * @return
     678                 :            :  *   - 0: Success, driver provides Rx event adapter capabilities for the
     679                 :            :  *      ethernet device.
     680                 :            :  *   - <0: Error code returned by the driver function.
     681                 :            :  */
     682                 :            : typedef int (*eventdev_timer_adapter_caps_get_t)(
     683                 :            :         const struct rte_eventdev *dev, uint64_t flags, uint32_t *caps,
     684                 :            :         const struct event_timer_adapter_ops **ops);
     685                 :            : 
     686                 :            : /**
     687                 :            :  * Add ethernet Rx queues to event device. This callback is invoked if
     688                 :            :  * the caps returned from rte_eventdev_eth_rx_adapter_caps_get(, eth_port_id)
     689                 :            :  * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set.
     690                 :            :  *
     691                 :            :  * @param dev
     692                 :            :  *   Event device pointer
     693                 :            :  *
     694                 :            :  * @param eth_dev
     695                 :            :  *   Ethernet device pointer
     696                 :            :  *
     697                 :            :  * @param rx_queue_id
     698                 :            :  *   Ethernet device receive queue index
     699                 :            :  *
     700                 :            :  * @param queue_conf
     701                 :            :  *  Additional configuration structure
     702                 :            : 
     703                 :            :  * @return
     704                 :            :  *   - 0: Success, ethernet receive queue added successfully.
     705                 :            :  *   - <0: Error code returned by the driver function.
     706                 :            :  */
     707                 :            : typedef int (*eventdev_eth_rx_adapter_queue_add_t)(
     708                 :            :                 const struct rte_eventdev *dev,
     709                 :            :                 const struct rte_eth_dev *eth_dev,
     710                 :            :                 int32_t rx_queue_id,
     711                 :            :                 const struct rte_event_eth_rx_adapter_queue_conf *queue_conf);
     712                 :            : 
     713                 :            : /**
     714                 :            :  * Delete ethernet Rx queues from event device. This callback is invoked if
     715                 :            :  * the caps returned from eventdev_eth_rx_adapter_caps_get(, eth_port_id)
     716                 :            :  * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set.
     717                 :            :  *
     718                 :            :  * @param dev
     719                 :            :  *   Event device pointer
     720                 :            :  *
     721                 :            :  * @param eth_dev
     722                 :            :  *   Ethernet device pointer
     723                 :            :  *
     724                 :            :  * @param rx_queue_id
     725                 :            :  *   Ethernet device receive queue index
     726                 :            :  *
     727                 :            :  * @return
     728                 :            :  *   - 0: Success, ethernet receive queue deleted successfully.
     729                 :            :  *   - <0: Error code returned by the driver function.
     730                 :            :  */
     731                 :            : typedef int (*eventdev_eth_rx_adapter_queue_del_t)
     732                 :            :                                         (const struct rte_eventdev *dev,
     733                 :            :                                         const struct rte_eth_dev *eth_dev,
     734                 :            :                                         int32_t rx_queue_id);
     735                 :            : 
     736                 :            : /**
     737                 :            :  * Retrieve Rx adapter queue config information for the specified
     738                 :            :  * rx queue ID.
     739                 :            :  *
     740                 :            :  * @param dev
     741                 :            :  *  Event device pointer
     742                 :            :  *
     743                 :            :  * @param eth_dev
     744                 :            :  *  Ethernet device pointer
     745                 :            :  *
     746                 :            :  * @param rx_queue_id
     747                 :            :  *  Ethernet device receive queue index.
     748                 :            :  *
     749                 :            :  * @param[out] queue_conf
     750                 :            :  *  Pointer to rte_event_eth_rx_adapter_queue_conf structure
     751                 :            :  *
     752                 :            :  * @return
     753                 :            :  *  - 0: Success
     754                 :            :  *  - <0: Error code on failure.
     755                 :            :  */
     756                 :            : typedef int (*eventdev_eth_rx_adapter_queue_conf_get_t)
     757                 :            :                         (const struct rte_eventdev *dev,
     758                 :            :                         const struct rte_eth_dev *eth_dev,
     759                 :            :                         uint16_t rx_queue_id,
     760                 :            :                         struct rte_event_eth_rx_adapter_queue_conf *queue_conf);
     761                 :            : 
     762                 :            : /**
     763                 :            :  * Start ethernet Rx adapter. This callback is invoked if
     764                 :            :  * the caps returned from eventdev_eth_rx_adapter_caps_get(.., eth_port_id)
     765                 :            :  * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set and Rx queues
     766                 :            :  * from eth_port_id have been added to the event device.
     767                 :            :  *
     768                 :            :  * @param dev
     769                 :            :  *   Event device pointer
     770                 :            :  *
     771                 :            :  * @param eth_dev
     772                 :            :  *   Ethernet device pointer
     773                 :            :  *
     774                 :            :  * @return
     775                 :            :  *   - 0: Success, ethernet Rx adapter started successfully.
     776                 :            :  *   - <0: Error code returned by the driver function.
     777                 :            :  */
     778                 :            : typedef int (*eventdev_eth_rx_adapter_start_t)
     779                 :            :                                         (const struct rte_eventdev *dev,
     780                 :            :                                         const struct rte_eth_dev *eth_dev);
     781                 :            : 
     782                 :            : /**
     783                 :            :  * Stop ethernet Rx adapter. This callback is invoked if
     784                 :            :  * the caps returned from eventdev_eth_rx_adapter_caps_get(..,eth_port_id)
     785                 :            :  * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set and Rx queues
     786                 :            :  * from eth_port_id have been added to the event device.
     787                 :            :  *
     788                 :            :  * @param dev
     789                 :            :  *   Event device pointer
     790                 :            :  *
     791                 :            :  * @param eth_dev
     792                 :            :  *   Ethernet device pointer
     793                 :            :  *
     794                 :            :  * @return
     795                 :            :  *   - 0: Success, ethernet Rx adapter stopped successfully.
     796                 :            :  *   - <0: Error code returned by the driver function.
     797                 :            :  */
     798                 :            : typedef int (*eventdev_eth_rx_adapter_stop_t)
     799                 :            :                                         (const struct rte_eventdev *dev,
     800                 :            :                                         const struct rte_eth_dev *eth_dev);
     801                 :            : 
     802                 :            : struct rte_event_eth_rx_adapter_stats;
     803                 :            : 
     804                 :            : /**
     805                 :            :  * Retrieve ethernet Rx adapter statistics.
     806                 :            :  *
     807                 :            :  * @param dev
     808                 :            :  *   Event device pointer
     809                 :            :  *
     810                 :            :  * @param eth_dev
     811                 :            :  *   Ethernet device pointer
     812                 :            :  *
     813                 :            :  * @param[out] stats
     814                 :            :  *   Pointer to stats structure
     815                 :            :  *
     816                 :            :  * @return
     817                 :            :  *   Return 0 on success.
     818                 :            :  */
     819                 :            : 
     820                 :            : typedef int (*eventdev_eth_rx_adapter_stats_get)
     821                 :            :                         (const struct rte_eventdev *dev,
     822                 :            :                         const struct rte_eth_dev *eth_dev,
     823                 :            :                         struct rte_event_eth_rx_adapter_stats *stats);
     824                 :            : /**
     825                 :            :  * Reset ethernet Rx adapter statistics.
     826                 :            :  *
     827                 :            :  * @param dev
     828                 :            :  *   Event device pointer
     829                 :            :  *
     830                 :            :  * @param eth_dev
     831                 :            :  *   Ethernet device pointer
     832                 :            :  *
     833                 :            :  * @return
     834                 :            :  *   Return 0 on success.
     835                 :            :  */
     836                 :            : typedef int (*eventdev_eth_rx_adapter_stats_reset)
     837                 :            :                         (const struct rte_eventdev *dev,
     838                 :            :                         const struct rte_eth_dev *eth_dev);
     839                 :            : 
     840                 :            : struct rte_event_eth_rx_adapter_queue_stats;
     841                 :            : 
     842                 :            : /**
     843                 :            :  * Retrieve ethernet Rx adapter queue statistics.
     844                 :            :  *
     845                 :            :  * @param dev
     846                 :            :  *   Event device pointer
     847                 :            :  *
     848                 :            :  * @param eth_dev
     849                 :            :  *   Ethernet device pointer
     850                 :            :  *
     851                 :            :  * @param rx_queue_id
     852                 :            :  *  Ethernet device receive queue index.
     853                 :            :  *
     854                 :            :  * @param[out] q_stats
     855                 :            :  *   Pointer to queue stats structure
     856                 :            :  *
     857                 :            :  * @return
     858                 :            :  *   Return 0 on success.
     859                 :            :  */
     860                 :            : typedef int (*eventdev_eth_rx_adapter_q_stats_get)
     861                 :            :                         (const struct rte_eventdev *dev,
     862                 :            :                          const struct rte_eth_dev *eth_dev,
     863                 :            :                          uint16_t rx_queue_id,
     864                 :            :                          struct rte_event_eth_rx_adapter_queue_stats *q_stats);
     865                 :            : 
     866                 :            : /**
     867                 :            :  * Reset ethernet Rx adapter queue statistics.
     868                 :            :  *
     869                 :            :  * @param dev
     870                 :            :  *   Event device pointer
     871                 :            :  *
     872                 :            :  * @param eth_dev
     873                 :            :  *   Ethernet device pointer
     874                 :            :  *
     875                 :            :  * @param rx_queue_id
     876                 :            :  *  Ethernet device receive queue index.
     877                 :            :  *
     878                 :            :  * @return
     879                 :            :  *   Return 0 on success.
     880                 :            :  */
     881                 :            : typedef int (*eventdev_eth_rx_adapter_q_stats_reset)
     882                 :            :                         (const struct rte_eventdev *dev,
     883                 :            :                          const struct rte_eth_dev *eth_dev,
     884                 :            :                          uint16_t rx_queue_id);
     885                 :            : 
     886                 :            : /**
     887                 :            :  * Start eventdev selftest.
     888                 :            :  *
     889                 :            :  * @return
     890                 :            :  *   Return 0 on success.
     891                 :            :  */
     892                 :            : typedef int (*eventdev_selftest)(void);
     893                 :            : 
     894                 :            : struct rte_event_eth_rx_adapter_vector_limits;
     895                 :            : /**
     896                 :            :  * Get event vector limits for a given event, ethernet device pair.
     897                 :            :  *
     898                 :            :  * @param dev
     899                 :            :  *   Event device pointer
     900                 :            :  *
     901                 :            :  * @param eth_dev
     902                 :            :  *   Ethernet device pointer
     903                 :            :  *
     904                 :            :  * @param[out] limits
     905                 :            :  *   Pointer to the limits structure to be filled.
     906                 :            :  *
     907                 :            :  * @return
     908                 :            :  *   - 0: Success.
     909                 :            :  *   - <0: Error code returned by the driver function.
     910                 :            :  */
     911                 :            : typedef int (*eventdev_eth_rx_adapter_vector_limits_get_t)(
     912                 :            :         const struct rte_eventdev *dev, const struct rte_eth_dev *eth_dev,
     913                 :            :         struct rte_event_eth_rx_adapter_vector_limits *limits);
     914                 :            : 
     915                 :            : /**
     916                 :            :  * Get Rx adapter instance ID for Rx queue
     917                 :            :  *
     918                 :            :  * @param eth_dev_id
     919                 :            :  *  Port identifier of ethernet device
     920                 :            :  *
     921                 :            :  * @param rx_queue_id
     922                 :            :  *  Ethernet device Rx queue index
     923                 :            :  *
     924                 :            :  * @param[out] rxa_inst_id
     925                 :            :  *  Pointer to Rx adapter instance identifier.
     926                 :            :  *  Contains valid Rx adapter instance ID when return value is 0
     927                 :            :  *
     928                 :            :  * @return
     929                 :            :  *   -  0: Success
     930                 :            :  *   - <0: Error code on failure
     931                 :            :  */
     932                 :            : typedef int (*eventdev_eth_rx_adapter_instance_get_t)
     933                 :            :         (uint16_t eth_dev_id, uint16_t rx_queue_id, uint8_t *rxa_inst_id);
     934                 :            : 
     935                 :            : typedef uint32_t rte_event_pmd_selftest_seqn_t;
     936                 :            : extern int rte_event_pmd_selftest_seqn_dynfield_offset;
     937                 :            : 
     938                 :            : /**
     939                 :            :  * Read test sequence number from mbuf.
     940                 :            :  *
     941                 :            :  * @param mbuf Structure to read from.
     942                 :            :  * @return pointer to test sequence number.
     943                 :            :  */
     944                 :            : __rte_internal
     945                 :            : static inline rte_event_pmd_selftest_seqn_t *
     946                 :            : rte_event_pmd_selftest_seqn(struct rte_mbuf *mbuf)
     947                 :            : {
     948   [ -  +  -  +  :         45 :         return RTE_MBUF_DYNFIELD(mbuf,
          -  +  -  +  -  
                +  -  + ]
     949                 :            :                 rte_event_pmd_selftest_seqn_dynfield_offset,
     950                 :            :                 rte_event_pmd_selftest_seqn_t *);
     951                 :            : }
     952                 :            : 
     953                 :            : struct rte_cryptodev;
     954                 :            : struct rte_event_crypto_adapter_queue_conf;
     955                 :            : 
     956                 :            : /**
     957                 :            :  * This API may change without prior notice
     958                 :            :  *
     959                 :            :  * Retrieve the event device's crypto adapter capabilities for the
     960                 :            :  * specified cryptodev
     961                 :            :  *
     962                 :            :  * @param dev
     963                 :            :  *   Event device pointer
     964                 :            :  *
     965                 :            :  * @param cdev
     966                 :            :  *   cryptodev pointer
     967                 :            :  *
     968                 :            :  * @param[out] caps
     969                 :            :  *   A pointer to memory filled with event adapter capabilities.
     970                 :            :  *   It is expected to be pre-allocated & initialized by caller.
     971                 :            :  *
     972                 :            :  * @return
     973                 :            :  *   - 0: Success, driver provides event adapter capabilities for the
     974                 :            :  *      cryptodev.
     975                 :            :  *   - <0: Error code returned by the driver function.
     976                 :            :  */
     977                 :            : typedef int (*eventdev_crypto_adapter_caps_get_t)
     978                 :            :                                         (const struct rte_eventdev *dev,
     979                 :            :                                          const struct rte_cryptodev *cdev,
     980                 :            :                                          uint32_t *caps);
     981                 :            : 
     982                 :            : /**
     983                 :            :  * This API may change without prior notice
     984                 :            :  *
     985                 :            :  * Add crypto queue pair to event device. This callback is invoked if
     986                 :            :  * the caps returned from rte_event_crypto_adapter_caps_get(, cdev_id)
     987                 :            :  * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set.
     988                 :            :  *
     989                 :            :  * @param dev
     990                 :            :  *   Event device pointer
     991                 :            :  *
     992                 :            :  * @param cdev
     993                 :            :  *   cryptodev pointer
     994                 :            :  *
     995                 :            :  * @param queue_pair_id
     996                 :            :  *   cryptodev queue pair identifier.
     997                 :            :  *
     998                 :            :  * @param event
     999                 :            :  *  Event information required for binding cryptodev queue pair to event queue.
    1000                 :            :  *  This structure will have a valid value for only those HW PMDs supporting
    1001                 :            :  *  @see RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND capability.
    1002                 :            :  *
    1003                 :            :  * @return
    1004                 :            :  *   - 0: Success, cryptodev queue pair added successfully.
    1005                 :            :  *   - <0: Error code returned by the driver function.
    1006                 :            :  */
    1007                 :            : typedef int (*eventdev_crypto_adapter_queue_pair_add_t)(
    1008                 :            :                 const struct rte_eventdev *dev,
    1009                 :            :                 const struct rte_cryptodev *cdev,
    1010                 :            :                 int32_t queue_pair_id,
    1011                 :            :                 const struct rte_event_crypto_adapter_queue_conf *queue_conf);
    1012                 :            : 
    1013                 :            : 
    1014                 :            : /**
    1015                 :            :  * This API may change without prior notice
    1016                 :            :  *
    1017                 :            :  * Delete crypto queue pair to event device. This callback is invoked if
    1018                 :            :  * the caps returned from rte_event_crypto_adapter_caps_get(, cdev_id)
    1019                 :            :  * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set.
    1020                 :            :  *
    1021                 :            :  * @param dev
    1022                 :            :  *   Event device pointer
    1023                 :            :  *
    1024                 :            :  * @param cdev
    1025                 :            :  *   cryptodev pointer
    1026                 :            :  *
    1027                 :            :  * @param queue_pair_id
    1028                 :            :  *   cryptodev queue pair identifier.
    1029                 :            :  *
    1030                 :            :  * @return
    1031                 :            :  *   - 0: Success, cryptodev queue pair deleted successfully.
    1032                 :            :  *   - <0: Error code returned by the driver function.
    1033                 :            :  */
    1034                 :            : typedef int (*eventdev_crypto_adapter_queue_pair_del_t)
    1035                 :            :                                         (const struct rte_eventdev *dev,
    1036                 :            :                                          const struct rte_cryptodev *cdev,
    1037                 :            :                                          int32_t queue_pair_id);
    1038                 :            : 
    1039                 :            : /**
    1040                 :            :  * Start crypto adapter. This callback is invoked if
    1041                 :            :  * the caps returned from rte_event_crypto_adapter_caps_get(.., cdev_id)
    1042                 :            :  * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set and queue pairs
    1043                 :            :  * from cdev_id have been added to the event device.
    1044                 :            :  *
    1045                 :            :  * @param dev
    1046                 :            :  *   Event device pointer
    1047                 :            :  *
    1048                 :            :  * @param cdev
    1049                 :            :  *   Crypto device pointer
    1050                 :            :  *
    1051                 :            :  * @return
    1052                 :            :  *   - 0: Success, crypto adapter started successfully.
    1053                 :            :  *   - <0: Error code returned by the driver function.
    1054                 :            :  */
    1055                 :            : typedef int (*eventdev_crypto_adapter_start_t)
    1056                 :            :                                         (const struct rte_eventdev *dev,
    1057                 :            :                                          const struct rte_cryptodev *cdev);
    1058                 :            : 
    1059                 :            : /**
    1060                 :            :  * Stop crypto adapter. This callback is invoked if
    1061                 :            :  * the caps returned from rte_event_crypto_adapter_caps_get(.., cdev_id)
    1062                 :            :  * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set and queue pairs
    1063                 :            :  * from cdev_id have been added to the event device.
    1064                 :            :  *
    1065                 :            :  * @param dev
    1066                 :            :  *   Event device pointer
    1067                 :            :  *
    1068                 :            :  * @param cdev
    1069                 :            :  *   Crypto device pointer
    1070                 :            :  *
    1071                 :            :  * @return
    1072                 :            :  *   - 0: Success, crypto adapter stopped successfully.
    1073                 :            :  *   - <0: Error code returned by the driver function.
    1074                 :            :  */
    1075                 :            : typedef int (*eventdev_crypto_adapter_stop_t)
    1076                 :            :                                         (const struct rte_eventdev *dev,
    1077                 :            :                                          const struct rte_cryptodev *cdev);
    1078                 :            : 
    1079                 :            : struct rte_event_crypto_adapter_stats;
    1080                 :            : 
    1081                 :            : /**
    1082                 :            :  * Retrieve crypto adapter statistics.
    1083                 :            :  *
    1084                 :            :  * @param dev
    1085                 :            :  *   Event device pointer
    1086                 :            :  *
    1087                 :            :  * @param cdev
    1088                 :            :  *   Crypto device pointer
    1089                 :            :  *
    1090                 :            :  * @param[out] stats
    1091                 :            :  *   Pointer to stats structure
    1092                 :            :  *
    1093                 :            :  * @return
    1094                 :            :  *   Return 0 on success.
    1095                 :            :  */
    1096                 :            : 
    1097                 :            : typedef int (*eventdev_crypto_adapter_stats_get)
    1098                 :            :                         (const struct rte_eventdev *dev,
    1099                 :            :                          const struct rte_cryptodev *cdev,
    1100                 :            :                          struct rte_event_crypto_adapter_stats *stats);
    1101                 :            : 
    1102                 :            : /**
    1103                 :            :  * Reset crypto adapter statistics.
    1104                 :            :  *
    1105                 :            :  * @param dev
    1106                 :            :  *   Event device pointer
    1107                 :            :  *
    1108                 :            :  * @param cdev
    1109                 :            :  *   Crypto device pointer
    1110                 :            :  *
    1111                 :            :  * @return
    1112                 :            :  *   Return 0 on success.
    1113                 :            :  */
    1114                 :            : 
    1115                 :            : typedef int (*eventdev_crypto_adapter_stats_reset)
    1116                 :            :                         (const struct rte_eventdev *dev,
    1117                 :            :                          const struct rte_cryptodev *cdev);
    1118                 :            : 
    1119                 :            : struct rte_event_crypto_adapter_vector_limits;
    1120                 :            : /**
    1121                 :            :  * Get event vector limits for a given event, crypto device pair.
    1122                 :            :  *
    1123                 :            :  * @param dev
    1124                 :            :  *   Event device pointer
    1125                 :            :  *
    1126                 :            :  * @param cdev
    1127                 :            :  *   Crypto device pointer
    1128                 :            :  *
    1129                 :            :  * @param[out] limits
    1130                 :            :  *   Pointer to the limits structure to be filled.
    1131                 :            :  *
    1132                 :            :  * @return
    1133                 :            :  *   - 0: Success.
    1134                 :            :  *   - <0: Error code returned by the driver function.
    1135                 :            :  */
    1136                 :            : typedef int (*eventdev_crypto_adapter_vector_limits_get_t)(
    1137                 :            :         const struct rte_eventdev *dev, const struct rte_cryptodev *cdev,
    1138                 :            :         struct rte_event_crypto_adapter_vector_limits *limits);
    1139                 :            : 
    1140                 :            : /**
    1141                 :            :  * Retrieve the event device's eth Tx adapter capabilities.
    1142                 :            :  *
    1143                 :            :  * @param dev
    1144                 :            :  *   Event device pointer
    1145                 :            :  *
    1146                 :            :  * @param eth_dev
    1147                 :            :  *   Ethernet device pointer
    1148                 :            :  *
    1149                 :            :  * @param[out] caps
    1150                 :            :  *   A pointer to memory filled with eth Tx adapter capabilities.
    1151                 :            :  *
    1152                 :            :  * @return
    1153                 :            :  *   - 0: Success, driver provides eth Tx adapter capabilities
    1154                 :            :  *   - <0: Error code returned by the driver function.
    1155                 :            :  */
    1156                 :            : typedef int (*eventdev_eth_tx_adapter_caps_get_t)
    1157                 :            :                                         (const struct rte_eventdev *dev,
    1158                 :            :                                         const struct rte_eth_dev *eth_dev,
    1159                 :            :                                         uint32_t *caps);
    1160                 :            : 
    1161                 :            : /**
    1162                 :            :  * Create adapter callback.
    1163                 :            :  *
    1164                 :            :  * @param id
    1165                 :            :  *   Adapter identifier
    1166                 :            :  *
    1167                 :            :  * @param dev
    1168                 :            :  *   Event device pointer
    1169                 :            :  *
    1170                 :            :  * @return
    1171                 :            :  *   - 0: Success.
    1172                 :            :  *   - <0: Error code on failure.
    1173                 :            :  */
    1174                 :            : typedef int (*eventdev_eth_tx_adapter_create_t)(uint8_t id,
    1175                 :            :                                         const struct rte_eventdev *dev);
    1176                 :            : 
    1177                 :            : /**
    1178                 :            :  * Free adapter callback.
    1179                 :            :  *
    1180                 :            :  * @param id
    1181                 :            :  *   Adapter identifier
    1182                 :            :  *
    1183                 :            :  * @param dev
    1184                 :            :  *   Event device pointer
    1185                 :            :  *
    1186                 :            :  * @return
    1187                 :            :  *   - 0: Success.
    1188                 :            :  *   - <0: Error code on failure.
    1189                 :            :  */
    1190                 :            : typedef int (*eventdev_eth_tx_adapter_free_t)(uint8_t id,
    1191                 :            :                                         const struct rte_eventdev *dev);
    1192                 :            : 
    1193                 :            : /**
    1194                 :            :  * Add a Tx queue to the adapter.
    1195                 :            :  * A queue value of -1 is used to indicate all
    1196                 :            :  * queues within the device.
    1197                 :            :  *
    1198                 :            :  * @param id
    1199                 :            :  *   Adapter identifier
    1200                 :            :  *
    1201                 :            :  * @param dev
    1202                 :            :  *   Event device pointer
    1203                 :            :  *
    1204                 :            :  * @param eth_dev
    1205                 :            :  *   Ethernet device pointer
    1206                 :            :  *
    1207                 :            :  * @param tx_queue_id
    1208                 :            :  *   Transmit queue index
    1209                 :            :  *
    1210                 :            :  * @return
    1211                 :            :  *   - 0: Success.
    1212                 :            :  *   - <0: Error code on failure.
    1213                 :            :  */
    1214                 :            : typedef int (*eventdev_eth_tx_adapter_queue_add_t)(
    1215                 :            :                                         uint8_t id,
    1216                 :            :                                         const struct rte_eventdev *dev,
    1217                 :            :                                         const struct rte_eth_dev *eth_dev,
    1218                 :            :                                         int32_t tx_queue_id);
    1219                 :            : 
    1220                 :            : /**
    1221                 :            :  * Delete a Tx queue from the adapter.
    1222                 :            :  * A queue value of -1 is used to indicate all
    1223                 :            :  * queues within the device, that have been added to this
    1224                 :            :  * adapter.
    1225                 :            :  *
    1226                 :            :  * @param id
    1227                 :            :  *   Adapter identifier
    1228                 :            :  *
    1229                 :            :  * @param dev
    1230                 :            :  *   Event device pointer
    1231                 :            :  *
    1232                 :            :  * @param eth_dev
    1233                 :            :  *   Ethernet device pointer
    1234                 :            :  *
    1235                 :            :  * @param tx_queue_id
    1236                 :            :  *   Transmit queue index
    1237                 :            :  *
    1238                 :            :  * @return
    1239                 :            :  *  - 0: Success, Queues deleted successfully.
    1240                 :            :  *  - <0: Error code on failure.
    1241                 :            :  */
    1242                 :            : typedef int (*eventdev_eth_tx_adapter_queue_del_t)(
    1243                 :            :                                         uint8_t id,
    1244                 :            :                                         const struct rte_eventdev *dev,
    1245                 :            :                                         const struct rte_eth_dev *eth_dev,
    1246                 :            :                                         int32_t tx_queue_id);
    1247                 :            : 
    1248                 :            : /**
    1249                 :            :  * Start the adapter.
    1250                 :            :  *
    1251                 :            :  * @param id
    1252                 :            :  *   Adapter identifier
    1253                 :            :  *
    1254                 :            :  * @param dev
    1255                 :            :  *   Event device pointer
    1256                 :            :  *
    1257                 :            :  * @return
    1258                 :            :  *  - 0: Success, Adapter started correctly.
    1259                 :            :  *  - <0: Error code on failure.
    1260                 :            :  */
    1261                 :            : typedef int (*eventdev_eth_tx_adapter_start_t)(uint8_t id,
    1262                 :            :                                         const struct rte_eventdev *dev);
    1263                 :            : 
    1264                 :            : /**
    1265                 :            :  * Stop the adapter.
    1266                 :            :  *
    1267                 :            :  * @param id
    1268                 :            :  *  Adapter identifier
    1269                 :            :  *
    1270                 :            :  * @param dev
    1271                 :            :  *   Event device pointer
    1272                 :            :  *
    1273                 :            :  * @return
    1274                 :            :  *  - 0: Success.
    1275                 :            :  *  - <0: Error code on failure.
    1276                 :            :  */
    1277                 :            : typedef int (*eventdev_eth_tx_adapter_stop_t)(uint8_t id,
    1278                 :            :                                         const struct rte_eventdev *dev);
    1279                 :            : 
    1280                 :            : struct rte_event_eth_tx_adapter_stats;
    1281                 :            : 
    1282                 :            : /**
    1283                 :            :  * Retrieve statistics for an adapter
    1284                 :            :  *
    1285                 :            :  * @param id
    1286                 :            :  *  Adapter identifier
    1287                 :            :  *
    1288                 :            :  * @param dev
    1289                 :            :  *   Event device pointer
    1290                 :            :  *
    1291                 :            :  * @param [out] stats
    1292                 :            :  *  A pointer to structure used to retrieve statistics for an adapter
    1293                 :            :  *
    1294                 :            :  * @return
    1295                 :            :  *  - 0: Success, statistics retrieved successfully.
    1296                 :            :  *  - <0: Error code on failure.
    1297                 :            :  */
    1298                 :            : typedef int (*eventdev_eth_tx_adapter_stats_get_t)(
    1299                 :            :                                 uint8_t id,
    1300                 :            :                                 const struct rte_eventdev *dev,
    1301                 :            :                                 struct rte_event_eth_tx_adapter_stats *stats);
    1302                 :            : 
    1303                 :            : /**
    1304                 :            :  * Reset statistics for an adapter
    1305                 :            :  *
    1306                 :            :  * @param id
    1307                 :            :  *  Adapter identifier
    1308                 :            :  *
    1309                 :            :  * @param dev
    1310                 :            :  *   Event device pointer
    1311                 :            :  *
    1312                 :            :  * @return
    1313                 :            :  *  - 0: Success, statistics retrieved successfully.
    1314                 :            :  *  - <0: Error code on failure.
    1315                 :            :  */
    1316                 :            : typedef int (*eventdev_eth_tx_adapter_stats_reset_t)(uint8_t id,
    1317                 :            :                                         const struct rte_eventdev *dev);
    1318                 :            : 
    1319                 :            : /**
    1320                 :            :  * Get TX adapter instance ID for Tx queue
    1321                 :            :  *
    1322                 :            :  * @param eth_dev_id
    1323                 :            :  *  Port identifier of Ethernet device
    1324                 :            :  *
    1325                 :            :  * @param tx_queue_id
    1326                 :            :  *  Ethernet device Tx queue index
    1327                 :            :  *
    1328                 :            :  * @param[out] txa_inst_id
    1329                 :            :  *  Pointer to Tx adapter instance identifier
    1330                 :            :  *  Contains valid Tx adapter instance ID when return value is 0
    1331                 :            :  *
    1332                 :            :  * @return
    1333                 :            :  *  -  0: Success
    1334                 :            :  *  - <0: Error code on failure
    1335                 :            :  */
    1336                 :            : typedef int (*eventdev_eth_tx_adapter_instance_get_t)
    1337                 :            :         (uint16_t eth_dev_id, uint16_t tx_queue_id, uint8_t *txa_inst_id);
    1338                 :            : 
    1339                 :            : /**
    1340                 :            :  * Start a Tx queue that is assigned to Tx adapter instance
    1341                 :            :  *
    1342                 :            :  * @param id
    1343                 :            :  *  Adapter identifier
    1344                 :            :  *
    1345                 :            :  * @param eth_dev_id
    1346                 :            :  *  Port identifier of Ethernet device
    1347                 :            :  *
    1348                 :            :  * @param tx_queue_id
    1349                 :            :  *  Ethernet device Tx queue index
    1350                 :            :  *
    1351                 :            :  * @return
    1352                 :            :  *  -  0: Success
    1353                 :            :  *  - <0: Error code on failure
    1354                 :            :  */
    1355                 :            : typedef int (*eventdev_eth_tx_adapter_queue_start)
    1356                 :            :         (uint8_t id, uint16_t eth_dev_id, uint16_t tx_queue_id);
    1357                 :            : 
    1358                 :            : /**
    1359                 :            :  * Stop a Tx queue that is assigned to Tx adapter instance
    1360                 :            :  *
    1361                 :            :  * @param id
    1362                 :            :  *  Adapter identifier
    1363                 :            :  *
    1364                 :            :  * @param eth_dev_id
    1365                 :            :  *  Port identifier of Ethernet device
    1366                 :            :  *
    1367                 :            :  * @param tx_queue_id
    1368                 :            :  *  Ethernet device Tx queue index
    1369                 :            :  *
    1370                 :            :  * @return
    1371                 :            :  *  -  0: Success
    1372                 :            :  *  - <0: Error code on failure
    1373                 :            :  */
    1374                 :            : typedef int (*eventdev_eth_tx_adapter_queue_stop)
    1375                 :            :         (uint8_t id, uint16_t eth_dev_id, uint16_t tx_queue_id);
    1376                 :            : 
    1377                 :            : #define eventdev_stop_flush_t rte_eventdev_stop_flush_t
    1378                 :            : 
    1379                 :            : /**
    1380                 :            :  * Retrieve the event device's DMA adapter capabilities for the
    1381                 :            :  * specified DMA device
    1382                 :            :  *
    1383                 :            :  * @param dev
    1384                 :            :  *   Event device pointer
    1385                 :            :  *
    1386                 :            :  * @param dma_dev_id
    1387                 :            :  *   DMA device identifier
    1388                 :            :  *
    1389                 :            :  * @param[out] caps
    1390                 :            :  *   A pointer to memory filled with event adapter capabilities.
    1391                 :            :  *   It is expected to be pre-allocated & initialized by caller.
    1392                 :            :  *
    1393                 :            :  * @return
    1394                 :            :  *   - 0: Success, driver provides event adapter capabilities for the
    1395                 :            :  *      dmadev.
    1396                 :            :  *   - <0: Error code returned by the driver function.
    1397                 :            :  *
    1398                 :            :  */
    1399                 :            : typedef int (*eventdev_dma_adapter_caps_get_t)(const struct rte_eventdev *dev,
    1400                 :            :                                                const int16_t dma_dev_id, uint32_t *caps);
    1401                 :            : 
    1402                 :            : /**
    1403                 :            :  * Add DMA vchan queue to event device. This callback is invoked if
    1404                 :            :  * the caps returned from rte_event_dma_adapter_caps_get(, dmadev_id)
    1405                 :            :  * has RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_* set.
    1406                 :            :  *
    1407                 :            :  * @param dev
    1408                 :            :  *   Event device pointer
    1409                 :            :  *
    1410                 :            :  * @param dma_dev_id
    1411                 :            :  *   DMA device identifier
    1412                 :            :  *
    1413                 :            :  * @param vchan_id
    1414                 :            :  *   dmadev vchan queue identifier.
    1415                 :            :  *
    1416                 :            :  * @param event
    1417                 :            :  *   Event information required for binding dmadev vchan to event queue.
    1418                 :            :  *   This structure will have a valid value for only those HW PMDs supporting
    1419                 :            :  *   @see RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_VCHAN_EV_BIND capability.
    1420                 :            :  *
    1421                 :            :  * @return
    1422                 :            :  *   - 0: Success, dmadev vchan added successfully.
    1423                 :            :  *   - <0: Error code returned by the driver function.
    1424                 :            :  *
    1425                 :            :  */
    1426                 :            : typedef int (*eventdev_dma_adapter_vchan_add_t)(const struct rte_eventdev *dev,
    1427                 :            :                                                 const int16_t dma_dev_id,
    1428                 :            :                                                 uint16_t vchan_id,
    1429                 :            :                                                 const struct rte_event *event);
    1430                 :            : 
    1431                 :            : /**
    1432                 :            :  * Delete DMA vhcan to event device. This callback is invoked if
    1433                 :            :  * the caps returned from rte_event_dma_adapter_caps_get(, dmadev_id)
    1434                 :            :  * has RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_* set.
    1435                 :            :  *
    1436                 :            :  * @param dev
    1437                 :            :  *   Event device pointer
    1438                 :            :  *
    1439                 :            :  * @param dma_dev_id
    1440                 :            :  *   DMA device identifier
    1441                 :            :  *
    1442                 :            :  * @param vchan_id
    1443                 :            :  *   dmadev vchan identifier.
    1444                 :            :  *
    1445                 :            :  * @return
    1446                 :            :  *   - 0: Success, dmadev vchan deleted successfully.
    1447                 :            :  *   - <0: Error code returned by the driver function.
    1448                 :            :  *
    1449                 :            :  */
    1450                 :            : typedef int (*eventdev_dma_adapter_vchan_del_t)(const struct rte_eventdev *dev,
    1451                 :            :                                                 const int16_t dma_dev_id,
    1452                 :            :                                                 uint16_t vchan_id);
    1453                 :            : 
    1454                 :            : /**
    1455                 :            :  * Start DMA adapter. This callback is invoked if
    1456                 :            :  * the caps returned from rte_event_dma_adapter_caps_get(.., dmadev_id)
    1457                 :            :  * has RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_* set and vchan for dmadev_id
    1458                 :            :  * have been added to the event device.
    1459                 :            :  *
    1460                 :            :  * @param dev
    1461                 :            :  *   Event device pointer
    1462                 :            :  *
    1463                 :            :  * @param dma_dev_id
    1464                 :            :  *   DMA device identifier
    1465                 :            :  *
    1466                 :            :  * @return
    1467                 :            :  *   - 0: Success, DMA adapter started successfully.
    1468                 :            :  *   - <0: Error code returned by the driver function.
    1469                 :            :  */
    1470                 :            : typedef int (*eventdev_dma_adapter_start_t)(const struct rte_eventdev *dev,
    1471                 :            :                                             const int16_t dma_dev_id);
    1472                 :            : 
    1473                 :            : /**
    1474                 :            :  * Stop DMA adapter. This callback is invoked if
    1475                 :            :  * the caps returned from rte_event_dma_adapter_caps_get(.., dmadev_id)
    1476                 :            :  * has RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_* set and vchan for dmadev_id
    1477                 :            :  * have been added to the event device.
    1478                 :            :  *
    1479                 :            :  * @param dev
    1480                 :            :  *   Event device pointer
    1481                 :            :  *
    1482                 :            :  * @param dma_dev_id
    1483                 :            :  *   DMA device identifier
    1484                 :            :  *
    1485                 :            :  * @return
    1486                 :            :  *   - 0: Success, DMA adapter stopped successfully.
    1487                 :            :  *   - <0: Error code returned by the driver function.
    1488                 :            :  */
    1489                 :            : typedef int (*eventdev_dma_adapter_stop_t)(const struct rte_eventdev *dev,
    1490                 :            :                                            const int16_t dma_dev_id);
    1491                 :            : 
    1492                 :            : struct rte_event_dma_adapter_stats;
    1493                 :            : 
    1494                 :            : /**
    1495                 :            :  * Retrieve DMA adapter statistics.
    1496                 :            :  *
    1497                 :            :  * @param dev
    1498                 :            :  *   Event device pointer
    1499                 :            :  *
    1500                 :            :  * @param dma_dev_id
    1501                 :            :  *   DMA device identifier
    1502                 :            :  *
    1503                 :            :  * @param[out] stats
    1504                 :            :  *   Pointer to stats structure
    1505                 :            :  *
    1506                 :            :  * @return
    1507                 :            :  *   Return 0 on success.
    1508                 :            :  */
    1509                 :            : typedef int (*eventdev_dma_adapter_stats_get)(const struct rte_eventdev *dev,
    1510                 :            :                                               const int16_t dma_dev_id,
    1511                 :            :                                               struct rte_event_dma_adapter_stats *stats);
    1512                 :            : 
    1513                 :            : /**
    1514                 :            :  * Reset DMA adapter statistics.
    1515                 :            :  *
    1516                 :            :  * @param dev
    1517                 :            :  *   Event device pointer
    1518                 :            :  *
    1519                 :            :  * @param dma_dev_id
    1520                 :            :  *   DMA device identifier
    1521                 :            :  *
    1522                 :            :  * @return
    1523                 :            :  *   Return 0 on success.
    1524                 :            :  */
    1525                 :            : typedef int (*eventdev_dma_adapter_stats_reset)(const struct rte_eventdev *dev,
    1526                 :            :                                                 const int16_t dma_dev_id);
    1527                 :            : 
    1528                 :            : 
    1529                 :            : /** Event device operations function pointer table */
    1530                 :            : struct eventdev_ops {
    1531                 :            :         eventdev_info_get_t dev_infos_get;      /**< Get device info. */
    1532                 :            :         eventdev_configure_t dev_configure;     /**< Configure device. */
    1533                 :            :         eventdev_start_t dev_start;             /**< Start device. */
    1534                 :            :         eventdev_stop_t dev_stop;               /**< Stop device. */
    1535                 :            :         eventdev_close_t dev_close;             /**< Close device. */
    1536                 :            : 
    1537                 :            :         eventdev_queue_default_conf_get_t queue_def_conf;
    1538                 :            :         /**< Get default queue configuration. */
    1539                 :            :         eventdev_queue_setup_t queue_setup;
    1540                 :            :         /**< Set up an event queue. */
    1541                 :            :         eventdev_queue_release_t queue_release;
    1542                 :            :         /**< Release an event queue. */
    1543                 :            :         eventdev_queue_attr_set_t queue_attr_set;
    1544                 :            :         /**< Set an event queue attribute. */
    1545                 :            : 
    1546                 :            :         eventdev_port_default_conf_get_t port_def_conf;
    1547                 :            :         /**< Get default port configuration. */
    1548                 :            :         eventdev_port_setup_t port_setup;
    1549                 :            :         /**< Set up an event port. */
    1550                 :            :         eventdev_port_release_t port_release;
    1551                 :            :         /**< Release an event port. */
    1552                 :            :         eventdev_port_quiesce_t port_quiesce;
    1553                 :            :         /**< Quiesce an event port. */
    1554                 :            : 
    1555                 :            :         eventdev_port_link_t port_link;
    1556                 :            :         /**< Link event queues to an event port. */
    1557                 :            :         eventdev_port_link_profile_t port_link_profile;
    1558                 :            :         /**< Link event queues associated with a profile to an event port. */
    1559                 :            :         eventdev_port_unlink_t port_unlink;
    1560                 :            :         /**< Unlink event queues from an event port. */
    1561                 :            :         eventdev_port_unlink_profile_t port_unlink_profile;
    1562                 :            :         /**< Unlink event queues associated with a profile from an event port. */
    1563                 :            :         eventdev_port_unlinks_in_progress_t port_unlinks_in_progress;
    1564                 :            :         /**< Unlinks in progress on an event port. */
    1565                 :            :         eventdev_dequeue_timeout_ticks_t timeout_ticks;
    1566                 :            :         /**< Converts ns to *timeout_ticks* value for rte_event_dequeue() */
    1567                 :            :         eventdev_dump_t dump;
    1568                 :            :         /* Dump internal information */
    1569                 :            : 
    1570                 :            :         eventdev_xstats_get_t xstats_get;
    1571                 :            :         /**< Get extended device statistics. */
    1572                 :            :         eventdev_xstats_get_names_t xstats_get_names;
    1573                 :            :         /**< Get names of extended stats. */
    1574                 :            :         eventdev_xstats_get_by_name xstats_get_by_name;
    1575                 :            :         /**< Get one value by name. */
    1576                 :            :         eventdev_xstats_reset_t xstats_reset;
    1577                 :            :         /**< Reset the statistics values in xstats. */
    1578                 :            : 
    1579                 :            :         eventdev_eth_rx_adapter_caps_get_t eth_rx_adapter_caps_get;
    1580                 :            :         /**< Get ethernet Rx adapter capabilities */
    1581                 :            :         eventdev_eth_rx_adapter_queue_add_t eth_rx_adapter_queue_add;
    1582                 :            :         /**< Add Rx queues to ethernet Rx adapter */
    1583                 :            :         eventdev_eth_rx_adapter_queue_del_t eth_rx_adapter_queue_del;
    1584                 :            :         /**< Delete Rx queues from ethernet Rx adapter */
    1585                 :            :         eventdev_eth_rx_adapter_queue_conf_get_t eth_rx_adapter_queue_conf_get;
    1586                 :            :         /**< Get Rx adapter queue info */
    1587                 :            :         eventdev_eth_rx_adapter_start_t eth_rx_adapter_start;
    1588                 :            :         /**< Start ethernet Rx adapter */
    1589                 :            :         eventdev_eth_rx_adapter_stop_t eth_rx_adapter_stop;
    1590                 :            :         /**< Stop ethernet Rx adapter */
    1591                 :            :         eventdev_eth_rx_adapter_stats_get eth_rx_adapter_stats_get;
    1592                 :            :         /**< Get ethernet Rx stats */
    1593                 :            :         eventdev_eth_rx_adapter_stats_reset eth_rx_adapter_stats_reset;
    1594                 :            :         /**< Reset ethernet Rx stats */
    1595                 :            :         eventdev_eth_rx_adapter_vector_limits_get_t
    1596                 :            :                 eth_rx_adapter_vector_limits_get;
    1597                 :            :         /**< Get event vector limits for the Rx adapter */
    1598                 :            :         eventdev_eth_rx_adapter_instance_get_t eth_rx_adapter_instance_get;
    1599                 :            :         /**< Get Rx adapter instance ID for Rx queue */
    1600                 :            : 
    1601                 :            :         eventdev_timer_adapter_caps_get_t timer_adapter_caps_get;
    1602                 :            :         /**< Get timer adapter capabilities */
    1603                 :            : 
    1604                 :            :         eventdev_crypto_adapter_caps_get_t crypto_adapter_caps_get;
    1605                 :            :         /**< Get crypto adapter capabilities */
    1606                 :            :         eventdev_crypto_adapter_queue_pair_add_t crypto_adapter_queue_pair_add;
    1607                 :            :         /**< Add queue pair to crypto adapter */
    1608                 :            :         eventdev_crypto_adapter_queue_pair_del_t crypto_adapter_queue_pair_del;
    1609                 :            :         /**< Delete queue pair from crypto adapter */
    1610                 :            :         eventdev_crypto_adapter_start_t crypto_adapter_start;
    1611                 :            :         /**< Start crypto adapter */
    1612                 :            :         eventdev_crypto_adapter_stop_t crypto_adapter_stop;
    1613                 :            :         /**< Stop crypto adapter */
    1614                 :            :         eventdev_crypto_adapter_stats_get crypto_adapter_stats_get;
    1615                 :            :         /**< Get crypto stats */
    1616                 :            :         eventdev_crypto_adapter_stats_reset crypto_adapter_stats_reset;
    1617                 :            :         /**< Reset crypto stats */
    1618                 :            :         eventdev_crypto_adapter_vector_limits_get_t
    1619                 :            :                 crypto_adapter_vector_limits_get;
    1620                 :            :         /**< Get event vector limits for the crypto adapter */
    1621                 :            : 
    1622                 :            :         eventdev_eth_rx_adapter_q_stats_get eth_rx_adapter_queue_stats_get;
    1623                 :            :         /**< Get ethernet Rx queue stats */
    1624                 :            :         eventdev_eth_rx_adapter_q_stats_reset eth_rx_adapter_queue_stats_reset;
    1625                 :            :         /**< Reset ethernet Rx queue stats */
    1626                 :            : 
    1627                 :            :         eventdev_eth_tx_adapter_caps_get_t eth_tx_adapter_caps_get;
    1628                 :            :         /**< Get ethernet Tx adapter capabilities */
    1629                 :            : 
    1630                 :            :         eventdev_eth_tx_adapter_create_t eth_tx_adapter_create;
    1631                 :            :         /**< Create adapter callback */
    1632                 :            :         eventdev_eth_tx_adapter_free_t eth_tx_adapter_free;
    1633                 :            :         /**< Free adapter callback */
    1634                 :            :         eventdev_eth_tx_adapter_queue_add_t eth_tx_adapter_queue_add;
    1635                 :            :         /**< Add Tx queues to the eth Tx adapter */
    1636                 :            :         eventdev_eth_tx_adapter_queue_del_t eth_tx_adapter_queue_del;
    1637                 :            :         /**< Delete Tx queues from the eth Tx adapter */
    1638                 :            :         eventdev_eth_tx_adapter_start_t eth_tx_adapter_start;
    1639                 :            :         /**< Start eth Tx adapter */
    1640                 :            :         eventdev_eth_tx_adapter_stop_t eth_tx_adapter_stop;
    1641                 :            :         /**< Stop eth Tx adapter */
    1642                 :            :         eventdev_eth_tx_adapter_stats_get_t eth_tx_adapter_stats_get;
    1643                 :            :         /**< Get eth Tx adapter statistics */
    1644                 :            :         eventdev_eth_tx_adapter_stats_reset_t eth_tx_adapter_stats_reset;
    1645                 :            :         /**< Reset eth Tx adapter statistics */
    1646                 :            :         eventdev_eth_tx_adapter_instance_get_t eth_tx_adapter_instance_get;
    1647                 :            :         /**< Get Tx adapter instance ID for Tx queue */
    1648                 :            :         eventdev_eth_tx_adapter_queue_start eth_tx_adapter_queue_start;
    1649                 :            :         /**< Start Tx queue assigned to Tx adapter instance */
    1650                 :            :         eventdev_eth_tx_adapter_queue_stop eth_tx_adapter_queue_stop;
    1651                 :            :         /**< Stop Tx queue assigned to Tx adapter instance */
    1652                 :            : 
    1653                 :            :         eventdev_dma_adapter_caps_get_t dma_adapter_caps_get;
    1654                 :            :         /**< Get DMA adapter capabilities */
    1655                 :            :         eventdev_dma_adapter_vchan_add_t dma_adapter_vchan_add;
    1656                 :            :         /**< Add vchan queue to DMA adapter */
    1657                 :            :         eventdev_dma_adapter_vchan_del_t dma_adapter_vchan_del;
    1658                 :            :         /**< Delete vchan queue from DMA adapter */
    1659                 :            :         eventdev_dma_adapter_start_t dma_adapter_start;
    1660                 :            :         /**< Start DMA adapter */
    1661                 :            :         eventdev_dma_adapter_stop_t dma_adapter_stop;
    1662                 :            :         /**< Stop DMA adapter */
    1663                 :            :         eventdev_dma_adapter_stats_get dma_adapter_stats_get;
    1664                 :            :         /**< Get DMA stats */
    1665                 :            :         eventdev_dma_adapter_stats_reset dma_adapter_stats_reset;
    1666                 :            :         /**< Reset DMA stats */
    1667                 :            : 
    1668                 :            :         eventdev_selftest dev_selftest;
    1669                 :            :         /**< Start eventdev Selftest */
    1670                 :            : 
    1671                 :            :         eventdev_stop_flush_t dev_stop_flush;
    1672                 :            :         /**< User-provided event flush function */
    1673                 :            : };
    1674                 :            : 
    1675                 :            : /**
    1676                 :            :  * Allocates a new eventdev slot for an event device and returns the pointer
    1677                 :            :  * to that slot for the driver to use.
    1678                 :            :  *
    1679                 :            :  * @param name
    1680                 :            :  *   Unique identifier name for each device
    1681                 :            :  * @param socket_id
    1682                 :            :  *   Socket to allocate resources on.
    1683                 :            :  * @return
    1684                 :            :  *   - Slot in the rte_dev_devices array for a new device;
    1685                 :            :  */
    1686                 :            : __rte_internal
    1687                 :            : struct rte_eventdev *
    1688                 :            : rte_event_pmd_allocate(const char *name, int socket_id);
    1689                 :            : 
    1690                 :            : /**
    1691                 :            :  * Release the specified eventdev device.
    1692                 :            :  *
    1693                 :            :  * @param eventdev
    1694                 :            :  * The *eventdev* pointer is the address of the *rte_eventdev* structure.
    1695                 :            :  * @return
    1696                 :            :  *   - 0 on success, negative on error
    1697                 :            :  */
    1698                 :            : __rte_internal
    1699                 :            : int
    1700                 :            : rte_event_pmd_release(struct rte_eventdev *eventdev);
    1701                 :            : 
    1702                 :            : /**
    1703                 :            :  *
    1704                 :            :  * @internal
    1705                 :            :  * This is the last step of device probing.
    1706                 :            :  * It must be called after a port is allocated and initialized successfully.
    1707                 :            :  *
    1708                 :            :  * @param eventdev
    1709                 :            :  *  New event device.
    1710                 :            :  */
    1711                 :            : __rte_internal
    1712                 :            : void
    1713                 :            : event_dev_probing_finish(struct rte_eventdev *eventdev);
    1714                 :            : 
    1715                 :            : /**
    1716                 :            :  * Reset eventdevice fastpath APIs to dummy values.
    1717                 :            :  *
    1718                 :            :  * @param fp_ops
    1719                 :            :  * The *fp_ops* pointer to reset.
    1720                 :            :  */
    1721                 :            : __rte_internal
    1722                 :            : void
    1723                 :            : event_dev_fp_ops_reset(struct rte_event_fp_ops *fp_op);
    1724                 :            : 
    1725                 :            : /**
    1726                 :            :  * Set eventdevice fastpath APIs to event device values.
    1727                 :            :  *
    1728                 :            :  * @param fp_ops
    1729                 :            :  * The *fp_ops* pointer to set.
    1730                 :            :  */
    1731                 :            : __rte_internal
    1732                 :            : void
    1733                 :            : event_dev_fp_ops_set(struct rte_event_fp_ops *fp_ops,
    1734                 :            :                      const struct rte_eventdev *dev);
    1735                 :            : 
    1736                 :            : #ifdef __cplusplus
    1737                 :            : }
    1738                 :            : #endif
    1739                 :            : 
    1740                 :            : #endif /* _RTE_EVENTDEV_PMD_H_ */

Generated by: LCOV version 1.14