dao_virtio_cryptodev.h

Go to the documentation of this file.

/* SPDX-License-Identifier: Marvell-MIT
 * Copyright (c) 2025 Marvell
 */
 
#ifndef __INCLUDE_DAO_VIRTIO_CRYPTO_H__
#define __INCLUDE_DAO_VIRTIO_CRYPTO_H__
 
#include <rte_common.h>
#include <rte_crypto.h>
#include <rte_crypto_asym.h>
 
#include <dao_virtio.h>
 
#define DAO_VIRTIO_CRYPTO_DEV_MAX 1
/* TODO - should be 64 */
#define DAO_VIRTIO_CRYPTO_QP_MAX 128
 
#define DAO_VIRTIO_INVALID_ID 0xFFFF
 
#define DAO_VIRTIO_CRYPTO_RX_BUF_CACHE_SZ 128
#define DAO_VIRTIO_CRYPTO_TX_BUF_CACHE_SZ 512
 
#define DAO_VIRTIO_CRYPTO_MAX_CHAIN_READ_DESC  4
#define DAO_VIRTIO_CRYPTO_MAX_CHAIN_WRITE_DESC 4
 
struct dao_virtio_cryptodev_conf {
    uint16_t pem_devid;
    uint16_t dma_vchan;
    struct rte_mempool *pool;
    uint16_t cdev_id;
};
 
/* End of structure dao_virtio_cryptodev_conf. */
 
struct dao_virtio_cryptodev {
    void *qs[DAO_VIRTIO_MAX_QUEUES] __rte_cache_aligned;
    uint16_t deq_fn_id;
    uint16_t enq_fn_id;
    uint16_t mgmt_fn_id;
    uint16_t cdev_id;
    uint8_t cdev_qp_id_map[DAO_VIRTIO_CRYPTO_QP_MAX];
#define DAO_VIRTIO_CRYPTODEV_MEM_SZ 8192
    uint8_t reserved[DAO_VIRTIO_CRYPTODEV_MEM_SZ];
};
 
struct dao_virtio_crypto_buffer {
    struct {
        union {
            struct {
                uint16_t id;
                uint16_t qp_id;
            } cdev;
            struct {
                uint16_t dev_id;
                uint16_t q_id;
            } virt;
        };
        /* Count of packets from same queue */
        uint16_t cnt;
    } metadata;
 
    uint32_t output_len;
    rte_iova_t output_addr;
    struct rte_crypto_op cop;
    struct rte_crypto_asym_op asym;
    uint8_t reserved[];
};
 
struct dao_virtio_cryptodev_vdev_q {
    uint16_t virtio_dev_id;
    uint16_t virtio_queue_id;
};
 
extern struct dao_virtio_cryptodev dao_virtio_cryptodevs[];
 
/* Fast path data */
typedef uint16_t (*dao_virtio_crypto_deq_fn_t)(void *q, struct rte_crypto_op **cops,
                           uint16_t nb_cops);
typedef uint16_t (*dao_virtio_crypto_enq_fn_t)(void *q, struct rte_crypto_op **cops,
                           uint16_t nb_cops);
typedef int (*dao_crypto_desc_manage_fn_t)(uint16_t devid, uint16_t qp_count);
 
extern dao_virtio_crypto_deq_fn_t dao_virtio_crypto_deq_fns[];
extern dao_virtio_crypto_enq_fn_t dao_virtio_crypto_enq_fns[];
extern dao_crypto_desc_manage_fn_t dao_crypto_desc_manage_fns[];
 
typedef int (*dao_virtio_cryptodev_status_cb_t)(uint16_t devid, uint8_t status);
 
typedef uint64_t (*dao_virtio_cryptodev_sym_sess_create_cb_t)(uint16_t dev_id,
                                  struct rte_crypto_sym_xform *x);
typedef uint64_t (*dao_virtio_cryptodev_asym_sess_create_cb_t)(uint16_t dev_id,
                                   struct rte_crypto_asym_xform *x);
typedef void (*dao_virtio_cryptodev_session_destroy_cb_t)(uint16_t dev_id, uint64_t session_id);
 
struct dao_virtio_cryptodev_cbs {
    dao_virtio_cryptodev_status_cb_t status_cb;
    dao_virtio_cryptodev_sym_sess_create_cb_t sym_sess_create_cb;
    dao_virtio_cryptodev_session_destroy_cb_t sym_sess_destroy_cb;
    dao_virtio_cryptodev_asym_sess_create_cb_t asym_sess_create_cb;
    dao_virtio_cryptodev_session_destroy_cb_t asym_sess_destroy_cb;
};
 
/* End of structure dao_virtio_cryptodev_cbs. */
 
int dao_virtio_cryptodev_init(uint16_t devid, struct dao_virtio_cryptodev_conf *conf);
 
int dao_virtio_cryptodev_fini(uint16_t devid);
 
void dao_virtio_cryptodev_cb_register(struct dao_virtio_cryptodev_cbs *cbs);
 
void dao_virtio_cryptodev_cb_unregister(void);
 
uint16_t dao_virtio_cryptodev_data_queue_cnt_get(uint16_t dev_id);
 
uint16_t dao_virtio_cryptodev_max_dataqueue_cnt_get(uint16_t dev_id);
 
void dao_virtio_cryptodev_common_cfg_init(void);
 
int dao_virtio_cryptodev_cdev_add(uint16_t dev_id, uint16_t qp_count,
                  struct rte_mempool *mempool[]);
 
int dao_virtio_cryptodev_cdev_remove(uint16_t dev_id);
 
int dao_virtio_cryptodev_cdev_queue_assign(uint16_t virt_dev_id, uint16_t virt_queue_id);
 
int dao_virtio_cryptodev_cdev_queue_release(uint16_t virt_dev_id, uint16_t virt_queue_id);
 
int dao_virtio_cryptodev_cdev_map_queue_get(uint16_t virt_dev_id, uint16_t virt_queue_id,
                        uint16_t *cdev_id, uint16_t *cdev_qp_id,
                        struct rte_mempool **mempool);
 
int dao_virtio_cryptodev_virt_dev_map_queue_get(uint16_t cdev_id, uint16_t cdev_qp_id,
                        uint16_t *virt_dev_id, uint16_t *virt_queue_id);
const struct dao_virtio_cryptodev_vdev_q *
dao_virtio_cryptodev_cdev_map_all_queues_get(uint16_t cdev_id);
 
static __rte_always_inline int
dao_virtio_crypto_desc_manage(uint16_t devid, uint16_t qp_count)
{
    struct dao_virtio_cryptodev *cryptodev = &dao_virtio_cryptodevs[devid];
    dao_crypto_desc_manage_fn_t mgmt_fn;
 
    mgmt_fn = dao_crypto_desc_manage_fns[cryptodev->mgmt_fn_id];
 
    return (*mgmt_fn)(devid, qp_count);
}
 
static __rte_always_inline uint16_t
dao_virtio_crypto_host_rx(uint16_t devid, uint16_t qid, struct rte_crypto_op **cops,
              uint16_t nb_cops)
{
    struct dao_virtio_cryptodev *cryptodev = &dao_virtio_cryptodevs[devid];
    dao_virtio_crypto_deq_fn_t deq_fn;
    void *q = cryptodev->qs[qid];
 
    if (unlikely(!q))
        return 0;
 
    deq_fn = dao_virtio_crypto_deq_fns[cryptodev->deq_fn_id];
 
    return (*deq_fn)(q, cops, nb_cops);
}
 
static __rte_always_inline uint16_t
dao_virtio_crypto_host_tx(uint16_t devid, uint16_t qid, struct rte_crypto_op **cops,
              uint16_t nb_cops)
{
    struct dao_virtio_cryptodev *cryptodev = &dao_virtio_cryptodevs[devid];
    dao_virtio_crypto_enq_fn_t enq_fn;
    void *q = cryptodev->qs[qid];
 
    if (unlikely(q == NULL))
        return 0;
 
    enq_fn = dao_virtio_crypto_enq_fns[cryptodev->enq_fn_id];
 
    return (*enq_fn)(q, cops, nb_cops);
}
 
static __rte_always_inline uint16_t
dao_virtio_cdev_id_get(uint16_t virt_dev_id)
{
    struct dao_virtio_cryptodev *cryptodev = &dao_virtio_cryptodevs[virt_dev_id];
 
    return cryptodev->cdev_id;
}
 
static __rte_always_inline uint16_t
dao_virtio_cdev_qp_id_get(uint16_t virt_dev_id, uint16_t virt_q_id)
{
    struct dao_virtio_cryptodev *cryptodev = &dao_virtio_cryptodevs[virt_dev_id];
 
    return cryptodev->cdev_qp_id_map[virt_q_id];
}
 
void dao_virtio_crypto_tx_desc_dma_completion(uint16_t devid, uint16_t qid);
 
#endif /* __INCLUDE_DAO_VIRTIO_CRYPTO_H__ */