struct rte_compressdev_global *rte_compressdev_globals = &compressdev_globals;
+const struct rte_compressdev_capabilities * __rte_experimental
+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_experimental
+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";
+ default:
+ return NULL;
+ }
+}
+
static struct rte_compressdev *
rte_compressdev_get_dev(uint8_t dev_id)
{
}
+int __rte_experimental
+rte_compressdev_get_dev_id(const char *name)
+{
+ unsigned int i;
+
+ if (name == NULL)
+ return -1;
+
+ for (i = 0; i < rte_compressdev_globals->nb_devs; i++)
+ if ((strcmp(rte_compressdev_globals->devs[i].data->name, name)
+ == 0) &&
+ (rte_compressdev_globals->devs[i].attached ==
+ RTE_COMPRESSDEV_ATTACHED))
+ return i;
+
+ return -1;
+}
+
uint8_t __rte_experimental
rte_compressdev_count(void)
{
return 0;
}
+uint16_t __rte_experimental
+rte_compressdev_queue_pair_count(uint8_t dev_id)
+{
+ struct rte_compressdev *dev;
+
+ dev = &rte_comp_devices[dev_id];
+ return dev->data->nb_queue_pairs;
+}
+
+static int
+rte_compressdev_queue_pairs_config(struct rte_compressdev *dev,
+ uint16_t nb_qpairs, int socket_id)
+{
+ struct rte_compressdev_info dev_info;
+ void **qp;
+ unsigned int i;
+
+ if ((dev == NULL) || (nb_qpairs < 1)) {
+ COMPRESSDEV_LOG(ERR, "invalid param: dev %p, nb_queues %u",
+ dev, nb_qpairs);
+ return -EINVAL;
+ }
+
+ COMPRESSDEV_LOG(DEBUG, "Setup %d queues pairs on device %u",
+ nb_qpairs, dev->data->dev_id);
+
+ memset(&dev_info, 0, sizeof(struct rte_compressdev_info));
+
+ RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_infos_get, -ENOTSUP);
+ (*dev->dev_ops->dev_infos_get)(dev, &dev_info);
+
+ if ((dev_info.max_nb_queue_pairs != 0) &&
+ (nb_qpairs > dev_info.max_nb_queue_pairs)) {
+ COMPRESSDEV_LOG(ERR, "Invalid num queue_pairs (%u) for dev %u",
+ nb_qpairs, dev->data->dev_id);
+ return -EINVAL;
+ }
+
+ if (dev->data->queue_pairs == NULL) { /* first time configuration */
+ dev->data->queue_pairs = rte_zmalloc_socket(
+ "compressdev->queue_pairs",
+ sizeof(dev->data->queue_pairs[0]) * nb_qpairs,
+ RTE_CACHE_LINE_SIZE, socket_id);
+
+ if (dev->data->queue_pairs == NULL) {
+ dev->data->nb_queue_pairs = 0;
+ COMPRESSDEV_LOG(ERR,
+ "failed to get memory for qp meta data, nb_queues %u",
+ nb_qpairs);
+ return -(ENOMEM);
+ }
+ } else { /* re-configure */
+ int ret;
+ uint16_t old_nb_queues = dev->data->nb_queue_pairs;
+
+ qp = dev->data->queue_pairs;
+
+ RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,
+ -ENOTSUP);
+
+ for (i = nb_qpairs; i < old_nb_queues; i++) {
+ ret = (*dev->dev_ops->queue_pair_release)(dev, i);
+ if (ret < 0)
+ return ret;
+ }
+
+ qp = rte_realloc(qp, sizeof(qp[0]) * nb_qpairs,
+ RTE_CACHE_LINE_SIZE);
+ if (qp == NULL) {
+ COMPRESSDEV_LOG(ERR,
+ "failed to realloc qp meta data, nb_queues %u",
+ nb_qpairs);
+ return -(ENOMEM);
+ }
+
+ if (nb_qpairs > old_nb_queues) {
+ uint16_t new_qs = nb_qpairs - old_nb_queues;
+
+ memset(qp + old_nb_queues, 0,
+ sizeof(qp[0]) * new_qs);
+ }
+
+ dev->data->queue_pairs = qp;
+
+ }
+ dev->data->nb_queue_pairs = nb_qpairs;
+ return 0;
+}
+
+static int
+rte_compressdev_queue_pairs_release(struct rte_compressdev *dev)
+{
+ uint16_t num_qps, i;
+ int ret;
+
+ if (dev == NULL) {
+ COMPRESSDEV_LOG(ERR, "invalid param: dev %p", dev);
+ return -EINVAL;
+ }
+
+ num_qps = dev->data->nb_queue_pairs;
+
+ if (num_qps == 0)
+ return 0;
+
+ COMPRESSDEV_LOG(DEBUG, "Free %d queues pairs on device %u",
+ dev->data->nb_queue_pairs, dev->data->dev_id);
+
+ RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,
+ -ENOTSUP);
+
+ for (i = 0; i < num_qps; i++) {
+ ret = (*dev->dev_ops->queue_pair_release)(dev, i);
+ if (ret < 0)
+ return ret;
+ }
+
+ if (dev->data->queue_pairs != NULL)
+ rte_free(dev->data->queue_pairs);
+ dev->data->queue_pairs = NULL;
+ dev->data->nb_queue_pairs = 0;
+
+ return 0;
+}
+
int __rte_experimental
rte_compressdev_configure(uint8_t dev_id, struct rte_compressdev_config *config)
{
struct rte_compressdev *dev;
+ int diag;
if (!rte_compressdev_is_valid_dev(dev_id)) {
COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_configure, -ENOTSUP);
+ /* Setup new number of queue pairs and reconfigure device. */
+ diag = rte_compressdev_queue_pairs_config(dev, config->nb_queue_pairs,
+ config->socket_id);
+ if (diag != 0) {
+ COMPRESSDEV_LOG(ERR,
+ "dev%d rte_comp_dev_queue_pairs_config = %d",
+ dev_id, diag);
+ return diag;
+ }
+
return (*dev->dev_ops->dev_configure)(dev, config);
}
-
int __rte_experimental
rte_compressdev_start(uint8_t dev_id)
{
return -EBUSY;
}
+ /* Free queue pairs memory */
+ retval = rte_compressdev_queue_pairs_release(dev);
+
+ if (retval < 0)
+ return retval;
+
RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_close, -ENOTSUP);
retval = (*dev->dev_ops->dev_close)(dev);
return 0;
}
+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)
+{
+ struct rte_compressdev *dev;
+
+ if (!rte_compressdev_is_valid_dev(dev_id)) {
+ COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
+ return -EINVAL;
+ }
+
+ dev = &rte_comp_devices[dev_id];
+ if (queue_pair_id >= dev->data->nb_queue_pairs) {
+ COMPRESSDEV_LOG(ERR, "Invalid queue_pair_id=%d", queue_pair_id);
+ return -EINVAL;
+ }
+
+ if (dev->data->dev_started) {
+ COMPRESSDEV_LOG(ERR,
+ "device %d must be stopped to allow configuration", dev_id);
+ return -EBUSY;
+ }
+
+ if (max_inflight_ops == 0) {
+ COMPRESSDEV_LOG(ERR,
+ "Invalid maximum number of inflight operations");
+ return -EINVAL;
+ }
+
+ RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_setup, -ENOTSUP);
+
+ return (*dev->dev_ops->queue_pair_setup)(dev, queue_pair_id,
+ max_inflight_ops, socket_id);
+}
+
+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)
+{
+ struct rte_compressdev *dev = &rte_compressdevs[dev_id];
+
+ nb_ops = (*dev->dequeue_burst)
+ (dev->data->queue_pairs[qp_id], ops, nb_ops);
+
+ return 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)
+{
+ struct rte_compressdev *dev = &rte_compressdevs[dev_id];
+
+ return (*dev->enqueue_burst)(
+ dev->data->queue_pairs[qp_id], ops, nb_ops);
+}
+
+int __rte_experimental
+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_experimental
+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_experimental
rte_compressdev_info_get(uint8_t dev_id, struct rte_compressdev_info *dev_info)
{
dev_info->driver_name = dev->device->driver->name;
}
+int __rte_experimental
+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_experimental
+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_experimental
+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_experimental
+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_experimental
rte_compressdev_name_get(uint8_t dev_id)
{
return dev->data->name;
}
-RTE_INIT(rte_compressdev_log);
-
-static void
-rte_compressdev_log(void)
+RTE_INIT(rte_compressdev_log)
{
compressdev_logtype = rte_log_register("lib.compressdev");
if (compressdev_logtype >= 0)
git.droids-corp.org / dpdk.git / blobdiff