dao_virtio_blkdev.h

Go to the documentation of this file.

/* SPDX-License-Identifier: Marvell-Proprietary
 * Copyright (c) 2025 Marvell
 */
 
#ifndef __INCLUDE_DAO_VIRTIO_BLK_H__
#define __INCLUDE_DAO_VIRTIO_BLK_H__
 
#include <dao_virtio.h>
#include <dao_util.h>
 
#include <spec/virtio_blk.h>
 
struct dao_virtio_blkdev_conf {
    uint16_t pem_devid;
    uint64_t capacity;
    uint32_t blk_size;
    uint32_t seg_size_max;
    uint32_t seg_max;
    uint16_t dma_vchan;
#define DAO_VIRTIO_BLKDEV_EXTBUF    DAO_BIT_ULL(0)
    /* Config flags */
    uint16_t flags;
    union {
        struct {
            struct rte_mempool *pool;
        };
        struct {
            uint16_t dataroom_size;
        };
    };
    uint16_t max_virt_queues;
    uint64_t feat_bits;
    bool auto_free_en;
};
 
/* End of structure dao_virtio_blkdev_conf. */
 
struct dao_virtio_blk_hdr {
    uint64_t desc_data[2];
    uint8_t *status;
    uint32_t tot_len;
    uint32_t tot_segs;
    uint32_t tot_bufs;
    uint8_t hdr_data[];
} __rte_packed;
 
typedef struct dao_virtio_blkdev {
    void *qs[DAO_VIRTIO_MAX_QUEUES] __rte_cache_aligned;
    uint16_t deq_fn_id;
    uint16_t compl_fn_id;
    uint16_t mgmt_fn_id;
 
#define DAO_VIRTIO_BLKDEV_MEM_SZ 8192
    uint8_t reserved[DAO_VIRTIO_BLKDEV_MEM_SZ];
} dao_virtio_blkdev_t;
 
typedef enum {
    DAO_VIRTIO_BLK_REQ_COMPLETE,
    DAO_VIRTIO_BLK_REQ_IN_PROGRESS
} dao_virtio_blk_req_status_t;
 
extern struct dao_virtio_blkdev dao_virtio_blkdevs[];
 
/* Fast path data */
typedef uint16_t (*dao_virtio_blk_deq_fn_t)(void *q, void **mbufs,
                        uint16_t nb_mbufs);
typedef uint16_t (*dao_virtio_blk_deq_ext_fn_t)(void *q, void **vbufs,
                        uint16_t nb_bufs);
typedef uint16_t (*dao_virtio_blk_process_compl_fn_t)(void *q,
            void **mbufs, uint16_t nb_compl);
typedef uint16_t (*dao_virtio_blk_process_compl_ext_fn_t)(void *q, void **vbufs,
                            uint16_t nb_compl);
typedef int (*dao_virtio_blk_desc_manage_fn_t)(uint16_t devid, uint16_t qp_count);
typedef int (*dao_virtio_blk_desc_manage_ext_fn_t)(uint16_t devid, uint16_t qp_count);
 
extern dao_virtio_blk_deq_fn_t dao_virtio_blk_deq_fns[];
extern dao_virtio_blk_deq_ext_fn_t dao_virtio_blk_deq_ext_fns[];
extern dao_virtio_blk_process_compl_fn_t dao_virtio_blk_process_compl_fns[];
extern dao_virtio_blk_process_compl_ext_fn_t dao_virtio_blk_process_compl_ext_fns[];
extern dao_virtio_blk_desc_manage_fn_t dao_blk_desc_manage_fns[];
extern dao_virtio_blk_desc_manage_ext_fn_t dao_blk_desc_manage_ext_fns[];
 
typedef int (*dao_virtio_blkdev_status_cb_t)(uint16_t devid, uint8_t status);
typedef int (*dao_virtio_blkdev_mq_cfg_t)(uint16_t devid, bool qmap_set);
typedef int (*dao_virtio_blkdev_extbuf_get)(uint16_t devid, void *buffs[],
                    uint16_t nb_buffs);
typedef int (*dao_virtio_blkdev_extbuf_put)(uint16_t devid, void *buffs[],
                    uint16_t nb_buffs);
 
struct dao_virtio_blkdev_cbs {
    dao_virtio_blkdev_status_cb_t status_cb;
    dao_virtio_blkdev_extbuf_get extbuf_get;
    dao_virtio_blkdev_extbuf_put extbuf_put;
};
 
/* End of structure dao_virtio_blkdev_cbs. */
 
int dao_virtio_blkdev_init(uint16_t devid, struct dao_virtio_blkdev_conf *conf);
 
int dao_virtio_blkdev_fini(uint16_t devid);
 
void dao_virtio_blkdev_cb_register(struct dao_virtio_blkdev_cbs *cbs);
 
void dao_virtio_blkdev_cb_unregister(void);
 
int dao_virtio_blkdev_queue_count(uint16_t devid);
 
uint64_t dao_virtio_blkdev_feature_bits_get(uint16_t devid);
 
int dao_virtio_blkdev_queue_count_max(uint16_t pem_devid, uint16_t devid);
 
static __rte_always_inline int
dao_virtio_blk_io_desc_manage(uint16_t devid, uint16_t q_count)
{
    struct dao_virtio_blkdev *blkdev = &dao_virtio_blkdevs[devid];
    dao_virtio_blk_desc_manage_fn_t mgmt_fn;
 
    mgmt_fn = dao_blk_desc_manage_fns[blkdev->mgmt_fn_id];
 
    return (*mgmt_fn)(devid, q_count);
}
 
static __rte_always_inline uint16_t
dao_virtio_blk_process_compl(uint16_t devid, uint16_t qid,
                 void **mbufs, uint16_t nb_compl)
{
    struct dao_virtio_blkdev *blkdev = &dao_virtio_blkdevs[devid];
    dao_virtio_blk_process_compl_fn_t compl_fn;
    void *q = blkdev->qs[qid];
 
    if (unlikely(!q))
        return 0;
 
    compl_fn = dao_virtio_blk_process_compl_fns[blkdev->compl_fn_id];
 
    return (*compl_fn)(q, mbufs, nb_compl);
}
 
static __rte_always_inline uint16_t
dao_virtio_blk_process_compl_ext(uint16_t devid, uint16_t qid, void **vbufs,
                 uint16_t nb_compl)
{
    struct dao_virtio_blkdev *blkdev = &dao_virtio_blkdevs[devid];
    dao_virtio_blk_process_compl_ext_fn_t compl_fn;
    void *q = blkdev->qs[qid];
 
    if (unlikely(!q))
        return 0;
 
    compl_fn = dao_virtio_blk_process_compl_ext_fns[blkdev->compl_fn_id];
 
    return (*compl_fn)(q, vbufs, nb_compl);
}
 
static __rte_always_inline uint16_t
dao_virtio_blk_dequeue_burst(uint16_t devid, uint16_t qid,
                 void **mbufs, uint16_t nb_mbufs)
{
    struct dao_virtio_blkdev *blkdev = &dao_virtio_blkdevs[devid];
    dao_virtio_blk_deq_fn_t deq_fn;
    void *q = blkdev->qs[qid];
 
    if (unlikely(!q))
        return 0;
 
    deq_fn = dao_virtio_blk_deq_fns[blkdev->deq_fn_id];
 
    return (*deq_fn)(q, mbufs, nb_mbufs);
}
 
static __rte_always_inline uint16_t
dao_virtio_blk_dequeue_burst_ext(uint16_t devid, uint16_t qid, void **vbufs,
                 uint16_t nb_bufs)
{
    struct dao_virtio_blkdev *blkdev = &dao_virtio_blkdevs[devid];
    dao_virtio_blk_deq_ext_fn_t deq_fn;
    void *q = blkdev->qs[qid];
 
    if (unlikely(!q))
        return 0;
 
    deq_fn = dao_virtio_blk_deq_ext_fns[blkdev->deq_fn_id];
 
    return (*deq_fn)(q, vbufs, nb_bufs);
}
 
#endif /* __INCLUDE_DAO_VIRTIO_BLK_H__ */