1 /******************************************************************************
2
3 Copyright (c) 2013-2018, Intel Corporation
4 All rights reserved.
5
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
8
9 1. Redistributions of source code must retain the above copyright notice,
10 this list of conditions and the following disclaimer.
11
12 2. Redistributions in binary form must reproduce the above copyright
13 notice, this list of conditions and the following disclaimer in the
14 documentation and/or other materials provided with the distribution.
15
16 3. Neither the name of the Intel Corporation nor the names of its
17 contributors may be used to endorse or promote products derived from
18 this software without specific prior written permission.
19
20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 POSSIBILITY OF SUCH DAMAGE.
31
32 ******************************************************************************/
33
34 #ifndef _VIRTCHNL_H_
35 #define _VIRTCHNL_H_
36
37 /* Description:
38 * This header file describes the VF-PF communication protocol used
39 * by the drivers for all devices starting from our 40G product line
40 *
41 * Admin queue buffer usage:
42 * desc->opcode is always aqc_opc_send_msg_to_pf
43 * flags, retval, datalen, and data addr are all used normally.
44 * The Firmware copies the cookie fields when sending messages between the
45 * PF and VF, but uses all other fields internally. Due to this limitation,
46 * we must send all messages as "indirect", i.e. using an external buffer.
47 *
48 * All the VSI indexes are relative to the VF. Each VF can have maximum of
49 * three VSIs. All the queue indexes are relative to the VSI. Each VF can
50 * have a maximum of sixteen queues for all of its VSIs.
51 *
52 * The PF is required to return a status code in v_retval for all messages
53 * except RESET_VF, which does not require any response. The return value
54 * is of status_code type, defined in the shared type.h.
55 *
56 * In general, VF driver initialization should roughly follow the order of
57 * these opcodes. The VF driver must first validate the API version of the
58 * PF driver, then request a reset, then get resources, then configure
59 * queues and interrupts. After these operations are complete, the VF
60 * driver may start its queues, optionally add MAC and VLAN filters, and
61 * process traffic.
62 */
63
64 /* START GENERIC DEFINES
65 * Need to ensure the following enums and defines hold the same meaning and
66 * value in current and future projects
67 */
68
69 /* Error Codes */
70 enum virtchnl_status_code {
71 VIRTCHNL_STATUS_SUCCESS = 0,
72 VIRTCHNL_ERR_PARAM = -5,
73 VIRTCHNL_STATUS_ERR_OPCODE_MISMATCH = -38,
74 VIRTCHNL_STATUS_ERR_CQP_COMPL_ERROR = -39,
75 VIRTCHNL_STATUS_ERR_INVALID_VF_ID = -40,
76 VIRTCHNL_STATUS_NOT_SUPPORTED = -64,
77 };
78
79 #define VIRTCHNL_LINK_SPEED_2_5GB_SHIFT 0x0
80 #define VIRTCHNL_LINK_SPEED_100MB_SHIFT 0x1
81 #define VIRTCHNL_LINK_SPEED_1000MB_SHIFT 0x2
82 #define VIRTCHNL_LINK_SPEED_10GB_SHIFT 0x3
83 #define VIRTCHNL_LINK_SPEED_40GB_SHIFT 0x4
84 #define VIRTCHNL_LINK_SPEED_20GB_SHIFT 0x5
85 #define VIRTCHNL_LINK_SPEED_25GB_SHIFT 0x6
86 #define VIRTCHNL_LINK_SPEED_5GB_SHIFT 0x7
87
88 enum virtchnl_link_speed {
89 VIRTCHNL_LINK_SPEED_UNKNOWN = 0,
90 VIRTCHNL_LINK_SPEED_100MB = BIT(VIRTCHNL_LINK_SPEED_100MB_SHIFT),
91 VIRTCHNL_LINK_SPEED_1GB = BIT(VIRTCHNL_LINK_SPEED_1000MB_SHIFT),
92 VIRTCHNL_LINK_SPEED_10GB = BIT(VIRTCHNL_LINK_SPEED_10GB_SHIFT),
93 VIRTCHNL_LINK_SPEED_40GB = BIT(VIRTCHNL_LINK_SPEED_40GB_SHIFT),
94 VIRTCHNL_LINK_SPEED_20GB = BIT(VIRTCHNL_LINK_SPEED_20GB_SHIFT),
95 VIRTCHNL_LINK_SPEED_25GB = BIT(VIRTCHNL_LINK_SPEED_25GB_SHIFT),
96 VIRTCHNL_LINK_SPEED_2_5GB = BIT(VIRTCHNL_LINK_SPEED_2_5GB_SHIFT),
97 VIRTCHNL_LINK_SPEED_5GB = BIT(VIRTCHNL_LINK_SPEED_5GB_SHIFT),
98 };
99
100 /* for hsplit_0 field of Rx HMC context */
101 /* deprecated with AVF 1.0 */
102 enum virtchnl_rx_hsplit {
103 VIRTCHNL_RX_HSPLIT_NO_SPLIT = 0,
104 VIRTCHNL_RX_HSPLIT_SPLIT_L2 = 1,
105 VIRTCHNL_RX_HSPLIT_SPLIT_IP = 2,
106 VIRTCHNL_RX_HSPLIT_SPLIT_TCP_UDP = 4,
107 VIRTCHNL_RX_HSPLIT_SPLIT_SCTP = 8,
108 };
109
110 #define VIRTCHNL_ETH_LENGTH_OF_ADDRESS 6
111 /* END GENERIC DEFINES */
112
113 /* Opcodes for VF-PF communication. These are placed in the v_opcode field
114 * of the virtchnl_msg structure.
115 */
116 enum virtchnl_ops {
117 /* The PF sends status change events to VFs using
118 * the VIRTCHNL_OP_EVENT opcode.
119 * VFs send requests to the PF using the other ops.
120 * Use of "advanced opcode" features must be negotiated as part of capabilities
121 * exchange and are not considered part of base mode feature set.
122 */
123 VIRTCHNL_OP_UNKNOWN = 0,
124 VIRTCHNL_OP_VERSION = 1, /* must ALWAYS be 1 */
125 VIRTCHNL_OP_RESET_VF = 2,
126 VIRTCHNL_OP_GET_VF_RESOURCES = 3,
127 VIRTCHNL_OP_CONFIG_TX_QUEUE = 4,
128 VIRTCHNL_OP_CONFIG_RX_QUEUE = 5,
129 VIRTCHNL_OP_CONFIG_VSI_QUEUES = 6,
130 VIRTCHNL_OP_CONFIG_IRQ_MAP = 7,
131 VIRTCHNL_OP_ENABLE_QUEUES = 8,
132 VIRTCHNL_OP_DISABLE_QUEUES = 9,
133 VIRTCHNL_OP_ADD_ETH_ADDR = 10,
134 VIRTCHNL_OP_DEL_ETH_ADDR = 11,
135 VIRTCHNL_OP_ADD_VLAN = 12,
136 VIRTCHNL_OP_DEL_VLAN = 13,
137 VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE = 14,
138 VIRTCHNL_OP_GET_STATS = 15,
139 VIRTCHNL_OP_RSVD = 16,
140 VIRTCHNL_OP_EVENT = 17, /* must ALWAYS be 17 */
141 VIRTCHNL_OP_IWARP = 20, /* advanced opcode */
142 VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP = 21, /* advanced opcode */
143 VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP = 22, /* advanced opcode */
144 VIRTCHNL_OP_CONFIG_RSS_KEY = 23,
145 VIRTCHNL_OP_CONFIG_RSS_LUT = 24,
146 VIRTCHNL_OP_GET_RSS_HENA_CAPS = 25,
147 VIRTCHNL_OP_SET_RSS_HENA = 26,
148 VIRTCHNL_OP_ENABLE_VLAN_STRIPPING = 27,
149 VIRTCHNL_OP_DISABLE_VLAN_STRIPPING = 28,
150 VIRTCHNL_OP_REQUEST_QUEUES = 29,
151
152 };
153
154 /* This macro is used to generate a compilation error if a structure
155 * is not exactly the correct length. It gives a divide by zero error if the
156 * structure is not of the correct size, otherwise it creates an enum that is
157 * never used.
158 */
159 #define VIRTCHNL_CHECK_STRUCT_LEN(n, X) enum virtchnl_static_assert_enum_##X \
160 {virtchnl_static_assert_##X = (n) / ((sizeof(struct X) == (n)) ? 1 : 0)}
161
162 /* Virtual channel message descriptor. This overlays the admin queue
163 * descriptor. All other data is passed in external buffers.
164 */
165
166 struct virtchnl_msg {
167 u8 pad[8]; /* AQ flags/opcode/len/retval fields */
168 enum virtchnl_ops v_opcode; /* avoid confusion with desc->opcode */
169 enum virtchnl_status_code v_retval; /* ditto for desc->retval */
170 u32 vfid; /* used by PF when sending to VF */
171 };
172
173 VIRTCHNL_CHECK_STRUCT_LEN(20, virtchnl_msg);
174
175 /* Message descriptions and data structures.*/
176
177 /* VIRTCHNL_OP_VERSION
178 * VF posts its version number to the PF. PF responds with its version number
179 * in the same format, along with a return code.
180 * Reply from PF has its major/minor versions also in param0 and param1.
181 * If there is a major version mismatch, then the VF cannot operate.
182 * If there is a minor version mismatch, then the VF can operate but should
183 * add a warning to the system log.
184 *
185 * This enum element MUST always be specified as == 1, regardless of other
186 * changes in the API. The PF must always respond to this message without
187 * error regardless of version mismatch.
188 */
189 #define VIRTCHNL_VERSION_MAJOR 1
190 #define VIRTCHNL_VERSION_MINOR 1
191 #define VIRTCHNL_VERSION_MINOR_NO_VF_CAPS 0
192
193 struct virtchnl_version_info {
194 u32 major;
195 u32 minor;
196 };
197
198 VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_version_info);
199
200 #define VF_IS_V10(_v) (((_v)->major == 1) && ((_v)->minor == 0))
201 #define VF_IS_V11(_ver) (((_ver)->major == 1) && ((_ver)->minor == 1))
202
203 /* VIRTCHNL_OP_RESET_VF
204 * VF sends this request to PF with no parameters
205 * PF does NOT respond! VF driver must delay then poll VFGEN_RSTAT register
206 * until reset completion is indicated. The admin queue must be reinitialized
207 * after this operation.
208 *
209 * When reset is complete, PF must ensure that all queues in all VSIs associated
210 * with the VF are stopped, all queue configurations in the HMC are set to 0,
211 * and all MAC and VLAN filters (except the default MAC address) on all VSIs
212 * are cleared.
213 */
214
215 /* VSI types that use VIRTCHNL interface for VF-PF communication. VSI_SRIOV
216 * vsi_type should always be 6 for backward compatibility. Add other fields
217 * as needed.
218 */
219 enum virtchnl_vsi_type {
220 VIRTCHNL_VSI_TYPE_INVALID = 0,
221 VIRTCHNL_VSI_SRIOV = 6,
222 };
223
224 /* VIRTCHNL_OP_GET_VF_RESOURCES
225 * Version 1.0 VF sends this request to PF with no parameters
226 * Version 1.1 VF sends this request to PF with u32 bitmap of its capabilities
227 * PF responds with an indirect message containing
228 * virtchnl_vf_resource and one or more
229 * virtchnl_vsi_resource structures.
230 */
231
232 struct virtchnl_vsi_resource {
233 u16 vsi_id;
234 u16 num_queue_pairs;
235 enum virtchnl_vsi_type vsi_type;
236 u16 qset_handle;
237 u8 default_mac_addr[VIRTCHNL_ETH_LENGTH_OF_ADDRESS];
238 };
239
240 VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_vsi_resource);
241
242 /* VF capability flags
243 * VIRTCHNL_VF_OFFLOAD_L2 flag is inclusive of base mode L2 offloads including
244 * TX/RX Checksum offloading and TSO for non-tunnelled packets.
245 */
246 #define VIRTCHNL_VF_OFFLOAD_L2 0x00000001
247 #define VIRTCHNL_VF_OFFLOAD_IWARP 0x00000002
248 #define VIRTCHNL_VF_OFFLOAD_RSVD 0x00000004
249 #define VIRTCHNL_VF_OFFLOAD_RSS_AQ 0x00000008
250 #define VIRTCHNL_VF_OFFLOAD_RSS_REG 0x00000010
251 #define VIRTCHNL_VF_OFFLOAD_WB_ON_ITR 0x00000020
252 #define VIRTCHNL_VF_OFFLOAD_REQ_QUEUES 0x00000040
253 #define VIRTCHNL_VF_OFFLOAD_VLAN 0x00010000
254 #define VIRTCHNL_VF_OFFLOAD_RX_POLLING 0x00020000
255 #define VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2 0x00040000
256 #define VIRTCHNL_VF_OFFLOAD_RSS_PF 0X00080000
257 #define VIRTCHNL_VF_OFFLOAD_ENCAP 0X00100000
258 #define VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM 0X00200000
259 #define VIRTCHNL_VF_OFFLOAD_RX_ENCAP_CSUM 0X00400000
260
261 #define VF_BASE_MODE_OFFLOADS (VIRTCHNL_VF_OFFLOAD_L2 | \
262 VIRTCHNL_VF_OFFLOAD_VLAN | \
263 VIRTCHNL_VF_OFFLOAD_RSS_PF)
264
265 struct virtchnl_vf_resource {
266 u16 num_vsis;
267 u16 num_queue_pairs;
268 u16 max_vectors;
269 u16 max_mtu;
270
271 u32 vf_cap_flags;
272 u32 rss_key_size;
273 u32 rss_lut_size;
274
275 struct virtchnl_vsi_resource vsi_res[1];
276 };
277
278 VIRTCHNL_CHECK_STRUCT_LEN(36, virtchnl_vf_resource);
279
280 /* VIRTCHNL_OP_CONFIG_TX_QUEUE
281 * VF sends this message to set up parameters for one TX queue.
282 * External data buffer contains one instance of virtchnl_txq_info.
283 * PF configures requested queue and returns a status code.
284 */
285
286 /* Tx queue config info */
287 struct virtchnl_txq_info {
288 u16 vsi_id;
289 u16 queue_id;
290 u16 ring_len; /* number of descriptors, multiple of 8 */
291 u16 headwb_enabled; /* deprecated with AVF 1.0 */
292 u64 dma_ring_addr;
293 u64 dma_headwb_addr; /* deprecated with AVF 1.0 */
294 };
295
296 VIRTCHNL_CHECK_STRUCT_LEN(24, virtchnl_txq_info);
297
298 /* VIRTCHNL_OP_CONFIG_RX_QUEUE
299 * VF sends this message to set up parameters for one RX queue.
300 * External data buffer contains one instance of virtchnl_rxq_info.
301 * PF configures requested queue and returns a status code.
302 */
303
304 /* Rx queue config info */
305 struct virtchnl_rxq_info {
306 u16 vsi_id;
307 u16 queue_id;
308 u32 ring_len; /* number of descriptors, multiple of 32 */
309 u16 hdr_size;
310 u16 splithdr_enabled; /* deprecated with AVF 1.0 */
311 u32 databuffer_size;
312 u32 max_pkt_size;
313 u32 pad1;
314 u64 dma_ring_addr;
315 enum virtchnl_rx_hsplit rx_split_pos; /* deprecated with AVF 1.0 */
316 u32 pad2;
317 };
318
319 VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_rxq_info);
320
321 /* VIRTCHNL_OP_CONFIG_VSI_QUEUES
322 * VF sends this message to set parameters for all active TX and RX queues
323 * associated with the specified VSI.
324 * PF configures queues and returns status.
325 * If the number of queues specified is greater than the number of queues
326 * associated with the VSI, an error is returned and no queues are configured.
327 */
328 struct virtchnl_queue_pair_info {
329 /* NOTE: vsi_id and queue_id should be identical for both queues. */
330 struct virtchnl_txq_info txq;
331 struct virtchnl_rxq_info rxq;
332 };
333
334 VIRTCHNL_CHECK_STRUCT_LEN(64, virtchnl_queue_pair_info);
335
336 struct virtchnl_vsi_queue_config_info {
337 u16 vsi_id;
338 u16 num_queue_pairs;
339 u32 pad;
340 struct virtchnl_queue_pair_info qpair[1];
341 };
342
343 VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_vsi_queue_config_info);
344
345 /* VIRTCHNL_OP_REQUEST_QUEUES
346 * VF sends this message to request the PF to allocate additional queues to
347 * this VF. Each VF gets a guaranteed number of queues on init but asking for
348 * additional queues must be negotiated. This is a best effort request as it
349 * is possible the PF does not have enough queues left to support the request.
350 * If the PF cannot support the number requested it will respond with the
351 * maximum number it is able to support; otherwise it will respond with the
352 * number requested.
353 */
354
355 /* VF resource request */
356 struct virtchnl_vf_res_request {
357 u16 num_queue_pairs;
358 };
359
360 /* VIRTCHNL_OP_CONFIG_IRQ_MAP
361 * VF uses this message to map vectors to queues.
362 * The rxq_map and txq_map fields are bitmaps used to indicate which queues
363 * are to be associated with the specified vector.
364 * The "other" causes are always mapped to vector 0.
365 * PF configures interrupt mapping and returns status.
366 */
367 struct virtchnl_vector_map {
368 u16 vsi_id;
369 u16 vector_id;
370 u16 rxq_map;
371 u16 txq_map;
372 u16 rxitr_idx;
373 u16 txitr_idx;
374 };
375
376 VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_vector_map);
377
378 struct virtchnl_irq_map_info {
379 u16 num_vectors;
380 struct virtchnl_vector_map vecmap[1];
381 };
382
383 VIRTCHNL_CHECK_STRUCT_LEN(14, virtchnl_irq_map_info);
384
385 /* VIRTCHNL_OP_ENABLE_QUEUES
386 * VIRTCHNL_OP_DISABLE_QUEUES
387 * VF sends these message to enable or disable TX/RX queue pairs.
388 * The queues fields are bitmaps indicating which queues to act upon.
389 * (Currently, we only support 16 queues per VF, but we make the field
390 * u32 to allow for expansion.)
391 * PF performs requested action and returns status.
392 */
393 struct virtchnl_queue_select {
394 u16 vsi_id;
395 u16 pad;
396 u32 rx_queues;
397 u32 tx_queues;
398 };
399
400 VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_queue_select);
401
402 /* VIRTCHNL_OP_ADD_ETH_ADDR
403 * VF sends this message in order to add one or more unicast or multicast
404 * address filters for the specified VSI.
405 * PF adds the filters and returns status.
406 */
407
408 /* VIRTCHNL_OP_DEL_ETH_ADDR
409 * VF sends this message in order to remove one or more unicast or multicast
410 * filters for the specified VSI.
411 * PF removes the filters and returns status.
412 */
413
414 struct virtchnl_ether_addr {
415 u8 addr[VIRTCHNL_ETH_LENGTH_OF_ADDRESS];
416 u8 pad[2];
417 };
418
419 VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_ether_addr);
420
421 struct virtchnl_ether_addr_list {
422 u16 vsi_id;
423 u16 num_elements;
424 struct virtchnl_ether_addr list[1];
425 };
426
427 VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_ether_addr_list);
428
429 /* VIRTCHNL_OP_ADD_VLAN
430 * VF sends this message to add one or more VLAN tag filters for receives.
431 * PF adds the filters and returns status.
432 * If a port VLAN is configured by the PF, this operation will return an
433 * error to the VF.
434 */
435
436 /* VIRTCHNL_OP_DEL_VLAN
437 * VF sends this message to remove one or more VLAN tag filters for receives.
438 * PF removes the filters and returns status.
439 * If a port VLAN is configured by the PF, this operation will return an
440 * error to the VF.
441 */
442
443 struct virtchnl_vlan_filter_list {
444 u16 vsi_id;
445 u16 num_elements;
446 u16 vlan_id[1];
447 };
448
449 VIRTCHNL_CHECK_STRUCT_LEN(6, virtchnl_vlan_filter_list);
450
451 /* VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE
452 * VF sends VSI id and flags.
453 * PF returns status code in retval.
454 * Note: we assume that broadcast accept mode is always enabled.
455 */
456 struct virtchnl_promisc_info {
457 u16 vsi_id;
458 u16 flags;
459 };
460
461 VIRTCHNL_CHECK_STRUCT_LEN(4, virtchnl_promisc_info);
462
463 #define FLAG_VF_UNICAST_PROMISC 0x00000001
464 #define FLAG_VF_MULTICAST_PROMISC 0x00000002
465
466 /* VIRTCHNL_OP_GET_STATS
467 * VF sends this message to request stats for the selected VSI. VF uses
468 * the virtchnl_queue_select struct to specify the VSI. The queue_id
469 * field is ignored by the PF.
470 *
471 * PF replies with struct eth_stats in an external buffer.
472 */
473
474 /* VIRTCHNL_OP_CONFIG_RSS_KEY
475 * VIRTCHNL_OP_CONFIG_RSS_LUT
476 * VF sends these messages to configure RSS. Only supported if both PF
477 * and VF drivers set the VIRTCHNL_VF_OFFLOAD_RSS_PF bit during
478 * configuration negotiation. If this is the case, then the RSS fields in
479 * the VF resource struct are valid.
480 * Both the key and LUT are initialized to 0 by the PF, meaning that
481 * RSS is effectively disabled until set up by the VF.
482 */
483 struct virtchnl_rss_key {
484 u16 vsi_id;
485 u16 key_len;
486 u8 key[1]; /* RSS hash key, packed bytes */
487 };
488
489 VIRTCHNL_CHECK_STRUCT_LEN(6, virtchnl_rss_key);
490
491 struct virtchnl_rss_lut {
492 u16 vsi_id;
493 u16 lut_entries;
494 u8 lut[1]; /* RSS lookup table */
495 };
496
497 VIRTCHNL_CHECK_STRUCT_LEN(6, virtchnl_rss_lut);
498
499 /* VIRTCHNL_OP_GET_RSS_HENA_CAPS
500 * VIRTCHNL_OP_SET_RSS_HENA
501 * VF sends these messages to get and set the hash filter enable bits for RSS.
502 * By default, the PF sets these to all possible traffic types that the
503 * hardware supports. The VF can query this value if it wants to change the
504 * traffic types that are hashed by the hardware.
505 */
506 struct virtchnl_rss_hena {
507 u64 hena;
508 };
509
510 VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_rss_hena);
511
512 /* VIRTCHNL_OP_EVENT
513 * PF sends this message to inform the VF driver of events that may affect it.
514 * No direct response is expected from the VF, though it may generate other
515 * messages in response to this one.
516 */
517 enum virtchnl_event_codes {
518 VIRTCHNL_EVENT_UNKNOWN = 0,
519 VIRTCHNL_EVENT_LINK_CHANGE,
520 VIRTCHNL_EVENT_RESET_IMPENDING,
521 VIRTCHNL_EVENT_PF_DRIVER_CLOSE,
522 };
523
524 #define PF_EVENT_SEVERITY_INFO 0
525 #define PF_EVENT_SEVERITY_ATTENTION 1
526 #define PF_EVENT_SEVERITY_ACTION_REQUIRED 2
527 #define PF_EVENT_SEVERITY_CERTAIN_DOOM 255
528
529 struct virtchnl_pf_event {
530 enum virtchnl_event_codes event;
531 union {
532 struct {
533 enum virtchnl_link_speed link_speed;
534 bool link_status;
535 } link_event;
536 } event_data;
537
538 int severity;
539 };
540
541 VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_pf_event);
542
543
544 /* VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP
545 * VF uses this message to request PF to map IWARP vectors to IWARP queues.
546 * The request for this originates from the VF IWARP driver through
547 * a client interface between VF LAN and VF IWARP driver.
548 * A vector could have an AEQ and CEQ attached to it although
549 * there is a single AEQ per VF IWARP instance in which case
550 * most vectors will have an INVALID_IDX for aeq and valid idx for ceq.
551 * There will never be a case where there will be multiple CEQs attached
552 * to a single vector.
553 * PF configures interrupt mapping and returns status.
554 */
555
556 /* HW does not define a type value for AEQ; only for RX/TX and CEQ.
557 * In order for us to keep the interface simple, SW will define a
558 * unique type value for AEQ.
559 */
560 #define QUEUE_TYPE_PE_AEQ 0x80
561 #define QUEUE_INVALID_IDX 0xFFFF
562
563 struct virtchnl_iwarp_qv_info {
564 u32 v_idx; /* msix_vector */
565 u16 ceq_idx;
566 u16 aeq_idx;
567 u8 itr_idx;
568 };
569
570 VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_iwarp_qv_info);
571
572 struct virtchnl_iwarp_qvlist_info {
573 u32 num_vectors;
574 struct virtchnl_iwarp_qv_info qv_info[1];
575 };
576
577 VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_iwarp_qvlist_info);
578
579
580 /* VF reset states - these are written into the RSTAT register:
581 * VFGEN_RSTAT on the VF
582 * When the PF initiates a reset, it writes 0
583 * When the reset is complete, it writes 1
584 * When the PF detects that the VF has recovered, it writes 2
585 * VF checks this register periodically to determine if a reset has occurred,
586 * then polls it to know when the reset is complete.
587 * If either the PF or VF reads the register while the hardware
588 * is in a reset state, it will return DEADBEEF, which, when masked
589 * will result in 3.
590 */
591 enum virtchnl_vfr_states {
592 VIRTCHNL_VFR_INPROGRESS = 0,
593 VIRTCHNL_VFR_COMPLETED,
594 VIRTCHNL_VFR_VFACTIVE,
595 };
596
597 /**
598 * virtchnl_vc_validate_vf_msg
599 * @ver: Virtchnl version info
600 * @v_opcode: Opcode for the message
601 * @msg: pointer to the msg buffer
602 * @msglen: msg length
603 *
604 * validate msg format against struct for each opcode
605 */
606 static inline int
virtchnl_vc_validate_vf_msg(struct virtchnl_version_info * ver,u32 v_opcode,u8 * msg,u16 msglen)607 virtchnl_vc_validate_vf_msg(struct virtchnl_version_info *ver, u32 v_opcode,
608 u8 *msg, u16 msglen)
609 {
610 bool err_msg_format = FALSE;
611 int valid_len = 0;
612
613 /* Validate message length. */
614 switch (v_opcode) {
615 case VIRTCHNL_OP_VERSION:
616 valid_len = sizeof(struct virtchnl_version_info);
617 break;
618 case VIRTCHNL_OP_RESET_VF:
619 break;
620 case VIRTCHNL_OP_GET_VF_RESOURCES:
621 if (VF_IS_V11(ver))
622 valid_len = sizeof(u32);
623 break;
624 case VIRTCHNL_OP_CONFIG_TX_QUEUE:
625 valid_len = sizeof(struct virtchnl_txq_info);
626 break;
627 case VIRTCHNL_OP_CONFIG_RX_QUEUE:
628 valid_len = sizeof(struct virtchnl_rxq_info);
629 break;
630 case VIRTCHNL_OP_CONFIG_VSI_QUEUES:
631 valid_len = sizeof(struct virtchnl_vsi_queue_config_info);
632 if (msglen >= valid_len) {
633 struct virtchnl_vsi_queue_config_info *vqc =
634 (struct virtchnl_vsi_queue_config_info *)msg;
635 valid_len += (vqc->num_queue_pairs *
636 sizeof(struct
637 virtchnl_queue_pair_info));
638 if (vqc->num_queue_pairs == 0)
639 err_msg_format = TRUE;
640 }
641 break;
642 case VIRTCHNL_OP_CONFIG_IRQ_MAP:
643 valid_len = sizeof(struct virtchnl_irq_map_info);
644 if (msglen >= valid_len) {
645 struct virtchnl_irq_map_info *vimi =
646 (struct virtchnl_irq_map_info *)msg;
647 valid_len += (vimi->num_vectors *
648 sizeof(struct virtchnl_vector_map));
649 if (vimi->num_vectors == 0)
650 err_msg_format = TRUE;
651 }
652 break;
653 case VIRTCHNL_OP_ENABLE_QUEUES:
654 case VIRTCHNL_OP_DISABLE_QUEUES:
655 valid_len = sizeof(struct virtchnl_queue_select);
656 break;
657 case VIRTCHNL_OP_ADD_ETH_ADDR:
658 case VIRTCHNL_OP_DEL_ETH_ADDR:
659 valid_len = sizeof(struct virtchnl_ether_addr_list);
660 if (msglen >= valid_len) {
661 struct virtchnl_ether_addr_list *veal =
662 (struct virtchnl_ether_addr_list *)msg;
663 valid_len += veal->num_elements *
664 sizeof(struct virtchnl_ether_addr);
665 if (veal->num_elements == 0)
666 err_msg_format = TRUE;
667 }
668 break;
669 case VIRTCHNL_OP_ADD_VLAN:
670 case VIRTCHNL_OP_DEL_VLAN:
671 valid_len = sizeof(struct virtchnl_vlan_filter_list);
672 if (msglen >= valid_len) {
673 struct virtchnl_vlan_filter_list *vfl =
674 (struct virtchnl_vlan_filter_list *)msg;
675 valid_len += vfl->num_elements * sizeof(u16);
676 if (vfl->num_elements == 0)
677 err_msg_format = TRUE;
678 }
679 break;
680 case VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE:
681 valid_len = sizeof(struct virtchnl_promisc_info);
682 break;
683 case VIRTCHNL_OP_GET_STATS:
684 valid_len = sizeof(struct virtchnl_queue_select);
685 break;
686 case VIRTCHNL_OP_IWARP:
687 /* These messages are opaque to us and will be validated in
688 * the RDMA client code. We just need to check for nonzero
689 * length. The firmware will enforce max length restrictions.
690 */
691 if (msglen)
692 valid_len = msglen;
693 else
694 err_msg_format = TRUE;
695 break;
696 case VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP:
697 break;
698 case VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP:
699 valid_len = sizeof(struct virtchnl_iwarp_qvlist_info);
700 if (msglen >= valid_len) {
701 struct virtchnl_iwarp_qvlist_info *qv =
702 (struct virtchnl_iwarp_qvlist_info *)msg;
703 if (qv->num_vectors == 0) {
704 err_msg_format = TRUE;
705 break;
706 }
707 valid_len += ((qv->num_vectors - 1) *
708 sizeof(struct virtchnl_iwarp_qv_info));
709 }
710 break;
711 case VIRTCHNL_OP_CONFIG_RSS_KEY:
712 valid_len = sizeof(struct virtchnl_rss_key);
713 if (msglen >= valid_len) {
714 struct virtchnl_rss_key *vrk =
715 (struct virtchnl_rss_key *)msg;
716 valid_len += vrk->key_len - 1;
717 }
718 break;
719 case VIRTCHNL_OP_CONFIG_RSS_LUT:
720 valid_len = sizeof(struct virtchnl_rss_lut);
721 if (msglen >= valid_len) {
722 struct virtchnl_rss_lut *vrl =
723 (struct virtchnl_rss_lut *)msg;
724 valid_len += vrl->lut_entries - 1;
725 }
726 break;
727 case VIRTCHNL_OP_GET_RSS_HENA_CAPS:
728 break;
729 case VIRTCHNL_OP_SET_RSS_HENA:
730 valid_len = sizeof(struct virtchnl_rss_hena);
731 break;
732 case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING:
733 case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING:
734 break;
735 case VIRTCHNL_OP_REQUEST_QUEUES:
736 valid_len = sizeof(struct virtchnl_vf_res_request);
737 break;
738 /* These are always errors coming from the VF. */
739 case VIRTCHNL_OP_EVENT:
740 case VIRTCHNL_OP_UNKNOWN:
741 default:
742 return VIRTCHNL_ERR_PARAM;
743 }
744 /* few more checks */
745 if (err_msg_format || valid_len != msglen)
746 return VIRTCHNL_STATUS_ERR_OPCODE_MISMATCH;
747
748 return 0;
749 }
750 #endif /* _VIRTCHNL_H_ */
751