#include <stdio.h>
#include <inttypes.h>
+#include <rte_string_fns.h>
#include <rte_malloc.h>
#include <rte_eal.h>
#include <rte_memzone.h>
#define RTE_COMPRESSDEV_DETACHED (0)
#define RTE_COMPRESSDEV_ATTACHED (1)
-struct rte_compressdev rte_comp_devices[RTE_COMPRESS_MAX_DEVS];
-
-struct rte_compressdev *rte_compressdevs = &rte_comp_devices[0];
+static struct rte_compressdev rte_comp_devices[RTE_COMPRESS_MAX_DEVS];
static struct rte_compressdev_global compressdev_globals = {
- .devs = &rte_comp_devices[0],
+ .devs = rte_comp_devices,
.data = { NULL },
.nb_devs = 0,
.max_devs = RTE_COMPRESS_MAX_DEVS
};
-struct rte_compressdev_global *rte_compressdev_globals = &compressdev_globals;
+const struct rte_compressdev_capabilities *
+rte_compressdev_capability_get(uint8_t dev_id,
+ enum rte_comp_algorithm algo)
+{
+ const struct rte_compressdev_capabilities *capability;
+ struct rte_compressdev_info dev_info;
+ int i = 0;
+
+ if (dev_id >= compressdev_globals.nb_devs) {
+ COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
+ return NULL;
+ }
+ rte_compressdev_info_get(dev_id, &dev_info);
+
+ while ((capability = &dev_info.capabilities[i++])->algo !=
+ RTE_COMP_ALGO_UNSPECIFIED){
+ if (capability->algo == algo)
+ return capability;
+ }
+
+ return NULL;
+}
+
+const char *
+rte_compressdev_get_feature_name(uint64_t flag)
+{
+ switch (flag) {
+ case RTE_COMPDEV_FF_HW_ACCELERATED:
+ return "HW_ACCELERATED";
+ case RTE_COMPDEV_FF_CPU_SSE:
+ return "CPU_SSE";
+ case RTE_COMPDEV_FF_CPU_AVX:
+ return "CPU_AVX";
+ case RTE_COMPDEV_FF_CPU_AVX2:
+ return "CPU_AVX2";
+ case RTE_COMPDEV_FF_CPU_AVX512:
+ return "CPU_AVX512";
+ case RTE_COMPDEV_FF_CPU_NEON:
+ return "CPU_NEON";
+ case RTE_COMPDEV_FF_OP_DONE_IN_DEQUEUE:
+ return "OP_DONE_IN_DEQ";
+ default:
+ return NULL;
+ }
+}
static struct rte_compressdev *
rte_compressdev_get_dev(uint8_t dev_id)
{
- return &rte_compressdev_globals->devs[dev_id];
+ return &compressdev_globals.devs[dev_id];
}
-struct rte_compressdev * __rte_experimental
+struct rte_compressdev *
rte_compressdev_pmd_get_named_dev(const char *name)
{
struct rte_compressdev *dev;
if (name == NULL)
return NULL;
- for (i = 0; i < rte_compressdev_globals->max_devs; i++) {
- dev = &rte_compressdev_globals->devs[i];
+ for (i = 0; i < compressdev_globals.max_devs; i++) {
+ dev = &compressdev_globals.devs[i];
if ((dev->attached == RTE_COMPRESSDEV_ATTACHED) &&
(strcmp(dev->data->name, name) == 0))
{
struct rte_compressdev *dev = NULL;
- if (dev_id >= rte_compressdev_globals->nb_devs)
+ if (dev_id >= compressdev_globals.nb_devs)
return 0;
dev = rte_compressdev_get_dev(dev_id);
}
-uint8_t __rte_experimental
+int
+rte_compressdev_get_dev_id(const char *name)
+{
+ unsigned int i;
+
+ if (name == NULL)
+ return -1;
+
+ for (i = 0; i < compressdev_globals.nb_devs; i++)
+ if ((strcmp(compressdev_globals.devs[i].data->name, name)
+ == 0) &&
+ (compressdev_globals.devs[i].attached ==
+ RTE_COMPRESSDEV_ATTACHED))
+ return i;
+
+ return -1;
+}
+
+uint8_t
rte_compressdev_count(void)
{
- return rte_compressdev_globals->nb_devs;
+ return compressdev_globals.nb_devs;
}
-uint8_t __rte_experimental
+uint8_t
rte_compressdev_devices_get(const char *driver_name, uint8_t *devices,
uint8_t nb_devices)
{
uint8_t i, count = 0;
- struct rte_compressdev *devs = rte_compressdev_globals->devs;
- uint8_t max_devs = rte_compressdev_globals->max_devs;
+ struct rte_compressdev *devs = compressdev_globals.devs;
+ uint8_t max_devs = compressdev_globals.max_devs;
for (i = 0; i < max_devs && count < nb_devices; i++) {
return count;
}
-int __rte_experimental
+int
rte_compressdev_socket_id(uint8_t dev_id)
{
struct rte_compressdev *dev;
return RTE_COMPRESS_MAX_DEVS;
}
-struct rte_compressdev * __rte_experimental
+struct rte_compressdev *
rte_compressdev_pmd_allocate(const char *name, int socket_id)
{
struct rte_compressdev *compressdev;
compressdev->data = compressdev_data;
- snprintf(compressdev->data->name, RTE_COMPRESSDEV_NAME_MAX_LEN,
- "%s", name);
+ strlcpy(compressdev->data->name, name,
+ RTE_COMPRESSDEV_NAME_MAX_LEN);
compressdev->data->dev_id = dev_id;
compressdev->data->socket_id = socket_id;
return compressdev;
}
-int __rte_experimental
+int
rte_compressdev_pmd_release_device(struct rte_compressdev *compressdev)
{
int ret;
return 0;
}
-uint16_t __rte_experimental
+uint16_t
rte_compressdev_queue_pair_count(uint8_t dev_id)
{
struct rte_compressdev *dev;
return 0;
}
-int __rte_experimental
+int
rte_compressdev_configure(uint8_t dev_id, struct rte_compressdev_config *config)
{
struct rte_compressdev *dev;
return (*dev->dev_ops->dev_configure)(dev, config);
}
-int __rte_experimental
+int
rte_compressdev_start(uint8_t dev_id)
{
struct rte_compressdev *dev;
return 0;
}
-void __rte_experimental
+void
rte_compressdev_stop(uint8_t dev_id)
{
struct rte_compressdev *dev;
dev->data->dev_started = 0;
}
-int __rte_experimental
+int
rte_compressdev_close(uint8_t dev_id)
{
struct rte_compressdev *dev;
return 0;
}
-int __rte_experimental
+int
rte_compressdev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id,
uint32_t max_inflight_ops, int socket_id)
{
max_inflight_ops, socket_id);
}
-void __rte_experimental
+uint16_t
+rte_compressdev_dequeue_burst(uint8_t dev_id, uint16_t qp_id,
+ struct rte_comp_op **ops, uint16_t nb_ops)
+{
+ struct rte_compressdev *dev = &rte_comp_devices[dev_id];
+
+ nb_ops = (*dev->dequeue_burst)
+ (dev->data->queue_pairs[qp_id], ops, nb_ops);
+
+ return nb_ops;
+}
+
+uint16_t
+rte_compressdev_enqueue_burst(uint8_t dev_id, uint16_t qp_id,
+ struct rte_comp_op **ops, uint16_t nb_ops)
+{
+ struct rte_compressdev *dev = &rte_comp_devices[dev_id];
+
+ return (*dev->enqueue_burst)(
+ dev->data->queue_pairs[qp_id], ops, nb_ops);
+}
+
+int
+rte_compressdev_stats_get(uint8_t dev_id, struct rte_compressdev_stats *stats)
+{
+ struct rte_compressdev *dev;
+
+ if (!rte_compressdev_is_valid_dev(dev_id)) {
+ COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
+ return -ENODEV;
+ }
+
+ if (stats == NULL) {
+ COMPRESSDEV_LOG(ERR, "Invalid stats ptr");
+ return -EINVAL;
+ }
+
+ dev = &rte_comp_devices[dev_id];
+ memset(stats, 0, sizeof(*stats));
+
+ RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stats_get, -ENOTSUP);
+ (*dev->dev_ops->stats_get)(dev, stats);
+ return 0;
+}
+
+void
+rte_compressdev_stats_reset(uint8_t dev_id)
+{
+ struct rte_compressdev *dev;
+
+ if (!rte_compressdev_is_valid_dev(dev_id)) {
+ COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
+ return;
+ }
+
+ dev = &rte_comp_devices[dev_id];
+
+ RTE_FUNC_PTR_OR_RET(*dev->dev_ops->stats_reset);
+ (*dev->dev_ops->stats_reset)(dev);
+}
+
+
+void
rte_compressdev_info_get(uint8_t dev_id, struct rte_compressdev_info *dev_info)
{
struct rte_compressdev *dev;
dev_info->driver_name = dev->device->driver->name;
}
-const char * __rte_experimental
+int
+rte_compressdev_private_xform_create(uint8_t dev_id,
+ const struct rte_comp_xform *xform,
+ void **priv_xform)
+{
+ struct rte_compressdev *dev;
+ int ret;
+
+ dev = rte_compressdev_get_dev(dev_id);
+
+ if (xform == NULL || priv_xform == NULL || dev == NULL)
+ return -EINVAL;
+
+ RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_create, -ENOTSUP);
+ ret = (*dev->dev_ops->private_xform_create)(dev, xform, priv_xform);
+ if (ret < 0) {
+ COMPRESSDEV_LOG(ERR,
+ "dev_id %d failed to create private_xform: err=%d",
+ dev_id, ret);
+ return ret;
+ };
+
+ return 0;
+}
+
+int
+rte_compressdev_private_xform_free(uint8_t dev_id, void *priv_xform)
+{
+ struct rte_compressdev *dev;
+ int ret;
+
+ dev = rte_compressdev_get_dev(dev_id);
+
+ if (dev == NULL || priv_xform == NULL)
+ return -EINVAL;
+
+ RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_free, -ENOTSUP);
+ ret = dev->dev_ops->private_xform_free(dev, priv_xform);
+ if (ret < 0) {
+ COMPRESSDEV_LOG(ERR,
+ "dev_id %d failed to free private xform: err=%d",
+ dev_id, ret);
+ return ret;
+ };
+
+ return 0;
+}
+
+int
+rte_compressdev_stream_create(uint8_t dev_id,
+ const struct rte_comp_xform *xform,
+ void **stream)
+{
+ struct rte_compressdev *dev;
+ int ret;
+
+ dev = rte_compressdev_get_dev(dev_id);
+
+ if (xform == NULL || dev == NULL || stream == NULL)
+ return -EINVAL;
+
+ RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stream_create, -ENOTSUP);
+ ret = (*dev->dev_ops->stream_create)(dev, xform, stream);
+ if (ret < 0) {
+ COMPRESSDEV_LOG(ERR,
+ "dev_id %d failed to create stream: err=%d",
+ dev_id, ret);
+ return ret;
+ };
+
+ return 0;
+}
+
+
+int
+rte_compressdev_stream_free(uint8_t dev_id, void *stream)
+{
+ struct rte_compressdev *dev;
+ int ret;
+
+ dev = rte_compressdev_get_dev(dev_id);
+
+ if (dev == NULL || stream == NULL)
+ return -EINVAL;
+
+ RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stream_free, -ENOTSUP);
+ ret = dev->dev_ops->stream_free(dev, stream);
+ if (ret < 0) {
+ COMPRESSDEV_LOG(ERR,
+ "dev_id %d failed to free stream: err=%d",
+ dev_id, ret);
+ return ret;
+ };
+
+ return 0;
+}
+
+const char *
rte_compressdev_name_get(uint8_t dev_id)
{
struct rte_compressdev *dev = rte_compressdev_get_dev(dev_id);
return dev->data->name;
}
-RTE_INIT(rte_compressdev_log);
-
-static void
-rte_compressdev_log(void)
-{
- compressdev_logtype = rte_log_register("lib.compressdev");
- if (compressdev_logtype >= 0)
- rte_log_set_level(compressdev_logtype, RTE_LOG_NOTICE);
-}
+RTE_LOG_REGISTER(compressdev_logtype, lib.compressdev, NOTICE);
git.droids-corp.org / dpdk.git / blobdiff