#ifndef VF_PF_SW_IF_H
#define VF_PF_SW_IF_H


/* 
 * common flags - right now it duplicates the #defines in the PF code -
 * TODO: put in another common header file
 */
#define SW_VFPF_QUEUE_FLG_TPA                   0x0001
#define SW_VFPF_QUEUE_FLG_CACHE_ALIGN           0x0002
#define SW_VFPF_QUEUE_FLG_STATS         0x0004
#define SW_VFPF_QUEUE_FLG_OV                    0x0008
#define SW_VFPF_QUEUE_FLG_VLAN                  0x0010
#define SW_VFPF_QUEUE_FLG_COS                   0x0020
#define SW_VFPF_QUEUE_FLG_HC            0x0040
#define SW_VFPF_QUEUE_FLG_DHC           0x0080

#define SW_VFPF_QUEUE_DROP_IP_CS_ERR    (1 << 0)
#define SW_VFPF_QUEUE_DROP_TCP_CS_ERR   (1 << 1)
#define SW_VFPF_QUEUE_DROP_TTL0         (1 << 2)
#define SW_VFPF_QUEUE_DROP_UDP_CS_ERR   (1 << 3)

#define SW_VFPF_VFDEF_INFO_AUX_DIRECT_DQ   0x01

enum {
        SW_PFVF_STATUS_WAITING = 0,
        SW_PFVF_STATUS_SUCCESS,
        SW_PFVF_STATUS_FAILURE,
        SW_PFVF_STATUS_NOT_SUPPORTED,
    SW_PFVF_STATUS_MISMATCH_PF_VF_VERSION,
    SW_PFVF_STATUS_NO_RESOURCE,
    SW_PFVF_STATUS_MISMATCH_FW_HSI
};

/*  Headers */
struct vf_pf_msg_hdr {
        u16 opcode;

#define PFVF_IF_VERSION            1
        u8  if_ver;
        u8  opcode_ver;
        u32 resp_msg_offset;
};

struct pf_vf_msg_hdr {
        u8 status;
        u8 opcode_ver;
        u16 opcode;
};

/* simple response */
struct pf_vf_msg_resp {
        struct pf_vf_msg_hdr    hdr;
};


/* Acquire */
struct vf_pf_msg_acquire {
        struct vf_pf_msg_hdr hdr;

        struct sw_vf_pf_vfdev_info
        {
                /* the following fields are for debug purposes */
                u8  vf_id;              /* ME register value */
                u8  vf_os;              /* e.g. Linux, W2K8 */
        u8  vf_aux;
        u8  fp_hsi_ver;
        u32 vf_fw_hsi_version;  /* e.g. 6.0.12 */
        } vfdev_info;

        struct sw_vf_pf_resc_request
        {
                u8  num_rxqs;
                u8  num_txqs;
                u8  num_sbs;
                u8  num_mac_filters;
                u8  num_vlan_filters;
                u8  num_mc_filters;
        u8  reserved1;
        u8  reserved2;

        /* TODO: future:
                statistics resc?, other resc?   */
        } resc_request;
};


/* simple operation request on queue */
struct vf_pf_msg_q_op {
        struct vf_pf_msg_hdr    hdr;
        u8                      vf_qid;
        u8                      padding[3];
};

struct vf_pf_msg_rss {
        struct vf_pf_msg_hdr    hdr;
        u32                                     rss_flags;

        /* Number hash bits to take into an account */
        u8                                      rss_result_mask;

        u8                                              ind_table_size;
        u8                                              rss_key_size;

        /* Indirection table */
        u8                                      ind_table[T_ETH_INDIRECTION_TABLE_SIZE];

        /* RSS hash values */
        u32                                     rss_key[10];
};

struct vf_pf_msg_rsc {
    struct vf_pf_msg_hdr    hdr;
    u32                     rsc_ipv4_state;
    u32                     rsc_ipv6_state;
};

struct sw_hw_sb_info {
        u8 hw_sb_id;    /* aka absolute igu id, used to ack the sb */
        u8 sb_qid;      /* used to update DHC for sb */
};

struct pf_vf_msg_acquire_resp {
        struct pf_vf_msg_hdr hdr;
        
        struct sw_pf_vf_pfdev_info
        {
                u32 chip_num;
                
                u32 pf_cap;
                #define PFVF_CAP_RSS        0x00000001
                #define PFVF_CAP_DHC        0x00000002
                #define PFVF_CAP_TPA        0x00000004
                #define PFVF_DEBUG          0x80000000
                
                u16 db_size;
                u8  indices_per_sb;
                u8  padding;
        } pfdev_info;

        struct sw_pf_vf_resc
        {  
                /* 
                 * in case of status NO_RESOURCE in message hdr, pf will fill
                 * this struct with suggested amount of resources for next
                 * acquire request 
                 */
        
                #define PFVF_MAX_QUEUES_PER_VF         16
                #define PFVF_MAX_SBS_PER_VF            16
                struct sw_hw_sb_info hw_sbs[PFVF_MAX_SBS_PER_VF];
                u8      hw_qid[PFVF_MAX_QUEUES_PER_VF];
                u8      num_rxqs;
                u8      num_txqs;
                u8      num_sbs;
                u8      num_mac_filters;
                u8      num_vlan_filters;
                u8      num_mc_filters;
                u8  igu_test_cnt;
                u8  igu_cnt;
                u8      permanent_mac_addr[8];
                u8      current_mac_addr[8];
        /* TODO: stats resc? cid for the ramrod? stats_id? spq prod id? */
        } resc;
};

/* Init VF */
struct vf_pf_msg_init_vf {
        struct vf_pf_msg_hdr hdr;
        
        u64 sb_addr[PFVF_MAX_SBS_PER_VF]; /* vf_sb based */
        u64 spq_addr;
        u64 stats_addr;
};

/* Setup Queue */
struct vf_pf_msg_setup_q {
        struct vf_pf_msg_hdr hdr;
        u8 vf_qid;                      /* index in hw_qid[] */

        u8 param_valid;
        #define VFPF_RXQ_VALID          0x01
        #define VFPF_TXQ_VALID          0x02

        u16 padding;

        struct sw_vf_pf_rxq_params {
                /* physical addresses */
                u64 rcq_addr;
                u64 rcq_np_addr;
                u64 rxq_addr;
                u64 sge_addr;
                
                /* sb + hc info */
                u8  vf_sb;              /* index in hw_sbs[] */
                u8  sb_index;           /* Index in the SB */
                u16 hc_rate;            /* desired interrupts per sec. */
                                        /* valid iff VFPF_QUEUE_FLG_HC */
                /* rx buffer info */
                u16 mtu;
                u16 buf_sz;
                u16 flags;              /* VFPF_QUEUE_FLG_X flags */
                u16 stat_id;            /* valid iff VFPF_QUEUE_FLG_STATS */

                /* valid iff VFPF_QUEUE_FLG_TPA */
                u16 sge_buf_sz;         
                u16 tpa_agg_sz;
                u8 max_sge_pkt;

                u8 drop_flags;          /* VFPF_QUEUE_DROP_X, for Linux all should 
                                         * be turned off, see setup_rx_queue() 
                                         * for reference
                                         */

                u8 cache_line_log;      /* VFPF_QUEUE_FLG_CACHE_ALIGN 
                                         * see init_rx_queue()
                                         */
                u8 padding;
        } rxq;

        struct sw_vf_pf_txq_params {
                /* physical addresses */
                u64 txq_addr;

                /* sb + hc info */
                u8  vf_sb;              /* index in hw_sbs[] */
                u8  sb_index;           /* Index in the SB */
                u16 hc_rate;            /* desired interrupts per sec. */
                                        /* valid iff VFPF_QUEUE_FLG_HC */
                u32 flags;              /* VFPF_QUEUE_FLG_X flags */
                u16 stat_id;            /* valid iff VFPF_QUEUE_FLG_STATS */
                u8  traffic_type;       /* see in setup_context() */
                u8  padding;
        } txq;
};


/* Set Queue Filters */
struct vf_pf_q_mac_vlan_filter {
        u32 flags;
        #define VFPF_Q_FILTER_DEST_MAC_PRESENT  0x01
        #define VFPF_Q_FILTER_VLAN_TAG_PRESENT  0x02

        #define VFPF_Q_FILTER_SET_MAC                   0x100
        
        u8  dest_mac[6];
        u16 vlan_tag;
};

struct vf_pf_msg_set_q_filters {
        struct vf_pf_msg_hdr hdr;

        u32 flags;
        #define VFPF_SET_Q_FILTERS_MAC_VLAN_CHANGED     0x01
        #define VFPF_SET_Q_FILTERS_MULTICAST_CHANGED    0x02
        #define VFPF_SET_Q_FILTERS_RX_MASK_CHANGED      0x04
        
        u8 vf_qid;                      /* index in hw_qid[] */
        u8 n_mac_vlan_filters;
        u8 n_multicast;
        u8 padding;
        
        #define PFVF_MAX_MAC_FILTERS                    16
        #define PFVF_MAX_VLAN_FILTERS                   16
//      #define PFVF_MAX_MAC_FILTERS                    1
//      #define PFVF_MAX_VLAN_FILTERS                   1
        #define PFVF_MAX_FILTERS                        (PFVF_MAX_MAC_FILTERS +\
                                                         PFVF_MAX_VLAN_FILTERS)
        struct vf_pf_q_mac_vlan_filter filters[PFVF_MAX_FILTERS];
        
        #define PFVF_MAX_MULTICAST_PER_VF               32
//      #define PFVF_MAX_MULTICAST_PER_VF               1
        u8  multicast[PFVF_MAX_MULTICAST_PER_VF][6];
        
        u32 rx_mask;
        #define VFPF_RX_MASK_ACCEPT_NONE                0x00000000
        #define VFPF_RX_MASK_ACCEPT_MATCHED_UNICAST     0x00000001
        #define VFPF_RX_MASK_ACCEPT_MATCHED_MULTICAST   0x00000002
        #define VFPF_RX_MASK_ACCEPT_ALL_UNICAST         0x00000004
        #define VFPF_RX_MASK_ACCEPT_ALL_MULTICAST       0x00000008
        #define VFPF_RX_MASK_ACCEPT_BROADCAST           0x00000010
        /* TODO: #define VFPF_RX_MASK_ACCEPT_ANY_VLAN   0x00000020 */
};


/* close VF (disable VF) */
struct vf_pf_msg_close_vf {
        struct vf_pf_msg_hdr    hdr;
        u16                     vf_id;  /* for debug */
        u16                     padding;                        
};

/* rlease the VF's acquired resources */
struct vf_pf_msg_release_vf {
        struct vf_pf_msg_hdr    hdr;
        u16                     vf_id;  /* for debug */
        u16                     padding;
};


union vf_pf_msg {
        struct vf_pf_msg_hdr            hdr;
        struct vf_pf_msg_acquire        acquire;
        struct vf_pf_msg_init_vf        init_vf;
        struct vf_pf_msg_close_vf       close_vf;
        struct vf_pf_msg_q_op           q_op;
        struct vf_pf_msg_setup_q        setup_q;
        struct vf_pf_msg_set_q_filters  set_q_filters;
        struct vf_pf_msg_release_vf     release_vf;
        struct vf_pf_msg_rss            update_rss;
    struct vf_pf_msg_rsc        update_rsc;
};


union pf_vf_msg {
        struct pf_vf_msg_resp           resp;
        struct pf_vf_msg_acquire_resp   acquire_resp;
};

typedef struct {
        u32 req_sz;
        u32 resp_sz;
} msg_sz_t;

#define PFVF_OP_VER_MAX(op_arry)  (sizeof(op_arry)/sizeof(*op_arry) - 1)

static const msg_sz_t acquire_req_sz[] = {
        /* sizeof(vf_pf_msg_acquire) - offsetof(struct vf_pf_msg_acquire, fieldX), */
        {sizeof(struct vf_pf_msg_acquire),
        sizeof(struct pf_vf_msg_acquire_resp)}
};
#define PFVF_ACQUIRE_VER  PFVF_OP_VER_MAX(acquire_req_sz)       

static const msg_sz_t init_vf_req_sz[] = {
        {sizeof(struct vf_pf_msg_init_vf), sizeof(struct pf_vf_msg_resp)}
};
#define PFVF_INIT_VF_VER  PFVF_OP_VER_MAX(init_vf_req_sz)

static const msg_sz_t setup_q_req_sz[] = {
        {sizeof(struct vf_pf_msg_setup_q), sizeof(struct pf_vf_msg_resp)}
};
#define PFVF_SETUP_Q_VER  PFVF_OP_VER_MAX(setup_q_req_sz)

static const msg_sz_t set_q_filters_req_sz[] = {
        {sizeof(struct vf_pf_msg_set_q_filters), sizeof(struct pf_vf_msg_resp)}
};
#define PFVF_SET_Q_FILTERS_VER  PFVF_OP_VER_MAX(set_q_filters_req_sz)

static const msg_sz_t activate_q_req_sz[] = {
        {sizeof(struct vf_pf_msg_q_op), sizeof(struct pf_vf_msg_resp)}
};
#define PFVF_ACTIVATE_Q_VER  PFVF_OP_VER_MAX(activate_q_req_sz)

static const msg_sz_t deactivate_q_req_sz[] = {
        {sizeof(struct vf_pf_msg_q_op), sizeof(struct pf_vf_msg_resp)}
};
#define PFVF_DEACTIVATE_Q_VER  PFVF_OP_VER_MAX(deactivate_q_req_sz)

static const msg_sz_t teardown_q_req_sz[] = {
        {sizeof(struct vf_pf_msg_q_op), sizeof(struct pf_vf_msg_resp)}
};
#define PFVF_TEARDOWN_Q_VER  PFVF_OP_VER_MAX(teardown_q_req_sz)

static const msg_sz_t close_vf_req_sz[] = {
        {sizeof(struct vf_pf_msg_close_vf), sizeof(struct pf_vf_msg_resp)}
};
#define PFVF_CLOSE_VF_VER  PFVF_OP_VER_MAX(close_vf_req_sz)

static const msg_sz_t release_vf_req_sz[] = {
        {sizeof(struct vf_pf_msg_release_vf), sizeof(struct pf_vf_msg_resp)}
};
#define PFVF_RELEASE_VF_VER  PFVF_OP_VER_MAX(release_vf_req_sz)

static const msg_sz_t update_rss_req_sz[] = {
        {sizeof(struct vf_pf_msg_rss), sizeof(struct pf_vf_msg_resp)}
};
#define PFVF_UPDATE_RSS_VER  PFVF_OP_VER_MAX(update_rss_req_sz)

static const msg_sz_t update_rsc_req_sz[] = {
    {sizeof(struct vf_pf_msg_rsc), sizeof(struct pf_vf_msg_resp)}
};
#define PFVF_UPDATE_RSC_VER  PFVF_OP_VER_MAX(update_rsc_req_sz)

enum {
        PFVF_OP_ACQUIRE = 0,
        PFVF_OP_INIT_VF,
        PFVF_OP_SETUP_Q,
        PFVF_OP_SET_Q_FILTERS,
        PFVF_OP_ACTIVATE_Q,
        PFVF_OP_DEACTIVATE_Q,
        PFVF_OP_TEARDOWN_Q,
        PFVF_OP_CLOSE_VF,
        PFVF_OP_RELEASE_VF,
        PFVF_OP_UPDATE_RSS,
    PFVF_OP_UPDATE_RSC,
        PFVF_OP_MAX
};


/** To get size of message of the type X(request or response)
 *  for the op_code Y of the version Z one should use
 *
 *  op_code_req_sz[Y][Z].req_sz/resp_sz
 ******************************************************************/
/* const msg_sz_t* op_codes_req_sz[] = {
        (const msg_sz_t*)acquire_req_sz,
        (const msg_sz_t*)init_vf_req_sz,
        (const msg_sz_t*)setup_q_req_sz,
        (const msg_sz_t*)set_q_filters_req_sz,
        (const msg_sz_t*)activate_q_req_sz,
        (const msg_sz_t*)deactivate_q_req_sz,
        (const msg_sz_t*)teardown_q_req_sz,
        (const msg_sz_t*)close_vf_req_sz,
        (const msg_sz_t*)release_vf_req_sz
}; */

#endif /* VF_PF_SW_IF_H */