rte_event_eth_tx_adapter.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2018 Intel Corporation.
 */

#ifndef _RTE_EVENT_ETH_TX_ADAPTER_
#define _RTE_EVENT_ETH_TX_ADAPTER_

#ifdef __cplusplus
extern "C" {
#endif

#include <stdint.h>

#include <rte_compat.h>
#include <rte_mbuf.h>

#include "rte_eventdev.h"

struct rte_event_eth_tx_adapter_conf {
    uint8_t event_port_id;
    uint32_t max_nb_tx;
};

struct rte_event_eth_tx_adapter_runtime_params {
    uint32_t max_nb_tx;
    uint16_t flush_threshold;
    uint16_t rsvd[29];
};

typedef int (*rte_event_eth_tx_adapter_conf_cb) (uint8_t id, uint8_t dev_id,
                struct rte_event_eth_tx_adapter_conf *conf,
                void *arg);

struct rte_event_eth_tx_adapter_stats {
    uint64_t tx_retry;
    uint64_t tx_packets;
    uint64_t tx_dropped;
};

int
rte_event_eth_tx_adapter_create(uint8_t id, uint8_t dev_id,
                struct rte_event_port_conf *port_config);

int
rte_event_eth_tx_adapter_create_ext(uint8_t id, uint8_t dev_id,
                rte_event_eth_tx_adapter_conf_cb conf_cb,
                void *conf_arg);

int
rte_event_eth_tx_adapter_free(uint8_t id);

int
rte_event_eth_tx_adapter_start(uint8_t id);

int
rte_event_eth_tx_adapter_stop(uint8_t id);

int
rte_event_eth_tx_adapter_queue_add(uint8_t id,
                uint16_t eth_dev_id,
                int32_t queue);

int
rte_event_eth_tx_adapter_queue_del(uint8_t id,
                uint16_t eth_dev_id,
                int32_t queue);

static __rte_always_inline void
rte_event_eth_tx_adapter_txq_set(struct rte_mbuf *pkt, uint16_t queue)
{
    pkt->hash.txadapter.txq = queue;
}

static __rte_always_inline uint16_t
rte_event_eth_tx_adapter_txq_get(struct rte_mbuf *pkt)
{
    return pkt->hash.txadapter.txq;
}

int
rte_event_eth_tx_adapter_event_port_get(uint8_t id, uint8_t *event_port_id);

#define RTE_EVENT_ETH_TX_ADAPTER_ENQUEUE_SAME_DEST  0x1

static inline uint16_t
rte_event_eth_tx_adapter_enqueue(uint8_t dev_id,
                uint8_t port_id,
                struct rte_event ev[],
                uint16_t nb_events,
                const uint8_t flags)
{
    const struct rte_event_fp_ops *fp_ops;
    void *port;

    fp_ops = &rte_event_fp_ops[dev_id];
    port = fp_ops->data[port_id];
#ifdef RTE_LIBRTE_EVENTDEV_DEBUG
    if (dev_id >= RTE_EVENT_MAX_DEVS ||
        port_id >= RTE_EVENT_MAX_PORTS_PER_DEV) {
        rte_errno = EINVAL;
        return 0;
    }

    if (port == NULL) {
        rte_errno = EINVAL;
        return 0;
    }
#endif
    rte_eventdev_trace_eth_tx_adapter_enqueue(dev_id, port_id, ev,
        nb_events, flags);
    if (flags)
        return fp_ops->txa_enqueue_same_dest(port, ev, nb_events);
    else
        return fp_ops->txa_enqueue(port, ev, nb_events);
}

int
rte_event_eth_tx_adapter_stats_get(uint8_t id,
                struct rte_event_eth_tx_adapter_stats *stats);

int
rte_event_eth_tx_adapter_stats_reset(uint8_t id);

int
rte_event_eth_tx_adapter_service_id_get(uint8_t id, uint32_t *service_id);

int
rte_event_eth_tx_adapter_instance_get(uint16_t eth_dev_id,
                      uint16_t tx_queue_id,
                      uint8_t *txa_inst_id);
int
rte_event_eth_tx_adapter_queue_start(uint16_t eth_dev_id, uint16_t tx_queue_id);

int
rte_event_eth_tx_adapter_queue_stop(uint16_t eth_dev_id, uint16_t tx_queue_id);

__rte_experimental
int
rte_event_eth_tx_adapter_runtime_params_init(
        struct rte_event_eth_tx_adapter_runtime_params *txa_params);

__rte_experimental
int
rte_event_eth_tx_adapter_runtime_params_set(uint8_t id,
        struct rte_event_eth_tx_adapter_runtime_params *params);

__rte_experimental
int
rte_event_eth_tx_adapter_runtime_params_get(uint8_t id,
        struct rte_event_eth_tx_adapter_runtime_params *params);

#ifdef __cplusplus
}
#endif
#endif  /* _RTE_EVENT_ETH_TX_ADAPTER_ */