rte_eventdev_pmd.h

Go to the documentation of this file.

/*
 *
 *   Copyright(c) 2016 Cavium, Inc. All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *     * Neither the name of Cavium, Inc nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#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"

/* 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_EVENTDEV_DETACHED  (0)
#define RTE_EVENTDEV_ATTACHED  (1)

struct rte_eth_dev;

struct rte_eventdev_global {
    uint8_t nb_devs;    
};

extern struct rte_eventdev_global *rte_eventdev_globals;
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_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 *queue_conf;

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 *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);

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_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;
};

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_ */