rte_eventdev_pmd.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2016 Cavium, Inc
 */

#ifndef _RTE_EVENTDEV_PMD_H_
#define _RTE_EVENTDEV_PMD_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <string.h>

#include <rte_common.h>
#include <rte_config.h>
#include <rte_dev.h>
#include <rte_log.h>
#include <rte_malloc.h>

#include "rte_eventdev.h"
#include "rte_event_timer_adapter_pmd.h"

/* Logging Macros */
#define RTE_EDEV_LOG_ERR(...) \
    RTE_LOG(ERR, EVENTDEV, \
        RTE_FMT("%s() line %u: " RTE_FMT_HEAD(__VA_ARGS__,) "\n", \
            __func__, __LINE__, RTE_FMT_TAIL(__VA_ARGS__,)))

#ifdef RTE_LIBRTE_EVENTDEV_DEBUG
#define RTE_EDEV_LOG_DEBUG(...) \
    RTE_LOG(DEBUG, EVENTDEV, \
        RTE_FMT("%s() line %u: " RTE_FMT_HEAD(__VA_ARGS__,) "\n", \
            __func__, __LINE__, RTE_FMT_TAIL(__VA_ARGS__,)))
#else
#define RTE_EDEV_LOG_DEBUG(...) (void)0
#endif

/* Macros to check for valid device */
#define RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, retval) do { \
    if (!rte_event_pmd_is_valid_dev((dev_id))) { \
        RTE_EDEV_LOG_ERR("Invalid dev_id=%d\n", dev_id); \
        return retval; \
    } \
} while (0)

#define RTE_EVENTDEV_VALID_DEVID_OR_ERRNO_RET(dev_id, errno, retval) do { \
    if (!rte_event_pmd_is_valid_dev((dev_id))) { \
        RTE_EDEV_LOG_ERR("Invalid dev_id=%d\n", dev_id); \
        rte_errno = errno; \
        return retval; \
    } \
} while (0)

#define RTE_EVENTDEV_VALID_DEVID_OR_RET(dev_id) do { \
    if (!rte_event_pmd_is_valid_dev((dev_id))) { \
        RTE_EDEV_LOG_ERR("Invalid dev_id=%d\n", dev_id); \
        return; \
    } \
} while (0)

#define RTE_EVENT_ETH_RX_ADAPTER_SW_CAP \
        ((RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) | \
            (RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ))

#define RTE_EVENT_CRYPTO_ADAPTER_SW_CAP \
        RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA

#define RTE_EVENTDEV_DETACHED  (0)
#define RTE_EVENTDEV_ATTACHED  (1)

struct rte_eth_dev;

struct rte_eventdev_global {
    uint8_t nb_devs;    
};

extern struct rte_eventdev *rte_eventdevs;
static inline struct rte_eventdev *
rte_event_pmd_get_named_dev(const char *name)
{
    struct rte_eventdev *dev;
    unsigned int i;

    if (name == NULL)
        return NULL;

    for (i = 0; i < RTE_EVENT_MAX_DEVS; i++) {
        dev = &rte_eventdevs[i];
        if ((dev->attached == RTE_EVENTDEV_ATTACHED) &&
                (strcmp(dev->data->name, name) == 0))
            return dev;
    }

    return NULL;
}

static inline unsigned
rte_event_pmd_is_valid_dev(uint8_t dev_id)
{
    struct rte_eventdev *dev;

    if (dev_id >= RTE_EVENT_MAX_DEVS)
        return 0;

    dev = &rte_eventdevs[dev_id];
    if (dev->attached != RTE_EVENTDEV_ATTACHED)
        return 0;
    else
        return 1;
}

typedef void (*eventdev_info_get_t)(struct rte_eventdev *dev,
        struct rte_event_dev_info *dev_info);

typedef int (*eventdev_configure_t)(const struct rte_eventdev *dev);

typedef int (*eventdev_start_t)(struct rte_eventdev *dev);

typedef void (*eventdev_stop_t)(struct rte_eventdev *dev);

typedef int (*eventdev_close_t)(struct rte_eventdev *dev);

typedef void (*eventdev_queue_default_conf_get_t)(struct rte_eventdev *dev,
        uint8_t queue_id, struct rte_event_queue_conf *queue_conf);

typedef int (*eventdev_queue_setup_t)(struct rte_eventdev *dev,
        uint8_t queue_id,
        const struct rte_event_queue_conf *queue_conf);

typedef void (*eventdev_queue_release_t)(struct rte_eventdev *dev,
        uint8_t queue_id);

typedef void (*eventdev_port_default_conf_get_t)(struct rte_eventdev *dev,
        uint8_t port_id, struct rte_event_port_conf *port_conf);

typedef int (*eventdev_port_setup_t)(struct rte_eventdev *dev,
        uint8_t port_id,
        const struct rte_event_port_conf *port_conf);

typedef void (*eventdev_port_release_t)(void *port);

typedef int (*eventdev_port_link_t)(struct rte_eventdev *dev, void *port,
        const uint8_t queues[], const uint8_t priorities[],
        uint16_t nb_links);

typedef int (*eventdev_port_unlink_t)(struct rte_eventdev *dev, void *port,
        uint8_t queues[], uint16_t nb_unlinks);

typedef int (*eventdev_port_unlinks_in_progress_t)(struct rte_eventdev *dev,
        void *port);

typedef int (*eventdev_dequeue_timeout_ticks_t)(struct rte_eventdev *dev,
        uint64_t ns, uint64_t *timeout_ticks);

typedef void (*eventdev_dump_t)(struct rte_eventdev *dev, FILE *f);

typedef int (*eventdev_xstats_get_t)(const struct rte_eventdev *dev,
        enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id,
        const unsigned int ids[], uint64_t values[], unsigned int n);

typedef int (*eventdev_xstats_reset_t)(struct rte_eventdev *dev,
        enum rte_event_dev_xstats_mode mode,
        int16_t queue_port_id,
        const uint32_t ids[],
        uint32_t nb_ids);

typedef int (*eventdev_xstats_get_names_t)(const struct rte_eventdev *dev,
        enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id,
        struct rte_event_dev_xstats_name *xstats_names,
        unsigned int *ids, unsigned int size);

typedef uint64_t (*eventdev_xstats_get_by_name)(const struct rte_eventdev *dev,
        const char *name, unsigned int *id);


typedef int (*eventdev_eth_rx_adapter_caps_get_t)
                    (const struct rte_eventdev *dev,
                    const struct rte_eth_dev *eth_dev,
                    uint32_t *caps);

struct rte_event_eth_rx_adapter_queue_conf;

typedef int (*eventdev_timer_adapter_caps_get_t)(
                const struct rte_eventdev *dev,
                uint64_t flags,
                uint32_t *caps,
                const struct rte_event_timer_adapter_ops **ops);

typedef int (*eventdev_eth_rx_adapter_queue_add_t)(
        const struct rte_eventdev *dev,
        const struct rte_eth_dev *eth_dev,
        int32_t rx_queue_id,
        const struct rte_event_eth_rx_adapter_queue_conf *queue_conf);

typedef int (*eventdev_eth_rx_adapter_queue_del_t)
                    (const struct rte_eventdev *dev,
                    const struct rte_eth_dev *eth_dev,
                    int32_t rx_queue_id);

typedef int (*eventdev_eth_rx_adapter_start_t)
                    (const struct rte_eventdev *dev,
                    const struct rte_eth_dev *eth_dev);

typedef int (*eventdev_eth_rx_adapter_stop_t)
                    (const struct rte_eventdev *dev,
                    const struct rte_eth_dev *eth_dev);

struct rte_event_eth_rx_adapter_stats;

typedef int (*eventdev_eth_rx_adapter_stats_get)
            (const struct rte_eventdev *dev,
            const struct rte_eth_dev *eth_dev,
            struct rte_event_eth_rx_adapter_stats *stats);
typedef int (*eventdev_eth_rx_adapter_stats_reset)
            (const struct rte_eventdev *dev,
            const struct rte_eth_dev *eth_dev);
typedef int (*eventdev_selftest)(void);


struct rte_cryptodev;

typedef int (*eventdev_crypto_adapter_caps_get_t)
                    (const struct rte_eventdev *dev,
                     const struct rte_cryptodev *cdev,
                     uint32_t *caps);

typedef int (*eventdev_crypto_adapter_queue_pair_add_t)
            (const struct rte_eventdev *dev,
             const struct rte_cryptodev *cdev,
             int32_t queue_pair_id,
             const struct rte_event *event);


typedef int (*eventdev_crypto_adapter_queue_pair_del_t)
                    (const struct rte_eventdev *dev,
                     const struct rte_cryptodev *cdev,
                     int32_t queue_pair_id);

typedef int (*eventdev_crypto_adapter_start_t)
                    (const struct rte_eventdev *dev,
                     const struct rte_cryptodev *cdev);

typedef int (*eventdev_crypto_adapter_stop_t)
                    (const struct rte_eventdev *dev,
                     const struct rte_cryptodev *cdev);

struct rte_event_crypto_adapter_stats;

typedef int (*eventdev_crypto_adapter_stats_get)
            (const struct rte_eventdev *dev,
             const struct rte_cryptodev *cdev,
             struct rte_event_crypto_adapter_stats *stats);

typedef int (*eventdev_crypto_adapter_stats_reset)
            (const struct rte_eventdev *dev,
             const struct rte_cryptodev *cdev);

typedef int (*eventdev_eth_tx_adapter_caps_get_t)
                    (const struct rte_eventdev *dev,
                    const struct rte_eth_dev *eth_dev,
                    uint32_t *caps);

typedef int (*eventdev_eth_tx_adapter_create_t)(uint8_t id,
                    const struct rte_eventdev *dev);

typedef int (*eventdev_eth_tx_adapter_free_t)(uint8_t id,
                    const struct rte_eventdev *dev);

typedef int (*eventdev_eth_tx_adapter_queue_add_t)(
                    uint8_t id,
                    const struct rte_eventdev *dev,
                    const struct rte_eth_dev *eth_dev,
                    int32_t tx_queue_id);

typedef int (*eventdev_eth_tx_adapter_queue_del_t)(
                    uint8_t id,
                    const struct rte_eventdev *dev,
                    const struct rte_eth_dev *eth_dev,
                    int32_t tx_queue_id);

typedef int (*eventdev_eth_tx_adapter_start_t)(uint8_t id,
                    const struct rte_eventdev *dev);

typedef int (*eventdev_eth_tx_adapter_stop_t)(uint8_t id,
                    const struct rte_eventdev *dev);

struct rte_event_eth_tx_adapter_stats;

typedef int (*eventdev_eth_tx_adapter_stats_get_t)(
                uint8_t id,
                const struct rte_eventdev *dev,
                struct rte_event_eth_tx_adapter_stats *stats);

typedef int (*eventdev_eth_tx_adapter_stats_reset_t)(uint8_t id,
                    const struct rte_eventdev *dev);

struct rte_eventdev_ops {
    eventdev_info_get_t dev_infos_get;  
    eventdev_configure_t dev_configure; 
    eventdev_start_t dev_start;     
    eventdev_stop_t dev_stop;       
    eventdev_close_t dev_close;     
    eventdev_queue_default_conf_get_t queue_def_conf;
    eventdev_queue_setup_t queue_setup;
    eventdev_queue_release_t queue_release;
    eventdev_port_default_conf_get_t port_def_conf;
    eventdev_port_setup_t port_setup;
    eventdev_port_release_t port_release;
    eventdev_port_link_t port_link;
    eventdev_port_unlink_t port_unlink;
    eventdev_port_unlinks_in_progress_t port_unlinks_in_progress;
    eventdev_dequeue_timeout_ticks_t timeout_ticks;
    eventdev_dump_t dump;
    /* Dump internal information */

    eventdev_xstats_get_t xstats_get;
    eventdev_xstats_get_names_t xstats_get_names;
    eventdev_xstats_get_by_name xstats_get_by_name;
    eventdev_xstats_reset_t xstats_reset;
    eventdev_eth_rx_adapter_caps_get_t eth_rx_adapter_caps_get;
    eventdev_eth_rx_adapter_queue_add_t eth_rx_adapter_queue_add;
    eventdev_eth_rx_adapter_queue_del_t eth_rx_adapter_queue_del;
    eventdev_eth_rx_adapter_start_t eth_rx_adapter_start;
    eventdev_eth_rx_adapter_stop_t eth_rx_adapter_stop;
    eventdev_eth_rx_adapter_stats_get eth_rx_adapter_stats_get;
    eventdev_eth_rx_adapter_stats_reset eth_rx_adapter_stats_reset;
    eventdev_timer_adapter_caps_get_t timer_adapter_caps_get;
    eventdev_crypto_adapter_caps_get_t crypto_adapter_caps_get;
    eventdev_crypto_adapter_queue_pair_add_t crypto_adapter_queue_pair_add;
    eventdev_crypto_adapter_queue_pair_del_t crypto_adapter_queue_pair_del;
    eventdev_crypto_adapter_start_t crypto_adapter_start;
    eventdev_crypto_adapter_stop_t crypto_adapter_stop;
    eventdev_crypto_adapter_stats_get crypto_adapter_stats_get;
    eventdev_crypto_adapter_stats_reset crypto_adapter_stats_reset;
    eventdev_eth_tx_adapter_caps_get_t eth_tx_adapter_caps_get;
    eventdev_eth_tx_adapter_create_t eth_tx_adapter_create;
    eventdev_eth_tx_adapter_free_t eth_tx_adapter_free;
    eventdev_eth_tx_adapter_queue_add_t eth_tx_adapter_queue_add;
    eventdev_eth_tx_adapter_queue_del_t eth_tx_adapter_queue_del;
    eventdev_eth_tx_adapter_start_t eth_tx_adapter_start;
    eventdev_eth_tx_adapter_stop_t eth_tx_adapter_stop;
    eventdev_eth_tx_adapter_stats_get_t eth_tx_adapter_stats_get;
    eventdev_eth_tx_adapter_stats_reset_t eth_tx_adapter_stats_reset;
    eventdev_selftest dev_selftest;
    eventdev_stop_flush_t dev_stop_flush;
};

struct rte_eventdev *
rte_event_pmd_allocate(const char *name, int socket_id);

int
rte_event_pmd_release(struct rte_eventdev *eventdev);

#ifdef __cplusplus
}
#endif

#endif /* _RTE_EVENTDEV_PMD_H_ */