/*
 *------------------------------------------------------------------
 * Copyright (c) 2023 Intel and/or its affiliates.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *------------------------------------------------------------------
 */

#ifndef _IDPF_VIRTCHNL_H_
#define _IDPF_VIRTCHNL_H_

#include <idpf/virtchnl2_lan_desc.h>

#define foreach_virtchnl2_status                                              \
  _ (0, SUCCESS)                                                              \
  _ (-5, ERR_PARAM)                                                           \
  _ (-38, ERR_OPCODE_MISMATCH)

typedef enum
{
#define _(v, n) VIRTCHNL2_STATUS_##n = v,
  foreach_virtchnl2_status
#undef _
} virtchnl2_status_t;

#define foreach_virtchnl2_op                                                  \
  _ (0, UNKNOWN)                                                              \
  _ (1, VERSION)                                                              \
  _ (500, GET_CAPS)                                                           \
  _ (501, CREATE_VPORT)                                                       \
  _ (502, DESTROY_VPORT)                                                      \
  _ (503, ENABLE_VPORT)                                                       \
  _ (504, DISABLE_VPORT)                                                      \
  _ (505, CONFIG_TX_QUEUES)                                                   \
  _ (506, CONFIG_RX_QUEUES)                                                   \
  _ (507, ENABLE_QUEUES)                                                      \
  _ (508, DISABLE_QUEUES)                                                     \
  _ (509, ADD_QUEUES)                                                         \
  _ (510, DEL_QUEUES)                                                         \
  _ (511, MAP_QUEUE_VECTOR)                                                   \
  _ (512, UNMAP_QUEUE_VECTOR)                                                 \
  _ (513, GET_RSS_KEY)                                                        \
  _ (514, SET_RSS_KEY)                                                        \
  _ (515, GET_RSS_LUT)                                                        \
  _ (516, SET_RSS_LUT)                                                        \
  _ (517, GET_RSS_HASH)                                                       \
  _ (518, SET_RSS_HASH)                                                       \
  _ (519, SET_SRIOV_VFS)                                                      \
  _ (520, ALLOC_VECTORS)                                                      \
  _ (521, DEALLOC_VECTORS)                                                    \
  _ (522, EVENT)                                                              \
  _ (523, GET_STATS)                                                          \
  _ (524, RESET_VF)                                                           \
  _ (526, GET_PTYPE_INFO)                                                     \
  _ (532, CREATE_ADI)                                                         \
  _ (533, DESTROY_ADI)                                                        \
  _ (534, LOOPBACK)                                                           \
  _ (535, ADD_MAC_ADDR)                                                       \
  _ (536, DEL_MAC_ADDR)                                                       \
  _ (537, CONFIG_PROMISCUOUS_MODE)

typedef enum
{
#define _(v, n) VIRTCHNL2_OP_##n = v,
  foreach_virtchnl2_op
#undef _
} virtchnl2_op_t;

/* VIRTCHNL2_VPORT_TYPE
 * Type of virtual port
 */
#define foreach_virtchnl2_vport_type                                          \
  _ (0, DEFAULT)                                                              \
  _ (1, SRIOV)                                                                \
  _ (2, SIOV)                                                                 \
  _ (3, SUBDEV)                                                               \
  _ (4, MNG)

typedef enum
{
#define _(v, n) VIRTCHNL2_VPORT_TYPE_##n = v,
  foreach_virtchnl2_vport_type
#undef _
} virtchnl2_vport_type_t;

/* VIRTCHNL2_QUEUE_MODEL
 * Type of queue model
 */
#define VIRTCHNL2_QUEUE_MODEL_SINGLE 0
#define VIRTCHNL2_QUEUE_MODEL_SPLIT  1

#define foreach_idpf_checksum_cap_flag                                        \
  _ (0, TX_CSUM_L3_IPV4, "tx-csum-l3-ipv4")                                   \
  _ (1, TX_CSUM_L4_IPV4_TCP, "tx-csum-l4-ipv4-tcp")                           \
  _ (2, TX_CSUM_L4_IPV4_UDP, "tx-csum-l4-ipv4-udp")                           \
  _ (3, TX_CSUM_L4_IPV4_SCTP, "tx-csum-l4-ipv4-sctp")                         \
  _ (4, TX_CSUM_L4_IPV6_TCP, "tx-csum-l4-ipv6-tcp")                           \
  _ (5, TX_CSUM_L4_IPV6_UDP, "tx-csum-l4-ipv6-udp")                           \
  _ (6, TX_CSUM_L4_IPV6_SCTP, "tx-csum-l4-ipv6-sctp")                         \
  _ (7, TX_CSUM_GENERIC, "tx-csum-generic")                                   \
  _ (8, RX_CSUM_L3_IPV4, "rx-csum-l3-ipv4")                                   \
  _ (9, RX_CSUM_L4_IPV4_TCP, "rx-csum-l4-ipv4-tcp")                           \
  _ (10, RX_CSUM_L4_IPV4_UDP, "rx-csum-l4-ipv4-udp")                          \
  _ (11, RX_CSUM_L4_IPV4_SCTP, "rx-csum-l4-ipv4-sctp")                        \
  _ (12, RX_CSUM_L4_IPV6_TCP, "rx-csum-l4-ipv6-tcp")                          \
  _ (13, RX_CSUM_L4_IPV6_UDP, "rx-csum-l4-ipv6-udp")                          \
  _ (14, RX_CSUM_L4_IPV6_SCTP, "rx-csum-l4-ipv6-sctp")                        \
  _ (15, RX_CSUM_GENERIC, "rx-csum-generic")                                  \
  _ (16, TX_CSUM_L3_SINGLE_TUNNEL, "tx-csum-l3-single-tunnel")                \
  _ (17, TX_CSUM_L3_DOUBLE_TUNNEL, "tx-csum-l3-double-tunnel")                \
  _ (18, RX_CSUM_L3_SINGLE_TUNNEL, "rx-csum-l3-single-tunnel")                \
  _ (19, RX_CSUM_L3_DOUBLE_TUNNEL, "rx-csum-l3-double-tunnel")                \
  _ (20, TX_CSUM_L4_SINGLE_TUNNEL, "tx-csum-l4-single-tunnel")                \
  _ (21, TX_CSUM_L4_DOUBLE_TUNNEL, "tx-csum-l4-double-tunnel")                \
  _ (22, RX_CSUM_L4_SINGLE_TUNNEL, "rx-csum-l4-single-tunnel")                \
  _ (23, RX_CSUM_L4_DOUBLE_TUNNEL, "rx-csum-l4-double-tunnel")

typedef enum
{
#define _(a, b, c) VIRTCHNL2_CAP_##b = (1 << a),
  foreach_idpf_checksum_cap_flag
#undef _
} idpf_checksum_cap_flag_t;

#define foreach_idpf_seg_cap_flag                                             \
  _ (0, IPV4_TCP, "ipv4-tcp")                                                 \
  _ (1, IPV4_UDP, "ipv4-udp")                                                 \
  _ (2, IPV4_SCTP, "ipv4-sctp")                                               \
  _ (3, IPV6_TCP, "ipv6-tcp")                                                 \
  _ (4, IPV6_UDP, "ipv6-udp")                                                 \
  _ (5, IPV6_SCTP, "ipv6-sctp")                                               \
  _ (6, GENERIC, "generic")                                                   \
  _ (7, TX_SINGLE_TUNNEL, "tx-single-tunnel")                                 \
  _ (8, TX_DOUBLE_TUNNEL, "tx-double-tunnel")

typedef enum
{
#define _(a, b, c) VIRTCHNL2_CAP_SEG_##b = (1 << a),
  foreach_idpf_seg_cap_flag
#undef _
} idpf_seg_cap_flag_t;

#define foreach_idpf_rss_cap_flag                                             \
  _ (0, IPV4_TCP, "ipv4-tcp")                                                 \
  _ (1, IPV4_UDP, "ipv4-udp")                                                 \
  _ (2, IPV4_SCTP, "ipv4-sctp")                                               \
  _ (3, IPV4_OTHER, "ipv4-other")                                             \
  _ (4, IPV6_TCP, "ipv6-tcp")                                                 \
  _ (5, IPV6_UDP, "ipv6-udp")                                                 \
  _ (6, IPV6_SCTP, "ipv6-sctp")                                               \
  _ (7, IPV6_OTHER, "ipv6-other")                                             \
  _ (8, IPV4_AH, "ipv4-ah")                                                   \
  _ (9, IPV4_ESP, "ipv4-esp")                                                 \
  _ (10, IPV4_AH_ESP, "ipv4-ah-esp")                                          \
  _ (11, IPV6_AH, "ipv6-ah")                                                  \
  _ (12, IPV6_ESP, "ipv6-esp")                                                \
  _ (13, IPV6_AH_ESP, "ipv6-ah-esp")

typedef enum
{
#define _(a, b, c) VIRTCHNL2_CAP_RSS_##b = (1 << a),
  foreach_idpf_rss_cap_flag
#undef _
} idpf_rss_cap_flag_t;

#define foreach_idpf_hsplit_cap_flag                                          \
  _ (0, AT_L2, "at-l2")                                                       \
  _ (1, AT_L3, "at-l3")                                                       \
  _ (2, AT_L4V4, "at-l4v4")                                                   \
  _ (3, AT_L4V6, "at-l4v6")

typedef enum
{
#define _(a, b, c) VIRTCHNL2_CAP_RX_HSPLIT_##b = (1 << a),
  foreach_idpf_hsplit_cap_flag
#undef _
} idpf_hsplit_cap_flag_t;

#define foreach_idpf_rsc_cap_flag                                             \
  _ (0, IPV4_TCP, "ipv4-tcp")                                                 \
  _ (1, IPV4_SCTP, "ipv4-sctp")                                               \
  _ (2, IPV6_TCP, "ipv6-tcp")                                                 \
  _ (3, IPV6_SCTP, "ipv6-sctp")

typedef enum
{
#define _(a, b, c) VIRTCHNL2_CAP_RSC_##b = (1 << a),
  foreach_idpf_rsc_cap_flag
#undef _
} idpf_rsc_cap_flag_t;

#define foreach_idpf_other_cap_flag                                           \
  _ (0, RDMA, "rdma")                                                         \
  _ (1, SRIOV, "sriov")                                                       \
  _ (2, MACFILTER, "macfilter")                                               \
  _ (3, FLOW_DIRECTOR, "flow-director")                                       \
  _ (4, SPLITQ_QSCHED, "spliteq-qsched")                                      \
  _ (5, CRC, "crc")                                                           \
  _ (6, ADQ, "adq")                                                           \
  _ (7, WB_ON_ITR, "wb-on-itr")                                               \
  _ (8, PROMISC, "promisc")                                                   \
  _ (9, LINK_SPEED, "link-speed")                                             \
  _ (10, INLINE_IPSEC, "inline-ipsec")                                        \
  _ (11, LARGE_NUM_QUEUES, "large-num-queues")                                \
  _ (12, VLAN, "vlan")                                                        \
  _ (13, PTP, "ptp")                                                          \
  _ (15, ADV_RSS, "adv-rss")                                                  \
  _ (16, FDIR, "fdir")                                                        \
  _ (17, RX_FLEX_DESC, "rx-flex-desc")                                        \
  _ (18, PTYPE, "ptype")                                                      \
  _ (19, LOOPBACK, "loopback")                                                \
  _ (20, OEM, "oem")

typedef enum
{
#define _(a, b, c) VIRTCHNL2_CAP_##b = (1 << a),
  foreach_idpf_other_cap_flag
#undef _
} idpf_other_cap_flag_t;

#define VIRTCHNL2_TXQ_SCHED_MODE_QUEUE 0
#define VIRTCHNL2_TXQ_SCHED_MODE_FLOW  1

#define VIRTCHNL2_TXQ_ENABLE_MISS_COMPL BIT (0)

#define VIRTCHNL2_RDMA_CPF 0
#define VIRTCHNL2_NVME_CPF 1
#define VIRTCHNL2_ATE_CPF  2
#define VIRTCHNL2_LCE_CPF  3

#define VIRTCHNL2_RXQ_RSC		   BIT (0)
#define VIRTCHNL2_RXQ_HDR_SPLIT		   BIT (1)
#define VIRTCHNL2_RXQ_IMMEDIATE_WRITE_BACK BIT (2)
#define VIRTCHNL2_RX_DESC_SIZE_16BYTE	   BIT (3)
#define VIRTCHNL2_RX_DESC_SIZE_32BYTE	   BIT (4)

#define foreach_virtchnl2_rss_alg                                             \
  _ (0, TOEPLITZ_ASYMMETRIC)                                                  \
  _ (1, R_ASYMMETRIC)                                                         \
  _ (2, TOEPLITZ_SYMMETRIC)                                                   \
  _ (3, XOR_SYMMETRIC)

typedef enum
{
#define _(v, n) VIRTCHNL2_RSS_ALG_##n = v,
  foreach_virtchnl2_rss_alg
#undef _
} virtchnl2_rss_alg_t;

#define foreach_virtchnl2_event                                               \
  _ (0, UNKNOWN)                                                              \
  _ (1, LINK_CHANGE)                                                          \
  _ (2, START_RESET_ADI)                                                      \
  _ (3, FINISH_RESET_ADI)

typedef enum
{
#define _(v, n) VIRTCHNL2_EVENT_##n = v,
  foreach_virtchnl2_event
#undef _
} virtchnl2_event_name_t;

#define foreach_idpf_queue_type                                               \
  _ (0, TX)                                                                   \
  _ (1, RX)                                                                   \
  _ (2, TX_COMPLETION)                                                        \
  _ (3, RX_BUFFER)                                                            \
  _ (4, CONFIG_TX)                                                            \
  _ (5, CONFIG_RX)                                                            \
  _ (6, P2P_TX)                                                               \
  _ (7, P2P_RX)                                                               \
  _ (8, P2P_TX_COMPLETION)                                                    \
  _ (9, P2P_RX_BUFFER)                                                        \
  _ (10, MBX_TX)                                                              \
  _ (11, MBX_RX)

typedef enum
{
#define _(v, n) VIRTCHNL2_QUEUE_TYPE_##n = v,
  foreach_idpf_queue_type
#undef _
} idpf_queue_type_t;

#define foreach_virtchnl2_itr_idx                                             \
  _ (0, 0)                                                                    \
  _ (1, 1)                                                                    \
  _ (2, 2)                                                                    \
  _ (3, NO_ITR)

typedef enum
{
#define _(v, n) VIRTCHNL2_ITR_IDX_##n = v,
  foreach_virtchnl2_itr_idx
#undef _
} virtchnl2_itr_idx_t;

#define VIRTCHNL2_MAC_ADDR_PRIMARY 1
#define VIRTCHNL2_MAC_ADDR_EXTRA   2

#define VIRTCHNL2_UNICAST_PROMISC   BIT (0)
#define VIRTCHNL2_MULTICAST_PROMISC BIT (1)

#define foreach_virtchnl2_proto_hdr                                           \
  _ (0, ANY)                                                                  \
  _ (1, PRE_MAC)                                                              \
  _ (2, MAC)                                                                  \
  _ (3, POST_MAC)                                                             \
  _ (4, ETHERTYPE)                                                            \
  _ (5, VLAN)                                                                 \
  _ (6, SVLAN)                                                                \
  _ (7, CVLAN)                                                                \
  _ (8, MPLS)                                                                 \
  _ (9, UMPLS)                                                                \
  _ (10, MMPLS)                                                               \
  _ (11, PTP)                                                                 \
  _ (12, CTRL)                                                                \
  _ (13, LLDP)                                                                \
  _ (14, ARP)                                                                 \
  _ (15, ECP)                                                                 \
  _ (16, EAPOL)                                                               \
  _ (17, PPPOD)                                                               \
  _ (18, PPPOE)                                                               \
  _ (19, IPV4)                                                                \
  _ (20, IPV4_FRAG)                                                           \
  _ (21, IPV6)                                                                \
  _ (22, IPV6_FRAG)                                                           \
  _ (23, IPV6_EH)                                                             \
  _ (24, UDP)                                                                 \
  _ (25, TCP)                                                                 \
  _ (26, SCTP)                                                                \
  _ (27, ICMP)                                                                \
  _ (28, ICMPV6)                                                              \
  _ (29, IGMP)                                                                \
  _ (30, AH)                                                                  \
  _ (31, ESP)                                                                 \
  _ (32, IKE)                                                                 \
  _ (33, NATT_KEEP)                                                           \
  _ (34, PAY)                                                                 \
  _ (35, L2TPV2)                                                              \
  _ (36, L2TPV2_CONTROL)                                                      \
  _ (37, L2TPV3)                                                              \
  _ (38, GTP)                                                                 \
  _ (39, GTP_EH)                                                              \
  _ (40, GTPCV2)                                                              \
  _ (41, GTPC_TEID)                                                           \
  _ (42, GTPU)                                                                \
  _ (43, GTPU_UL)                                                             \
  _ (44, GTPU_DL)                                                             \
  _ (45, ECPRI)                                                               \
  _ (46, VRRP)                                                                \
  _ (47, OSPF)                                                                \
  _ (48, TUN)                                                                 \
  _ (49, GRE)                                                                 \
  _ (50, NVGRE)                                                               \
  _ (51, VXLAN)                                                               \
  _ (52, VXLAN_GPE)                                                           \
  _ (53, GENEVE)                                                              \
  _ (54, NSH)                                                                 \
  _ (55, QUIC)                                                                \
  _ (56, PFCP)                                                                \
  _ (57, PFCP_NODE)                                                           \
  _ (58, PFCP_SESSION)                                                        \
  _ (59, RTP)                                                                 \
  _ (60, ROCE)                                                                \
  _ (61, ROCEV1)                                                              \
  _ (62, ROCEV2)                                                              \
  _ (65535, NO_PROTO)

typedef enum
{
#define _(v, n) VIRTCHNL2_PROTO_HDR_##n = v,
  foreach_virtchnl2_proto_hdr
#undef _
} virtchnl2_proto_hdr_t;

#define VIRTCHNL2_VERSION_MAJOR_2 2
#define VIRTCHNL2_VERSION_MINOR_0 0

typedef struct
{
  u32 major;
  u32 minor;
} virtchnl2_version_info_t;

STATIC_ASSERT_SIZEOF (virtchnl2_version_info_t, 8);

typedef struct
{
  u32 csum_caps;
  u32 seg_caps;
  u32 hsplit_caps;
  u32 rsc_caps;
  u64 rss_caps;
  u64 other_caps;

  u32 mailbox_dyn_ctl;
  u16 mailbox_vector_id;
  u16 num_allocated_vectors;

  u16 max_rx_q;
  u16 max_tx_q;
  u16 max_rx_bufq;
  u16 max_tx_complq;

  u16 max_sriov_vfs;

  u16 max_vports;
  u16 default_num_vports;

  u16 max_tx_hdr_size;

  u8 max_sg_bufs_per_tx_pkt;

  u8 itr_idx_map;

  u16 pad1;

  u16 oem_cp_ver_major;
  u16 oem_cp_ver_minor;
  u32 device_type;

  u8 reserved[12];
} virtchnl2_get_capabilities_t;

STATIC_ASSERT_SIZEOF (virtchnl2_get_capabilities_t, 80);

typedef struct
{
  /* see VIRTCHNL2_QUEUE_TYPE definitions */
  u32 type;
  u32 start_queue_id;
  u32 num_queues;
  u32 pad;

  /* Queue tail register offset and spacing provided by CP */
  u64 qtail_reg_start;
  u32 qtail_reg_spacing;

  u8 reserved[4];
} virtchnl2_queue_reg_chunk_t;

STATIC_ASSERT_SIZEOF (virtchnl2_queue_reg_chunk_t, 32);

/* structure to specify several chunks of contiguous queues */
typedef struct
{
  u16 num_chunks;
  u8 reserved[6];
  virtchnl2_queue_reg_chunk_t chunks[1];
} virtchnl2_queue_reg_chunks_t;

STATIC_ASSERT_SIZEOF (virtchnl2_queue_reg_chunks_t, 40);

#define VIRTCHNL2_ETH_LENGTH_OF_ADDRESS 6

typedef struct
{
  u16 vport_type;
  u16 txq_model;
  u16 rxq_model;
  u16 num_tx_q;
  u16 num_tx_complq;
  u16 num_rx_q;
  u16 num_rx_bufq;
  u16 default_rx_q;
  u16 vport_index;

  u16 max_mtu;
  u32 vport_id;
  u8 default_mac_addr[VIRTCHNL2_ETH_LENGTH_OF_ADDRESS];
  u16 pad;
  u64 rx_desc_ids;
  u64 tx_desc_ids;

#define MAX_Q_REGIONS 16
  u32 max_qs_per_qregion[MAX_Q_REGIONS];
  u32 qregion_total_qs;
  u16 qregion_type;
  u16 pad2;

  u32 rss_algorithm;
  u16 rss_key_size;
  u16 rss_lut_size;

  u32 rx_split_pos;

  u8 reserved[20];
  virtchnl2_queue_reg_chunks_t chunks;
} virtchnl2_create_vport_t;

STATIC_ASSERT_SIZEOF (virtchnl2_create_vport_t, 192);

typedef struct
{
  u32 vport_id;
  u8 reserved[4];
} virtchnl2_vport_t;

STATIC_ASSERT_SIZEOF (virtchnl2_vport_t, 8);

typedef struct
{
  u64 dma_ring_addr;
  u32 type;
  u32 queue_id;
  u16 relative_queue_id;
  u16 model;
  u16 sched_mode;
  u16 qflags;
  u16 ring_len;

  u16 tx_compl_queue_id;
  u16 peer_type;
  u16 peer_rx_queue_id;

  u16 qregion_id;
  u8 pad[2];

  u32 egress_pasid;
  u32 egress_hdr_pasid;
  u32 egress_buf_pasid;

  u8 reserved[8];
} virtchnl2_txq_info_t;

STATIC_ASSERT_SIZEOF (virtchnl2_txq_info_t, 56);

typedef struct
{
  u32 vport_id;
  u16 num_qinfo;

  u8 reserved[10];
  virtchnl2_txq_info_t qinfo[1];
} virtchnl2_config_tx_queues_t;

STATIC_ASSERT_SIZEOF (virtchnl2_config_tx_queues_t, 72);

/* Receive queue config info */
typedef struct
{
  u64 desc_ids;
  u64 dma_ring_addr;

  u32 type;
  u32 queue_id;

  u16 model;

  u16 hdr_buffer_size;
  u32 data_buffer_size;
  u32 max_pkt_size;

  u16 ring_len;
  u8 buffer_notif_stride;
  u8 pad[1];

  u64 dma_head_wb_addr;

  u16 qflags;

  u16 rx_buffer_low_watermark;

  u16 rx_bufq1_id;
  u16 rx_bufq2_id;
  u8 bufq2_ena;
  u8 pad2;

  u16 qregion_id;

  u32 ingress_pasid;
  u32 ingress_hdr_pasid;
  u32 ingress_buf_pasid;

  u8 reserved[16];
} virtchnl2_rxq_info_t;

STATIC_ASSERT_SIZEOF (virtchnl2_rxq_info_t, 88);

typedef struct
{
  u32 vport_id;
  u16 num_qinfo;

  u8 reserved[18];
  virtchnl2_rxq_info_t qinfo[1];
} virtchnl2_config_rx_queues_t;

STATIC_ASSERT_SIZEOF (virtchnl2_config_rx_queues_t, 112);

typedef struct
{
  u32 vport_id;
  u16 num_tx_q;
  u16 num_tx_complq;
  u16 num_rx_q;
  u16 num_rx_bufq;
  u8 reserved[4];
  virtchnl2_queue_reg_chunks_t chunks;
} virtchnl2_add_queues_t;

STATIC_ASSERT_SIZEOF (virtchnl2_add_queues_t, 56);

typedef struct
{
  u16 start_vector_id;
  u16 start_evv_id;
  u16 num_vectors;
  u16 pad1;

  u32 dynctl_reg_start;
  u32 dynctl_reg_spacing;

  u32 itrn_reg_start;
  u32 itrn_reg_spacing;
  u8 reserved[8];
} virtchnl2_vector_chunk_t;

STATIC_ASSERT_SIZEOF (virtchnl2_vector_chunk_t, 32);

typedef struct
{
  u16 num_vchunks;
  u8 reserved[14];
  virtchnl2_vector_chunk_t vchunks[1];
} virtchnl2_vector_chunks_t;

STATIC_ASSERT_SIZEOF (virtchnl2_vector_chunks_t, 48);

typedef struct
{
  u16 num_vectors;
  u8 reserved[14];
  virtchnl2_vector_chunks_t vchunks;
} virtchnl2_alloc_vectors_t;

STATIC_ASSERT_SIZEOF (virtchnl2_alloc_vectors_t, 64);

typedef struct
{
  u32 vport_id;
  u16 lut_entries_start;
  u16 lut_entries;
  u8 reserved[4];
  u32 lut[1]; /* RSS lookup table */
} virtchnl2_rss_lut_t;

STATIC_ASSERT_SIZEOF (virtchnl2_rss_lut_t, 16);

typedef struct
{
  /* Packet Type Groups bitmap */
  u64 ptype_groups;
  u32 vport_id;
  u8 reserved[4];
} virtchnl2_rss_hash_t;

STATIC_ASSERT_SIZEOF (virtchnl2_rss_hash_t, 16);

typedef struct
{
  u16 num_vfs;
  u16 pad;
} virtchnl2_sriov_vfs_info_t;

STATIC_ASSERT_SIZEOF (virtchnl2_sriov_vfs_info_t, 4);

typedef struct
{
  u32 pasid;
  u16 mbx_id;
  u16 mbx_vec_id;
  u16 adi_id;
  u8 reserved[64];
  u8 pad[6];
  virtchnl2_queue_reg_chunks_t chunks;
  virtchnl2_vector_chunks_t vchunks;
} virtchnl2_create_adi_t;

STATIC_ASSERT_SIZEOF (virtchnl2_create_adi_t, 168);

typedef struct
{
  u16 adi_id;
  u8 reserved[2];
} virtchnl2_destroy_adi_t;

STATIC_ASSERT_SIZEOF (virtchnl2_destroy_adi_t, 4);

typedef struct
{
  u16 ptype_id_10;
  u8 ptype_id_8;
  u8 proto_id_count;
  u16 pad;
  u16 proto_id[1];
} virtchnl2_ptype_t;

STATIC_ASSERT_SIZEOF (virtchnl2_ptype_t, 8);

typedef struct
{
  u16 start_ptype_id;
  u16 num_ptypes;
  u32 pad;
  virtchnl2_ptype_t ptype[1];
} virtchnl2_get_ptype_info_t;

STATIC_ASSERT_SIZEOF (virtchnl2_get_ptype_info_t, 16);

typedef struct
{
  u32 vport_id;
  u8 pad[4];

  u64 rx_bytes;
  u64 rx_unicast;
  u64 rx_multicast;
  u64 rx_broadcast;
  u64 rx_discards;
  u64 rx_errors;
  u64 rx_unknown_protocol;
  u64 tx_bytes;
  u64 tx_unicast;
  u64 tx_multicast;
  u64 tx_broadcast;
  u64 tx_discards;
  u64 tx_errors;
  u64 rx_invalid_frame_length;
  u64 rx_overflow_drop;
} virtchnl2_vport_stats_t;

STATIC_ASSERT_SIZEOF (virtchnl2_vport_stats_t, 128);

typedef struct
{
  u32 event;
  u32 link_speed;
  u32 vport_id;
  u8 link_status;
  u8 pad[1];
  u16 adi_id;
} virtchnl2_event_t;

STATIC_ASSERT_SIZEOF (virtchnl2_event_t, 16);

typedef struct
{
  u32 vport_id;
  u16 key_len;
  u8 pad;
  u8 key[1];
} virtchnl2_rss_key_t;

STATIC_ASSERT_SIZEOF (virtchnl2_rss_key_t, 8);

typedef struct
{
  u32 type;
  u32 start_queue_id;
  u32 num_queues;
  u8 reserved[4];
} virtchnl2_queue_chunk_t;

STATIC_ASSERT_SIZEOF (virtchnl2_queue_chunk_t, 16);

typedef struct
{
  u16 num_chunks;
  u8 reserved[6];
  virtchnl2_queue_chunk_t chunks[1];
} virtchnl2_queue_chunks_t;

STATIC_ASSERT_SIZEOF (virtchnl2_queue_chunks_t, 24);

typedef struct
{
  u32 vport_id;
  u8 reserved[4];
  virtchnl2_queue_chunks_t chunks;
} virtchnl2_del_ena_dis_queues_t;

STATIC_ASSERT_SIZEOF (virtchnl2_del_ena_dis_queues_t, 32);

typedef struct
{
  u32 queue_id;
  u16 vector_id;
  u8 pad[2];

  u32 itr_idx;

  u32 queue_type;
  u8 reserved[8];
} virtchnl2_queue_vector_t;

STATIC_ASSERT_SIZEOF (virtchnl2_queue_vector_t, 24);

typedef struct
{
  u32 vport_id;
  u16 num_qv_maps;
  u8 pad[10];
  virtchnl2_queue_vector_t qv_maps[1];
} virtchnl2_queue_vector_maps_t;

STATIC_ASSERT_SIZEOF (virtchnl2_queue_vector_maps_t, 40);

typedef struct
{
  u32 vport_id;
  u8 enable;
  u8 pad[3];
} virtchnl2_loopback_t;

STATIC_ASSERT_SIZEOF (virtchnl2_loopback_t, 8);

typedef struct
{
  u8 addr[VIRTCHNL2_ETH_LENGTH_OF_ADDRESS];
  u8 type;
  u8 pad;
} virtchnl2_mac_addr_t;

STATIC_ASSERT_SIZEOF (virtchnl2_mac_addr_t, 8);

typedef struct
{
  u32 vport_id;
  u16 num_mac_addr;
  u8 pad[2];
  virtchnl2_mac_addr_t mac_addr_list[1];
} virtchnl2_mac_addr_list_t;

STATIC_ASSERT_SIZEOF (virtchnl2_mac_addr_list_t, 16);

typedef struct
{
  u32 vport_id;
  u16 flags;
  u8 pad[2];
} virtchnl2_promisc_info_t;

STATIC_ASSERT_SIZEOF (virtchnl2_promisc_info_t, 8);

#endif /* _IDPF_VIRTCHNL_H_ */