]> git.proxmox.com Git - ceph.git/blob - ceph/src/spdk/dpdk/drivers/net/iavf/base/iavf_common.c
projects / ceph.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
import 15.2.0 Octopus source
[ceph.git] / ceph / src / spdk / dpdk / drivers / net / iavf / base / iavf_common.c
1 /*******************************************************************************
2
3 Copyright (c) 2013 - 2015, 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 #include "iavf_type.h"
35 #include "iavf_adminq.h"
36 #include "iavf_prototype.h"
37 #include "virtchnl.h"
38
39
40 /**
41 * iavf_set_mac_type - Sets MAC type
42 * @hw: pointer to the HW structure
43 *
44 * This function sets the mac type of the adapter based on the
45 * vendor ID and device ID stored in the hw structure.
46 **/
47 enum iavf_status_code iavf_set_mac_type(struct iavf_hw *hw)
48 {
49 enum iavf_status_code status = IAVF_SUCCESS;
50
51 DEBUGFUNC("iavf_set_mac_type\n");
52
53 if (hw->vendor_id == IAVF_INTEL_VENDOR_ID) {
54 switch (hw->device_id) {
55 /* TODO: remove undefined device ID now, need to think how to
56 * remove them in share code
57 */
58 case IAVF_DEV_ID_ADAPTIVE_VF:
59 hw->mac.type = IAVF_MAC_VF;
60 break;
61 default:
62 hw->mac.type = IAVF_MAC_GENERIC;
63 break;
64 }
65 } else {
66 status = IAVF_ERR_DEVICE_NOT_SUPPORTED;
67 }
68
69 DEBUGOUT2("iavf_set_mac_type found mac: %d, returns: %d\n",
70 hw->mac.type, status);
71 return status;
72 }
73
74 /**
75 * iavf_aq_str - convert AQ err code to a string
76 * @hw: pointer to the HW structure
77 * @aq_err: the AQ error code to convert
78 **/
79 const char *iavf_aq_str(struct iavf_hw *hw, enum iavf_admin_queue_err aq_err)
80 {
81 switch (aq_err) {
82 case IAVF_AQ_RC_OK:
83 return "OK";
84 case IAVF_AQ_RC_EPERM:
85 return "IAVF_AQ_RC_EPERM";
86 case IAVF_AQ_RC_ENOENT:
87 return "IAVF_AQ_RC_ENOENT";
88 case IAVF_AQ_RC_ESRCH:
89 return "IAVF_AQ_RC_ESRCH";
90 case IAVF_AQ_RC_EINTR:
91 return "IAVF_AQ_RC_EINTR";
92 case IAVF_AQ_RC_EIO:
93 return "IAVF_AQ_RC_EIO";
94 case IAVF_AQ_RC_ENXIO:
95 return "IAVF_AQ_RC_ENXIO";
96 case IAVF_AQ_RC_E2BIG:
97 return "IAVF_AQ_RC_E2BIG";
98 case IAVF_AQ_RC_EAGAIN:
99 return "IAVF_AQ_RC_EAGAIN";
100 case IAVF_AQ_RC_ENOMEM:
101 return "IAVF_AQ_RC_ENOMEM";
102 case IAVF_AQ_RC_EACCES:
103 return "IAVF_AQ_RC_EACCES";
104 case IAVF_AQ_RC_EFAULT:
105 return "IAVF_AQ_RC_EFAULT";
106 case IAVF_AQ_RC_EBUSY:
107 return "IAVF_AQ_RC_EBUSY";
108 case IAVF_AQ_RC_EEXIST:
109 return "IAVF_AQ_RC_EEXIST";
110 case IAVF_AQ_RC_EINVAL:
111 return "IAVF_AQ_RC_EINVAL";
112 case IAVF_AQ_RC_ENOTTY:
113 return "IAVF_AQ_RC_ENOTTY";
114 case IAVF_AQ_RC_ENOSPC:
115 return "IAVF_AQ_RC_ENOSPC";
116 case IAVF_AQ_RC_ENOSYS:
117 return "IAVF_AQ_RC_ENOSYS";
118 case IAVF_AQ_RC_ERANGE:
119 return "IAVF_AQ_RC_ERANGE";
120 case IAVF_AQ_RC_EFLUSHED:
121 return "IAVF_AQ_RC_EFLUSHED";
122 case IAVF_AQ_RC_BAD_ADDR:
123 return "IAVF_AQ_RC_BAD_ADDR";
124 case IAVF_AQ_RC_EMODE:
125 return "IAVF_AQ_RC_EMODE";
126 case IAVF_AQ_RC_EFBIG:
127 return "IAVF_AQ_RC_EFBIG";
128 }
129
130 snprintf(hw->err_str, sizeof(hw->err_str), "%d", aq_err);
131 return hw->err_str;
132 }
133
134 /**
135 * iavf_stat_str - convert status err code to a string
136 * @hw: pointer to the HW structure
137 * @stat_err: the status error code to convert
138 **/
139 const char *iavf_stat_str(struct iavf_hw *hw, enum iavf_status_code stat_err)
140 {
141 switch (stat_err) {
142 case IAVF_SUCCESS:
143 return "OK";
144 case IAVF_ERR_NVM:
145 return "IAVF_ERR_NVM";
146 case IAVF_ERR_NVM_CHECKSUM:
147 return "IAVF_ERR_NVM_CHECKSUM";
148 case IAVF_ERR_PHY:
149 return "IAVF_ERR_PHY";
150 case IAVF_ERR_CONFIG:
151 return "IAVF_ERR_CONFIG";
152 case IAVF_ERR_PARAM:
153 return "IAVF_ERR_PARAM";
154 case IAVF_ERR_MAC_TYPE:
155 return "IAVF_ERR_MAC_TYPE";
156 case IAVF_ERR_UNKNOWN_PHY:
157 return "IAVF_ERR_UNKNOWN_PHY";
158 case IAVF_ERR_LINK_SETUP:
159 return "IAVF_ERR_LINK_SETUP";
160 case IAVF_ERR_ADAPTER_STOPPED:
161 return "IAVF_ERR_ADAPTER_STOPPED";
162 case IAVF_ERR_INVALID_MAC_ADDR:
163 return "IAVF_ERR_INVALID_MAC_ADDR";
164 case IAVF_ERR_DEVICE_NOT_SUPPORTED:
165 return "IAVF_ERR_DEVICE_NOT_SUPPORTED";
166 case IAVF_ERR_MASTER_REQUESTS_PENDING:
167 return "IAVF_ERR_MASTER_REQUESTS_PENDING";
168 case IAVF_ERR_INVALID_LINK_SETTINGS:
169 return "IAVF_ERR_INVALID_LINK_SETTINGS";
170 case IAVF_ERR_AUTONEG_NOT_COMPLETE:
171 return "IAVF_ERR_AUTONEG_NOT_COMPLETE";
172 case IAVF_ERR_RESET_FAILED:
173 return "IAVF_ERR_RESET_FAILED";
174 case IAVF_ERR_SWFW_SYNC:
175 return "IAVF_ERR_SWFW_SYNC";
176 case IAVF_ERR_NO_AVAILABLE_VSI:
177 return "IAVF_ERR_NO_AVAILABLE_VSI";
178 case IAVF_ERR_NO_MEMORY:
179 return "IAVF_ERR_NO_MEMORY";
180 case IAVF_ERR_BAD_PTR:
181 return "IAVF_ERR_BAD_PTR";
182 case IAVF_ERR_RING_FULL:
183 return "IAVF_ERR_RING_FULL";
184 case IAVF_ERR_INVALID_PD_ID:
185 return "IAVF_ERR_INVALID_PD_ID";
186 case IAVF_ERR_INVALID_QP_ID:
187 return "IAVF_ERR_INVALID_QP_ID";
188 case IAVF_ERR_INVALID_CQ_ID:
189 return "IAVF_ERR_INVALID_CQ_ID";
190 case IAVF_ERR_INVALID_CEQ_ID:
191 return "IAVF_ERR_INVALID_CEQ_ID";
192 case IAVF_ERR_INVALID_AEQ_ID:
193 return "IAVF_ERR_INVALID_AEQ_ID";
194 case IAVF_ERR_INVALID_SIZE:
195 return "IAVF_ERR_INVALID_SIZE";
196 case IAVF_ERR_INVALID_ARP_INDEX:
197 return "IAVF_ERR_INVALID_ARP_INDEX";
198 case IAVF_ERR_INVALID_FPM_FUNC_ID:
199 return "IAVF_ERR_INVALID_FPM_FUNC_ID";
200 case IAVF_ERR_QP_INVALID_MSG_SIZE:
201 return "IAVF_ERR_QP_INVALID_MSG_SIZE";
202 case IAVF_ERR_QP_TOOMANY_WRS_POSTED:
203 return "IAVF_ERR_QP_TOOMANY_WRS_POSTED";
204 case IAVF_ERR_INVALID_FRAG_COUNT:
205 return "IAVF_ERR_INVALID_FRAG_COUNT";
206 case IAVF_ERR_QUEUE_EMPTY:
207 return "IAVF_ERR_QUEUE_EMPTY";
208 case IAVF_ERR_INVALID_ALIGNMENT:
209 return "IAVF_ERR_INVALID_ALIGNMENT";
210 case IAVF_ERR_FLUSHED_QUEUE:
211 return "IAVF_ERR_FLUSHED_QUEUE";
212 case IAVF_ERR_INVALID_PUSH_PAGE_INDEX:
213 return "IAVF_ERR_INVALID_PUSH_PAGE_INDEX";
214 case IAVF_ERR_INVALID_IMM_DATA_SIZE:
215 return "IAVF_ERR_INVALID_IMM_DATA_SIZE";
216 case IAVF_ERR_TIMEOUT:
217 return "IAVF_ERR_TIMEOUT";
218 case IAVF_ERR_OPCODE_MISMATCH:
219 return "IAVF_ERR_OPCODE_MISMATCH";
220 case IAVF_ERR_CQP_COMPL_ERROR:
221 return "IAVF_ERR_CQP_COMPL_ERROR";
222 case IAVF_ERR_INVALID_VF_ID:
223 return "IAVF_ERR_INVALID_VF_ID";
224 case IAVF_ERR_INVALID_HMCFN_ID:
225 return "IAVF_ERR_INVALID_HMCFN_ID";
226 case IAVF_ERR_BACKING_PAGE_ERROR:
227 return "IAVF_ERR_BACKING_PAGE_ERROR";
228 case IAVF_ERR_NO_PBLCHUNKS_AVAILABLE:
229 return "IAVF_ERR_NO_PBLCHUNKS_AVAILABLE";
230 case IAVF_ERR_INVALID_PBLE_INDEX:
231 return "IAVF_ERR_INVALID_PBLE_INDEX";
232 case IAVF_ERR_INVALID_SD_INDEX:
233 return "IAVF_ERR_INVALID_SD_INDEX";
234 case IAVF_ERR_INVALID_PAGE_DESC_INDEX:
235 return "IAVF_ERR_INVALID_PAGE_DESC_INDEX";
236 case IAVF_ERR_INVALID_SD_TYPE:
237 return "IAVF_ERR_INVALID_SD_TYPE";
238 case IAVF_ERR_MEMCPY_FAILED:
239 return "IAVF_ERR_MEMCPY_FAILED";
240 case IAVF_ERR_INVALID_HMC_OBJ_INDEX:
241 return "IAVF_ERR_INVALID_HMC_OBJ_INDEX";
242 case IAVF_ERR_INVALID_HMC_OBJ_COUNT:
243 return "IAVF_ERR_INVALID_HMC_OBJ_COUNT";
244 case IAVF_ERR_INVALID_SRQ_ARM_LIMIT:
245 return "IAVF_ERR_INVALID_SRQ_ARM_LIMIT";
246 case IAVF_ERR_SRQ_ENABLED:
247 return "IAVF_ERR_SRQ_ENABLED";
248 case IAVF_ERR_ADMIN_QUEUE_ERROR:
249 return "IAVF_ERR_ADMIN_QUEUE_ERROR";
250 case IAVF_ERR_ADMIN_QUEUE_TIMEOUT:
251 return "IAVF_ERR_ADMIN_QUEUE_TIMEOUT";
252 case IAVF_ERR_BUF_TOO_SHORT:
253 return "IAVF_ERR_BUF_TOO_SHORT";
254 case IAVF_ERR_ADMIN_QUEUE_FULL:
255 return "IAVF_ERR_ADMIN_QUEUE_FULL";
256 case IAVF_ERR_ADMIN_QUEUE_NO_WORK:
257 return "IAVF_ERR_ADMIN_QUEUE_NO_WORK";
258 case IAVF_ERR_BAD_IWARP_CQE:
259 return "IAVF_ERR_BAD_IWARP_CQE";
260 case IAVF_ERR_NVM_BLANK_MODE:
261 return "IAVF_ERR_NVM_BLANK_MODE";
262 case IAVF_ERR_NOT_IMPLEMENTED:
263 return "IAVF_ERR_NOT_IMPLEMENTED";
264 case IAVF_ERR_PE_DOORBELL_NOT_ENABLED:
265 return "IAVF_ERR_PE_DOORBELL_NOT_ENABLED";
266 case IAVF_ERR_DIAG_TEST_FAILED:
267 return "IAVF_ERR_DIAG_TEST_FAILED";
268 case IAVF_ERR_NOT_READY:
269 return "IAVF_ERR_NOT_READY";
270 case IAVF_NOT_SUPPORTED:
271 return "IAVF_NOT_SUPPORTED";
272 case IAVF_ERR_FIRMWARE_API_VERSION:
273 return "IAVF_ERR_FIRMWARE_API_VERSION";
274 case IAVF_ERR_ADMIN_QUEUE_CRITICAL_ERROR:
275 return "IAVF_ERR_ADMIN_QUEUE_CRITICAL_ERROR";
276 }
277
278 snprintf(hw->err_str, sizeof(hw->err_str), "%d", stat_err);
279 return hw->err_str;
280 }
281
282 /**
283 * iavf_debug_aq
284 * @hw: debug mask related to admin queue
285 * @mask: debug mask
286 * @desc: pointer to admin queue descriptor
287 * @buffer: pointer to command buffer
288 * @buf_len: max length of buffer
289 *
290 * Dumps debug log about adminq command with descriptor contents.
291 **/
292 void iavf_debug_aq(struct iavf_hw *hw, enum iavf_debug_mask mask, void *desc,
293 void *buffer, u16 buf_len)
294 {
295 struct iavf_aq_desc *aq_desc = (struct iavf_aq_desc *)desc;
296 u8 *buf = (u8 *)buffer;
297 u16 len;
298 u16 i = 0;
299
300 if ((!(mask & hw->debug_mask)) || (desc == NULL))
301 return;
302
303 len = LE16_TO_CPU(aq_desc->datalen);
304
305 iavf_debug(hw, mask,
306 "AQ CMD: opcode 0x%04X, flags 0x%04X, datalen 0x%04X, retval 0x%04X\n",
307 LE16_TO_CPU(aq_desc->opcode),
308 LE16_TO_CPU(aq_desc->flags),
309 LE16_TO_CPU(aq_desc->datalen),
310 LE16_TO_CPU(aq_desc->retval));
311 iavf_debug(hw, mask, "\tcookie (h,l) 0x%08X 0x%08X\n",
312 LE32_TO_CPU(aq_desc->cookie_high),
313 LE32_TO_CPU(aq_desc->cookie_low));
314 iavf_debug(hw, mask, "\tparam (0,1) 0x%08X 0x%08X\n",
315 LE32_TO_CPU(aq_desc->params.internal.param0),
316 LE32_TO_CPU(aq_desc->params.internal.param1));
317 iavf_debug(hw, mask, "\taddr (h,l) 0x%08X 0x%08X\n",
318 LE32_TO_CPU(aq_desc->params.external.addr_high),
319 LE32_TO_CPU(aq_desc->params.external.addr_low));
320
321 if ((buffer != NULL) && (aq_desc->datalen != 0)) {
322 iavf_debug(hw, mask, "AQ CMD Buffer:\n");
323 if (buf_len < len)
324 len = buf_len;
325 /* write the full 16-byte chunks */
326 for (i = 0; i < (len - 16); i += 16)
327 iavf_debug(hw, mask,
328 "\t0x%04X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n",
329 i, buf[i], buf[i+1], buf[i+2], buf[i+3],
330 buf[i+4], buf[i+5], buf[i+6], buf[i+7],
331 buf[i+8], buf[i+9], buf[i+10], buf[i+11],
332 buf[i+12], buf[i+13], buf[i+14], buf[i+15]);
333 /* the most we could have left is 16 bytes, pad with zeros */
334 if (i < len) {
335 char d_buf[16];
336 int j, i_sav;
337
338 i_sav = i;
339 memset(d_buf, 0, sizeof(d_buf));
340 for (j = 0; i < len; j++, i++)
341 d_buf[j] = buf[i];
342 iavf_debug(hw, mask,
343 "\t0x%04X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n",
344 i_sav, d_buf[0], d_buf[1], d_buf[2], d_buf[3],
345 d_buf[4], d_buf[5], d_buf[6], d_buf[7],
346 d_buf[8], d_buf[9], d_buf[10], d_buf[11],
347 d_buf[12], d_buf[13], d_buf[14], d_buf[15]);
348 }
349 }
350 }
351
352 /**
353 * iavf_check_asq_alive
354 * @hw: pointer to the hw struct
355 *
356 * Returns true if Queue is enabled else false.
357 **/
358 bool iavf_check_asq_alive(struct iavf_hw *hw)
359 {
360 if (hw->aq.asq.len)
361 #ifdef INTEGRATED_VF
362 if (iavf_is_vf(hw))
363 return !!(rd32(hw, hw->aq.asq.len) &
364 IAVF_ATQLEN1_ATQENABLE_MASK);
365 #else
366 return !!(rd32(hw, hw->aq.asq.len) &
367 IAVF_ATQLEN1_ATQENABLE_MASK);
368 #endif /* INTEGRATED_VF */
369 return false;
370 }
371
372 /**
373 * iavf_aq_queue_shutdown
374 * @hw: pointer to the hw struct
375 * @unloading: is the driver unloading itself
376 *
377 * Tell the Firmware that we're shutting down the AdminQ and whether
378 * or not the driver is unloading as well.
379 **/
380 enum iavf_status_code iavf_aq_queue_shutdown(struct iavf_hw *hw,
381 bool unloading)
382 {
383 struct iavf_aq_desc desc;
384 struct iavf_aqc_queue_shutdown *cmd =
385 (struct iavf_aqc_queue_shutdown *)&desc.params.raw;
386 enum iavf_status_code status;
387
388 iavf_fill_default_direct_cmd_desc(&desc,
389 iavf_aqc_opc_queue_shutdown);
390
391 if (unloading)
392 cmd->driver_unloading = CPU_TO_LE32(IAVF_AQ_DRIVER_UNLOADING);
393 status = iavf_asq_send_command(hw, &desc, NULL, 0, NULL);
394
395 return status;
396 }
397
398 /**
399 * iavf_aq_get_set_rss_lut
400 * @hw: pointer to the hardware structure
401 * @vsi_id: vsi fw index
402 * @pf_lut: for PF table set true, for VSI table set false
403 * @lut: pointer to the lut buffer provided by the caller
404 * @lut_size: size of the lut buffer
405 * @set: set true to set the table, false to get the table
406 *
407 * Internal function to get or set RSS look up table
408 **/
409 STATIC enum iavf_status_code iavf_aq_get_set_rss_lut(struct iavf_hw *hw,
410 u16 vsi_id, bool pf_lut,
411 u8 *lut, u16 lut_size,
412 bool set)
413 {
414 enum iavf_status_code status;
415 struct iavf_aq_desc desc;
416 struct iavf_aqc_get_set_rss_lut *cmd_resp =
417 (struct iavf_aqc_get_set_rss_lut *)&desc.params.raw;
418
419 if (set)
420 iavf_fill_default_direct_cmd_desc(&desc,
421 iavf_aqc_opc_set_rss_lut);
422 else
423 iavf_fill_default_direct_cmd_desc(&desc,
424 iavf_aqc_opc_get_rss_lut);
425
426 /* Indirect command */
427 desc.flags |= CPU_TO_LE16((u16)IAVF_AQ_FLAG_BUF);
428 desc.flags |= CPU_TO_LE16((u16)IAVF_AQ_FLAG_RD);
429
430 cmd_resp->vsi_id =
431 CPU_TO_LE16((u16)((vsi_id <<
432 IAVF_AQC_SET_RSS_LUT_VSI_ID_SHIFT) &
433 IAVF_AQC_SET_RSS_LUT_VSI_ID_MASK));
434 cmd_resp->vsi_id |= CPU_TO_LE16((u16)IAVF_AQC_SET_RSS_LUT_VSI_VALID);
435
436 if (pf_lut)
437 cmd_resp->flags |= CPU_TO_LE16((u16)
438 ((IAVF_AQC_SET_RSS_LUT_TABLE_TYPE_PF <<
439 IAVF_AQC_SET_RSS_LUT_TABLE_TYPE_SHIFT) &
440 IAVF_AQC_SET_RSS_LUT_TABLE_TYPE_MASK));
441 else
442 cmd_resp->flags |= CPU_TO_LE16((u16)
443 ((IAVF_AQC_SET_RSS_LUT_TABLE_TYPE_VSI <<
444 IAVF_AQC_SET_RSS_LUT_TABLE_TYPE_SHIFT) &
445 IAVF_AQC_SET_RSS_LUT_TABLE_TYPE_MASK));
446
447 status = iavf_asq_send_command(hw, &desc, lut, lut_size, NULL);
448
449 return status;
450 }
451
452 /**
453 * iavf_aq_get_rss_lut
454 * @hw: pointer to the hardware structure
455 * @vsi_id: vsi fw index
456 * @pf_lut: for PF table set true, for VSI table set false
457 * @lut: pointer to the lut buffer provided by the caller
458 * @lut_size: size of the lut buffer
459 *
460 * get the RSS lookup table, PF or VSI type
461 **/
462 enum iavf_status_code iavf_aq_get_rss_lut(struct iavf_hw *hw, u16 vsi_id,
463 bool pf_lut, u8 *lut, u16 lut_size)
464 {
465 return iavf_aq_get_set_rss_lut(hw, vsi_id, pf_lut, lut, lut_size,
466 false);
467 }
468
469 /**
470 * iavf_aq_set_rss_lut
471 * @hw: pointer to the hardware structure
472 * @vsi_id: vsi fw index
473 * @pf_lut: for PF table set true, for VSI table set false
474 * @lut: pointer to the lut buffer provided by the caller
475 * @lut_size: size of the lut buffer
476 *
477 * set the RSS lookup table, PF or VSI type
478 **/
479 enum iavf_status_code iavf_aq_set_rss_lut(struct iavf_hw *hw, u16 vsi_id,
480 bool pf_lut, u8 *lut, u16 lut_size)
481 {
482 return iavf_aq_get_set_rss_lut(hw, vsi_id, pf_lut, lut, lut_size, true);
483 }
484
485 /**
486 * iavf_aq_get_set_rss_key
487 * @hw: pointer to the hw struct
488 * @vsi_id: vsi fw index
489 * @key: pointer to key info struct
490 * @set: set true to set the key, false to get the key
491 *
492 * get the RSS key per VSI
493 **/
494 STATIC enum iavf_status_code iavf_aq_get_set_rss_key(struct iavf_hw *hw,
495 u16 vsi_id,
496 struct iavf_aqc_get_set_rss_key_data *key,
497 bool set)
498 {
499 enum iavf_status_code status;
500 struct iavf_aq_desc desc;
501 struct iavf_aqc_get_set_rss_key *cmd_resp =
502 (struct iavf_aqc_get_set_rss_key *)&desc.params.raw;
503 u16 key_size = sizeof(struct iavf_aqc_get_set_rss_key_data);
504
505 if (set)
506 iavf_fill_default_direct_cmd_desc(&desc,
507 iavf_aqc_opc_set_rss_key);
508 else
509 iavf_fill_default_direct_cmd_desc(&desc,
510 iavf_aqc_opc_get_rss_key);
511
512 /* Indirect command */
513 desc.flags |= CPU_TO_LE16((u16)IAVF_AQ_FLAG_BUF);
514 desc.flags |= CPU_TO_LE16((u16)IAVF_AQ_FLAG_RD);
515
516 cmd_resp->vsi_id =
517 CPU_TO_LE16((u16)((vsi_id <<
518 IAVF_AQC_SET_RSS_KEY_VSI_ID_SHIFT) &
519 IAVF_AQC_SET_RSS_KEY_VSI_ID_MASK));
520 cmd_resp->vsi_id |= CPU_TO_LE16((u16)IAVF_AQC_SET_RSS_KEY_VSI_VALID);
521
522 status = iavf_asq_send_command(hw, &desc, key, key_size, NULL);
523
524 return status;
525 }
526
527 /**
528 * iavf_aq_get_rss_key
529 * @hw: pointer to the hw struct
530 * @vsi_id: vsi fw index
531 * @key: pointer to key info struct
532 *
533 **/
534 enum iavf_status_code iavf_aq_get_rss_key(struct iavf_hw *hw,
535 u16 vsi_id,
536 struct iavf_aqc_get_set_rss_key_data *key)
537 {
538 return iavf_aq_get_set_rss_key(hw, vsi_id, key, false);
539 }
540
541 /**
542 * iavf_aq_set_rss_key
543 * @hw: pointer to the hw struct
544 * @vsi_id: vsi fw index
545 * @key: pointer to key info struct
546 *
547 * set the RSS key per VSI
548 **/
549 enum iavf_status_code iavf_aq_set_rss_key(struct iavf_hw *hw,
550 u16 vsi_id,
551 struct iavf_aqc_get_set_rss_key_data *key)
552 {
553 return iavf_aq_get_set_rss_key(hw, vsi_id, key, true);
554 }
555
556 /* The iavf_ptype_lookup table is used to convert from the 8-bit ptype in the
557 * hardware to a bit-field that can be used by SW to more easily determine the
558 * packet type.
559 *
560 * Macros are used to shorten the table lines and make this table human
561 * readable.
562 *
563 * We store the PTYPE in the top byte of the bit field - this is just so that
564 * we can check that the table doesn't have a row missing, as the index into
565 * the table should be the PTYPE.
566 *
567 * Typical work flow:
568 *
569 * IF NOT iavf_ptype_lookup[ptype].known
570 * THEN
571 * Packet is unknown
572 * ELSE IF iavf_ptype_lookup[ptype].outer_ip == IAVF_RX_PTYPE_OUTER_IP
573 * Use the rest of the fields to look at the tunnels, inner protocols, etc
574 * ELSE
575 * Use the enum iavf_rx_l2_ptype to decode the packet type
576 * ENDIF
577 */
578
579 /* macro to make the table lines short */
580 #define IAVF_PTT(PTYPE, OUTER_IP, OUTER_IP_VER, OUTER_FRAG, T, TE, TEF, I, PL)\
581 { PTYPE, \
582 1, \
583 IAVF_RX_PTYPE_OUTER_##OUTER_IP, \
584 IAVF_RX_PTYPE_OUTER_##OUTER_IP_VER, \
585 IAVF_RX_PTYPE_##OUTER_FRAG, \
586 IAVF_RX_PTYPE_TUNNEL_##T, \
587 IAVF_RX_PTYPE_TUNNEL_END_##TE, \
588 IAVF_RX_PTYPE_##TEF, \
589 IAVF_RX_PTYPE_INNER_PROT_##I, \
590 IAVF_RX_PTYPE_PAYLOAD_LAYER_##PL }
591
592 #define IAVF_PTT_UNUSED_ENTRY(PTYPE) \
593 { PTYPE, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
594
595 /* shorter macros makes the table fit but are terse */
596 #define IAVF_RX_PTYPE_NOF IAVF_RX_PTYPE_NOT_FRAG
597 #define IAVF_RX_PTYPE_FRG IAVF_RX_PTYPE_FRAG
598 #define IAVF_RX_PTYPE_INNER_PROT_TS IAVF_RX_PTYPE_INNER_PROT_TIMESYNC
599
600 /* Lookup table mapping the HW PTYPE to the bit field for decoding */
601 struct iavf_rx_ptype_decoded iavf_ptype_lookup[] = {
602 /* L2 Packet types */
603 IAVF_PTT_UNUSED_ENTRY(0),
604 IAVF_PTT(1, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY2),
605 IAVF_PTT(2, L2, NONE, NOF, NONE, NONE, NOF, TS, PAY2),
606 IAVF_PTT(3, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY2),
607 IAVF_PTT_UNUSED_ENTRY(4),
608 IAVF_PTT_UNUSED_ENTRY(5),
609 IAVF_PTT(6, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY2),
610 IAVF_PTT(7, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY2),
611 IAVF_PTT_UNUSED_ENTRY(8),
612 IAVF_PTT_UNUSED_ENTRY(9),
613 IAVF_PTT(10, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY2),
614 IAVF_PTT(11, L2, NONE, NOF, NONE, NONE, NOF, NONE, NONE),
615 IAVF_PTT(12, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
616 IAVF_PTT(13, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
617 IAVF_PTT(14, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
618 IAVF_PTT(15, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
619 IAVF_PTT(16, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
620 IAVF_PTT(17, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
621 IAVF_PTT(18, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
622 IAVF_PTT(19, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
623 IAVF_PTT(20, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
624 IAVF_PTT(21, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
625
626 /* Non Tunneled IPv4 */
627 IAVF_PTT(22, IP, IPV4, FRG, NONE, NONE, NOF, NONE, PAY3),
628 IAVF_PTT(23, IP, IPV4, NOF, NONE, NONE, NOF, NONE, PAY3),
629 IAVF_PTT(24, IP, IPV4, NOF, NONE, NONE, NOF, UDP, PAY4),
630 IAVF_PTT_UNUSED_ENTRY(25),
631 IAVF_PTT(26, IP, IPV4, NOF, NONE, NONE, NOF, TCP, PAY4),
632 IAVF_PTT(27, IP, IPV4, NOF, NONE, NONE, NOF, SCTP, PAY4),
633 IAVF_PTT(28, IP, IPV4, NOF, NONE, NONE, NOF, ICMP, PAY4),
634
635 /* IPv4 --> IPv4 */
636 IAVF_PTT(29, IP, IPV4, NOF, IP_IP, IPV4, FRG, NONE, PAY3),
637 IAVF_PTT(30, IP, IPV4, NOF, IP_IP, IPV4, NOF, NONE, PAY3),
638 IAVF_PTT(31, IP, IPV4, NOF, IP_IP, IPV4, NOF, UDP, PAY4),
639 IAVF_PTT_UNUSED_ENTRY(32),
640 IAVF_PTT(33, IP, IPV4, NOF, IP_IP, IPV4, NOF, TCP, PAY4),
641 IAVF_PTT(34, IP, IPV4, NOF, IP_IP, IPV4, NOF, SCTP, PAY4),
642 IAVF_PTT(35, IP, IPV4, NOF, IP_IP, IPV4, NOF, ICMP, PAY4),
643
644 /* IPv4 --> IPv6 */
645 IAVF_PTT(36, IP, IPV4, NOF, IP_IP, IPV6, FRG, NONE, PAY3),
646 IAVF_PTT(37, IP, IPV4, NOF, IP_IP, IPV6, NOF, NONE, PAY3),
647 IAVF_PTT(38, IP, IPV4, NOF, IP_IP, IPV6, NOF, UDP, PAY4),
648 IAVF_PTT_UNUSED_ENTRY(39),
649 IAVF_PTT(40, IP, IPV4, NOF, IP_IP, IPV6, NOF, TCP, PAY4),
650 IAVF_PTT(41, IP, IPV4, NOF, IP_IP, IPV6, NOF, SCTP, PAY4),
651 IAVF_PTT(42, IP, IPV4, NOF, IP_IP, IPV6, NOF, ICMP, PAY4),
652
653 /* IPv4 --> GRE/NAT */
654 IAVF_PTT(43, IP, IPV4, NOF, IP_GRENAT, NONE, NOF, NONE, PAY3),
655
656 /* IPv4 --> GRE/NAT --> IPv4 */
657 IAVF_PTT(44, IP, IPV4, NOF, IP_GRENAT, IPV4, FRG, NONE, PAY3),
658 IAVF_PTT(45, IP, IPV4, NOF, IP_GRENAT, IPV4, NOF, NONE, PAY3),
659 IAVF_PTT(46, IP, IPV4, NOF, IP_GRENAT, IPV4, NOF, UDP, PAY4),
660 IAVF_PTT_UNUSED_ENTRY(47),
661 IAVF_PTT(48, IP, IPV4, NOF, IP_GRENAT, IPV4, NOF, TCP, PAY4),
662 IAVF_PTT(49, IP, IPV4, NOF, IP_GRENAT, IPV4, NOF, SCTP, PAY4),
663 IAVF_PTT(50, IP, IPV4, NOF, IP_GRENAT, IPV4, NOF, ICMP, PAY4),
664
665 /* IPv4 --> GRE/NAT --> IPv6 */
666 IAVF_PTT(51, IP, IPV4, NOF, IP_GRENAT, IPV6, FRG, NONE, PAY3),
667 IAVF_PTT(52, IP, IPV4, NOF, IP_GRENAT, IPV6, NOF, NONE, PAY3),
668 IAVF_PTT(53, IP, IPV4, NOF, IP_GRENAT, IPV6, NOF, UDP, PAY4),
669 IAVF_PTT_UNUSED_ENTRY(54),
670 IAVF_PTT(55, IP, IPV4, NOF, IP_GRENAT, IPV6, NOF, TCP, PAY4),
671 IAVF_PTT(56, IP, IPV4, NOF, IP_GRENAT, IPV6, NOF, SCTP, PAY4),
672 IAVF_PTT(57, IP, IPV4, NOF, IP_GRENAT, IPV6, NOF, ICMP, PAY4),
673
674 /* IPv4 --> GRE/NAT --> MAC */
675 IAVF_PTT(58, IP, IPV4, NOF, IP_GRENAT_MAC, NONE, NOF, NONE, PAY3),
676
677 /* IPv4 --> GRE/NAT --> MAC --> IPv4 */
678 IAVF_PTT(59, IP, IPV4, NOF, IP_GRENAT_MAC, IPV4, FRG, NONE, PAY3),
679 IAVF_PTT(60, IP, IPV4, NOF, IP_GRENAT_MAC, IPV4, NOF, NONE, PAY3),
680 IAVF_PTT(61, IP, IPV4, NOF, IP_GRENAT_MAC, IPV4, NOF, UDP, PAY4),
681 IAVF_PTT_UNUSED_ENTRY(62),
682 IAVF_PTT(63, IP, IPV4, NOF, IP_GRENAT_MAC, IPV4, NOF, TCP, PAY4),
683 IAVF_PTT(64, IP, IPV4, NOF, IP_GRENAT_MAC, IPV4, NOF, SCTP, PAY4),
684 IAVF_PTT(65, IP, IPV4, NOF, IP_GRENAT_MAC, IPV4, NOF, ICMP, PAY4),
685
686 /* IPv4 --> GRE/NAT -> MAC --> IPv6 */
687 IAVF_PTT(66, IP, IPV4, NOF, IP_GRENAT_MAC, IPV6, FRG, NONE, PAY3),
688 IAVF_PTT(67, IP, IPV4, NOF, IP_GRENAT_MAC, IPV6, NOF, NONE, PAY3),
689 IAVF_PTT(68, IP, IPV4, NOF, IP_GRENAT_MAC, IPV6, NOF, UDP, PAY4),
690 IAVF_PTT_UNUSED_ENTRY(69),
691 IAVF_PTT(70, IP, IPV4, NOF, IP_GRENAT_MAC, IPV6, NOF, TCP, PAY4),
692 IAVF_PTT(71, IP, IPV4, NOF, IP_GRENAT_MAC, IPV6, NOF, SCTP, PAY4),
693 IAVF_PTT(72, IP, IPV4, NOF, IP_GRENAT_MAC, IPV6, NOF, ICMP, PAY4),
694
695 /* IPv4 --> GRE/NAT --> MAC/VLAN */
696 IAVF_PTT(73, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, NONE, NOF, NONE, PAY3),
697
698 /* IPv4 ---> GRE/NAT -> MAC/VLAN --> IPv4 */
699 IAVF_PTT(74, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV4, FRG, NONE, PAY3),
700 IAVF_PTT(75, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, NONE, PAY3),
701 IAVF_PTT(76, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, UDP, PAY4),
702 IAVF_PTT_UNUSED_ENTRY(77),
703 IAVF_PTT(78, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, TCP, PAY4),
704 IAVF_PTT(79, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, SCTP, PAY4),
705 IAVF_PTT(80, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, ICMP, PAY4),
706
707 /* IPv4 -> GRE/NAT -> MAC/VLAN --> IPv6 */
708 IAVF_PTT(81, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV6, FRG, NONE, PAY3),
709 IAVF_PTT(82, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, NONE, PAY3),
710 IAVF_PTT(83, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, UDP, PAY4),
711 IAVF_PTT_UNUSED_ENTRY(84),
712 IAVF_PTT(85, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, TCP, PAY4),
713 IAVF_PTT(86, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, SCTP, PAY4),
714 IAVF_PTT(87, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, ICMP, PAY4),
715
716 /* Non Tunneled IPv6 */
717 IAVF_PTT(88, IP, IPV6, FRG, NONE, NONE, NOF, NONE, PAY3),
718 IAVF_PTT(89, IP, IPV6, NOF, NONE, NONE, NOF, NONE, PAY3),
719 IAVF_PTT(90, IP, IPV6, NOF, NONE, NONE, NOF, UDP, PAY4),
720 IAVF_PTT_UNUSED_ENTRY(91),
721 IAVF_PTT(92, IP, IPV6, NOF, NONE, NONE, NOF, TCP, PAY4),
722 IAVF_PTT(93, IP, IPV6, NOF, NONE, NONE, NOF, SCTP, PAY4),
723 IAVF_PTT(94, IP, IPV6, NOF, NONE, NONE, NOF, ICMP, PAY4),
724
725 /* IPv6 --> IPv4 */
726 IAVF_PTT(95, IP, IPV6, NOF, IP_IP, IPV4, FRG, NONE, PAY3),
727 IAVF_PTT(96, IP, IPV6, NOF, IP_IP, IPV4, NOF, NONE, PAY3),
728 IAVF_PTT(97, IP, IPV6, NOF, IP_IP, IPV4, NOF, UDP, PAY4),
729 IAVF_PTT_UNUSED_ENTRY(98),
730 IAVF_PTT(99, IP, IPV6, NOF, IP_IP, IPV4, NOF, TCP, PAY4),
731 IAVF_PTT(100, IP, IPV6, NOF, IP_IP, IPV4, NOF, SCTP, PAY4),
732 IAVF_PTT(101, IP, IPV6, NOF, IP_IP, IPV4, NOF, ICMP, PAY4),
733
734 /* IPv6 --> IPv6 */
735 IAVF_PTT(102, IP, IPV6, NOF, IP_IP, IPV6, FRG, NONE, PAY3),
736 IAVF_PTT(103, IP, IPV6, NOF, IP_IP, IPV6, NOF, NONE, PAY3),
737 IAVF_PTT(104, IP, IPV6, NOF, IP_IP, IPV6, NOF, UDP, PAY4),
738 IAVF_PTT_UNUSED_ENTRY(105),
739 IAVF_PTT(106, IP, IPV6, NOF, IP_IP, IPV6, NOF, TCP, PAY4),
740 IAVF_PTT(107, IP, IPV6, NOF, IP_IP, IPV6, NOF, SCTP, PAY4),
741 IAVF_PTT(108, IP, IPV6, NOF, IP_IP, IPV6, NOF, ICMP, PAY4),
742
743 /* IPv6 --> GRE/NAT */
744 IAVF_PTT(109, IP, IPV6, NOF, IP_GRENAT, NONE, NOF, NONE, PAY3),
745
746 /* IPv6 --> GRE/NAT -> IPv4 */
747 IAVF_PTT(110, IP, IPV6, NOF, IP_GRENAT, IPV4, FRG, NONE, PAY3),
748 IAVF_PTT(111, IP, IPV6, NOF, IP_GRENAT, IPV4, NOF, NONE, PAY3),
749 IAVF_PTT(112, IP, IPV6, NOF, IP_GRENAT, IPV4, NOF, UDP, PAY4),
750 IAVF_PTT_UNUSED_ENTRY(113),
751 IAVF_PTT(114, IP, IPV6, NOF, IP_GRENAT, IPV4, NOF, TCP, PAY4),
752 IAVF_PTT(115, IP, IPV6, NOF, IP_GRENAT, IPV4, NOF, SCTP, PAY4),
753 IAVF_PTT(116, IP, IPV6, NOF, IP_GRENAT, IPV4, NOF, ICMP, PAY4),
754
755 /* IPv6 --> GRE/NAT -> IPv6 */
756 IAVF_PTT(117, IP, IPV6, NOF, IP_GRENAT, IPV6, FRG, NONE, PAY3),
757 IAVF_PTT(118, IP, IPV6, NOF, IP_GRENAT, IPV6, NOF, NONE, PAY3),
758 IAVF_PTT(119, IP, IPV6, NOF, IP_GRENAT, IPV6, NOF, UDP, PAY4),
759 IAVF_PTT_UNUSED_ENTRY(120),
760 IAVF_PTT(121, IP, IPV6, NOF, IP_GRENAT, IPV6, NOF, TCP, PAY4),
761 IAVF_PTT(122, IP, IPV6, NOF, IP_GRENAT, IPV6, NOF, SCTP, PAY4),
762 IAVF_PTT(123, IP, IPV6, NOF, IP_GRENAT, IPV6, NOF, ICMP, PAY4),
763
764 /* IPv6 --> GRE/NAT -> MAC */
765 IAVF_PTT(124, IP, IPV6, NOF, IP_GRENAT_MAC, NONE, NOF, NONE, PAY3),
766
767 /* IPv6 --> GRE/NAT -> MAC -> IPv4 */
768 IAVF_PTT(125, IP, IPV6, NOF, IP_GRENAT_MAC, IPV4, FRG, NONE, PAY3),
769 IAVF_PTT(126, IP, IPV6, NOF, IP_GRENAT_MAC, IPV4, NOF, NONE, PAY3),
770 IAVF_PTT(127, IP, IPV6, NOF, IP_GRENAT_MAC, IPV4, NOF, UDP, PAY4),
771 IAVF_PTT_UNUSED_ENTRY(128),
772 IAVF_PTT(129, IP, IPV6, NOF, IP_GRENAT_MAC, IPV4, NOF, TCP, PAY4),
773 IAVF_PTT(130, IP, IPV6, NOF, IP_GRENAT_MAC, IPV4, NOF, SCTP, PAY4),
774 IAVF_PTT(131, IP, IPV6, NOF, IP_GRENAT_MAC, IPV4, NOF, ICMP, PAY4),
775
776 /* IPv6 --> GRE/NAT -> MAC -> IPv6 */
777 IAVF_PTT(132, IP, IPV6, NOF, IP_GRENAT_MAC, IPV6, FRG, NONE, PAY3),
778 IAVF_PTT(133, IP, IPV6, NOF, IP_GRENAT_MAC, IPV6, NOF, NONE, PAY3),
779 IAVF_PTT(134, IP, IPV6, NOF, IP_GRENAT_MAC, IPV6, NOF, UDP, PAY4),
780 IAVF_PTT_UNUSED_ENTRY(135),
781 IAVF_PTT(136, IP, IPV6, NOF, IP_GRENAT_MAC, IPV6, NOF, TCP, PAY4),
782 IAVF_PTT(137, IP, IPV6, NOF, IP_GRENAT_MAC, IPV6, NOF, SCTP, PAY4),
783 IAVF_PTT(138, IP, IPV6, NOF, IP_GRENAT_MAC, IPV6, NOF, ICMP, PAY4),
784
785 /* IPv6 --> GRE/NAT -> MAC/VLAN */
786 IAVF_PTT(139, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, NONE, NOF, NONE, PAY3),
787
788 /* IPv6 --> GRE/NAT -> MAC/VLAN --> IPv4 */
789 IAVF_PTT(140, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV4, FRG, NONE, PAY3),
790 IAVF_PTT(141, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, NONE, PAY3),
791 IAVF_PTT(142, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, UDP, PAY4),
792 IAVF_PTT_UNUSED_ENTRY(143),
793 IAVF_PTT(144, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, TCP, PAY4),
794 IAVF_PTT(145, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, SCTP, PAY4),
795 IAVF_PTT(146, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, ICMP, PAY4),
796
797 /* IPv6 --> GRE/NAT -> MAC/VLAN --> IPv6 */
798 IAVF_PTT(147, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV6, FRG, NONE, PAY3),
799 IAVF_PTT(148, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, NONE, PAY3),
800 IAVF_PTT(149, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, UDP, PAY4),
801 IAVF_PTT_UNUSED_ENTRY(150),
802 IAVF_PTT(151, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, TCP, PAY4),
803 IAVF_PTT(152, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, SCTP, PAY4),
804 IAVF_PTT(153, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, ICMP, PAY4),
805
806 /* unused entries */
807 IAVF_PTT_UNUSED_ENTRY(154),
808 IAVF_PTT_UNUSED_ENTRY(155),
809 IAVF_PTT_UNUSED_ENTRY(156),
810 IAVF_PTT_UNUSED_ENTRY(157),
811 IAVF_PTT_UNUSED_ENTRY(158),
812 IAVF_PTT_UNUSED_ENTRY(159),
813
814 IAVF_PTT_UNUSED_ENTRY(160),
815 IAVF_PTT_UNUSED_ENTRY(161),
816 IAVF_PTT_UNUSED_ENTRY(162),
817 IAVF_PTT_UNUSED_ENTRY(163),
818 IAVF_PTT_UNUSED_ENTRY(164),
819 IAVF_PTT_UNUSED_ENTRY(165),
820 IAVF_PTT_UNUSED_ENTRY(166),
821 IAVF_PTT_UNUSED_ENTRY(167),
822 IAVF_PTT_UNUSED_ENTRY(168),
823 IAVF_PTT_UNUSED_ENTRY(169),
824
825 IAVF_PTT_UNUSED_ENTRY(170),
826 IAVF_PTT_UNUSED_ENTRY(171),
827 IAVF_PTT_UNUSED_ENTRY(172),
828 IAVF_PTT_UNUSED_ENTRY(173),
829 IAVF_PTT_UNUSED_ENTRY(174),
830 IAVF_PTT_UNUSED_ENTRY(175),
831 IAVF_PTT_UNUSED_ENTRY(176),
832 IAVF_PTT_UNUSED_ENTRY(177),
833 IAVF_PTT_UNUSED_ENTRY(178),
834 IAVF_PTT_UNUSED_ENTRY(179),
835
836 IAVF_PTT_UNUSED_ENTRY(180),
837 IAVF_PTT_UNUSED_ENTRY(181),
838 IAVF_PTT_UNUSED_ENTRY(182),
839 IAVF_PTT_UNUSED_ENTRY(183),
840 IAVF_PTT_UNUSED_ENTRY(184),
841 IAVF_PTT_UNUSED_ENTRY(185),
842 IAVF_PTT_UNUSED_ENTRY(186),
843 IAVF_PTT_UNUSED_ENTRY(187),
844 IAVF_PTT_UNUSED_ENTRY(188),
845 IAVF_PTT_UNUSED_ENTRY(189),
846
847 IAVF_PTT_UNUSED_ENTRY(190),
848 IAVF_PTT_UNUSED_ENTRY(191),
849 IAVF_PTT_UNUSED_ENTRY(192),
850 IAVF_PTT_UNUSED_ENTRY(193),
851 IAVF_PTT_UNUSED_ENTRY(194),
852 IAVF_PTT_UNUSED_ENTRY(195),
853 IAVF_PTT_UNUSED_ENTRY(196),
854 IAVF_PTT_UNUSED_ENTRY(197),
855 IAVF_PTT_UNUSED_ENTRY(198),
856 IAVF_PTT_UNUSED_ENTRY(199),
857
858 IAVF_PTT_UNUSED_ENTRY(200),
859 IAVF_PTT_UNUSED_ENTRY(201),
860 IAVF_PTT_UNUSED_ENTRY(202),
861 IAVF_PTT_UNUSED_ENTRY(203),
862 IAVF_PTT_UNUSED_ENTRY(204),
863 IAVF_PTT_UNUSED_ENTRY(205),
864 IAVF_PTT_UNUSED_ENTRY(206),
865 IAVF_PTT_UNUSED_ENTRY(207),
866 IAVF_PTT_UNUSED_ENTRY(208),
867 IAVF_PTT_UNUSED_ENTRY(209),
868
869 IAVF_PTT_UNUSED_ENTRY(210),
870 IAVF_PTT_UNUSED_ENTRY(211),
871 IAVF_PTT_UNUSED_ENTRY(212),
872 IAVF_PTT_UNUSED_ENTRY(213),
873 IAVF_PTT_UNUSED_ENTRY(214),
874 IAVF_PTT_UNUSED_ENTRY(215),
875 IAVF_PTT_UNUSED_ENTRY(216),
876 IAVF_PTT_UNUSED_ENTRY(217),
877 IAVF_PTT_UNUSED_ENTRY(218),
878 IAVF_PTT_UNUSED_ENTRY(219),
879
880 IAVF_PTT_UNUSED_ENTRY(220),
881 IAVF_PTT_UNUSED_ENTRY(221),
882 IAVF_PTT_UNUSED_ENTRY(222),
883 IAVF_PTT_UNUSED_ENTRY(223),
884 IAVF_PTT_UNUSED_ENTRY(224),
885 IAVF_PTT_UNUSED_ENTRY(225),
886 IAVF_PTT_UNUSED_ENTRY(226),
887 IAVF_PTT_UNUSED_ENTRY(227),
888 IAVF_PTT_UNUSED_ENTRY(228),
889 IAVF_PTT_UNUSED_ENTRY(229),
890
891 IAVF_PTT_UNUSED_ENTRY(230),
892 IAVF_PTT_UNUSED_ENTRY(231),
893 IAVF_PTT_UNUSED_ENTRY(232),
894 IAVF_PTT_UNUSED_ENTRY(233),
895 IAVF_PTT_UNUSED_ENTRY(234),
896 IAVF_PTT_UNUSED_ENTRY(235),
897 IAVF_PTT_UNUSED_ENTRY(236),
898 IAVF_PTT_UNUSED_ENTRY(237),
899 IAVF_PTT_UNUSED_ENTRY(238),
900 IAVF_PTT_UNUSED_ENTRY(239),
901
902 IAVF_PTT_UNUSED_ENTRY(240),
903 IAVF_PTT_UNUSED_ENTRY(241),
904 IAVF_PTT_UNUSED_ENTRY(242),
905 IAVF_PTT_UNUSED_ENTRY(243),
906 IAVF_PTT_UNUSED_ENTRY(244),
907 IAVF_PTT_UNUSED_ENTRY(245),
908 IAVF_PTT_UNUSED_ENTRY(246),
909 IAVF_PTT_UNUSED_ENTRY(247),
910 IAVF_PTT_UNUSED_ENTRY(248),
911 IAVF_PTT_UNUSED_ENTRY(249),
912
913 IAVF_PTT_UNUSED_ENTRY(250),
914 IAVF_PTT_UNUSED_ENTRY(251),
915 IAVF_PTT_UNUSED_ENTRY(252),
916 IAVF_PTT_UNUSED_ENTRY(253),
917 IAVF_PTT_UNUSED_ENTRY(254),
918 IAVF_PTT_UNUSED_ENTRY(255)
919 };
920
921
922 /**
923 * iavf_validate_mac_addr - Validate unicast MAC address
924 * @mac_addr: pointer to MAC address
925 *
926 * Tests a MAC address to ensure it is a valid Individual Address
927 **/
928 enum iavf_status_code iavf_validate_mac_addr(u8 *mac_addr)
929 {
930 enum iavf_status_code status = IAVF_SUCCESS;
931
932 DEBUGFUNC("iavf_validate_mac_addr");
933
934 /* Broadcast addresses ARE multicast addresses
935 * Make sure it is not a multicast address
936 * Reject the zero address
937 */
938 if (IAVF_IS_MULTICAST(mac_addr) ||
939 (mac_addr[0] == 0 && mac_addr[1] == 0 && mac_addr[2] == 0 &&
940 mac_addr[3] == 0 && mac_addr[4] == 0 && mac_addr[5] == 0))
941 status = IAVF_ERR_INVALID_MAC_ADDR;
942
943 return status;
944 }
945
946 /**
947 * iavf_aq_rx_ctl_read_register - use FW to read from an Rx control register
948 * @hw: pointer to the hw struct
949 * @reg_addr: register address
950 * @reg_val: ptr to register value
951 * @cmd_details: pointer to command details structure or NULL
952 *
953 * Use the firmware to read the Rx control register,
954 * especially useful if the Rx unit is under heavy pressure
955 **/
956 enum iavf_status_code iavf_aq_rx_ctl_read_register(struct iavf_hw *hw,
957 u32 reg_addr, u32 *reg_val,
958 struct iavf_asq_cmd_details *cmd_details)
959 {
960 struct iavf_aq_desc desc;
961 struct iavf_aqc_rx_ctl_reg_read_write *cmd_resp =
962 (struct iavf_aqc_rx_ctl_reg_read_write *)&desc.params.raw;
963 enum iavf_status_code status;
964
965 if (reg_val == NULL)
966 return IAVF_ERR_PARAM;
967
968 iavf_fill_default_direct_cmd_desc(&desc, iavf_aqc_opc_rx_ctl_reg_read);
969
970 cmd_resp->address = CPU_TO_LE32(reg_addr);
971
972 status = iavf_asq_send_command(hw, &desc, NULL, 0, cmd_details);
973
974 if (status == IAVF_SUCCESS)
975 *reg_val = LE32_TO_CPU(cmd_resp->value);
976
977 return status;
978 }
979
980 /**
981 * iavf_read_rx_ctl - read from an Rx control register
982 * @hw: pointer to the hw struct
983 * @reg_addr: register address
984 **/
985 u32 iavf_read_rx_ctl(struct iavf_hw *hw, u32 reg_addr)
986 {
987 enum iavf_status_code status = IAVF_SUCCESS;
988 bool use_register;
989 int retry = 5;
990 u32 val = 0;
991
992 use_register = (((hw->aq.api_maj_ver == 1) &&
993 (hw->aq.api_min_ver < 5)) ||
994 (hw->mac.type == IAVF_MAC_X722));
995 if (!use_register) {
996 do_retry:
997 status = iavf_aq_rx_ctl_read_register(hw, reg_addr, &val, NULL);
998 if (hw->aq.asq_last_status == IAVF_AQ_RC_EAGAIN && retry) {
999 iavf_msec_delay(1);
1000 retry--;
1001 goto do_retry;
1002 }
1003 }
1004
1005 /* if the AQ access failed, try the old-fashioned way */
1006 if (status || use_register)
1007 val = rd32(hw, reg_addr);
1008
1009 return val;
1010 }
1011
1012 /**
1013 * iavf_aq_rx_ctl_write_register
1014 * @hw: pointer to the hw struct
1015 * @reg_addr: register address
1016 * @reg_val: register value
1017 * @cmd_details: pointer to command details structure or NULL
1018 *
1019 * Use the firmware to write to an Rx control register,
1020 * especially useful if the Rx unit is under heavy pressure
1021 **/
1022 enum iavf_status_code iavf_aq_rx_ctl_write_register(struct iavf_hw *hw,
1023 u32 reg_addr, u32 reg_val,
1024 struct iavf_asq_cmd_details *cmd_details)
1025 {
1026 struct iavf_aq_desc desc;
1027 struct iavf_aqc_rx_ctl_reg_read_write *cmd =
1028 (struct iavf_aqc_rx_ctl_reg_read_write *)&desc.params.raw;
1029 enum iavf_status_code status;
1030
1031 iavf_fill_default_direct_cmd_desc(&desc, iavf_aqc_opc_rx_ctl_reg_write);
1032
1033 cmd->address = CPU_TO_LE32(reg_addr);
1034 cmd->value = CPU_TO_LE32(reg_val);
1035
1036 status = iavf_asq_send_command(hw, &desc, NULL, 0, cmd_details);
1037
1038 return status;
1039 }
1040
1041 /**
1042 * iavf_write_rx_ctl - write to an Rx control register
1043 * @hw: pointer to the hw struct
1044 * @reg_addr: register address
1045 * @reg_val: register value
1046 **/
1047 void iavf_write_rx_ctl(struct iavf_hw *hw, u32 reg_addr, u32 reg_val)
1048 {
1049 enum iavf_status_code status = IAVF_SUCCESS;
1050 bool use_register;
1051 int retry = 5;
1052
1053 use_register = (((hw->aq.api_maj_ver == 1) &&
1054 (hw->aq.api_min_ver < 5)) ||
1055 (hw->mac.type == IAVF_MAC_X722));
1056 if (!use_register) {
1057 do_retry:
1058 status = iavf_aq_rx_ctl_write_register(hw, reg_addr,
1059 reg_val, NULL);
1060 if (hw->aq.asq_last_status == IAVF_AQ_RC_EAGAIN && retry) {
1061 iavf_msec_delay(1);
1062 retry--;
1063 goto do_retry;
1064 }
1065 }
1066
1067 /* if the AQ access failed, try the old-fashioned way */
1068 if (status || use_register)
1069 wr32(hw, reg_addr, reg_val);
1070 }
1071
1072 /**
1073 * iavf_aq_set_phy_register
1074 * @hw: pointer to the hw struct
1075 * @phy_select: select which phy should be accessed
1076 * @dev_addr: PHY device address
1077 * @reg_addr: PHY register address
1078 * @reg_val: new register value
1079 * @cmd_details: pointer to command details structure or NULL
1080 *
1081 * Write the external PHY register.
1082 **/
1083 enum iavf_status_code iavf_aq_set_phy_register(struct iavf_hw *hw,
1084 u8 phy_select, u8 dev_addr,
1085 u32 reg_addr, u32 reg_val,
1086 struct iavf_asq_cmd_details *cmd_details)
1087 {
1088 struct iavf_aq_desc desc;
1089 struct iavf_aqc_phy_register_access *cmd =
1090 (struct iavf_aqc_phy_register_access *)&desc.params.raw;
1091 enum iavf_status_code status;
1092
1093 iavf_fill_default_direct_cmd_desc(&desc,
1094 iavf_aqc_opc_set_phy_register);
1095
1096 cmd->phy_interface = phy_select;
1097 cmd->dev_addres = dev_addr;
1098 cmd->reg_address = CPU_TO_LE32(reg_addr);
1099 cmd->reg_value = CPU_TO_LE32(reg_val);
1100
1101 status = iavf_asq_send_command(hw, &desc, NULL, 0, cmd_details);
1102
1103 return status;
1104 }
1105
1106 /**
1107 * iavf_aq_get_phy_register
1108 * @hw: pointer to the hw struct
1109 * @phy_select: select which phy should be accessed
1110 * @dev_addr: PHY device address
1111 * @reg_addr: PHY register address
1112 * @reg_val: read register value
1113 * @cmd_details: pointer to command details structure or NULL
1114 *
1115 * Read the external PHY register.
1116 **/
1117 enum iavf_status_code iavf_aq_get_phy_register(struct iavf_hw *hw,
1118 u8 phy_select, u8 dev_addr,
1119 u32 reg_addr, u32 *reg_val,
1120 struct iavf_asq_cmd_details *cmd_details)
1121 {
1122 struct iavf_aq_desc desc;
1123 struct iavf_aqc_phy_register_access *cmd =
1124 (struct iavf_aqc_phy_register_access *)&desc.params.raw;
1125 enum iavf_status_code status;
1126
1127 iavf_fill_default_direct_cmd_desc(&desc,
1128 iavf_aqc_opc_get_phy_register);
1129
1130 cmd->phy_interface = phy_select;
1131 cmd->dev_addres = dev_addr;
1132 cmd->reg_address = CPU_TO_LE32(reg_addr);
1133
1134 status = iavf_asq_send_command(hw, &desc, NULL, 0, cmd_details);
1135 if (!status)
1136 *reg_val = LE32_TO_CPU(cmd->reg_value);
1137
1138 return status;
1139 }
1140
1141
1142 /**
1143 * iavf_aq_send_msg_to_pf
1144 * @hw: pointer to the hardware structure
1145 * @v_opcode: opcodes for VF-PF communication
1146 * @v_retval: return error code
1147 * @msg: pointer to the msg buffer
1148 * @msglen: msg length
1149 * @cmd_details: pointer to command details
1150 *
1151 * Send message to PF driver using admin queue. By default, this message
1152 * is sent asynchronously, i.e. iavf_asq_send_command() does not wait for
1153 * completion before returning.
1154 **/
1155 enum iavf_status_code iavf_aq_send_msg_to_pf(struct iavf_hw *hw,
1156 enum virtchnl_ops v_opcode,
1157 enum iavf_status_code v_retval,
1158 u8 *msg, u16 msglen,
1159 struct iavf_asq_cmd_details *cmd_details)
1160 {
1161 struct iavf_aq_desc desc;
1162 struct iavf_asq_cmd_details details;
1163 enum iavf_status_code status;
1164
1165 iavf_fill_default_direct_cmd_desc(&desc, iavf_aqc_opc_send_msg_to_pf);
1166 desc.flags |= CPU_TO_LE16((u16)IAVF_AQ_FLAG_SI);
1167 desc.cookie_high = CPU_TO_LE32(v_opcode);
1168 desc.cookie_low = CPU_TO_LE32(v_retval);
1169 if (msglen) {
1170 desc.flags |= CPU_TO_LE16((u16)(IAVF_AQ_FLAG_BUF
1171 | IAVF_AQ_FLAG_RD));
1172 if (msglen > IAVF_AQ_LARGE_BUF)
1173 desc.flags |= CPU_TO_LE16((u16)IAVF_AQ_FLAG_LB);
1174 desc.datalen = CPU_TO_LE16(msglen);
1175 }
1176 if (!cmd_details) {
1177 iavf_memset(&details, 0, sizeof(details), IAVF_NONDMA_MEM);
1178 details.async = true;
1179 cmd_details = &details;
1180 }
1181 status = iavf_asq_send_command(hw, (struct iavf_aq_desc *)&desc, msg,
1182 msglen, cmd_details);
1183 return status;
1184 }
1185
1186 /**
1187 * iavf_parse_hw_config
1188 * @hw: pointer to the hardware structure
1189 * @msg: pointer to the virtual channel VF resource structure
1190 *
1191 * Given a VF resource message from the PF, populate the hw struct
1192 * with appropriate information.
1193 **/
1194 void iavf_parse_hw_config(struct iavf_hw *hw,
1195 struct virtchnl_vf_resource *msg)
1196 {
1197 struct virtchnl_vsi_resource *vsi_res;
1198 int i;
1199
1200 vsi_res = &msg->vsi_res[0];
1201
1202 hw->dev_caps.num_vsis = msg->num_vsis;
1203 hw->dev_caps.num_rx_qp = msg->num_queue_pairs;
1204 hw->dev_caps.num_tx_qp = msg->num_queue_pairs;
1205 hw->dev_caps.num_msix_vectors_vf = msg->max_vectors;
1206 hw->dev_caps.dcb = msg->vf_cap_flags &
1207 VIRTCHNL_VF_OFFLOAD_L2;
1208 hw->dev_caps.iwarp = (msg->vf_cap_flags &
1209 VIRTCHNL_VF_OFFLOAD_IWARP) ? 1 : 0;
1210 for (i = 0; i < msg->num_vsis; i++) {
1211 if (vsi_res->vsi_type == VIRTCHNL_VSI_SRIOV) {
1212 iavf_memcpy(hw->mac.perm_addr,
1213 vsi_res->default_mac_addr,
1214 ETH_ALEN,
1215 IAVF_NONDMA_TO_NONDMA);
1216 iavf_memcpy(hw->mac.addr, vsi_res->default_mac_addr,
1217 ETH_ALEN,
1218 IAVF_NONDMA_TO_NONDMA);
1219 }
1220 vsi_res++;
1221 }
1222 }
1223
1224 /**
1225 * iavf_reset
1226 * @hw: pointer to the hardware structure
1227 *
1228 * Send a VF_RESET message to the PF. Does not wait for response from PF
1229 * as none will be forthcoming. Immediately after calling this function,
1230 * the admin queue should be shut down and (optionally) reinitialized.
1231 **/
1232 enum iavf_status_code iavf_reset(struct iavf_hw *hw)
1233 {
1234 return iavf_aq_send_msg_to_pf(hw, VIRTCHNL_OP_RESET_VF,
1235 IAVF_SUCCESS, NULL, 0, NULL);
1236 }
1237
1238 /**
1239 * iavf_aq_set_arp_proxy_config
1240 * @hw: pointer to the HW structure
1241 * @proxy_config: pointer to proxy config command table struct
1242 * @cmd_details: pointer to command details
1243 *
1244 * Set ARP offload parameters from pre-populated
1245 * iavf_aqc_arp_proxy_data struct
1246 **/
1247 enum iavf_status_code iavf_aq_set_arp_proxy_config(struct iavf_hw *hw,
1248 struct iavf_aqc_arp_proxy_data *proxy_config,
1249 struct iavf_asq_cmd_details *cmd_details)
1250 {
1251 struct iavf_aq_desc desc;
1252 enum iavf_status_code status;
1253
1254 if (!proxy_config)
1255 return IAVF_ERR_PARAM;
1256
1257 iavf_fill_default_direct_cmd_desc(&desc, iavf_aqc_opc_set_proxy_config);
1258
1259 desc.flags |= CPU_TO_LE16((u16)IAVF_AQ_FLAG_BUF);
1260 desc.flags |= CPU_TO_LE16((u16)IAVF_AQ_FLAG_RD);
1261 desc.params.external.addr_high =
1262 CPU_TO_LE32(IAVF_HI_DWORD((u64)proxy_config));
1263 desc.params.external.addr_low =
1264 CPU_TO_LE32(IAVF_LO_DWORD((u64)proxy_config));
1265 desc.datalen = CPU_TO_LE16(sizeof(struct iavf_aqc_arp_proxy_data));
1266
1267 status = iavf_asq_send_command(hw, &desc, proxy_config,
1268 sizeof(struct iavf_aqc_arp_proxy_data),
1269 cmd_details);
1270
1271 return status;
1272 }
1273
1274 /**
1275 * iavf_aq_opc_set_ns_proxy_table_entry
1276 * @hw: pointer to the HW structure
1277 * @ns_proxy_table_entry: pointer to NS table entry command struct
1278 * @cmd_details: pointer to command details
1279 *
1280 * Set IPv6 Neighbor Solicitation (NS) protocol offload parameters
1281 * from pre-populated iavf_aqc_ns_proxy_data struct
1282 **/
1283 enum iavf_status_code iavf_aq_set_ns_proxy_table_entry(struct iavf_hw *hw,
1284 struct iavf_aqc_ns_proxy_data *ns_proxy_table_entry,
1285 struct iavf_asq_cmd_details *cmd_details)
1286 {
1287 struct iavf_aq_desc desc;
1288 enum iavf_status_code status;
1289
1290 if (!ns_proxy_table_entry)
1291 return IAVF_ERR_PARAM;
1292
1293 iavf_fill_default_direct_cmd_desc(&desc,
1294 iavf_aqc_opc_set_ns_proxy_table_entry);
1295
1296 desc.flags |= CPU_TO_LE16((u16)IAVF_AQ_FLAG_BUF);
1297 desc.flags |= CPU_TO_LE16((u16)IAVF_AQ_FLAG_RD);
1298 desc.params.external.addr_high =
1299 CPU_TO_LE32(IAVF_HI_DWORD((u64)ns_proxy_table_entry));
1300 desc.params.external.addr_low =
1301 CPU_TO_LE32(IAVF_LO_DWORD((u64)ns_proxy_table_entry));
1302 desc.datalen = CPU_TO_LE16(sizeof(struct iavf_aqc_ns_proxy_data));
1303
1304 status = iavf_asq_send_command(hw, &desc, ns_proxy_table_entry,
1305 sizeof(struct iavf_aqc_ns_proxy_data),
1306 cmd_details);
1307
1308 return status;
1309 }
1310
1311 /**
1312 * iavf_aq_set_clear_wol_filter
1313 * @hw: pointer to the hw struct
1314 * @filter_index: index of filter to modify (0-7)
1315 * @filter: buffer containing filter to be set
1316 * @set_filter: true to set filter, false to clear filter
1317 * @no_wol_tco: if true, pass through packets cannot cause wake-up
1318 * if false, pass through packets may cause wake-up
1319 * @filter_valid: true if filter action is valid
1320 * @no_wol_tco_valid: true if no WoL in TCO traffic action valid
1321 * @cmd_details: pointer to command details structure or NULL
1322 *
1323 * Set or clear WoL filter for port attached to the PF
1324 **/
1325 enum iavf_status_code iavf_aq_set_clear_wol_filter(struct iavf_hw *hw,
1326 u8 filter_index,
1327 struct iavf_aqc_set_wol_filter_data *filter,
1328 bool set_filter, bool no_wol_tco,
1329 bool filter_valid, bool no_wol_tco_valid,
1330 struct iavf_asq_cmd_details *cmd_details)
1331 {
1332 struct iavf_aq_desc desc;
1333 struct iavf_aqc_set_wol_filter *cmd =
1334 (struct iavf_aqc_set_wol_filter *)&desc.params.raw;
1335 enum iavf_status_code status;
1336 u16 cmd_flags = 0;
1337 u16 valid_flags = 0;
1338 u16 buff_len = 0;
1339
1340 iavf_fill_default_direct_cmd_desc(&desc, iavf_aqc_opc_set_wol_filter);
1341
1342 if (filter_index >= IAVF_AQC_MAX_NUM_WOL_FILTERS)
1343 return IAVF_ERR_PARAM;
1344 cmd->filter_index = CPU_TO_LE16(filter_index);
1345
1346 if (set_filter) {
1347 if (!filter)
1348 return IAVF_ERR_PARAM;
1349
1350 cmd_flags |= IAVF_AQC_SET_WOL_FILTER;
1351 cmd_flags |= IAVF_AQC_SET_WOL_FILTER_WOL_PRESERVE_ON_PFR;
1352 }
1353
1354 if (no_wol_tco)
1355 cmd_flags |= IAVF_AQC_SET_WOL_FILTER_NO_TCO_WOL;
1356 cmd->cmd_flags = CPU_TO_LE16(cmd_flags);
1357
1358 if (filter_valid)
1359 valid_flags |= IAVF_AQC_SET_WOL_FILTER_ACTION_VALID;
1360 if (no_wol_tco_valid)
1361 valid_flags |= IAVF_AQC_SET_WOL_FILTER_NO_TCO_ACTION_VALID;
1362 cmd->valid_flags = CPU_TO_LE16(valid_flags);
1363
1364 buff_len = sizeof(*filter);
1365 desc.datalen = CPU_TO_LE16(buff_len);
1366
1367 desc.flags |= CPU_TO_LE16((u16)IAVF_AQ_FLAG_BUF);
1368 desc.flags |= CPU_TO_LE16((u16)IAVF_AQ_FLAG_RD);
1369
1370 cmd->address_high = CPU_TO_LE32(IAVF_HI_DWORD((u64)filter));
1371 cmd->address_low = CPU_TO_LE32(IAVF_LO_DWORD((u64)filter));
1372
1373 status = iavf_asq_send_command(hw, &desc, filter,
1374 buff_len, cmd_details);
1375
1376 return status;
1377 }
1378
1379 /**
1380 * iavf_aq_get_wake_event_reason
1381 * @hw: pointer to the hw struct
1382 * @wake_reason: return value, index of matching filter
1383 * @cmd_details: pointer to command details structure or NULL
1384 *
1385 * Get information for the reason of a Wake Up event
1386 **/
1387 enum iavf_status_code iavf_aq_get_wake_event_reason(struct iavf_hw *hw,
1388 u16 *wake_reason,
1389 struct iavf_asq_cmd_details *cmd_details)
1390 {
1391 struct iavf_aq_desc desc;
1392 struct iavf_aqc_get_wake_reason_completion *resp =
1393 (struct iavf_aqc_get_wake_reason_completion *)&desc.params.raw;
1394 enum iavf_status_code status;
1395
1396 iavf_fill_default_direct_cmd_desc(&desc, iavf_aqc_opc_get_wake_reason);
1397
1398 status = iavf_asq_send_command(hw, &desc, NULL, 0, cmd_details);
1399
1400 if (status == IAVF_SUCCESS)
1401 *wake_reason = LE16_TO_CPU(resp->wake_reason);
1402
1403 return status;
1404 }
1405
1406 /**
1407 * iavf_aq_clear_all_wol_filters
1408 * @hw: pointer to the hw struct
1409 * @cmd_details: pointer to command details structure or NULL
1410 *
1411 * Get information for the reason of a Wake Up event
1412 **/
1413 enum iavf_status_code iavf_aq_clear_all_wol_filters(struct iavf_hw *hw,
1414 struct iavf_asq_cmd_details *cmd_details)
1415 {
1416 struct iavf_aq_desc desc;
1417 enum iavf_status_code status;
1418
1419 iavf_fill_default_direct_cmd_desc(&desc,
1420 iavf_aqc_opc_clear_all_wol_filters);
1421
1422 status = iavf_asq_send_command(hw, &desc, NULL, 0, cmd_details);
1423
1424 return status;
1425 }
1426
1427 /**
1428 * iavf_aq_write_ddp - Write dynamic device personalization (ddp)
1429 * @hw: pointer to the hw struct
1430 * @buff: command buffer (size in bytes = buff_size)
1431 * @buff_size: buffer size in bytes
1432 * @track_id: package tracking id
1433 * @error_offset: returns error offset
1434 * @error_info: returns error information
1435 * @cmd_details: pointer to command details structure or NULL
1436 **/
1437 enum
1438 iavf_status_code iavf_aq_write_ddp(struct iavf_hw *hw, void *buff,
1439 u16 buff_size, u32 track_id,
1440 u32 *error_offset, u32 *error_info,
1441 struct iavf_asq_cmd_details *cmd_details)
1442 {
1443 struct iavf_aq_desc desc;
1444 struct iavf_aqc_write_personalization_profile *cmd =
1445 (struct iavf_aqc_write_personalization_profile *)
1446 &desc.params.raw;
1447 struct iavf_aqc_write_ddp_resp *resp;
1448 enum iavf_status_code status;
1449
1450 iavf_fill_default_direct_cmd_desc(&desc,
1451 iavf_aqc_opc_write_personalization_profile);
1452
1453 desc.flags |= CPU_TO_LE16(IAVF_AQ_FLAG_BUF | IAVF_AQ_FLAG_RD);
1454 if (buff_size > IAVF_AQ_LARGE_BUF)
1455 desc.flags |= CPU_TO_LE16((u16)IAVF_AQ_FLAG_LB);
1456
1457 desc.datalen = CPU_TO_LE16(buff_size);
1458
1459 cmd->profile_track_id = CPU_TO_LE32(track_id);
1460
1461 status = iavf_asq_send_command(hw, &desc, buff, buff_size, cmd_details);
1462 if (!status) {
1463 resp = (struct iavf_aqc_write_ddp_resp *)&desc.params.raw;
1464 if (error_offset)
1465 *error_offset = LE32_TO_CPU(resp->error_offset);
1466 if (error_info)
1467 *error_info = LE32_TO_CPU(resp->error_info);
1468 }
1469
1470 return status;
1471 }
1472
1473 /**
1474 * iavf_aq_get_ddp_list - Read dynamic device personalization (ddp)
1475 * @hw: pointer to the hw struct
1476 * @buff: command buffer (size in bytes = buff_size)
1477 * @buff_size: buffer size in bytes
1478 * @flags: AdminQ command flags
1479 * @cmd_details: pointer to command details structure or NULL
1480 **/
1481 enum
1482 iavf_status_code iavf_aq_get_ddp_list(struct iavf_hw *hw, void *buff,
1483 u16 buff_size, u8 flags,
1484 struct iavf_asq_cmd_details *cmd_details)
1485 {
1486 struct iavf_aq_desc desc;
1487 struct iavf_aqc_get_applied_profiles *cmd =
1488 (struct iavf_aqc_get_applied_profiles *)&desc.params.raw;
1489 enum iavf_status_code status;
1490
1491 iavf_fill_default_direct_cmd_desc(&desc,
1492 iavf_aqc_opc_get_personalization_profile_list);
1493
1494 desc.flags |= CPU_TO_LE16((u16)IAVF_AQ_FLAG_BUF);
1495 if (buff_size > IAVF_AQ_LARGE_BUF)
1496 desc.flags |= CPU_TO_LE16((u16)IAVF_AQ_FLAG_LB);
1497 desc.datalen = CPU_TO_LE16(buff_size);
1498
1499 cmd->flags = flags;
1500
1501 status = iavf_asq_send_command(hw, &desc, buff, buff_size, cmd_details);
1502
1503 return status;
1504 }
1505
1506 /**
1507 * iavf_find_segment_in_package
1508 * @segment_type: the segment type to search for (i.e., SEGMENT_TYPE_IAVF)
1509 * @pkg_hdr: pointer to the package header to be searched
1510 *
1511 * This function searches a package file for a particular segment type. On
1512 * success it returns a pointer to the segment header, otherwise it will
1513 * return NULL.
1514 **/
1515 struct iavf_generic_seg_header *
1516 iavf_find_segment_in_package(u32 segment_type,
1517 struct iavf_package_header *pkg_hdr)
1518 {
1519 struct iavf_generic_seg_header *segment;
1520 u32 i;
1521
1522 /* Search all package segments for the requested segment type */
1523 for (i = 0; i < pkg_hdr->segment_count; i++) {
1524 segment =
1525 (struct iavf_generic_seg_header *)((u8 *)pkg_hdr +
1526 pkg_hdr->segment_offset[i]);
1527
1528 if (segment->type == segment_type)
1529 return segment;
1530 }
1531
1532 return NULL;
1533 }
1534
1535 /* Get section table in profile */
1536 #define IAVF_SECTION_TABLE(profile, sec_tbl) \
1537 do { \
1538 struct iavf_profile_segment *p = (profile); \
1539 u32 count; \
1540 u32 *nvm; \
1541 count = p->device_table_count; \
1542 nvm = (u32 *)&p->device_table[count]; \
1543 sec_tbl = (struct iavf_section_table *)&nvm[nvm[0] + 1]; \
1544 } while (0)
1545
1546 /* Get section header in profile */
1547 #define IAVF_SECTION_HEADER(profile, offset) \
1548 (struct iavf_profile_section_header *)((u8 *)(profile) + (offset))
1549
1550 /**
1551 * iavf_find_section_in_profile
1552 * @section_type: the section type to search for (i.e., SECTION_TYPE_NOTE)
1553 * @profile: pointer to the iavf segment header to be searched
1554 *
1555 * This function searches iavf segment for a particular section type. On
1556 * success it returns a pointer to the section header, otherwise it will
1557 * return NULL.
1558 **/
1559 struct iavf_profile_section_header *
1560 iavf_find_section_in_profile(u32 section_type,
1561 struct iavf_profile_segment *profile)
1562 {
1563 struct iavf_profile_section_header *sec;
1564 struct iavf_section_table *sec_tbl;
1565 u32 sec_off;
1566 u32 i;
1567
1568 if (profile->header.type != SEGMENT_TYPE_IAVF)
1569 return NULL;
1570
1571 IAVF_SECTION_TABLE(profile, sec_tbl);
1572
1573 for (i = 0; i < sec_tbl->section_count; i++) {
1574 sec_off = sec_tbl->section_offset[i];
1575 sec = IAVF_SECTION_HEADER(profile, sec_off);
1576 if (sec->section.type == section_type)
1577 return sec;
1578 }
1579
1580 return NULL;
1581 }
1582
1583 /**
1584 * iavf_ddp_exec_aq_section - Execute generic AQ for DDP
1585 * @hw: pointer to the hw struct
1586 * @aq: command buffer containing all data to execute AQ
1587 **/
1588 STATIC enum
1589 iavf_status_code iavf_ddp_exec_aq_section(struct iavf_hw *hw,
1590 struct iavf_profile_aq_section *aq)
1591 {
1592 enum iavf_status_code status;
1593 struct iavf_aq_desc desc;
1594 u8 *msg = NULL;
1595 u16 msglen;
1596
1597 iavf_fill_default_direct_cmd_desc(&desc, aq->opcode);
1598 desc.flags |= CPU_TO_LE16(aq->flags);
1599 iavf_memcpy(desc.params.raw, aq->param, sizeof(desc.params.raw),
1600 IAVF_NONDMA_TO_NONDMA);
1601
1602 msglen = aq->datalen;
1603 if (msglen) {
1604 desc.flags |= CPU_TO_LE16((u16)(IAVF_AQ_FLAG_BUF |
1605 IAVF_AQ_FLAG_RD));
1606 if (msglen > IAVF_AQ_LARGE_BUF)
1607 desc.flags |= CPU_TO_LE16((u16)IAVF_AQ_FLAG_LB);
1608 desc.datalen = CPU_TO_LE16(msglen);
1609 msg = &aq->data[0];
1610 }
1611
1612 status = iavf_asq_send_command(hw, &desc, msg, msglen, NULL);
1613
1614 if (status != IAVF_SUCCESS) {
1615 iavf_debug(hw, IAVF_DEBUG_PACKAGE,
1616 "unable to exec DDP AQ opcode %u, error %d\n",
1617 aq->opcode, status);
1618 return status;
1619 }
1620
1621 /* copy returned desc to aq_buf */
1622 iavf_memcpy(aq->param, desc.params.raw, sizeof(desc.params.raw),
1623 IAVF_NONDMA_TO_NONDMA);
1624
1625 return IAVF_SUCCESS;
1626 }
1627
1628 /**
1629 * iavf_validate_profile
1630 * @hw: pointer to the hardware structure
1631 * @profile: pointer to the profile segment of the package to be validated
1632 * @track_id: package tracking id
1633 * @rollback: flag if the profile is for rollback.
1634 *
1635 * Validates supported devices and profile's sections.
1636 */
1637 STATIC enum iavf_status_code
1638 iavf_validate_profile(struct iavf_hw *hw, struct iavf_profile_segment *profile,
1639 u32 track_id, bool rollback)
1640 {
1641 struct iavf_profile_section_header *sec = NULL;
1642 enum iavf_status_code status = IAVF_SUCCESS;
1643 struct iavf_section_table *sec_tbl;
1644 u32 vendor_dev_id;
1645 u32 dev_cnt;
1646 u32 sec_off;
1647 u32 i;
1648
1649 if (track_id == IAVF_DDP_TRACKID_INVALID) {
1650 iavf_debug(hw, IAVF_DEBUG_PACKAGE, "Invalid track_id\n");
1651 return IAVF_NOT_SUPPORTED;
1652 }
1653
1654 dev_cnt = profile->device_table_count;
1655 for (i = 0; i < dev_cnt; i++) {
1656 vendor_dev_id = profile->device_table[i].vendor_dev_id;
1657 if ((vendor_dev_id >> 16) == IAVF_INTEL_VENDOR_ID &&
1658 hw->device_id == (vendor_dev_id & 0xFFFF))
1659 break;
1660 }
1661 if (dev_cnt && (i == dev_cnt)) {
1662 iavf_debug(hw, IAVF_DEBUG_PACKAGE,
1663 "Device doesn't support DDP\n");
1664 return IAVF_ERR_DEVICE_NOT_SUPPORTED;
1665 }
1666
1667 IAVF_SECTION_TABLE(profile, sec_tbl);
1668
1669 /* Validate sections types */
1670 for (i = 0; i < sec_tbl->section_count; i++) {
1671 sec_off = sec_tbl->section_offset[i];
1672 sec = IAVF_SECTION_HEADER(profile, sec_off);
1673 if (rollback) {
1674 if (sec->section.type == SECTION_TYPE_MMIO ||
1675 sec->section.type == SECTION_TYPE_AQ ||
1676 sec->section.type == SECTION_TYPE_RB_AQ) {
1677 iavf_debug(hw, IAVF_DEBUG_PACKAGE,
1678 "Not a roll-back package\n");
1679 return IAVF_NOT_SUPPORTED;
1680 }
1681 } else {
1682 if (sec->section.type == SECTION_TYPE_RB_AQ ||
1683 sec->section.type == SECTION_TYPE_RB_MMIO) {
1684 iavf_debug(hw, IAVF_DEBUG_PACKAGE,
1685 "Not an original package\n");
1686 return IAVF_NOT_SUPPORTED;
1687 }
1688 }
1689 }
1690
1691 return status;
1692 }
1693
1694 /**
1695 * iavf_write_profile
1696 * @hw: pointer to the hardware structure
1697 * @profile: pointer to the profile segment of the package to be downloaded
1698 * @track_id: package tracking id
1699 *
1700 * Handles the download of a complete package.
1701 */
1702 enum iavf_status_code
1703 iavf_write_profile(struct iavf_hw *hw, struct iavf_profile_segment *profile,
1704 u32 track_id)
1705 {
1706 enum iavf_status_code status = IAVF_SUCCESS;
1707 struct iavf_section_table *sec_tbl;
1708 struct iavf_profile_section_header *sec = NULL;
1709 struct iavf_profile_aq_section *ddp_aq;
1710 u32 section_size = 0;
1711 u32 offset = 0, info = 0;
1712 u32 sec_off;
1713 u32 i;
1714
1715 status = iavf_validate_profile(hw, profile, track_id, false);
1716 if (status)
1717 return status;
1718
1719 IAVF_SECTION_TABLE(profile, sec_tbl);
1720
1721 for (i = 0; i < sec_tbl->section_count; i++) {
1722 sec_off = sec_tbl->section_offset[i];
1723 sec = IAVF_SECTION_HEADER(profile, sec_off);
1724 /* Process generic admin command */
1725 if (sec->section.type == SECTION_TYPE_AQ) {
1726 ddp_aq = (struct iavf_profile_aq_section *)&sec[1];
1727 status = iavf_ddp_exec_aq_section(hw, ddp_aq);
1728 if (status) {
1729 iavf_debug(hw, IAVF_DEBUG_PACKAGE,
1730 "Failed to execute aq: section %d, opcode %u\n",
1731 i, ddp_aq->opcode);
1732 break;
1733 }
1734 sec->section.type = SECTION_TYPE_RB_AQ;
1735 }
1736
1737 /* Skip any non-mmio sections */
1738 if (sec->section.type != SECTION_TYPE_MMIO)
1739 continue;
1740
1741 section_size = sec->section.size +
1742 sizeof(struct iavf_profile_section_header);
1743
1744 /* Write MMIO section */
1745 status = iavf_aq_write_ddp(hw, (void *)sec, (u16)section_size,
1746 track_id, &offset, &info, NULL);
1747 if (status) {
1748 iavf_debug(hw, IAVF_DEBUG_PACKAGE,
1749 "Failed to write profile: section %d, offset %d, info %d\n",
1750 i, offset, info);
1751 break;
1752 }
1753 }
1754 return status;
1755 }
1756
1757 /**
1758 * iavf_rollback_profile
1759 * @hw: pointer to the hardware structure
1760 * @profile: pointer to the profile segment of the package to be removed
1761 * @track_id: package tracking id
1762 *
1763 * Rolls back previously loaded package.
1764 */
1765 enum iavf_status_code
1766 iavf_rollback_profile(struct iavf_hw *hw, struct iavf_profile_segment *profile,
1767 u32 track_id)
1768 {
1769 struct iavf_profile_section_header *sec = NULL;
1770 enum iavf_status_code status = IAVF_SUCCESS;
1771 struct iavf_section_table *sec_tbl;
1772 u32 offset = 0, info = 0;
1773 u32 section_size = 0;
1774 u32 sec_off;
1775 int i;
1776
1777 status = iavf_validate_profile(hw, profile, track_id, true);
1778 if (status)
1779 return status;
1780
1781 IAVF_SECTION_TABLE(profile, sec_tbl);
1782
1783 /* For rollback write sections in reverse */
1784 for (i = sec_tbl->section_count - 1; i >= 0; i--) {
1785 sec_off = sec_tbl->section_offset[i];
1786 sec = IAVF_SECTION_HEADER(profile, sec_off);
1787
1788 /* Skip any non-rollback sections */
1789 if (sec->section.type != SECTION_TYPE_RB_MMIO)
1790 continue;
1791
1792 section_size = sec->section.size +
1793 sizeof(struct iavf_profile_section_header);
1794
1795 /* Write roll-back MMIO section */
1796 status = iavf_aq_write_ddp(hw, (void *)sec, (u16)section_size,
1797 track_id, &offset, &info, NULL);
1798 if (status) {
1799 iavf_debug(hw, IAVF_DEBUG_PACKAGE,
1800 "Failed to write profile: section %d, offset %d, info %d\n",
1801 i, offset, info);
1802 break;
1803 }
1804 }
1805 return status;
1806 }
1807
1808 /**
1809 * iavf_add_pinfo_to_list
1810 * @hw: pointer to the hardware structure
1811 * @profile: pointer to the profile segment of the package
1812 * @profile_info_sec: buffer for information section
1813 * @track_id: package tracking id
1814 *
1815 * Register a profile to the list of loaded profiles.
1816 */
1817 enum iavf_status_code
1818 iavf_add_pinfo_to_list(struct iavf_hw *hw,
1819 struct iavf_profile_segment *profile,
1820 u8 *profile_info_sec, u32 track_id)
1821 {
1822 enum iavf_status_code status = IAVF_SUCCESS;
1823 struct iavf_profile_section_header *sec = NULL;
1824 struct iavf_profile_info *pinfo;
1825 u32 offset = 0, info = 0;
1826
1827 sec = (struct iavf_profile_section_header *)profile_info_sec;
1828 sec->tbl_size = 1;
1829 sec->data_end = sizeof(struct iavf_profile_section_header) +
1830 sizeof(struct iavf_profile_info);
1831 sec->section.type = SECTION_TYPE_INFO;
1832 sec->section.offset = sizeof(struct iavf_profile_section_header);
1833 sec->section.size = sizeof(struct iavf_profile_info);
1834 pinfo = (struct iavf_profile_info *)(profile_info_sec +
1835 sec->section.offset);
1836 pinfo->track_id = track_id;
1837 pinfo->version = profile->version;
1838 pinfo->op = IAVF_DDP_ADD_TRACKID;
1839 iavf_memcpy(pinfo->name, profile->name, IAVF_DDP_NAME_SIZE,
1840 IAVF_NONDMA_TO_NONDMA);
1841
1842 status = iavf_aq_write_ddp(hw, (void *)sec, sec->data_end,
1843 track_id, &offset, &info, NULL);
1844 return status;
1845 }
Ceph