rte_eventdev_pmd.h

Go to the documentation of this file.

/*
 *
 *   Copyright(c) 2016 Cavium networks. 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 networks 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_dev.h>
#include <rte_pci.h>
#include <rte_malloc.h>
#include <rte_log.h>
#include <rte_common.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_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_EVENTDEV_DETACHED  (0)
#define RTE_EVENTDEV_ATTACHED  (1)

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

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

struct rte_eventdev_driver {
        struct rte_pci_driver pci_drv;  
        unsigned int dev_private_size;  
        eventdev_init_t eventdev_init;  
        eventdev_uninit_t eventdev_uninit; 
};

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

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

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

int
rte_event_pmd_release(struct rte_eventdev *eventdev);

struct rte_eventdev *
rte_event_pmd_vdev_init(const char *name, size_t dev_private_size,
                int socket_id);

int
rte_event_pmd_vdev_uninit(const char *name);

int rte_event_pmd_pci_probe(struct rte_pci_driver *pci_drv,
                            struct rte_pci_device *pci_dev);

int rte_event_pmd_pci_remove(struct rte_pci_device *pci_dev);

#ifdef __cplusplus
}
#endif

#endif /* _RTE_EVENTDEV_PMD_H_ */