dao_virtio_netdev.h

Go to the documentation of this file.

/* SPDX-License-Identifier: Marvell-Proprietary
 * Copyright (c) 2023 Marvell
 */
 
#ifndef __INCLUDE_DAO_VIRTIO_NET_H__
#define __INCLUDE_DAO_VIRTIO_NET_H__
 
#include <rte_prefetch.h>
 
#include <dao_util.h>
#include <dao_virtio.h>
 
#include <spec/virtio_net.h>
 
struct dao_virtio_netdev_link_info {
    uint16_t status;
    uint32_t speed;
    uint8_t duplex;
};
 
struct dao_virtio_netdev_conf {
    uint16_t pem_devid;
#define DAO_VIRTIO_NETDEV_EXTBUF DAO_BIT_ULL(0)
    uint16_t flags;
    union {
        struct {
            struct rte_mempool *pool;
        };
        struct {
            uint16_t dataroom_size;
        };
    };
    uint16_t dma_vchan;
    uint16_t max_virt_qps_limit;
    bool auto_free_en;
    uint16_t reta_size;
    uint16_t hash_key_size;
    uint16_t mtu;
    uint8_t mac[VIRTIO_NET_ETHER_ADDR_LEN];
    struct dao_virtio_netdev_link_info link_info;
    bool csum_en;
};
 
/* End of structure dao_virtio_netdev_conf. */
 
struct dao_virtio_netdev {
    void *qs[DAO_VIRTIO_MAX_QUEUES] __rte_cache_aligned;
    uint16_t deq_fn_id;
    uint16_t enq_fn_id;
    uint16_t mgmt_fn_id;
#define DAO_VIRTIO_NETDEV_MEM_SZ 8192
    uint8_t reserved[DAO_VIRTIO_NETDEV_MEM_SZ];
};
 
struct __rte_packed_begin dao_virtio_net_hdr {
    uint64_t desc_data[2];
    struct virtio_net_hdr hdr;
} __rte_packed_end;
 
extern struct dao_virtio_netdev dao_virtio_netdevs[];
 
/* Fast path data */
typedef uint16_t (*dao_virtio_net_deq_fn_t)(void *q, struct rte_mbuf **mbufs, uint16_t nb_mbufs);
typedef uint16_t (*dao_virtio_net_enq_fn_t)(void *q, struct rte_mbuf **mbufs, uint16_t nb_mbufs);
typedef int (*dao_net_desc_manage_fn_t)(uint16_t devid, uint16_t qp_count);
 
extern dao_virtio_net_deq_fn_t dao_virtio_net_deq_fns[];
extern dao_virtio_net_deq_fn_t dao_virtio_net_deq_ops_fns[];
extern dao_virtio_net_enq_fn_t dao_virtio_net_enq_fns[];
extern dao_virtio_net_enq_fn_t dao_virtio_net_enq_ops_fns[];
extern dao_net_desc_manage_fn_t dao_net_desc_manage_ops_fns[];
extern dao_net_desc_manage_fn_t dao_net_desc_manage_fns[];
 
typedef uint16_t (*dao_virtio_net_deq_ext_fn_t)(void *q, void **vbufs, uint16_t nb_bufs);
typedef uint16_t (*dao_virtio_net_enq_ext_fn_t)(void *q, void **vbufs, uint16_t nb_bufs);
extern dao_virtio_net_deq_ext_fn_t dao_virtio_net_deq_ext_fns[];
extern dao_virtio_net_enq_ext_fn_t dao_virtio_net_enq_ext_fns[];
 
typedef int (*dao_virtio_netdev_rss_cb_t)(uint16_t devid, struct virtio_net_ctrl_rss *rss);
typedef int (*dao_virtio_netdev_status_cb_t)(uint16_t devid, uint8_t status);
typedef int (*dao_virtio_netdev_promisc_cb_t)(uint16_t devid, uint8_t enable);
typedef int (*dao_virtio_netdev_allmulti_cb_t)(uint16_t devid, uint8_t enable);
typedef int (*dao_virtio_netdev_mac_set_cb_t)(uint16_t devid, uint8_t *mac);
typedef int (*dao_virtio_netdev_mac_add_cb_t)(uint16_t devid, struct virtio_net_ctrl_mac *mac_tbl,
                          uint8_t type);
typedef int (*dao_virtio_netdev_mq_cfg_t)(uint16_t devid, bool qmap_set);
typedef int (*dao_virtio_netdev_vlan_t)(uint16_t devid, uint16_t vlan_tci);
typedef int (*dao_virtio_netdev_extbuf_get)(uint16_t devid, void *buffs[], uint16_t nb_buffs);
typedef int (*dao_virtio_netdev_extbuf_put)(uint16_t devid, void *buffs[], uint16_t nb_buffs);
 
struct dao_virtio_netdev_cbs {
    dao_virtio_netdev_status_cb_t status_cb;
    dao_virtio_netdev_rss_cb_t rss_cb;
    dao_virtio_netdev_promisc_cb_t promisc_cb;
    dao_virtio_netdev_allmulti_cb_t allmulti_cb;
    dao_virtio_netdev_mac_set_cb_t mac_set;
    dao_virtio_netdev_mac_add_cb_t mac_add;
    dao_virtio_netdev_mq_cfg_t mq_configure;
    dao_virtio_netdev_vlan_t vlan_add;
    dao_virtio_netdev_vlan_t vlan_del;
    dao_virtio_netdev_extbuf_get extbuf_get;
    dao_virtio_netdev_extbuf_put extbuf_put;
};
 
/* End of structure dao_virtio_netdev_cbs. */
 
int dao_virtio_netdev_init(uint16_t devid, struct dao_virtio_netdev_conf *conf);
 
int dao_virtio_netdev_fini(uint16_t devid);
 
void dao_virtio_netdev_cb_register(struct dao_virtio_netdev_cbs *cbs);
 
void dao_virtio_netdev_cb_unregister(void);
 
int dao_virtio_netdev_queue_count(uint16_t devid);
 
uint64_t dao_virtio_netdev_feature_bits_get(uint16_t devid);
 
int dao_virtio_netdev_queue_count_max(uint16_t pem_devid, uint16_t devid);
 
int dao_virtio_netdev_link_sts_update(uint16_t devid, struct dao_virtio_netdev_link_info *info);
 
uint8_t dao_virtio_netdev_hdrlen_get(uint16_t devid);
 
/* Fast path routines */
 
static __rte_always_inline int
dao_virtio_net_desc_manage(uint16_t devid, uint16_t qp_count)
{
    struct dao_virtio_netdev *netdev = &dao_virtio_netdevs[devid];
    dao_net_desc_manage_fn_t mgmt_fn;
    mgmt_fn = dao_net_desc_manage_fns[netdev->mgmt_fn_id];
 
    return (*mgmt_fn)(devid, qp_count);
}
 
static __rte_always_inline int
dao_virtio_net_desc_manage_ops(uint16_t devid, uint16_t qp_count)
{
    struct dao_virtio_netdev *netdev = &dao_virtio_netdevs[devid];
    dao_net_desc_manage_fn_t mgmt_fn;
 
    mgmt_fn = dao_net_desc_manage_ops_fns[netdev->mgmt_fn_id];
 
    return (*mgmt_fn)(devid, qp_count);
}
 
static __rte_always_inline uint16_t
dao_virtio_net_dequeue_burst(uint16_t devid, uint16_t qid, struct rte_mbuf **mbufs,
                 uint16_t nb_mbufs)
{
    struct dao_virtio_netdev *netdev = &dao_virtio_netdevs[devid];
    dao_virtio_net_deq_fn_t deq_fn;
    void *q = netdev->qs[qid];
 
    if (unlikely(!q))
        return 0;
 
    deq_fn = dao_virtio_net_deq_fns[netdev->deq_fn_id];
 
    return (*deq_fn)(q, mbufs, nb_mbufs);
}
 
static __rte_always_inline uint16_t
dao_virtio_net_dequeue_burst_ops(uint16_t devid, uint16_t qid, struct rte_mbuf **mbufs,
                 uint16_t nb_mbufs)
{
    struct dao_virtio_netdev *netdev = &dao_virtio_netdevs[devid];
    dao_virtio_net_deq_fn_t deq_fn;
    void *q = netdev->qs[qid];
 
    if (unlikely(!q))
        return 0;
 
    rte_prefetch0(q);
    rte_prefetch0(RTE_PTR_ADD(q, RTE_CACHE_LINE_SIZE * 2));
    rte_prefetch0(RTE_PTR_ADD(q, RTE_CACHE_LINE_SIZE * 6));
 
    deq_fn = dao_virtio_net_deq_ops_fns[netdev->deq_fn_id];
 
    return (*deq_fn)(q, mbufs, nb_mbufs);
}
 
static __rte_always_inline uint16_t
dao_virtio_net_enqueue_burst(uint16_t devid, uint16_t qid, struct rte_mbuf **mbufs,
                 uint16_t nb_mbufs)
{
    struct dao_virtio_netdev *netdev = &dao_virtio_netdevs[devid];
    dao_virtio_net_enq_fn_t enq_fn;
    void *q = netdev->qs[qid];
 
    if (unlikely(!q))
        return 0;
 
    enq_fn = dao_virtio_net_enq_fns[netdev->enq_fn_id];
 
    return (*enq_fn)(q, mbufs, nb_mbufs);
}
 
static __rte_always_inline uint16_t
dao_virtio_net_enqueue_burst_ops(uint16_t devid, uint16_t qid, struct rte_mbuf **mbufs,
                 uint16_t nb_mbufs)
{
    struct dao_virtio_netdev *netdev = &dao_virtio_netdevs[devid];
    dao_virtio_net_enq_fn_t enq_fn;
    void *q = netdev->qs[qid];
 
    if (unlikely(!q))
        return 0;
 
    rte_prefetch0(q);
    rte_prefetch0(RTE_PTR_ADD(q, RTE_CACHE_LINE_SIZE * 2));
    rte_prefetch0(RTE_PTR_ADD(q, RTE_CACHE_LINE_SIZE * 6));
 
    enq_fn = dao_virtio_net_enq_ops_fns[netdev->enq_fn_id];
 
    return (*enq_fn)(q, mbufs, nb_mbufs);
}
 
static __rte_always_inline uint16_t
dao_virtio_net_dequeue_burst_ext(uint16_t devid, uint16_t qid, void **vbufs, uint16_t nb_bufs)
{
    struct dao_virtio_netdev *netdev = &dao_virtio_netdevs[devid];
    dao_virtio_net_deq_ext_fn_t deq_fn;
    void *q = netdev->qs[qid];
 
    if (unlikely(!q))
        return 0;
 
    deq_fn = dao_virtio_net_deq_ext_fns[netdev->deq_fn_id];
 
    return (*deq_fn)(q, vbufs, nb_bufs);
}
 
static __rte_always_inline uint16_t
dao_virtio_net_enqueue_burst_ext(uint16_t devid, uint16_t qid, void **vbufs, uint16_t nb_bufs)
{
    struct dao_virtio_netdev *netdev = &dao_virtio_netdevs[devid];
    dao_virtio_net_enq_ext_fn_t enq_fn;
    void *q = netdev->qs[qid];
 
    if (unlikely(!q))
        return 0;
 
    enq_fn = dao_virtio_net_enq_ext_fns[netdev->enq_fn_id];
 
    return (*enq_fn)(q, vbufs, nb_bufs);
}
 
#endif /* __INCLUDE_DAO_VIRTIO_NET_H__ */