rte_compressdev.h

Go to the documentation of this file.

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

#ifndef _RTE_COMPRESSDEV_H_
#define _RTE_COMPRESSDEV_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <rte_common.h>

#include "rte_comp.h"

struct rte_param_log2_range {
        uint8_t min;    
        uint8_t max;    
        uint8_t increment;
};

struct rte_compressdev_capabilities {
        enum rte_comp_algorithm algo;
        /* Compression algorithm */
        uint64_t comp_feature_flags;
        struct rte_param_log2_range window_size;
};

#define RTE_COMP_END_OF_CAPABILITIES_LIST() \
        { RTE_COMP_ALGO_UNSPECIFIED }

const struct rte_compressdev_capabilities * __rte_experimental
rte_compressdev_capability_get(uint8_t dev_id,
                        enum rte_comp_algorithm algo);

#define RTE_COMPDEV_FF_HW_ACCELERATED           (1ULL << 0)

#define RTE_COMPDEV_FF_CPU_SSE                  (1ULL << 1)

#define RTE_COMPDEV_FF_CPU_AVX                  (1ULL << 2)

#define RTE_COMPDEV_FF_CPU_AVX2                 (1ULL << 3)

#define RTE_COMPDEV_FF_CPU_AVX512               (1ULL << 4)

#define RTE_COMPDEV_FF_CPU_NEON                 (1ULL << 5)

const char * __rte_experimental
rte_compressdev_get_feature_name(uint64_t flag);

struct rte_compressdev_info {
        const char *driver_name;                
        uint64_t feature_flags;                 
        const struct rte_compressdev_capabilities *capabilities;
        uint16_t max_nb_queue_pairs;
};

struct rte_compressdev_stats {
        uint64_t enqueued_count;
        uint64_t dequeued_count;
        uint64_t enqueue_err_count;
        uint64_t dequeue_err_count;
};


int __rte_experimental
rte_compressdev_get_dev_id(const char *name);

const char * __rte_experimental
rte_compressdev_name_get(uint8_t dev_id);

uint8_t __rte_experimental
rte_compressdev_count(void);

uint8_t __rte_experimental
rte_compressdev_devices_get(const char *driver_name, uint8_t *devices,
                uint8_t nb_devices);

/*
 * Return the NUMA socket to which a device is connected.
 *
 * @param dev_id
 *   Compress device identifier
 * @return
 *   The NUMA socket id to which the device is connected or
 *   a default of zero if the socket could not be determined.
 *   -1 if returned is the dev_id value is out of range.
 */
int __rte_experimental
rte_compressdev_socket_id(uint8_t dev_id);

struct rte_compressdev_config {
        int socket_id;
        uint16_t nb_queue_pairs;
        uint16_t max_nb_priv_xforms;
        uint16_t max_nb_streams;
};

int __rte_experimental
rte_compressdev_configure(uint8_t dev_id,
                        struct rte_compressdev_config *config);

int __rte_experimental
rte_compressdev_start(uint8_t dev_id);

void __rte_experimental
rte_compressdev_stop(uint8_t dev_id);

int __rte_experimental
rte_compressdev_close(uint8_t dev_id);

int __rte_experimental
rte_compressdev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id,
                uint32_t max_inflight_ops, int socket_id);

uint16_t __rte_experimental
rte_compressdev_queue_pair_count(uint8_t dev_id);


int __rte_experimental
rte_compressdev_stats_get(uint8_t dev_id, struct rte_compressdev_stats *stats);

void __rte_experimental
rte_compressdev_stats_reset(uint8_t dev_id);

void __rte_experimental
rte_compressdev_info_get(uint8_t dev_id, struct rte_compressdev_info *dev_info);

uint16_t __rte_experimental
rte_compressdev_dequeue_burst(uint8_t dev_id, uint16_t qp_id,
                struct rte_comp_op **ops, uint16_t nb_ops);

uint16_t __rte_experimental
rte_compressdev_enqueue_burst(uint8_t dev_id, uint16_t qp_id,
                struct rte_comp_op **ops, uint16_t nb_ops);

int __rte_experimental
rte_compressdev_stream_create(uint8_t dev_id,
                const struct rte_comp_xform *xform,
                void **stream);

int __rte_experimental
rte_compressdev_stream_free(uint8_t dev_id, void *stream);

int __rte_experimental
rte_compressdev_private_xform_create(uint8_t dev_id,
                const struct rte_comp_xform *xform,
                void **private_xform);

int __rte_experimental
rte_compressdev_private_xform_free(uint8_t dev_id, void *private_xform);

#ifdef __cplusplus
}
#endif

#endif /* _RTE_COMPRESSDEV_H_ */