Changeset View
Changeset View
Standalone View
Standalone View
sys/dev/ixl/virtchnl.h
/****************************************************************************** | /****************************************************************************** | ||||
Copyright (c) 2013-2017, Intel Corporation | Copyright (c) 2013-2019, Intel Corporation | ||||
All rights reserved. | All rights reserved. | ||||
Redistribution and use in source and binary forms, with or without | Redistribution and use in source and binary forms, with or without | ||||
modification, are permitted provided that the following conditions are met: | modification, are permitted provided that the following conditions are met: | ||||
1. Redistributions of source code must retain the above copyright notice, | 1. Redistributions of source code must retain the above copyright notice, | ||||
this list of conditions and the following disclaimer. | this list of conditions and the following disclaimer. | ||||
Show All 15 Lines | /****************************************************************************** | ||||
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | ||||
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | 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 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | ||||
POSSIBILITY OF SUCH DAMAGE. | POSSIBILITY OF SUCH DAMAGE. | ||||
******************************************************************************/ | ******************************************************************************/ | ||||
/*$FreeBSD$*/ | /*$FreeBSD$*/ | ||||
#ifndef _VIRTCHNL_H_ | #ifndef _VIRTCHNL_H_ | ||||
#define _VIRTCHNL_H_ | #define _VIRTCHNL_H_ | ||||
/* Description: | /* Description: | ||||
* This header file describes the VF-PF communication protocol used | * This header file describes the VF-PF communication protocol used | ||||
* by the drivers for all devices starting from our 40G product line | * by the drivers for all devices starting from our 40G product line | ||||
* | * | ||||
* Admin queue buffer usage: | * Admin queue buffer usage: | ||||
Show All 22 Lines | |||||
/* START GENERIC DEFINES | /* START GENERIC DEFINES | ||||
* Need to ensure the following enums and defines hold the same meaning and | * Need to ensure the following enums and defines hold the same meaning and | ||||
* value in current and future projects | * value in current and future projects | ||||
*/ | */ | ||||
/* Error Codes */ | /* Error Codes */ | ||||
enum virtchnl_status_code { | enum virtchnl_status_code { | ||||
VIRTCHNL_STATUS_SUCCESS = 0, | VIRTCHNL_STATUS_SUCCESS = 0, | ||||
VIRTCHNL_ERR_PARAM = -5, | VIRTCHNL_STATUS_ERR_PARAM = -5, | ||||
VIRTCHNL_STATUS_ERR_NO_MEMORY = -18, | |||||
VIRTCHNL_STATUS_ERR_OPCODE_MISMATCH = -38, | VIRTCHNL_STATUS_ERR_OPCODE_MISMATCH = -38, | ||||
VIRTCHNL_STATUS_ERR_CQP_COMPL_ERROR = -39, | VIRTCHNL_STATUS_ERR_CQP_COMPL_ERROR = -39, | ||||
VIRTCHNL_STATUS_ERR_INVALID_VF_ID = -40, | VIRTCHNL_STATUS_ERR_INVALID_VF_ID = -40, | ||||
VIRTCHNL_STATUS_NOT_SUPPORTED = -64, | VIRTCHNL_STATUS_ERR_ADMIN_QUEUE_ERROR = -53, | ||||
VIRTCHNL_STATUS_ERR_NOT_SUPPORTED = -64, | |||||
}; | }; | ||||
/* Backward compatibility */ | |||||
#define VIRTCHNL_ERR_PARAM VIRTCHNL_STATUS_ERR_PARAM | |||||
#define VIRTCHNL_STATUS_NOT_SUPPORTED VIRTCHNL_STATUS_ERR_NOT_SUPPORTED | |||||
#define VIRTCHNL_LINK_SPEED_2_5GB_SHIFT 0x0 | |||||
#define VIRTCHNL_LINK_SPEED_100MB_SHIFT 0x1 | #define VIRTCHNL_LINK_SPEED_100MB_SHIFT 0x1 | ||||
#define VIRTCHNL_LINK_SPEED_1000MB_SHIFT 0x2 | #define VIRTCHNL_LINK_SPEED_1000MB_SHIFT 0x2 | ||||
#define VIRTCHNL_LINK_SPEED_10GB_SHIFT 0x3 | #define VIRTCHNL_LINK_SPEED_10GB_SHIFT 0x3 | ||||
#define VIRTCHNL_LINK_SPEED_40GB_SHIFT 0x4 | #define VIRTCHNL_LINK_SPEED_40GB_SHIFT 0x4 | ||||
#define VIRTCHNL_LINK_SPEED_20GB_SHIFT 0x5 | #define VIRTCHNL_LINK_SPEED_20GB_SHIFT 0x5 | ||||
#define VIRTCHNL_LINK_SPEED_25GB_SHIFT 0x6 | #define VIRTCHNL_LINK_SPEED_25GB_SHIFT 0x6 | ||||
#define VIRTCHNL_LINK_SPEED_5GB_SHIFT 0x7 | |||||
enum virtchnl_link_speed { | enum virtchnl_link_speed { | ||||
VIRTCHNL_LINK_SPEED_UNKNOWN = 0, | VIRTCHNL_LINK_SPEED_UNKNOWN = 0, | ||||
VIRTCHNL_LINK_SPEED_100MB = BIT(VIRTCHNL_LINK_SPEED_100MB_SHIFT), | VIRTCHNL_LINK_SPEED_100MB = BIT(VIRTCHNL_LINK_SPEED_100MB_SHIFT), | ||||
VIRTCHNL_LINK_SPEED_1GB = BIT(VIRTCHNL_LINK_SPEED_1000MB_SHIFT), | VIRTCHNL_LINK_SPEED_1GB = BIT(VIRTCHNL_LINK_SPEED_1000MB_SHIFT), | ||||
VIRTCHNL_LINK_SPEED_10GB = BIT(VIRTCHNL_LINK_SPEED_10GB_SHIFT), | VIRTCHNL_LINK_SPEED_10GB = BIT(VIRTCHNL_LINK_SPEED_10GB_SHIFT), | ||||
VIRTCHNL_LINK_SPEED_40GB = BIT(VIRTCHNL_LINK_SPEED_40GB_SHIFT), | VIRTCHNL_LINK_SPEED_40GB = BIT(VIRTCHNL_LINK_SPEED_40GB_SHIFT), | ||||
VIRTCHNL_LINK_SPEED_20GB = BIT(VIRTCHNL_LINK_SPEED_20GB_SHIFT), | VIRTCHNL_LINK_SPEED_20GB = BIT(VIRTCHNL_LINK_SPEED_20GB_SHIFT), | ||||
VIRTCHNL_LINK_SPEED_25GB = BIT(VIRTCHNL_LINK_SPEED_25GB_SHIFT), | VIRTCHNL_LINK_SPEED_25GB = BIT(VIRTCHNL_LINK_SPEED_25GB_SHIFT), | ||||
VIRTCHNL_LINK_SPEED_2_5GB = BIT(VIRTCHNL_LINK_SPEED_2_5GB_SHIFT), | |||||
VIRTCHNL_LINK_SPEED_5GB = BIT(VIRTCHNL_LINK_SPEED_5GB_SHIFT), | |||||
}; | }; | ||||
/* for hsplit_0 field of Rx HMC context */ | /* for hsplit_0 field of Rx HMC context */ | ||||
/* deprecated with AVF 1.0 */ | /* deprecated with AVF 1.0 */ | ||||
enum virtchnl_rx_hsplit { | enum virtchnl_rx_hsplit { | ||||
VIRTCHNL_RX_HSPLIT_NO_SPLIT = 0, | VIRTCHNL_RX_HSPLIT_NO_SPLIT = 0, | ||||
VIRTCHNL_RX_HSPLIT_SPLIT_L2 = 1, | VIRTCHNL_RX_HSPLIT_SPLIT_L2 = 1, | ||||
VIRTCHNL_RX_HSPLIT_SPLIT_IP = 2, | VIRTCHNL_RX_HSPLIT_SPLIT_IP = 2, | ||||
Show All 27 Lines | */ | ||||
VIRTCHNL_OP_ADD_ETH_ADDR = 10, | VIRTCHNL_OP_ADD_ETH_ADDR = 10, | ||||
VIRTCHNL_OP_DEL_ETH_ADDR = 11, | VIRTCHNL_OP_DEL_ETH_ADDR = 11, | ||||
VIRTCHNL_OP_ADD_VLAN = 12, | VIRTCHNL_OP_ADD_VLAN = 12, | ||||
VIRTCHNL_OP_DEL_VLAN = 13, | VIRTCHNL_OP_DEL_VLAN = 13, | ||||
VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE = 14, | VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE = 14, | ||||
VIRTCHNL_OP_GET_STATS = 15, | VIRTCHNL_OP_GET_STATS = 15, | ||||
VIRTCHNL_OP_RSVD = 16, | VIRTCHNL_OP_RSVD = 16, | ||||
VIRTCHNL_OP_EVENT = 17, /* must ALWAYS be 17 */ | VIRTCHNL_OP_EVENT = 17, /* must ALWAYS be 17 */ | ||||
/* opcode 19 is reserved */ | |||||
VIRTCHNL_OP_IWARP = 20, /* advanced opcode */ | VIRTCHNL_OP_IWARP = 20, /* advanced opcode */ | ||||
VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP = 21, /* advanced opcode */ | VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP = 21, /* advanced opcode */ | ||||
VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP = 22, /* advanced opcode */ | VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP = 22, /* advanced opcode */ | ||||
VIRTCHNL_OP_CONFIG_RSS_KEY = 23, | VIRTCHNL_OP_CONFIG_RSS_KEY = 23, | ||||
VIRTCHNL_OP_CONFIG_RSS_LUT = 24, | VIRTCHNL_OP_CONFIG_RSS_LUT = 24, | ||||
VIRTCHNL_OP_GET_RSS_HENA_CAPS = 25, | VIRTCHNL_OP_GET_RSS_HENA_CAPS = 25, | ||||
VIRTCHNL_OP_SET_RSS_HENA = 26, | VIRTCHNL_OP_SET_RSS_HENA = 26, | ||||
VIRTCHNL_OP_ENABLE_VLAN_STRIPPING = 27, | VIRTCHNL_OP_ENABLE_VLAN_STRIPPING = 27, | ||||
VIRTCHNL_OP_DISABLE_VLAN_STRIPPING = 28, | VIRTCHNL_OP_DISABLE_VLAN_STRIPPING = 28, | ||||
VIRTCHNL_OP_REQUEST_QUEUES = 29, | VIRTCHNL_OP_REQUEST_QUEUES = 29, | ||||
VIRTCHNL_OP_ENABLE_CHANNELS = 30, | |||||
VIRTCHNL_OP_DISABLE_CHANNELS = 31, | |||||
VIRTCHNL_OP_ADD_CLOUD_FILTER = 32, | |||||
VIRTCHNL_OP_DEL_CLOUD_FILTER = 33, | |||||
}; | }; | ||||
/* This macro is used to generate a compilation error if a structure | /* These macros are used to generate compilation errors if a structure/union | ||||
* is not exactly the correct length. It gives a divide by zero error if the | * is not exactly the correct length. It gives a divide by zero error if the | ||||
* structure is not of the correct size, otherwise it creates an enum that is | * structure/union is not of the correct size, otherwise it creates an enum | ||||
* never used. | * that is never used. | ||||
*/ | */ | ||||
#define VIRTCHNL_CHECK_STRUCT_LEN(n, X) enum virtchnl_static_assert_enum_##X \ | #define VIRTCHNL_CHECK_STRUCT_LEN(n, X) enum virtchnl_static_assert_enum_##X \ | ||||
{virtchnl_static_assert_##X = (n) / ((sizeof(struct X) == (n)) ? 1 : 0)} | { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } | ||||
#define VIRTCHNL_CHECK_UNION_LEN(n, X) enum virtchnl_static_asset_enum_##X \ | |||||
{ virtchnl_static_assert_##X = (n)/((sizeof(union X) == (n)) ? 1 : 0) } | |||||
/* Virtual channel message descriptor. This overlays the admin queue | /* Virtual channel message descriptor. This overlays the admin queue | ||||
* descriptor. All other data is passed in external buffers. | * descriptor. All other data is passed in external buffers. | ||||
*/ | */ | ||||
struct virtchnl_msg { | struct virtchnl_msg { | ||||
u8 pad[8]; /* AQ flags/opcode/len/retval fields */ | u8 pad[8]; /* AQ flags/opcode/len/retval fields */ | ||||
enum virtchnl_ops v_opcode; /* avoid confusion with desc->opcode */ | enum virtchnl_ops v_opcode; /* avoid confusion with desc->opcode */ | ||||
enum virtchnl_status_code v_retval; /* ditto for desc->retval */ | enum virtchnl_status_code v_retval; /* ditto for desc->retval */ | ||||
u32 vfid; /* used by PF when sending to VF */ | u32 vfid; /* used by PF when sending to VF */ | ||||
}; | }; | ||||
VIRTCHNL_CHECK_STRUCT_LEN(20, virtchnl_msg); | VIRTCHNL_CHECK_STRUCT_LEN(20, virtchnl_msg); | ||||
/* Message descriptions and data structures.*/ | /* Message descriptions and data structures. */ | ||||
/* VIRTCHNL_OP_VERSION | /* VIRTCHNL_OP_VERSION | ||||
* VF posts its version number to the PF. PF responds with its version number | * VF posts its version number to the PF. PF responds with its version number | ||||
* in the same format, along with a return code. | * in the same format, along with a return code. | ||||
* Reply from PF has its major/minor versions also in param0 and param1. | * Reply from PF has its major/minor versions also in param0 and param1. | ||||
* If there is a major version mismatch, then the VF cannot operate. | * If there is a major version mismatch, then the VF cannot operate. | ||||
* If there is a minor version mismatch, then the VF can operate but should | * If there is a minor version mismatch, then the VF can operate but should | ||||
* add a warning to the system log. | * add a warning to the system log. | ||||
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines | |||||
*/ | */ | ||||
#define VIRTCHNL_VF_OFFLOAD_L2 0x00000001 | #define VIRTCHNL_VF_OFFLOAD_L2 0x00000001 | ||||
#define VIRTCHNL_VF_OFFLOAD_IWARP 0x00000002 | #define VIRTCHNL_VF_OFFLOAD_IWARP 0x00000002 | ||||
#define VIRTCHNL_VF_OFFLOAD_RSVD 0x00000004 | #define VIRTCHNL_VF_OFFLOAD_RSVD 0x00000004 | ||||
#define VIRTCHNL_VF_OFFLOAD_RSS_AQ 0x00000008 | #define VIRTCHNL_VF_OFFLOAD_RSS_AQ 0x00000008 | ||||
#define VIRTCHNL_VF_OFFLOAD_RSS_REG 0x00000010 | #define VIRTCHNL_VF_OFFLOAD_RSS_REG 0x00000010 | ||||
#define VIRTCHNL_VF_OFFLOAD_WB_ON_ITR 0x00000020 | #define VIRTCHNL_VF_OFFLOAD_WB_ON_ITR 0x00000020 | ||||
#define VIRTCHNL_VF_OFFLOAD_REQ_QUEUES 0x00000040 | #define VIRTCHNL_VF_OFFLOAD_REQ_QUEUES 0x00000040 | ||||
#define VIRTCHNL_VF_OFFLOAD_CRC 0x00000080 | |||||
#define VIRTCHNL_VF_OFFLOAD_VLAN 0x00010000 | #define VIRTCHNL_VF_OFFLOAD_VLAN 0x00010000 | ||||
#define VIRTCHNL_VF_OFFLOAD_RX_POLLING 0x00020000 | #define VIRTCHNL_VF_OFFLOAD_RX_POLLING 0x00020000 | ||||
#define VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2 0x00040000 | #define VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2 0x00040000 | ||||
#define VIRTCHNL_VF_OFFLOAD_RSS_PF 0X00080000 | #define VIRTCHNL_VF_OFFLOAD_RSS_PF 0X00080000 | ||||
#define VIRTCHNL_VF_OFFLOAD_ENCAP 0X00100000 | #define VIRTCHNL_VF_OFFLOAD_ENCAP 0X00100000 | ||||
#define VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM 0X00200000 | #define VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM 0X00200000 | ||||
#define VIRTCHNL_VF_OFFLOAD_RX_ENCAP_CSUM 0X00400000 | #define VIRTCHNL_VF_OFFLOAD_RX_ENCAP_CSUM 0X00400000 | ||||
#define VIRTCHNL_VF_OFFLOAD_ADQ 0X00800000 | |||||
/* Define below the capability flags that are not offloads */ | |||||
#define VIRTCHNL_VF_CAP_ADV_LINK_SPEED 0x00000080 | |||||
#define VF_BASE_MODE_OFFLOADS (VIRTCHNL_VF_OFFLOAD_L2 | \ | #define VF_BASE_MODE_OFFLOADS (VIRTCHNL_VF_OFFLOAD_L2 | \ | ||||
VIRTCHNL_VF_OFFLOAD_VLAN | \ | VIRTCHNL_VF_OFFLOAD_VLAN | \ | ||||
VIRTCHNL_VF_OFFLOAD_RSS_PF) | VIRTCHNL_VF_OFFLOAD_RSS_PF) | ||||
struct virtchnl_vf_resource { | struct virtchnl_vf_resource { | ||||
u16 num_vsis; | u16 num_vsis; | ||||
u16 num_queue_pairs; | u16 num_queue_pairs; | ||||
u16 max_vectors; | u16 max_vectors; | ||||
Show All 24 Lines | struct virtchnl_txq_info { | ||||
u64 dma_headwb_addr; /* deprecated with AVF 1.0 */ | u64 dma_headwb_addr; /* deprecated with AVF 1.0 */ | ||||
}; | }; | ||||
VIRTCHNL_CHECK_STRUCT_LEN(24, virtchnl_txq_info); | VIRTCHNL_CHECK_STRUCT_LEN(24, virtchnl_txq_info); | ||||
/* VIRTCHNL_OP_CONFIG_RX_QUEUE | /* VIRTCHNL_OP_CONFIG_RX_QUEUE | ||||
* VF sends this message to set up parameters for one RX queue. | * VF sends this message to set up parameters for one RX queue. | ||||
* External data buffer contains one instance of virtchnl_rxq_info. | * External data buffer contains one instance of virtchnl_rxq_info. | ||||
* PF configures requested queue and returns a status code. | * PF configures requested queue and returns a status code. The | ||||
* crc_disable flag disables CRC stripping on the VF. Setting | |||||
* the crc_disable flag to 1 will disable CRC stripping for each | |||||
* queue in the VF where the flag is set. The VIRTCHNL_VF_OFFLOAD_CRC | |||||
* offload must have been set prior to sending this info or the PF | |||||
* will ignore the request. This flag should be set the same for | |||||
* all of the queues for a VF. | |||||
*/ | */ | ||||
/* Rx queue config info */ | /* Rx queue config info */ | ||||
struct virtchnl_rxq_info { | struct virtchnl_rxq_info { | ||||
u16 vsi_id; | u16 vsi_id; | ||||
u16 queue_id; | u16 queue_id; | ||||
u32 ring_len; /* number of descriptors, multiple of 32 */ | u32 ring_len; /* number of descriptors, multiple of 32 */ | ||||
u16 hdr_size; | u16 hdr_size; | ||||
u16 splithdr_enabled; /* deprecated with AVF 1.0 */ | u16 splithdr_enabled; /* deprecated with AVF 1.0 */ | ||||
u32 databuffer_size; | u32 databuffer_size; | ||||
u32 max_pkt_size; | u32 max_pkt_size; | ||||
u32 pad1; | u8 crc_disable; | ||||
u8 pad1[3]; | |||||
u64 dma_ring_addr; | u64 dma_ring_addr; | ||||
enum virtchnl_rx_hsplit rx_split_pos; /* deprecated with AVF 1.0 */ | enum virtchnl_rx_hsplit rx_split_pos; /* deprecated with AVF 1.0 */ | ||||
u32 pad2; | u32 pad2; | ||||
}; | }; | ||||
VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_rxq_info); | VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_rxq_info); | ||||
/* VIRTCHNL_OP_CONFIG_VSI_QUEUES | /* VIRTCHNL_OP_CONFIG_VSI_QUEUES | ||||
* VF sends this message to set parameters for all active TX and RX queues | * VF sends this message to set parameters for active TX and RX queues | ||||
* associated with the specified VSI. | * associated with the specified VSI. | ||||
* PF configures queues and returns status. | * PF configures queues and returns status. | ||||
* If the number of queues specified is greater than the number of queues | * If the number of queues specified is greater than the number of queues | ||||
* associated with the VSI, an error is returned and no queues are configured. | * associated with the VSI, an error is returned and no queues are configured. | ||||
* NOTE: The VF is not required to configure all queues in a single request. | |||||
* It may send multiple messages. PF drivers must correctly handle all VF | |||||
* requests. | |||||
*/ | */ | ||||
struct virtchnl_queue_pair_info { | struct virtchnl_queue_pair_info { | ||||
/* NOTE: vsi_id and queue_id should be identical for both queues. */ | /* NOTE: vsi_id and queue_id should be identical for both queues. */ | ||||
struct virtchnl_txq_info txq; | struct virtchnl_txq_info txq; | ||||
struct virtchnl_rxq_info rxq; | struct virtchnl_rxq_info rxq; | ||||
}; | }; | ||||
VIRTCHNL_CHECK_STRUCT_LEN(64, virtchnl_queue_pair_info); | VIRTCHNL_CHECK_STRUCT_LEN(64, virtchnl_queue_pair_info); | ||||
Show All 21 Lines | |||||
struct virtchnl_vf_res_request { | struct virtchnl_vf_res_request { | ||||
u16 num_queue_pairs; | u16 num_queue_pairs; | ||||
}; | }; | ||||
/* VIRTCHNL_OP_CONFIG_IRQ_MAP | /* VIRTCHNL_OP_CONFIG_IRQ_MAP | ||||
* VF uses this message to map vectors to queues. | * VF uses this message to map vectors to queues. | ||||
* The rxq_map and txq_map fields are bitmaps used to indicate which queues | * The rxq_map and txq_map fields are bitmaps used to indicate which queues | ||||
* are to be associated with the specified vector. | * are to be associated with the specified vector. | ||||
* The "other" causes are always mapped to vector 0. | * The "other" causes are always mapped to vector 0. The VF may not request | ||||
* that vector 0 be used for traffic. | |||||
* PF configures interrupt mapping and returns status. | * PF configures interrupt mapping and returns status. | ||||
* NOTE: due to hardware requirements, all active queues (both TX and RX) | |||||
* should be mapped to interrupts, even if the driver intends to operate | |||||
* only in polling mode. In this case the interrupt may be disabled, but | |||||
* the ITR timer will still run to trigger writebacks. | |||||
*/ | */ | ||||
struct virtchnl_vector_map { | struct virtchnl_vector_map { | ||||
u16 vsi_id; | u16 vsi_id; | ||||
u16 vector_id; | u16 vector_id; | ||||
u16 rxq_map; | u16 rxq_map; | ||||
u16 txq_map; | u16 txq_map; | ||||
u16 rxitr_idx; | u16 rxitr_idx; | ||||
u16 txitr_idx; | u16 txitr_idx; | ||||
Show All 10 Lines | |||||
/* VIRTCHNL_OP_ENABLE_QUEUES | /* VIRTCHNL_OP_ENABLE_QUEUES | ||||
* VIRTCHNL_OP_DISABLE_QUEUES | * VIRTCHNL_OP_DISABLE_QUEUES | ||||
* VF sends these message to enable or disable TX/RX queue pairs. | * VF sends these message to enable or disable TX/RX queue pairs. | ||||
* The queues fields are bitmaps indicating which queues to act upon. | * The queues fields are bitmaps indicating which queues to act upon. | ||||
* (Currently, we only support 16 queues per VF, but we make the field | * (Currently, we only support 16 queues per VF, but we make the field | ||||
* u32 to allow for expansion.) | * u32 to allow for expansion.) | ||||
* PF performs requested action and returns status. | * PF performs requested action and returns status. | ||||
* NOTE: The VF is not required to enable/disable all queues in a single | |||||
* request. It may send multiple messages. | |||||
* PF drivers must correctly handle all VF requests. | |||||
*/ | */ | ||||
struct virtchnl_queue_select { | struct virtchnl_queue_select { | ||||
u16 vsi_id; | u16 vsi_id; | ||||
u16 pad; | u16 pad; | ||||
u32 rx_queues; | u32 rx_queues; | ||||
u32 tx_queues; | u32 tx_queues; | ||||
}; | }; | ||||
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines | |||||
#define FLAG_VF_UNICAST_PROMISC 0x00000001 | #define FLAG_VF_UNICAST_PROMISC 0x00000001 | ||||
#define FLAG_VF_MULTICAST_PROMISC 0x00000002 | #define FLAG_VF_MULTICAST_PROMISC 0x00000002 | ||||
/* VIRTCHNL_OP_GET_STATS | /* VIRTCHNL_OP_GET_STATS | ||||
* VF sends this message to request stats for the selected VSI. VF uses | * VF sends this message to request stats for the selected VSI. VF uses | ||||
* the virtchnl_queue_select struct to specify the VSI. The queue_id | * the virtchnl_queue_select struct to specify the VSI. The queue_id | ||||
* field is ignored by the PF. | * field is ignored by the PF. | ||||
* | * | ||||
* PF replies with struct eth_stats in an external buffer. | * PF replies with struct virtchnl_eth_stats in an external buffer. | ||||
*/ | */ | ||||
struct virtchnl_eth_stats { | |||||
u64 rx_bytes; /* received bytes */ | |||||
u64 rx_unicast; /* received unicast pkts */ | |||||
u64 rx_multicast; /* received multicast pkts */ | |||||
u64 rx_broadcast; /* received broadcast pkts */ | |||||
u64 rx_discards; | |||||
u64 rx_unknown_protocol; | |||||
u64 tx_bytes; /* transmitted bytes */ | |||||
u64 tx_unicast; /* transmitted unicast pkts */ | |||||
u64 tx_multicast; /* transmitted multicast pkts */ | |||||
u64 tx_broadcast; /* transmitted broadcast pkts */ | |||||
u64 tx_discards; | |||||
u64 tx_errors; | |||||
}; | |||||
/* VIRTCHNL_OP_CONFIG_RSS_KEY | /* VIRTCHNL_OP_CONFIG_RSS_KEY | ||||
* VIRTCHNL_OP_CONFIG_RSS_LUT | * VIRTCHNL_OP_CONFIG_RSS_LUT | ||||
* VF sends these messages to configure RSS. Only supported if both PF | * VF sends these messages to configure RSS. Only supported if both PF | ||||
* and VF drivers set the VIRTCHNL_VF_OFFLOAD_RSS_PF bit during | * and VF drivers set the VIRTCHNL_VF_OFFLOAD_RSS_PF bit during | ||||
* configuration negotiation. If this is the case, then the RSS fields in | * configuration negotiation. If this is the case, then the RSS fields in | ||||
* the VF resource struct are valid. | * the VF resource struct are valid. | ||||
* Both the key and LUT are initialized to 0 by the PF, meaning that | * Both the key and LUT are initialized to 0 by the PF, meaning that | ||||
* RSS is effectively disabled until set up by the VF. | * RSS is effectively disabled until set up by the VF. | ||||
Show All 22 Lines | |||||
* traffic types that are hashed by the hardware. | * traffic types that are hashed by the hardware. | ||||
*/ | */ | ||||
struct virtchnl_rss_hena { | struct virtchnl_rss_hena { | ||||
u64 hena; | u64 hena; | ||||
}; | }; | ||||
VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_rss_hena); | VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_rss_hena); | ||||
/* VIRTCHNL_OP_ENABLE_CHANNELS | |||||
* VIRTCHNL_OP_DISABLE_CHANNELS | |||||
* VF sends these messages to enable or disable channels based on | |||||
* the user specified queue count and queue offset for each traffic class. | |||||
* This struct encompasses all the information that the PF needs from | |||||
* VF to create a channel. | |||||
*/ | |||||
struct virtchnl_channel_info { | |||||
u16 count; /* number of queues in a channel */ | |||||
u16 offset; /* queues in a channel start from 'offset' */ | |||||
u32 pad; | |||||
u64 max_tx_rate; | |||||
}; | |||||
VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_channel_info); | |||||
struct virtchnl_tc_info { | |||||
u32 num_tc; | |||||
u32 pad; | |||||
struct virtchnl_channel_info list[1]; | |||||
}; | |||||
VIRTCHNL_CHECK_STRUCT_LEN(24, virtchnl_tc_info); | |||||
/* VIRTCHNL_ADD_CLOUD_FILTER | |||||
* VIRTCHNL_DEL_CLOUD_FILTER | |||||
* VF sends these messages to add or delete a cloud filter based on the | |||||
* user specified match and action filters. These structures encompass | |||||
* all the information that the PF needs from the VF to add/delete a | |||||
* cloud filter. | |||||
*/ | |||||
struct virtchnl_l4_spec { | |||||
u8 src_mac[ETH_ALEN]; | |||||
u8 dst_mac[ETH_ALEN]; | |||||
__be16 vlan_id; | |||||
__be16 pad; /* reserved for future use */ | |||||
__be32 src_ip[4]; | |||||
__be32 dst_ip[4]; | |||||
__be16 src_port; | |||||
__be16 dst_port; | |||||
}; | |||||
VIRTCHNL_CHECK_STRUCT_LEN(52, virtchnl_l4_spec); | |||||
union virtchnl_flow_spec { | |||||
struct virtchnl_l4_spec tcp_spec; | |||||
u8 buffer[128]; /* reserved for future use */ | |||||
}; | |||||
VIRTCHNL_CHECK_UNION_LEN(128, virtchnl_flow_spec); | |||||
enum virtchnl_action { | |||||
/* action types */ | |||||
VIRTCHNL_ACTION_DROP = 0, | |||||
VIRTCHNL_ACTION_TC_REDIRECT, | |||||
}; | |||||
enum virtchnl_flow_type { | |||||
/* flow types */ | |||||
VIRTCHNL_TCP_V4_FLOW = 0, | |||||
VIRTCHNL_TCP_V6_FLOW, | |||||
}; | |||||
struct virtchnl_filter { | |||||
union virtchnl_flow_spec data; | |||||
union virtchnl_flow_spec mask; | |||||
enum virtchnl_flow_type flow_type; | |||||
enum virtchnl_action action; | |||||
u32 action_meta; | |||||
u8 field_flags; | |||||
}; | |||||
VIRTCHNL_CHECK_STRUCT_LEN(272, virtchnl_filter); | |||||
/* VIRTCHNL_OP_EVENT | /* VIRTCHNL_OP_EVENT | ||||
* PF sends this message to inform the VF driver of events that may affect it. | * PF sends this message to inform the VF driver of events that may affect it. | ||||
* No direct response is expected from the VF, though it may generate other | * No direct response is expected from the VF, though it may generate other | ||||
* messages in response to this one. | * messages in response to this one. | ||||
*/ | */ | ||||
enum virtchnl_event_codes { | enum virtchnl_event_codes { | ||||
VIRTCHNL_EVENT_UNKNOWN = 0, | VIRTCHNL_EVENT_UNKNOWN = 0, | ||||
VIRTCHNL_EVENT_LINK_CHANGE, | VIRTCHNL_EVENT_LINK_CHANGE, | ||||
VIRTCHNL_EVENT_RESET_IMPENDING, | VIRTCHNL_EVENT_RESET_IMPENDING, | ||||
VIRTCHNL_EVENT_PF_DRIVER_CLOSE, | VIRTCHNL_EVENT_PF_DRIVER_CLOSE, | ||||
}; | }; | ||||
#define PF_EVENT_SEVERITY_INFO 0 | #define PF_EVENT_SEVERITY_INFO 0 | ||||
#define PF_EVENT_SEVERITY_ATTENTION 1 | #define PF_EVENT_SEVERITY_ATTENTION 1 | ||||
#define PF_EVENT_SEVERITY_ACTION_REQUIRED 2 | #define PF_EVENT_SEVERITY_ACTION_REQUIRED 2 | ||||
#define PF_EVENT_SEVERITY_CERTAIN_DOOM 255 | #define PF_EVENT_SEVERITY_CERTAIN_DOOM 255 | ||||
struct virtchnl_pf_event { | struct virtchnl_pf_event { | ||||
enum virtchnl_event_codes event; | enum virtchnl_event_codes event; | ||||
union { | union { | ||||
/* If the PF driver does not support the new speed reporting | |||||
* capabilities then use link_event else use link_event_adv to | |||||
* get the speed and link information. The ability to understand | |||||
* new speeds is indicated by setting the capability flag | |||||
* VIRTCHNL_VF_CAP_ADV_LINK_SPEED in vf_cap_flags parameter | |||||
* in virtchnl_vf_resource struct and can be used to determine | |||||
* which link event struct to use below. | |||||
*/ | |||||
struct { | struct { | ||||
enum virtchnl_link_speed link_speed; | enum virtchnl_link_speed link_speed; | ||||
bool link_status; | u8 link_status; | ||||
} link_event; | } link_event; | ||||
struct { | |||||
/* link_speed provided in Mbps */ | |||||
u32 link_speed; | |||||
u8 link_status; | |||||
} link_event_adv; | |||||
} event_data; | } event_data; | ||||
int severity; | int severity; | ||||
}; | }; | ||||
VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_pf_event); | VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_pf_event); | ||||
/* VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP | /* VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP | ||||
* VF uses this message to request PF to map IWARP vectors to IWARP queues. | * VF uses this message to request PF to map IWARP vectors to IWARP queues. | ||||
* The request for this originates from the VF IWARP driver through | * The request for this originates from the VF IWARP driver through | ||||
* a client interface between VF LAN and VF IWARP driver. | * a client interface between VF LAN and VF IWARP driver. | ||||
* A vector could have an AEQ and CEQ attached to it although | * A vector could have an AEQ and CEQ attached to it although | ||||
* there is a single AEQ per VF IWARP instance in which case | * there is a single AEQ per VF IWARP instance in which case | ||||
* most vectors will have an INVALID_IDX for aeq and valid idx for ceq. | * most vectors will have an INVALID_IDX for aeq and valid idx for ceq. | ||||
* There will never be a case where there will be multiple CEQs attached | * There will never be a case where there will be multiple CEQs attached | ||||
* to a single vector. | * to a single vector. | ||||
* PF configures interrupt mapping and returns status. | * PF configures interrupt mapping and returns status. | ||||
*/ | */ | ||||
/* HW does not define a type value for AEQ; only for RX/TX and CEQ. | |||||
* In order for us to keep the interface simple, SW will define a | |||||
* unique type value for AEQ. | |||||
*/ | |||||
#define QUEUE_TYPE_PE_AEQ 0x80 | |||||
#define QUEUE_INVALID_IDX 0xFFFF | |||||
struct virtchnl_iwarp_qv_info { | struct virtchnl_iwarp_qv_info { | ||||
u32 v_idx; /* msix_vector */ | u32 v_idx; /* msix_vector */ | ||||
u16 ceq_idx; | u16 ceq_idx; | ||||
u16 aeq_idx; | u16 aeq_idx; | ||||
u8 itr_idx; | u8 itr_idx; | ||||
}; | }; | ||||
VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_iwarp_qv_info); | VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_iwarp_qv_info); | ||||
struct virtchnl_iwarp_qvlist_info { | struct virtchnl_iwarp_qvlist_info { | ||||
u32 num_vectors; | u32 num_vectors; | ||||
struct virtchnl_iwarp_qv_info qv_info[1]; | struct virtchnl_iwarp_qv_info qv_info[1]; | ||||
}; | }; | ||||
VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_iwarp_qvlist_info); | VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_iwarp_qvlist_info); | ||||
/* Since VF messages are limited by u16 size, precalculate the maximum possible | |||||
* values of nested elements in virtchnl structures that virtual channel can | |||||
* possibly handle in a single message. | |||||
*/ | |||||
enum virtchnl_vector_limits { | |||||
VIRTCHNL_OP_CONFIG_VSI_QUEUES_MAX = | |||||
((u16)(~0) - sizeof(struct virtchnl_vsi_queue_config_info)) / | |||||
sizeof(struct virtchnl_queue_pair_info), | |||||
VIRTCHNL_OP_CONFIG_IRQ_MAP_MAX = | |||||
((u16)(~0) - sizeof(struct virtchnl_irq_map_info)) / | |||||
sizeof(struct virtchnl_vector_map), | |||||
VIRTCHNL_OP_ADD_DEL_ETH_ADDR_MAX = | |||||
((u16)(~0) - sizeof(struct virtchnl_ether_addr_list)) / | |||||
sizeof(struct virtchnl_ether_addr), | |||||
VIRTCHNL_OP_ADD_DEL_VLAN_MAX = | |||||
((u16)(~0) - sizeof(struct virtchnl_vlan_filter_list)) / | |||||
sizeof(u16), | |||||
VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP_MAX = | |||||
((u16)(~0) - sizeof(struct virtchnl_iwarp_qvlist_info)) / | |||||
sizeof(struct virtchnl_iwarp_qv_info), | |||||
VIRTCHNL_OP_ENABLE_CHANNELS_MAX = | |||||
((u16)(~0) - sizeof(struct virtchnl_tc_info)) / | |||||
sizeof(struct virtchnl_channel_info), | |||||
}; | |||||
/* VF reset states - these are written into the RSTAT register: | /* VF reset states - these are written into the RSTAT register: | ||||
* VFGEN_RSTAT on the VF | * VFGEN_RSTAT on the VF | ||||
* When the PF initiates a reset, it writes 0 | * When the PF initiates a reset, it writes 0 | ||||
* When the reset is complete, it writes 1 | * When the reset is complete, it writes 1 | ||||
* When the PF detects that the VF has recovered, it writes 2 | * When the PF detects that the VF has recovered, it writes 2 | ||||
* VF checks this register periodically to determine if a reset has occurred, | * VF checks this register periodically to determine if a reset has occurred, | ||||
* then polls it to know when the reset is complete. | * then polls it to know when the reset is complete. | ||||
* If either the PF or VF reads the register while the hardware | * If either the PF or VF reads the register while the hardware | ||||
Show All 39 Lines | virtchnl_vc_validate_vf_msg(struct virtchnl_version_info *ver, u32 v_opcode, | ||||
case VIRTCHNL_OP_CONFIG_RX_QUEUE: | case VIRTCHNL_OP_CONFIG_RX_QUEUE: | ||||
valid_len = sizeof(struct virtchnl_rxq_info); | valid_len = sizeof(struct virtchnl_rxq_info); | ||||
break; | break; | ||||
case VIRTCHNL_OP_CONFIG_VSI_QUEUES: | case VIRTCHNL_OP_CONFIG_VSI_QUEUES: | ||||
valid_len = sizeof(struct virtchnl_vsi_queue_config_info); | valid_len = sizeof(struct virtchnl_vsi_queue_config_info); | ||||
if (msglen >= valid_len) { | if (msglen >= valid_len) { | ||||
struct virtchnl_vsi_queue_config_info *vqc = | struct virtchnl_vsi_queue_config_info *vqc = | ||||
(struct virtchnl_vsi_queue_config_info *)msg; | (struct virtchnl_vsi_queue_config_info *)msg; | ||||
if (vqc->num_queue_pairs == 0 || vqc->num_queue_pairs > | |||||
VIRTCHNL_OP_CONFIG_VSI_QUEUES_MAX) { | |||||
err_msg_format = TRUE; | |||||
break; | |||||
} | |||||
valid_len += (vqc->num_queue_pairs * | valid_len += (vqc->num_queue_pairs * | ||||
sizeof(struct | sizeof(struct | ||||
virtchnl_queue_pair_info)); | virtchnl_queue_pair_info)); | ||||
if (vqc->num_queue_pairs == 0) | |||||
err_msg_format = TRUE; | |||||
} | } | ||||
break; | break; | ||||
case VIRTCHNL_OP_CONFIG_IRQ_MAP: | case VIRTCHNL_OP_CONFIG_IRQ_MAP: | ||||
valid_len = sizeof(struct virtchnl_irq_map_info); | valid_len = sizeof(struct virtchnl_irq_map_info); | ||||
if (msglen >= valid_len) { | if (msglen >= valid_len) { | ||||
struct virtchnl_irq_map_info *vimi = | struct virtchnl_irq_map_info *vimi = | ||||
(struct virtchnl_irq_map_info *)msg; | (struct virtchnl_irq_map_info *)msg; | ||||
if (vimi->num_vectors == 0 || vimi->num_vectors > | |||||
VIRTCHNL_OP_CONFIG_IRQ_MAP_MAX) { | |||||
err_msg_format = TRUE; | |||||
break; | |||||
} | |||||
valid_len += (vimi->num_vectors * | valid_len += (vimi->num_vectors * | ||||
sizeof(struct virtchnl_vector_map)); | sizeof(struct virtchnl_vector_map)); | ||||
if (vimi->num_vectors == 0) | |||||
err_msg_format = TRUE; | |||||
} | } | ||||
break; | break; | ||||
case VIRTCHNL_OP_ENABLE_QUEUES: | case VIRTCHNL_OP_ENABLE_QUEUES: | ||||
case VIRTCHNL_OP_DISABLE_QUEUES: | case VIRTCHNL_OP_DISABLE_QUEUES: | ||||
valid_len = sizeof(struct virtchnl_queue_select); | valid_len = sizeof(struct virtchnl_queue_select); | ||||
break; | break; | ||||
case VIRTCHNL_OP_ADD_ETH_ADDR: | case VIRTCHNL_OP_ADD_ETH_ADDR: | ||||
case VIRTCHNL_OP_DEL_ETH_ADDR: | case VIRTCHNL_OP_DEL_ETH_ADDR: | ||||
valid_len = sizeof(struct virtchnl_ether_addr_list); | valid_len = sizeof(struct virtchnl_ether_addr_list); | ||||
if (msglen >= valid_len) { | if (msglen >= valid_len) { | ||||
struct virtchnl_ether_addr_list *veal = | struct virtchnl_ether_addr_list *veal = | ||||
(struct virtchnl_ether_addr_list *)msg; | (struct virtchnl_ether_addr_list *)msg; | ||||
if (veal->num_elements == 0 || veal->num_elements > | |||||
VIRTCHNL_OP_ADD_DEL_ETH_ADDR_MAX) { | |||||
err_msg_format = TRUE; | |||||
break; | |||||
} | |||||
valid_len += veal->num_elements * | valid_len += veal->num_elements * | ||||
sizeof(struct virtchnl_ether_addr); | sizeof(struct virtchnl_ether_addr); | ||||
if (veal->num_elements == 0) | |||||
err_msg_format = TRUE; | |||||
} | } | ||||
break; | break; | ||||
case VIRTCHNL_OP_ADD_VLAN: | case VIRTCHNL_OP_ADD_VLAN: | ||||
case VIRTCHNL_OP_DEL_VLAN: | case VIRTCHNL_OP_DEL_VLAN: | ||||
valid_len = sizeof(struct virtchnl_vlan_filter_list); | valid_len = sizeof(struct virtchnl_vlan_filter_list); | ||||
if (msglen >= valid_len) { | if (msglen >= valid_len) { | ||||
struct virtchnl_vlan_filter_list *vfl = | struct virtchnl_vlan_filter_list *vfl = | ||||
(struct virtchnl_vlan_filter_list *)msg; | (struct virtchnl_vlan_filter_list *)msg; | ||||
valid_len += vfl->num_elements * sizeof(u16); | |||||
if (vfl->num_elements == 0) | if (vfl->num_elements == 0 || vfl->num_elements > | ||||
VIRTCHNL_OP_ADD_DEL_VLAN_MAX) { | |||||
err_msg_format = TRUE; | err_msg_format = TRUE; | ||||
break; | |||||
} | } | ||||
valid_len += vfl->num_elements * sizeof(u16); | |||||
} | |||||
break; | break; | ||||
case VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE: | case VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE: | ||||
valid_len = sizeof(struct virtchnl_promisc_info); | valid_len = sizeof(struct virtchnl_promisc_info); | ||||
break; | break; | ||||
case VIRTCHNL_OP_GET_STATS: | case VIRTCHNL_OP_GET_STATS: | ||||
valid_len = sizeof(struct virtchnl_queue_select); | valid_len = sizeof(struct virtchnl_queue_select); | ||||
break; | break; | ||||
case VIRTCHNL_OP_IWARP: | case VIRTCHNL_OP_IWARP: | ||||
/* These messages are opaque to us and will be validated in | /* These messages are opaque to us and will be validated in | ||||
* the RDMA client code. We just need to check for nonzero | * the RDMA client code. We just need to check for nonzero | ||||
* length. The firmware will enforce max length restrictions. | * length. The firmware will enforce max length restrictions. | ||||
*/ | */ | ||||
if (msglen) | if (msglen) | ||||
valid_len = msglen; | valid_len = msglen; | ||||
else | else | ||||
err_msg_format = TRUE; | err_msg_format = TRUE; | ||||
break; | break; | ||||
case VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP: | case VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP: | ||||
break; | break; | ||||
case VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP: | case VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP: | ||||
valid_len = sizeof(struct virtchnl_iwarp_qvlist_info); | valid_len = sizeof(struct virtchnl_iwarp_qvlist_info); | ||||
if (msglen >= valid_len) { | if (msglen >= valid_len) { | ||||
struct virtchnl_iwarp_qvlist_info *qv = | struct virtchnl_iwarp_qvlist_info *qv = | ||||
(struct virtchnl_iwarp_qvlist_info *)msg; | (struct virtchnl_iwarp_qvlist_info *)msg; | ||||
if (qv->num_vectors == 0) { | |||||
if (qv->num_vectors == 0 || qv->num_vectors > | |||||
VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP_MAX) { | |||||
err_msg_format = TRUE; | err_msg_format = TRUE; | ||||
break; | break; | ||||
} | } | ||||
valid_len += ((qv->num_vectors - 1) * | valid_len += ((qv->num_vectors - 1) * | ||||
sizeof(struct virtchnl_iwarp_qv_info)); | sizeof(struct virtchnl_iwarp_qv_info)); | ||||
} | } | ||||
break; | break; | ||||
case VIRTCHNL_OP_CONFIG_RSS_KEY: | case VIRTCHNL_OP_CONFIG_RSS_KEY: | ||||
valid_len = sizeof(struct virtchnl_rss_key); | valid_len = sizeof(struct virtchnl_rss_key); | ||||
if (msglen >= valid_len) { | if (msglen >= valid_len) { | ||||
struct virtchnl_rss_key *vrk = | struct virtchnl_rss_key *vrk = | ||||
Show All 15 Lines | case VIRTCHNL_OP_SET_RSS_HENA: | ||||
valid_len = sizeof(struct virtchnl_rss_hena); | valid_len = sizeof(struct virtchnl_rss_hena); | ||||
break; | break; | ||||
case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING: | case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING: | ||||
case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING: | case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING: | ||||
break; | break; | ||||
case VIRTCHNL_OP_REQUEST_QUEUES: | case VIRTCHNL_OP_REQUEST_QUEUES: | ||||
valid_len = sizeof(struct virtchnl_vf_res_request); | valid_len = sizeof(struct virtchnl_vf_res_request); | ||||
break; | break; | ||||
case VIRTCHNL_OP_ENABLE_CHANNELS: | |||||
valid_len = sizeof(struct virtchnl_tc_info); | |||||
if (msglen >= valid_len) { | |||||
struct virtchnl_tc_info *vti = | |||||
(struct virtchnl_tc_info *)msg; | |||||
if (vti->num_tc == 0 || vti->num_tc > | |||||
VIRTCHNL_OP_ENABLE_CHANNELS_MAX) { | |||||
err_msg_format = TRUE; | |||||
break; | |||||
} | |||||
valid_len += (vti->num_tc - 1) * | |||||
sizeof(struct virtchnl_channel_info); | |||||
} | |||||
break; | |||||
case VIRTCHNL_OP_DISABLE_CHANNELS: | |||||
break; | |||||
case VIRTCHNL_OP_ADD_CLOUD_FILTER: | |||||
/* fall through */ | |||||
case VIRTCHNL_OP_DEL_CLOUD_FILTER: | |||||
valid_len = sizeof(struct virtchnl_filter); | |||||
break; | |||||
/* These are always errors coming from the VF. */ | /* These are always errors coming from the VF. */ | ||||
case VIRTCHNL_OP_EVENT: | case VIRTCHNL_OP_EVENT: | ||||
case VIRTCHNL_OP_UNKNOWN: | case VIRTCHNL_OP_UNKNOWN: | ||||
default: | default: | ||||
return VIRTCHNL_ERR_PARAM; | return VIRTCHNL_STATUS_ERR_PARAM; | ||||
} | } | ||||
/* few more checks */ | /* few more checks */ | ||||
if (err_msg_format || valid_len != msglen) | if (err_msg_format || valid_len != msglen) | ||||
return VIRTCHNL_STATUS_ERR_OPCODE_MISMATCH; | return VIRTCHNL_STATUS_ERR_OPCODE_MISMATCH; | ||||
return 0; | return 0; | ||||
} | } | ||||
#endif /* _VIRTCHNL_H_ */ | #endif /* _VIRTCHNL_H_ */ |