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_
 
#include <stdint.h>
#include <stdbool.h>
 
#include <rte_compat.h>
#include <rte_cpuflags.h>
 
#include "rte_bbdev_op.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include "rte_bbdev_trace_fp.h"
 
#ifndef RTE_BBDEV_MAX_DEVS
#define RTE_BBDEV_MAX_DEVS 128  
#endif
 
/*
 * Maximum size to be used to manage the enum rte_bbdev_enqueue_status
 * including padding for future enum insertion.
 * The enum values must be explicitly kept smaller or equal to this padded maximum size.
 */
#define RTE_BBDEV_ENQ_STATUS_SIZE_MAX 6
 
enum rte_bbdev_state {
    RTE_BBDEV_UNUSED,
    RTE_BBDEV_INITIALIZED
};
 
uint16_t
rte_bbdev_count(void);
 
bool
rte_bbdev_is_valid(uint16_t dev_id);
 
uint16_t
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_bbdev_setup_queues(uint16_t dev_id, uint16_t num_queues, int socket_id);
 
int
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_bbdev_queue_configure(uint16_t dev_id, uint16_t queue_id,
        const struct rte_bbdev_queue_conf *conf);
 
int
rte_bbdev_start(uint16_t dev_id);
 
int
rte_bbdev_stop(uint16_t dev_id);
 
int
rte_bbdev_close(uint16_t dev_id);
 
int
rte_bbdev_queue_start(uint16_t dev_id, uint16_t queue_id);
 
int
rte_bbdev_queue_stop(uint16_t dev_id, uint16_t queue_id);
 
enum rte_bbdev_enqueue_status {
    RTE_BBDEV_ENQ_STATUS_NONE,             
    RTE_BBDEV_ENQ_STATUS_QUEUE_FULL,       
    RTE_BBDEV_ENQ_STATUS_RING_FULL,        
    RTE_BBDEV_ENQ_STATUS_INVALID_OP,       
    /* Note: RTE_BBDEV_ENQ_STATUS_SIZE_MAX must be larger or equal to maximum enum value. */
};
 
enum rte_bbdev_device_status {
    RTE_BBDEV_DEV_NOSTATUS,        
    RTE_BBDEV_DEV_NOT_SUPPORTED,   
    RTE_BBDEV_DEV_RESET,           
    RTE_BBDEV_DEV_CONFIGURED,      
    RTE_BBDEV_DEV_ACTIVE,          
    RTE_BBDEV_DEV_FATAL_ERR,       
    RTE_BBDEV_DEV_RESTART_REQ,     
    RTE_BBDEV_DEV_RECONFIG_REQ,    
    RTE_BBDEV_DEV_CORRECT_ERR,     
};
 
struct rte_bbdev_stats {
    uint64_t enqueued_count;  
    uint64_t dequeued_count;  
    uint64_t enqueue_err_count;
    uint64_t dequeue_err_count;
    uint64_t enqueue_warn_count;
    uint64_t dequeue_warn_count;
    uint64_t enqueue_status_count[RTE_BBDEV_ENQ_STATUS_SIZE_MAX];
    uint64_t acc_offload_cycles;
    uint16_t enqueue_depth_avail;
};
 
int
rte_bbdev_stats_get(uint16_t dev_id, struct rte_bbdev_stats *stats);
 
int
rte_bbdev_stats_reset(uint16_t dev_id);
 
__rte_experimental
int rte_bbdev_queue_stats_get(uint16_t dev_id, uint16_t queue_id, struct rte_bbdev_stats *stats);
 
/* Structure rte_bbdev_driver_info 8< */
struct rte_bbdev_driver_info {
    const char *driver_name;
 
    unsigned int max_num_queues;
    unsigned int num_queues[RTE_BBDEV_OP_TYPE_SIZE_MAX];
    unsigned int queue_priority[RTE_BBDEV_OP_TYPE_SIZE_MAX];
    uint32_t queue_size_lim;
    bool hardware_accelerated;
    uint8_t max_dl_queue_priority;
    uint8_t max_ul_queue_priority;
    bool queue_intr_supported;
    enum rte_bbdev_device_status device_status;
    uint32_t harq_buffer_size;
    uint16_t min_alignment;
    uint8_t data_endianness;
    struct rte_bbdev_queue_conf default_queue_conf;
    const struct rte_bbdev_op_cap *capabilities;
    const enum rte_cpu_flag_t *cpu_flag_reqs;
    uint16_t *fft_window_width;
};
/* >8 End of structure rte_bbdev_driver_info. */
 
#define RTE_BBDEV_END_OF_CAPABILITIES_LIST() \
    { RTE_BBDEV_OP_NONE }
 
/* Structure rte_bbdev_info 8< */
struct rte_bbdev_info {
    int socket_id;  
    const char *dev_name;  
    const struct rte_device *device; 
    uint16_t num_queues;  
    bool started;  
    struct rte_bbdev_driver_info drv;  
};
/* >8 End of structure rte_bbdev_info. */
 
int
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_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;  
    enum rte_bbdev_enqueue_status enqueue_status; 
    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_enqueue_fft_ops_t)(
        struct rte_bbdev_queue_data *q_data,
        struct rte_bbdev_fft_op **ops,
        uint16_t num);
 
typedef uint16_t (*rte_bbdev_enqueue_mldts_ops_t)(
        struct rte_bbdev_queue_data *q_data,
        struct rte_bbdev_mldts_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);
 
typedef uint16_t (*rte_bbdev_dequeue_fft_ops_t)(
        struct rte_bbdev_queue_data *q_data,
        struct rte_bbdev_fft_op **ops, uint16_t num);
 
typedef uint16_t (*rte_bbdev_dequeue_mldts_ops_t)(
        struct rte_bbdev_queue_data *q_data,
        struct rte_bbdev_mldts_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_ATOMIC(uint16_t) process_cnt;  
};
 
/* Forward declarations */
struct rte_bbdev_ops;
struct rte_bbdev_callback;
struct rte_intr_handle;
 
RTE_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;
    rte_bbdev_enqueue_enc_ops_t enqueue_ldpc_enc_ops;
    rte_bbdev_enqueue_dec_ops_t enqueue_ldpc_dec_ops;
    rte_bbdev_dequeue_enc_ops_t dequeue_ldpc_enc_ops;
    rte_bbdev_dequeue_dec_ops_t dequeue_ldpc_dec_ops;
    rte_bbdev_enqueue_fft_ops_t enqueue_fft_ops;
    rte_bbdev_dequeue_fft_ops_t dequeue_fft_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; 
    rte_bbdev_enqueue_mldts_ops_t enqueue_mldts_ops;
    rte_bbdev_dequeue_mldts_ops_t dequeue_mldts_ops;
};
 
extern struct rte_bbdev rte_bbdev_devices[];
 
static inline uint16_t
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];
    rte_bbdev_trace_enqueue(dev_id, queue_id, (void **)ops, num_ops,
            rte_bbdev_op_type_str(RTE_BBDEV_OP_TURBO_DEC));
    return dev->enqueue_enc_ops(q_data, ops, num_ops);
}
 
static inline uint16_t
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];
    rte_bbdev_trace_enqueue(dev_id, queue_id, (void **)ops, num_ops,
            rte_bbdev_op_type_str(RTE_BBDEV_OP_TURBO_ENC));
    return dev->enqueue_dec_ops(q_data, ops, num_ops);
}
 
static inline uint16_t
rte_bbdev_enqueue_ldpc_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];
    rte_bbdev_trace_enqueue(dev_id, queue_id, (void **)ops, num_ops,
            rte_bbdev_op_type_str(RTE_BBDEV_OP_LDPC_ENC));
    return dev->enqueue_ldpc_enc_ops(q_data, ops, num_ops);
}
 
static inline uint16_t
rte_bbdev_enqueue_ldpc_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];
    rte_bbdev_trace_enqueue(dev_id, queue_id, (void **)ops, num_ops,
            rte_bbdev_op_type_str(RTE_BBDEV_OP_LDPC_DEC));
    return dev->enqueue_ldpc_dec_ops(q_data, ops, num_ops);
}
 
static inline uint16_t
rte_bbdev_enqueue_fft_ops(uint16_t dev_id, uint16_t queue_id,
        struct rte_bbdev_fft_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];
    rte_bbdev_trace_enqueue(dev_id, queue_id, (void **)ops, num_ops,
            rte_bbdev_op_type_str(RTE_BBDEV_OP_FFT));
    return dev->enqueue_fft_ops(q_data, ops, num_ops);
}
 
static inline uint16_t
rte_bbdev_enqueue_mldts_ops(uint16_t dev_id, uint16_t queue_id,
        struct rte_bbdev_mldts_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];
    rte_bbdev_trace_enqueue(dev_id, queue_id, (void **)ops, num_ops,
            rte_bbdev_op_type_str(RTE_BBDEV_OP_MLDTS));
    return dev->enqueue_mldts_ops(q_data, ops, num_ops);
}
 
static inline uint16_t
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];
    uint16_t num_ops_dequeued = dev->dequeue_enc_ops(q_data, ops, num_ops);
    if (num_ops_dequeued > 0)
        rte_bbdev_trace_dequeue(dev_id, queue_id, (void **)ops, num_ops,
                num_ops_dequeued, rte_bbdev_op_type_str(RTE_BBDEV_OP_TURBO_ENC));
    return num_ops_dequeued;
}
 
static inline uint16_t
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];
    uint16_t num_ops_dequeued = dev->dequeue_dec_ops(q_data, ops, num_ops);
    if (num_ops_dequeued > 0)
        rte_bbdev_trace_dequeue(dev_id, queue_id, (void **)ops, num_ops,
                num_ops_dequeued, rte_bbdev_op_type_str(RTE_BBDEV_OP_TURBO_DEC));
    return num_ops_dequeued;
}
 
 
static inline uint16_t
rte_bbdev_dequeue_ldpc_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];
    uint16_t num_ops_dequeued = dev->dequeue_ldpc_enc_ops(q_data, ops, num_ops);
    if (num_ops_dequeued > 0)
        rte_bbdev_trace_dequeue(dev_id, queue_id, (void **)ops, num_ops,
                num_ops_dequeued, rte_bbdev_op_type_str(RTE_BBDEV_OP_LDPC_ENC));
    return num_ops_dequeued;
}
 
static inline uint16_t
rte_bbdev_dequeue_ldpc_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];
    uint16_t num_ops_dequeued = dev->dequeue_ldpc_dec_ops(q_data, ops, num_ops);
    if (num_ops_dequeued > 0)
        rte_bbdev_trace_dequeue(dev_id, queue_id, (void **)ops, num_ops,
                num_ops_dequeued, rte_bbdev_op_type_str(RTE_BBDEV_OP_LDPC_DEC));
    return num_ops_dequeued;
}
 
static inline uint16_t
rte_bbdev_dequeue_fft_ops(uint16_t dev_id, uint16_t queue_id,
        struct rte_bbdev_fft_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];
    uint16_t num_ops_dequeued = dev->dequeue_fft_ops(q_data, ops, num_ops);
    if (num_ops_dequeued > 0)
        rte_bbdev_trace_dequeue(dev_id, queue_id, (void **)ops, num_ops,
                num_ops_dequeued, rte_bbdev_op_type_str(RTE_BBDEV_OP_FFT));
    return num_ops_dequeued;
}
 
static inline uint16_t
rte_bbdev_dequeue_mldts_ops(uint16_t dev_id, uint16_t queue_id,
        struct rte_bbdev_mldts_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];
    uint16_t num_ops_dequeued = dev->dequeue_mldts_ops(q_data, ops, num_ops);
    if (num_ops_dequeued > 0)
        rte_bbdev_trace_dequeue(dev_id, queue_id, (void **)ops, num_ops,
                num_ops_dequeued, rte_bbdev_op_type_str(RTE_BBDEV_OP_MLDTS));
    return num_ops_dequeued;
}
 
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_bbdev_callback_register(uint16_t dev_id, enum rte_bbdev_event_type event,
        rte_bbdev_cb_fn cb_fn, void *cb_arg);
 
int
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_bbdev_queue_intr_enable(uint16_t dev_id, uint16_t queue_id);
 
int
rte_bbdev_queue_intr_disable(uint16_t dev_id, uint16_t queue_id);
 
int
rte_bbdev_queue_intr_ctl(uint16_t dev_id, uint16_t queue_id, int epfd, int op,
        void *data);
 
const char*
rte_bbdev_device_status_str(enum rte_bbdev_device_status status);
 
const char*
rte_bbdev_enqueue_status_str(enum rte_bbdev_enqueue_status status);
 
__rte_experimental
int
rte_bbdev_queue_ops_dump(uint16_t dev_id, uint16_t queue_index, FILE *file);
 
 
__rte_experimental
char *
rte_bbdev_ops_param_string(void *op, enum rte_bbdev_op_type op_type, char *str, uint32_t len);
 
__rte_experimental
void
rte_bbdev_ops_trace(void *op, enum rte_bbdev_op_type op_type);
 
#ifdef __cplusplus
}
#endif
 
#endif /* _RTE_BBDEV_H_ */