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 */ |
46 | enum 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 | |
70 | enum 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 */ |
84 | enum 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 | */ |
97 | enum 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 | = 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 | = 23, |
131 | = 24, |
132 | = 25, |
133 | = 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 | = 45, |
144 | = 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 | |
185 | struct virtchnl_version_info { |
186 | u32 major; |
187 | u32 minor; |
188 | }; |
189 | |
190 | VIRTCHNL_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 | */ |
211 | enum 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 | |
224 | struct 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 | |
234 | VIRTCHNL_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 BIT(3) |
244 | #define 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 BIT(18) |
254 | #define 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 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 | |
268 | struct 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 ; |
276 | u32 ; |
277 | |
278 | struct virtchnl_vsi_resource vsi_res[]; |
279 | }; |
280 | |
281 | VIRTCHNL_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 */ |
291 | struct 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 | |
300 | VIRTCHNL_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 */ |
315 | struct 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 | |
333 | VIRTCHNL_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 | */ |
345 | struct 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 | |
351 | VIRTCHNL_CHECK_STRUCT_LEN(64, virtchnl_queue_pair_info); |
352 | |
353 | struct 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 | |
360 | VIRTCHNL_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 */ |
374 | struct 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 | */ |
390 | struct 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 | |
399 | VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_vector_map); |
400 | |
401 | struct virtchnl_irq_map_info { |
402 | u16 num_vectors; |
403 | struct virtchnl_vector_map vecmap[]; |
404 | }; |
405 | |
406 | VIRTCHNL_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 | */ |
420 | struct virtchnl_queue_select { |
421 | u16 vsi_id; |
422 | u16 pad; |
423 | u32 rx_queues; |
424 | u32 tx_queues; |
425 | }; |
426 | |
427 | VIRTCHNL_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 | */ |
463 | struct 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 2 |
469 | #define VIRTCHNL_ETHER_ADDR_TYPE_MASK 3 /* first two bits of type are valid */ |
470 | u8 pad; |
471 | }; |
472 | |
473 | VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_ether_addr); |
474 | |
475 | struct virtchnl_ether_addr_list { |
476 | u16 vsi_id; |
477 | u16 num_elements; |
478 | struct virtchnl_ether_addr list[]; |
479 | }; |
480 | |
481 | VIRTCHNL_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 | |
498 | struct virtchnl_vlan_filter_list { |
499 | u16 vsi_id; |
500 | u16 num_elements; |
501 | u16 vlan_id[]; |
502 | }; |
503 | |
504 | VIRTCHNL_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 | */ |
560 | enum 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 | */ |
595 | struct 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 | */ |
622 | struct 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 | |
629 | VIRTCHNL_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 | */ |
644 | enum 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 | */ |
665 | struct 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 | |
673 | VIRTCHNL_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 | */ |
687 | struct virtchnl_vlan_caps { |
688 | struct virtchnl_vlan_filtering_caps filtering; |
689 | struct virtchnl_vlan_offload_caps offloads; |
690 | }; |
691 | |
692 | VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_vlan_caps); |
693 | |
694 | struct 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 | |
707 | VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_vlan); |
708 | |
709 | struct virtchnl_vlan_filter { |
710 | struct virtchnl_vlan inner; |
711 | struct virtchnl_vlan outer; |
712 | u8 pad[16]; |
713 | }; |
714 | |
715 | VIRTCHNL_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 | */ |
728 | struct 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 | |
735 | VIRTCHNL_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 | */ |
844 | struct virtchnl_vlan_setting { |
845 | u32 outer_ethertype_setting; |
846 | u32 inner_ethertype_setting; |
847 | u16 vport_id; |
848 | u8 pad[6]; |
849 | }; |
850 | |
851 | VIRTCHNL_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 | */ |
858 | struct virtchnl_promisc_info { |
859 | u16 vsi_id; |
860 | u16 flags; |
861 | }; |
862 | |
863 | VIRTCHNL_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 | */ |
885 | struct { |
886 | u16 ; |
887 | u16 ; |
888 | u8 []; /* RSS hash key, packed bytes */ |
889 | }; |
890 | |
891 | VIRTCHNL_CHECK_STRUCT_LEN(4, virtchnl_rss_key); |
892 | #define 6 |
893 | |
894 | struct { |
895 | u16 ; |
896 | u16 ; |
897 | u8 []; /* RSS lookup table */ |
898 | }; |
899 | |
900 | VIRTCHNL_CHECK_STRUCT_LEN(4, virtchnl_rss_lut); |
901 | #define 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 | */ |
910 | struct { |
911 | u64 ; |
912 | }; |
913 | |
914 | VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_rss_hena); |
915 | |
916 | /* Type of RSS algorithm */ |
917 | enum { |
918 | = 0, |
919 | = 1, |
920 | = 2, |
921 | = 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 | */ |
931 | struct { |
932 | u16 ; |
933 | u16 ; /* enum virtchnl_rss_algorithm */ |
934 | u32 ; |
935 | }; |
936 | |
937 | VIRTCHNL_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 | */ |
946 | struct 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 | |
953 | VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_channel_info); |
954 | |
955 | struct virtchnl_tc_info { |
956 | u32 num_tc; |
957 | u32 pad; |
958 | struct virtchnl_channel_info list[]; |
959 | }; |
960 | |
961 | VIRTCHNL_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 | |
972 | struct 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 | |
983 | VIRTCHNL_CHECK_STRUCT_LEN(52, virtchnl_l4_spec); |
984 | |
985 | union virtchnl_flow_spec { |
986 | struct virtchnl_l4_spec tcp_spec; |
987 | u8 buffer[128]; /* reserved for future use */ |
988 | }; |
989 | |
990 | VIRTCHNL_CHECK_UNION_LEN(128, virtchnl_flow_spec); |
991 | |
992 | enum 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 | |
1003 | enum virtchnl_flow_type { |
1004 | /* flow types */ |
1005 | VIRTCHNL_TCP_V4_FLOW = 0, |
1006 | VIRTCHNL_TCP_V6_FLOW, |
1007 | }; |
1008 | |
1009 | struct 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 | |
1023 | VIRTCHNL_CHECK_STRUCT_LEN(272, virtchnl_filter); |
1024 | |
1025 | struct 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 | */ |
1034 | enum 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 | |
1044 | struct 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 | |
1072 | VIRTCHNL_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 | |
1088 | struct 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 | |
1096 | VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_rdma_qv_info); |
1097 | |
1098 | struct virtchnl_rdma_qvlist_info { |
1099 | u32 num_vectors; |
1100 | struct virtchnl_rdma_qv_info qv_info[]; |
1101 | }; |
1102 | |
1103 | VIRTCHNL_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 | */ |
1117 | enum 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 | */ |
1165 | enum 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. */ |
1187 | enum 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 | |
1250 | struct 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 | |
1262 | VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_proto_hdr); |
1263 | |
1264 | struct 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 | |
1278 | VIRTCHNL_CHECK_STRUCT_LEN(2312, virtchnl_proto_hdrs); |
1279 | |
1280 | struct { |
1281 | struct virtchnl_proto_hdrs ; /* protocol headers */ |
1282 | |
1283 | /* see enum virtchnl_rss_algorithm; rss algorithm type */ |
1284 | s32 ; |
1285 | u8 [128]; /* reserve for future */ |
1286 | }; |
1287 | |
1288 | VIRTCHNL_CHECK_STRUCT_LEN(2444, virtchnl_rss_cfg); |
1289 | |
1290 | /* action configuration for FDIR */ |
1291 | struct 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 | |
1312 | VIRTCHNL_CHECK_STRUCT_LEN(36, virtchnl_filter_action); |
1313 | |
1314 | #define VIRTCHNL_MAX_NUM_ACTIONS 8 |
1315 | |
1316 | struct 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 | |
1322 | VIRTCHNL_CHECK_STRUCT_LEN(292, virtchnl_filter_action_set); |
1323 | |
1324 | /* pattern and action for FDIR rule */ |
1325 | struct virtchnl_fdir_rule { |
1326 | struct virtchnl_proto_hdrs proto_hdrs; |
1327 | struct virtchnl_filter_action_set action_set; |
1328 | }; |
1329 | |
1330 | VIRTCHNL_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 | */ |
1361 | enum 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 | */ |
1377 | struct 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 | |
1391 | VIRTCHNL_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 | */ |
1397 | struct 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 | |
1406 | VIRTCHNL_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 | */ |
1442 | static inline int |
1443 | virtchnl_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 | |