1/* SPDX-License-Identifier: GPL-2.0-only */ 2/* Copyright (c) 2013-2022, Intel Corporation. */ 3 4#ifndef _VIRTCHNL_H_ 5#define _VIRTCHNL_H_ 6 7#include <linux/bitops.h> 8#include <linux/bits.h> 9#include <linux/overflow.h> 10#include <uapi/linux/if_ether.h> 11 12/* Description: 13 * This header file describes the Virtual Function (VF) - Physical Function 14 * (PF) communication protocol used by the drivers for all devices starting 15 * from our 40G product line 16 * 17 * Admin queue buffer usage: 18 * desc->opcode is always aqc_opc_send_msg_to_pf 19 * flags, retval, datalen, and data addr are all used normally. 20 * The Firmware copies the cookie fields when sending messages between the 21 * PF and VF, but uses all other fields internally. Due to this limitation, 22 * we must send all messages as "indirect", i.e. using an external buffer. 23 * 24 * All the VSI indexes are relative to the VF. Each VF can have maximum of 25 * three VSIs. All the queue indexes are relative to the VSI. Each VF can 26 * have a maximum of sixteen queues for all of its VSIs. 27 * 28 * The PF is required to return a status code in v_retval for all messages 29 * except RESET_VF, which does not require any response. The returned value 30 * is of virtchnl_status_code type, defined here. 31 * 32 * In general, VF driver initialization should roughly follow the order of 33 * these opcodes. The VF driver must first validate the API version of the 34 * PF driver, then request a reset, then get resources, then configure 35 * queues and interrupts. After these operations are complete, the VF 36 * driver may start its queues, optionally add MAC and VLAN filters, and 37 * process traffic. 38 */ 39 40/* START GENERIC DEFINES 41 * Need to ensure the following enums and defines hold the same meaning and 42 * value in current and future projects 43 */ 44 45/* Error Codes */ 46enum virtchnl_status_code { 47 VIRTCHNL_STATUS_SUCCESS = 0, 48 VIRTCHNL_STATUS_ERR_PARAM = -5, 49 VIRTCHNL_STATUS_ERR_NO_MEMORY = -18, 50 VIRTCHNL_STATUS_ERR_OPCODE_MISMATCH = -38, 51 VIRTCHNL_STATUS_ERR_CQP_COMPL_ERROR = -39, 52 VIRTCHNL_STATUS_ERR_INVALID_VF_ID = -40, 53 VIRTCHNL_STATUS_ERR_ADMIN_QUEUE_ERROR = -53, 54 VIRTCHNL_STATUS_ERR_NOT_SUPPORTED = -64, 55}; 56 57/* Backward compatibility */ 58#define VIRTCHNL_ERR_PARAM VIRTCHNL_STATUS_ERR_PARAM 59#define VIRTCHNL_STATUS_NOT_SUPPORTED VIRTCHNL_STATUS_ERR_NOT_SUPPORTED 60 61#define VIRTCHNL_LINK_SPEED_2_5GB_SHIFT 0x0 62#define VIRTCHNL_LINK_SPEED_100MB_SHIFT 0x1 63#define VIRTCHNL_LINK_SPEED_1000MB_SHIFT 0x2 64#define VIRTCHNL_LINK_SPEED_10GB_SHIFT 0x3 65#define VIRTCHNL_LINK_SPEED_40GB_SHIFT 0x4 66#define VIRTCHNL_LINK_SPEED_20GB_SHIFT 0x5 67#define VIRTCHNL_LINK_SPEED_25GB_SHIFT 0x6 68#define VIRTCHNL_LINK_SPEED_5GB_SHIFT 0x7 69 70enum virtchnl_link_speed { 71 VIRTCHNL_LINK_SPEED_UNKNOWN = 0, 72 VIRTCHNL_LINK_SPEED_100MB = BIT(VIRTCHNL_LINK_SPEED_100MB_SHIFT), 73 VIRTCHNL_LINK_SPEED_1GB = BIT(VIRTCHNL_LINK_SPEED_1000MB_SHIFT), 74 VIRTCHNL_LINK_SPEED_10GB = BIT(VIRTCHNL_LINK_SPEED_10GB_SHIFT), 75 VIRTCHNL_LINK_SPEED_40GB = BIT(VIRTCHNL_LINK_SPEED_40GB_SHIFT), 76 VIRTCHNL_LINK_SPEED_20GB = BIT(VIRTCHNL_LINK_SPEED_20GB_SHIFT), 77 VIRTCHNL_LINK_SPEED_25GB = BIT(VIRTCHNL_LINK_SPEED_25GB_SHIFT), 78 VIRTCHNL_LINK_SPEED_2_5GB = BIT(VIRTCHNL_LINK_SPEED_2_5GB_SHIFT), 79 VIRTCHNL_LINK_SPEED_5GB = BIT(VIRTCHNL_LINK_SPEED_5GB_SHIFT), 80}; 81 82/* for hsplit_0 field of Rx HMC context */ 83/* deprecated with AVF 1.0 */ 84enum virtchnl_rx_hsplit { 85 VIRTCHNL_RX_HSPLIT_NO_SPLIT = 0, 86 VIRTCHNL_RX_HSPLIT_SPLIT_L2 = 1, 87 VIRTCHNL_RX_HSPLIT_SPLIT_IP = 2, 88 VIRTCHNL_RX_HSPLIT_SPLIT_TCP_UDP = 4, 89 VIRTCHNL_RX_HSPLIT_SPLIT_SCTP = 8, 90}; 91 92/* END GENERIC DEFINES */ 93 94/* Opcodes for VF-PF communication. These are placed in the v_opcode field 95 * of the virtchnl_msg structure. 96 */ 97enum virtchnl_ops { 98/* The PF sends status change events to VFs using 99 * the VIRTCHNL_OP_EVENT opcode. 100 * VFs send requests to the PF using the other ops. 101 * Use of "advanced opcode" features must be negotiated as part of capabilities 102 * exchange and are not considered part of base mode feature set. 103 */ 104 VIRTCHNL_OP_UNKNOWN = 0, 105 VIRTCHNL_OP_VERSION = 1, /* must ALWAYS be 1 */ 106 VIRTCHNL_OP_RESET_VF = 2, 107 VIRTCHNL_OP_GET_VF_RESOURCES = 3, 108 VIRTCHNL_OP_CONFIG_TX_QUEUE = 4, 109 VIRTCHNL_OP_CONFIG_RX_QUEUE = 5, 110 VIRTCHNL_OP_CONFIG_VSI_QUEUES = 6, 111 VIRTCHNL_OP_CONFIG_IRQ_MAP = 7, 112 VIRTCHNL_OP_ENABLE_QUEUES = 8, 113 VIRTCHNL_OP_DISABLE_QUEUES = 9, 114 VIRTCHNL_OP_ADD_ETH_ADDR = 10, 115 VIRTCHNL_OP_DEL_ETH_ADDR = 11, 116 VIRTCHNL_OP_ADD_VLAN = 12, 117 VIRTCHNL_OP_DEL_VLAN = 13, 118 VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE = 14, 119 VIRTCHNL_OP_GET_STATS = 15, 120 VIRTCHNL_OP_RSVD = 16, 121 VIRTCHNL_OP_EVENT = 17, /* must ALWAYS be 17 */ 122 VIRTCHNL_OP_CONFIG_RSS_HFUNC = 18, 123 /* opcode 19 is reserved */ 124 VIRTCHNL_OP_IWARP = 20, /* advanced opcode */ 125 VIRTCHNL_OP_RDMA = VIRTCHNL_OP_IWARP, 126 VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP = 21, /* advanced opcode */ 127 VIRTCHNL_OP_CONFIG_RDMA_IRQ_MAP = VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP, 128 VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP = 22, /* advanced opcode */ 129 VIRTCHNL_OP_RELEASE_RDMA_IRQ_MAP = VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP, 130 VIRTCHNL_OP_CONFIG_RSS_KEY = 23, 131 VIRTCHNL_OP_CONFIG_RSS_LUT = 24, 132 VIRTCHNL_OP_GET_RSS_HENA_CAPS = 25, 133 VIRTCHNL_OP_SET_RSS_HENA = 26, 134 VIRTCHNL_OP_ENABLE_VLAN_STRIPPING = 27, 135 VIRTCHNL_OP_DISABLE_VLAN_STRIPPING = 28, 136 VIRTCHNL_OP_REQUEST_QUEUES = 29, 137 VIRTCHNL_OP_ENABLE_CHANNELS = 30, 138 VIRTCHNL_OP_DISABLE_CHANNELS = 31, 139 VIRTCHNL_OP_ADD_CLOUD_FILTER = 32, 140 VIRTCHNL_OP_DEL_CLOUD_FILTER = 33, 141 /* opcode 34 - 43 are reserved */ 142 VIRTCHNL_OP_GET_SUPPORTED_RXDIDS = 44, 143 VIRTCHNL_OP_ADD_RSS_CFG = 45, 144 VIRTCHNL_OP_DEL_RSS_CFG = 46, 145 VIRTCHNL_OP_ADD_FDIR_FILTER = 47, 146 VIRTCHNL_OP_DEL_FDIR_FILTER = 48, 147 VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS = 51, 148 VIRTCHNL_OP_ADD_VLAN_V2 = 52, 149 VIRTCHNL_OP_DEL_VLAN_V2 = 53, 150 VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2 = 54, 151 VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2 = 55, 152 VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2 = 56, 153 VIRTCHNL_OP_DISABLE_VLAN_INSERTION_V2 = 57, 154 VIRTCHNL_OP_MAX, 155}; 156 157/* These macros are used to generate compilation errors if a structure/union 158 * is not exactly the correct length. It gives a divide by zero error if the 159 * structure/union is not of the correct size, otherwise it creates an enum 160 * that is never used. 161 */ 162#define VIRTCHNL_CHECK_STRUCT_LEN(n, X) enum virtchnl_static_assert_enum_##X \ 163 { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } 164#define VIRTCHNL_CHECK_UNION_LEN(n, X) enum virtchnl_static_asset_enum_##X \ 165 { virtchnl_static_assert_##X = (n)/((sizeof(union X) == (n)) ? 1 : 0) } 166 167/* Message descriptions and data structures. */ 168 169/* VIRTCHNL_OP_VERSION 170 * VF posts its version number to the PF. PF responds with its version number 171 * in the same format, along with a return code. 172 * Reply from PF has its major/minor versions also in param0 and param1. 173 * If there is a major version mismatch, then the VF cannot operate. 174 * If there is a minor version mismatch, then the VF can operate but should 175 * add a warning to the system log. 176 * 177 * This enum element MUST always be specified as == 1, regardless of other 178 * changes in the API. The PF must always respond to this message without 179 * error regardless of version mismatch. 180 */ 181#define VIRTCHNL_VERSION_MAJOR 1 182#define VIRTCHNL_VERSION_MINOR 1 183#define VIRTCHNL_VERSION_MINOR_NO_VF_CAPS 0 184 185struct virtchnl_version_info { 186 u32 major; 187 u32 minor; 188}; 189 190VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_version_info); 191 192#define VF_IS_V10(_v) (((_v)->major == 1) && ((_v)->minor == 0)) 193#define VF_IS_V11(_ver) (((_ver)->major == 1) && ((_ver)->minor == 1)) 194 195/* VIRTCHNL_OP_RESET_VF 196 * VF sends this request to PF with no parameters 197 * PF does NOT respond! VF driver must delay then poll VFGEN_RSTAT register 198 * until reset completion is indicated. The admin queue must be reinitialized 199 * after this operation. 200 * 201 * When reset is complete, PF must ensure that all queues in all VSIs associated 202 * with the VF are stopped, all queue configurations in the HMC are set to 0, 203 * and all MAC and VLAN filters (except the default MAC address) on all VSIs 204 * are cleared. 205 */ 206 207/* VSI types that use VIRTCHNL interface for VF-PF communication. VSI_SRIOV 208 * vsi_type should always be 6 for backward compatibility. Add other fields 209 * as needed. 210 */ 211enum virtchnl_vsi_type { 212 VIRTCHNL_VSI_TYPE_INVALID = 0, 213 VIRTCHNL_VSI_SRIOV = 6, 214}; 215 216/* VIRTCHNL_OP_GET_VF_RESOURCES 217 * Version 1.0 VF sends this request to PF with no parameters 218 * Version 1.1 VF sends this request to PF with u32 bitmap of its capabilities 219 * PF responds with an indirect message containing 220 * virtchnl_vf_resource and one or more 221 * virtchnl_vsi_resource structures. 222 */ 223 224struct virtchnl_vsi_resource { 225 u16 vsi_id; 226 u16 num_queue_pairs; 227 228 /* see enum virtchnl_vsi_type */ 229 s32 vsi_type; 230 u16 qset_handle; 231 u8 default_mac_addr[ETH_ALEN]; 232}; 233 234VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_vsi_resource); 235 236/* VF capability flags 237 * VIRTCHNL_VF_OFFLOAD_L2 flag is inclusive of base mode L2 offloads including 238 * TX/RX Checksum offloading and TSO for non-tunnelled packets. 239 */ 240#define VIRTCHNL_VF_OFFLOAD_L2 BIT(0) 241#define VIRTCHNL_VF_OFFLOAD_RDMA BIT(1) 242#define VIRTCHNL_VF_CAP_RDMA VIRTCHNL_VF_OFFLOAD_RDMA 243#define VIRTCHNL_VF_OFFLOAD_RSS_AQ BIT(3) 244#define VIRTCHNL_VF_OFFLOAD_RSS_REG BIT(4) 245#define VIRTCHNL_VF_OFFLOAD_WB_ON_ITR BIT(5) 246#define VIRTCHNL_VF_OFFLOAD_REQ_QUEUES BIT(6) 247/* used to negotiate communicating link speeds in Mbps */ 248#define VIRTCHNL_VF_CAP_ADV_LINK_SPEED BIT(7) 249#define VIRTCHNL_VF_OFFLOAD_CRC BIT(10) 250#define VIRTCHNL_VF_OFFLOAD_VLAN_V2 BIT(15) 251#define VIRTCHNL_VF_OFFLOAD_VLAN BIT(16) 252#define VIRTCHNL_VF_OFFLOAD_RX_POLLING BIT(17) 253#define VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2 BIT(18) 254#define VIRTCHNL_VF_OFFLOAD_RSS_PF BIT(19) 255#define VIRTCHNL_VF_OFFLOAD_ENCAP BIT(20) 256#define VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM BIT(21) 257#define VIRTCHNL_VF_OFFLOAD_RX_ENCAP_CSUM BIT(22) 258#define VIRTCHNL_VF_OFFLOAD_ADQ BIT(23) 259#define VIRTCHNL_VF_OFFLOAD_USO BIT(25) 260#define VIRTCHNL_VF_OFFLOAD_RX_FLEX_DESC BIT(26) 261#define VIRTCHNL_VF_OFFLOAD_ADV_RSS_PF BIT(27) 262#define VIRTCHNL_VF_OFFLOAD_FDIR_PF BIT(28) 263 264#define VF_BASE_MODE_OFFLOADS (VIRTCHNL_VF_OFFLOAD_L2 | \ 265 VIRTCHNL_VF_OFFLOAD_VLAN | \ 266 VIRTCHNL_VF_OFFLOAD_RSS_PF) 267 268struct virtchnl_vf_resource { 269 u16 num_vsis; 270 u16 num_queue_pairs; 271 u16 max_vectors; 272 u16 max_mtu; 273 274 u32 vf_cap_flags; 275 u32 rss_key_size; 276 u32 rss_lut_size; 277 278 struct virtchnl_vsi_resource vsi_res[]; 279}; 280 281VIRTCHNL_CHECK_STRUCT_LEN(20, virtchnl_vf_resource); 282#define virtchnl_vf_resource_LEGACY_SIZEOF 36 283 284/* VIRTCHNL_OP_CONFIG_TX_QUEUE 285 * VF sends this message to set up parameters for one TX queue. 286 * External data buffer contains one instance of virtchnl_txq_info. 287 * PF configures requested queue and returns a status code. 288 */ 289 290/* Tx queue config info */ 291struct virtchnl_txq_info { 292 u16 vsi_id; 293 u16 queue_id; 294 u16 ring_len; /* number of descriptors, multiple of 8 */ 295 u16 headwb_enabled; /* deprecated with AVF 1.0 */ 296 u64 dma_ring_addr; 297 u64 dma_headwb_addr; /* deprecated with AVF 1.0 */ 298}; 299 300VIRTCHNL_CHECK_STRUCT_LEN(24, virtchnl_txq_info); 301 302/* VIRTCHNL_OP_CONFIG_RX_QUEUE 303 * VF sends this message to set up parameters for one RX queue. 304 * External data buffer contains one instance of virtchnl_rxq_info. 305 * PF configures requested queue and returns a status code. The 306 * crc_disable flag disables CRC stripping on the VF. Setting 307 * the crc_disable flag to 1 will disable CRC stripping for each 308 * queue in the VF where the flag is set. The VIRTCHNL_VF_OFFLOAD_CRC 309 * offload must have been set prior to sending this info or the PF 310 * will ignore the request. This flag should be set the same for 311 * all of the queues for a VF. 312 */ 313 314/* Rx queue config info */ 315struct virtchnl_rxq_info { 316 u16 vsi_id; 317 u16 queue_id; 318 u32 ring_len; /* number of descriptors, multiple of 32 */ 319 u16 hdr_size; 320 u16 splithdr_enabled; /* deprecated with AVF 1.0 */ 321 u32 databuffer_size; 322 u32 max_pkt_size; 323 u8 crc_disable; 324 u8 rxdid; 325 u8 pad1[2]; 326 u64 dma_ring_addr; 327 328 /* see enum virtchnl_rx_hsplit; deprecated with AVF 1.0 */ 329 s32 rx_split_pos; 330 u32 pad2; 331}; 332 333VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_rxq_info); 334 335/* VIRTCHNL_OP_CONFIG_VSI_QUEUES 336 * VF sends this message to set parameters for all active TX and RX queues 337 * associated with the specified VSI. 338 * PF configures queues and returns status. 339 * If the number of queues specified is greater than the number of queues 340 * associated with the VSI, an error is returned and no queues are configured. 341 * NOTE: The VF is not required to configure all queues in a single request. 342 * It may send multiple messages. PF drivers must correctly handle all VF 343 * requests. 344 */ 345struct virtchnl_queue_pair_info { 346 /* NOTE: vsi_id and queue_id should be identical for both queues. */ 347 struct virtchnl_txq_info txq; 348 struct virtchnl_rxq_info rxq; 349}; 350 351VIRTCHNL_CHECK_STRUCT_LEN(64, virtchnl_queue_pair_info); 352 353struct virtchnl_vsi_queue_config_info { 354 u16 vsi_id; 355 u16 num_queue_pairs; 356 u32 pad; 357 struct virtchnl_queue_pair_info qpair[]; 358}; 359 360VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_vsi_queue_config_info); 361#define virtchnl_vsi_queue_config_info_LEGACY_SIZEOF 72 362 363/* VIRTCHNL_OP_REQUEST_QUEUES 364 * VF sends this message to request the PF to allocate additional queues to 365 * this VF. Each VF gets a guaranteed number of queues on init but asking for 366 * additional queues must be negotiated. This is a best effort request as it 367 * is possible the PF does not have enough queues left to support the request. 368 * If the PF cannot support the number requested it will respond with the 369 * maximum number it is able to support. If the request is successful, PF will 370 * then reset the VF to institute required changes. 371 */ 372 373/* VF resource request */ 374struct virtchnl_vf_res_request { 375 u16 num_queue_pairs; 376}; 377 378/* VIRTCHNL_OP_CONFIG_IRQ_MAP 379 * VF uses this message to map vectors to queues. 380 * The rxq_map and txq_map fields are bitmaps used to indicate which queues 381 * are to be associated with the specified vector. 382 * The "other" causes are always mapped to vector 0. The VF may not request 383 * that vector 0 be used for traffic. 384 * PF configures interrupt mapping and returns status. 385 * NOTE: due to hardware requirements, all active queues (both TX and RX) 386 * should be mapped to interrupts, even if the driver intends to operate 387 * only in polling mode. In this case the interrupt may be disabled, but 388 * the ITR timer will still run to trigger writebacks. 389 */ 390struct virtchnl_vector_map { 391 u16 vsi_id; 392 u16 vector_id; 393 u16 rxq_map; 394 u16 txq_map; 395 u16 rxitr_idx; 396 u16 txitr_idx; 397}; 398 399VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_vector_map); 400 401struct virtchnl_irq_map_info { 402 u16 num_vectors; 403 struct virtchnl_vector_map vecmap[]; 404}; 405 406VIRTCHNL_CHECK_STRUCT_LEN(2, virtchnl_irq_map_info); 407#define virtchnl_irq_map_info_LEGACY_SIZEOF 14 408 409/* VIRTCHNL_OP_ENABLE_QUEUES 410 * VIRTCHNL_OP_DISABLE_QUEUES 411 * VF sends these message to enable or disable TX/RX queue pairs. 412 * The queues fields are bitmaps indicating which queues to act upon. 413 * (Currently, we only support 16 queues per VF, but we make the field 414 * u32 to allow for expansion.) 415 * PF performs requested action and returns status. 416 * NOTE: The VF is not required to enable/disable all queues in a single 417 * request. It may send multiple messages. 418 * PF drivers must correctly handle all VF requests. 419 */ 420struct virtchnl_queue_select { 421 u16 vsi_id; 422 u16 pad; 423 u32 rx_queues; 424 u32 tx_queues; 425}; 426 427VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_queue_select); 428 429/* VIRTCHNL_OP_ADD_ETH_ADDR 430 * VF sends this message in order to add one or more unicast or multicast 431 * address filters for the specified VSI. 432 * PF adds the filters and returns status. 433 */ 434 435/* VIRTCHNL_OP_DEL_ETH_ADDR 436 * VF sends this message in order to remove one or more unicast or multicast 437 * filters for the specified VSI. 438 * PF removes the filters and returns status. 439 */ 440 441/* VIRTCHNL_ETHER_ADDR_LEGACY 442 * Prior to adding the @type member to virtchnl_ether_addr, there were 2 pad 443 * bytes. Moving forward all VF drivers should not set type to 444 * VIRTCHNL_ETHER_ADDR_LEGACY. This is only here to not break previous/legacy 445 * behavior. The control plane function (i.e. PF) can use a best effort method 446 * of tracking the primary/device unicast in this case, but there is no 447 * guarantee and functionality depends on the implementation of the PF. 448 */ 449 450/* VIRTCHNL_ETHER_ADDR_PRIMARY 451 * All VF drivers should set @type to VIRTCHNL_ETHER_ADDR_PRIMARY for the 452 * primary/device unicast MAC address filter for VIRTCHNL_OP_ADD_ETH_ADDR and 453 * VIRTCHNL_OP_DEL_ETH_ADDR. This allows for the underlying control plane 454 * function (i.e. PF) to accurately track and use this MAC address for 455 * displaying on the host and for VM/function reset. 456 */ 457 458/* VIRTCHNL_ETHER_ADDR_EXTRA 459 * All VF drivers should set @type to VIRTCHNL_ETHER_ADDR_EXTRA for any extra 460 * unicast and/or multicast filters that are being added/deleted via 461 * VIRTCHNL_OP_DEL_ETH_ADDR/VIRTCHNL_OP_ADD_ETH_ADDR respectively. 462 */ 463struct virtchnl_ether_addr { 464 u8 addr[ETH_ALEN]; 465 u8 type; 466#define VIRTCHNL_ETHER_ADDR_LEGACY 0 467#define VIRTCHNL_ETHER_ADDR_PRIMARY 1 468#define VIRTCHNL_ETHER_ADDR_EXTRA 2 469#define VIRTCHNL_ETHER_ADDR_TYPE_MASK 3 /* first two bits of type are valid */ 470 u8 pad; 471}; 472 473VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_ether_addr); 474 475struct virtchnl_ether_addr_list { 476 u16 vsi_id; 477 u16 num_elements; 478 struct virtchnl_ether_addr list[]; 479}; 480 481VIRTCHNL_CHECK_STRUCT_LEN(4, virtchnl_ether_addr_list); 482#define virtchnl_ether_addr_list_LEGACY_SIZEOF 12 483 484/* VIRTCHNL_OP_ADD_VLAN 485 * VF sends this message to add one or more VLAN tag filters for receives. 486 * PF adds the filters and returns status. 487 * If a port VLAN is configured by the PF, this operation will return an 488 * error to the VF. 489 */ 490 491/* VIRTCHNL_OP_DEL_VLAN 492 * VF sends this message to remove one or more VLAN tag filters for receives. 493 * PF removes the filters and returns status. 494 * If a port VLAN is configured by the PF, this operation will return an 495 * error to the VF. 496 */ 497 498struct virtchnl_vlan_filter_list { 499 u16 vsi_id; 500 u16 num_elements; 501 u16 vlan_id[]; 502}; 503 504VIRTCHNL_CHECK_STRUCT_LEN(4, virtchnl_vlan_filter_list); 505#define virtchnl_vlan_filter_list_LEGACY_SIZEOF 6 506 507/* This enum is used for all of the VIRTCHNL_VF_OFFLOAD_VLAN_V2_CAPS related 508 * structures and opcodes. 509 * 510 * VIRTCHNL_VLAN_UNSUPPORTED - This field is not supported and if a VF driver 511 * populates it the PF should return VIRTCHNL_STATUS_ERR_NOT_SUPPORTED. 512 * 513 * VIRTCHNL_VLAN_ETHERTYPE_8100 - This field supports 0x8100 ethertype. 514 * VIRTCHNL_VLAN_ETHERTYPE_88A8 - This field supports 0x88A8 ethertype. 515 * VIRTCHNL_VLAN_ETHERTYPE_9100 - This field supports 0x9100 ethertype. 516 * 517 * VIRTCHNL_VLAN_ETHERTYPE_AND - Used when multiple ethertypes can be supported 518 * by the PF concurrently. For example, if the PF can support 519 * VIRTCHNL_VLAN_ETHERTYPE_8100 AND VIRTCHNL_VLAN_ETHERTYPE_88A8 filters it 520 * would OR the following bits: 521 * 522 * VIRTHCNL_VLAN_ETHERTYPE_8100 | 523 * VIRTCHNL_VLAN_ETHERTYPE_88A8 | 524 * VIRTCHNL_VLAN_ETHERTYPE_AND; 525 * 526 * The VF would interpret this as VLAN filtering can be supported on both 0x8100 527 * and 0x88A8 VLAN ethertypes. 528 * 529 * VIRTCHNL_ETHERTYPE_XOR - Used when only a single ethertype can be supported 530 * by the PF concurrently. For example if the PF can support 531 * VIRTCHNL_VLAN_ETHERTYPE_8100 XOR VIRTCHNL_VLAN_ETHERTYPE_88A8 stripping 532 * offload it would OR the following bits: 533 * 534 * VIRTCHNL_VLAN_ETHERTYPE_8100 | 535 * VIRTCHNL_VLAN_ETHERTYPE_88A8 | 536 * VIRTCHNL_VLAN_ETHERTYPE_XOR; 537 * 538 * The VF would interpret this as VLAN stripping can be supported on either 539 * 0x8100 or 0x88a8 VLAN ethertypes. So when requesting VLAN stripping via 540 * VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2 the specified ethertype will override 541 * the previously set value. 542 * 543 * VIRTCHNL_VLAN_TAG_LOCATION_L2TAG1 - Used to tell the VF to insert and/or 544 * strip the VLAN tag using the L2TAG1 field of the Tx/Rx descriptors. 545 * 546 * VIRTCHNL_VLAN_TAG_LOCATION_L2TAG2 - Used to tell the VF to insert hardware 547 * offloaded VLAN tags using the L2TAG2 field of the Tx descriptor. 548 * 549 * VIRTCHNL_VLAN_TAG_LOCATION_L2TAG2 - Used to tell the VF to strip hardware 550 * offloaded VLAN tags using the L2TAG2_2 field of the Rx descriptor. 551 * 552 * VIRTCHNL_VLAN_PRIO - This field supports VLAN priority bits. This is used for 553 * VLAN filtering if the underlying PF supports it. 554 * 555 * VIRTCHNL_VLAN_TOGGLE_ALLOWED - This field is used to say whether a 556 * certain VLAN capability can be toggled. For example if the underlying PF/CP 557 * allows the VF to toggle VLAN filtering, stripping, and/or insertion it should 558 * set this bit along with the supported ethertypes. 559 */ 560enum virtchnl_vlan_support { 561 VIRTCHNL_VLAN_UNSUPPORTED = 0, 562 VIRTCHNL_VLAN_ETHERTYPE_8100 = BIT(0), 563 VIRTCHNL_VLAN_ETHERTYPE_88A8 = BIT(1), 564 VIRTCHNL_VLAN_ETHERTYPE_9100 = BIT(2), 565 VIRTCHNL_VLAN_TAG_LOCATION_L2TAG1 = BIT(8), 566 VIRTCHNL_VLAN_TAG_LOCATION_L2TAG2 = BIT(9), 567 VIRTCHNL_VLAN_TAG_LOCATION_L2TAG2_2 = BIT(10), 568 VIRTCHNL_VLAN_PRIO = BIT(24), 569 VIRTCHNL_VLAN_FILTER_MASK = BIT(28), 570 VIRTCHNL_VLAN_ETHERTYPE_AND = BIT(29), 571 VIRTCHNL_VLAN_ETHERTYPE_XOR = BIT(30), 572 VIRTCHNL_VLAN_TOGGLE = BIT(31), 573}; 574 575/* This structure is used as part of the VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS 576 * for filtering, insertion, and stripping capabilities. 577 * 578 * If only outer capabilities are supported (for filtering, insertion, and/or 579 * stripping) then this refers to the outer most or single VLAN from the VF's 580 * perspective. 581 * 582 * If only inner capabilities are supported (for filtering, insertion, and/or 583 * stripping) then this refers to the outer most or single VLAN from the VF's 584 * perspective. Functionally this is the same as if only outer capabilities are 585 * supported. The VF driver is just forced to use the inner fields when 586 * adding/deleting filters and enabling/disabling offloads (if supported). 587 * 588 * If both outer and inner capabilities are supported (for filtering, insertion, 589 * and/or stripping) then outer refers to the outer most or single VLAN and 590 * inner refers to the second VLAN, if it exists, in the packet. 591 * 592 * There is no support for tunneled VLAN offloads, so outer or inner are never 593 * referring to a tunneled packet from the VF's perspective. 594 */ 595struct virtchnl_vlan_supported_caps { 596 u32 outer; 597 u32 inner; 598}; 599 600/* The PF populates these fields based on the supported VLAN filtering. If a 601 * field is VIRTCHNL_VLAN_UNSUPPORTED then it's not supported and the PF will 602 * reject any VIRTCHNL_OP_ADD_VLAN_V2 or VIRTCHNL_OP_DEL_VLAN_V2 messages using 603 * the unsupported fields. 604 * 605 * Also, a VF is only allowed to toggle its VLAN filtering setting if the 606 * VIRTCHNL_VLAN_TOGGLE bit is set. 607 * 608 * The ethertype(s) specified in the ethertype_init field are the ethertypes 609 * enabled for VLAN filtering. VLAN filtering in this case refers to the outer 610 * most VLAN from the VF's perspective. If both inner and outer filtering are 611 * allowed then ethertype_init only refers to the outer most VLAN as only 612 * VLAN ethertype supported for inner VLAN filtering is 613 * VIRTCHNL_VLAN_ETHERTYPE_8100. By default, inner VLAN filtering is disabled 614 * when both inner and outer filtering are allowed. 615 * 616 * The max_filters field tells the VF how many VLAN filters it's allowed to have 617 * at any one time. If it exceeds this amount and tries to add another filter, 618 * then the request will be rejected by the PF. To prevent failures, the VF 619 * should keep track of how many VLAN filters it has added and not attempt to 620 * add more than max_filters. 621 */ 622struct virtchnl_vlan_filtering_caps { 623 struct virtchnl_vlan_supported_caps filtering_support; 624 u32 ethertype_init; 625 u16 max_filters; 626 u8 pad[2]; 627}; 628 629VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_vlan_filtering_caps); 630 631/* This enum is used for the virtchnl_vlan_offload_caps structure to specify 632 * if the PF supports a different ethertype for stripping and insertion. 633 * 634 * VIRTCHNL_ETHERTYPE_STRIPPING_MATCHES_INSERTION - The ethertype(s) specified 635 * for stripping affect the ethertype(s) specified for insertion and visa versa 636 * as well. If the VF tries to configure VLAN stripping via 637 * VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2 with VIRTCHNL_VLAN_ETHERTYPE_8100 then 638 * that will be the ethertype for both stripping and insertion. 639 * 640 * VIRTCHNL_ETHERTYPE_MATCH_NOT_REQUIRED - The ethertype(s) specified for 641 * stripping do not affect the ethertype(s) specified for insertion and visa 642 * versa. 643 */ 644enum virtchnl_vlan_ethertype_match { 645 VIRTCHNL_ETHERTYPE_STRIPPING_MATCHES_INSERTION = 0, 646 VIRTCHNL_ETHERTYPE_MATCH_NOT_REQUIRED = 1, 647}; 648 649/* The PF populates these fields based on the supported VLAN offloads. If a 650 * field is VIRTCHNL_VLAN_UNSUPPORTED then it's not supported and the PF will 651 * reject any VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2 or 652 * VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2 messages using the unsupported fields. 653 * 654 * Also, a VF is only allowed to toggle its VLAN offload setting if the 655 * VIRTCHNL_VLAN_TOGGLE_ALLOWED bit is set. 656 * 657 * The VF driver needs to be aware of how the tags are stripped by hardware and 658 * inserted by the VF driver based on the level of offload support. The PF will 659 * populate these fields based on where the VLAN tags are expected to be 660 * offloaded via the VIRTHCNL_VLAN_TAG_LOCATION_* bits. The VF will need to 661 * interpret these fields. See the definition of the 662 * VIRTCHNL_VLAN_TAG_LOCATION_* bits above the virtchnl_vlan_support 663 * enumeration. 664 */ 665struct virtchnl_vlan_offload_caps { 666 struct virtchnl_vlan_supported_caps stripping_support; 667 struct virtchnl_vlan_supported_caps insertion_support; 668 u32 ethertype_init; 669 u8 ethertype_match; 670 u8 pad[3]; 671}; 672 673VIRTCHNL_CHECK_STRUCT_LEN(24, virtchnl_vlan_offload_caps); 674 675/* VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS 676 * VF sends this message to determine its VLAN capabilities. 677 * 678 * PF will mark which capabilities it supports based on hardware support and 679 * current configuration. For example, if a port VLAN is configured the PF will 680 * not allow outer VLAN filtering, stripping, or insertion to be configured so 681 * it will block these features from the VF. 682 * 683 * The VF will need to cross reference its capabilities with the PFs 684 * capabilities in the response message from the PF to determine the VLAN 685 * support. 686 */ 687struct virtchnl_vlan_caps { 688 struct virtchnl_vlan_filtering_caps filtering; 689 struct virtchnl_vlan_offload_caps offloads; 690}; 691 692VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_vlan_caps); 693 694struct virtchnl_vlan { 695 u16 tci; /* tci[15:13] = PCP and tci[11:0] = VID */ 696 u16 tci_mask; /* only valid if VIRTCHNL_VLAN_FILTER_MASK set in 697 * filtering caps 698 */ 699 u16 tpid; /* 0x8100, 0x88a8, etc. and only type(s) set in 700 * filtering caps. Note that tpid here does not refer to 701 * VIRTCHNL_VLAN_ETHERTYPE_*, but it refers to the 702 * actual 2-byte VLAN TPID 703 */ 704 u8 pad[2]; 705}; 706 707VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_vlan); 708 709struct virtchnl_vlan_filter { 710 struct virtchnl_vlan inner; 711 struct virtchnl_vlan outer; 712 u8 pad[16]; 713}; 714 715VIRTCHNL_CHECK_STRUCT_LEN(32, virtchnl_vlan_filter); 716 717/* VIRTCHNL_OP_ADD_VLAN_V2 718 * VIRTCHNL_OP_DEL_VLAN_V2 719 * 720 * VF sends these messages to add/del one or more VLAN tag filters for Rx 721 * traffic. 722 * 723 * The PF attempts to add the filters and returns status. 724 * 725 * The VF should only ever attempt to add/del virtchnl_vlan_filter(s) using the 726 * supported fields negotiated via VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS. 727 */ 728struct virtchnl_vlan_filter_list_v2 { 729 u16 vport_id; 730 u16 num_elements; 731 u8 pad[4]; 732 struct virtchnl_vlan_filter filters[]; 733}; 734 735VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_vlan_filter_list_v2); 736#define virtchnl_vlan_filter_list_v2_LEGACY_SIZEOF 40 737 738/* VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2 739 * VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2 740 * VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2 741 * VIRTCHNL_OP_DISABLE_VLAN_INSERTION_V2 742 * 743 * VF sends this message to enable or disable VLAN stripping or insertion. It 744 * also needs to specify an ethertype. The VF knows which VLAN ethertypes are 745 * allowed and whether or not it's allowed to enable/disable the specific 746 * offload via the VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS message. The VF needs to 747 * parse the virtchnl_vlan_caps.offloads fields to determine which offload 748 * messages are allowed. 749 * 750 * For example, if the PF populates the virtchnl_vlan_caps.offloads in the 751 * following manner the VF will be allowed to enable and/or disable 0x8100 inner 752 * VLAN insertion and/or stripping via the opcodes listed above. Inner in this 753 * case means the outer most or single VLAN from the VF's perspective. This is 754 * because no outer offloads are supported. See the comments above the 755 * virtchnl_vlan_supported_caps structure for more details. 756 * 757 * virtchnl_vlan_caps.offloads.stripping_support.inner = 758 * VIRTCHNL_VLAN_TOGGLE | 759 * VIRTCHNL_VLAN_ETHERTYPE_8100; 760 * 761 * virtchnl_vlan_caps.offloads.insertion_support.inner = 762 * VIRTCHNL_VLAN_TOGGLE | 763 * VIRTCHNL_VLAN_ETHERTYPE_8100; 764 * 765 * In order to enable inner (again note that in this case inner is the outer 766 * most or single VLAN from the VF's perspective) VLAN stripping for 0x8100 767 * VLANs, the VF would populate the virtchnl_vlan_setting structure in the 768 * following manner and send the VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2 message. 769 * 770 * virtchnl_vlan_setting.inner_ethertype_setting = 771 * VIRTCHNL_VLAN_ETHERTYPE_8100; 772 * 773 * virtchnl_vlan_setting.vport_id = vport_id or vsi_id assigned to the VF on 774 * initialization. 775 * 776 * The reason that VLAN TPID(s) are not being used for the 777 * outer_ethertype_setting and inner_ethertype_setting fields is because it's 778 * possible a device could support VLAN insertion and/or stripping offload on 779 * multiple ethertypes concurrently, so this method allows a VF to request 780 * multiple ethertypes in one message using the virtchnl_vlan_support 781 * enumeration. 782 * 783 * For example, if the PF populates the virtchnl_vlan_caps.offloads in the 784 * following manner the VF will be allowed to enable 0x8100 and 0x88a8 outer 785 * VLAN insertion and stripping simultaneously. The 786 * virtchnl_vlan_caps.offloads.ethertype_match field will also have to be 787 * populated based on what the PF can support. 788 * 789 * virtchnl_vlan_caps.offloads.stripping_support.outer = 790 * VIRTCHNL_VLAN_TOGGLE | 791 * VIRTCHNL_VLAN_ETHERTYPE_8100 | 792 * VIRTCHNL_VLAN_ETHERTYPE_88A8 | 793 * VIRTCHNL_VLAN_ETHERTYPE_AND; 794 * 795 * virtchnl_vlan_caps.offloads.insertion_support.outer = 796 * VIRTCHNL_VLAN_TOGGLE | 797 * VIRTCHNL_VLAN_ETHERTYPE_8100 | 798 * VIRTCHNL_VLAN_ETHERTYPE_88A8 | 799 * VIRTCHNL_VLAN_ETHERTYPE_AND; 800 * 801 * In order to enable outer VLAN stripping for 0x8100 and 0x88a8 VLANs, the VF 802 * would populate the virthcnl_vlan_offload_structure in the following manner 803 * and send the VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2 message. 804 * 805 * virtchnl_vlan_setting.outer_ethertype_setting = 806 * VIRTHCNL_VLAN_ETHERTYPE_8100 | 807 * VIRTHCNL_VLAN_ETHERTYPE_88A8; 808 * 809 * virtchnl_vlan_setting.vport_id = vport_id or vsi_id assigned to the VF on 810 * initialization. 811 * 812 * There is also the case where a PF and the underlying hardware can support 813 * VLAN offloads on multiple ethertypes, but not concurrently. For example, if 814 * the PF populates the virtchnl_vlan_caps.offloads in the following manner the 815 * VF will be allowed to enable and/or disable 0x8100 XOR 0x88a8 outer VLAN 816 * offloads. The ethertypes must match for stripping and insertion. 817 * 818 * virtchnl_vlan_caps.offloads.stripping_support.outer = 819 * VIRTCHNL_VLAN_TOGGLE | 820 * VIRTCHNL_VLAN_ETHERTYPE_8100 | 821 * VIRTCHNL_VLAN_ETHERTYPE_88A8 | 822 * VIRTCHNL_VLAN_ETHERTYPE_XOR; 823 * 824 * virtchnl_vlan_caps.offloads.insertion_support.outer = 825 * VIRTCHNL_VLAN_TOGGLE | 826 * VIRTCHNL_VLAN_ETHERTYPE_8100 | 827 * VIRTCHNL_VLAN_ETHERTYPE_88A8 | 828 * VIRTCHNL_VLAN_ETHERTYPE_XOR; 829 * 830 * virtchnl_vlan_caps.offloads.ethertype_match = 831 * VIRTCHNL_ETHERTYPE_STRIPPING_MATCHES_INSERTION; 832 * 833 * In order to enable outer VLAN stripping for 0x88a8 VLANs, the VF would 834 * populate the virtchnl_vlan_setting structure in the following manner and send 835 * the VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2. Also, this will change the 836 * ethertype for VLAN insertion if it's enabled. So, for completeness, a 837 * VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2 with the same ethertype should be sent. 838 * 839 * virtchnl_vlan_setting.outer_ethertype_setting = VIRTHCNL_VLAN_ETHERTYPE_88A8; 840 * 841 * virtchnl_vlan_setting.vport_id = vport_id or vsi_id assigned to the VF on 842 * initialization. 843 */ 844struct virtchnl_vlan_setting { 845 u32 outer_ethertype_setting; 846 u32 inner_ethertype_setting; 847 u16 vport_id; 848 u8 pad[6]; 849}; 850 851VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_vlan_setting); 852 853/* VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE 854 * VF sends VSI id and flags. 855 * PF returns status code in retval. 856 * Note: we assume that broadcast accept mode is always enabled. 857 */ 858struct virtchnl_promisc_info { 859 u16 vsi_id; 860 u16 flags; 861}; 862 863VIRTCHNL_CHECK_STRUCT_LEN(4, virtchnl_promisc_info); 864 865#define FLAG_VF_UNICAST_PROMISC 0x00000001 866#define FLAG_VF_MULTICAST_PROMISC 0x00000002 867 868/* VIRTCHNL_OP_GET_STATS 869 * VF sends this message to request stats for the selected VSI. VF uses 870 * the virtchnl_queue_select struct to specify the VSI. The queue_id 871 * field is ignored by the PF. 872 * 873 * PF replies with struct eth_stats in an external buffer. 874 */ 875 876/* VIRTCHNL_OP_CONFIG_RSS_KEY 877 * VIRTCHNL_OP_CONFIG_RSS_LUT 878 * VF sends these messages to configure RSS. Only supported if both PF 879 * and VF drivers set the VIRTCHNL_VF_OFFLOAD_RSS_PF bit during 880 * configuration negotiation. If this is the case, then the RSS fields in 881 * the VF resource struct are valid. 882 * Both the key and LUT are initialized to 0 by the PF, meaning that 883 * RSS is effectively disabled until set up by the VF. 884 */ 885struct virtchnl_rss_key { 886 u16 vsi_id; 887 u16 key_len; 888 u8 key[]; /* RSS hash key, packed bytes */ 889}; 890 891VIRTCHNL_CHECK_STRUCT_LEN(4, virtchnl_rss_key); 892#define virtchnl_rss_key_LEGACY_SIZEOF 6 893 894struct virtchnl_rss_lut { 895 u16 vsi_id; 896 u16 lut_entries; 897 u8 lut[]; /* RSS lookup table */ 898}; 899 900VIRTCHNL_CHECK_STRUCT_LEN(4, virtchnl_rss_lut); 901#define virtchnl_rss_lut_LEGACY_SIZEOF 6 902 903/* VIRTCHNL_OP_GET_RSS_HENA_CAPS 904 * VIRTCHNL_OP_SET_RSS_HENA 905 * VF sends these messages to get and set the hash filter enable bits for RSS. 906 * By default, the PF sets these to all possible traffic types that the 907 * hardware supports. The VF can query this value if it wants to change the 908 * traffic types that are hashed by the hardware. 909 */ 910struct virtchnl_rss_hena { 911 u64 hena; 912}; 913 914VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_rss_hena); 915 916/* Type of RSS algorithm */ 917enum virtchnl_rss_algorithm { 918 VIRTCHNL_RSS_ALG_TOEPLITZ_ASYMMETRIC = 0, 919 VIRTCHNL_RSS_ALG_R_ASYMMETRIC = 1, 920 VIRTCHNL_RSS_ALG_TOEPLITZ_SYMMETRIC = 2, 921 VIRTCHNL_RSS_ALG_XOR_SYMMETRIC = 3, 922}; 923 924/* VIRTCHNL_OP_CONFIG_RSS_HFUNC 925 * VF sends this message to configure the RSS hash function. Only supported 926 * if both PF and VF drivers set the VIRTCHNL_VF_OFFLOAD_RSS_PF bit during 927 * configuration negotiation. 928 * The hash function is initialized to VIRTCHNL_RSS_ALG_TOEPLITZ_ASYMMETRIC 929 * by the PF. 930 */ 931struct virtchnl_rss_hfunc { 932 u16 vsi_id; 933 u16 rss_algorithm; /* enum virtchnl_rss_algorithm */ 934 u32 reserved; 935}; 936 937VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_rss_hfunc); 938 939/* VIRTCHNL_OP_ENABLE_CHANNELS 940 * VIRTCHNL_OP_DISABLE_CHANNELS 941 * VF sends these messages to enable or disable channels based on 942 * the user specified queue count and queue offset for each traffic class. 943 * This struct encompasses all the information that the PF needs from 944 * VF to create a channel. 945 */ 946struct virtchnl_channel_info { 947 u16 count; /* number of queues in a channel */ 948 u16 offset; /* queues in a channel start from 'offset' */ 949 u32 pad; 950 u64 max_tx_rate; 951}; 952 953VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_channel_info); 954 955struct virtchnl_tc_info { 956 u32 num_tc; 957 u32 pad; 958 struct virtchnl_channel_info list[]; 959}; 960 961VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_tc_info); 962#define virtchnl_tc_info_LEGACY_SIZEOF 24 963 964/* VIRTCHNL_ADD_CLOUD_FILTER 965 * VIRTCHNL_DEL_CLOUD_FILTER 966 * VF sends these messages to add or delete a cloud filter based on the 967 * user specified match and action filters. These structures encompass 968 * all the information that the PF needs from the VF to add/delete a 969 * cloud filter. 970 */ 971 972struct virtchnl_l4_spec { 973 u8 src_mac[ETH_ALEN]; 974 u8 dst_mac[ETH_ALEN]; 975 __be16 vlan_id; 976 __be16 pad; /* reserved for future use */ 977 __be32 src_ip[4]; 978 __be32 dst_ip[4]; 979 __be16 src_port; 980 __be16 dst_port; 981}; 982 983VIRTCHNL_CHECK_STRUCT_LEN(52, virtchnl_l4_spec); 984 985union virtchnl_flow_spec { 986 struct virtchnl_l4_spec tcp_spec; 987 u8 buffer[128]; /* reserved for future use */ 988}; 989 990VIRTCHNL_CHECK_UNION_LEN(128, virtchnl_flow_spec); 991 992enum virtchnl_action { 993 /* action types */ 994 VIRTCHNL_ACTION_DROP = 0, 995 VIRTCHNL_ACTION_TC_REDIRECT, 996 VIRTCHNL_ACTION_PASSTHRU, 997 VIRTCHNL_ACTION_QUEUE, 998 VIRTCHNL_ACTION_Q_REGION, 999 VIRTCHNL_ACTION_MARK, 1000 VIRTCHNL_ACTION_COUNT, 1001}; 1002 1003enum virtchnl_flow_type { 1004 /* flow types */ 1005 VIRTCHNL_TCP_V4_FLOW = 0, 1006 VIRTCHNL_TCP_V6_FLOW, 1007}; 1008 1009struct virtchnl_filter { 1010 union virtchnl_flow_spec data; 1011 union virtchnl_flow_spec mask; 1012 1013 /* see enum virtchnl_flow_type */ 1014 s32 flow_type; 1015 1016 /* see enum virtchnl_action */ 1017 s32 action; 1018 u32 action_meta; 1019 u8 field_flags; 1020 u8 pad[3]; 1021}; 1022 1023VIRTCHNL_CHECK_STRUCT_LEN(272, virtchnl_filter); 1024 1025struct virtchnl_supported_rxdids { 1026 u64 supported_rxdids; 1027}; 1028 1029/* VIRTCHNL_OP_EVENT 1030 * PF sends this message to inform the VF driver of events that may affect it. 1031 * No direct response is expected from the VF, though it may generate other 1032 * messages in response to this one. 1033 */ 1034enum virtchnl_event_codes { 1035 VIRTCHNL_EVENT_UNKNOWN = 0, 1036 VIRTCHNL_EVENT_LINK_CHANGE, 1037 VIRTCHNL_EVENT_RESET_IMPENDING, 1038 VIRTCHNL_EVENT_PF_DRIVER_CLOSE, 1039}; 1040 1041#define PF_EVENT_SEVERITY_INFO 0 1042#define PF_EVENT_SEVERITY_CERTAIN_DOOM 255 1043 1044struct virtchnl_pf_event { 1045 /* see enum virtchnl_event_codes */ 1046 s32 event; 1047 union { 1048 /* If the PF driver does not support the new speed reporting 1049 * capabilities then use link_event else use link_event_adv to 1050 * get the speed and link information. The ability to understand 1051 * new speeds is indicated by setting the capability flag 1052 * VIRTCHNL_VF_CAP_ADV_LINK_SPEED in vf_cap_flags parameter 1053 * in virtchnl_vf_resource struct and can be used to determine 1054 * which link event struct to use below. 1055 */ 1056 struct { 1057 enum virtchnl_link_speed link_speed; 1058 bool link_status; 1059 u8 pad[3]; 1060 } link_event; 1061 struct { 1062 /* link_speed provided in Mbps */ 1063 u32 link_speed; 1064 u8 link_status; 1065 u8 pad[3]; 1066 } link_event_adv; 1067 } event_data; 1068 1069 s32 severity; 1070}; 1071 1072VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_pf_event); 1073 1074/* used to specify if a ceq_idx or aeq_idx is invalid */ 1075#define VIRTCHNL_RDMA_INVALID_QUEUE_IDX 0xFFFF 1076/* VIRTCHNL_OP_CONFIG_RDMA_IRQ_MAP 1077 * VF uses this message to request PF to map RDMA vectors to RDMA queues. 1078 * The request for this originates from the VF RDMA driver through 1079 * a client interface between VF LAN and VF RDMA driver. 1080 * A vector could have an AEQ and CEQ attached to it although 1081 * there is a single AEQ per VF RDMA instance in which case 1082 * most vectors will have an VIRTCHNL_RDMA_INVALID_QUEUE_IDX for aeq and valid 1083 * idx for ceqs There will never be a case where there will be multiple CEQs 1084 * attached to a single vector. 1085 * PF configures interrupt mapping and returns status. 1086 */ 1087 1088struct virtchnl_rdma_qv_info { 1089 u32 v_idx; /* msix_vector */ 1090 u16 ceq_idx; /* set to VIRTCHNL_RDMA_INVALID_QUEUE_IDX if invalid */ 1091 u16 aeq_idx; /* set to VIRTCHNL_RDMA_INVALID_QUEUE_IDX if invalid */ 1092 u8 itr_idx; 1093 u8 pad[3]; 1094}; 1095 1096VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_rdma_qv_info); 1097 1098struct virtchnl_rdma_qvlist_info { 1099 u32 num_vectors; 1100 struct virtchnl_rdma_qv_info qv_info[]; 1101}; 1102 1103VIRTCHNL_CHECK_STRUCT_LEN(4, virtchnl_rdma_qvlist_info); 1104#define virtchnl_rdma_qvlist_info_LEGACY_SIZEOF 16 1105 1106/* VF reset states - these are written into the RSTAT register: 1107 * VFGEN_RSTAT on the VF 1108 * When the PF initiates a reset, it writes 0 1109 * When the reset is complete, it writes 1 1110 * When the PF detects that the VF has recovered, it writes 2 1111 * VF checks this register periodically to determine if a reset has occurred, 1112 * then polls it to know when the reset is complete. 1113 * If either the PF or VF reads the register while the hardware 1114 * is in a reset state, it will return DEADBEEF, which, when masked 1115 * will result in 3. 1116 */ 1117enum virtchnl_vfr_states { 1118 VIRTCHNL_VFR_INPROGRESS = 0, 1119 VIRTCHNL_VFR_COMPLETED, 1120 VIRTCHNL_VFR_VFACTIVE, 1121}; 1122 1123#define VIRTCHNL_MAX_NUM_PROTO_HDRS 32 1124#define PROTO_HDR_SHIFT 5 1125#define PROTO_HDR_FIELD_START(proto_hdr_type) ((proto_hdr_type) << PROTO_HDR_SHIFT) 1126#define PROTO_HDR_FIELD_MASK ((1UL << PROTO_HDR_SHIFT) - 1) 1127 1128/* VF use these macros to configure each protocol header. 1129 * Specify which protocol headers and protocol header fields base on 1130 * virtchnl_proto_hdr_type and virtchnl_proto_hdr_field. 1131 * @param hdr: a struct of virtchnl_proto_hdr 1132 * @param hdr_type: ETH/IPV4/TCP, etc 1133 * @param field: SRC/DST/TEID/SPI, etc 1134 */ 1135#define VIRTCHNL_ADD_PROTO_HDR_FIELD(hdr, field) \ 1136 ((hdr)->field_selector |= BIT((field) & PROTO_HDR_FIELD_MASK)) 1137#define VIRTCHNL_DEL_PROTO_HDR_FIELD(hdr, field) \ 1138 ((hdr)->field_selector &= ~BIT((field) & PROTO_HDR_FIELD_MASK)) 1139#define VIRTCHNL_TEST_PROTO_HDR_FIELD(hdr, val) \ 1140 ((hdr)->field_selector & BIT((val) & PROTO_HDR_FIELD_MASK)) 1141#define VIRTCHNL_GET_PROTO_HDR_FIELD(hdr) ((hdr)->field_selector) 1142 1143#define VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, hdr_type, field) \ 1144 (VIRTCHNL_ADD_PROTO_HDR_FIELD(hdr, \ 1145 VIRTCHNL_PROTO_HDR_ ## hdr_type ## _ ## field)) 1146#define VIRTCHNL_DEL_PROTO_HDR_FIELD_BIT(hdr, hdr_type, field) \ 1147 (VIRTCHNL_DEL_PROTO_HDR_FIELD(hdr, \ 1148 VIRTCHNL_PROTO_HDR_ ## hdr_type ## _ ## field)) 1149 1150#define VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, hdr_type) \ 1151 ((hdr)->type = VIRTCHNL_PROTO_HDR_ ## hdr_type) 1152#define VIRTCHNL_GET_PROTO_HDR_TYPE(hdr) \ 1153 (((hdr)->type) >> PROTO_HDR_SHIFT) 1154#define VIRTCHNL_TEST_PROTO_HDR_TYPE(hdr, val) \ 1155 ((hdr)->type == ((s32)((val) >> PROTO_HDR_SHIFT))) 1156#define VIRTCHNL_TEST_PROTO_HDR(hdr, val) \ 1157 (VIRTCHNL_TEST_PROTO_HDR_TYPE((hdr), (val)) && \ 1158 VIRTCHNL_TEST_PROTO_HDR_FIELD((hdr), (val))) 1159 1160/* Protocol header type within a packet segment. A segment consists of one or 1161 * more protocol headers that make up a logical group of protocol headers. Each 1162 * logical group of protocol headers encapsulates or is encapsulated using/by 1163 * tunneling or encapsulation protocols for network virtualization. 1164 */ 1165enum virtchnl_proto_hdr_type { 1166 VIRTCHNL_PROTO_HDR_NONE, 1167 VIRTCHNL_PROTO_HDR_ETH, 1168 VIRTCHNL_PROTO_HDR_S_VLAN, 1169 VIRTCHNL_PROTO_HDR_C_VLAN, 1170 VIRTCHNL_PROTO_HDR_IPV4, 1171 VIRTCHNL_PROTO_HDR_IPV6, 1172 VIRTCHNL_PROTO_HDR_TCP, 1173 VIRTCHNL_PROTO_HDR_UDP, 1174 VIRTCHNL_PROTO_HDR_SCTP, 1175 VIRTCHNL_PROTO_HDR_GTPU_IP, 1176 VIRTCHNL_PROTO_HDR_GTPU_EH, 1177 VIRTCHNL_PROTO_HDR_GTPU_EH_PDU_DWN, 1178 VIRTCHNL_PROTO_HDR_GTPU_EH_PDU_UP, 1179 VIRTCHNL_PROTO_HDR_PPPOE, 1180 VIRTCHNL_PROTO_HDR_L2TPV3, 1181 VIRTCHNL_PROTO_HDR_ESP, 1182 VIRTCHNL_PROTO_HDR_AH, 1183 VIRTCHNL_PROTO_HDR_PFCP, 1184}; 1185 1186/* Protocol header field within a protocol header. */ 1187enum virtchnl_proto_hdr_field { 1188 /* ETHER */ 1189 VIRTCHNL_PROTO_HDR_ETH_SRC = 1190 PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_ETH), 1191 VIRTCHNL_PROTO_HDR_ETH_DST, 1192 VIRTCHNL_PROTO_HDR_ETH_ETHERTYPE, 1193 /* S-VLAN */ 1194 VIRTCHNL_PROTO_HDR_S_VLAN_ID = 1195 PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_S_VLAN), 1196 /* C-VLAN */ 1197 VIRTCHNL_PROTO_HDR_C_VLAN_ID = 1198 PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_C_VLAN), 1199 /* IPV4 */ 1200 VIRTCHNL_PROTO_HDR_IPV4_SRC = 1201 PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_IPV4), 1202 VIRTCHNL_PROTO_HDR_IPV4_DST, 1203 VIRTCHNL_PROTO_HDR_IPV4_DSCP, 1204 VIRTCHNL_PROTO_HDR_IPV4_TTL, 1205 VIRTCHNL_PROTO_HDR_IPV4_PROT, 1206 /* IPV6 */ 1207 VIRTCHNL_PROTO_HDR_IPV6_SRC = 1208 PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_IPV6), 1209 VIRTCHNL_PROTO_HDR_IPV6_DST, 1210 VIRTCHNL_PROTO_HDR_IPV6_TC, 1211 VIRTCHNL_PROTO_HDR_IPV6_HOP_LIMIT, 1212 VIRTCHNL_PROTO_HDR_IPV6_PROT, 1213 /* TCP */ 1214 VIRTCHNL_PROTO_HDR_TCP_SRC_PORT = 1215 PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_TCP), 1216 VIRTCHNL_PROTO_HDR_TCP_DST_PORT, 1217 /* UDP */ 1218 VIRTCHNL_PROTO_HDR_UDP_SRC_PORT = 1219 PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_UDP), 1220 VIRTCHNL_PROTO_HDR_UDP_DST_PORT, 1221 /* SCTP */ 1222 VIRTCHNL_PROTO_HDR_SCTP_SRC_PORT = 1223 PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_SCTP), 1224 VIRTCHNL_PROTO_HDR_SCTP_DST_PORT, 1225 /* GTPU_IP */ 1226 VIRTCHNL_PROTO_HDR_GTPU_IP_TEID = 1227 PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_GTPU_IP), 1228 /* GTPU_EH */ 1229 VIRTCHNL_PROTO_HDR_GTPU_EH_PDU = 1230 PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_GTPU_EH), 1231 VIRTCHNL_PROTO_HDR_GTPU_EH_QFI, 1232 /* PPPOE */ 1233 VIRTCHNL_PROTO_HDR_PPPOE_SESS_ID = 1234 PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_PPPOE), 1235 /* L2TPV3 */ 1236 VIRTCHNL_PROTO_HDR_L2TPV3_SESS_ID = 1237 PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_L2TPV3), 1238 /* ESP */ 1239 VIRTCHNL_PROTO_HDR_ESP_SPI = 1240 PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_ESP), 1241 /* AH */ 1242 VIRTCHNL_PROTO_HDR_AH_SPI = 1243 PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_AH), 1244 /* PFCP */ 1245 VIRTCHNL_PROTO_HDR_PFCP_S_FIELD = 1246 PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_PFCP), 1247 VIRTCHNL_PROTO_HDR_PFCP_SEID, 1248}; 1249 1250struct virtchnl_proto_hdr { 1251 /* see enum virtchnl_proto_hdr_type */ 1252 s32 type; 1253 u32 field_selector; /* a bit mask to select field for header type */ 1254 u8 buffer[64]; 1255 /** 1256 * binary buffer in network order for specific header type. 1257 * For example, if type = VIRTCHNL_PROTO_HDR_IPV4, a IPv4 1258 * header is expected to be copied into the buffer. 1259 */ 1260}; 1261 1262VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_proto_hdr); 1263 1264struct virtchnl_proto_hdrs { 1265 u8 tunnel_level; 1266 u8 pad[3]; 1267 /** 1268 * specify where protocol header start from. 1269 * 0 - from the outer layer 1270 * 1 - from the first inner layer 1271 * 2 - from the second inner layer 1272 * .... 1273 **/ 1274 int count; /* the proto layers must < VIRTCHNL_MAX_NUM_PROTO_HDRS */ 1275 struct virtchnl_proto_hdr proto_hdr[VIRTCHNL_MAX_NUM_PROTO_HDRS]; 1276}; 1277 1278VIRTCHNL_CHECK_STRUCT_LEN(2312, virtchnl_proto_hdrs); 1279 1280struct virtchnl_rss_cfg { 1281 struct virtchnl_proto_hdrs proto_hdrs; /* protocol headers */ 1282 1283 /* see enum virtchnl_rss_algorithm; rss algorithm type */ 1284 s32 rss_algorithm; 1285 u8 reserved[128]; /* reserve for future */ 1286}; 1287 1288VIRTCHNL_CHECK_STRUCT_LEN(2444, virtchnl_rss_cfg); 1289 1290/* action configuration for FDIR */ 1291struct virtchnl_filter_action { 1292 /* see enum virtchnl_action type */ 1293 s32 type; 1294 union { 1295 /* used for queue and qgroup action */ 1296 struct { 1297 u16 index; 1298 u8 region; 1299 } queue; 1300 /* used for count action */ 1301 struct { 1302 /* share counter ID with other flow rules */ 1303 u8 shared; 1304 u32 id; /* counter ID */ 1305 } count; 1306 /* used for mark action */ 1307 u32 mark_id; 1308 u8 reserve[32]; 1309 } act_conf; 1310}; 1311 1312VIRTCHNL_CHECK_STRUCT_LEN(36, virtchnl_filter_action); 1313 1314#define VIRTCHNL_MAX_NUM_ACTIONS 8 1315 1316struct virtchnl_filter_action_set { 1317 /* action number must be less then VIRTCHNL_MAX_NUM_ACTIONS */ 1318 int count; 1319 struct virtchnl_filter_action actions[VIRTCHNL_MAX_NUM_ACTIONS]; 1320}; 1321 1322VIRTCHNL_CHECK_STRUCT_LEN(292, virtchnl_filter_action_set); 1323 1324/* pattern and action for FDIR rule */ 1325struct virtchnl_fdir_rule { 1326 struct virtchnl_proto_hdrs proto_hdrs; 1327 struct virtchnl_filter_action_set action_set; 1328}; 1329 1330VIRTCHNL_CHECK_STRUCT_LEN(2604, virtchnl_fdir_rule); 1331 1332/* Status returned to VF after VF requests FDIR commands 1333 * VIRTCHNL_FDIR_SUCCESS 1334 * VF FDIR related request is successfully done by PF 1335 * The request can be OP_ADD/DEL/QUERY_FDIR_FILTER. 1336 * 1337 * VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE 1338 * OP_ADD_FDIR_FILTER request is failed due to no Hardware resource. 1339 * 1340 * VIRTCHNL_FDIR_FAILURE_RULE_EXIST 1341 * OP_ADD_FDIR_FILTER request is failed due to the rule is already existed. 1342 * 1343 * VIRTCHNL_FDIR_FAILURE_RULE_CONFLICT 1344 * OP_ADD_FDIR_FILTER request is failed due to conflict with existing rule. 1345 * 1346 * VIRTCHNL_FDIR_FAILURE_RULE_NONEXIST 1347 * OP_DEL_FDIR_FILTER request is failed due to this rule doesn't exist. 1348 * 1349 * VIRTCHNL_FDIR_FAILURE_RULE_INVALID 1350 * OP_ADD_FDIR_FILTER request is failed due to parameters validation 1351 * or HW doesn't support. 1352 * 1353 * VIRTCHNL_FDIR_FAILURE_RULE_TIMEOUT 1354 * OP_ADD/DEL_FDIR_FILTER request is failed due to timing out 1355 * for programming. 1356 * 1357 * VIRTCHNL_FDIR_FAILURE_QUERY_INVALID 1358 * OP_QUERY_FDIR_FILTER request is failed due to parameters validation, 1359 * for example, VF query counter of a rule who has no counter action. 1360 */ 1361enum virtchnl_fdir_prgm_status { 1362 VIRTCHNL_FDIR_SUCCESS = 0, 1363 VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE, 1364 VIRTCHNL_FDIR_FAILURE_RULE_EXIST, 1365 VIRTCHNL_FDIR_FAILURE_RULE_CONFLICT, 1366 VIRTCHNL_FDIR_FAILURE_RULE_NONEXIST, 1367 VIRTCHNL_FDIR_FAILURE_RULE_INVALID, 1368 VIRTCHNL_FDIR_FAILURE_RULE_TIMEOUT, 1369 VIRTCHNL_FDIR_FAILURE_QUERY_INVALID, 1370}; 1371 1372/* VIRTCHNL_OP_ADD_FDIR_FILTER 1373 * VF sends this request to PF by filling out vsi_id, 1374 * validate_only and rule_cfg. PF will return flow_id 1375 * if the request is successfully done and return add_status to VF. 1376 */ 1377struct virtchnl_fdir_add { 1378 u16 vsi_id; /* INPUT */ 1379 /* 1380 * 1 for validating a fdir rule, 0 for creating a fdir rule. 1381 * Validate and create share one ops: VIRTCHNL_OP_ADD_FDIR_FILTER. 1382 */ 1383 u16 validate_only; /* INPUT */ 1384 u32 flow_id; /* OUTPUT */ 1385 struct virtchnl_fdir_rule rule_cfg; /* INPUT */ 1386 1387 /* see enum virtchnl_fdir_prgm_status; OUTPUT */ 1388 s32 status; 1389}; 1390 1391VIRTCHNL_CHECK_STRUCT_LEN(2616, virtchnl_fdir_add); 1392 1393/* VIRTCHNL_OP_DEL_FDIR_FILTER 1394 * VF sends this request to PF by filling out vsi_id 1395 * and flow_id. PF will return del_status to VF. 1396 */ 1397struct virtchnl_fdir_del { 1398 u16 vsi_id; /* INPUT */ 1399 u16 pad; 1400 u32 flow_id; /* INPUT */ 1401 1402 /* see enum virtchnl_fdir_prgm_status; OUTPUT */ 1403 s32 status; 1404}; 1405 1406VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_fdir_del); 1407 1408#define __vss_byone(p, member, count, old) \ 1409 (struct_size(p, member, count) + (old - 1 - struct_size(p, member, 0))) 1410 1411#define __vss_byelem(p, member, count, old) \ 1412 (struct_size(p, member, count - 1) + (old - struct_size(p, member, 0))) 1413 1414#define __vss_full(p, member, count, old) \ 1415 (struct_size(p, member, count) + (old - struct_size(p, member, 0))) 1416 1417#define __vss(type, func, p, member, count) \ 1418 struct type: func(p, member, count, type##_LEGACY_SIZEOF) 1419 1420#define virtchnl_struct_size(p, m, c) \ 1421 _Generic(*p, \ 1422 __vss(virtchnl_vf_resource, __vss_full, p, m, c), \ 1423 __vss(virtchnl_vsi_queue_config_info, __vss_full, p, m, c), \ 1424 __vss(virtchnl_irq_map_info, __vss_full, p, m, c), \ 1425 __vss(virtchnl_ether_addr_list, __vss_full, p, m, c), \ 1426 __vss(virtchnl_vlan_filter_list, __vss_full, p, m, c), \ 1427 __vss(virtchnl_vlan_filter_list_v2, __vss_byelem, p, m, c), \ 1428 __vss(virtchnl_tc_info, __vss_byelem, p, m, c), \ 1429 __vss(virtchnl_rdma_qvlist_info, __vss_byelem, p, m, c), \ 1430 __vss(virtchnl_rss_key, __vss_byone, p, m, c), \ 1431 __vss(virtchnl_rss_lut, __vss_byone, p, m, c)) 1432 1433/** 1434 * virtchnl_vc_validate_vf_msg 1435 * @ver: Virtchnl version info 1436 * @v_opcode: Opcode for the message 1437 * @msg: pointer to the msg buffer 1438 * @msglen: msg length 1439 * 1440 * validate msg format against struct for each opcode 1441 */ 1442static inline int 1443virtchnl_vc_validate_vf_msg(struct virtchnl_version_info *ver, u32 v_opcode, 1444 u8 *msg, u16 msglen) 1445{ 1446 bool err_msg_format = false; 1447 u32 valid_len = 0; 1448 1449 /* Validate message length. */ 1450 switch (v_opcode) { 1451 case VIRTCHNL_OP_VERSION: 1452 valid_len = sizeof(struct virtchnl_version_info); 1453 break; 1454 case VIRTCHNL_OP_RESET_VF: 1455 break; 1456 case VIRTCHNL_OP_GET_VF_RESOURCES: 1457 if (VF_IS_V11(ver)) 1458 valid_len = sizeof(u32); 1459 break; 1460 case VIRTCHNL_OP_CONFIG_TX_QUEUE: 1461 valid_len = sizeof(struct virtchnl_txq_info); 1462 break; 1463 case VIRTCHNL_OP_CONFIG_RX_QUEUE: 1464 valid_len = sizeof(struct virtchnl_rxq_info); 1465 break; 1466 case VIRTCHNL_OP_CONFIG_VSI_QUEUES: 1467 valid_len = virtchnl_vsi_queue_config_info_LEGACY_SIZEOF; 1468 if (msglen >= valid_len) { 1469 struct virtchnl_vsi_queue_config_info *vqc = 1470 (struct virtchnl_vsi_queue_config_info *)msg; 1471 valid_len = virtchnl_struct_size(vqc, qpair, 1472 vqc->num_queue_pairs); 1473 if (vqc->num_queue_pairs == 0) 1474 err_msg_format = true; 1475 } 1476 break; 1477 case VIRTCHNL_OP_CONFIG_IRQ_MAP: 1478 valid_len = virtchnl_irq_map_info_LEGACY_SIZEOF; 1479 if (msglen >= valid_len) { 1480 struct virtchnl_irq_map_info *vimi = 1481 (struct virtchnl_irq_map_info *)msg; 1482 valid_len = virtchnl_struct_size(vimi, vecmap, 1483 vimi->num_vectors); 1484 if (vimi->num_vectors == 0) 1485 err_msg_format = true; 1486 } 1487 break; 1488 case VIRTCHNL_OP_ENABLE_QUEUES: 1489 case VIRTCHNL_OP_DISABLE_QUEUES: 1490 valid_len = sizeof(struct virtchnl_queue_select); 1491 break; 1492 case VIRTCHNL_OP_ADD_ETH_ADDR: 1493 case VIRTCHNL_OP_DEL_ETH_ADDR: 1494 valid_len = virtchnl_ether_addr_list_LEGACY_SIZEOF; 1495 if (msglen >= valid_len) { 1496 struct virtchnl_ether_addr_list *veal = 1497 (struct virtchnl_ether_addr_list *)msg; 1498 valid_len = virtchnl_struct_size(veal, list, 1499 veal->num_elements); 1500 if (veal->num_elements == 0) 1501 err_msg_format = true; 1502 } 1503 break; 1504 case VIRTCHNL_OP_ADD_VLAN: 1505 case VIRTCHNL_OP_DEL_VLAN: 1506 valid_len = virtchnl_vlan_filter_list_LEGACY_SIZEOF; 1507 if (msglen >= valid_len) { 1508 struct virtchnl_vlan_filter_list *vfl = 1509 (struct virtchnl_vlan_filter_list *)msg; 1510 valid_len = virtchnl_struct_size(vfl, vlan_id, 1511 vfl->num_elements); 1512 if (vfl->num_elements == 0) 1513 err_msg_format = true; 1514 } 1515 break; 1516 case VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE: 1517 valid_len = sizeof(struct virtchnl_promisc_info); 1518 break; 1519 case VIRTCHNL_OP_GET_STATS: 1520 valid_len = sizeof(struct virtchnl_queue_select); 1521 break; 1522 case VIRTCHNL_OP_RDMA: 1523 /* These messages are opaque to us and will be validated in 1524 * the RDMA client code. We just need to check for nonzero 1525 * length. The firmware will enforce max length restrictions. 1526 */ 1527 if (msglen) 1528 valid_len = msglen; 1529 else 1530 err_msg_format = true; 1531 break; 1532 case VIRTCHNL_OP_RELEASE_RDMA_IRQ_MAP: 1533 break; 1534 case VIRTCHNL_OP_CONFIG_RDMA_IRQ_MAP: 1535 valid_len = virtchnl_rdma_qvlist_info_LEGACY_SIZEOF; 1536 if (msglen >= valid_len) { 1537 struct virtchnl_rdma_qvlist_info *qv = 1538 (struct virtchnl_rdma_qvlist_info *)msg; 1539 1540 valid_len = virtchnl_struct_size(qv, qv_info, 1541 qv->num_vectors); 1542 } 1543 break; 1544 case VIRTCHNL_OP_CONFIG_RSS_KEY: 1545 valid_len = virtchnl_rss_key_LEGACY_SIZEOF; 1546 if (msglen >= valid_len) { 1547 struct virtchnl_rss_key *vrk = 1548 (struct virtchnl_rss_key *)msg; 1549 valid_len = virtchnl_struct_size(vrk, key, 1550 vrk->key_len); 1551 } 1552 break; 1553 case VIRTCHNL_OP_CONFIG_RSS_LUT: 1554 valid_len = virtchnl_rss_lut_LEGACY_SIZEOF; 1555 if (msglen >= valid_len) { 1556 struct virtchnl_rss_lut *vrl = 1557 (struct virtchnl_rss_lut *)msg; 1558 valid_len = virtchnl_struct_size(vrl, lut, 1559 vrl->lut_entries); 1560 } 1561 break; 1562 case VIRTCHNL_OP_CONFIG_RSS_HFUNC: 1563 valid_len = sizeof(struct virtchnl_rss_hfunc); 1564 break; 1565 case VIRTCHNL_OP_GET_RSS_HENA_CAPS: 1566 break; 1567 case VIRTCHNL_OP_SET_RSS_HENA: 1568 valid_len = sizeof(struct virtchnl_rss_hena); 1569 break; 1570 case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING: 1571 case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING: 1572 break; 1573 case VIRTCHNL_OP_REQUEST_QUEUES: 1574 valid_len = sizeof(struct virtchnl_vf_res_request); 1575 break; 1576 case VIRTCHNL_OP_ENABLE_CHANNELS: 1577 valid_len = virtchnl_tc_info_LEGACY_SIZEOF; 1578 if (msglen >= valid_len) { 1579 struct virtchnl_tc_info *vti = 1580 (struct virtchnl_tc_info *)msg; 1581 valid_len = virtchnl_struct_size(vti, list, 1582 vti->num_tc); 1583 if (vti->num_tc == 0) 1584 err_msg_format = true; 1585 } 1586 break; 1587 case VIRTCHNL_OP_DISABLE_CHANNELS: 1588 break; 1589 case VIRTCHNL_OP_ADD_CLOUD_FILTER: 1590 case VIRTCHNL_OP_DEL_CLOUD_FILTER: 1591 valid_len = sizeof(struct virtchnl_filter); 1592 break; 1593 case VIRTCHNL_OP_GET_SUPPORTED_RXDIDS: 1594 break; 1595 case VIRTCHNL_OP_ADD_RSS_CFG: 1596 case VIRTCHNL_OP_DEL_RSS_CFG: 1597 valid_len = sizeof(struct virtchnl_rss_cfg); 1598 break; 1599 case VIRTCHNL_OP_ADD_FDIR_FILTER: 1600 valid_len = sizeof(struct virtchnl_fdir_add); 1601 break; 1602 case VIRTCHNL_OP_DEL_FDIR_FILTER: 1603 valid_len = sizeof(struct virtchnl_fdir_del); 1604 break; 1605 case VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS: 1606 break; 1607 case VIRTCHNL_OP_ADD_VLAN_V2: 1608 case VIRTCHNL_OP_DEL_VLAN_V2: 1609 valid_len = virtchnl_vlan_filter_list_v2_LEGACY_SIZEOF; 1610 if (msglen >= valid_len) { 1611 struct virtchnl_vlan_filter_list_v2 *vfl = 1612 (struct virtchnl_vlan_filter_list_v2 *)msg; 1613 1614 valid_len = virtchnl_struct_size(vfl, filters, 1615 vfl->num_elements); 1616 1617 if (vfl->num_elements == 0) { 1618 err_msg_format = true; 1619 break; 1620 } 1621 } 1622 break; 1623 case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2: 1624 case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2: 1625 case VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2: 1626 case VIRTCHNL_OP_DISABLE_VLAN_INSERTION_V2: 1627 valid_len = sizeof(struct virtchnl_vlan_setting); 1628 break; 1629 /* These are always errors coming from the VF. */ 1630 case VIRTCHNL_OP_EVENT: 1631 case VIRTCHNL_OP_UNKNOWN: 1632 default: 1633 return VIRTCHNL_STATUS_ERR_PARAM; 1634 } 1635 /* few more checks */ 1636 if (err_msg_format || valid_len != msglen) 1637 return VIRTCHNL_STATUS_ERR_OPCODE_MISMATCH; 1638 1639 return 0; 1640} 1641#endif /* _VIRTCHNL_H_ */ 1642