rte_rawdev_pmd.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright 2017 NXP
 */
 
#ifndef _RTE_RAWDEV_PMD_H_
#define _RTE_RAWDEV_PMD_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <string.h>
 
#include <dev_driver.h>
#include <rte_malloc.h>
#include <rte_log.h>
#include <rte_common.h>
 
#include "rte_rawdev.h"
 
extern int librawdev_logtype;
 
/* Logging Macros */
#define RTE_RDEV_LOG(level, fmt, args...) \
    rte_log(RTE_LOG_ ## level, librawdev_logtype, "%s(): " fmt "\n", \
        __func__, ##args)
 
#define RTE_RDEV_ERR(fmt, args...) \
    RTE_RDEV_LOG(ERR, fmt, ## args)
#define RTE_RDEV_DEBUG(fmt, args...) \
    RTE_RDEV_LOG(DEBUG, fmt, ## args)
#define RTE_RDEV_INFO(fmt, args...) \
    RTE_RDEV_LOG(INFO, fmt, ## args)
 
 
/* Macros to check for valid device */
#define RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, retval) do { \
    if (!rte_rawdev_pmd_is_valid_dev((dev_id))) { \
        RTE_RDEV_ERR("Invalid dev_id=%d", dev_id); \
        return retval; \
    } \
} while (0)
 
#define RTE_RAWDEV_VALID_DEVID_OR_RET(dev_id) do { \
    if (!rte_rawdev_pmd_is_valid_dev((dev_id))) { \
        RTE_RDEV_ERR("Invalid dev_id=%d", dev_id); \
        return; \
    } \
} while (0)
 
#define RTE_RAWDEV_DETACHED  (0)
#define RTE_RAWDEV_ATTACHED  (1)
 
/* Global structure used for maintaining state of allocated raw devices.
 *
 * TODO: Can be expanded to <type of raw device>:<count> in future.
 *       Applications should be able to select from a number of type of raw
 *       devices which were detected or attached to this DPDK instance.
 */
struct rte_rawdev_global {
    uint16_t nb_devs;
};
 
extern struct rte_rawdev *rte_rawdevs;
static inline struct rte_rawdev *
rte_rawdev_pmd_get_named_dev(const char *name)
{
    struct rte_rawdev *dev;
    unsigned int i;
 
    if (name == NULL)
        return NULL;
 
    for (i = 0; i < RTE_RAWDEV_MAX_DEVS; i++) {
        dev = &rte_rawdevs[i];
        if ((dev->attached == RTE_RAWDEV_ATTACHED) &&
           (strcmp(dev->name, name) == 0))
            return dev;
    }
 
    return NULL;
}
 
static inline unsigned
rte_rawdev_pmd_is_valid_dev(uint8_t dev_id)
{
    struct rte_rawdev *dev;
 
    if (dev_id >= RTE_RAWDEV_MAX_DEVS)
        return 0;
 
    dev = &rte_rawdevs[dev_id];
    if (dev->attached != RTE_RAWDEV_ATTACHED)
        return 0;
    else
        return 1;
}
 
typedef int (*rawdev_info_get_t)(struct rte_rawdev *dev,
                  rte_rawdev_obj_t dev_info,
                  size_t dev_private_size);
 
typedef int (*rawdev_configure_t)(const struct rte_rawdev *dev,
                  rte_rawdev_obj_t config,
                  size_t config_size);
 
typedef int (*rawdev_start_t)(struct rte_rawdev *dev);
 
typedef void (*rawdev_stop_t)(struct rte_rawdev *dev);
 
typedef int (*rawdev_close_t)(struct rte_rawdev *dev);
 
typedef int (*rawdev_reset_t)(struct rte_rawdev *dev);
 
typedef int (*rawdev_queue_conf_get_t)(struct rte_rawdev *dev,
                    uint16_t queue_id,
                    rte_rawdev_obj_t queue_conf,
                    size_t queue_conf_size);
 
typedef int (*rawdev_queue_setup_t)(struct rte_rawdev *dev,
                    uint16_t queue_id,
                    rte_rawdev_obj_t queue_conf,
                    size_t queue_conf_size);
 
typedef int (*rawdev_queue_release_t)(struct rte_rawdev *dev,
                      uint16_t queue_id);
 
typedef uint16_t (*rawdev_queue_count_t)(struct rte_rawdev *dev);
 
typedef int (*rawdev_enqueue_bufs_t)(struct rte_rawdev *dev,
                     struct rte_rawdev_buf **buffers,
                     unsigned int count,
                     rte_rawdev_obj_t context);
 
typedef int (*rawdev_dequeue_bufs_t)(struct rte_rawdev *dev,
                     struct rte_rawdev_buf **buffers,
                     unsigned int count,
                     rte_rawdev_obj_t context);
 
typedef int (*rawdev_dump_t)(struct rte_rawdev *dev, FILE *f);
 
typedef int (*rawdev_get_attr_t)(struct rte_rawdev *dev,
                 const char *attr_name,
                 uint64_t *attr_value);
 
typedef int (*rawdev_set_attr_t)(struct rte_rawdev *dev,
                 const char *attr_name,
                 const uint64_t attr_value);
 
typedef int (*rawdev_xstats_get_t)(const struct rte_rawdev *dev,
        const unsigned int ids[], uint64_t values[], unsigned int n);
 
typedef int (*rawdev_xstats_reset_t)(struct rte_rawdev *dev,
        const uint32_t ids[],
        uint32_t nb_ids);
 
typedef int (*rawdev_xstats_get_names_t)(const struct rte_rawdev *dev,
        struct rte_rawdev_xstats_name *xstats_names,
        unsigned int size);
 
typedef uint64_t (*rawdev_xstats_get_by_name_t)(const struct rte_rawdev *dev,
                        const char *name,
                        unsigned int *id);
 
typedef int (*rawdev_firmware_status_get_t)(struct rte_rawdev *dev,
                        rte_rawdev_obj_t status_info);
 
typedef int (*rawdev_firmware_version_get_t)(struct rte_rawdev *dev,
                         rte_rawdev_obj_t version_info);
 
typedef int (*rawdev_firmware_load_t)(struct rte_rawdev *dev,
                      rte_rawdev_obj_t firmware_buf);
 
typedef int (*rawdev_firmware_unload_t)(struct rte_rawdev *dev);
 
typedef int (*rawdev_selftest_t)(uint16_t dev_id);
 
struct rte_rawdev_ops {
    rawdev_info_get_t dev_info_get;
    rawdev_configure_t dev_configure;
    rawdev_start_t dev_start;
    rawdev_stop_t dev_stop;
    rawdev_close_t dev_close;
    rawdev_reset_t dev_reset;
 
    rawdev_queue_conf_get_t queue_def_conf;
    rawdev_queue_setup_t queue_setup;
    rawdev_queue_release_t queue_release;
    rawdev_queue_count_t queue_count;
 
    rawdev_enqueue_bufs_t enqueue_bufs;
    rawdev_dequeue_bufs_t dequeue_bufs;
 
    /* Dump internal information */
    rawdev_dump_t dump;
 
    rawdev_get_attr_t attr_get;
    rawdev_set_attr_t attr_set;
 
    rawdev_xstats_get_t xstats_get;
    rawdev_xstats_get_names_t xstats_get_names;
    rawdev_xstats_get_by_name_t xstats_get_by_name;
    rawdev_xstats_reset_t xstats_reset;
 
    rawdev_firmware_status_get_t firmware_status_get;
    rawdev_firmware_version_get_t firmware_version_get;
    rawdev_firmware_load_t firmware_load;
    rawdev_firmware_unload_t firmware_unload;
 
    rawdev_selftest_t dev_selftest;
};
 
struct rte_rawdev *
rte_rawdev_pmd_allocate(const char *name, size_t dev_private_size,
            int socket_id);
 
int
rte_rawdev_pmd_release(struct rte_rawdev *rawdev);
 
struct rte_rawdev *
rte_rawdev_pmd_init(const char *name, size_t dev_private_size,
            int socket_id);
 
int
rte_rawdev_pmd_uninit(const char *name);
 
#ifdef __cplusplus
}
#endif
 
#endif /* _RTE_RAWDEV_PMD_H_ */