rte_bbdev.h

Go to the documentation of this file.

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

#ifndef _RTE_BBDEV_H_
#define _RTE_BBDEV_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <stdint.h>
#include <stdbool.h>
#include <string.h>

#include <rte_compat.h>
#include <rte_atomic.h>
#include <rte_bus.h>
#include <rte_cpuflags.h>
#include <rte_memory.h>

#include "rte_bbdev_op.h"

#ifndef RTE_BBDEV_MAX_DEVS
#define RTE_BBDEV_MAX_DEVS 128  
#endif

enum rte_bbdev_state {
        RTE_BBDEV_UNUSED,
        RTE_BBDEV_INITIALIZED
};

uint16_t __rte_experimental
rte_bbdev_count(void);

bool __rte_experimental
rte_bbdev_is_valid(uint16_t dev_id);

uint16_t __rte_experimental
rte_bbdev_find_next(uint16_t dev_id);

#define RTE_BBDEV_FOREACH(i) for (i = rte_bbdev_find_next(-1); \
                i < RTE_BBDEV_MAX_DEVS; \
                i = rte_bbdev_find_next(i))

int __rte_experimental
rte_bbdev_setup_queues(uint16_t dev_id, uint16_t num_queues, int socket_id);

int __rte_experimental
rte_bbdev_intr_enable(uint16_t dev_id);

struct rte_bbdev_queue_conf {
        int socket;  
        uint32_t queue_size;  
        uint8_t priority;  
        bool deferred_start; 
        enum rte_bbdev_op_type op_type; 
};

int __rte_experimental
rte_bbdev_queue_configure(uint16_t dev_id, uint16_t queue_id,
                const struct rte_bbdev_queue_conf *conf);

int __rte_experimental
rte_bbdev_start(uint16_t dev_id);

int __rte_experimental
rte_bbdev_stop(uint16_t dev_id);

int __rte_experimental
rte_bbdev_close(uint16_t dev_id);

int __rte_experimental
rte_bbdev_queue_start(uint16_t dev_id, uint16_t queue_id);

int __rte_experimental
rte_bbdev_queue_stop(uint16_t dev_id, uint16_t queue_id);

struct rte_bbdev_stats {
        uint64_t enqueued_count;  
        uint64_t dequeued_count;  
        uint64_t enqueue_err_count;
        uint64_t dequeue_err_count;
        uint64_t acc_offload_cycles;
};

int __rte_experimental
rte_bbdev_stats_get(uint16_t dev_id, struct rte_bbdev_stats *stats);

int __rte_experimental
rte_bbdev_stats_reset(uint16_t dev_id);

struct rte_bbdev_driver_info {
        const char *driver_name;

        unsigned int max_num_queues;
        uint32_t queue_size_lim;
        bool hardware_accelerated;
        uint8_t max_dl_queue_priority;
        uint8_t max_ul_queue_priority;
        bool queue_intr_supported;
        uint16_t min_alignment;
        struct rte_bbdev_queue_conf default_queue_conf;
        const struct rte_bbdev_op_cap *capabilities;
        const enum rte_cpu_flag_t *cpu_flag_reqs;
};

#define RTE_BBDEV_END_OF_CAPABILITIES_LIST() \
        { RTE_BBDEV_OP_NONE }

struct rte_bbdev_info {
        int socket_id;  
        const char *dev_name;  
        const struct rte_bus *bus;  
        uint16_t num_queues;  
        bool started;  
        struct rte_bbdev_driver_info drv;  
};

int __rte_experimental
rte_bbdev_info_get(uint16_t dev_id, struct rte_bbdev_info *dev_info);

struct rte_bbdev_queue_info {
        struct rte_bbdev_queue_conf conf;
        bool started;
};

int __rte_experimental
rte_bbdev_queue_info_get(uint16_t dev_id, uint16_t queue_id,
                struct rte_bbdev_queue_info *queue_info);

struct rte_bbdev_queue_data {
        void *queue_private;  
        struct rte_bbdev_queue_conf conf;  
        struct rte_bbdev_stats queue_stats;  
        bool started;  
};

typedef uint16_t (*rte_bbdev_enqueue_enc_ops_t)(
                struct rte_bbdev_queue_data *q_data,
                struct rte_bbdev_enc_op **ops,
                uint16_t num);

typedef uint16_t (*rte_bbdev_enqueue_dec_ops_t)(
                struct rte_bbdev_queue_data *q_data,
                struct rte_bbdev_dec_op **ops,
                uint16_t num);

typedef uint16_t (*rte_bbdev_dequeue_enc_ops_t)(
                struct rte_bbdev_queue_data *q_data,
                struct rte_bbdev_enc_op **ops, uint16_t num);

typedef uint16_t (*rte_bbdev_dequeue_dec_ops_t)(
                struct rte_bbdev_queue_data *q_data,
                struct rte_bbdev_dec_op **ops, uint16_t num);

#define RTE_BBDEV_NAME_MAX_LEN  64  
struct rte_bbdev_data {
        char name[RTE_BBDEV_NAME_MAX_LEN]; 
        void *dev_private;  
        uint16_t num_queues;  
        struct rte_bbdev_queue_data *queues;  
        uint16_t dev_id;  
        int socket_id;  
        bool started;  
        rte_atomic16_t process_cnt;
};

/* Forward declarations */
struct rte_bbdev_ops;
struct rte_bbdev_callback;
struct rte_intr_handle;

TAILQ_HEAD(rte_bbdev_cb_list, rte_bbdev_callback);

struct __rte_cache_aligned rte_bbdev {
        rte_bbdev_enqueue_enc_ops_t enqueue_enc_ops;
        rte_bbdev_enqueue_dec_ops_t enqueue_dec_ops;
        rte_bbdev_dequeue_enc_ops_t dequeue_enc_ops;
        rte_bbdev_dequeue_dec_ops_t dequeue_dec_ops;
        const struct rte_bbdev_ops *dev_ops;  
        struct rte_bbdev_data *data;  
        enum rte_bbdev_state state;  
        struct rte_device *device; 
        struct rte_bbdev_cb_list list_cbs;
        struct rte_intr_handle *intr_handle; 
};

extern struct rte_bbdev rte_bbdev_devices[];

static inline uint16_t __rte_experimental
rte_bbdev_enqueue_enc_ops(uint16_t dev_id, uint16_t queue_id,
                struct rte_bbdev_enc_op **ops, uint16_t num_ops)
{
        struct rte_bbdev *dev = &rte_bbdev_devices[dev_id];
        struct rte_bbdev_queue_data *q_data = &dev->data->queues[queue_id];
        return dev->enqueue_enc_ops(q_data, ops, num_ops);
}

static inline uint16_t __rte_experimental
rte_bbdev_enqueue_dec_ops(uint16_t dev_id, uint16_t queue_id,
                struct rte_bbdev_dec_op **ops, uint16_t num_ops)
{
        struct rte_bbdev *dev = &rte_bbdev_devices[dev_id];
        struct rte_bbdev_queue_data *q_data = &dev->data->queues[queue_id];
        return dev->enqueue_dec_ops(q_data, ops, num_ops);
}

static inline uint16_t __rte_experimental
rte_bbdev_dequeue_enc_ops(uint16_t dev_id, uint16_t queue_id,
                struct rte_bbdev_enc_op **ops, uint16_t num_ops)
{
        struct rte_bbdev *dev = &rte_bbdev_devices[dev_id];
        struct rte_bbdev_queue_data *q_data = &dev->data->queues[queue_id];
        return dev->dequeue_enc_ops(q_data, ops, num_ops);
}

static inline uint16_t __rte_experimental
rte_bbdev_dequeue_dec_ops(uint16_t dev_id, uint16_t queue_id,
                struct rte_bbdev_dec_op **ops, uint16_t num_ops)
{
        struct rte_bbdev *dev = &rte_bbdev_devices[dev_id];
        struct rte_bbdev_queue_data *q_data = &dev->data->queues[queue_id];
        return dev->dequeue_dec_ops(q_data, ops, num_ops);
}

enum rte_bbdev_event_type {
        RTE_BBDEV_EVENT_UNKNOWN,  
        RTE_BBDEV_EVENT_ERROR,  
        RTE_BBDEV_EVENT_DEQUEUE,  
        RTE_BBDEV_EVENT_MAX  
};

typedef void (*rte_bbdev_cb_fn)(uint16_t dev_id,
                enum rte_bbdev_event_type event, void *cb_arg,
                void *ret_param);

int __rte_experimental
rte_bbdev_callback_register(uint16_t dev_id, enum rte_bbdev_event_type event,
                rte_bbdev_cb_fn cb_fn, void *cb_arg);

int __rte_experimental
rte_bbdev_callback_unregister(uint16_t dev_id, enum rte_bbdev_event_type event,
                rte_bbdev_cb_fn cb_fn, void *cb_arg);

int __rte_experimental
rte_bbdev_queue_intr_enable(uint16_t dev_id, uint16_t queue_id);

int __rte_experimental
rte_bbdev_queue_intr_disable(uint16_t dev_id, uint16_t queue_id);

int __rte_experimental
rte_bbdev_queue_intr_ctl(uint16_t dev_id, uint16_t queue_id, int epfd, int op,
                void *data);

#ifdef __cplusplus
}
#endif

#endif /* _RTE_BBDEV_H_ */