rte_ethdev.h

Go to the documentation of this file.

/*-
 *   BSD LICENSE
 *
 *   Copyright(c) 2010-2016 Intel Corporation. All rights reserved.
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *     * Neither the name of Intel Corporation nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _RTE_ETHDEV_H_
#define _RTE_ETHDEV_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <stdint.h>

#include <rte_dev.h>

/* Use this macro to check if LRO API is supported */
#define RTE_ETHDEV_HAS_LRO_SUPPORT

#include <rte_log.h>
#include <rte_interrupts.h>
#include <rte_pci.h>
#include <rte_dev.h>
#include <rte_devargs.h>
#include "rte_ether.h"
#include "rte_eth_ctrl.h"
#include "rte_dev_info.h"

struct rte_mbuf;

struct rte_eth_stats {
    uint64_t ipackets;  
    uint64_t opackets;  
    uint64_t ibytes;    
    uint64_t obytes;    
    uint64_t imissed;
    uint64_t ierrors;   
    uint64_t oerrors;   
    uint64_t rx_nombuf; 
    uint64_t q_ipackets[RTE_ETHDEV_QUEUE_STAT_CNTRS];
    uint64_t q_opackets[RTE_ETHDEV_QUEUE_STAT_CNTRS];
    uint64_t q_ibytes[RTE_ETHDEV_QUEUE_STAT_CNTRS];
    uint64_t q_obytes[RTE_ETHDEV_QUEUE_STAT_CNTRS];
    uint64_t q_errors[RTE_ETHDEV_QUEUE_STAT_CNTRS];
};

#define ETH_LINK_SPEED_AUTONEG  (0 <<  0)  
#define ETH_LINK_SPEED_FIXED    (1 <<  0)  
#define ETH_LINK_SPEED_10M_HD   (1 <<  1)  
#define ETH_LINK_SPEED_10M      (1 <<  2)  
#define ETH_LINK_SPEED_100M_HD  (1 <<  3)  
#define ETH_LINK_SPEED_100M     (1 <<  4)  
#define ETH_LINK_SPEED_1G       (1 <<  5)  
#define ETH_LINK_SPEED_2_5G     (1 <<  6)  
#define ETH_LINK_SPEED_5G       (1 <<  7)  
#define ETH_LINK_SPEED_10G      (1 <<  8)  
#define ETH_LINK_SPEED_20G      (1 <<  9)  
#define ETH_LINK_SPEED_25G      (1 << 10)  
#define ETH_LINK_SPEED_40G      (1 << 11)  
#define ETH_LINK_SPEED_50G      (1 << 12)  
#define ETH_LINK_SPEED_56G      (1 << 13)  
#define ETH_LINK_SPEED_100G     (1 << 14)  
#define ETH_SPEED_NUM_NONE         0 
#define ETH_SPEED_NUM_10M         10 
#define ETH_SPEED_NUM_100M       100 
#define ETH_SPEED_NUM_1G        1000 
#define ETH_SPEED_NUM_2_5G      2500 
#define ETH_SPEED_NUM_5G        5000 
#define ETH_SPEED_NUM_10G      10000 
#define ETH_SPEED_NUM_20G      20000 
#define ETH_SPEED_NUM_25G      25000 
#define ETH_SPEED_NUM_40G      40000 
#define ETH_SPEED_NUM_50G      50000 
#define ETH_SPEED_NUM_56G      56000 
#define ETH_SPEED_NUM_100G    100000 
__extension__
struct rte_eth_link {
    uint32_t link_speed;        
    uint16_t link_duplex  : 1;  
    uint16_t link_autoneg : 1;  
    uint16_t link_status  : 1;  
} __attribute__((aligned(8)));      
/* Utility constants */
#define ETH_LINK_HALF_DUPLEX 0 
#define ETH_LINK_FULL_DUPLEX 1 
#define ETH_LINK_DOWN        0 
#define ETH_LINK_UP          1 
#define ETH_LINK_FIXED       0 
#define ETH_LINK_AUTONEG     1 
struct rte_eth_thresh {
    uint8_t pthresh; 
    uint8_t hthresh; 
    uint8_t wthresh; 
};

#define ETH_MQ_RX_RSS_FLAG  0x1
#define ETH_MQ_RX_DCB_FLAG  0x2
#define ETH_MQ_RX_VMDQ_FLAG 0x4

enum rte_eth_rx_mq_mode {
    ETH_MQ_RX_NONE = 0,

    ETH_MQ_RX_RSS = ETH_MQ_RX_RSS_FLAG,
    ETH_MQ_RX_DCB = ETH_MQ_RX_DCB_FLAG,
    ETH_MQ_RX_DCB_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_DCB_FLAG,

    ETH_MQ_RX_VMDQ_ONLY = ETH_MQ_RX_VMDQ_FLAG,
    ETH_MQ_RX_VMDQ_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_VMDQ_FLAG,
    ETH_MQ_RX_VMDQ_DCB = ETH_MQ_RX_VMDQ_FLAG | ETH_MQ_RX_DCB_FLAG,
    ETH_MQ_RX_VMDQ_DCB_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_DCB_FLAG |
                 ETH_MQ_RX_VMDQ_FLAG,
};

#define ETH_RSS                       ETH_MQ_RX_RSS
#define VMDQ_DCB                      ETH_MQ_RX_VMDQ_DCB
#define ETH_DCB_RX                    ETH_MQ_RX_DCB

enum rte_eth_tx_mq_mode {
    ETH_MQ_TX_NONE    = 0,  
    ETH_MQ_TX_DCB,          
    ETH_MQ_TX_VMDQ_DCB, 
    ETH_MQ_TX_VMDQ_ONLY,    
};

#define ETH_DCB_NONE                ETH_MQ_TX_NONE
#define ETH_VMDQ_DCB_TX             ETH_MQ_TX_VMDQ_DCB
#define ETH_DCB_TX                  ETH_MQ_TX_DCB

struct rte_eth_rxmode {
    enum rte_eth_rx_mq_mode mq_mode;
    uint32_t max_rx_pkt_len;  
    uint16_t split_hdr_size;  
    __extension__
    uint16_t header_split : 1, 
        hw_ip_checksum   : 1, 
        hw_vlan_filter   : 1, 
        hw_vlan_strip    : 1, 
        hw_vlan_extend   : 1, 
        jumbo_frame      : 1, 
        hw_strip_crc     : 1, 
        enable_scatter   : 1, 
        enable_lro       : 1; 
};

enum rte_vlan_type {
    ETH_VLAN_TYPE_UNKNOWN = 0,
    ETH_VLAN_TYPE_INNER, 
    ETH_VLAN_TYPE_OUTER, 
    ETH_VLAN_TYPE_MAX,
};

struct rte_eth_rss_conf {
    uint8_t *rss_key;    
    uint8_t rss_key_len; 
    uint64_t rss_hf;     
};

/*
 * The RSS offload types are defined based on flow types which are defined
 * in rte_eth_ctrl.h. Different NIC hardwares may support different RSS offload
 * types. The supported flow types or RSS offload types can be queried by
 * rte_eth_dev_info_get().
 */
#define ETH_RSS_IPV4               (1ULL << RTE_ETH_FLOW_IPV4)
#define ETH_RSS_FRAG_IPV4          (1ULL << RTE_ETH_FLOW_FRAG_IPV4)
#define ETH_RSS_NONFRAG_IPV4_TCP   (1ULL << RTE_ETH_FLOW_NONFRAG_IPV4_TCP)
#define ETH_RSS_NONFRAG_IPV4_UDP   (1ULL << RTE_ETH_FLOW_NONFRAG_IPV4_UDP)
#define ETH_RSS_NONFRAG_IPV4_SCTP  (1ULL << RTE_ETH_FLOW_NONFRAG_IPV4_SCTP)
#define ETH_RSS_NONFRAG_IPV4_OTHER (1ULL << RTE_ETH_FLOW_NONFRAG_IPV4_OTHER)
#define ETH_RSS_IPV6               (1ULL << RTE_ETH_FLOW_IPV6)
#define ETH_RSS_FRAG_IPV6          (1ULL << RTE_ETH_FLOW_FRAG_IPV6)
#define ETH_RSS_NONFRAG_IPV6_TCP   (1ULL << RTE_ETH_FLOW_NONFRAG_IPV6_TCP)
#define ETH_RSS_NONFRAG_IPV6_UDP   (1ULL << RTE_ETH_FLOW_NONFRAG_IPV6_UDP)
#define ETH_RSS_NONFRAG_IPV6_SCTP  (1ULL << RTE_ETH_FLOW_NONFRAG_IPV6_SCTP)
#define ETH_RSS_NONFRAG_IPV6_OTHER (1ULL << RTE_ETH_FLOW_NONFRAG_IPV6_OTHER)
#define ETH_RSS_L2_PAYLOAD         (1ULL << RTE_ETH_FLOW_L2_PAYLOAD)
#define ETH_RSS_IPV6_EX            (1ULL << RTE_ETH_FLOW_IPV6_EX)
#define ETH_RSS_IPV6_TCP_EX        (1ULL << RTE_ETH_FLOW_IPV6_TCP_EX)
#define ETH_RSS_IPV6_UDP_EX        (1ULL << RTE_ETH_FLOW_IPV6_UDP_EX)
#define ETH_RSS_PORT               (1ULL << RTE_ETH_FLOW_PORT)
#define ETH_RSS_VXLAN              (1ULL << RTE_ETH_FLOW_VXLAN)
#define ETH_RSS_GENEVE             (1ULL << RTE_ETH_FLOW_GENEVE)
#define ETH_RSS_NVGRE              (1ULL << RTE_ETH_FLOW_NVGRE)

#define ETH_RSS_IP ( \
    ETH_RSS_IPV4 | \
    ETH_RSS_FRAG_IPV4 | \
    ETH_RSS_NONFRAG_IPV4_OTHER | \
    ETH_RSS_IPV6 | \
    ETH_RSS_FRAG_IPV6 | \
    ETH_RSS_NONFRAG_IPV6_OTHER | \
    ETH_RSS_IPV6_EX)

#define ETH_RSS_UDP ( \
    ETH_RSS_NONFRAG_IPV4_UDP | \
    ETH_RSS_NONFRAG_IPV6_UDP | \
    ETH_RSS_IPV6_UDP_EX)

#define ETH_RSS_TCP ( \
    ETH_RSS_NONFRAG_IPV4_TCP | \
    ETH_RSS_NONFRAG_IPV6_TCP | \
    ETH_RSS_IPV6_TCP_EX)

#define ETH_RSS_SCTP ( \
    ETH_RSS_NONFRAG_IPV4_SCTP | \
    ETH_RSS_NONFRAG_IPV6_SCTP)

#define ETH_RSS_TUNNEL ( \
    ETH_RSS_VXLAN  | \
    ETH_RSS_GENEVE | \
    ETH_RSS_NVGRE)


#define ETH_RSS_PROTO_MASK ( \
    ETH_RSS_IPV4 | \
    ETH_RSS_FRAG_IPV4 | \
    ETH_RSS_NONFRAG_IPV4_TCP | \
    ETH_RSS_NONFRAG_IPV4_UDP | \
    ETH_RSS_NONFRAG_IPV4_SCTP | \
    ETH_RSS_NONFRAG_IPV4_OTHER | \
    ETH_RSS_IPV6 | \
    ETH_RSS_FRAG_IPV6 | \
    ETH_RSS_NONFRAG_IPV6_TCP | \
    ETH_RSS_NONFRAG_IPV6_UDP | \
    ETH_RSS_NONFRAG_IPV6_SCTP | \
    ETH_RSS_NONFRAG_IPV6_OTHER | \
    ETH_RSS_L2_PAYLOAD | \
    ETH_RSS_IPV6_EX | \
    ETH_RSS_IPV6_TCP_EX | \
    ETH_RSS_IPV6_UDP_EX | \
    ETH_RSS_PORT  | \
    ETH_RSS_VXLAN | \
    ETH_RSS_GENEVE | \
    ETH_RSS_NVGRE)

/*
 * Definitions used for redirection table entry size.
 * Some RSS RETA sizes may not be supported by some drivers, check the
 * documentation or the description of relevant functions for more details.
 */
#define ETH_RSS_RETA_SIZE_64  64
#define ETH_RSS_RETA_SIZE_128 128
#define ETH_RSS_RETA_SIZE_256 256
#define ETH_RSS_RETA_SIZE_512 512
#define RTE_RETA_GROUP_SIZE   64

/* Definitions used for VMDQ and DCB functionality */
#define ETH_VMDQ_MAX_VLAN_FILTERS   64 
#define ETH_DCB_NUM_USER_PRIORITIES 8  
#define ETH_VMDQ_DCB_NUM_QUEUES     128 
#define ETH_DCB_NUM_QUEUES          128 
/* DCB capability defines */
#define ETH_DCB_PG_SUPPORT      0x00000001 
#define ETH_DCB_PFC_SUPPORT     0x00000002 
/* Definitions used for VLAN Offload functionality */
#define ETH_VLAN_STRIP_OFFLOAD   0x0001 
#define ETH_VLAN_FILTER_OFFLOAD  0x0002 
#define ETH_VLAN_EXTEND_OFFLOAD  0x0004 
/* Definitions used for mask VLAN setting */
#define ETH_VLAN_STRIP_MASK   0x0001 
#define ETH_VLAN_FILTER_MASK  0x0002 
#define ETH_VLAN_EXTEND_MASK  0x0004 
#define ETH_VLAN_ID_MAX       0x0FFF 
/* Definitions used for receive MAC address   */
#define ETH_NUM_RECEIVE_MAC_ADDR  128 
/* Definitions used for unicast hash  */
#define ETH_VMDQ_NUM_UC_HASH_ARRAY  128 
/* Definitions used for VMDQ pool rx mode setting */
#define ETH_VMDQ_ACCEPT_UNTAG   0x0001 
#define ETH_VMDQ_ACCEPT_HASH_MC 0x0002 
#define ETH_VMDQ_ACCEPT_HASH_UC 0x0004 
#define ETH_VMDQ_ACCEPT_BROADCAST   0x0008 
#define ETH_VMDQ_ACCEPT_MULTICAST   0x0010 
#define ETH_MIRROR_MAX_VLANS       64

#define ETH_MIRROR_VIRTUAL_POOL_UP     0x01  
#define ETH_MIRROR_UPLINK_PORT         0x02  
#define ETH_MIRROR_DOWNLINK_PORT       0x04  
#define ETH_MIRROR_VLAN                0x08  
#define ETH_MIRROR_VIRTUAL_POOL_DOWN   0x10  
struct rte_eth_vlan_mirror {
    uint64_t vlan_mask; 
    uint16_t vlan_id[ETH_MIRROR_MAX_VLANS];
};

struct rte_eth_mirror_conf {
    uint8_t rule_type; 
    uint8_t dst_pool;  
    uint64_t pool_mask; 
    struct rte_eth_vlan_mirror vlan;
};

struct rte_eth_rss_reta_entry64 {
    uint64_t mask;
    uint16_t reta[RTE_RETA_GROUP_SIZE];
};

enum rte_eth_nb_tcs {
    ETH_4_TCS = 4, 
    ETH_8_TCS = 8  
};

enum rte_eth_nb_pools {
    ETH_8_POOLS = 8,    
    ETH_16_POOLS = 16,  
    ETH_32_POOLS = 32,  
    ETH_64_POOLS = 64   
};

/* This structure may be extended in future. */
struct rte_eth_dcb_rx_conf {
    enum rte_eth_nb_tcs nb_tcs; 
    uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
};

struct rte_eth_vmdq_dcb_tx_conf {
    enum rte_eth_nb_pools nb_queue_pools; 
    uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
};

struct rte_eth_dcb_tx_conf {
    enum rte_eth_nb_tcs nb_tcs; 
    uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
};

struct rte_eth_vmdq_tx_conf {
    enum rte_eth_nb_pools nb_queue_pools; 
};

struct rte_eth_vmdq_dcb_conf {
    enum rte_eth_nb_pools nb_queue_pools; 
    uint8_t enable_default_pool; 
    uint8_t default_pool; 
    uint8_t nb_pool_maps; 
    struct {
        uint16_t vlan_id; 
        uint64_t pools;   
    } pool_map[ETH_VMDQ_MAX_VLAN_FILTERS]; 
    uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
};

struct rte_eth_vmdq_rx_conf {
    enum rte_eth_nb_pools nb_queue_pools; 
    uint8_t enable_default_pool; 
    uint8_t default_pool; 
    uint8_t enable_loop_back; 
    uint8_t nb_pool_maps; 
    uint32_t rx_mode; 
    struct {
        uint16_t vlan_id; 
        uint64_t pools;   
    } pool_map[ETH_VMDQ_MAX_VLAN_FILTERS]; 
};

struct rte_eth_txmode {
    enum rte_eth_tx_mq_mode mq_mode; 
    /* For i40e specifically */
    uint16_t pvid;
    __extension__
    uint8_t hw_vlan_reject_tagged : 1,
        hw_vlan_reject_untagged : 1,
        hw_vlan_insert_pvid : 1;
};

struct rte_eth_rxconf {
    struct rte_eth_thresh rx_thresh; 
    uint16_t rx_free_thresh; 
    uint8_t rx_drop_en; 
    uint8_t rx_deferred_start; 
};

#define ETH_TXQ_FLAGS_NOMULTSEGS 0x0001 
#define ETH_TXQ_FLAGS_NOREFCOUNT 0x0002 
#define ETH_TXQ_FLAGS_NOMULTMEMP 0x0004 
#define ETH_TXQ_FLAGS_NOVLANOFFL 0x0100 
#define ETH_TXQ_FLAGS_NOXSUMSCTP 0x0200 
#define ETH_TXQ_FLAGS_NOXSUMUDP  0x0400 
#define ETH_TXQ_FLAGS_NOXSUMTCP  0x0800 
#define ETH_TXQ_FLAGS_NOOFFLOADS \
        (ETH_TXQ_FLAGS_NOVLANOFFL | ETH_TXQ_FLAGS_NOXSUMSCTP | \
         ETH_TXQ_FLAGS_NOXSUMUDP  | ETH_TXQ_FLAGS_NOXSUMTCP)
#define ETH_TXQ_FLAGS_NOXSUMS \
        (ETH_TXQ_FLAGS_NOXSUMSCTP | ETH_TXQ_FLAGS_NOXSUMUDP | \
         ETH_TXQ_FLAGS_NOXSUMTCP)

struct rte_eth_txconf {
    struct rte_eth_thresh tx_thresh; 
    uint16_t tx_rs_thresh; 
    uint16_t tx_free_thresh; 
    uint32_t txq_flags; 
    uint8_t tx_deferred_start; 
};

struct rte_eth_desc_lim {
    uint16_t nb_max;   
    uint16_t nb_min;   
    uint16_t nb_align; 
};

enum rte_eth_fc_mode {
    RTE_FC_NONE = 0, 
    RTE_FC_RX_PAUSE, 
    RTE_FC_TX_PAUSE, 
    RTE_FC_FULL      
};

struct rte_eth_fc_conf {
    uint32_t high_water;  
    uint32_t low_water;   
    uint16_t pause_time;  
    uint16_t send_xon;    
    enum rte_eth_fc_mode mode;  
    uint8_t mac_ctrl_frame_fwd; 
    uint8_t autoneg;      
};

struct rte_eth_pfc_conf {
    struct rte_eth_fc_conf fc; 
    uint8_t priority;          
};

enum rte_fdir_pballoc_type {
    RTE_FDIR_PBALLOC_64K = 0,  
    RTE_FDIR_PBALLOC_128K,     
    RTE_FDIR_PBALLOC_256K,     
};

enum rte_fdir_status_mode {
    RTE_FDIR_NO_REPORT_STATUS = 0, 
    RTE_FDIR_REPORT_STATUS, 
    RTE_FDIR_REPORT_STATUS_ALWAYS, 
};

struct rte_fdir_conf {
    enum rte_fdir_mode mode; 
    enum rte_fdir_pballoc_type pballoc; 
    enum rte_fdir_status_mode status;  
    uint8_t drop_queue;
    struct rte_eth_fdir_masks mask;
    struct rte_eth_fdir_flex_conf flex_conf;
};

struct rte_eth_udp_tunnel {
    uint16_t udp_port; 
    uint8_t prot_type; 
};

struct rte_intr_conf {
    uint16_t lsc;
    uint16_t rxq;
};

struct rte_eth_conf {
    uint32_t link_speeds; 
    struct rte_eth_rxmode rxmode; 
    struct rte_eth_txmode txmode; 
    uint32_t lpbk_mode; 
    struct {
        struct rte_eth_rss_conf rss_conf; 
        struct rte_eth_vmdq_dcb_conf vmdq_dcb_conf;
        struct rte_eth_dcb_rx_conf dcb_rx_conf;
        struct rte_eth_vmdq_rx_conf vmdq_rx_conf;
    } rx_adv_conf; 
    union {
        struct rte_eth_vmdq_dcb_tx_conf vmdq_dcb_tx_conf;
        struct rte_eth_dcb_tx_conf dcb_tx_conf;
        struct rte_eth_vmdq_tx_conf vmdq_tx_conf;
    } tx_adv_conf; 
    uint32_t dcb_capability_en;
    struct rte_fdir_conf fdir_conf; 
    struct rte_intr_conf intr_conf; 
};

#define DEV_RX_OFFLOAD_VLAN_STRIP  0x00000001
#define DEV_RX_OFFLOAD_IPV4_CKSUM  0x00000002
#define DEV_RX_OFFLOAD_UDP_CKSUM   0x00000004
#define DEV_RX_OFFLOAD_TCP_CKSUM   0x00000008
#define DEV_RX_OFFLOAD_TCP_LRO     0x00000010
#define DEV_RX_OFFLOAD_QINQ_STRIP  0x00000020
#define DEV_RX_OFFLOAD_OUTER_IPV4_CKSUM 0x00000040

#define DEV_TX_OFFLOAD_VLAN_INSERT 0x00000001
#define DEV_TX_OFFLOAD_IPV4_CKSUM  0x00000002
#define DEV_TX_OFFLOAD_UDP_CKSUM   0x00000004
#define DEV_TX_OFFLOAD_TCP_CKSUM   0x00000008
#define DEV_TX_OFFLOAD_SCTP_CKSUM  0x00000010
#define DEV_TX_OFFLOAD_TCP_TSO     0x00000020
#define DEV_TX_OFFLOAD_UDP_TSO     0x00000040
#define DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM 0x00000080 
#define DEV_TX_OFFLOAD_QINQ_INSERT 0x00000100
#define DEV_TX_OFFLOAD_VXLAN_TNL_TSO    0x00000200    
#define DEV_TX_OFFLOAD_GRE_TNL_TSO      0x00000400    
#define DEV_TX_OFFLOAD_IPIP_TNL_TSO     0x00000800    
#define DEV_TX_OFFLOAD_GENEVE_TNL_TSO   0x00001000    
struct rte_eth_dev_info {
    struct rte_pci_device *pci_dev; 
    const char *driver_name; 
    unsigned int if_index; 
    uint32_t min_rx_bufsize; 
    uint32_t max_rx_pktlen; 
    uint16_t max_rx_queues; 
    uint16_t max_tx_queues; 
    uint32_t max_mac_addrs; 
    uint32_t max_hash_mac_addrs;
    uint16_t max_vfs; 
    uint16_t max_vmdq_pools; 
    uint32_t rx_offload_capa; 
    uint32_t tx_offload_capa; 
    uint16_t reta_size;
    uint8_t hash_key_size; 
    uint64_t flow_type_rss_offloads;
    struct rte_eth_rxconf default_rxconf; 
    struct rte_eth_txconf default_txconf; 
    uint16_t vmdq_queue_base; 
    uint16_t vmdq_queue_num;  
    uint16_t vmdq_pool_base;  
    struct rte_eth_desc_lim rx_desc_lim;  
    struct rte_eth_desc_lim tx_desc_lim;  
    uint32_t speed_capa;  
    uint16_t nb_rx_queues; 
    uint16_t nb_tx_queues; 
};

struct rte_eth_rxq_info {
    struct rte_mempool *mp;     
    struct rte_eth_rxconf conf; 
    uint8_t scattered_rx;       
    uint16_t nb_desc;           
} __rte_cache_min_aligned;

struct rte_eth_txq_info {
    struct rte_eth_txconf conf; 
    uint16_t nb_desc;           
} __rte_cache_min_aligned;

#define RTE_ETH_XSTATS_NAME_SIZE 64

struct rte_eth_xstat {
    uint64_t id;
    uint64_t value;
};

struct rte_eth_xstat_name {
    char name[RTE_ETH_XSTATS_NAME_SIZE];
};

#define ETH_DCB_NUM_TCS    8
#define ETH_MAX_VMDQ_POOL  64

struct rte_eth_dcb_tc_queue_mapping {
    struct {
        uint8_t base;
        uint8_t nb_queue;
    } tc_rxq[ETH_MAX_VMDQ_POOL][ETH_DCB_NUM_TCS];
    struct {
        uint8_t base;
        uint8_t nb_queue;
    } tc_txq[ETH_MAX_VMDQ_POOL][ETH_DCB_NUM_TCS];
};

struct rte_eth_dcb_info {
    uint8_t nb_tcs;        
    uint8_t prio_tc[ETH_DCB_NUM_USER_PRIORITIES]; 
    uint8_t tc_bws[ETH_DCB_NUM_TCS]; 
    struct rte_eth_dcb_tc_queue_mapping tc_queue;
};

#define RTE_ETH_QUEUE_STATE_STOPPED 0
#define RTE_ETH_QUEUE_STATE_STARTED 1

struct rte_eth_dev;

struct rte_eth_dev_callback;
TAILQ_HEAD(rte_eth_dev_cb_list, rte_eth_dev_callback);

/* Macros to check for valid port */
#define RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, retval) do { \
    if (!rte_eth_dev_is_valid_port(port_id)) { \
        RTE_PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id); \
        return retval; \
    } \
} while (0)

#define RTE_ETH_VALID_PORTID_OR_RET(port_id) do { \
    if (!rte_eth_dev_is_valid_port(port_id)) { \
        RTE_PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id); \
        return; \
    } \
} while (0)

#define ETH_L2_TUNNEL_ENABLE_MASK       0x00000001

#define ETH_L2_TUNNEL_INSERTION_MASK    0x00000002

#define ETH_L2_TUNNEL_STRIPPING_MASK    0x00000004

#define ETH_L2_TUNNEL_FORWARDING_MASK   0x00000008

/*
 * Definitions of all functions exported by an Ethernet driver through the
 * the generic structure of type *eth_dev_ops* supplied in the *rte_eth_dev*
 * structure associated with an Ethernet device.
 */

typedef int  (*eth_dev_configure_t)(struct rte_eth_dev *dev);
typedef int  (*eth_dev_start_t)(struct rte_eth_dev *dev);
typedef void (*eth_dev_stop_t)(struct rte_eth_dev *dev);
typedef int  (*eth_dev_set_link_up_t)(struct rte_eth_dev *dev);
typedef int  (*eth_dev_set_link_down_t)(struct rte_eth_dev *dev);
typedef void (*eth_dev_close_t)(struct rte_eth_dev *dev);
typedef void (*eth_promiscuous_enable_t)(struct rte_eth_dev *dev);
typedef void (*eth_promiscuous_disable_t)(struct rte_eth_dev *dev);
typedef void (*eth_allmulticast_enable_t)(struct rte_eth_dev *dev);
typedef void (*eth_allmulticast_disable_t)(struct rte_eth_dev *dev);
typedef int (*eth_link_update_t)(struct rte_eth_dev *dev,
                int wait_to_complete);
typedef void (*eth_stats_get_t)(struct rte_eth_dev *dev,
                struct rte_eth_stats *igb_stats);
typedef void (*eth_stats_reset_t)(struct rte_eth_dev *dev);
typedef int (*eth_xstats_get_t)(struct rte_eth_dev *dev,
    struct rte_eth_xstat *stats, unsigned n);
typedef void (*eth_xstats_reset_t)(struct rte_eth_dev *dev);
typedef int (*eth_xstats_get_names_t)(struct rte_eth_dev *dev,
    struct rte_eth_xstat_name *xstats_names, unsigned size);
typedef int (*eth_queue_stats_mapping_set_t)(struct rte_eth_dev *dev,
                         uint16_t queue_id,
                         uint8_t stat_idx,
                         uint8_t is_rx);
typedef void (*eth_dev_infos_get_t)(struct rte_eth_dev *dev,
                    struct rte_eth_dev_info *dev_info);
typedef const uint32_t *(*eth_dev_supported_ptypes_get_t)(struct rte_eth_dev *dev);
typedef int (*eth_queue_start_t)(struct rte_eth_dev *dev,
                    uint16_t queue_id);
typedef int (*eth_queue_stop_t)(struct rte_eth_dev *dev,
                    uint16_t queue_id);
typedef int (*eth_rx_queue_setup_t)(struct rte_eth_dev *dev,
                    uint16_t rx_queue_id,
                    uint16_t nb_rx_desc,
                    unsigned int socket_id,
                    const struct rte_eth_rxconf *rx_conf,
                    struct rte_mempool *mb_pool);
typedef int (*eth_tx_queue_setup_t)(struct rte_eth_dev *dev,
                    uint16_t tx_queue_id,
                    uint16_t nb_tx_desc,
                    unsigned int socket_id,
                    const struct rte_eth_txconf *tx_conf);
typedef int (*eth_rx_enable_intr_t)(struct rte_eth_dev *dev,
                    uint16_t rx_queue_id);
typedef int (*eth_rx_disable_intr_t)(struct rte_eth_dev *dev,
                    uint16_t rx_queue_id);
typedef void (*eth_queue_release_t)(void *queue);
typedef uint32_t (*eth_rx_queue_count_t)(struct rte_eth_dev *dev,
                     uint16_t rx_queue_id);
typedef int (*eth_rx_descriptor_done_t)(void *rxq, uint16_t offset);
typedef void (*eth_rxq_info_get_t)(struct rte_eth_dev *dev,
    uint16_t rx_queue_id, struct rte_eth_rxq_info *qinfo);

typedef void (*eth_txq_info_get_t)(struct rte_eth_dev *dev,
    uint16_t tx_queue_id, struct rte_eth_txq_info *qinfo);

typedef int (*mtu_set_t)(struct rte_eth_dev *dev, uint16_t mtu);
typedef int (*vlan_filter_set_t)(struct rte_eth_dev *dev,
                  uint16_t vlan_id,
                  int on);
typedef int (*vlan_tpid_set_t)(struct rte_eth_dev *dev,
                   enum rte_vlan_type type, uint16_t tpid);
typedef void (*vlan_offload_set_t)(struct rte_eth_dev *dev, int mask);
typedef int (*vlan_pvid_set_t)(struct rte_eth_dev *dev,
                   uint16_t vlan_id,
                   int on);
typedef void (*vlan_strip_queue_set_t)(struct rte_eth_dev *dev,
                  uint16_t rx_queue_id,
                  int on);
typedef uint16_t (*eth_rx_burst_t)(void *rxq,
                   struct rte_mbuf **rx_pkts,
                   uint16_t nb_pkts);
typedef uint16_t (*eth_tx_burst_t)(void *txq,
                   struct rte_mbuf **tx_pkts,
                   uint16_t nb_pkts);
typedef int (*flow_ctrl_get_t)(struct rte_eth_dev *dev,
                   struct rte_eth_fc_conf *fc_conf);
typedef int (*flow_ctrl_set_t)(struct rte_eth_dev *dev,
                   struct rte_eth_fc_conf *fc_conf);
typedef int (*priority_flow_ctrl_set_t)(struct rte_eth_dev *dev,
                struct rte_eth_pfc_conf *pfc_conf);
typedef int (*reta_update_t)(struct rte_eth_dev *dev,
                 struct rte_eth_rss_reta_entry64 *reta_conf,
                 uint16_t reta_size);
typedef int (*reta_query_t)(struct rte_eth_dev *dev,
                struct rte_eth_rss_reta_entry64 *reta_conf,
                uint16_t reta_size);
typedef int (*rss_hash_update_t)(struct rte_eth_dev *dev,
                 struct rte_eth_rss_conf *rss_conf);
typedef int (*rss_hash_conf_get_t)(struct rte_eth_dev *dev,
                   struct rte_eth_rss_conf *rss_conf);
typedef int (*eth_dev_led_on_t)(struct rte_eth_dev *dev);
typedef int (*eth_dev_led_off_t)(struct rte_eth_dev *dev);
typedef void (*eth_mac_addr_remove_t)(struct rte_eth_dev *dev, uint32_t index);
typedef void (*eth_mac_addr_add_t)(struct rte_eth_dev *dev,
                  struct ether_addr *mac_addr,
                  uint32_t index,
                  uint32_t vmdq);
typedef void (*eth_mac_addr_set_t)(struct rte_eth_dev *dev,
                  struct ether_addr *mac_addr);
typedef int (*eth_uc_hash_table_set_t)(struct rte_eth_dev *dev,
                  struct ether_addr *mac_addr,
                  uint8_t on);
typedef int (*eth_uc_all_hash_table_set_t)(struct rte_eth_dev *dev,
                  uint8_t on);
typedef int (*eth_set_vf_rx_mode_t)(struct rte_eth_dev *dev,
                  uint16_t vf,
                  uint16_t rx_mode,
                  uint8_t on);
typedef int (*eth_set_vf_rx_t)(struct rte_eth_dev *dev,
                uint16_t vf,
                uint8_t on);
typedef int (*eth_set_vf_tx_t)(struct rte_eth_dev *dev,
                uint16_t vf,
                uint8_t on);
typedef int (*eth_set_vf_vlan_filter_t)(struct rte_eth_dev *dev,
                  uint16_t vlan,
                  uint64_t vf_mask,
                  uint8_t vlan_on);
typedef int (*eth_set_queue_rate_limit_t)(struct rte_eth_dev *dev,
                uint16_t queue_idx,
                uint16_t tx_rate);
typedef int (*eth_set_vf_rate_limit_t)(struct rte_eth_dev *dev,
                uint16_t vf,
                uint16_t tx_rate,
                uint64_t q_msk);
typedef int (*eth_mirror_rule_set_t)(struct rte_eth_dev *dev,
                  struct rte_eth_mirror_conf *mirror_conf,
                  uint8_t rule_id,
                  uint8_t on);
typedef int (*eth_mirror_rule_reset_t)(struct rte_eth_dev *dev,
                  uint8_t rule_id);
typedef int (*eth_udp_tunnel_port_add_t)(struct rte_eth_dev *dev,
                     struct rte_eth_udp_tunnel *tunnel_udp);
typedef int (*eth_udp_tunnel_port_del_t)(struct rte_eth_dev *dev,
                     struct rte_eth_udp_tunnel *tunnel_udp);
typedef int (*eth_set_mc_addr_list_t)(struct rte_eth_dev *dev,
                      struct ether_addr *mc_addr_set,
                      uint32_t nb_mc_addr);
typedef int (*eth_timesync_enable_t)(struct rte_eth_dev *dev);
typedef int (*eth_timesync_disable_t)(struct rte_eth_dev *dev);
typedef int (*eth_timesync_read_rx_timestamp_t)(struct rte_eth_dev *dev,
                        struct timespec *timestamp,
                        uint32_t flags);
typedef int (*eth_timesync_read_tx_timestamp_t)(struct rte_eth_dev *dev,
                        struct timespec *timestamp);
typedef int (*eth_timesync_adjust_time)(struct rte_eth_dev *dev, int64_t);
typedef int (*eth_timesync_read_time)(struct rte_eth_dev *dev,
                      struct timespec *timestamp);
typedef int (*eth_timesync_write_time)(struct rte_eth_dev *dev,
                       const struct timespec *timestamp);
typedef int (*eth_get_reg_t)(struct rte_eth_dev *dev,
                struct rte_dev_reg_info *info);
typedef int (*eth_get_eeprom_length_t)(struct rte_eth_dev *dev);
typedef int (*eth_get_eeprom_t)(struct rte_eth_dev *dev,
                struct rte_dev_eeprom_info *info);
typedef int (*eth_set_eeprom_t)(struct rte_eth_dev *dev,
                struct rte_dev_eeprom_info *info);
typedef int (*eth_l2_tunnel_eth_type_conf_t)
    (struct rte_eth_dev *dev, struct rte_eth_l2_tunnel_conf *l2_tunnel);
typedef int (*eth_l2_tunnel_offload_set_t)
    (struct rte_eth_dev *dev,
     struct rte_eth_l2_tunnel_conf *l2_tunnel,
     uint32_t mask,
     uint8_t en);
#ifdef RTE_NIC_BYPASS

enum {
    RTE_BYPASS_MODE_NONE,
    RTE_BYPASS_MODE_NORMAL,
    RTE_BYPASS_MODE_BYPASS,
    RTE_BYPASS_MODE_ISOLATE,
    RTE_BYPASS_MODE_NUM,
};

#define RTE_BYPASS_MODE_VALID(x)    \
    ((x) > RTE_BYPASS_MODE_NONE && (x) < RTE_BYPASS_MODE_NUM)

enum {
    RTE_BYPASS_EVENT_NONE,
    RTE_BYPASS_EVENT_START,
    RTE_BYPASS_EVENT_OS_ON = RTE_BYPASS_EVENT_START,
    RTE_BYPASS_EVENT_POWER_ON,
    RTE_BYPASS_EVENT_OS_OFF,
    RTE_BYPASS_EVENT_POWER_OFF,
    RTE_BYPASS_EVENT_TIMEOUT,
    RTE_BYPASS_EVENT_NUM
};

#define RTE_BYPASS_EVENT_VALID(x)   \
    ((x) > RTE_BYPASS_EVENT_NONE && (x) < RTE_BYPASS_MODE_NUM)

enum {
    RTE_BYPASS_TMT_OFF,     /* timeout disabled. */
    RTE_BYPASS_TMT_1_5_SEC, /* timeout for 1.5 seconds */
    RTE_BYPASS_TMT_2_SEC,   /* timeout for 2 seconds */
    RTE_BYPASS_TMT_3_SEC,   /* timeout for 3 seconds */
    RTE_BYPASS_TMT_4_SEC,   /* timeout for 4 seconds */
    RTE_BYPASS_TMT_8_SEC,   /* timeout for 8 seconds */
    RTE_BYPASS_TMT_16_SEC,  /* timeout for 16 seconds */
    RTE_BYPASS_TMT_32_SEC,  /* timeout for 32 seconds */
    RTE_BYPASS_TMT_NUM
};

#define RTE_BYPASS_TMT_VALID(x) \
    ((x) == RTE_BYPASS_TMT_OFF || \
    ((x) > RTE_BYPASS_TMT_OFF && (x) < RTE_BYPASS_TMT_NUM))

typedef void (*bypass_init_t)(struct rte_eth_dev *dev);
typedef int32_t (*bypass_state_set_t)(struct rte_eth_dev *dev, uint32_t *new_state);
typedef int32_t (*bypass_state_show_t)(struct rte_eth_dev *dev, uint32_t *state);
typedef int32_t (*bypass_event_set_t)(struct rte_eth_dev *dev, uint32_t state, uint32_t event);
typedef int32_t (*bypass_event_show_t)(struct rte_eth_dev *dev, uint32_t event_shift, uint32_t *event);
typedef int32_t (*bypass_wd_timeout_set_t)(struct rte_eth_dev *dev, uint32_t timeout);
typedef int32_t (*bypass_wd_timeout_show_t)(struct rte_eth_dev *dev, uint32_t *wd_timeout);
typedef int32_t (*bypass_ver_show_t)(struct rte_eth_dev *dev, uint32_t *ver);
typedef int32_t (*bypass_wd_reset_t)(struct rte_eth_dev *dev);
#endif

typedef int (*eth_filter_ctrl_t)(struct rte_eth_dev *dev,
                 enum rte_filter_type filter_type,
                 enum rte_filter_op filter_op,
                 void *arg);
typedef int (*eth_get_dcb_info)(struct rte_eth_dev *dev,
                 struct rte_eth_dcb_info *dcb_info);
struct eth_dev_ops {
    eth_dev_configure_t        dev_configure; 
    eth_dev_start_t            dev_start;     
    eth_dev_stop_t             dev_stop;      
    eth_dev_set_link_up_t      dev_set_link_up;   
    eth_dev_set_link_down_t    dev_set_link_down; 
    eth_dev_close_t            dev_close;     
    eth_promiscuous_enable_t   promiscuous_enable; 
    eth_promiscuous_disable_t  promiscuous_disable;
    eth_allmulticast_enable_t  allmulticast_enable;
    eth_allmulticast_disable_t allmulticast_disable;
    eth_link_update_t          link_update;   
    eth_stats_get_t            stats_get;     
    eth_stats_reset_t          stats_reset;   
    eth_xstats_get_t           xstats_get;    
    eth_xstats_reset_t         xstats_reset;  
    eth_xstats_get_names_t     xstats_get_names;
    eth_queue_stats_mapping_set_t queue_stats_mapping_set;
    eth_dev_infos_get_t        dev_infos_get; 
    eth_dev_supported_ptypes_get_t dev_supported_ptypes_get;
    mtu_set_t                  mtu_set; 
    vlan_filter_set_t          vlan_filter_set;  
    vlan_tpid_set_t            vlan_tpid_set;      
    vlan_strip_queue_set_t     vlan_strip_queue_set; 
    vlan_offload_set_t         vlan_offload_set; 
    vlan_pvid_set_t            vlan_pvid_set; 
    eth_queue_start_t          rx_queue_start;
    eth_queue_stop_t           rx_queue_stop;
    eth_queue_start_t          tx_queue_start;
    eth_queue_stop_t           tx_queue_stop;
    eth_rx_queue_setup_t       rx_queue_setup;
    eth_queue_release_t        rx_queue_release;
    eth_rx_queue_count_t       rx_queue_count; 
    eth_rx_descriptor_done_t   rx_descriptor_done;  
    eth_rx_enable_intr_t       rx_queue_intr_enable;
    eth_rx_disable_intr_t      rx_queue_intr_disable;
    eth_tx_queue_setup_t       tx_queue_setup;
    eth_queue_release_t        tx_queue_release;
    eth_dev_led_on_t           dev_led_on;    
    eth_dev_led_off_t          dev_led_off;   
    flow_ctrl_get_t            flow_ctrl_get; 
    flow_ctrl_set_t            flow_ctrl_set; 
    priority_flow_ctrl_set_t   priority_flow_ctrl_set; 
    eth_mac_addr_remove_t      mac_addr_remove; 
    eth_mac_addr_add_t         mac_addr_add;  
    eth_mac_addr_set_t         mac_addr_set;  
    eth_uc_hash_table_set_t    uc_hash_table_set;  
    eth_uc_all_hash_table_set_t uc_all_hash_table_set;  
    eth_mirror_rule_set_t      mirror_rule_set;  
    eth_mirror_rule_reset_t    mirror_rule_reset;  
    eth_set_vf_rx_mode_t       set_vf_rx_mode;   
    eth_set_vf_rx_t            set_vf_rx;  
    eth_set_vf_tx_t            set_vf_tx;  
    eth_set_vf_vlan_filter_t   set_vf_vlan_filter;  
    eth_udp_tunnel_port_add_t udp_tunnel_port_add;
    eth_udp_tunnel_port_del_t udp_tunnel_port_del;
    eth_set_queue_rate_limit_t set_queue_rate_limit;   
    eth_set_vf_rate_limit_t    set_vf_rate_limit;   
    reta_update_t reta_update;
    reta_query_t reta_query;

    eth_get_reg_t get_reg;
    eth_get_eeprom_length_t get_eeprom_length;
    eth_get_eeprom_t get_eeprom;
    eth_set_eeprom_t set_eeprom;
  /* bypass control */
#ifdef RTE_NIC_BYPASS
  bypass_init_t bypass_init;
  bypass_state_set_t bypass_state_set;
  bypass_state_show_t bypass_state_show;
  bypass_event_set_t bypass_event_set;
  bypass_event_show_t bypass_event_show;
  bypass_wd_timeout_set_t bypass_wd_timeout_set;
  bypass_wd_timeout_show_t bypass_wd_timeout_show;
  bypass_ver_show_t bypass_ver_show;
  bypass_wd_reset_t bypass_wd_reset;
#endif

    rss_hash_update_t rss_hash_update;
    rss_hash_conf_get_t rss_hash_conf_get;
    eth_filter_ctrl_t              filter_ctrl;
    eth_set_mc_addr_list_t set_mc_addr_list; 
    eth_rxq_info_get_t rxq_info_get;
    eth_txq_info_get_t txq_info_get;
    eth_timesync_enable_t timesync_enable;
    eth_timesync_disable_t timesync_disable;
    eth_timesync_read_rx_timestamp_t timesync_read_rx_timestamp;
    eth_timesync_read_tx_timestamp_t timesync_read_tx_timestamp;

    eth_get_dcb_info get_dcb_info;
    eth_timesync_adjust_time timesync_adjust_time;
    eth_timesync_read_time timesync_read_time;
    eth_timesync_write_time timesync_write_time;
    eth_l2_tunnel_eth_type_conf_t l2_tunnel_eth_type_conf;
    eth_l2_tunnel_offload_set_t l2_tunnel_offload_set;
};

typedef uint16_t (*rte_rx_callback_fn)(uint8_t port, uint16_t queue,
    struct rte_mbuf *pkts[], uint16_t nb_pkts, uint16_t max_pkts,
    void *user_param);

typedef uint16_t (*rte_tx_callback_fn)(uint8_t port, uint16_t queue,
    struct rte_mbuf *pkts[], uint16_t nb_pkts, void *user_param);

struct rte_eth_rxtx_callback {
    struct rte_eth_rxtx_callback *next;
    union{
        rte_rx_callback_fn rx;
        rte_tx_callback_fn tx;
    } fn;
    void *param;
};

struct rte_eth_dev {
    eth_rx_burst_t rx_pkt_burst; 
    eth_tx_burst_t tx_pkt_burst; 
    struct rte_eth_dev_data *data;  
    const struct eth_driver *driver;
    const struct eth_dev_ops *dev_ops; 
    struct rte_pci_device *pci_dev; 
    struct rte_eth_dev_cb_list link_intr_cbs;
    struct rte_eth_rxtx_callback *post_rx_burst_cbs[RTE_MAX_QUEUES_PER_PORT];
    struct rte_eth_rxtx_callback *pre_tx_burst_cbs[RTE_MAX_QUEUES_PER_PORT];
    uint8_t attached; 
} __rte_cache_aligned;

struct rte_eth_dev_sriov {
    uint8_t active;               
    uint8_t nb_q_per_pool;        
    uint16_t def_vmdq_idx;        
    uint16_t def_pool_q_idx;      
};
#define RTE_ETH_DEV_SRIOV(dev)         ((dev)->data->sriov)

#define RTE_ETH_NAME_MAX_LEN (32)

struct rte_eth_dev_data {
    char name[RTE_ETH_NAME_MAX_LEN]; 
    void **rx_queues; 
    void **tx_queues; 
    uint16_t nb_rx_queues; 
    uint16_t nb_tx_queues; 
    struct rte_eth_dev_sriov sriov;    
    void *dev_private;              
    struct rte_eth_link dev_link;
    struct rte_eth_conf dev_conf;   
    uint16_t mtu;                   
    uint32_t min_rx_buf_size;
    uint64_t rx_mbuf_alloc_failed; 
    struct ether_addr* mac_addrs;
    uint64_t mac_pool_sel[ETH_NUM_RECEIVE_MAC_ADDR];
    struct ether_addr* hash_mac_addrs;
    uint8_t port_id;           
    __extension__
    uint8_t promiscuous   : 1, 
        scattered_rx : 1,  
        all_multicast : 1, 
        dev_started : 1,   
        lro         : 1;   
    uint8_t rx_queue_state[RTE_MAX_QUEUES_PER_PORT];
    uint8_t tx_queue_state[RTE_MAX_QUEUES_PER_PORT];
    uint32_t dev_flags; 
    enum rte_kernel_driver kdrv;    
    int numa_node;  
    const char *drv_name;   
} __rte_cache_aligned;

#define RTE_ETH_DEV_DETACHABLE   0x0001

#define RTE_ETH_DEV_INTR_LSC     0x0002

#define RTE_ETH_DEV_BONDED_SLAVE 0x0004

extern struct rte_eth_dev rte_eth_devices[];

uint8_t rte_eth_dev_count(void);

struct rte_eth_dev *rte_eth_dev_allocated(const char *name);

struct rte_eth_dev *rte_eth_dev_allocate(const char *name);

int rte_eth_dev_release_port(struct rte_eth_dev *eth_dev);

int rte_eth_dev_attach(const char *devargs, uint8_t *port_id);

int rte_eth_dev_detach(uint8_t port_id, char *devname);

struct eth_driver;
typedef int (*eth_dev_init_t)(struct rte_eth_dev *eth_dev);

typedef int (*eth_dev_uninit_t)(struct rte_eth_dev *eth_dev);

struct eth_driver {
    struct rte_pci_driver pci_drv;    
    eth_dev_init_t eth_dev_init;      
    eth_dev_uninit_t eth_dev_uninit;  
    unsigned int dev_private_size;    
};

uint32_t rte_eth_speed_bitflag(uint32_t speed, int duplex);

int rte_eth_dev_configure(uint8_t port_id, uint16_t nb_rx_queue,
        uint16_t nb_tx_queue, const struct rte_eth_conf *eth_conf);

int rte_eth_rx_queue_setup(uint8_t port_id, uint16_t rx_queue_id,
        uint16_t nb_rx_desc, unsigned int socket_id,
        const struct rte_eth_rxconf *rx_conf,
        struct rte_mempool *mb_pool);

int rte_eth_tx_queue_setup(uint8_t port_id, uint16_t tx_queue_id,
        uint16_t nb_tx_desc, unsigned int socket_id,
        const struct rte_eth_txconf *tx_conf);

int rte_eth_dev_socket_id(uint8_t port_id);

int rte_eth_dev_is_valid_port(uint8_t port_id);

int rte_eth_dev_rx_queue_start(uint8_t port_id, uint16_t rx_queue_id);

int rte_eth_dev_rx_queue_stop(uint8_t port_id, uint16_t rx_queue_id);

int rte_eth_dev_tx_queue_start(uint8_t port_id, uint16_t tx_queue_id);

int rte_eth_dev_tx_queue_stop(uint8_t port_id, uint16_t tx_queue_id);



int rte_eth_dev_start(uint8_t port_id);

void rte_eth_dev_stop(uint8_t port_id);


int rte_eth_dev_set_link_up(uint8_t port_id);

int rte_eth_dev_set_link_down(uint8_t port_id);

void rte_eth_dev_close(uint8_t port_id);

void rte_eth_promiscuous_enable(uint8_t port_id);

void rte_eth_promiscuous_disable(uint8_t port_id);

int rte_eth_promiscuous_get(uint8_t port_id);

void rte_eth_allmulticast_enable(uint8_t port_id);

void rte_eth_allmulticast_disable(uint8_t port_id);

int rte_eth_allmulticast_get(uint8_t port_id);

void rte_eth_link_get(uint8_t port_id, struct rte_eth_link *link);

void rte_eth_link_get_nowait(uint8_t port_id, struct rte_eth_link *link);

int rte_eth_stats_get(uint8_t port_id, struct rte_eth_stats *stats);

void rte_eth_stats_reset(uint8_t port_id);

int rte_eth_xstats_get_names(uint8_t port_id,
        struct rte_eth_xstat_name *xstats_names,
        unsigned size);

int rte_eth_xstats_get(uint8_t port_id, struct rte_eth_xstat *xstats,
        unsigned n);

void rte_eth_xstats_reset(uint8_t port_id);

int rte_eth_dev_set_tx_queue_stats_mapping(uint8_t port_id,
        uint16_t tx_queue_id, uint8_t stat_idx);

int rte_eth_dev_set_rx_queue_stats_mapping(uint8_t port_id,
                       uint16_t rx_queue_id,
                       uint8_t stat_idx);

void rte_eth_macaddr_get(uint8_t port_id, struct ether_addr *mac_addr);

void rte_eth_dev_info_get(uint8_t port_id, struct rte_eth_dev_info *dev_info);

int rte_eth_dev_get_supported_ptypes(uint8_t port_id, uint32_t ptype_mask,
                     uint32_t *ptypes, int num);

int rte_eth_dev_get_mtu(uint8_t port_id, uint16_t *mtu);

int rte_eth_dev_set_mtu(uint8_t port_id, uint16_t mtu);

int rte_eth_dev_vlan_filter(uint8_t port_id, uint16_t vlan_id, int on);

int rte_eth_dev_set_vlan_strip_on_queue(uint8_t port_id, uint16_t rx_queue_id,
        int on);

int rte_eth_dev_set_vlan_ether_type(uint8_t port_id,
                    enum rte_vlan_type vlan_type,
                    uint16_t tag_type);

int rte_eth_dev_set_vlan_offload(uint8_t port_id, int offload_mask);

int rte_eth_dev_get_vlan_offload(uint8_t port_id);

int rte_eth_dev_set_vlan_pvid(uint8_t port_id, uint16_t pvid, int on);

static inline uint16_t
rte_eth_rx_burst(uint8_t port_id, uint16_t queue_id,
         struct rte_mbuf **rx_pkts, const uint16_t nb_pkts)
{
    struct rte_eth_dev *dev = &rte_eth_devices[port_id];
    uint16_t nb_rx;

#ifdef RTE_LIBRTE_ETHDEV_DEBUG
    RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, 0);
    RTE_FUNC_PTR_OR_ERR_RET(*dev->rx_pkt_burst, 0);

    if (queue_id >= dev->data->nb_rx_queues) {
        RTE_PMD_DEBUG_TRACE("Invalid RX queue_id=%d\n", queue_id);
        return 0;
    }
#endif
    nb_rx = (*dev->rx_pkt_burst)(dev->data->rx_queues[queue_id],
            rx_pkts, nb_pkts);

#ifdef RTE_ETHDEV_RXTX_CALLBACKS
    if (unlikely(dev->post_rx_burst_cbs[queue_id] != NULL)) {
        struct rte_eth_rxtx_callback *cb =
                dev->post_rx_burst_cbs[queue_id];

        do {
            nb_rx = cb->fn.rx(port_id, queue_id, rx_pkts, nb_rx,
                        nb_pkts, cb->param);
            cb = cb->next;
        } while (cb != NULL);
    }
#endif

    return nb_rx;
}

static inline int
rte_eth_rx_queue_count(uint8_t port_id, uint16_t queue_id)
{
    struct rte_eth_dev *dev = &rte_eth_devices[port_id];
    RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
    RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_count, -ENOTSUP);
        return (int)(*dev->dev_ops->rx_queue_count)(dev, queue_id);
}

static inline int
rte_eth_rx_descriptor_done(uint8_t port_id, uint16_t queue_id, uint16_t offset)
{
    struct rte_eth_dev *dev = &rte_eth_devices[port_id];
    RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
    RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_descriptor_done, -ENOTSUP);
    return (*dev->dev_ops->rx_descriptor_done)( \
        dev->data->rx_queues[queue_id], offset);
}

static inline uint16_t
rte_eth_tx_burst(uint8_t port_id, uint16_t queue_id,
         struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
{
    struct rte_eth_dev *dev = &rte_eth_devices[port_id];

#ifdef RTE_LIBRTE_ETHDEV_DEBUG
    RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, 0);
    RTE_FUNC_PTR_OR_ERR_RET(*dev->tx_pkt_burst, 0);

    if (queue_id >= dev->data->nb_tx_queues) {
        RTE_PMD_DEBUG_TRACE("Invalid TX queue_id=%d\n", queue_id);
        return 0;
    }
#endif

#ifdef RTE_ETHDEV_RXTX_CALLBACKS
    struct rte_eth_rxtx_callback *cb = dev->pre_tx_burst_cbs[queue_id];

    if (unlikely(cb != NULL)) {
        do {
            nb_pkts = cb->fn.tx(port_id, queue_id, tx_pkts, nb_pkts,
                    cb->param);
            cb = cb->next;
        } while (cb != NULL);
    }
#endif

    return (*dev->tx_pkt_burst)(dev->data->tx_queues[queue_id], tx_pkts, nb_pkts);
}

typedef void (*buffer_tx_error_fn)(struct rte_mbuf **unsent, uint16_t count,
        void *userdata);

struct rte_eth_dev_tx_buffer {
    buffer_tx_error_fn error_callback;
    void *error_userdata;
    uint16_t size;           
    uint16_t length;         
    struct rte_mbuf *pkts[];
};

#define RTE_ETH_TX_BUFFER_SIZE(sz) \
    (sizeof(struct rte_eth_dev_tx_buffer) + (sz) * sizeof(struct rte_mbuf *))

int
rte_eth_tx_buffer_init(struct rte_eth_dev_tx_buffer *buffer, uint16_t size);

static inline uint16_t
rte_eth_tx_buffer_flush(uint8_t port_id, uint16_t queue_id,
        struct rte_eth_dev_tx_buffer *buffer)
{
    uint16_t sent;
    uint16_t to_send = buffer->length;

    if (to_send == 0)
        return 0;

    sent = rte_eth_tx_burst(port_id, queue_id, buffer->pkts, to_send);

    buffer->length = 0;

    /* All packets sent, or to be dealt with by callback below */
    if (unlikely(sent != to_send))
        buffer->error_callback(&buffer->pkts[sent],
                       (uint16_t)(to_send - sent),
                       buffer->error_userdata);

    return sent;
}

static inline uint16_t __attribute__((always_inline))
rte_eth_tx_buffer(uint8_t port_id, uint16_t queue_id,
        struct rte_eth_dev_tx_buffer *buffer, struct rte_mbuf *tx_pkt)
{
    buffer->pkts[buffer->length++] = tx_pkt;
    if (buffer->length < buffer->size)
        return 0;

    return rte_eth_tx_buffer_flush(port_id, queue_id, buffer);
}

int
rte_eth_tx_buffer_set_err_callback(struct rte_eth_dev_tx_buffer *buffer,
        buffer_tx_error_fn callback, void *userdata);

void
rte_eth_tx_buffer_drop_callback(struct rte_mbuf **pkts, uint16_t unsent,
        void *userdata);

void
rte_eth_tx_buffer_count_callback(struct rte_mbuf **pkts, uint16_t unsent,
        void *userdata);

enum rte_eth_event_type {
    RTE_ETH_EVENT_UNKNOWN,  
    RTE_ETH_EVENT_INTR_LSC, 
    RTE_ETH_EVENT_QUEUE_STATE,
    RTE_ETH_EVENT_INTR_RESET,
    RTE_ETH_EVENT_VF_MBOX,  
    RTE_ETH_EVENT_MAX       
};

typedef void (*rte_eth_dev_cb_fn)(uint8_t port_id, \
        enum rte_eth_event_type event, void *cb_arg);
int rte_eth_dev_callback_register(uint8_t port_id,
            enum rte_eth_event_type event,
        rte_eth_dev_cb_fn cb_fn, void *cb_arg);

int rte_eth_dev_callback_unregister(uint8_t port_id,
            enum rte_eth_event_type event,
        rte_eth_dev_cb_fn cb_fn, void *cb_arg);

void _rte_eth_dev_callback_process(struct rte_eth_dev *dev,
                enum rte_eth_event_type event, void *cb_arg);

int rte_eth_dev_rx_intr_enable(uint8_t port_id, uint16_t queue_id);

int rte_eth_dev_rx_intr_disable(uint8_t port_id, uint16_t queue_id);

int rte_eth_dev_rx_intr_ctl(uint8_t port_id, int epfd, int op, void *data);

int rte_eth_dev_rx_intr_ctl_q(uint8_t port_id, uint16_t queue_id,
                  int epfd, int op, void *data);

int  rte_eth_led_on(uint8_t port_id);

int  rte_eth_led_off(uint8_t port_id);

int rte_eth_dev_flow_ctrl_get(uint8_t port_id,
                  struct rte_eth_fc_conf *fc_conf);

int rte_eth_dev_flow_ctrl_set(uint8_t port_id,
                  struct rte_eth_fc_conf *fc_conf);

int rte_eth_dev_priority_flow_ctrl_set(uint8_t port_id,
                struct rte_eth_pfc_conf *pfc_conf);

int rte_eth_dev_mac_addr_add(uint8_t port, struct ether_addr *mac_addr,
                uint32_t pool);

int rte_eth_dev_mac_addr_remove(uint8_t port, struct ether_addr *mac_addr);

int rte_eth_dev_default_mac_addr_set(uint8_t port, struct ether_addr *mac_addr);


int rte_eth_dev_rss_reta_update(uint8_t port,
                struct rte_eth_rss_reta_entry64 *reta_conf,
                uint16_t reta_size);

int rte_eth_dev_rss_reta_query(uint8_t port,
                   struct rte_eth_rss_reta_entry64 *reta_conf,
                   uint16_t reta_size);

int rte_eth_dev_uc_hash_table_set(uint8_t port,struct ether_addr *addr,
                    uint8_t on);

int rte_eth_dev_uc_all_hash_table_set(uint8_t port,uint8_t on);

int rte_eth_dev_set_vf_rxmode(uint8_t port, uint16_t vf, uint16_t rx_mode,
                uint8_t on);

int
rte_eth_dev_set_vf_tx(uint8_t port,uint16_t vf, uint8_t on);

int
rte_eth_dev_set_vf_rx(uint8_t port,uint16_t vf, uint8_t on);

int
rte_eth_dev_set_vf_vlan_filter(uint8_t port, uint16_t vlan_id,
                uint64_t vf_mask,
                uint8_t vlan_on);

int rte_eth_mirror_rule_set(uint8_t port_id,
            struct rte_eth_mirror_conf *mirror_conf,
            uint8_t rule_id,
            uint8_t on);

int rte_eth_mirror_rule_reset(uint8_t port_id,
                     uint8_t rule_id);

int rte_eth_set_queue_rate_limit(uint8_t port_id, uint16_t queue_idx,
            uint16_t tx_rate);

int rte_eth_set_vf_rate_limit(uint8_t port_id, uint16_t vf,
            uint16_t tx_rate, uint64_t q_msk);

int rte_eth_dev_bypass_init(uint8_t port);

int rte_eth_dev_bypass_state_show(uint8_t port, uint32_t *state);

int rte_eth_dev_bypass_state_set(uint8_t port, uint32_t *new_state);

int rte_eth_dev_bypass_event_show(uint8_t port, uint32_t event, uint32_t *state);

int rte_eth_dev_bypass_event_store(uint8_t port, uint32_t event, uint32_t state);

int rte_eth_dev_wd_timeout_store(uint8_t port, uint32_t timeout);

int rte_eth_dev_bypass_ver_show(uint8_t port, uint32_t *ver);

int rte_eth_dev_bypass_wd_timeout_show(uint8_t port, uint32_t *wd_timeout);

int rte_eth_dev_bypass_wd_reset(uint8_t port);

int rte_eth_dev_rss_hash_update(uint8_t port_id,
                struct rte_eth_rss_conf *rss_conf);

int
rte_eth_dev_rss_hash_conf_get(uint8_t port_id,
                  struct rte_eth_rss_conf *rss_conf);

int
rte_eth_dev_udp_tunnel_port_add(uint8_t port_id,
                struct rte_eth_udp_tunnel *tunnel_udp);

int
rte_eth_dev_udp_tunnel_port_delete(uint8_t port_id,
                   struct rte_eth_udp_tunnel *tunnel_udp);

int rte_eth_dev_filter_supported(uint8_t port_id, enum rte_filter_type filter_type);

int rte_eth_dev_filter_ctrl(uint8_t port_id, enum rte_filter_type filter_type,
            enum rte_filter_op filter_op, void *arg);

int rte_eth_dev_get_dcb_info(uint8_t port_id,
                 struct rte_eth_dcb_info *dcb_info);

void *rte_eth_add_rx_callback(uint8_t port_id, uint16_t queue_id,
        rte_rx_callback_fn fn, void *user_param);

/*
* Add a callback that must be called first on packet RX on a given port
* and queue.
*
* This API configures a first function to be called for each burst of
* packets received on a given NIC port queue. The return value is a pointer
* that can be used to later remove the callback using
* rte_eth_remove_rx_callback().
*
* Multiple functions are called in the order that they are added.
*
* @param port_id
*   The port identifier of the Ethernet device.
* @param queue_id
*   The queue on the Ethernet device on which the callback is to be added.
* @param fn
*   The callback function
* @param user_param
*   A generic pointer parameter which will be passed to each invocation of the
*   callback function on this port and queue.
*
* @return
*   NULL on error.
*   On success, a pointer value which can later be used to remove the callback.
*/
void *rte_eth_add_first_rx_callback(uint8_t port_id, uint16_t queue_id,
        rte_rx_callback_fn fn, void *user_param);

void *rte_eth_add_tx_callback(uint8_t port_id, uint16_t queue_id,
        rte_tx_callback_fn fn, void *user_param);

int rte_eth_remove_rx_callback(uint8_t port_id, uint16_t queue_id,
        struct rte_eth_rxtx_callback *user_cb);

int rte_eth_remove_tx_callback(uint8_t port_id, uint16_t queue_id,
        struct rte_eth_rxtx_callback *user_cb);

int rte_eth_rx_queue_info_get(uint8_t port_id, uint16_t queue_id,
    struct rte_eth_rxq_info *qinfo);

int rte_eth_tx_queue_info_get(uint8_t port_id, uint16_t queue_id,
    struct rte_eth_txq_info *qinfo);

int rte_eth_dev_get_reg_info(uint8_t port_id, struct rte_dev_reg_info *info);

int rte_eth_dev_get_eeprom_length(uint8_t port_id);

int rte_eth_dev_get_eeprom(uint8_t port_id, struct rte_dev_eeprom_info *info);

int rte_eth_dev_set_eeprom(uint8_t port_id, struct rte_dev_eeprom_info *info);

int rte_eth_dev_set_mc_addr_list(uint8_t port_id,
                 struct ether_addr *mc_addr_set,
                 uint32_t nb_mc_addr);

int rte_eth_timesync_enable(uint8_t port_id);

int rte_eth_timesync_disable(uint8_t port_id);

int rte_eth_timesync_read_rx_timestamp(uint8_t port_id,
        struct timespec *timestamp, uint32_t flags);

int rte_eth_timesync_read_tx_timestamp(uint8_t port_id,
        struct timespec *timestamp);

int rte_eth_timesync_adjust_time(uint8_t port_id, int64_t delta);

int rte_eth_timesync_read_time(uint8_t port_id, struct timespec *time);

int rte_eth_timesync_write_time(uint8_t port_id, const struct timespec *time);

void rte_eth_copy_pci_info(struct rte_eth_dev *eth_dev,
        struct rte_pci_device *pci_dev);

const struct rte_memzone *
rte_eth_dma_zone_reserve(const struct rte_eth_dev *eth_dev, const char *name,
             uint16_t queue_id, size_t size,
             unsigned align, int socket_id);

int
rte_eth_dev_l2_tunnel_eth_type_conf(uint8_t port_id,
                    struct rte_eth_l2_tunnel_conf *l2_tunnel);

int
rte_eth_dev_l2_tunnel_offload_set(uint8_t port_id,
                  struct rte_eth_l2_tunnel_conf *l2_tunnel,
                  uint32_t mask,
                  uint8_t en);

int
rte_eth_dev_get_port_by_name(const char *name, uint8_t *port_id);

int
rte_eth_dev_get_name_by_port(uint8_t port_id, char *name);

int rte_eth_dev_pci_probe(struct rte_pci_driver *pci_drv,
              struct rte_pci_device *pci_dev);

int rte_eth_dev_pci_remove(struct rte_pci_device *pci_dev);

#ifdef __cplusplus
}
#endif

#endif /* _RTE_ETHDEV_H_ */