LCOV - code coverage report
Current view: top level - lib/eventdev - rte_event_eth_tx_adapter.h (source / functions) Hit Total Coverage
Test: Code coverage Lines: 2 10 20.0 %
Date: 2024-02-14 00:53:57 Functions: 0 1 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 1 6 16.7 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2018 Intel Corporation.
       3                 :            :  */
       4                 :            : 
       5                 :            : #ifndef _RTE_EVENT_ETH_TX_ADAPTER_
       6                 :            : #define _RTE_EVENT_ETH_TX_ADAPTER_
       7                 :            : 
       8                 :            : /**
       9                 :            :  * @file
      10                 :            :  *
      11                 :            :  * RTE Event Ethernet Tx Adapter
      12                 :            :  *
      13                 :            :  * The event ethernet Tx adapter provides configuration and data path APIs
      14                 :            :  * for the ethernet transmit stage of an event driven packet processing
      15                 :            :  * application. These APIs abstract the implementation of the transmit stage
      16                 :            :  * and allow the application to use eventdev PMD support or a common
      17                 :            :  * implementation.
      18                 :            :  *
      19                 :            :  * In the common implementation, the application enqueues mbufs to the adapter
      20                 :            :  * which runs as a rte_service function. The service function dequeues events
      21                 :            :  * from its event port and transmits the mbufs referenced by these events.
      22                 :            :  *
      23                 :            :  * The ethernet Tx event adapter APIs are:
      24                 :            :  *
      25                 :            :  *  - rte_event_eth_tx_adapter_create()
      26                 :            :  *  - rte_event_eth_tx_adapter_create_ext()
      27                 :            :  *  - rte_event_eth_tx_adapter_free()
      28                 :            :  *  - rte_event_eth_tx_adapter_start()
      29                 :            :  *  - rte_event_eth_tx_adapter_stop()
      30                 :            :  *  - rte_event_eth_tx_adapter_queue_add()
      31                 :            :  *  - rte_event_eth_tx_adapter_queue_del()
      32                 :            :  *  - rte_event_eth_tx_adapter_stats_get()
      33                 :            :  *  - rte_event_eth_tx_adapter_stats_reset()
      34                 :            :  *  - rte_event_eth_tx_adapter_enqueue()
      35                 :            :  *  - rte_event_eth_tx_adapter_event_port_get()
      36                 :            :  *  - rte_event_eth_tx_adapter_service_id_get()
      37                 :            :  *  - rte_event_eth_tx_adapter_instance_get()
      38                 :            :  *  - rte_event_eth_tx_adapter_queue_start()
      39                 :            :  *  - rte_event_eth_tx_adapter_queue_stop()
      40                 :            :  *  - rte_event_eth_tx_adapter_runtime_params_get()
      41                 :            :  *  - rte_event_eth_tx_adapter_runtime_params_init()
      42                 :            :  *  - rte_event_eth_tx_adapter_runtime_params_set()
      43                 :            :  *
      44                 :            :  * The application creates the adapter using
      45                 :            :  * rte_event_eth_tx_adapter_create() or rte_event_eth_tx_adapter_create_ext().
      46                 :            :  *
      47                 :            :  * The adapter will use the common implementation when the eventdev PMD
      48                 :            :  * does not have the #RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT capability.
      49                 :            :  * The common implementation uses an event port that is created using the port
      50                 :            :  * configuration parameter passed to rte_event_eth_tx_adapter_create(). The
      51                 :            :  * application can get the port identifier using
      52                 :            :  * rte_event_eth_tx_adapter_event_port_get() and must link an event queue to
      53                 :            :  * this port.
      54                 :            :  *
      55                 :            :  * If the eventdev PMD has the #RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT
      56                 :            :  * flags set, Tx adapter events should be enqueued using the
      57                 :            :  * rte_event_eth_tx_adapter_enqueue() function, else the application should
      58                 :            :  * use rte_event_enqueue_burst().
      59                 :            :  *
      60                 :            :  * Transmit queues can be added and deleted from the adapter using
      61                 :            :  * rte_event_eth_tx_adapter_queue_add()/del() APIs respectively.
      62                 :            :  *
      63                 :            :  * The application can start and stop the adapter using the
      64                 :            :  * rte_event_eth_tx_adapter_start/stop() calls.
      65                 :            :  *
      66                 :            :  * The common adapter implementation uses an EAL service function as described
      67                 :            :  * before and its execution is controlled using the rte_service APIs. The
      68                 :            :  * rte_event_eth_tx_adapter_service_id_get()
      69                 :            :  * function can be used to retrieve the adapter's service function ID.
      70                 :            :  *
      71                 :            :  * The ethernet port and transmit queue index to transmit the mbuf on are
      72                 :            :  * specified using the mbuf port struct rte_mbuf::hash::txadapter:txq.
      73                 :            :  * The application should use the rte_event_eth_tx_adapter_txq_set()
      74                 :            :  * and rte_event_eth_tx_adapter_txq_get() functions to access the transmit
      75                 :            :  * queue index, using these macros will help with minimizing application
      76                 :            :  * impact due to a change in how the transmit queue index is specified.
      77                 :            :  */
      78                 :            : 
      79                 :            : #ifdef __cplusplus
      80                 :            : extern "C" {
      81                 :            : #endif
      82                 :            : 
      83                 :            : #include <stdint.h>
      84                 :            : 
      85                 :            : #include <rte_compat.h>
      86                 :            : #include <rte_mbuf.h>
      87                 :            : 
      88                 :            : #include "rte_eventdev.h"
      89                 :            : 
      90                 :            : /**
      91                 :            :  * Adapter configuration structure
      92                 :            :  *
      93                 :            :  * @see rte_event_eth_tx_adapter_create_ext
      94                 :            :  * @see rte_event_eth_tx_adapter_conf_cb
      95                 :            :  */
      96                 :            : struct rte_event_eth_tx_adapter_conf {
      97                 :            :         uint8_t event_port_id;
      98                 :            :         /**< Event port identifier, the adapter service function dequeues mbuf
      99                 :            :          * events from this port.
     100                 :            :          * @see RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT
     101                 :            :          */
     102                 :            :         uint32_t max_nb_tx;
     103                 :            :         /**< The adapter can return early if it has processed at least
     104                 :            :          * max_nb_tx mbufs. This isn't treated as a requirement; batching may
     105                 :            :          * cause the adapter to process more than max_nb_tx mbufs.
     106                 :            :          */
     107                 :            : };
     108                 :            : 
     109                 :            : /**
     110                 :            :  * Adapter runtime configuration parameters
     111                 :            :  */
     112                 :            : struct rte_event_eth_tx_adapter_runtime_params {
     113                 :            :         uint32_t max_nb_tx;
     114                 :            :         /**< The adapter can return early if it has processed at least
     115                 :            :          * max_nb_tx mbufs. This isn't treated as a requirement; batching may
     116                 :            :          * cause the adapter to process more than max_nb_tx mbufs.
     117                 :            :          *
     118                 :            :          * rte_event_eth_tx_adapter_create() configures the
     119                 :            :          * adapter with default value of max_nb_tx.
     120                 :            :          * rte_event_eth_tx_adapter_create_ext() configures the adapter with
     121                 :            :          * user provided value of max_nb_tx through
     122                 :            :          * rte_event_eth_tx_adapter_conf::max_nb_tx parameter.
     123                 :            :          * rte_event_eth_tx_adapter_runtime_params_set() allows to re-configure
     124                 :            :          * max_nb_tx during runtime (after adding at least one queue)
     125                 :            :          *
     126                 :            :          * This is valid for the devices without
     127                 :            :          * RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT capability.
     128                 :            :          */
     129                 :            :         uint16_t flush_threshold;
     130                 :            :         /**< the number of service function iteration count to
     131                 :            :          * flush buffered packets.
     132                 :            :          *
     133                 :            :          * This is valid for the devices without
     134                 :            :          * RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT capability.
     135                 :            :          */
     136                 :            :         uint16_t rsvd[29];
     137                 :            :         /**< Reserved fields for future expansion */
     138                 :            : };
     139                 :            : 
     140                 :            : /**
     141                 :            :  * Function type used for adapter configuration callback. The callback is
     142                 :            :  * used to fill in members of the struct rte_event_eth_tx_adapter_conf, this
     143                 :            :  * callback is invoked when creating a RTE service function based
     144                 :            :  * adapter implementation.
     145                 :            :  *
     146                 :            :  * @param id
     147                 :            :  *  Adapter identifier.
     148                 :            :  * @param dev_id
     149                 :            :  *  Event device identifier.
     150                 :            :  * @param [out] conf
     151                 :            :  *  Structure that needs to be populated by this callback.
     152                 :            :  * @param arg
     153                 :            :  *  Argument to the callback. This is the same as the conf_arg passed to the
     154                 :            :  *  rte_event_eth_tx_adapter_create_ext().
     155                 :            :  *
     156                 :            :  * @return
     157                 :            :  *   - 0: Success
     158                 :            :  *   - <0: Error code on failure
     159                 :            :  */
     160                 :            : typedef int (*rte_event_eth_tx_adapter_conf_cb) (uint8_t id, uint8_t dev_id,
     161                 :            :                                 struct rte_event_eth_tx_adapter_conf *conf,
     162                 :            :                                 void *arg);
     163                 :            : 
     164                 :            : /**
     165                 :            :  * A structure used to retrieve statistics for an ethernet Tx adapter instance.
     166                 :            :  */
     167                 :            : struct rte_event_eth_tx_adapter_stats {
     168                 :            :         uint64_t tx_retry;
     169                 :            :         /**< Number of transmit retries */
     170                 :            :         uint64_t tx_packets;
     171                 :            :         /**< Number of packets transmitted */
     172                 :            :         uint64_t tx_dropped;
     173                 :            :         /**< Number of packets dropped */
     174                 :            : };
     175                 :            : 
     176                 :            : /**
     177                 :            :  * Create a new ethernet Tx adapter with the specified identifier.
     178                 :            :  *
     179                 :            :  * When this API is used for creating adapter instance,
     180                 :            :  * ``rte_event_dev_config::nb_event_ports`` is automatically incremented,
     181                 :            :  * and event device is reconfigured with additional event port during service
     182                 :            :  * initialization. This event device reconfigure logic also increments the
     183                 :            :  * ``rte_event_dev_config::nb_single_link_event_port_queues``
     184                 :            :  * parameter if the adapter event port config is of type
     185                 :            :  * ``RTE_EVENT_PORT_CFG_SINGLE_LINK``.
     186                 :            :  *
     187                 :            :  * Application no longer needs to account for the
     188                 :            :  * ``rte_event_dev_config::nb_event_ports`` and
     189                 :            :  * ``rte_event_dev_config::nb_single_link_event_port_queues``
     190                 :            :  * parameters required for eth Tx adapter in event device configure when
     191                 :            :  * the adapter is created with this API.
     192                 :            :  *
     193                 :            :  * @param id
     194                 :            :  *  The identifier of the ethernet Tx adapter.
     195                 :            :  * @param dev_id
     196                 :            :  *  The event device identifier.
     197                 :            :  * @param port_config
     198                 :            :  *  Event port configuration, the adapter uses this configuration to
     199                 :            :  *  create an event port if needed.
     200                 :            :  * @return
     201                 :            :  *   - 0: Success
     202                 :            :  *   - <0: Error code on failure
     203                 :            :  */
     204                 :            : int
     205                 :            : rte_event_eth_tx_adapter_create(uint8_t id, uint8_t dev_id,
     206                 :            :                                 struct rte_event_port_conf *port_config);
     207                 :            : 
     208                 :            : /**
     209                 :            :  * Create a new ethernet Tx adapter with the specified identifier.
     210                 :            :  *
     211                 :            :  * @param id
     212                 :            :  *  The identifier of the ethernet Tx adapter.
     213                 :            :  * @param dev_id
     214                 :            :  *  The event device identifier.
     215                 :            :  * @param conf_cb
     216                 :            :  *  Callback function that initializes members of the
     217                 :            :  *  struct rte_event_eth_tx_adapter_conf struct passed into
     218                 :            :  *  it.
     219                 :            :  * @param conf_arg
     220                 :            :  *  Argument that is passed to the conf_cb function.
     221                 :            :  * @return
     222                 :            :  *   - 0: Success
     223                 :            :  *   - <0: Error code on failure
     224                 :            :  */
     225                 :            : int
     226                 :            : rte_event_eth_tx_adapter_create_ext(uint8_t id, uint8_t dev_id,
     227                 :            :                                 rte_event_eth_tx_adapter_conf_cb conf_cb,
     228                 :            :                                 void *conf_arg);
     229                 :            : 
     230                 :            : /**
     231                 :            :  * Free an ethernet Tx adapter
     232                 :            :  *
     233                 :            :  * @param id
     234                 :            :  *  Adapter identifier.
     235                 :            :  * @return
     236                 :            :  *   - 0: Success
     237                 :            :  *   - <0: Error code on failure, If the adapter still has Tx queues
     238                 :            :  *      added to it, the function returns -EBUSY.
     239                 :            :  */
     240                 :            : int
     241                 :            : rte_event_eth_tx_adapter_free(uint8_t id);
     242                 :            : 
     243                 :            : /**
     244                 :            :  * Start ethernet Tx adapter
     245                 :            :  *
     246                 :            :  * @param id
     247                 :            :  *  Adapter identifier.
     248                 :            :  * @return
     249                 :            :  *  - 0: Success, Adapter started correctly.
     250                 :            :  *  - <0: Error code on failure.
     251                 :            :  */
     252                 :            : int
     253                 :            : rte_event_eth_tx_adapter_start(uint8_t id);
     254                 :            : 
     255                 :            : /**
     256                 :            :  * Stop ethernet Tx adapter
     257                 :            :  *
     258                 :            :  * @param id
     259                 :            :  *  Adapter identifier.
     260                 :            :  * @return
     261                 :            :  *  - 0: Success.
     262                 :            :  *  - <0: Error code on failure.
     263                 :            :  */
     264                 :            : int
     265                 :            : rte_event_eth_tx_adapter_stop(uint8_t id);
     266                 :            : 
     267                 :            : /**
     268                 :            :  * Add a Tx queue to the adapter.
     269                 :            :  * A queue value of -1 is used to indicate all
     270                 :            :  * queues within the device.
     271                 :            :  *
     272                 :            :  * @param id
     273                 :            :  *  Adapter identifier.
     274                 :            :  * @param eth_dev_id
     275                 :            :  *  Ethernet Port Identifier.
     276                 :            :  * @param queue
     277                 :            :  *  Tx queue index.
     278                 :            :  * @return
     279                 :            :  *  - 0: Success, Queues added successfully.
     280                 :            :  *  - <0: Error code on failure.
     281                 :            :  */
     282                 :            : int
     283                 :            : rte_event_eth_tx_adapter_queue_add(uint8_t id,
     284                 :            :                                 uint16_t eth_dev_id,
     285                 :            :                                 int32_t queue);
     286                 :            : 
     287                 :            : /**
     288                 :            :  * Delete a Tx queue from the adapter.
     289                 :            :  * A queue value of -1 is used to indicate all
     290                 :            :  * queues within the device, that have been added to this
     291                 :            :  * adapter.
     292                 :            :  *
     293                 :            :  * @param id
     294                 :            :  *  Adapter identifier.
     295                 :            :  * @param eth_dev_id
     296                 :            :  *  Ethernet Port Identifier.
     297                 :            :  * @param queue
     298                 :            :  *  Tx queue index.
     299                 :            :  * @return
     300                 :            :  *  - 0: Success, Queues deleted successfully.
     301                 :            :  *  - <0: Error code on failure.
     302                 :            :  */
     303                 :            : int
     304                 :            : rte_event_eth_tx_adapter_queue_del(uint8_t id,
     305                 :            :                                 uint16_t eth_dev_id,
     306                 :            :                                 int32_t queue);
     307                 :            : 
     308                 :            : /**
     309                 :            :  * Set Tx queue in the mbuf. This queue is used by the adapter
     310                 :            :  * to transmit the mbuf.
     311                 :            :  *
     312                 :            :  * @param pkt
     313                 :            :  *  Pointer to the mbuf.
     314                 :            :  * @param queue
     315                 :            :  *  Tx queue index.
     316                 :            :  */
     317                 :            : static __rte_always_inline void
     318                 :            : rte_event_eth_tx_adapter_txq_set(struct rte_mbuf *pkt, uint16_t queue)
     319                 :            : {
     320                 :       4096 :         pkt->hash.txadapter.txq = queue;
     321                 :          0 : }
     322                 :            : 
     323                 :            : /**
     324                 :            :  * Retrieve Tx queue from the mbuf.
     325                 :            :  *
     326                 :            :  * @param pkt
     327                 :            :  *  Pointer to the mbuf.
     328                 :            :  * @return
     329                 :            :  *  Tx queue identifier.
     330                 :            :  *
     331                 :            :  * @see rte_event_eth_tx_adapter_txq_set()
     332                 :            :  */
     333                 :            : static __rte_always_inline uint16_t
     334                 :            : rte_event_eth_tx_adapter_txq_get(struct rte_mbuf *pkt)
     335                 :            : {
     336   [ +  -  -  - ]:       4096 :         return pkt->hash.txadapter.txq;
     337                 :            : }
     338                 :            : 
     339                 :            : /**
     340                 :            :  * Retrieve the adapter event port. The adapter creates an event port if
     341                 :            :  * the #RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT is not set in the
     342                 :            :  * ethernet Tx capabilities of the event device.
     343                 :            :  *
     344                 :            :  * @param id
     345                 :            :  *  Adapter Identifier.
     346                 :            :  * @param[out] event_port_id
     347                 :            :  *  Event port pointer.
     348                 :            :  * @return
     349                 :            :  *   - 0: Success.
     350                 :            :  *   - <0: Error code on failure.
     351                 :            :  */
     352                 :            : int
     353                 :            : rte_event_eth_tx_adapter_event_port_get(uint8_t id, uint8_t *event_port_id);
     354                 :            : 
     355                 :            : #define RTE_EVENT_ETH_TX_ADAPTER_ENQUEUE_SAME_DEST      0x1
     356                 :            : /**< This flag is used when all the packets enqueued in the tx adapter are
     357                 :            :  * destined for the same Ethernet port & Tx queue.
     358                 :            :  */
     359                 :            : 
     360                 :            : /**
     361                 :            :  * Enqueue a burst of events objects or an event object supplied in *rte_event*
     362                 :            :  * structure on an  event device designated by its *dev_id* through the event
     363                 :            :  * port specified by *port_id*. This function is supported if the eventdev PMD
     364                 :            :  * has the #RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT capability flag set.
     365                 :            :  *
     366                 :            :  * The *nb_events* parameter is the number of event objects to enqueue which are
     367                 :            :  * supplied in the *ev* array of *rte_event* structure.
     368                 :            :  *
     369                 :            :  * The rte_event_eth_tx_adapter_enqueue() function returns the number of
     370                 :            :  * events objects it actually enqueued. A return value equal to *nb_events*
     371                 :            :  * means that all event objects have been enqueued.
     372                 :            :  *
     373                 :            :  * @param dev_id
     374                 :            :  *  The identifier of the device.
     375                 :            :  * @param port_id
     376                 :            :  *  The identifier of the event port.
     377                 :            :  * @param ev
     378                 :            :  *  Points to an array of *nb_events* objects of type *rte_event* structure
     379                 :            :  *  which contain the event object enqueue operations to be processed.
     380                 :            :  * @param nb_events
     381                 :            :  *  The number of event objects to enqueue, typically number of
     382                 :            :  *  rte_event_port_attr_get(...RTE_EVENT_PORT_ATTR_ENQ_DEPTH...)
     383                 :            :  *  available for this port.
     384                 :            :  * @param flags
     385                 :            :  *  RTE_EVENT_ETH_TX_ADAPTER_ENQUEUE_ flags.
     386                 :            :  *  #RTE_EVENT_ETH_TX_ADAPTER_ENQUEUE_SAME_DEST signifies that all the packets
     387                 :            :  *  which are enqueued are destined for the same Ethernet port & Tx queue.
     388                 :            :  *
     389                 :            :  * @return
     390                 :            :  *   The number of event objects actually enqueued on the event device. The
     391                 :            :  *   return value can be less than the value of the *nb_events* parameter when
     392                 :            :  *   the event devices queue is full or if invalid parameters are specified in a
     393                 :            :  *   *rte_event*. If the return value is less than *nb_events*, the remaining
     394                 :            :  *   events at the end of ev[] are not consumed and the caller has to take care
     395                 :            :  *   of them, and rte_errno is set accordingly. Possible errno values include:
     396                 :            :  *   - EINVAL   The port ID is invalid, device ID is invalid, an event's queue
     397                 :            :  *              ID is invalid, or an event's sched type doesn't match the
     398                 :            :  *              capabilities of the destination queue.
     399                 :            :  *   - ENOSPC   The event port was backpressured and unable to enqueue
     400                 :            :  *              one or more events. This error code is only applicable to
     401                 :            :  *              closed systems.
     402                 :            :  */
     403                 :            : static inline uint16_t
     404                 :          0 : rte_event_eth_tx_adapter_enqueue(uint8_t dev_id,
     405                 :            :                                 uint8_t port_id,
     406                 :            :                                 struct rte_event ev[],
     407                 :            :                                 uint16_t nb_events,
     408                 :            :                                 const uint8_t flags)
     409                 :            : {
     410                 :            :         const struct rte_event_fp_ops *fp_ops;
     411                 :            :         void *port;
     412                 :            : 
     413                 :          0 :         fp_ops = &rte_event_fp_ops[dev_id];
     414                 :          0 :         port = fp_ops->data[port_id];
     415                 :            : #ifdef RTE_LIBRTE_EVENTDEV_DEBUG
     416                 :            :         if (dev_id >= RTE_EVENT_MAX_DEVS ||
     417                 :            :             port_id >= RTE_EVENT_MAX_PORTS_PER_DEV) {
     418                 :            :                 rte_errno = EINVAL;
     419                 :            :                 return 0;
     420                 :            :         }
     421                 :            : 
     422                 :            :         if (port == NULL) {
     423                 :            :                 rte_errno = EINVAL;
     424                 :            :                 return 0;
     425                 :            :         }
     426                 :            : #endif
     427                 :          0 :         rte_eventdev_trace_eth_tx_adapter_enqueue(dev_id, port_id, ev,
     428                 :            :                 nb_events, flags);
     429         [ #  # ]:          0 :         if (flags)
     430                 :          0 :                 return fp_ops->txa_enqueue_same_dest(port, ev, nb_events);
     431                 :            :         else
     432                 :          0 :                 return fp_ops->txa_enqueue(port, ev, nb_events);
     433                 :            : }
     434                 :            : 
     435                 :            : /**
     436                 :            :  * Retrieve statistics for an adapter
     437                 :            :  *
     438                 :            :  * @param id
     439                 :            :  *  Adapter identifier.
     440                 :            :  * @param [out] stats
     441                 :            :  *  A pointer to structure used to retrieve statistics for an adapter.
     442                 :            :  * @return
     443                 :            :  *  - 0: Success, statistics retrieved successfully.
     444                 :            :  *  - <0: Error code on failure.
     445                 :            :  */
     446                 :            : int
     447                 :            : rte_event_eth_tx_adapter_stats_get(uint8_t id,
     448                 :            :                                 struct rte_event_eth_tx_adapter_stats *stats);
     449                 :            : 
     450                 :            : /**
     451                 :            :  * Reset statistics for an adapter.
     452                 :            :  *
     453                 :            :  * @param id
     454                 :            :  *  Adapter identifier.
     455                 :            :  * @return
     456                 :            :  *  - 0: Success, statistics reset successfully.
     457                 :            :  *  - <0: Error code on failure.
     458                 :            :  */
     459                 :            : int
     460                 :            : rte_event_eth_tx_adapter_stats_reset(uint8_t id);
     461                 :            : 
     462                 :            : /**
     463                 :            :  * Retrieve the service ID of an adapter. If the adapter doesn't use
     464                 :            :  * a rte_service function, this function returns -ESRCH.
     465                 :            :  *
     466                 :            :  * @param id
     467                 :            :  *  Adapter identifier.
     468                 :            :  * @param [out] service_id
     469                 :            :  *  A pointer to a uint32_t, to be filled in with the service id.
     470                 :            :  * @return
     471                 :            :  *  - 0: Success
     472                 :            :  *  - <0: Error code on failure, if the adapter doesn't use a rte_service
     473                 :            :  * function, this function returns -ESRCH.
     474                 :            :  */
     475                 :            : int
     476                 :            : rte_event_eth_tx_adapter_service_id_get(uint8_t id, uint32_t *service_id);
     477                 :            : 
     478                 :            : /**
     479                 :            :  * Get TX adapter instance id for TX queue
     480                 :            :  *
     481                 :            :  * @param eth_dev_id
     482                 :            :  *  Port identifier of Ethernet device
     483                 :            :  *
     484                 :            :  * @param tx_queue_id
     485                 :            :  *  Etherdev device TX queue index
     486                 :            :  *
     487                 :            :  * @param[out] txa_inst_id
     488                 :            :  *  Pointer to TX adapter instance identifier
     489                 :            :  *  Contains valid Tx adapter instance id when return value is 0
     490                 :            :  *
     491                 :            :  * @return
     492                 :            :  *  -  0: Success
     493                 :            :  *  - <0: Error code on failure
     494                 :            :  */
     495                 :            : int
     496                 :            : rte_event_eth_tx_adapter_instance_get(uint16_t eth_dev_id,
     497                 :            :                                       uint16_t tx_queue_id,
     498                 :            :                                       uint8_t *txa_inst_id);
     499                 :            : /**
     500                 :            :  * Enables the adapter to start enqueueing of packets to the
     501                 :            :  * Tx queue.
     502                 :            :  *
     503                 :            :  * This function is provided so that the application can
     504                 :            :  * resume enqueueing packets that reference packets for
     505                 :            :  * <eth_dev_id, tx_queue_id> after calling
     506                 :            :  * rte_event_eth_tx_adapter_queue_stop().
     507                 :            :  * @see rte_event_eth_tx_adapter_queue_stop
     508                 :            :  *
     509                 :            :  * Use case:
     510                 :            :  * --------
     511                 :            :  * The queue start/stop APIs help avoid some unexpected behavior with
     512                 :            :  * application stopping ethdev Tx queues and adapter being unaware of it.
     513                 :            :  * With these APIs, the application can call stop API to notify adapter
     514                 :            :  * that corresponding ethdev Tx queue is stopped and any in-flight
     515                 :            :  * packets are freed by adapter dataplane code. Adapter queue stop API
     516                 :            :  * is called before stopping the ethdev Tx queue. When ethdev Tx queue
     517                 :            :  * is enabled, application can notify adapter to resume processing of
     518                 :            :  * the packets for that queue by calling the start API. The ethdev Tx
     519                 :            :  * queue is started before calling adapter start API.
     520                 :            :  *
     521                 :            :  * @param eth_dev_id
     522                 :            :  *  Port identifier of Ethernet device.
     523                 :            :  * @param tx_queue_id
     524                 :            :  *  Ethernet device transmit queue index.
     525                 :            :  * @return
     526                 :            :  *   - 0: Success
     527                 :            :  *   - <0: Error code on failure
     528                 :            :  */
     529                 :            : int
     530                 :            : rte_event_eth_tx_adapter_queue_start(uint16_t eth_dev_id, uint16_t tx_queue_id);
     531                 :            : 
     532                 :            : /**
     533                 :            :  * Stops the adapter runtime function from enqueueing any packets
     534                 :            :  * to the associated Tx queue. This API also frees any packets that may
     535                 :            :  * have been buffered for this queue. All inflight packets destined to the
     536                 :            :  * queue are freed by the adapter runtime until the queue is started again.
     537                 :            :  * @see rte_event_eth_tx_adapter_queue_start
     538                 :            :  *
     539                 :            :  * @param eth_dev_id
     540                 :            :  *  Port identifier of Ethernet device.
     541                 :            :  * @param tx_queue_id
     542                 :            :  *  Ethernet device transmit queue index.
     543                 :            :  * @return
     544                 :            :  *   - 0: Success
     545                 :            :  *   - <0: Error code on failure
     546                 :            :  */
     547                 :            : int
     548                 :            : rte_event_eth_tx_adapter_queue_stop(uint16_t eth_dev_id, uint16_t tx_queue_id);
     549                 :            : 
     550                 :            : /**
     551                 :            :  * Initialize the adapter runtime configuration parameters with default values
     552                 :            :  *
     553                 :            :  * @param txa_params
     554                 :            :  *  A pointer to structure of type struct rte_event_eth_tx_adapter_runtime_params
     555                 :            :  *
     556                 :            :  * @return
     557                 :            :  *  -  0: Success
     558                 :            :  *  - <0: Error code on failure
     559                 :            :  */
     560                 :            : __rte_experimental
     561                 :            : int
     562                 :            : rte_event_eth_tx_adapter_runtime_params_init(
     563                 :            :                 struct rte_event_eth_tx_adapter_runtime_params *txa_params);
     564                 :            : 
     565                 :            : /**
     566                 :            :  * Set the runtime configuration parameters for adapter.
     567                 :            :  *
     568                 :            :  * @param id
     569                 :            :  *  Adapter identifier
     570                 :            :  * @param params
     571                 :            :  *  A pointer to structure of type struct rte_event_eth_tx_adapter_runtime_params
     572                 :            :  *  with configuration parameter values. The reserved fields of this structure
     573                 :            :  *  must be initialized to zero and the valid fields need to be set appropriately.
     574                 :            :  *  This structure can be initialized using
     575                 :            :  *  rte_event_eth_tx_adapter_runtime_params_init() API to default values or
     576                 :            :  *  application may reset this structure and update required fields.
     577                 :            :  *
     578                 :            :  * @return
     579                 :            :  * -  0: Success
     580                 :            :  * - <0: Error code on failure
     581                 :            :  */
     582                 :            : __rte_experimental
     583                 :            : int
     584                 :            : rte_event_eth_tx_adapter_runtime_params_set(uint8_t id,
     585                 :            :                 struct rte_event_eth_tx_adapter_runtime_params *params);
     586                 :            : 
     587                 :            : /**
     588                 :            :  * Get the runtime configuration parameters of adapter.
     589                 :            :  *
     590                 :            :  * @param id
     591                 :            :  *  Adapter identifier
     592                 :            :  * @param[out] params
     593                 :            :  *  A pointer to structure of type struct rte_event_eth_tx_adapter_runtime_params
     594                 :            :  *  containing valid Tx adapter parameters when return value is 0.
     595                 :            :  *
     596                 :            :  * @return
     597                 :            :  * -  0: Success
     598                 :            :  * - <0: Error code on failure
     599                 :            :  */
     600                 :            : __rte_experimental
     601                 :            : int
     602                 :            : rte_event_eth_tx_adapter_runtime_params_get(uint8_t id,
     603                 :            :                 struct rte_event_eth_tx_adapter_runtime_params *params);
     604                 :            : 
     605                 :            : #ifdef __cplusplus
     606                 :            : }
     607                 :            : #endif
     608                 :            : #endif  /* _RTE_EVENT_ETH_TX_ADAPTER_ */

Generated by: LCOV version 1.14