rte_event_crypto_adapter.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2018 Intel Corporation.
 * All rights reserved.
 */
 
#ifndef _RTE_EVENT_CRYPTO_ADAPTER_
#define _RTE_EVENT_CRYPTO_ADAPTER_
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>
 
#include "rte_eventdev.h"
 
enum rte_event_crypto_adapter_mode {
    RTE_EVENT_CRYPTO_ADAPTER_OP_NEW,
    RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD,
};
 
struct rte_event_crypto_request {
    uint8_t resv[8];
    uint16_t cdev_id;
    uint16_t queue_pair_id;
    uint32_t resv1;
};
 
union rte_event_crypto_metadata {
    struct rte_event_crypto_request request_info;
    struct rte_event response_info;
};
 
struct rte_event_crypto_adapter_conf {
    uint8_t event_port_id;
    uint32_t max_nb;
};
 
#define RTE_EVENT_CRYPTO_ADAPTER_EVENT_VECTOR   0x1
struct rte_event_crypto_adapter_queue_conf {
    uint32_t flags;
    struct rte_event ev;
    uint16_t vector_sz;
    uint64_t vector_timeout_ns;
    struct rte_mempool *vector_mp;
};
 
struct rte_event_crypto_adapter_vector_limits {
    uint16_t min_sz;
    uint16_t max_sz;
    uint8_t log2_sz;
    uint64_t min_timeout_ns;
    uint64_t max_timeout_ns;
};
 
typedef int (*rte_event_crypto_adapter_conf_cb) (uint8_t id, uint8_t dev_id,
            struct rte_event_crypto_adapter_conf *conf,
            void *arg);
 
struct rte_event_crypto_adapter_stats {
    uint64_t event_poll_count;
    uint64_t event_deq_count;
    uint64_t crypto_enq_count;
    uint64_t crypto_enq_fail;
    uint64_t crypto_deq_count;
    uint64_t event_enq_count;
    uint64_t event_enq_retry_count;
    uint64_t event_enq_fail_count;
};
 
int
rte_event_crypto_adapter_create_ext(uint8_t id, uint8_t dev_id,
                    rte_event_crypto_adapter_conf_cb conf_cb,
                    enum rte_event_crypto_adapter_mode mode,
                    void *conf_arg);
 
int
rte_event_crypto_adapter_create(uint8_t id, uint8_t dev_id,
                struct rte_event_port_conf *port_config,
                enum rte_event_crypto_adapter_mode mode);
 
int
rte_event_crypto_adapter_free(uint8_t id);
 
int
rte_event_crypto_adapter_queue_pair_add(uint8_t id,
            uint8_t cdev_id,
            int32_t queue_pair_id,
            const struct rte_event_crypto_adapter_queue_conf *conf);
 
int
rte_event_crypto_adapter_queue_pair_del(uint8_t id, uint8_t cdev_id,
                    int32_t queue_pair_id);
 
int
rte_event_crypto_adapter_start(uint8_t id);
 
int
rte_event_crypto_adapter_stop(uint8_t id);
 
int
rte_event_crypto_adapter_stats_get(uint8_t id,
                struct rte_event_crypto_adapter_stats *stats);
 
int
rte_event_crypto_adapter_stats_reset(uint8_t id);
 
int
rte_event_crypto_adapter_service_id_get(uint8_t id, uint32_t *service_id);
 
int
rte_event_crypto_adapter_event_port_get(uint8_t id, uint8_t *event_port_id);
 
__rte_experimental
int rte_event_crypto_adapter_vector_limits_get(
    uint8_t dev_id, uint16_t cdev_id,
    struct rte_event_crypto_adapter_vector_limits *limits);
 
static inline uint16_t
rte_event_crypto_adapter_enqueue(uint8_t dev_id,
                uint8_t port_id,
                struct rte_event ev[],
                uint16_t nb_events)
{
    const struct rte_event_fp_ops *fp_ops;
    void *port;
 
    fp_ops = &rte_event_fp_ops[dev_id];
    port = fp_ops->data[port_id];
#ifdef RTE_LIBRTE_EVENTDEV_DEBUG
    if (dev_id >= RTE_EVENT_MAX_DEVS ||
        port_id >= RTE_EVENT_MAX_PORTS_PER_DEV) {
        rte_errno = EINVAL;
        return 0;
    }
 
    if (port == NULL) {
        rte_errno = EINVAL;
        return 0;
    }
#endif
    rte_eventdev_trace_crypto_adapter_enqueue(dev_id, port_id, ev,
        nb_events);
 
    return fp_ops->ca_enqueue(port, ev, nb_events);
}
 
#ifdef __cplusplus
}
#endif
#endif  /* _RTE_EVENT_CRYPTO_ADAPTER_ */