1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2018, Intel Corporation. */
3 
4 #include "ice.h"
5 #include "ice_base.h"
6 #include "ice_flow.h"
7 #include "ice_lib.h"
8 #include "ice_fltr.h"
9 #include "ice_dcb_lib.h"
10 #include "ice_devlink.h"
11 #include "ice_vsi_vlan_ops.h"
12 
13 /**
14  * ice_vsi_type_str - maps VSI type enum to string equivalents
15  * @vsi_type: VSI type enum
16  */
17 const char *ice_vsi_type_str(enum ice_vsi_type vsi_type)
18 {
19 	switch (vsi_type) {
20 	case ICE_VSI_PF:
21 		return "ICE_VSI_PF";
22 	case ICE_VSI_VF:
23 		return "ICE_VSI_VF";
24 	case ICE_VSI_CTRL:
25 		return "ICE_VSI_CTRL";
26 	case ICE_VSI_CHNL:
27 		return "ICE_VSI_CHNL";
28 	case ICE_VSI_LB:
29 		return "ICE_VSI_LB";
30 	case ICE_VSI_SWITCHDEV_CTRL:
31 		return "ICE_VSI_SWITCHDEV_CTRL";
32 	default:
33 		return "unknown";
34 	}
35 }
36 
37 /**
38  * ice_vsi_ctrl_all_rx_rings - Start or stop a VSI's Rx rings
39  * @vsi: the VSI being configured
40  * @ena: start or stop the Rx rings
41  *
42  * First enable/disable all of the Rx rings, flush any remaining writes, and
43  * then verify that they have all been enabled/disabled successfully. This will
44  * let all of the register writes complete when enabling/disabling the Rx rings
45  * before waiting for the change in hardware to complete.
46  */
47 static int ice_vsi_ctrl_all_rx_rings(struct ice_vsi *vsi, bool ena)
48 {
49 	int ret = 0;
50 	u16 i;
51 
52 	ice_for_each_rxq(vsi, i)
53 		ice_vsi_ctrl_one_rx_ring(vsi, ena, i, false);
54 
55 	ice_flush(&vsi->back->hw);
56 
57 	ice_for_each_rxq(vsi, i) {
58 		ret = ice_vsi_wait_one_rx_ring(vsi, ena, i);
59 		if (ret)
60 			break;
61 	}
62 
63 	return ret;
64 }
65 
66 /**
67  * ice_vsi_alloc_arrays - Allocate queue and vector pointer arrays for the VSI
68  * @vsi: VSI pointer
69  *
70  * On error: returns error code (negative)
71  * On success: returns 0
72  */
73 static int ice_vsi_alloc_arrays(struct ice_vsi *vsi)
74 {
75 	struct ice_pf *pf = vsi->back;
76 	struct device *dev;
77 
78 	dev = ice_pf_to_dev(pf);
79 	if (vsi->type == ICE_VSI_CHNL)
80 		return 0;
81 
82 	/* allocate memory for both Tx and Rx ring pointers */
83 	vsi->tx_rings = devm_kcalloc(dev, vsi->alloc_txq,
84 				     sizeof(*vsi->tx_rings), GFP_KERNEL);
85 	if (!vsi->tx_rings)
86 		return -ENOMEM;
87 
88 	vsi->rx_rings = devm_kcalloc(dev, vsi->alloc_rxq,
89 				     sizeof(*vsi->rx_rings), GFP_KERNEL);
90 	if (!vsi->rx_rings)
91 		goto err_rings;
92 
93 	/* txq_map needs to have enough space to track both Tx (stack) rings
94 	 * and XDP rings; at this point vsi->num_xdp_txq might not be set,
95 	 * so use num_possible_cpus() as we want to always provide XDP ring
96 	 * per CPU, regardless of queue count settings from user that might
97 	 * have come from ethtool's set_channels() callback;
98 	 */
99 	vsi->txq_map = devm_kcalloc(dev, (vsi->alloc_txq + num_possible_cpus()),
100 				    sizeof(*vsi->txq_map), GFP_KERNEL);
101 
102 	if (!vsi->txq_map)
103 		goto err_txq_map;
104 
105 	vsi->rxq_map = devm_kcalloc(dev, vsi->alloc_rxq,
106 				    sizeof(*vsi->rxq_map), GFP_KERNEL);
107 	if (!vsi->rxq_map)
108 		goto err_rxq_map;
109 
110 	/* There is no need to allocate q_vectors for a loopback VSI. */
111 	if (vsi->type == ICE_VSI_LB)
112 		return 0;
113 
114 	/* allocate memory for q_vector pointers */
115 	vsi->q_vectors = devm_kcalloc(dev, vsi->num_q_vectors,
116 				      sizeof(*vsi->q_vectors), GFP_KERNEL);
117 	if (!vsi->q_vectors)
118 		goto err_vectors;
119 
120 	vsi->af_xdp_zc_qps = bitmap_zalloc(max_t(int, vsi->alloc_txq, vsi->alloc_rxq), GFP_KERNEL);
121 	if (!vsi->af_xdp_zc_qps)
122 		goto err_zc_qps;
123 
124 	return 0;
125 
126 err_zc_qps:
127 	devm_kfree(dev, vsi->q_vectors);
128 err_vectors:
129 	devm_kfree(dev, vsi->rxq_map);
130 err_rxq_map:
131 	devm_kfree(dev, vsi->txq_map);
132 err_txq_map:
133 	devm_kfree(dev, vsi->rx_rings);
134 err_rings:
135 	devm_kfree(dev, vsi->tx_rings);
136 	return -ENOMEM;
137 }
138 
139 /**
140  * ice_vsi_set_num_desc - Set number of descriptors for queues on this VSI
141  * @vsi: the VSI being configured
142  */
143 static void ice_vsi_set_num_desc(struct ice_vsi *vsi)
144 {
145 	switch (vsi->type) {
146 	case ICE_VSI_PF:
147 	case ICE_VSI_SWITCHDEV_CTRL:
148 	case ICE_VSI_CTRL:
149 	case ICE_VSI_LB:
150 		/* a user could change the values of num_[tr]x_desc using
151 		 * ethtool -G so we should keep those values instead of
152 		 * overwriting them with the defaults.
153 		 */
154 		if (!vsi->num_rx_desc)
155 			vsi->num_rx_desc = ICE_DFLT_NUM_RX_DESC;
156 		if (!vsi->num_tx_desc)
157 			vsi->num_tx_desc = ICE_DFLT_NUM_TX_DESC;
158 		break;
159 	default:
160 		dev_dbg(ice_pf_to_dev(vsi->back), "Not setting number of Tx/Rx descriptors for VSI type %d\n",
161 			vsi->type);
162 		break;
163 	}
164 }
165 
166 /**
167  * ice_vsi_set_num_qs - Set number of queues, descriptors and vectors for a VSI
168  * @vsi: the VSI being configured
169  * @vf: the VF associated with this VSI, if any
170  *
171  * Return 0 on success and a negative value on error
172  */
173 static void ice_vsi_set_num_qs(struct ice_vsi *vsi, struct ice_vf *vf)
174 {
175 	enum ice_vsi_type vsi_type = vsi->type;
176 	struct ice_pf *pf = vsi->back;
177 
178 	if (WARN_ON(vsi_type == ICE_VSI_VF && !vf))
179 		return;
180 
181 	switch (vsi_type) {
182 	case ICE_VSI_PF:
183 		if (vsi->req_txq) {
184 			vsi->alloc_txq = vsi->req_txq;
185 			vsi->num_txq = vsi->req_txq;
186 		} else {
187 			vsi->alloc_txq = min3(pf->num_lan_msix,
188 					      ice_get_avail_txq_count(pf),
189 					      (u16)num_online_cpus());
190 		}
191 
192 		pf->num_lan_tx = vsi->alloc_txq;
193 
194 		/* only 1 Rx queue unless RSS is enabled */
195 		if (!test_bit(ICE_FLAG_RSS_ENA, pf->flags)) {
196 			vsi->alloc_rxq = 1;
197 		} else {
198 			if (vsi->req_rxq) {
199 				vsi->alloc_rxq = vsi->req_rxq;
200 				vsi->num_rxq = vsi->req_rxq;
201 			} else {
202 				vsi->alloc_rxq = min3(pf->num_lan_msix,
203 						      ice_get_avail_rxq_count(pf),
204 						      (u16)num_online_cpus());
205 			}
206 		}
207 
208 		pf->num_lan_rx = vsi->alloc_rxq;
209 
210 		vsi->num_q_vectors = min_t(int, pf->num_lan_msix,
211 					   max_t(int, vsi->alloc_rxq,
212 						 vsi->alloc_txq));
213 		break;
214 	case ICE_VSI_SWITCHDEV_CTRL:
215 		/* The number of queues for ctrl VSI is equal to number of VFs.
216 		 * Each ring is associated to the corresponding VF_PR netdev.
217 		 */
218 		vsi->alloc_txq = ice_get_num_vfs(pf);
219 		vsi->alloc_rxq = vsi->alloc_txq;
220 		vsi->num_q_vectors = 1;
221 		break;
222 	case ICE_VSI_VF:
223 		if (vf->num_req_qs)
224 			vf->num_vf_qs = vf->num_req_qs;
225 		vsi->alloc_txq = vf->num_vf_qs;
226 		vsi->alloc_rxq = vf->num_vf_qs;
227 		/* pf->vfs.num_msix_per includes (VF miscellaneous vector +
228 		 * data queue interrupts). Since vsi->num_q_vectors is number
229 		 * of queues vectors, subtract 1 (ICE_NONQ_VECS_VF) from the
230 		 * original vector count
231 		 */
232 		vsi->num_q_vectors = pf->vfs.num_msix_per - ICE_NONQ_VECS_VF;
233 		break;
234 	case ICE_VSI_CTRL:
235 		vsi->alloc_txq = 1;
236 		vsi->alloc_rxq = 1;
237 		vsi->num_q_vectors = 1;
238 		break;
239 	case ICE_VSI_CHNL:
240 		vsi->alloc_txq = 0;
241 		vsi->alloc_rxq = 0;
242 		break;
243 	case ICE_VSI_LB:
244 		vsi->alloc_txq = 1;
245 		vsi->alloc_rxq = 1;
246 		break;
247 	default:
248 		dev_warn(ice_pf_to_dev(pf), "Unknown VSI type %d\n", vsi_type);
249 		break;
250 	}
251 
252 	ice_vsi_set_num_desc(vsi);
253 }
254 
255 /**
256  * ice_get_free_slot - get the next non-NULL location index in array
257  * @array: array to search
258  * @size: size of the array
259  * @curr: last known occupied index to be used as a search hint
260  *
261  * void * is being used to keep the functionality generic. This lets us use this
262  * function on any array of pointers.
263  */
264 static int ice_get_free_slot(void *array, int size, int curr)
265 {
266 	int **tmp_array = (int **)array;
267 	int next;
268 
269 	if (curr < (size - 1) && !tmp_array[curr + 1]) {
270 		next = curr + 1;
271 	} else {
272 		int i = 0;
273 
274 		while ((i < size) && (tmp_array[i]))
275 			i++;
276 		if (i == size)
277 			next = ICE_NO_VSI;
278 		else
279 			next = i;
280 	}
281 	return next;
282 }
283 
284 /**
285  * ice_vsi_delete - delete a VSI from the switch
286  * @vsi: pointer to VSI being removed
287  */
288 void ice_vsi_delete(struct ice_vsi *vsi)
289 {
290 	struct ice_pf *pf = vsi->back;
291 	struct ice_vsi_ctx *ctxt;
292 	int status;
293 
294 	ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
295 	if (!ctxt)
296 		return;
297 
298 	if (vsi->type == ICE_VSI_VF)
299 		ctxt->vf_num = vsi->vf->vf_id;
300 	ctxt->vsi_num = vsi->vsi_num;
301 
302 	memcpy(&ctxt->info, &vsi->info, sizeof(ctxt->info));
303 
304 	status = ice_free_vsi(&pf->hw, vsi->idx, ctxt, false, NULL);
305 	if (status)
306 		dev_err(ice_pf_to_dev(pf), "Failed to delete VSI %i in FW - error: %d\n",
307 			vsi->vsi_num, status);
308 
309 	kfree(ctxt);
310 }
311 
312 /**
313  * ice_vsi_free_arrays - De-allocate queue and vector pointer arrays for the VSI
314  * @vsi: pointer to VSI being cleared
315  */
316 static void ice_vsi_free_arrays(struct ice_vsi *vsi)
317 {
318 	struct ice_pf *pf = vsi->back;
319 	struct device *dev;
320 
321 	dev = ice_pf_to_dev(pf);
322 
323 	if (vsi->af_xdp_zc_qps) {
324 		bitmap_free(vsi->af_xdp_zc_qps);
325 		vsi->af_xdp_zc_qps = NULL;
326 	}
327 	/* free the ring and vector containers */
328 	if (vsi->q_vectors) {
329 		devm_kfree(dev, vsi->q_vectors);
330 		vsi->q_vectors = NULL;
331 	}
332 	if (vsi->tx_rings) {
333 		devm_kfree(dev, vsi->tx_rings);
334 		vsi->tx_rings = NULL;
335 	}
336 	if (vsi->rx_rings) {
337 		devm_kfree(dev, vsi->rx_rings);
338 		vsi->rx_rings = NULL;
339 	}
340 	if (vsi->txq_map) {
341 		devm_kfree(dev, vsi->txq_map);
342 		vsi->txq_map = NULL;
343 	}
344 	if (vsi->rxq_map) {
345 		devm_kfree(dev, vsi->rxq_map);
346 		vsi->rxq_map = NULL;
347 	}
348 }
349 
350 /**
351  * ice_vsi_clear - clean up and deallocate the provided VSI
352  * @vsi: pointer to VSI being cleared
353  *
354  * This deallocates the VSI's queue resources, removes it from the PF's
355  * VSI array if necessary, and deallocates the VSI
356  *
357  * Returns 0 on success, negative on failure
358  */
359 int ice_vsi_clear(struct ice_vsi *vsi)
360 {
361 	struct ice_pf *pf = NULL;
362 	struct device *dev;
363 
364 	if (!vsi)
365 		return 0;
366 
367 	if (!vsi->back)
368 		return -EINVAL;
369 
370 	pf = vsi->back;
371 	dev = ice_pf_to_dev(pf);
372 
373 	if (!pf->vsi[vsi->idx] || pf->vsi[vsi->idx] != vsi) {
374 		dev_dbg(dev, "vsi does not exist at pf->vsi[%d]\n", vsi->idx);
375 		return -EINVAL;
376 	}
377 
378 	mutex_lock(&pf->sw_mutex);
379 	/* updates the PF for this cleared VSI */
380 
381 	pf->vsi[vsi->idx] = NULL;
382 	if (vsi->idx < pf->next_vsi && vsi->type != ICE_VSI_CTRL)
383 		pf->next_vsi = vsi->idx;
384 	if (vsi->idx < pf->next_vsi && vsi->type == ICE_VSI_CTRL && vsi->vf)
385 		pf->next_vsi = vsi->idx;
386 
387 	ice_vsi_free_arrays(vsi);
388 	mutex_unlock(&pf->sw_mutex);
389 	devm_kfree(dev, vsi);
390 
391 	return 0;
392 }
393 
394 /**
395  * ice_msix_clean_ctrl_vsi - MSIX mode interrupt handler for ctrl VSI
396  * @irq: interrupt number
397  * @data: pointer to a q_vector
398  */
399 static irqreturn_t ice_msix_clean_ctrl_vsi(int __always_unused irq, void *data)
400 {
401 	struct ice_q_vector *q_vector = (struct ice_q_vector *)data;
402 
403 	if (!q_vector->tx.tx_ring)
404 		return IRQ_HANDLED;
405 
406 #define FDIR_RX_DESC_CLEAN_BUDGET 64
407 	ice_clean_rx_irq(q_vector->rx.rx_ring, FDIR_RX_DESC_CLEAN_BUDGET);
408 	ice_clean_ctrl_tx_irq(q_vector->tx.tx_ring);
409 
410 	return IRQ_HANDLED;
411 }
412 
413 /**
414  * ice_msix_clean_rings - MSIX mode Interrupt Handler
415  * @irq: interrupt number
416  * @data: pointer to a q_vector
417  */
418 static irqreturn_t ice_msix_clean_rings(int __always_unused irq, void *data)
419 {
420 	struct ice_q_vector *q_vector = (struct ice_q_vector *)data;
421 
422 	if (!q_vector->tx.tx_ring && !q_vector->rx.rx_ring)
423 		return IRQ_HANDLED;
424 
425 	q_vector->total_events++;
426 
427 	napi_schedule(&q_vector->napi);
428 
429 	return IRQ_HANDLED;
430 }
431 
432 static irqreturn_t ice_eswitch_msix_clean_rings(int __always_unused irq, void *data)
433 {
434 	struct ice_q_vector *q_vector = (struct ice_q_vector *)data;
435 	struct ice_pf *pf = q_vector->vsi->back;
436 	struct ice_vf *vf;
437 	unsigned int bkt;
438 
439 	if (!q_vector->tx.tx_ring && !q_vector->rx.rx_ring)
440 		return IRQ_HANDLED;
441 
442 	rcu_read_lock();
443 	ice_for_each_vf_rcu(pf, bkt, vf)
444 		napi_schedule(&vf->repr->q_vector->napi);
445 	rcu_read_unlock();
446 
447 	return IRQ_HANDLED;
448 }
449 
450 /**
451  * ice_vsi_alloc - Allocates the next available struct VSI in the PF
452  * @pf: board private structure
453  * @vsi_type: type of VSI
454  * @ch: ptr to channel
455  * @vf: VF for ICE_VSI_VF and ICE_VSI_CTRL
456  *
457  * The VF pointer is used for ICE_VSI_VF and ICE_VSI_CTRL. For ICE_VSI_CTRL,
458  * it may be NULL in the case there is no association with a VF. For
459  * ICE_VSI_VF the VF pointer *must not* be NULL.
460  *
461  * returns a pointer to a VSI on success, NULL on failure.
462  */
463 static struct ice_vsi *
464 ice_vsi_alloc(struct ice_pf *pf, enum ice_vsi_type vsi_type,
465 	      struct ice_channel *ch, struct ice_vf *vf)
466 {
467 	struct device *dev = ice_pf_to_dev(pf);
468 	struct ice_vsi *vsi = NULL;
469 
470 	if (WARN_ON(vsi_type == ICE_VSI_VF && !vf))
471 		return NULL;
472 
473 	/* Need to protect the allocation of the VSIs at the PF level */
474 	mutex_lock(&pf->sw_mutex);
475 
476 	/* If we have already allocated our maximum number of VSIs,
477 	 * pf->next_vsi will be ICE_NO_VSI. If not, pf->next_vsi index
478 	 * is available to be populated
479 	 */
480 	if (pf->next_vsi == ICE_NO_VSI) {
481 		dev_dbg(dev, "out of VSI slots!\n");
482 		goto unlock_pf;
483 	}
484 
485 	vsi = devm_kzalloc(dev, sizeof(*vsi), GFP_KERNEL);
486 	if (!vsi)
487 		goto unlock_pf;
488 
489 	vsi->type = vsi_type;
490 	vsi->back = pf;
491 	set_bit(ICE_VSI_DOWN, vsi->state);
492 
493 	if (vsi_type == ICE_VSI_VF)
494 		ice_vsi_set_num_qs(vsi, vf);
495 	else if (vsi_type != ICE_VSI_CHNL)
496 		ice_vsi_set_num_qs(vsi, NULL);
497 
498 	switch (vsi->type) {
499 	case ICE_VSI_SWITCHDEV_CTRL:
500 		if (ice_vsi_alloc_arrays(vsi))
501 			goto err_rings;
502 
503 		/* Setup eswitch MSIX irq handler for VSI */
504 		vsi->irq_handler = ice_eswitch_msix_clean_rings;
505 		break;
506 	case ICE_VSI_PF:
507 		if (ice_vsi_alloc_arrays(vsi))
508 			goto err_rings;
509 
510 		/* Setup default MSIX irq handler for VSI */
511 		vsi->irq_handler = ice_msix_clean_rings;
512 		break;
513 	case ICE_VSI_CTRL:
514 		if (ice_vsi_alloc_arrays(vsi))
515 			goto err_rings;
516 
517 		/* Setup ctrl VSI MSIX irq handler */
518 		vsi->irq_handler = ice_msix_clean_ctrl_vsi;
519 
520 		/* For the PF control VSI this is NULL, for the VF control VSI
521 		 * this will be the first VF to allocate it.
522 		 */
523 		vsi->vf = vf;
524 		break;
525 	case ICE_VSI_VF:
526 		if (ice_vsi_alloc_arrays(vsi))
527 			goto err_rings;
528 		vsi->vf = vf;
529 		break;
530 	case ICE_VSI_CHNL:
531 		if (!ch)
532 			goto err_rings;
533 		vsi->num_rxq = ch->num_rxq;
534 		vsi->num_txq = ch->num_txq;
535 		vsi->next_base_q = ch->base_q;
536 		break;
537 	case ICE_VSI_LB:
538 		if (ice_vsi_alloc_arrays(vsi))
539 			goto err_rings;
540 		break;
541 	default:
542 		dev_warn(dev, "Unknown VSI type %d\n", vsi->type);
543 		goto unlock_pf;
544 	}
545 
546 	if (vsi->type == ICE_VSI_CTRL && !vf) {
547 		/* Use the last VSI slot as the index for PF control VSI */
548 		vsi->idx = pf->num_alloc_vsi - 1;
549 		pf->ctrl_vsi_idx = vsi->idx;
550 		pf->vsi[vsi->idx] = vsi;
551 	} else {
552 		/* fill slot and make note of the index */
553 		vsi->idx = pf->next_vsi;
554 		pf->vsi[pf->next_vsi] = vsi;
555 
556 		/* prepare pf->next_vsi for next use */
557 		pf->next_vsi = ice_get_free_slot(pf->vsi, pf->num_alloc_vsi,
558 						 pf->next_vsi);
559 	}
560 
561 	if (vsi->type == ICE_VSI_CTRL && vf)
562 		vf->ctrl_vsi_idx = vsi->idx;
563 	goto unlock_pf;
564 
565 err_rings:
566 	devm_kfree(dev, vsi);
567 	vsi = NULL;
568 unlock_pf:
569 	mutex_unlock(&pf->sw_mutex);
570 	return vsi;
571 }
572 
573 /**
574  * ice_alloc_fd_res - Allocate FD resource for a VSI
575  * @vsi: pointer to the ice_vsi
576  *
577  * This allocates the FD resources
578  *
579  * Returns 0 on success, -EPERM on no-op or -EIO on failure
580  */
581 static int ice_alloc_fd_res(struct ice_vsi *vsi)
582 {
583 	struct ice_pf *pf = vsi->back;
584 	u32 g_val, b_val;
585 
586 	/* Flow Director filters are only allocated/assigned to the PF VSI or
587 	 * CHNL VSI which passes the traffic. The CTRL VSI is only used to
588 	 * add/delete filters so resources are not allocated to it
589 	 */
590 	if (!test_bit(ICE_FLAG_FD_ENA, pf->flags))
591 		return -EPERM;
592 
593 	if (!(vsi->type == ICE_VSI_PF || vsi->type == ICE_VSI_VF ||
594 	      vsi->type == ICE_VSI_CHNL))
595 		return -EPERM;
596 
597 	/* FD filters from guaranteed pool per VSI */
598 	g_val = pf->hw.func_caps.fd_fltr_guar;
599 	if (!g_val)
600 		return -EPERM;
601 
602 	/* FD filters from best effort pool */
603 	b_val = pf->hw.func_caps.fd_fltr_best_effort;
604 	if (!b_val)
605 		return -EPERM;
606 
607 	/* PF main VSI gets only 64 FD resources from guaranteed pool
608 	 * when ADQ is configured.
609 	 */
610 #define ICE_PF_VSI_GFLTR	64
611 
612 	/* determine FD filter resources per VSI from shared(best effort) and
613 	 * dedicated pool
614 	 */
615 	if (vsi->type == ICE_VSI_PF) {
616 		vsi->num_gfltr = g_val;
617 		/* if MQPRIO is configured, main VSI doesn't get all FD
618 		 * resources from guaranteed pool. PF VSI gets 64 FD resources
619 		 */
620 		if (test_bit(ICE_FLAG_TC_MQPRIO, pf->flags)) {
621 			if (g_val < ICE_PF_VSI_GFLTR)
622 				return -EPERM;
623 			/* allow bare minimum entries for PF VSI */
624 			vsi->num_gfltr = ICE_PF_VSI_GFLTR;
625 		}
626 
627 		/* each VSI gets same "best_effort" quota */
628 		vsi->num_bfltr = b_val;
629 	} else if (vsi->type == ICE_VSI_VF) {
630 		vsi->num_gfltr = 0;
631 
632 		/* each VSI gets same "best_effort" quota */
633 		vsi->num_bfltr = b_val;
634 	} else {
635 		struct ice_vsi *main_vsi;
636 		int numtc;
637 
638 		main_vsi = ice_get_main_vsi(pf);
639 		if (!main_vsi)
640 			return -EPERM;
641 
642 		if (!main_vsi->all_numtc)
643 			return -EINVAL;
644 
645 		/* figure out ADQ numtc */
646 		numtc = main_vsi->all_numtc - ICE_CHNL_START_TC;
647 
648 		/* only one TC but still asking resources for channels,
649 		 * invalid config
650 		 */
651 		if (numtc < ICE_CHNL_START_TC)
652 			return -EPERM;
653 
654 		g_val -= ICE_PF_VSI_GFLTR;
655 		/* channel VSIs gets equal share from guaranteed pool */
656 		vsi->num_gfltr = g_val / numtc;
657 
658 		/* each VSI gets same "best_effort" quota */
659 		vsi->num_bfltr = b_val;
660 	}
661 
662 	return 0;
663 }
664 
665 /**
666  * ice_vsi_get_qs - Assign queues from PF to VSI
667  * @vsi: the VSI to assign queues to
668  *
669  * Returns 0 on success and a negative value on error
670  */
671 static int ice_vsi_get_qs(struct ice_vsi *vsi)
672 {
673 	struct ice_pf *pf = vsi->back;
674 	struct ice_qs_cfg tx_qs_cfg = {
675 		.qs_mutex = &pf->avail_q_mutex,
676 		.pf_map = pf->avail_txqs,
677 		.pf_map_size = pf->max_pf_txqs,
678 		.q_count = vsi->alloc_txq,
679 		.scatter_count = ICE_MAX_SCATTER_TXQS,
680 		.vsi_map = vsi->txq_map,
681 		.vsi_map_offset = 0,
682 		.mapping_mode = ICE_VSI_MAP_CONTIG
683 	};
684 	struct ice_qs_cfg rx_qs_cfg = {
685 		.qs_mutex = &pf->avail_q_mutex,
686 		.pf_map = pf->avail_rxqs,
687 		.pf_map_size = pf->max_pf_rxqs,
688 		.q_count = vsi->alloc_rxq,
689 		.scatter_count = ICE_MAX_SCATTER_RXQS,
690 		.vsi_map = vsi->rxq_map,
691 		.vsi_map_offset = 0,
692 		.mapping_mode = ICE_VSI_MAP_CONTIG
693 	};
694 	int ret;
695 
696 	if (vsi->type == ICE_VSI_CHNL)
697 		return 0;
698 
699 	ret = __ice_vsi_get_qs(&tx_qs_cfg);
700 	if (ret)
701 		return ret;
702 	vsi->tx_mapping_mode = tx_qs_cfg.mapping_mode;
703 
704 	ret = __ice_vsi_get_qs(&rx_qs_cfg);
705 	if (ret)
706 		return ret;
707 	vsi->rx_mapping_mode = rx_qs_cfg.mapping_mode;
708 
709 	return 0;
710 }
711 
712 /**
713  * ice_vsi_put_qs - Release queues from VSI to PF
714  * @vsi: the VSI that is going to release queues
715  */
716 static void ice_vsi_put_qs(struct ice_vsi *vsi)
717 {
718 	struct ice_pf *pf = vsi->back;
719 	int i;
720 
721 	mutex_lock(&pf->avail_q_mutex);
722 
723 	ice_for_each_alloc_txq(vsi, i) {
724 		clear_bit(vsi->txq_map[i], pf->avail_txqs);
725 		vsi->txq_map[i] = ICE_INVAL_Q_INDEX;
726 	}
727 
728 	ice_for_each_alloc_rxq(vsi, i) {
729 		clear_bit(vsi->rxq_map[i], pf->avail_rxqs);
730 		vsi->rxq_map[i] = ICE_INVAL_Q_INDEX;
731 	}
732 
733 	mutex_unlock(&pf->avail_q_mutex);
734 }
735 
736 /**
737  * ice_is_safe_mode
738  * @pf: pointer to the PF struct
739  *
740  * returns true if driver is in safe mode, false otherwise
741  */
742 bool ice_is_safe_mode(struct ice_pf *pf)
743 {
744 	return !test_bit(ICE_FLAG_ADV_FEATURES, pf->flags);
745 }
746 
747 /**
748  * ice_is_rdma_ena
749  * @pf: pointer to the PF struct
750  *
751  * returns true if RDMA is currently supported, false otherwise
752  */
753 bool ice_is_rdma_ena(struct ice_pf *pf)
754 {
755 	return test_bit(ICE_FLAG_RDMA_ENA, pf->flags);
756 }
757 
758 /**
759  * ice_vsi_clean_rss_flow_fld - Delete RSS configuration
760  * @vsi: the VSI being cleaned up
761  *
762  * This function deletes RSS input set for all flows that were configured
763  * for this VSI
764  */
765 static void ice_vsi_clean_rss_flow_fld(struct ice_vsi *vsi)
766 {
767 	struct ice_pf *pf = vsi->back;
768 	int status;
769 
770 	if (ice_is_safe_mode(pf))
771 		return;
772 
773 	status = ice_rem_vsi_rss_cfg(&pf->hw, vsi->idx);
774 	if (status)
775 		dev_dbg(ice_pf_to_dev(pf), "ice_rem_vsi_rss_cfg failed for vsi = %d, error = %d\n",
776 			vsi->vsi_num, status);
777 }
778 
779 /**
780  * ice_rss_clean - Delete RSS related VSI structures and configuration
781  * @vsi: the VSI being removed
782  */
783 static void ice_rss_clean(struct ice_vsi *vsi)
784 {
785 	struct ice_pf *pf = vsi->back;
786 	struct device *dev;
787 
788 	dev = ice_pf_to_dev(pf);
789 
790 	if (vsi->rss_hkey_user)
791 		devm_kfree(dev, vsi->rss_hkey_user);
792 	if (vsi->rss_lut_user)
793 		devm_kfree(dev, vsi->rss_lut_user);
794 
795 	ice_vsi_clean_rss_flow_fld(vsi);
796 	/* remove RSS replay list */
797 	if (!ice_is_safe_mode(pf))
798 		ice_rem_vsi_rss_list(&pf->hw, vsi->idx);
799 }
800 
801 /**
802  * ice_vsi_set_rss_params - Setup RSS capabilities per VSI type
803  * @vsi: the VSI being configured
804  */
805 static void ice_vsi_set_rss_params(struct ice_vsi *vsi)
806 {
807 	struct ice_hw_common_caps *cap;
808 	struct ice_pf *pf = vsi->back;
809 
810 	if (!test_bit(ICE_FLAG_RSS_ENA, pf->flags)) {
811 		vsi->rss_size = 1;
812 		return;
813 	}
814 
815 	cap = &pf->hw.func_caps.common_cap;
816 	switch (vsi->type) {
817 	case ICE_VSI_CHNL:
818 	case ICE_VSI_PF:
819 		/* PF VSI will inherit RSS instance of PF */
820 		vsi->rss_table_size = (u16)cap->rss_table_size;
821 		if (vsi->type == ICE_VSI_CHNL)
822 			vsi->rss_size = min_t(u16, vsi->num_rxq,
823 					      BIT(cap->rss_table_entry_width));
824 		else
825 			vsi->rss_size = min_t(u16, num_online_cpus(),
826 					      BIT(cap->rss_table_entry_width));
827 		vsi->rss_lut_type = ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_PF;
828 		break;
829 	case ICE_VSI_SWITCHDEV_CTRL:
830 		vsi->rss_table_size = ICE_VSIQF_HLUT_ARRAY_SIZE;
831 		vsi->rss_size = min_t(u16, num_online_cpus(),
832 				      BIT(cap->rss_table_entry_width));
833 		vsi->rss_lut_type = ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_VSI;
834 		break;
835 	case ICE_VSI_VF:
836 		/* VF VSI will get a small RSS table.
837 		 * For VSI_LUT, LUT size should be set to 64 bytes.
838 		 */
839 		vsi->rss_table_size = ICE_VSIQF_HLUT_ARRAY_SIZE;
840 		vsi->rss_size = ICE_MAX_RSS_QS_PER_VF;
841 		vsi->rss_lut_type = ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_VSI;
842 		break;
843 	case ICE_VSI_LB:
844 		break;
845 	default:
846 		dev_dbg(ice_pf_to_dev(pf), "Unsupported VSI type %s\n",
847 			ice_vsi_type_str(vsi->type));
848 		break;
849 	}
850 }
851 
852 /**
853  * ice_set_dflt_vsi_ctx - Set default VSI context before adding a VSI
854  * @hw: HW structure used to determine the VLAN mode of the device
855  * @ctxt: the VSI context being set
856  *
857  * This initializes a default VSI context for all sections except the Queues.
858  */
859 static void ice_set_dflt_vsi_ctx(struct ice_hw *hw, struct ice_vsi_ctx *ctxt)
860 {
861 	u32 table = 0;
862 
863 	memset(&ctxt->info, 0, sizeof(ctxt->info));
864 	/* VSI's should be allocated from shared pool */
865 	ctxt->alloc_from_pool = true;
866 	/* Src pruning enabled by default */
867 	ctxt->info.sw_flags = ICE_AQ_VSI_SW_FLAG_SRC_PRUNE;
868 	/* Traffic from VSI can be sent to LAN */
869 	ctxt->info.sw_flags2 = ICE_AQ_VSI_SW_FLAG_LAN_ENA;
870 	/* allow all untagged/tagged packets by default on Tx */
871 	ctxt->info.inner_vlan_flags = ((ICE_AQ_VSI_INNER_VLAN_TX_MODE_ALL &
872 				  ICE_AQ_VSI_INNER_VLAN_TX_MODE_M) >>
873 				 ICE_AQ_VSI_INNER_VLAN_TX_MODE_S);
874 	/* SVM - by default bits 3 and 4 in inner_vlan_flags are 0's which
875 	 * results in legacy behavior (show VLAN, DEI, and UP) in descriptor.
876 	 *
877 	 * DVM - leave inner VLAN in packet by default
878 	 */
879 	if (ice_is_dvm_ena(hw)) {
880 		ctxt->info.inner_vlan_flags |=
881 			ICE_AQ_VSI_INNER_VLAN_EMODE_NOTHING;
882 		ctxt->info.outer_vlan_flags =
883 			(ICE_AQ_VSI_OUTER_VLAN_TX_MODE_ALL <<
884 			 ICE_AQ_VSI_OUTER_VLAN_TX_MODE_S) &
885 			ICE_AQ_VSI_OUTER_VLAN_TX_MODE_M;
886 		ctxt->info.outer_vlan_flags |=
887 			(ICE_AQ_VSI_OUTER_TAG_VLAN_8100 <<
888 			 ICE_AQ_VSI_OUTER_TAG_TYPE_S) &
889 			ICE_AQ_VSI_OUTER_TAG_TYPE_M;
890 		ctxt->info.outer_vlan_flags |=
891 			FIELD_PREP(ICE_AQ_VSI_OUTER_VLAN_EMODE_M,
892 				   ICE_AQ_VSI_OUTER_VLAN_EMODE_NOTHING);
893 	}
894 	/* Have 1:1 UP mapping for both ingress/egress tables */
895 	table |= ICE_UP_TABLE_TRANSLATE(0, 0);
896 	table |= ICE_UP_TABLE_TRANSLATE(1, 1);
897 	table |= ICE_UP_TABLE_TRANSLATE(2, 2);
898 	table |= ICE_UP_TABLE_TRANSLATE(3, 3);
899 	table |= ICE_UP_TABLE_TRANSLATE(4, 4);
900 	table |= ICE_UP_TABLE_TRANSLATE(5, 5);
901 	table |= ICE_UP_TABLE_TRANSLATE(6, 6);
902 	table |= ICE_UP_TABLE_TRANSLATE(7, 7);
903 	ctxt->info.ingress_table = cpu_to_le32(table);
904 	ctxt->info.egress_table = cpu_to_le32(table);
905 	/* Have 1:1 UP mapping for outer to inner UP table */
906 	ctxt->info.outer_up_table = cpu_to_le32(table);
907 	/* No Outer tag support outer_tag_flags remains to zero */
908 }
909 
910 /**
911  * ice_vsi_setup_q_map - Setup a VSI queue map
912  * @vsi: the VSI being configured
913  * @ctxt: VSI context structure
914  */
915 static int ice_vsi_setup_q_map(struct ice_vsi *vsi, struct ice_vsi_ctx *ctxt)
916 {
917 	u16 offset = 0, qmap = 0, tx_count = 0, pow = 0;
918 	u16 num_txq_per_tc, num_rxq_per_tc;
919 	u16 qcount_tx = vsi->alloc_txq;
920 	u16 qcount_rx = vsi->alloc_rxq;
921 	u8 netdev_tc = 0;
922 	int i;
923 
924 	if (!vsi->tc_cfg.numtc) {
925 		/* at least TC0 should be enabled by default */
926 		vsi->tc_cfg.numtc = 1;
927 		vsi->tc_cfg.ena_tc = 1;
928 	}
929 
930 	num_rxq_per_tc = min_t(u16, qcount_rx / vsi->tc_cfg.numtc, ICE_MAX_RXQS_PER_TC);
931 	if (!num_rxq_per_tc)
932 		num_rxq_per_tc = 1;
933 	num_txq_per_tc = qcount_tx / vsi->tc_cfg.numtc;
934 	if (!num_txq_per_tc)
935 		num_txq_per_tc = 1;
936 
937 	/* find the (rounded up) power-of-2 of qcount */
938 	pow = (u16)order_base_2(num_rxq_per_tc);
939 
940 	/* TC mapping is a function of the number of Rx queues assigned to the
941 	 * VSI for each traffic class and the offset of these queues.
942 	 * The first 10 bits are for queue offset for TC0, next 4 bits for no:of
943 	 * queues allocated to TC0. No:of queues is a power-of-2.
944 	 *
945 	 * If TC is not enabled, the queue offset is set to 0, and allocate one
946 	 * queue, this way, traffic for the given TC will be sent to the default
947 	 * queue.
948 	 *
949 	 * Setup number and offset of Rx queues for all TCs for the VSI
950 	 */
951 	ice_for_each_traffic_class(i) {
952 		if (!(vsi->tc_cfg.ena_tc & BIT(i))) {
953 			/* TC is not enabled */
954 			vsi->tc_cfg.tc_info[i].qoffset = 0;
955 			vsi->tc_cfg.tc_info[i].qcount_rx = 1;
956 			vsi->tc_cfg.tc_info[i].qcount_tx = 1;
957 			vsi->tc_cfg.tc_info[i].netdev_tc = 0;
958 			ctxt->info.tc_mapping[i] = 0;
959 			continue;
960 		}
961 
962 		/* TC is enabled */
963 		vsi->tc_cfg.tc_info[i].qoffset = offset;
964 		vsi->tc_cfg.tc_info[i].qcount_rx = num_rxq_per_tc;
965 		vsi->tc_cfg.tc_info[i].qcount_tx = num_txq_per_tc;
966 		vsi->tc_cfg.tc_info[i].netdev_tc = netdev_tc++;
967 
968 		qmap = ((offset << ICE_AQ_VSI_TC_Q_OFFSET_S) &
969 			ICE_AQ_VSI_TC_Q_OFFSET_M) |
970 			((pow << ICE_AQ_VSI_TC_Q_NUM_S) &
971 			 ICE_AQ_VSI_TC_Q_NUM_M);
972 		offset += num_rxq_per_tc;
973 		tx_count += num_txq_per_tc;
974 		ctxt->info.tc_mapping[i] = cpu_to_le16(qmap);
975 	}
976 
977 	/* if offset is non-zero, means it is calculated correctly based on
978 	 * enabled TCs for a given VSI otherwise qcount_rx will always
979 	 * be correct and non-zero because it is based off - VSI's
980 	 * allocated Rx queues which is at least 1 (hence qcount_tx will be
981 	 * at least 1)
982 	 */
983 	if (offset)
984 		vsi->num_rxq = offset;
985 	else
986 		vsi->num_rxq = num_rxq_per_tc;
987 
988 	if (vsi->num_rxq > vsi->alloc_rxq) {
989 		dev_err(ice_pf_to_dev(vsi->back), "Trying to use more Rx queues (%u), than were allocated (%u)!\n",
990 			vsi->num_rxq, vsi->alloc_rxq);
991 		return -EINVAL;
992 	}
993 
994 	vsi->num_txq = tx_count;
995 	if (vsi->num_txq > vsi->alloc_txq) {
996 		dev_err(ice_pf_to_dev(vsi->back), "Trying to use more Tx queues (%u), than were allocated (%u)!\n",
997 			vsi->num_txq, vsi->alloc_txq);
998 		return -EINVAL;
999 	}
1000 
1001 	if (vsi->type == ICE_VSI_VF && vsi->num_txq != vsi->num_rxq) {
1002 		dev_dbg(ice_pf_to_dev(vsi->back), "VF VSI should have same number of Tx and Rx queues. Hence making them equal\n");
1003 		/* since there is a chance that num_rxq could have been changed
1004 		 * in the above for loop, make num_txq equal to num_rxq.
1005 		 */
1006 		vsi->num_txq = vsi->num_rxq;
1007 	}
1008 
1009 	/* Rx queue mapping */
1010 	ctxt->info.mapping_flags |= cpu_to_le16(ICE_AQ_VSI_Q_MAP_CONTIG);
1011 	/* q_mapping buffer holds the info for the first queue allocated for
1012 	 * this VSI in the PF space and also the number of queues associated
1013 	 * with this VSI.
1014 	 */
1015 	ctxt->info.q_mapping[0] = cpu_to_le16(vsi->rxq_map[0]);
1016 	ctxt->info.q_mapping[1] = cpu_to_le16(vsi->num_rxq);
1017 
1018 	return 0;
1019 }
1020 
1021 /**
1022  * ice_set_fd_vsi_ctx - Set FD VSI context before adding a VSI
1023  * @ctxt: the VSI context being set
1024  * @vsi: the VSI being configured
1025  */
1026 static void ice_set_fd_vsi_ctx(struct ice_vsi_ctx *ctxt, struct ice_vsi *vsi)
1027 {
1028 	u8 dflt_q_group, dflt_q_prio;
1029 	u16 dflt_q, report_q, val;
1030 
1031 	if (vsi->type != ICE_VSI_PF && vsi->type != ICE_VSI_CTRL &&
1032 	    vsi->type != ICE_VSI_VF && vsi->type != ICE_VSI_CHNL)
1033 		return;
1034 
1035 	val = ICE_AQ_VSI_PROP_FLOW_DIR_VALID;
1036 	ctxt->info.valid_sections |= cpu_to_le16(val);
1037 	dflt_q = 0;
1038 	dflt_q_group = 0;
1039 	report_q = 0;
1040 	dflt_q_prio = 0;
1041 
1042 	/* enable flow director filtering/programming */
1043 	val = ICE_AQ_VSI_FD_ENABLE | ICE_AQ_VSI_FD_PROG_ENABLE;
1044 	ctxt->info.fd_options = cpu_to_le16(val);
1045 	/* max of allocated flow director filters */
1046 	ctxt->info.max_fd_fltr_dedicated =
1047 			cpu_to_le16(vsi->num_gfltr);
1048 	/* max of shared flow director filters any VSI may program */
1049 	ctxt->info.max_fd_fltr_shared =
1050 			cpu_to_le16(vsi->num_bfltr);
1051 	/* default queue index within the VSI of the default FD */
1052 	val = ((dflt_q << ICE_AQ_VSI_FD_DEF_Q_S) &
1053 	       ICE_AQ_VSI_FD_DEF_Q_M);
1054 	/* target queue or queue group to the FD filter */
1055 	val |= ((dflt_q_group << ICE_AQ_VSI_FD_DEF_GRP_S) &
1056 		ICE_AQ_VSI_FD_DEF_GRP_M);
1057 	ctxt->info.fd_def_q = cpu_to_le16(val);
1058 	/* queue index on which FD filter completion is reported */
1059 	val = ((report_q << ICE_AQ_VSI_FD_REPORT_Q_S) &
1060 	       ICE_AQ_VSI_FD_REPORT_Q_M);
1061 	/* priority of the default qindex action */
1062 	val |= ((dflt_q_prio << ICE_AQ_VSI_FD_DEF_PRIORITY_S) &
1063 		ICE_AQ_VSI_FD_DEF_PRIORITY_M);
1064 	ctxt->info.fd_report_opt = cpu_to_le16(val);
1065 }
1066 
1067 /**
1068  * ice_set_rss_vsi_ctx - Set RSS VSI context before adding a VSI
1069  * @ctxt: the VSI context being set
1070  * @vsi: the VSI being configured
1071  */
1072 static void ice_set_rss_vsi_ctx(struct ice_vsi_ctx *ctxt, struct ice_vsi *vsi)
1073 {
1074 	u8 lut_type, hash_type;
1075 	struct device *dev;
1076 	struct ice_pf *pf;
1077 
1078 	pf = vsi->back;
1079 	dev = ice_pf_to_dev(pf);
1080 
1081 	switch (vsi->type) {
1082 	case ICE_VSI_CHNL:
1083 	case ICE_VSI_PF:
1084 		/* PF VSI will inherit RSS instance of PF */
1085 		lut_type = ICE_AQ_VSI_Q_OPT_RSS_LUT_PF;
1086 		hash_type = ICE_AQ_VSI_Q_OPT_RSS_TPLZ;
1087 		break;
1088 	case ICE_VSI_VF:
1089 		/* VF VSI will gets a small RSS table which is a VSI LUT type */
1090 		lut_type = ICE_AQ_VSI_Q_OPT_RSS_LUT_VSI;
1091 		hash_type = ICE_AQ_VSI_Q_OPT_RSS_TPLZ;
1092 		break;
1093 	default:
1094 		dev_dbg(dev, "Unsupported VSI type %s\n",
1095 			ice_vsi_type_str(vsi->type));
1096 		return;
1097 	}
1098 
1099 	ctxt->info.q_opt_rss = ((lut_type << ICE_AQ_VSI_Q_OPT_RSS_LUT_S) &
1100 				ICE_AQ_VSI_Q_OPT_RSS_LUT_M) |
1101 				((hash_type << ICE_AQ_VSI_Q_OPT_RSS_HASH_S) &
1102 				 ICE_AQ_VSI_Q_OPT_RSS_HASH_M);
1103 }
1104 
1105 static void
1106 ice_chnl_vsi_setup_q_map(struct ice_vsi *vsi, struct ice_vsi_ctx *ctxt)
1107 {
1108 	struct ice_pf *pf = vsi->back;
1109 	u16 qcount, qmap;
1110 	u8 offset = 0;
1111 	int pow;
1112 
1113 	qcount = min_t(int, vsi->num_rxq, pf->num_lan_msix);
1114 
1115 	pow = order_base_2(qcount);
1116 	qmap = ((offset << ICE_AQ_VSI_TC_Q_OFFSET_S) &
1117 		 ICE_AQ_VSI_TC_Q_OFFSET_M) |
1118 		 ((pow << ICE_AQ_VSI_TC_Q_NUM_S) &
1119 		   ICE_AQ_VSI_TC_Q_NUM_M);
1120 
1121 	ctxt->info.tc_mapping[0] = cpu_to_le16(qmap);
1122 	ctxt->info.mapping_flags |= cpu_to_le16(ICE_AQ_VSI_Q_MAP_CONTIG);
1123 	ctxt->info.q_mapping[0] = cpu_to_le16(vsi->next_base_q);
1124 	ctxt->info.q_mapping[1] = cpu_to_le16(qcount);
1125 }
1126 
1127 /**
1128  * ice_vsi_init - Create and initialize a VSI
1129  * @vsi: the VSI being configured
1130  * @init_vsi: is this call creating a VSI
1131  *
1132  * This initializes a VSI context depending on the VSI type to be added and
1133  * passes it down to the add_vsi aq command to create a new VSI.
1134  */
1135 static int ice_vsi_init(struct ice_vsi *vsi, bool init_vsi)
1136 {
1137 	struct ice_pf *pf = vsi->back;
1138 	struct ice_hw *hw = &pf->hw;
1139 	struct ice_vsi_ctx *ctxt;
1140 	struct device *dev;
1141 	int ret = 0;
1142 
1143 	dev = ice_pf_to_dev(pf);
1144 	ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
1145 	if (!ctxt)
1146 		return -ENOMEM;
1147 
1148 	switch (vsi->type) {
1149 	case ICE_VSI_CTRL:
1150 	case ICE_VSI_LB:
1151 	case ICE_VSI_PF:
1152 		ctxt->flags = ICE_AQ_VSI_TYPE_PF;
1153 		break;
1154 	case ICE_VSI_SWITCHDEV_CTRL:
1155 	case ICE_VSI_CHNL:
1156 		ctxt->flags = ICE_AQ_VSI_TYPE_VMDQ2;
1157 		break;
1158 	case ICE_VSI_VF:
1159 		ctxt->flags = ICE_AQ_VSI_TYPE_VF;
1160 		/* VF number here is the absolute VF number (0-255) */
1161 		ctxt->vf_num = vsi->vf->vf_id + hw->func_caps.vf_base_id;
1162 		break;
1163 	default:
1164 		ret = -ENODEV;
1165 		goto out;
1166 	}
1167 
1168 	/* Handle VLAN pruning for channel VSI if main VSI has VLAN
1169 	 * prune enabled
1170 	 */
1171 	if (vsi->type == ICE_VSI_CHNL) {
1172 		struct ice_vsi *main_vsi;
1173 
1174 		main_vsi = ice_get_main_vsi(pf);
1175 		if (main_vsi && ice_vsi_is_vlan_pruning_ena(main_vsi))
1176 			ctxt->info.sw_flags2 |=
1177 				ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA;
1178 		else
1179 			ctxt->info.sw_flags2 &=
1180 				~ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA;
1181 	}
1182 
1183 	ice_set_dflt_vsi_ctx(hw, ctxt);
1184 	if (test_bit(ICE_FLAG_FD_ENA, pf->flags))
1185 		ice_set_fd_vsi_ctx(ctxt, vsi);
1186 	/* if the switch is in VEB mode, allow VSI loopback */
1187 	if (vsi->vsw->bridge_mode == BRIDGE_MODE_VEB)
1188 		ctxt->info.sw_flags |= ICE_AQ_VSI_SW_FLAG_ALLOW_LB;
1189 
1190 	/* Set LUT type and HASH type if RSS is enabled */
1191 	if (test_bit(ICE_FLAG_RSS_ENA, pf->flags) &&
1192 	    vsi->type != ICE_VSI_CTRL) {
1193 		ice_set_rss_vsi_ctx(ctxt, vsi);
1194 		/* if updating VSI context, make sure to set valid_section:
1195 		 * to indicate which section of VSI context being updated
1196 		 */
1197 		if (!init_vsi)
1198 			ctxt->info.valid_sections |=
1199 				cpu_to_le16(ICE_AQ_VSI_PROP_Q_OPT_VALID);
1200 	}
1201 
1202 	ctxt->info.sw_id = vsi->port_info->sw_id;
1203 	if (vsi->type == ICE_VSI_CHNL) {
1204 		ice_chnl_vsi_setup_q_map(vsi, ctxt);
1205 	} else {
1206 		ret = ice_vsi_setup_q_map(vsi, ctxt);
1207 		if (ret)
1208 			goto out;
1209 
1210 		if (!init_vsi) /* means VSI being updated */
1211 			/* must to indicate which section of VSI context are
1212 			 * being modified
1213 			 */
1214 			ctxt->info.valid_sections |=
1215 				cpu_to_le16(ICE_AQ_VSI_PROP_RXQ_MAP_VALID);
1216 	}
1217 
1218 	/* Allow control frames out of main VSI */
1219 	if (vsi->type == ICE_VSI_PF) {
1220 		ctxt->info.sec_flags |= ICE_AQ_VSI_SEC_FLAG_ALLOW_DEST_OVRD;
1221 		ctxt->info.valid_sections |=
1222 			cpu_to_le16(ICE_AQ_VSI_PROP_SECURITY_VALID);
1223 	}
1224 
1225 	if (init_vsi) {
1226 		ret = ice_add_vsi(hw, vsi->idx, ctxt, NULL);
1227 		if (ret) {
1228 			dev_err(dev, "Add VSI failed, err %d\n", ret);
1229 			ret = -EIO;
1230 			goto out;
1231 		}
1232 	} else {
1233 		ret = ice_update_vsi(hw, vsi->idx, ctxt, NULL);
1234 		if (ret) {
1235 			dev_err(dev, "Update VSI failed, err %d\n", ret);
1236 			ret = -EIO;
1237 			goto out;
1238 		}
1239 	}
1240 
1241 	/* keep context for update VSI operations */
1242 	vsi->info = ctxt->info;
1243 
1244 	/* record VSI number returned */
1245 	vsi->vsi_num = ctxt->vsi_num;
1246 
1247 out:
1248 	kfree(ctxt);
1249 	return ret;
1250 }
1251 
1252 /**
1253  * ice_free_res - free a block of resources
1254  * @res: pointer to the resource
1255  * @index: starting index previously returned by ice_get_res
1256  * @id: identifier to track owner
1257  *
1258  * Returns number of resources freed
1259  */
1260 int ice_free_res(struct ice_res_tracker *res, u16 index, u16 id)
1261 {
1262 	int count = 0;
1263 	int i;
1264 
1265 	if (!res || index >= res->end)
1266 		return -EINVAL;
1267 
1268 	id |= ICE_RES_VALID_BIT;
1269 	for (i = index; i < res->end && res->list[i] == id; i++) {
1270 		res->list[i] = 0;
1271 		count++;
1272 	}
1273 
1274 	return count;
1275 }
1276 
1277 /**
1278  * ice_search_res - Search the tracker for a block of resources
1279  * @res: pointer to the resource
1280  * @needed: size of the block needed
1281  * @id: identifier to track owner
1282  *
1283  * Returns the base item index of the block, or -ENOMEM for error
1284  */
1285 static int ice_search_res(struct ice_res_tracker *res, u16 needed, u16 id)
1286 {
1287 	u16 start = 0, end = 0;
1288 
1289 	if (needed > res->end)
1290 		return -ENOMEM;
1291 
1292 	id |= ICE_RES_VALID_BIT;
1293 
1294 	do {
1295 		/* skip already allocated entries */
1296 		if (res->list[end++] & ICE_RES_VALID_BIT) {
1297 			start = end;
1298 			if ((start + needed) > res->end)
1299 				break;
1300 		}
1301 
1302 		if (end == (start + needed)) {
1303 			int i = start;
1304 
1305 			/* there was enough, so assign it to the requestor */
1306 			while (i != end)
1307 				res->list[i++] = id;
1308 
1309 			return start;
1310 		}
1311 	} while (end < res->end);
1312 
1313 	return -ENOMEM;
1314 }
1315 
1316 /**
1317  * ice_get_free_res_count - Get free count from a resource tracker
1318  * @res: Resource tracker instance
1319  */
1320 static u16 ice_get_free_res_count(struct ice_res_tracker *res)
1321 {
1322 	u16 i, count = 0;
1323 
1324 	for (i = 0; i < res->end; i++)
1325 		if (!(res->list[i] & ICE_RES_VALID_BIT))
1326 			count++;
1327 
1328 	return count;
1329 }
1330 
1331 /**
1332  * ice_get_res - get a block of resources
1333  * @pf: board private structure
1334  * @res: pointer to the resource
1335  * @needed: size of the block needed
1336  * @id: identifier to track owner
1337  *
1338  * Returns the base item index of the block, or negative for error
1339  */
1340 int
1341 ice_get_res(struct ice_pf *pf, struct ice_res_tracker *res, u16 needed, u16 id)
1342 {
1343 	if (!res || !pf)
1344 		return -EINVAL;
1345 
1346 	if (!needed || needed > res->num_entries || id >= ICE_RES_VALID_BIT) {
1347 		dev_err(ice_pf_to_dev(pf), "param err: needed=%d, num_entries = %d id=0x%04x\n",
1348 			needed, res->num_entries, id);
1349 		return -EINVAL;
1350 	}
1351 
1352 	return ice_search_res(res, needed, id);
1353 }
1354 
1355 /**
1356  * ice_get_vf_ctrl_res - Get VF control VSI resource
1357  * @pf: pointer to the PF structure
1358  * @vsi: the VSI to allocate a resource for
1359  *
1360  * Look up whether another VF has already allocated the control VSI resource.
1361  * If so, re-use this resource so that we share it among all VFs.
1362  *
1363  * Otherwise, allocate the resource and return it.
1364  */
1365 static int ice_get_vf_ctrl_res(struct ice_pf *pf, struct ice_vsi *vsi)
1366 {
1367 	struct ice_vf *vf;
1368 	unsigned int bkt;
1369 	int base;
1370 
1371 	rcu_read_lock();
1372 	ice_for_each_vf_rcu(pf, bkt, vf) {
1373 		if (vf != vsi->vf && vf->ctrl_vsi_idx != ICE_NO_VSI) {
1374 			base = pf->vsi[vf->ctrl_vsi_idx]->base_vector;
1375 			rcu_read_unlock();
1376 			return base;
1377 		}
1378 	}
1379 	rcu_read_unlock();
1380 
1381 	return ice_get_res(pf, pf->irq_tracker, vsi->num_q_vectors,
1382 			   ICE_RES_VF_CTRL_VEC_ID);
1383 }
1384 
1385 /**
1386  * ice_vsi_setup_vector_base - Set up the base vector for the given VSI
1387  * @vsi: ptr to the VSI
1388  *
1389  * This should only be called after ice_vsi_alloc() which allocates the
1390  * corresponding SW VSI structure and initializes num_queue_pairs for the
1391  * newly allocated VSI.
1392  *
1393  * Returns 0 on success or negative on failure
1394  */
1395 static int ice_vsi_setup_vector_base(struct ice_vsi *vsi)
1396 {
1397 	struct ice_pf *pf = vsi->back;
1398 	struct device *dev;
1399 	u16 num_q_vectors;
1400 	int base;
1401 
1402 	dev = ice_pf_to_dev(pf);
1403 	/* SRIOV doesn't grab irq_tracker entries for each VSI */
1404 	if (vsi->type == ICE_VSI_VF)
1405 		return 0;
1406 	if (vsi->type == ICE_VSI_CHNL)
1407 		return 0;
1408 
1409 	if (vsi->base_vector) {
1410 		dev_dbg(dev, "VSI %d has non-zero base vector %d\n",
1411 			vsi->vsi_num, vsi->base_vector);
1412 		return -EEXIST;
1413 	}
1414 
1415 	num_q_vectors = vsi->num_q_vectors;
1416 	/* reserve slots from OS requested IRQs */
1417 	if (vsi->type == ICE_VSI_CTRL && vsi->vf) {
1418 		base = ice_get_vf_ctrl_res(pf, vsi);
1419 	} else {
1420 		base = ice_get_res(pf, pf->irq_tracker, num_q_vectors,
1421 				   vsi->idx);
1422 	}
1423 
1424 	if (base < 0) {
1425 		dev_err(dev, "%d MSI-X interrupts available. %s %d failed to get %d MSI-X vectors\n",
1426 			ice_get_free_res_count(pf->irq_tracker),
1427 			ice_vsi_type_str(vsi->type), vsi->idx, num_q_vectors);
1428 		return -ENOENT;
1429 	}
1430 	vsi->base_vector = (u16)base;
1431 	pf->num_avail_sw_msix -= num_q_vectors;
1432 
1433 	return 0;
1434 }
1435 
1436 /**
1437  * ice_vsi_clear_rings - Deallocates the Tx and Rx rings for VSI
1438  * @vsi: the VSI having rings deallocated
1439  */
1440 static void ice_vsi_clear_rings(struct ice_vsi *vsi)
1441 {
1442 	int i;
1443 
1444 	/* Avoid stale references by clearing map from vector to ring */
1445 	if (vsi->q_vectors) {
1446 		ice_for_each_q_vector(vsi, i) {
1447 			struct ice_q_vector *q_vector = vsi->q_vectors[i];
1448 
1449 			if (q_vector) {
1450 				q_vector->tx.tx_ring = NULL;
1451 				q_vector->rx.rx_ring = NULL;
1452 			}
1453 		}
1454 	}
1455 
1456 	if (vsi->tx_rings) {
1457 		ice_for_each_alloc_txq(vsi, i) {
1458 			if (vsi->tx_rings[i]) {
1459 				kfree_rcu(vsi->tx_rings[i], rcu);
1460 				WRITE_ONCE(vsi->tx_rings[i], NULL);
1461 			}
1462 		}
1463 	}
1464 	if (vsi->rx_rings) {
1465 		ice_for_each_alloc_rxq(vsi, i) {
1466 			if (vsi->rx_rings[i]) {
1467 				kfree_rcu(vsi->rx_rings[i], rcu);
1468 				WRITE_ONCE(vsi->rx_rings[i], NULL);
1469 			}
1470 		}
1471 	}
1472 }
1473 
1474 /**
1475  * ice_vsi_alloc_rings - Allocates Tx and Rx rings for the VSI
1476  * @vsi: VSI which is having rings allocated
1477  */
1478 static int ice_vsi_alloc_rings(struct ice_vsi *vsi)
1479 {
1480 	bool dvm_ena = ice_is_dvm_ena(&vsi->back->hw);
1481 	struct ice_pf *pf = vsi->back;
1482 	struct device *dev;
1483 	u16 i;
1484 
1485 	dev = ice_pf_to_dev(pf);
1486 	/* Allocate Tx rings */
1487 	ice_for_each_alloc_txq(vsi, i) {
1488 		struct ice_tx_ring *ring;
1489 
1490 		/* allocate with kzalloc(), free with kfree_rcu() */
1491 		ring = kzalloc(sizeof(*ring), GFP_KERNEL);
1492 
1493 		if (!ring)
1494 			goto err_out;
1495 
1496 		ring->q_index = i;
1497 		ring->reg_idx = vsi->txq_map[i];
1498 		ring->vsi = vsi;
1499 		ring->tx_tstamps = &pf->ptp.port.tx;
1500 		ring->dev = dev;
1501 		ring->count = vsi->num_tx_desc;
1502 		ring->txq_teid = ICE_INVAL_TEID;
1503 		if (dvm_ena)
1504 			ring->flags |= ICE_TX_FLAGS_RING_VLAN_L2TAG2;
1505 		else
1506 			ring->flags |= ICE_TX_FLAGS_RING_VLAN_L2TAG1;
1507 		WRITE_ONCE(vsi->tx_rings[i], ring);
1508 	}
1509 
1510 	/* Allocate Rx rings */
1511 	ice_for_each_alloc_rxq(vsi, i) {
1512 		struct ice_rx_ring *ring;
1513 
1514 		/* allocate with kzalloc(), free with kfree_rcu() */
1515 		ring = kzalloc(sizeof(*ring), GFP_KERNEL);
1516 		if (!ring)
1517 			goto err_out;
1518 
1519 		ring->q_index = i;
1520 		ring->reg_idx = vsi->rxq_map[i];
1521 		ring->vsi = vsi;
1522 		ring->netdev = vsi->netdev;
1523 		ring->dev = dev;
1524 		ring->count = vsi->num_rx_desc;
1525 		WRITE_ONCE(vsi->rx_rings[i], ring);
1526 	}
1527 
1528 	return 0;
1529 
1530 err_out:
1531 	ice_vsi_clear_rings(vsi);
1532 	return -ENOMEM;
1533 }
1534 
1535 /**
1536  * ice_vsi_manage_rss_lut - disable/enable RSS
1537  * @vsi: the VSI being changed
1538  * @ena: boolean value indicating if this is an enable or disable request
1539  *
1540  * In the event of disable request for RSS, this function will zero out RSS
1541  * LUT, while in the event of enable request for RSS, it will reconfigure RSS
1542  * LUT.
1543  */
1544 void ice_vsi_manage_rss_lut(struct ice_vsi *vsi, bool ena)
1545 {
1546 	u8 *lut;
1547 
1548 	lut = kzalloc(vsi->rss_table_size, GFP_KERNEL);
1549 	if (!lut)
1550 		return;
1551 
1552 	if (ena) {
1553 		if (vsi->rss_lut_user)
1554 			memcpy(lut, vsi->rss_lut_user, vsi->rss_table_size);
1555 		else
1556 			ice_fill_rss_lut(lut, vsi->rss_table_size,
1557 					 vsi->rss_size);
1558 	}
1559 
1560 	ice_set_rss_lut(vsi, lut, vsi->rss_table_size);
1561 	kfree(lut);
1562 }
1563 
1564 /**
1565  * ice_vsi_cfg_rss_lut_key - Configure RSS params for a VSI
1566  * @vsi: VSI to be configured
1567  */
1568 int ice_vsi_cfg_rss_lut_key(struct ice_vsi *vsi)
1569 {
1570 	struct ice_pf *pf = vsi->back;
1571 	struct device *dev;
1572 	u8 *lut, *key;
1573 	int err;
1574 
1575 	dev = ice_pf_to_dev(pf);
1576 	if (vsi->type == ICE_VSI_PF && vsi->ch_rss_size &&
1577 	    (test_bit(ICE_FLAG_TC_MQPRIO, pf->flags))) {
1578 		vsi->rss_size = min_t(u16, vsi->rss_size, vsi->ch_rss_size);
1579 	} else {
1580 		vsi->rss_size = min_t(u16, vsi->rss_size, vsi->num_rxq);
1581 
1582 		/* If orig_rss_size is valid and it is less than determined
1583 		 * main VSI's rss_size, update main VSI's rss_size to be
1584 		 * orig_rss_size so that when tc-qdisc is deleted, main VSI
1585 		 * RSS table gets programmed to be correct (whatever it was
1586 		 * to begin with (prior to setup-tc for ADQ config)
1587 		 */
1588 		if (vsi->orig_rss_size && vsi->rss_size < vsi->orig_rss_size &&
1589 		    vsi->orig_rss_size <= vsi->num_rxq) {
1590 			vsi->rss_size = vsi->orig_rss_size;
1591 			/* now orig_rss_size is used, reset it to zero */
1592 			vsi->orig_rss_size = 0;
1593 		}
1594 	}
1595 
1596 	lut = kzalloc(vsi->rss_table_size, GFP_KERNEL);
1597 	if (!lut)
1598 		return -ENOMEM;
1599 
1600 	if (vsi->rss_lut_user)
1601 		memcpy(lut, vsi->rss_lut_user, vsi->rss_table_size);
1602 	else
1603 		ice_fill_rss_lut(lut, vsi->rss_table_size, vsi->rss_size);
1604 
1605 	err = ice_set_rss_lut(vsi, lut, vsi->rss_table_size);
1606 	if (err) {
1607 		dev_err(dev, "set_rss_lut failed, error %d\n", err);
1608 		goto ice_vsi_cfg_rss_exit;
1609 	}
1610 
1611 	key = kzalloc(ICE_GET_SET_RSS_KEY_EXTEND_KEY_SIZE, GFP_KERNEL);
1612 	if (!key) {
1613 		err = -ENOMEM;
1614 		goto ice_vsi_cfg_rss_exit;
1615 	}
1616 
1617 	if (vsi->rss_hkey_user)
1618 		memcpy(key, vsi->rss_hkey_user, ICE_GET_SET_RSS_KEY_EXTEND_KEY_SIZE);
1619 	else
1620 		netdev_rss_key_fill((void *)key, ICE_GET_SET_RSS_KEY_EXTEND_KEY_SIZE);
1621 
1622 	err = ice_set_rss_key(vsi, key);
1623 	if (err)
1624 		dev_err(dev, "set_rss_key failed, error %d\n", err);
1625 
1626 	kfree(key);
1627 ice_vsi_cfg_rss_exit:
1628 	kfree(lut);
1629 	return err;
1630 }
1631 
1632 /**
1633  * ice_vsi_set_vf_rss_flow_fld - Sets VF VSI RSS input set for different flows
1634  * @vsi: VSI to be configured
1635  *
1636  * This function will only be called during the VF VSI setup. Upon successful
1637  * completion of package download, this function will configure default RSS
1638  * input sets for VF VSI.
1639  */
1640 static void ice_vsi_set_vf_rss_flow_fld(struct ice_vsi *vsi)
1641 {
1642 	struct ice_pf *pf = vsi->back;
1643 	struct device *dev;
1644 	int status;
1645 
1646 	dev = ice_pf_to_dev(pf);
1647 	if (ice_is_safe_mode(pf)) {
1648 		dev_dbg(dev, "Advanced RSS disabled. Package download failed, vsi num = %d\n",
1649 			vsi->vsi_num);
1650 		return;
1651 	}
1652 
1653 	status = ice_add_avf_rss_cfg(&pf->hw, vsi->idx, ICE_DEFAULT_RSS_HENA);
1654 	if (status)
1655 		dev_dbg(dev, "ice_add_avf_rss_cfg failed for vsi = %d, error = %d\n",
1656 			vsi->vsi_num, status);
1657 }
1658 
1659 /**
1660  * ice_vsi_set_rss_flow_fld - Sets RSS input set for different flows
1661  * @vsi: VSI to be configured
1662  *
1663  * This function will only be called after successful download package call
1664  * during initialization of PF. Since the downloaded package will erase the
1665  * RSS section, this function will configure RSS input sets for different
1666  * flow types. The last profile added has the highest priority, therefore 2
1667  * tuple profiles (i.e. IPv4 src/dst) are added before 4 tuple profiles
1668  * (i.e. IPv4 src/dst TCP src/dst port).
1669  */
1670 static void ice_vsi_set_rss_flow_fld(struct ice_vsi *vsi)
1671 {
1672 	u16 vsi_handle = vsi->idx, vsi_num = vsi->vsi_num;
1673 	struct ice_pf *pf = vsi->back;
1674 	struct ice_hw *hw = &pf->hw;
1675 	struct device *dev;
1676 	int status;
1677 
1678 	dev = ice_pf_to_dev(pf);
1679 	if (ice_is_safe_mode(pf)) {
1680 		dev_dbg(dev, "Advanced RSS disabled. Package download failed, vsi num = %d\n",
1681 			vsi_num);
1682 		return;
1683 	}
1684 	/* configure RSS for IPv4 with input set IP src/dst */
1685 	status = ice_add_rss_cfg(hw, vsi_handle, ICE_FLOW_HASH_IPV4,
1686 				 ICE_FLOW_SEG_HDR_IPV4);
1687 	if (status)
1688 		dev_dbg(dev, "ice_add_rss_cfg failed for ipv4 flow, vsi = %d, error = %d\n",
1689 			vsi_num, status);
1690 
1691 	/* configure RSS for IPv6 with input set IPv6 src/dst */
1692 	status = ice_add_rss_cfg(hw, vsi_handle, ICE_FLOW_HASH_IPV6,
1693 				 ICE_FLOW_SEG_HDR_IPV6);
1694 	if (status)
1695 		dev_dbg(dev, "ice_add_rss_cfg failed for ipv6 flow, vsi = %d, error = %d\n",
1696 			vsi_num, status);
1697 
1698 	/* configure RSS for tcp4 with input set IP src/dst, TCP src/dst */
1699 	status = ice_add_rss_cfg(hw, vsi_handle, ICE_HASH_TCP_IPV4,
1700 				 ICE_FLOW_SEG_HDR_TCP | ICE_FLOW_SEG_HDR_IPV4);
1701 	if (status)
1702 		dev_dbg(dev, "ice_add_rss_cfg failed for tcp4 flow, vsi = %d, error = %d\n",
1703 			vsi_num, status);
1704 
1705 	/* configure RSS for udp4 with input set IP src/dst, UDP src/dst */
1706 	status = ice_add_rss_cfg(hw, vsi_handle, ICE_HASH_UDP_IPV4,
1707 				 ICE_FLOW_SEG_HDR_UDP | ICE_FLOW_SEG_HDR_IPV4);
1708 	if (status)
1709 		dev_dbg(dev, "ice_add_rss_cfg failed for udp4 flow, vsi = %d, error = %d\n",
1710 			vsi_num, status);
1711 
1712 	/* configure RSS for sctp4 with input set IP src/dst */
1713 	status = ice_add_rss_cfg(hw, vsi_handle, ICE_FLOW_HASH_IPV4,
1714 				 ICE_FLOW_SEG_HDR_SCTP | ICE_FLOW_SEG_HDR_IPV4);
1715 	if (status)
1716 		dev_dbg(dev, "ice_add_rss_cfg failed for sctp4 flow, vsi = %d, error = %d\n",
1717 			vsi_num, status);
1718 
1719 	/* configure RSS for tcp6 with input set IPv6 src/dst, TCP src/dst */
1720 	status = ice_add_rss_cfg(hw, vsi_handle, ICE_HASH_TCP_IPV6,
1721 				 ICE_FLOW_SEG_HDR_TCP | ICE_FLOW_SEG_HDR_IPV6);
1722 	if (status)
1723 		dev_dbg(dev, "ice_add_rss_cfg failed for tcp6 flow, vsi = %d, error = %d\n",
1724 			vsi_num, status);
1725 
1726 	/* configure RSS for udp6 with input set IPv6 src/dst, UDP src/dst */
1727 	status = ice_add_rss_cfg(hw, vsi_handle, ICE_HASH_UDP_IPV6,
1728 				 ICE_FLOW_SEG_HDR_UDP | ICE_FLOW_SEG_HDR_IPV6);
1729 	if (status)
1730 		dev_dbg(dev, "ice_add_rss_cfg failed for udp6 flow, vsi = %d, error = %d\n",
1731 			vsi_num, status);
1732 
1733 	/* configure RSS for sctp6 with input set IPv6 src/dst */
1734 	status = ice_add_rss_cfg(hw, vsi_handle, ICE_FLOW_HASH_IPV6,
1735 				 ICE_FLOW_SEG_HDR_SCTP | ICE_FLOW_SEG_HDR_IPV6);
1736 	if (status)
1737 		dev_dbg(dev, "ice_add_rss_cfg failed for sctp6 flow, vsi = %d, error = %d\n",
1738 			vsi_num, status);
1739 
1740 	status = ice_add_rss_cfg(hw, vsi_handle, ICE_FLOW_HASH_ESP_SPI,
1741 				 ICE_FLOW_SEG_HDR_ESP);
1742 	if (status)
1743 		dev_dbg(dev, "ice_add_rss_cfg failed for esp/spi flow, vsi = %d, error = %d\n",
1744 			vsi_num, status);
1745 }
1746 
1747 /**
1748  * ice_pf_state_is_nominal - checks the PF for nominal state
1749  * @pf: pointer to PF to check
1750  *
1751  * Check the PF's state for a collection of bits that would indicate
1752  * the PF is in a state that would inhibit normal operation for
1753  * driver functionality.
1754  *
1755  * Returns true if PF is in a nominal state, false otherwise
1756  */
1757 bool ice_pf_state_is_nominal(struct ice_pf *pf)
1758 {
1759 	DECLARE_BITMAP(check_bits, ICE_STATE_NBITS) = { 0 };
1760 
1761 	if (!pf)
1762 		return false;
1763 
1764 	bitmap_set(check_bits, 0, ICE_STATE_NOMINAL_CHECK_BITS);
1765 	if (bitmap_intersects(pf->state, check_bits, ICE_STATE_NBITS))
1766 		return false;
1767 
1768 	return true;
1769 }
1770 
1771 /**
1772  * ice_update_eth_stats - Update VSI-specific ethernet statistics counters
1773  * @vsi: the VSI to be updated
1774  */
1775 void ice_update_eth_stats(struct ice_vsi *vsi)
1776 {
1777 	struct ice_eth_stats *prev_es, *cur_es;
1778 	struct ice_hw *hw = &vsi->back->hw;
1779 	u16 vsi_num = vsi->vsi_num;    /* HW absolute index of a VSI */
1780 
1781 	prev_es = &vsi->eth_stats_prev;
1782 	cur_es = &vsi->eth_stats;
1783 
1784 	ice_stat_update40(hw, GLV_GORCL(vsi_num), vsi->stat_offsets_loaded,
1785 			  &prev_es->rx_bytes, &cur_es->rx_bytes);
1786 
1787 	ice_stat_update40(hw, GLV_UPRCL(vsi_num), vsi->stat_offsets_loaded,
1788 			  &prev_es->rx_unicast, &cur_es->rx_unicast);
1789 
1790 	ice_stat_update40(hw, GLV_MPRCL(vsi_num), vsi->stat_offsets_loaded,
1791 			  &prev_es->rx_multicast, &cur_es->rx_multicast);
1792 
1793 	ice_stat_update40(hw, GLV_BPRCL(vsi_num), vsi->stat_offsets_loaded,
1794 			  &prev_es->rx_broadcast, &cur_es->rx_broadcast);
1795 
1796 	ice_stat_update32(hw, GLV_RDPC(vsi_num), vsi->stat_offsets_loaded,
1797 			  &prev_es->rx_discards, &cur_es->rx_discards);
1798 
1799 	ice_stat_update40(hw, GLV_GOTCL(vsi_num), vsi->stat_offsets_loaded,
1800 			  &prev_es->tx_bytes, &cur_es->tx_bytes);
1801 
1802 	ice_stat_update40(hw, GLV_UPTCL(vsi_num), vsi->stat_offsets_loaded,
1803 			  &prev_es->tx_unicast, &cur_es->tx_unicast);
1804 
1805 	ice_stat_update40(hw, GLV_MPTCL(vsi_num), vsi->stat_offsets_loaded,
1806 			  &prev_es->tx_multicast, &cur_es->tx_multicast);
1807 
1808 	ice_stat_update40(hw, GLV_BPTCL(vsi_num), vsi->stat_offsets_loaded,
1809 			  &prev_es->tx_broadcast, &cur_es->tx_broadcast);
1810 
1811 	ice_stat_update32(hw, GLV_TEPC(vsi_num), vsi->stat_offsets_loaded,
1812 			  &prev_es->tx_errors, &cur_es->tx_errors);
1813 
1814 	vsi->stat_offsets_loaded = true;
1815 }
1816 
1817 /**
1818  * ice_vsi_cfg_frame_size - setup max frame size and Rx buffer length
1819  * @vsi: VSI
1820  */
1821 void ice_vsi_cfg_frame_size(struct ice_vsi *vsi)
1822 {
1823 	if (!vsi->netdev || test_bit(ICE_FLAG_LEGACY_RX, vsi->back->flags)) {
1824 		vsi->max_frame = ICE_AQ_SET_MAC_FRAME_SIZE_MAX;
1825 		vsi->rx_buf_len = ICE_RXBUF_2048;
1826 #if (PAGE_SIZE < 8192)
1827 	} else if (!ICE_2K_TOO_SMALL_WITH_PADDING &&
1828 		   (vsi->netdev->mtu <= ETH_DATA_LEN)) {
1829 		vsi->max_frame = ICE_RXBUF_1536 - NET_IP_ALIGN;
1830 		vsi->rx_buf_len = ICE_RXBUF_1536 - NET_IP_ALIGN;
1831 #endif
1832 	} else {
1833 		vsi->max_frame = ICE_AQ_SET_MAC_FRAME_SIZE_MAX;
1834 #if (PAGE_SIZE < 8192)
1835 		vsi->rx_buf_len = ICE_RXBUF_3072;
1836 #else
1837 		vsi->rx_buf_len = ICE_RXBUF_2048;
1838 #endif
1839 	}
1840 }
1841 
1842 /**
1843  * ice_write_qrxflxp_cntxt - write/configure QRXFLXP_CNTXT register
1844  * @hw: HW pointer
1845  * @pf_q: index of the Rx queue in the PF's queue space
1846  * @rxdid: flexible descriptor RXDID
1847  * @prio: priority for the RXDID for this queue
1848  * @ena_ts: true to enable timestamp and false to disable timestamp
1849  */
1850 void
1851 ice_write_qrxflxp_cntxt(struct ice_hw *hw, u16 pf_q, u32 rxdid, u32 prio,
1852 			bool ena_ts)
1853 {
1854 	int regval = rd32(hw, QRXFLXP_CNTXT(pf_q));
1855 
1856 	/* clear any previous values */
1857 	regval &= ~(QRXFLXP_CNTXT_RXDID_IDX_M |
1858 		    QRXFLXP_CNTXT_RXDID_PRIO_M |
1859 		    QRXFLXP_CNTXT_TS_M);
1860 
1861 	regval |= (rxdid << QRXFLXP_CNTXT_RXDID_IDX_S) &
1862 		QRXFLXP_CNTXT_RXDID_IDX_M;
1863 
1864 	regval |= (prio << QRXFLXP_CNTXT_RXDID_PRIO_S) &
1865 		QRXFLXP_CNTXT_RXDID_PRIO_M;
1866 
1867 	if (ena_ts)
1868 		/* Enable TimeSync on this queue */
1869 		regval |= QRXFLXP_CNTXT_TS_M;
1870 
1871 	wr32(hw, QRXFLXP_CNTXT(pf_q), regval);
1872 }
1873 
1874 int ice_vsi_cfg_single_rxq(struct ice_vsi *vsi, u16 q_idx)
1875 {
1876 	if (q_idx >= vsi->num_rxq)
1877 		return -EINVAL;
1878 
1879 	return ice_vsi_cfg_rxq(vsi->rx_rings[q_idx]);
1880 }
1881 
1882 int ice_vsi_cfg_single_txq(struct ice_vsi *vsi, struct ice_tx_ring **tx_rings, u16 q_idx)
1883 {
1884 	struct ice_aqc_add_tx_qgrp *qg_buf;
1885 	int err;
1886 
1887 	if (q_idx >= vsi->alloc_txq || !tx_rings || !tx_rings[q_idx])
1888 		return -EINVAL;
1889 
1890 	qg_buf = kzalloc(struct_size(qg_buf, txqs, 1), GFP_KERNEL);
1891 	if (!qg_buf)
1892 		return -ENOMEM;
1893 
1894 	qg_buf->num_txqs = 1;
1895 
1896 	err = ice_vsi_cfg_txq(vsi, tx_rings[q_idx], qg_buf);
1897 	kfree(qg_buf);
1898 	return err;
1899 }
1900 
1901 /**
1902  * ice_vsi_cfg_rxqs - Configure the VSI for Rx
1903  * @vsi: the VSI being configured
1904  *
1905  * Return 0 on success and a negative value on error
1906  * Configure the Rx VSI for operation.
1907  */
1908 int ice_vsi_cfg_rxqs(struct ice_vsi *vsi)
1909 {
1910 	u16 i;
1911 
1912 	if (vsi->type == ICE_VSI_VF)
1913 		goto setup_rings;
1914 
1915 	ice_vsi_cfg_frame_size(vsi);
1916 setup_rings:
1917 	/* set up individual rings */
1918 	ice_for_each_rxq(vsi, i) {
1919 		int err = ice_vsi_cfg_rxq(vsi->rx_rings[i]);
1920 
1921 		if (err)
1922 			return err;
1923 	}
1924 
1925 	return 0;
1926 }
1927 
1928 /**
1929  * ice_vsi_cfg_txqs - Configure the VSI for Tx
1930  * @vsi: the VSI being configured
1931  * @rings: Tx ring array to be configured
1932  * @count: number of Tx ring array elements
1933  *
1934  * Return 0 on success and a negative value on error
1935  * Configure the Tx VSI for operation.
1936  */
1937 static int
1938 ice_vsi_cfg_txqs(struct ice_vsi *vsi, struct ice_tx_ring **rings, u16 count)
1939 {
1940 	struct ice_aqc_add_tx_qgrp *qg_buf;
1941 	u16 q_idx = 0;
1942 	int err = 0;
1943 
1944 	qg_buf = kzalloc(struct_size(qg_buf, txqs, 1), GFP_KERNEL);
1945 	if (!qg_buf)
1946 		return -ENOMEM;
1947 
1948 	qg_buf->num_txqs = 1;
1949 
1950 	for (q_idx = 0; q_idx < count; q_idx++) {
1951 		err = ice_vsi_cfg_txq(vsi, rings[q_idx], qg_buf);
1952 		if (err)
1953 			goto err_cfg_txqs;
1954 	}
1955 
1956 err_cfg_txqs:
1957 	kfree(qg_buf);
1958 	return err;
1959 }
1960 
1961 /**
1962  * ice_vsi_cfg_lan_txqs - Configure the VSI for Tx
1963  * @vsi: the VSI being configured
1964  *
1965  * Return 0 on success and a negative value on error
1966  * Configure the Tx VSI for operation.
1967  */
1968 int ice_vsi_cfg_lan_txqs(struct ice_vsi *vsi)
1969 {
1970 	return ice_vsi_cfg_txqs(vsi, vsi->tx_rings, vsi->num_txq);
1971 }
1972 
1973 /**
1974  * ice_vsi_cfg_xdp_txqs - Configure Tx queues dedicated for XDP in given VSI
1975  * @vsi: the VSI being configured
1976  *
1977  * Return 0 on success and a negative value on error
1978  * Configure the Tx queues dedicated for XDP in given VSI for operation.
1979  */
1980 int ice_vsi_cfg_xdp_txqs(struct ice_vsi *vsi)
1981 {
1982 	int ret;
1983 	int i;
1984 
1985 	ret = ice_vsi_cfg_txqs(vsi, vsi->xdp_rings, vsi->num_xdp_txq);
1986 	if (ret)
1987 		return ret;
1988 
1989 	ice_for_each_rxq(vsi, i)
1990 		ice_tx_xsk_pool(vsi, i);
1991 
1992 	return ret;
1993 }
1994 
1995 /**
1996  * ice_intrl_usec_to_reg - convert interrupt rate limit to register value
1997  * @intrl: interrupt rate limit in usecs
1998  * @gran: interrupt rate limit granularity in usecs
1999  *
2000  * This function converts a decimal interrupt rate limit in usecs to the format
2001  * expected by firmware.
2002  */
2003 static u32 ice_intrl_usec_to_reg(u8 intrl, u8 gran)
2004 {
2005 	u32 val = intrl / gran;
2006 
2007 	if (val)
2008 		return val | GLINT_RATE_INTRL_ENA_M;
2009 	return 0;
2010 }
2011 
2012 /**
2013  * ice_write_intrl - write throttle rate limit to interrupt specific register
2014  * @q_vector: pointer to interrupt specific structure
2015  * @intrl: throttle rate limit in microseconds to write
2016  */
2017 void ice_write_intrl(struct ice_q_vector *q_vector, u8 intrl)
2018 {
2019 	struct ice_hw *hw = &q_vector->vsi->back->hw;
2020 
2021 	wr32(hw, GLINT_RATE(q_vector->reg_idx),
2022 	     ice_intrl_usec_to_reg(intrl, ICE_INTRL_GRAN_ABOVE_25));
2023 }
2024 
2025 static struct ice_q_vector *ice_pull_qvec_from_rc(struct ice_ring_container *rc)
2026 {
2027 	switch (rc->type) {
2028 	case ICE_RX_CONTAINER:
2029 		if (rc->rx_ring)
2030 			return rc->rx_ring->q_vector;
2031 		break;
2032 	case ICE_TX_CONTAINER:
2033 		if (rc->tx_ring)
2034 			return rc->tx_ring->q_vector;
2035 		break;
2036 	default:
2037 		break;
2038 	}
2039 
2040 	return NULL;
2041 }
2042 
2043 /**
2044  * __ice_write_itr - write throttle rate to register
2045  * @q_vector: pointer to interrupt data structure
2046  * @rc: pointer to ring container
2047  * @itr: throttle rate in microseconds to write
2048  */
2049 static void __ice_write_itr(struct ice_q_vector *q_vector,
2050 			    struct ice_ring_container *rc, u16 itr)
2051 {
2052 	struct ice_hw *hw = &q_vector->vsi->back->hw;
2053 
2054 	wr32(hw, GLINT_ITR(rc->itr_idx, q_vector->reg_idx),
2055 	     ITR_REG_ALIGN(itr) >> ICE_ITR_GRAN_S);
2056 }
2057 
2058 /**
2059  * ice_write_itr - write throttle rate to queue specific register
2060  * @rc: pointer to ring container
2061  * @itr: throttle rate in microseconds to write
2062  */
2063 void ice_write_itr(struct ice_ring_container *rc, u16 itr)
2064 {
2065 	struct ice_q_vector *q_vector;
2066 
2067 	q_vector = ice_pull_qvec_from_rc(rc);
2068 	if (!q_vector)
2069 		return;
2070 
2071 	__ice_write_itr(q_vector, rc, itr);
2072 }
2073 
2074 /**
2075  * ice_set_q_vector_intrl - set up interrupt rate limiting
2076  * @q_vector: the vector to be configured
2077  *
2078  * Interrupt rate limiting is local to the vector, not per-queue so we must
2079  * detect if either ring container has dynamic moderation enabled to decide
2080  * what to set the interrupt rate limit to via INTRL settings. In the case that
2081  * dynamic moderation is disabled on both, write the value with the cached
2082  * setting to make sure INTRL register matches the user visible value.
2083  */
2084 void ice_set_q_vector_intrl(struct ice_q_vector *q_vector)
2085 {
2086 	if (ITR_IS_DYNAMIC(&q_vector->tx) || ITR_IS_DYNAMIC(&q_vector->rx)) {
2087 		/* in the case of dynamic enabled, cap each vector to no more
2088 		 * than (4 us) 250,000 ints/sec, which allows low latency
2089 		 * but still less than 500,000 interrupts per second, which
2090 		 * reduces CPU a bit in the case of the lowest latency
2091 		 * setting. The 4 here is a value in microseconds.
2092 		 */
2093 		ice_write_intrl(q_vector, 4);
2094 	} else {
2095 		ice_write_intrl(q_vector, q_vector->intrl);
2096 	}
2097 }
2098 
2099 /**
2100  * ice_vsi_cfg_msix - MSIX mode Interrupt Config in the HW
2101  * @vsi: the VSI being configured
2102  *
2103  * This configures MSIX mode interrupts for the PF VSI, and should not be used
2104  * for the VF VSI.
2105  */
2106 void ice_vsi_cfg_msix(struct ice_vsi *vsi)
2107 {
2108 	struct ice_pf *pf = vsi->back;
2109 	struct ice_hw *hw = &pf->hw;
2110 	u16 txq = 0, rxq = 0;
2111 	int i, q;
2112 
2113 	ice_for_each_q_vector(vsi, i) {
2114 		struct ice_q_vector *q_vector = vsi->q_vectors[i];
2115 		u16 reg_idx = q_vector->reg_idx;
2116 
2117 		ice_cfg_itr(hw, q_vector);
2118 
2119 		/* Both Transmit Queue Interrupt Cause Control register
2120 		 * and Receive Queue Interrupt Cause control register
2121 		 * expects MSIX_INDX field to be the vector index
2122 		 * within the function space and not the absolute
2123 		 * vector index across PF or across device.
2124 		 * For SR-IOV VF VSIs queue vector index always starts
2125 		 * with 1 since first vector index(0) is used for OICR
2126 		 * in VF space. Since VMDq and other PF VSIs are within
2127 		 * the PF function space, use the vector index that is
2128 		 * tracked for this PF.
2129 		 */
2130 		for (q = 0; q < q_vector->num_ring_tx; q++) {
2131 			ice_cfg_txq_interrupt(vsi, txq, reg_idx,
2132 					      q_vector->tx.itr_idx);
2133 			txq++;
2134 		}
2135 
2136 		for (q = 0; q < q_vector->num_ring_rx; q++) {
2137 			ice_cfg_rxq_interrupt(vsi, rxq, reg_idx,
2138 					      q_vector->rx.itr_idx);
2139 			rxq++;
2140 		}
2141 	}
2142 }
2143 
2144 /**
2145  * ice_vsi_start_all_rx_rings - start/enable all of a VSI's Rx rings
2146  * @vsi: the VSI whose rings are to be enabled
2147  *
2148  * Returns 0 on success and a negative value on error
2149  */
2150 int ice_vsi_start_all_rx_rings(struct ice_vsi *vsi)
2151 {
2152 	return ice_vsi_ctrl_all_rx_rings(vsi, true);
2153 }
2154 
2155 /**
2156  * ice_vsi_stop_all_rx_rings - stop/disable all of a VSI's Rx rings
2157  * @vsi: the VSI whose rings are to be disabled
2158  *
2159  * Returns 0 on success and a negative value on error
2160  */
2161 int ice_vsi_stop_all_rx_rings(struct ice_vsi *vsi)
2162 {
2163 	return ice_vsi_ctrl_all_rx_rings(vsi, false);
2164 }
2165 
2166 /**
2167  * ice_vsi_stop_tx_rings - Disable Tx rings
2168  * @vsi: the VSI being configured
2169  * @rst_src: reset source
2170  * @rel_vmvf_num: Relative ID of VF/VM
2171  * @rings: Tx ring array to be stopped
2172  * @count: number of Tx ring array elements
2173  */
2174 static int
2175 ice_vsi_stop_tx_rings(struct ice_vsi *vsi, enum ice_disq_rst_src rst_src,
2176 		      u16 rel_vmvf_num, struct ice_tx_ring **rings, u16 count)
2177 {
2178 	u16 q_idx;
2179 
2180 	if (vsi->num_txq > ICE_LAN_TXQ_MAX_QDIS)
2181 		return -EINVAL;
2182 
2183 	for (q_idx = 0; q_idx < count; q_idx++) {
2184 		struct ice_txq_meta txq_meta = { };
2185 		int status;
2186 
2187 		if (!rings || !rings[q_idx])
2188 			return -EINVAL;
2189 
2190 		ice_fill_txq_meta(vsi, rings[q_idx], &txq_meta);
2191 		status = ice_vsi_stop_tx_ring(vsi, rst_src, rel_vmvf_num,
2192 					      rings[q_idx], &txq_meta);
2193 
2194 		if (status)
2195 			return status;
2196 	}
2197 
2198 	return 0;
2199 }
2200 
2201 /**
2202  * ice_vsi_stop_lan_tx_rings - Disable LAN Tx rings
2203  * @vsi: the VSI being configured
2204  * @rst_src: reset source
2205  * @rel_vmvf_num: Relative ID of VF/VM
2206  */
2207 int
2208 ice_vsi_stop_lan_tx_rings(struct ice_vsi *vsi, enum ice_disq_rst_src rst_src,
2209 			  u16 rel_vmvf_num)
2210 {
2211 	return ice_vsi_stop_tx_rings(vsi, rst_src, rel_vmvf_num, vsi->tx_rings, vsi->num_txq);
2212 }
2213 
2214 /**
2215  * ice_vsi_stop_xdp_tx_rings - Disable XDP Tx rings
2216  * @vsi: the VSI being configured
2217  */
2218 int ice_vsi_stop_xdp_tx_rings(struct ice_vsi *vsi)
2219 {
2220 	return ice_vsi_stop_tx_rings(vsi, ICE_NO_RESET, 0, vsi->xdp_rings, vsi->num_xdp_txq);
2221 }
2222 
2223 /**
2224  * ice_vsi_is_vlan_pruning_ena - check if VLAN pruning is enabled or not
2225  * @vsi: VSI to check whether or not VLAN pruning is enabled.
2226  *
2227  * returns true if Rx VLAN pruning is enabled and false otherwise.
2228  */
2229 bool ice_vsi_is_vlan_pruning_ena(struct ice_vsi *vsi)
2230 {
2231 	if (!vsi)
2232 		return false;
2233 
2234 	return (vsi->info.sw_flags2 & ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA);
2235 }
2236 
2237 static void ice_vsi_set_tc_cfg(struct ice_vsi *vsi)
2238 {
2239 	if (!test_bit(ICE_FLAG_DCB_ENA, vsi->back->flags)) {
2240 		vsi->tc_cfg.ena_tc = ICE_DFLT_TRAFFIC_CLASS;
2241 		vsi->tc_cfg.numtc = 1;
2242 		return;
2243 	}
2244 
2245 	/* set VSI TC information based on DCB config */
2246 	ice_vsi_set_dcb_tc_cfg(vsi);
2247 }
2248 
2249 /**
2250  * ice_vsi_set_q_vectors_reg_idx - set the HW register index for all q_vectors
2251  * @vsi: VSI to set the q_vectors register index on
2252  */
2253 static int
2254 ice_vsi_set_q_vectors_reg_idx(struct ice_vsi *vsi)
2255 {
2256 	u16 i;
2257 
2258 	if (!vsi || !vsi->q_vectors)
2259 		return -EINVAL;
2260 
2261 	ice_for_each_q_vector(vsi, i) {
2262 		struct ice_q_vector *q_vector = vsi->q_vectors[i];
2263 
2264 		if (!q_vector) {
2265 			dev_err(ice_pf_to_dev(vsi->back), "Failed to set reg_idx on q_vector %d VSI %d\n",
2266 				i, vsi->vsi_num);
2267 			goto clear_reg_idx;
2268 		}
2269 
2270 		if (vsi->type == ICE_VSI_VF) {
2271 			struct ice_vf *vf = vsi->vf;
2272 
2273 			q_vector->reg_idx = ice_calc_vf_reg_idx(vf, q_vector);
2274 		} else {
2275 			q_vector->reg_idx =
2276 				q_vector->v_idx + vsi->base_vector;
2277 		}
2278 	}
2279 
2280 	return 0;
2281 
2282 clear_reg_idx:
2283 	ice_for_each_q_vector(vsi, i) {
2284 		struct ice_q_vector *q_vector = vsi->q_vectors[i];
2285 
2286 		if (q_vector)
2287 			q_vector->reg_idx = 0;
2288 	}
2289 
2290 	return -EINVAL;
2291 }
2292 
2293 /**
2294  * ice_cfg_sw_lldp - Config switch rules for LLDP packet handling
2295  * @vsi: the VSI being configured
2296  * @tx: bool to determine Tx or Rx rule
2297  * @create: bool to determine create or remove Rule
2298  */
2299 void ice_cfg_sw_lldp(struct ice_vsi *vsi, bool tx, bool create)
2300 {
2301 	int (*eth_fltr)(struct ice_vsi *v, u16 type, u16 flag,
2302 			enum ice_sw_fwd_act_type act);
2303 	struct ice_pf *pf = vsi->back;
2304 	struct device *dev;
2305 	int status;
2306 
2307 	dev = ice_pf_to_dev(pf);
2308 	eth_fltr = create ? ice_fltr_add_eth : ice_fltr_remove_eth;
2309 
2310 	if (tx) {
2311 		status = eth_fltr(vsi, ETH_P_LLDP, ICE_FLTR_TX,
2312 				  ICE_DROP_PACKET);
2313 	} else {
2314 		if (ice_fw_supports_lldp_fltr_ctrl(&pf->hw)) {
2315 			status = ice_lldp_fltr_add_remove(&pf->hw, vsi->vsi_num,
2316 							  create);
2317 		} else {
2318 			status = eth_fltr(vsi, ETH_P_LLDP, ICE_FLTR_RX,
2319 					  ICE_FWD_TO_VSI);
2320 		}
2321 	}
2322 
2323 	if (status)
2324 		dev_dbg(dev, "Fail %s %s LLDP rule on VSI %i error: %d\n",
2325 			create ? "adding" : "removing", tx ? "TX" : "RX",
2326 			vsi->vsi_num, status);
2327 }
2328 
2329 /**
2330  * ice_set_agg_vsi - sets up scheduler aggregator node and move VSI into it
2331  * @vsi: pointer to the VSI
2332  *
2333  * This function will allocate new scheduler aggregator now if needed and will
2334  * move specified VSI into it.
2335  */
2336 static void ice_set_agg_vsi(struct ice_vsi *vsi)
2337 {
2338 	struct device *dev = ice_pf_to_dev(vsi->back);
2339 	struct ice_agg_node *agg_node_iter = NULL;
2340 	u32 agg_id = ICE_INVALID_AGG_NODE_ID;
2341 	struct ice_agg_node *agg_node = NULL;
2342 	int node_offset, max_agg_nodes = 0;
2343 	struct ice_port_info *port_info;
2344 	struct ice_pf *pf = vsi->back;
2345 	u32 agg_node_id_start = 0;
2346 	int status;
2347 
2348 	/* create (as needed) scheduler aggregator node and move VSI into
2349 	 * corresponding aggregator node
2350 	 * - PF aggregator node to contains VSIs of type _PF and _CTRL
2351 	 * - VF aggregator nodes will contain VF VSI
2352 	 */
2353 	port_info = pf->hw.port_info;
2354 	if (!port_info)
2355 		return;
2356 
2357 	switch (vsi->type) {
2358 	case ICE_VSI_CTRL:
2359 	case ICE_VSI_CHNL:
2360 	case ICE_VSI_LB:
2361 	case ICE_VSI_PF:
2362 	case ICE_VSI_SWITCHDEV_CTRL:
2363 		max_agg_nodes = ICE_MAX_PF_AGG_NODES;
2364 		agg_node_id_start = ICE_PF_AGG_NODE_ID_START;
2365 		agg_node_iter = &pf->pf_agg_node[0];
2366 		break;
2367 	case ICE_VSI_VF:
2368 		/* user can create 'n' VFs on a given PF, but since max children
2369 		 * per aggregator node can be only 64. Following code handles
2370 		 * aggregator(s) for VF VSIs, either selects a agg_node which
2371 		 * was already created provided num_vsis < 64, otherwise
2372 		 * select next available node, which will be created
2373 		 */
2374 		max_agg_nodes = ICE_MAX_VF_AGG_NODES;
2375 		agg_node_id_start = ICE_VF_AGG_NODE_ID_START;
2376 		agg_node_iter = &pf->vf_agg_node[0];
2377 		break;
2378 	default:
2379 		/* other VSI type, handle later if needed */
2380 		dev_dbg(dev, "unexpected VSI type %s\n",
2381 			ice_vsi_type_str(vsi->type));
2382 		return;
2383 	}
2384 
2385 	/* find the appropriate aggregator node */
2386 	for (node_offset = 0; node_offset < max_agg_nodes; node_offset++) {
2387 		/* see if we can find space in previously created
2388 		 * node if num_vsis < 64, otherwise skip
2389 		 */
2390 		if (agg_node_iter->num_vsis &&
2391 		    agg_node_iter->num_vsis == ICE_MAX_VSIS_IN_AGG_NODE) {
2392 			agg_node_iter++;
2393 			continue;
2394 		}
2395 
2396 		if (agg_node_iter->valid &&
2397 		    agg_node_iter->agg_id != ICE_INVALID_AGG_NODE_ID) {
2398 			agg_id = agg_node_iter->agg_id;
2399 			agg_node = agg_node_iter;
2400 			break;
2401 		}
2402 
2403 		/* find unclaimed agg_id */
2404 		if (agg_node_iter->agg_id == ICE_INVALID_AGG_NODE_ID) {
2405 			agg_id = node_offset + agg_node_id_start;
2406 			agg_node = agg_node_iter;
2407 			break;
2408 		}
2409 		/* move to next agg_node */
2410 		agg_node_iter++;
2411 	}
2412 
2413 	if (!agg_node)
2414 		return;
2415 
2416 	/* if selected aggregator node was not created, create it */
2417 	if (!agg_node->valid) {
2418 		status = ice_cfg_agg(port_info, agg_id, ICE_AGG_TYPE_AGG,
2419 				     (u8)vsi->tc_cfg.ena_tc);
2420 		if (status) {
2421 			dev_err(dev, "unable to create aggregator node with agg_id %u\n",
2422 				agg_id);
2423 			return;
2424 		}
2425 		/* aggregator node is created, store the needed info */
2426 		agg_node->valid = true;
2427 		agg_node->agg_id = agg_id;
2428 	}
2429 
2430 	/* move VSI to corresponding aggregator node */
2431 	status = ice_move_vsi_to_agg(port_info, agg_id, vsi->idx,
2432 				     (u8)vsi->tc_cfg.ena_tc);
2433 	if (status) {
2434 		dev_err(dev, "unable to move VSI idx %u into aggregator %u node",
2435 			vsi->idx, agg_id);
2436 		return;
2437 	}
2438 
2439 	/* keep active children count for aggregator node */
2440 	agg_node->num_vsis++;
2441 
2442 	/* cache the 'agg_id' in VSI, so that after reset - VSI will be moved
2443 	 * to aggregator node
2444 	 */
2445 	vsi->agg_node = agg_node;
2446 	dev_dbg(dev, "successfully moved VSI idx %u tc_bitmap 0x%x) into aggregator node %d which has num_vsis %u\n",
2447 		vsi->idx, vsi->tc_cfg.ena_tc, vsi->agg_node->agg_id,
2448 		vsi->agg_node->num_vsis);
2449 }
2450 
2451 /**
2452  * ice_vsi_setup - Set up a VSI by a given type
2453  * @pf: board private structure
2454  * @pi: pointer to the port_info instance
2455  * @vsi_type: VSI type
2456  * @vf: pointer to VF to which this VSI connects. This field is used primarily
2457  *      for the ICE_VSI_VF type. Other VSI types should pass NULL.
2458  * @ch: ptr to channel
2459  *
2460  * This allocates the sw VSI structure and its queue resources.
2461  *
2462  * Returns pointer to the successfully allocated and configured VSI sw struct on
2463  * success, NULL on failure.
2464  */
2465 struct ice_vsi *
2466 ice_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi,
2467 	      enum ice_vsi_type vsi_type, struct ice_vf *vf,
2468 	      struct ice_channel *ch)
2469 {
2470 	u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 };
2471 	struct device *dev = ice_pf_to_dev(pf);
2472 	struct ice_vsi *vsi;
2473 	int ret, i;
2474 
2475 	if (vsi_type == ICE_VSI_CHNL)
2476 		vsi = ice_vsi_alloc(pf, vsi_type, ch, NULL);
2477 	else if (vsi_type == ICE_VSI_VF || vsi_type == ICE_VSI_CTRL)
2478 		vsi = ice_vsi_alloc(pf, vsi_type, NULL, vf);
2479 	else
2480 		vsi = ice_vsi_alloc(pf, vsi_type, NULL, NULL);
2481 
2482 	if (!vsi) {
2483 		dev_err(dev, "could not allocate VSI\n");
2484 		return NULL;
2485 	}
2486 
2487 	vsi->port_info = pi;
2488 	vsi->vsw = pf->first_sw;
2489 	if (vsi->type == ICE_VSI_PF)
2490 		vsi->ethtype = ETH_P_PAUSE;
2491 
2492 	ice_alloc_fd_res(vsi);
2493 
2494 	if (vsi_type != ICE_VSI_CHNL) {
2495 		if (ice_vsi_get_qs(vsi)) {
2496 			dev_err(dev, "Failed to allocate queues. vsi->idx = %d\n",
2497 				vsi->idx);
2498 			goto unroll_vsi_alloc;
2499 		}
2500 	}
2501 
2502 	/* set RSS capabilities */
2503 	ice_vsi_set_rss_params(vsi);
2504 
2505 	/* set TC configuration */
2506 	ice_vsi_set_tc_cfg(vsi);
2507 
2508 	/* create the VSI */
2509 	ret = ice_vsi_init(vsi, true);
2510 	if (ret)
2511 		goto unroll_get_qs;
2512 
2513 	ice_vsi_init_vlan_ops(vsi);
2514 
2515 	switch (vsi->type) {
2516 	case ICE_VSI_CTRL:
2517 	case ICE_VSI_SWITCHDEV_CTRL:
2518 	case ICE_VSI_PF:
2519 		ret = ice_vsi_alloc_q_vectors(vsi);
2520 		if (ret)
2521 			goto unroll_vsi_init;
2522 
2523 		ret = ice_vsi_setup_vector_base(vsi);
2524 		if (ret)
2525 			goto unroll_alloc_q_vector;
2526 
2527 		ret = ice_vsi_set_q_vectors_reg_idx(vsi);
2528 		if (ret)
2529 			goto unroll_vector_base;
2530 
2531 		ret = ice_vsi_alloc_rings(vsi);
2532 		if (ret)
2533 			goto unroll_vector_base;
2534 
2535 		ice_vsi_map_rings_to_vectors(vsi);
2536 
2537 		/* ICE_VSI_CTRL does not need RSS so skip RSS processing */
2538 		if (vsi->type != ICE_VSI_CTRL)
2539 			/* Do not exit if configuring RSS had an issue, at
2540 			 * least receive traffic on first queue. Hence no
2541 			 * need to capture return value
2542 			 */
2543 			if (test_bit(ICE_FLAG_RSS_ENA, pf->flags)) {
2544 				ice_vsi_cfg_rss_lut_key(vsi);
2545 				ice_vsi_set_rss_flow_fld(vsi);
2546 			}
2547 		ice_init_arfs(vsi);
2548 		break;
2549 	case ICE_VSI_CHNL:
2550 		if (test_bit(ICE_FLAG_RSS_ENA, pf->flags)) {
2551 			ice_vsi_cfg_rss_lut_key(vsi);
2552 			ice_vsi_set_rss_flow_fld(vsi);
2553 		}
2554 		break;
2555 	case ICE_VSI_VF:
2556 		/* VF driver will take care of creating netdev for this type and
2557 		 * map queues to vectors through Virtchnl, PF driver only
2558 		 * creates a VSI and corresponding structures for bookkeeping
2559 		 * purpose
2560 		 */
2561 		ret = ice_vsi_alloc_q_vectors(vsi);
2562 		if (ret)
2563 			goto unroll_vsi_init;
2564 
2565 		ret = ice_vsi_alloc_rings(vsi);
2566 		if (ret)
2567 			goto unroll_alloc_q_vector;
2568 
2569 		ret = ice_vsi_set_q_vectors_reg_idx(vsi);
2570 		if (ret)
2571 			goto unroll_vector_base;
2572 
2573 		/* Do not exit if configuring RSS had an issue, at least
2574 		 * receive traffic on first queue. Hence no need to capture
2575 		 * return value
2576 		 */
2577 		if (test_bit(ICE_FLAG_RSS_ENA, pf->flags)) {
2578 			ice_vsi_cfg_rss_lut_key(vsi);
2579 			ice_vsi_set_vf_rss_flow_fld(vsi);
2580 		}
2581 		break;
2582 	case ICE_VSI_LB:
2583 		ret = ice_vsi_alloc_rings(vsi);
2584 		if (ret)
2585 			goto unroll_vsi_init;
2586 		break;
2587 	default:
2588 		/* clean up the resources and exit */
2589 		goto unroll_vsi_init;
2590 	}
2591 
2592 	/* configure VSI nodes based on number of queues and TC's */
2593 	ice_for_each_traffic_class(i) {
2594 		if (!(vsi->tc_cfg.ena_tc & BIT(i)))
2595 			continue;
2596 
2597 		if (vsi->type == ICE_VSI_CHNL) {
2598 			if (!vsi->alloc_txq && vsi->num_txq)
2599 				max_txqs[i] = vsi->num_txq;
2600 			else
2601 				max_txqs[i] = pf->num_lan_tx;
2602 		} else {
2603 			max_txqs[i] = vsi->alloc_txq;
2604 		}
2605 	}
2606 
2607 	dev_dbg(dev, "vsi->tc_cfg.ena_tc = %d\n", vsi->tc_cfg.ena_tc);
2608 	ret = ice_cfg_vsi_lan(vsi->port_info, vsi->idx, vsi->tc_cfg.ena_tc,
2609 			      max_txqs);
2610 	if (ret) {
2611 		dev_err(dev, "VSI %d failed lan queue config, error %d\n",
2612 			vsi->vsi_num, ret);
2613 		goto unroll_clear_rings;
2614 	}
2615 
2616 	/* Add switch rule to drop all Tx Flow Control Frames, of look up
2617 	 * type ETHERTYPE from VSIs, and restrict malicious VF from sending
2618 	 * out PAUSE or PFC frames. If enabled, FW can still send FC frames.
2619 	 * The rule is added once for PF VSI in order to create appropriate
2620 	 * recipe, since VSI/VSI list is ignored with drop action...
2621 	 * Also add rules to handle LLDP Tx packets.  Tx LLDP packets need to
2622 	 * be dropped so that VFs cannot send LLDP packets to reconfig DCB
2623 	 * settings in the HW.
2624 	 */
2625 	if (!ice_is_safe_mode(pf))
2626 		if (vsi->type == ICE_VSI_PF) {
2627 			ice_fltr_add_eth(vsi, ETH_P_PAUSE, ICE_FLTR_TX,
2628 					 ICE_DROP_PACKET);
2629 			ice_cfg_sw_lldp(vsi, true, true);
2630 		}
2631 
2632 	if (!vsi->agg_node)
2633 		ice_set_agg_vsi(vsi);
2634 	return vsi;
2635 
2636 unroll_clear_rings:
2637 	ice_vsi_clear_rings(vsi);
2638 unroll_vector_base:
2639 	/* reclaim SW interrupts back to the common pool */
2640 	ice_free_res(pf->irq_tracker, vsi->base_vector, vsi->idx);
2641 	pf->num_avail_sw_msix += vsi->num_q_vectors;
2642 unroll_alloc_q_vector:
2643 	ice_vsi_free_q_vectors(vsi);
2644 unroll_vsi_init:
2645 	ice_vsi_delete(vsi);
2646 unroll_get_qs:
2647 	ice_vsi_put_qs(vsi);
2648 unroll_vsi_alloc:
2649 	if (vsi_type == ICE_VSI_VF)
2650 		ice_enable_lag(pf->lag);
2651 	ice_vsi_clear(vsi);
2652 
2653 	return NULL;
2654 }
2655 
2656 /**
2657  * ice_vsi_release_msix - Clear the queue to Interrupt mapping in HW
2658  * @vsi: the VSI being cleaned up
2659  */
2660 static void ice_vsi_release_msix(struct ice_vsi *vsi)
2661 {
2662 	struct ice_pf *pf = vsi->back;
2663 	struct ice_hw *hw = &pf->hw;
2664 	u32 txq = 0;
2665 	u32 rxq = 0;
2666 	int i, q;
2667 
2668 	ice_for_each_q_vector(vsi, i) {
2669 		struct ice_q_vector *q_vector = vsi->q_vectors[i];
2670 
2671 		ice_write_intrl(q_vector, 0);
2672 		for (q = 0; q < q_vector->num_ring_tx; q++) {
2673 			ice_write_itr(&q_vector->tx, 0);
2674 			wr32(hw, QINT_TQCTL(vsi->txq_map[txq]), 0);
2675 			if (ice_is_xdp_ena_vsi(vsi)) {
2676 				u32 xdp_txq = txq + vsi->num_xdp_txq;
2677 
2678 				wr32(hw, QINT_TQCTL(vsi->txq_map[xdp_txq]), 0);
2679 			}
2680 			txq++;
2681 		}
2682 
2683 		for (q = 0; q < q_vector->num_ring_rx; q++) {
2684 			ice_write_itr(&q_vector->rx, 0);
2685 			wr32(hw, QINT_RQCTL(vsi->rxq_map[rxq]), 0);
2686 			rxq++;
2687 		}
2688 	}
2689 
2690 	ice_flush(hw);
2691 }
2692 
2693 /**
2694  * ice_vsi_free_irq - Free the IRQ association with the OS
2695  * @vsi: the VSI being configured
2696  */
2697 void ice_vsi_free_irq(struct ice_vsi *vsi)
2698 {
2699 	struct ice_pf *pf = vsi->back;
2700 	int base = vsi->base_vector;
2701 	int i;
2702 
2703 	if (!vsi->q_vectors || !vsi->irqs_ready)
2704 		return;
2705 
2706 	ice_vsi_release_msix(vsi);
2707 	if (vsi->type == ICE_VSI_VF)
2708 		return;
2709 
2710 	vsi->irqs_ready = false;
2711 	ice_free_cpu_rx_rmap(vsi);
2712 
2713 	ice_for_each_q_vector(vsi, i) {
2714 		u16 vector = i + base;
2715 		int irq_num;
2716 
2717 		irq_num = pf->msix_entries[vector].vector;
2718 
2719 		/* free only the irqs that were actually requested */
2720 		if (!vsi->q_vectors[i] ||
2721 		    !(vsi->q_vectors[i]->num_ring_tx ||
2722 		      vsi->q_vectors[i]->num_ring_rx))
2723 			continue;
2724 
2725 		/* clear the affinity notifier in the IRQ descriptor */
2726 		if (!IS_ENABLED(CONFIG_RFS_ACCEL))
2727 			irq_set_affinity_notifier(irq_num, NULL);
2728 
2729 		/* clear the affinity_mask in the IRQ descriptor */
2730 		irq_set_affinity_hint(irq_num, NULL);
2731 		synchronize_irq(irq_num);
2732 		devm_free_irq(ice_pf_to_dev(pf), irq_num, vsi->q_vectors[i]);
2733 	}
2734 }
2735 
2736 /**
2737  * ice_vsi_free_tx_rings - Free Tx resources for VSI queues
2738  * @vsi: the VSI having resources freed
2739  */
2740 void ice_vsi_free_tx_rings(struct ice_vsi *vsi)
2741 {
2742 	int i;
2743 
2744 	if (!vsi->tx_rings)
2745 		return;
2746 
2747 	ice_for_each_txq(vsi, i)
2748 		if (vsi->tx_rings[i] && vsi->tx_rings[i]->desc)
2749 			ice_free_tx_ring(vsi->tx_rings[i]);
2750 }
2751 
2752 /**
2753  * ice_vsi_free_rx_rings - Free Rx resources for VSI queues
2754  * @vsi: the VSI having resources freed
2755  */
2756 void ice_vsi_free_rx_rings(struct ice_vsi *vsi)
2757 {
2758 	int i;
2759 
2760 	if (!vsi->rx_rings)
2761 		return;
2762 
2763 	ice_for_each_rxq(vsi, i)
2764 		if (vsi->rx_rings[i] && vsi->rx_rings[i]->desc)
2765 			ice_free_rx_ring(vsi->rx_rings[i]);
2766 }
2767 
2768 /**
2769  * ice_vsi_close - Shut down a VSI
2770  * @vsi: the VSI being shut down
2771  */
2772 void ice_vsi_close(struct ice_vsi *vsi)
2773 {
2774 	if (!test_and_set_bit(ICE_VSI_DOWN, vsi->state))
2775 		ice_down(vsi);
2776 
2777 	ice_vsi_free_irq(vsi);
2778 	ice_vsi_free_tx_rings(vsi);
2779 	ice_vsi_free_rx_rings(vsi);
2780 }
2781 
2782 /**
2783  * ice_ena_vsi - resume a VSI
2784  * @vsi: the VSI being resume
2785  * @locked: is the rtnl_lock already held
2786  */
2787 int ice_ena_vsi(struct ice_vsi *vsi, bool locked)
2788 {
2789 	int err = 0;
2790 
2791 	if (!test_bit(ICE_VSI_NEEDS_RESTART, vsi->state))
2792 		return 0;
2793 
2794 	clear_bit(ICE_VSI_NEEDS_RESTART, vsi->state);
2795 
2796 	if (vsi->netdev && vsi->type == ICE_VSI_PF) {
2797 		if (netif_running(vsi->netdev)) {
2798 			if (!locked)
2799 				rtnl_lock();
2800 
2801 			err = ice_open_internal(vsi->netdev);
2802 
2803 			if (!locked)
2804 				rtnl_unlock();
2805 		}
2806 	} else if (vsi->type == ICE_VSI_CTRL) {
2807 		err = ice_vsi_open_ctrl(vsi);
2808 	}
2809 
2810 	return err;
2811 }
2812 
2813 /**
2814  * ice_dis_vsi - pause a VSI
2815  * @vsi: the VSI being paused
2816  * @locked: is the rtnl_lock already held
2817  */
2818 void ice_dis_vsi(struct ice_vsi *vsi, bool locked)
2819 {
2820 	if (test_bit(ICE_VSI_DOWN, vsi->state))
2821 		return;
2822 
2823 	set_bit(ICE_VSI_NEEDS_RESTART, vsi->state);
2824 
2825 	if (vsi->type == ICE_VSI_PF && vsi->netdev) {
2826 		if (netif_running(vsi->netdev)) {
2827 			if (!locked)
2828 				rtnl_lock();
2829 
2830 			ice_vsi_close(vsi);
2831 
2832 			if (!locked)
2833 				rtnl_unlock();
2834 		} else {
2835 			ice_vsi_close(vsi);
2836 		}
2837 	} else if (vsi->type == ICE_VSI_CTRL ||
2838 		   vsi->type == ICE_VSI_SWITCHDEV_CTRL) {
2839 		ice_vsi_close(vsi);
2840 	}
2841 }
2842 
2843 /**
2844  * ice_vsi_dis_irq - Mask off queue interrupt generation on the VSI
2845  * @vsi: the VSI being un-configured
2846  */
2847 void ice_vsi_dis_irq(struct ice_vsi *vsi)
2848 {
2849 	int base = vsi->base_vector;
2850 	struct ice_pf *pf = vsi->back;
2851 	struct ice_hw *hw = &pf->hw;
2852 	u32 val;
2853 	int i;
2854 
2855 	/* disable interrupt causation from each queue */
2856 	if (vsi->tx_rings) {
2857 		ice_for_each_txq(vsi, i) {
2858 			if (vsi->tx_rings[i]) {
2859 				u16 reg;
2860 
2861 				reg = vsi->tx_rings[i]->reg_idx;
2862 				val = rd32(hw, QINT_TQCTL(reg));
2863 				val &= ~QINT_TQCTL_CAUSE_ENA_M;
2864 				wr32(hw, QINT_TQCTL(reg), val);
2865 			}
2866 		}
2867 	}
2868 
2869 	if (vsi->rx_rings) {
2870 		ice_for_each_rxq(vsi, i) {
2871 			if (vsi->rx_rings[i]) {
2872 				u16 reg;
2873 
2874 				reg = vsi->rx_rings[i]->reg_idx;
2875 				val = rd32(hw, QINT_RQCTL(reg));
2876 				val &= ~QINT_RQCTL_CAUSE_ENA_M;
2877 				wr32(hw, QINT_RQCTL(reg), val);
2878 			}
2879 		}
2880 	}
2881 
2882 	/* disable each interrupt */
2883 	ice_for_each_q_vector(vsi, i) {
2884 		if (!vsi->q_vectors[i])
2885 			continue;
2886 		wr32(hw, GLINT_DYN_CTL(vsi->q_vectors[i]->reg_idx), 0);
2887 	}
2888 
2889 	ice_flush(hw);
2890 
2891 	/* don't call synchronize_irq() for VF's from the host */
2892 	if (vsi->type == ICE_VSI_VF)
2893 		return;
2894 
2895 	ice_for_each_q_vector(vsi, i)
2896 		synchronize_irq(pf->msix_entries[i + base].vector);
2897 }
2898 
2899 /**
2900  * ice_napi_del - Remove NAPI handler for the VSI
2901  * @vsi: VSI for which NAPI handler is to be removed
2902  */
2903 void ice_napi_del(struct ice_vsi *vsi)
2904 {
2905 	int v_idx;
2906 
2907 	if (!vsi->netdev)
2908 		return;
2909 
2910 	ice_for_each_q_vector(vsi, v_idx)
2911 		netif_napi_del(&vsi->q_vectors[v_idx]->napi);
2912 }
2913 
2914 /**
2915  * ice_free_vf_ctrl_res - Free the VF control VSI resource
2916  * @pf: pointer to PF structure
2917  * @vsi: the VSI to free resources for
2918  *
2919  * Check if the VF control VSI resource is still in use. If no VF is using it
2920  * any more, release the VSI resource. Otherwise, leave it to be cleaned up
2921  * once no other VF uses it.
2922  */
2923 static void ice_free_vf_ctrl_res(struct ice_pf *pf,  struct ice_vsi *vsi)
2924 {
2925 	struct ice_vf *vf;
2926 	unsigned int bkt;
2927 
2928 	rcu_read_lock();
2929 	ice_for_each_vf_rcu(pf, bkt, vf) {
2930 		if (vf != vsi->vf && vf->ctrl_vsi_idx != ICE_NO_VSI) {
2931 			rcu_read_unlock();
2932 			return;
2933 		}
2934 	}
2935 	rcu_read_unlock();
2936 
2937 	/* No other VFs left that have control VSI. It is now safe to reclaim
2938 	 * SW interrupts back to the common pool.
2939 	 */
2940 	ice_free_res(pf->irq_tracker, vsi->base_vector,
2941 		     ICE_RES_VF_CTRL_VEC_ID);
2942 	pf->num_avail_sw_msix += vsi->num_q_vectors;
2943 }
2944 
2945 /**
2946  * ice_vsi_release - Delete a VSI and free its resources
2947  * @vsi: the VSI being removed
2948  *
2949  * Returns 0 on success or < 0 on error
2950  */
2951 int ice_vsi_release(struct ice_vsi *vsi)
2952 {
2953 	struct ice_pf *pf;
2954 	int err;
2955 
2956 	if (!vsi->back)
2957 		return -ENODEV;
2958 	pf = vsi->back;
2959 
2960 	/* do not unregister while driver is in the reset recovery pending
2961 	 * state. Since reset/rebuild happens through PF service task workqueue,
2962 	 * it's not a good idea to unregister netdev that is associated to the
2963 	 * PF that is running the work queue items currently. This is done to
2964 	 * avoid check_flush_dependency() warning on this wq
2965 	 */
2966 	if (vsi->netdev && !ice_is_reset_in_progress(pf->state) &&
2967 	    (test_bit(ICE_VSI_NETDEV_REGISTERED, vsi->state))) {
2968 		unregister_netdev(vsi->netdev);
2969 		clear_bit(ICE_VSI_NETDEV_REGISTERED, vsi->state);
2970 	}
2971 
2972 	if (vsi->type == ICE_VSI_PF)
2973 		ice_devlink_destroy_pf_port(pf);
2974 
2975 	if (test_bit(ICE_FLAG_RSS_ENA, pf->flags))
2976 		ice_rss_clean(vsi);
2977 
2978 	/* Disable VSI and free resources */
2979 	if (vsi->type != ICE_VSI_LB)
2980 		ice_vsi_dis_irq(vsi);
2981 	ice_vsi_close(vsi);
2982 
2983 	/* SR-IOV determines needed MSIX resources all at once instead of per
2984 	 * VSI since when VFs are spawned we know how many VFs there are and how
2985 	 * many interrupts each VF needs. SR-IOV MSIX resources are also
2986 	 * cleared in the same manner.
2987 	 */
2988 	if (vsi->type == ICE_VSI_CTRL && vsi->vf) {
2989 		ice_free_vf_ctrl_res(pf, vsi);
2990 	} else if (vsi->type != ICE_VSI_VF) {
2991 		/* reclaim SW interrupts back to the common pool */
2992 		ice_free_res(pf->irq_tracker, vsi->base_vector, vsi->idx);
2993 		pf->num_avail_sw_msix += vsi->num_q_vectors;
2994 	}
2995 
2996 	if (!ice_is_safe_mode(pf)) {
2997 		if (vsi->type == ICE_VSI_PF) {
2998 			ice_fltr_remove_eth(vsi, ETH_P_PAUSE, ICE_FLTR_TX,
2999 					    ICE_DROP_PACKET);
3000 			ice_cfg_sw_lldp(vsi, true, false);
3001 			/* The Rx rule will only exist to remove if the LLDP FW
3002 			 * engine is currently stopped
3003 			 */
3004 			if (!test_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags))
3005 				ice_cfg_sw_lldp(vsi, false, false);
3006 		}
3007 	}
3008 
3009 	if (ice_is_vsi_dflt_vsi(vsi))
3010 		ice_clear_dflt_vsi(vsi);
3011 	ice_fltr_remove_all(vsi);
3012 	ice_rm_vsi_lan_cfg(vsi->port_info, vsi->idx);
3013 	err = ice_rm_vsi_rdma_cfg(vsi->port_info, vsi->idx);
3014 	if (err)
3015 		dev_err(ice_pf_to_dev(vsi->back), "Failed to remove RDMA scheduler config for VSI %u, err %d\n",
3016 			vsi->vsi_num, err);
3017 	ice_vsi_delete(vsi);
3018 	ice_vsi_free_q_vectors(vsi);
3019 
3020 	if (vsi->netdev) {
3021 		if (test_bit(ICE_VSI_NETDEV_REGISTERED, vsi->state)) {
3022 			unregister_netdev(vsi->netdev);
3023 			clear_bit(ICE_VSI_NETDEV_REGISTERED, vsi->state);
3024 		}
3025 		if (test_bit(ICE_VSI_NETDEV_ALLOCD, vsi->state)) {
3026 			free_netdev(vsi->netdev);
3027 			vsi->netdev = NULL;
3028 			clear_bit(ICE_VSI_NETDEV_ALLOCD, vsi->state);
3029 		}
3030 	}
3031 
3032 	if (vsi->type == ICE_VSI_VF &&
3033 	    vsi->agg_node && vsi->agg_node->valid)
3034 		vsi->agg_node->num_vsis--;
3035 	ice_vsi_clear_rings(vsi);
3036 
3037 	ice_vsi_put_qs(vsi);
3038 
3039 	/* retain SW VSI data structure since it is needed to unregister and
3040 	 * free VSI netdev when PF is not in reset recovery pending state,\
3041 	 * for ex: during rmmod.
3042 	 */
3043 	if (!ice_is_reset_in_progress(pf->state))
3044 		ice_vsi_clear(vsi);
3045 
3046 	return 0;
3047 }
3048 
3049 /**
3050  * ice_vsi_rebuild_get_coalesce - get coalesce from all q_vectors
3051  * @vsi: VSI connected with q_vectors
3052  * @coalesce: array of struct with stored coalesce
3053  *
3054  * Returns array size.
3055  */
3056 static int
3057 ice_vsi_rebuild_get_coalesce(struct ice_vsi *vsi,
3058 			     struct ice_coalesce_stored *coalesce)
3059 {
3060 	int i;
3061 
3062 	ice_for_each_q_vector(vsi, i) {
3063 		struct ice_q_vector *q_vector = vsi->q_vectors[i];
3064 
3065 		coalesce[i].itr_tx = q_vector->tx.itr_settings;
3066 		coalesce[i].itr_rx = q_vector->rx.itr_settings;
3067 		coalesce[i].intrl = q_vector->intrl;
3068 
3069 		if (i < vsi->num_txq)
3070 			coalesce[i].tx_valid = true;
3071 		if (i < vsi->num_rxq)
3072 			coalesce[i].rx_valid = true;
3073 	}
3074 
3075 	return vsi->num_q_vectors;
3076 }
3077 
3078 /**
3079  * ice_vsi_rebuild_set_coalesce - set coalesce from earlier saved arrays
3080  * @vsi: VSI connected with q_vectors
3081  * @coalesce: pointer to array of struct with stored coalesce
3082  * @size: size of coalesce array
3083  *
3084  * Before this function, ice_vsi_rebuild_get_coalesce should be called to save
3085  * ITR params in arrays. If size is 0 or coalesce wasn't stored set coalesce
3086  * to default value.
3087  */
3088 static void
3089 ice_vsi_rebuild_set_coalesce(struct ice_vsi *vsi,
3090 			     struct ice_coalesce_stored *coalesce, int size)
3091 {
3092 	struct ice_ring_container *rc;
3093 	int i;
3094 
3095 	if ((size && !coalesce) || !vsi)
3096 		return;
3097 
3098 	/* There are a couple of cases that have to be handled here:
3099 	 *   1. The case where the number of queue vectors stays the same, but
3100 	 *      the number of Tx or Rx rings changes (the first for loop)
3101 	 *   2. The case where the number of queue vectors increased (the
3102 	 *      second for loop)
3103 	 */
3104 	for (i = 0; i < size && i < vsi->num_q_vectors; i++) {
3105 		/* There are 2 cases to handle here and they are the same for
3106 		 * both Tx and Rx:
3107 		 *   if the entry was valid previously (coalesce[i].[tr]x_valid
3108 		 *   and the loop variable is less than the number of rings
3109 		 *   allocated, then write the previous values
3110 		 *
3111 		 *   if the entry was not valid previously, but the number of
3112 		 *   rings is less than are allocated (this means the number of
3113 		 *   rings increased from previously), then write out the
3114 		 *   values in the first element
3115 		 *
3116 		 *   Also, always write the ITR, even if in ITR_IS_DYNAMIC
3117 		 *   as there is no harm because the dynamic algorithm
3118 		 *   will just overwrite.
3119 		 */
3120 		if (i < vsi->alloc_rxq && coalesce[i].rx_valid) {
3121 			rc = &vsi->q_vectors[i]->rx;
3122 			rc->itr_settings = coalesce[i].itr_rx;
3123 			ice_write_itr(rc, rc->itr_setting);
3124 		} else if (i < vsi->alloc_rxq) {
3125 			rc = &vsi->q_vectors[i]->rx;
3126 			rc->itr_settings = coalesce[0].itr_rx;
3127 			ice_write_itr(rc, rc->itr_setting);
3128 		}
3129 
3130 		if (i < vsi->alloc_txq && coalesce[i].tx_valid) {
3131 			rc = &vsi->q_vectors[i]->tx;
3132 			rc->itr_settings = coalesce[i].itr_tx;
3133 			ice_write_itr(rc, rc->itr_setting);
3134 		} else if (i < vsi->alloc_txq) {
3135 			rc = &vsi->q_vectors[i]->tx;
3136 			rc->itr_settings = coalesce[0].itr_tx;
3137 			ice_write_itr(rc, rc->itr_setting);
3138 		}
3139 
3140 		vsi->q_vectors[i]->intrl = coalesce[i].intrl;
3141 		ice_set_q_vector_intrl(vsi->q_vectors[i]);
3142 	}
3143 
3144 	/* the number of queue vectors increased so write whatever is in
3145 	 * the first element
3146 	 */
3147 	for (; i < vsi->num_q_vectors; i++) {
3148 		/* transmit */
3149 		rc = &vsi->q_vectors[i]->tx;
3150 		rc->itr_settings = coalesce[0].itr_tx;
3151 		ice_write_itr(rc, rc->itr_setting);
3152 
3153 		/* receive */
3154 		rc = &vsi->q_vectors[i]->rx;
3155 		rc->itr_settings = coalesce[0].itr_rx;
3156 		ice_write_itr(rc, rc->itr_setting);
3157 
3158 		vsi->q_vectors[i]->intrl = coalesce[0].intrl;
3159 		ice_set_q_vector_intrl(vsi->q_vectors[i]);
3160 	}
3161 }
3162 
3163 /**
3164  * ice_vsi_rebuild - Rebuild VSI after reset
3165  * @vsi: VSI to be rebuild
3166  * @init_vsi: is this an initialization or a reconfigure of the VSI
3167  *
3168  * Returns 0 on success and negative value on failure
3169  */
3170 int ice_vsi_rebuild(struct ice_vsi *vsi, bool init_vsi)
3171 {
3172 	u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 };
3173 	struct ice_coalesce_stored *coalesce;
3174 	int prev_num_q_vectors = 0;
3175 	enum ice_vsi_type vtype;
3176 	struct ice_pf *pf;
3177 	int ret, i;
3178 
3179 	if (!vsi)
3180 		return -EINVAL;
3181 
3182 	pf = vsi->back;
3183 	vtype = vsi->type;
3184 	if (WARN_ON(vtype == ICE_VSI_VF && !vsi->vf))
3185 		return -EINVAL;
3186 
3187 	ice_vsi_init_vlan_ops(vsi);
3188 
3189 	coalesce = kcalloc(vsi->num_q_vectors,
3190 			   sizeof(struct ice_coalesce_stored), GFP_KERNEL);
3191 	if (!coalesce)
3192 		return -ENOMEM;
3193 
3194 	prev_num_q_vectors = ice_vsi_rebuild_get_coalesce(vsi, coalesce);
3195 
3196 	ice_rm_vsi_lan_cfg(vsi->port_info, vsi->idx);
3197 	ret = ice_rm_vsi_rdma_cfg(vsi->port_info, vsi->idx);
3198 	if (ret)
3199 		dev_err(ice_pf_to_dev(vsi->back), "Failed to remove RDMA scheduler config for VSI %u, err %d\n",
3200 			vsi->vsi_num, ret);
3201 	ice_vsi_free_q_vectors(vsi);
3202 
3203 	/* SR-IOV determines needed MSIX resources all at once instead of per
3204 	 * VSI since when VFs are spawned we know how many VFs there are and how
3205 	 * many interrupts each VF needs. SR-IOV MSIX resources are also
3206 	 * cleared in the same manner.
3207 	 */
3208 	if (vtype != ICE_VSI_VF) {
3209 		/* reclaim SW interrupts back to the common pool */
3210 		ice_free_res(pf->irq_tracker, vsi->base_vector, vsi->idx);
3211 		pf->num_avail_sw_msix += vsi->num_q_vectors;
3212 		vsi->base_vector = 0;
3213 	}
3214 
3215 	if (ice_is_xdp_ena_vsi(vsi))
3216 		/* return value check can be skipped here, it always returns
3217 		 * 0 if reset is in progress
3218 		 */
3219 		ice_destroy_xdp_rings(vsi);
3220 	ice_vsi_put_qs(vsi);
3221 	ice_vsi_clear_rings(vsi);
3222 	ice_vsi_free_arrays(vsi);
3223 	if (vtype == ICE_VSI_VF)
3224 		ice_vsi_set_num_qs(vsi, vsi->vf);
3225 	else
3226 		ice_vsi_set_num_qs(vsi, NULL);
3227 
3228 	ret = ice_vsi_alloc_arrays(vsi);
3229 	if (ret < 0)
3230 		goto err_vsi;
3231 
3232 	ice_vsi_get_qs(vsi);
3233 
3234 	ice_alloc_fd_res(vsi);
3235 	ice_vsi_set_tc_cfg(vsi);
3236 
3237 	/* Initialize VSI struct elements and create VSI in FW */
3238 	ret = ice_vsi_init(vsi, init_vsi);
3239 	if (ret < 0)
3240 		goto err_vsi;
3241 
3242 	switch (vtype) {
3243 	case ICE_VSI_CTRL:
3244 	case ICE_VSI_SWITCHDEV_CTRL:
3245 	case ICE_VSI_PF:
3246 		ret = ice_vsi_alloc_q_vectors(vsi);
3247 		if (ret)
3248 			goto err_rings;
3249 
3250 		ret = ice_vsi_setup_vector_base(vsi);
3251 		if (ret)
3252 			goto err_vectors;
3253 
3254 		ret = ice_vsi_set_q_vectors_reg_idx(vsi);
3255 		if (ret)
3256 			goto err_vectors;
3257 
3258 		ret = ice_vsi_alloc_rings(vsi);
3259 		if (ret)
3260 			goto err_vectors;
3261 
3262 		ice_vsi_map_rings_to_vectors(vsi);
3263 		if (ice_is_xdp_ena_vsi(vsi)) {
3264 			ret = ice_vsi_determine_xdp_res(vsi);
3265 			if (ret)
3266 				goto err_vectors;
3267 			ret = ice_prepare_xdp_rings(vsi, vsi->xdp_prog);
3268 			if (ret)
3269 				goto err_vectors;
3270 		}
3271 		/* ICE_VSI_CTRL does not need RSS so skip RSS processing */
3272 		if (vtype != ICE_VSI_CTRL)
3273 			/* Do not exit if configuring RSS had an issue, at
3274 			 * least receive traffic on first queue. Hence no
3275 			 * need to capture return value
3276 			 */
3277 			if (test_bit(ICE_FLAG_RSS_ENA, pf->flags))
3278 				ice_vsi_cfg_rss_lut_key(vsi);
3279 		break;
3280 	case ICE_VSI_VF:
3281 		ret = ice_vsi_alloc_q_vectors(vsi);
3282 		if (ret)
3283 			goto err_rings;
3284 
3285 		ret = ice_vsi_set_q_vectors_reg_idx(vsi);
3286 		if (ret)
3287 			goto err_vectors;
3288 
3289 		ret = ice_vsi_alloc_rings(vsi);
3290 		if (ret)
3291 			goto err_vectors;
3292 
3293 		break;
3294 	case ICE_VSI_CHNL:
3295 		if (test_bit(ICE_FLAG_RSS_ENA, pf->flags)) {
3296 			ice_vsi_cfg_rss_lut_key(vsi);
3297 			ice_vsi_set_rss_flow_fld(vsi);
3298 		}
3299 		break;
3300 	default:
3301 		break;
3302 	}
3303 
3304 	/* configure VSI nodes based on number of queues and TC's */
3305 	for (i = 0; i < vsi->tc_cfg.numtc; i++) {
3306 		/* configure VSI nodes based on number of queues and TC's.
3307 		 * ADQ creates VSIs for each TC/Channel but doesn't
3308 		 * allocate queues instead it reconfigures the PF queues
3309 		 * as per the TC command. So max_txqs should point to the
3310 		 * PF Tx queues.
3311 		 */
3312 		if (vtype == ICE_VSI_CHNL)
3313 			max_txqs[i] = pf->num_lan_tx;
3314 		else
3315 			max_txqs[i] = vsi->alloc_txq;
3316 
3317 		if (ice_is_xdp_ena_vsi(vsi))
3318 			max_txqs[i] += vsi->num_xdp_txq;
3319 	}
3320 
3321 	if (test_bit(ICE_FLAG_TC_MQPRIO, pf->flags))
3322 		/* If MQPRIO is set, means channel code path, hence for main
3323 		 * VSI's, use TC as 1
3324 		 */
3325 		ret = ice_cfg_vsi_lan(vsi->port_info, vsi->idx, 1, max_txqs);
3326 	else
3327 		ret = ice_cfg_vsi_lan(vsi->port_info, vsi->idx,
3328 				      vsi->tc_cfg.ena_tc, max_txqs);
3329 
3330 	if (ret) {
3331 		dev_err(ice_pf_to_dev(pf), "VSI %d failed lan queue config, error %d\n",
3332 			vsi->vsi_num, ret);
3333 		if (init_vsi) {
3334 			ret = -EIO;
3335 			goto err_vectors;
3336 		} else {
3337 			return ice_schedule_reset(pf, ICE_RESET_PFR);
3338 		}
3339 	}
3340 	ice_vsi_rebuild_set_coalesce(vsi, coalesce, prev_num_q_vectors);
3341 	kfree(coalesce);
3342 
3343 	return 0;
3344 
3345 err_vectors:
3346 	ice_vsi_free_q_vectors(vsi);
3347 err_rings:
3348 	if (vsi->netdev) {
3349 		vsi->current_netdev_flags = 0;
3350 		unregister_netdev(vsi->netdev);
3351 		free_netdev(vsi->netdev);
3352 		vsi->netdev = NULL;
3353 	}
3354 err_vsi:
3355 	ice_vsi_clear(vsi);
3356 	set_bit(ICE_RESET_FAILED, pf->state);
3357 	kfree(coalesce);
3358 	return ret;
3359 }
3360 
3361 /**
3362  * ice_is_reset_in_progress - check for a reset in progress
3363  * @state: PF state field
3364  */
3365 bool ice_is_reset_in_progress(unsigned long *state)
3366 {
3367 	return test_bit(ICE_RESET_OICR_RECV, state) ||
3368 	       test_bit(ICE_PFR_REQ, state) ||
3369 	       test_bit(ICE_CORER_REQ, state) ||
3370 	       test_bit(ICE_GLOBR_REQ, state);
3371 }
3372 
3373 /**
3374  * ice_wait_for_reset - Wait for driver to finish reset and rebuild
3375  * @pf: pointer to the PF structure
3376  * @timeout: length of time to wait, in jiffies
3377  *
3378  * Wait (sleep) for a short time until the driver finishes cleaning up from
3379  * a device reset. The caller must be able to sleep. Use this to delay
3380  * operations that could fail while the driver is cleaning up after a device
3381  * reset.
3382  *
3383  * Returns 0 on success, -EBUSY if the reset is not finished within the
3384  * timeout, and -ERESTARTSYS if the thread was interrupted.
3385  */
3386 int ice_wait_for_reset(struct ice_pf *pf, unsigned long timeout)
3387 {
3388 	long ret;
3389 
3390 	ret = wait_event_interruptible_timeout(pf->reset_wait_queue,
3391 					       !ice_is_reset_in_progress(pf->state),
3392 					       timeout);
3393 	if (ret < 0)
3394 		return ret;
3395 	else if (!ret)
3396 		return -EBUSY;
3397 	else
3398 		return 0;
3399 }
3400 
3401 /**
3402  * ice_vsi_update_q_map - update our copy of the VSI info with new queue map
3403  * @vsi: VSI being configured
3404  * @ctx: the context buffer returned from AQ VSI update command
3405  */
3406 static void ice_vsi_update_q_map(struct ice_vsi *vsi, struct ice_vsi_ctx *ctx)
3407 {
3408 	vsi->info.mapping_flags = ctx->info.mapping_flags;
3409 	memcpy(&vsi->info.q_mapping, &ctx->info.q_mapping,
3410 	       sizeof(vsi->info.q_mapping));
3411 	memcpy(&vsi->info.tc_mapping, ctx->info.tc_mapping,
3412 	       sizeof(vsi->info.tc_mapping));
3413 }
3414 
3415 /**
3416  * ice_vsi_cfg_netdev_tc - Setup the netdev TC configuration
3417  * @vsi: the VSI being configured
3418  * @ena_tc: TC map to be enabled
3419  */
3420 void ice_vsi_cfg_netdev_tc(struct ice_vsi *vsi, u8 ena_tc)
3421 {
3422 	struct net_device *netdev = vsi->netdev;
3423 	struct ice_pf *pf = vsi->back;
3424 	int numtc = vsi->tc_cfg.numtc;
3425 	struct ice_dcbx_cfg *dcbcfg;
3426 	u8 netdev_tc;
3427 	int i;
3428 
3429 	if (!netdev)
3430 		return;
3431 
3432 	/* CHNL VSI doesn't have it's own netdev, hence, no netdev_tc */
3433 	if (vsi->type == ICE_VSI_CHNL)
3434 		return;
3435 
3436 	if (!ena_tc) {
3437 		netdev_reset_tc(netdev);
3438 		return;
3439 	}
3440 
3441 	if (vsi->type == ICE_VSI_PF && ice_is_adq_active(pf))
3442 		numtc = vsi->all_numtc;
3443 
3444 	if (netdev_set_num_tc(netdev, numtc))
3445 		return;
3446 
3447 	dcbcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
3448 
3449 	ice_for_each_traffic_class(i)
3450 		if (vsi->tc_cfg.ena_tc & BIT(i))
3451 			netdev_set_tc_queue(netdev,
3452 					    vsi->tc_cfg.tc_info[i].netdev_tc,
3453 					    vsi->tc_cfg.tc_info[i].qcount_tx,
3454 					    vsi->tc_cfg.tc_info[i].qoffset);
3455 	/* setup TC queue map for CHNL TCs */
3456 	ice_for_each_chnl_tc(i) {
3457 		if (!(vsi->all_enatc & BIT(i)))
3458 			break;
3459 		if (!vsi->mqprio_qopt.qopt.count[i])
3460 			break;
3461 		netdev_set_tc_queue(netdev, i,
3462 				    vsi->mqprio_qopt.qopt.count[i],
3463 				    vsi->mqprio_qopt.qopt.offset[i]);
3464 	}
3465 
3466 	if (test_bit(ICE_FLAG_TC_MQPRIO, pf->flags))
3467 		return;
3468 
3469 	for (i = 0; i < ICE_MAX_USER_PRIORITY; i++) {
3470 		u8 ets_tc = dcbcfg->etscfg.prio_table[i];
3471 
3472 		/* Get the mapped netdev TC# for the UP */
3473 		netdev_tc = vsi->tc_cfg.tc_info[ets_tc].netdev_tc;
3474 		netdev_set_prio_tc_map(netdev, i, netdev_tc);
3475 	}
3476 }
3477 
3478 /**
3479  * ice_vsi_setup_q_map_mqprio - Prepares mqprio based tc_config
3480  * @vsi: the VSI being configured,
3481  * @ctxt: VSI context structure
3482  * @ena_tc: number of traffic classes to enable
3483  *
3484  * Prepares VSI tc_config to have queue configurations based on MQPRIO options.
3485  */
3486 static int
3487 ice_vsi_setup_q_map_mqprio(struct ice_vsi *vsi, struct ice_vsi_ctx *ctxt,
3488 			   u8 ena_tc)
3489 {
3490 	u16 pow, offset = 0, qcount_tx = 0, qcount_rx = 0, qmap;
3491 	u16 tc0_offset = vsi->mqprio_qopt.qopt.offset[0];
3492 	int tc0_qcount = vsi->mqprio_qopt.qopt.count[0];
3493 	u8 netdev_tc = 0;
3494 	int i;
3495 
3496 	vsi->tc_cfg.ena_tc = ena_tc ? ena_tc : 1;
3497 
3498 	pow = order_base_2(tc0_qcount);
3499 	qmap = ((tc0_offset << ICE_AQ_VSI_TC_Q_OFFSET_S) &
3500 		ICE_AQ_VSI_TC_Q_OFFSET_M) |
3501 		((pow << ICE_AQ_VSI_TC_Q_NUM_S) & ICE_AQ_VSI_TC_Q_NUM_M);
3502 
3503 	ice_for_each_traffic_class(i) {
3504 		if (!(vsi->tc_cfg.ena_tc & BIT(i))) {
3505 			/* TC is not enabled */
3506 			vsi->tc_cfg.tc_info[i].qoffset = 0;
3507 			vsi->tc_cfg.tc_info[i].qcount_rx = 1;
3508 			vsi->tc_cfg.tc_info[i].qcount_tx = 1;
3509 			vsi->tc_cfg.tc_info[i].netdev_tc = 0;
3510 			ctxt->info.tc_mapping[i] = 0;
3511 			continue;
3512 		}
3513 
3514 		offset = vsi->mqprio_qopt.qopt.offset[i];
3515 		qcount_rx = vsi->mqprio_qopt.qopt.count[i];
3516 		qcount_tx = vsi->mqprio_qopt.qopt.count[i];
3517 		vsi->tc_cfg.tc_info[i].qoffset = offset;
3518 		vsi->tc_cfg.tc_info[i].qcount_rx = qcount_rx;
3519 		vsi->tc_cfg.tc_info[i].qcount_tx = qcount_tx;
3520 		vsi->tc_cfg.tc_info[i].netdev_tc = netdev_tc++;
3521 	}
3522 
3523 	if (vsi->all_numtc && vsi->all_numtc != vsi->tc_cfg.numtc) {
3524 		ice_for_each_chnl_tc(i) {
3525 			if (!(vsi->all_enatc & BIT(i)))
3526 				continue;
3527 			offset = vsi->mqprio_qopt.qopt.offset[i];
3528 			qcount_rx = vsi->mqprio_qopt.qopt.count[i];
3529 			qcount_tx = vsi->mqprio_qopt.qopt.count[i];
3530 		}
3531 	}
3532 
3533 	/* Set actual Tx/Rx queue pairs */
3534 	vsi->num_txq = offset + qcount_tx;
3535 	if (vsi->num_txq > vsi->alloc_txq) {
3536 		dev_err(ice_pf_to_dev(vsi->back), "Trying to use more Tx queues (%u), than were allocated (%u)!\n",
3537 			vsi->num_txq, vsi->alloc_txq);
3538 		return -EINVAL;
3539 	}
3540 
3541 	vsi->num_rxq = offset + qcount_rx;
3542 	if (vsi->num_rxq > vsi->alloc_rxq) {
3543 		dev_err(ice_pf_to_dev(vsi->back), "Trying to use more Rx queues (%u), than were allocated (%u)!\n",
3544 			vsi->num_rxq, vsi->alloc_rxq);
3545 		return -EINVAL;
3546 	}
3547 
3548 	/* Setup queue TC[0].qmap for given VSI context */
3549 	ctxt->info.tc_mapping[0] = cpu_to_le16(qmap);
3550 	ctxt->info.q_mapping[0] = cpu_to_le16(vsi->rxq_map[0]);
3551 	ctxt->info.q_mapping[1] = cpu_to_le16(tc0_qcount);
3552 
3553 	/* Find queue count available for channel VSIs and starting offset
3554 	 * for channel VSIs
3555 	 */
3556 	if (tc0_qcount && tc0_qcount < vsi->num_rxq) {
3557 		vsi->cnt_q_avail = vsi->num_rxq - tc0_qcount;
3558 		vsi->next_base_q = tc0_qcount;
3559 	}
3560 	dev_dbg(ice_pf_to_dev(vsi->back), "vsi->num_txq = %d\n",  vsi->num_txq);
3561 	dev_dbg(ice_pf_to_dev(vsi->back), "vsi->num_rxq = %d\n",  vsi->num_rxq);
3562 	dev_dbg(ice_pf_to_dev(vsi->back), "all_numtc %u, all_enatc: 0x%04x, tc_cfg.numtc %u\n",
3563 		vsi->all_numtc, vsi->all_enatc, vsi->tc_cfg.numtc);
3564 
3565 	return 0;
3566 }
3567 
3568 /**
3569  * ice_vsi_cfg_tc - Configure VSI Tx Sched for given TC map
3570  * @vsi: VSI to be configured
3571  * @ena_tc: TC bitmap
3572  *
3573  * VSI queues expected to be quiesced before calling this function
3574  */
3575 int ice_vsi_cfg_tc(struct ice_vsi *vsi, u8 ena_tc)
3576 {
3577 	u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 };
3578 	struct ice_pf *pf = vsi->back;
3579 	struct ice_vsi_ctx *ctx;
3580 	struct device *dev;
3581 	int i, ret = 0;
3582 	u8 num_tc = 0;
3583 
3584 	dev = ice_pf_to_dev(pf);
3585 	if (vsi->tc_cfg.ena_tc == ena_tc &&
3586 	    vsi->mqprio_qopt.mode != TC_MQPRIO_MODE_CHANNEL)
3587 		return ret;
3588 
3589 	ice_for_each_traffic_class(i) {
3590 		/* build bitmap of enabled TCs */
3591 		if (ena_tc & BIT(i))
3592 			num_tc++;
3593 		/* populate max_txqs per TC */
3594 		max_txqs[i] = vsi->alloc_txq;
3595 		/* Update max_txqs if it is CHNL VSI, because alloc_t[r]xq are
3596 		 * zero for CHNL VSI, hence use num_txq instead as max_txqs
3597 		 */
3598 		if (vsi->type == ICE_VSI_CHNL &&
3599 		    test_bit(ICE_FLAG_TC_MQPRIO, pf->flags))
3600 			max_txqs[i] = vsi->num_txq;
3601 	}
3602 
3603 	vsi->tc_cfg.ena_tc = ena_tc;
3604 	vsi->tc_cfg.numtc = num_tc;
3605 
3606 	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
3607 	if (!ctx)
3608 		return -ENOMEM;
3609 
3610 	ctx->vf_num = 0;
3611 	ctx->info = vsi->info;
3612 
3613 	if (vsi->type == ICE_VSI_PF &&
3614 	    test_bit(ICE_FLAG_TC_MQPRIO, pf->flags))
3615 		ret = ice_vsi_setup_q_map_mqprio(vsi, ctx, ena_tc);
3616 	else
3617 		ret = ice_vsi_setup_q_map(vsi, ctx);
3618 
3619 	if (ret)
3620 		goto out;
3621 
3622 	/* must to indicate which section of VSI context are being modified */
3623 	ctx->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_RXQ_MAP_VALID);
3624 	ret = ice_update_vsi(&pf->hw, vsi->idx, ctx, NULL);
3625 	if (ret) {
3626 		dev_info(dev, "Failed VSI Update\n");
3627 		goto out;
3628 	}
3629 
3630 	if (vsi->type == ICE_VSI_PF &&
3631 	    test_bit(ICE_FLAG_TC_MQPRIO, pf->flags))
3632 		ret = ice_cfg_vsi_lan(vsi->port_info, vsi->idx, 1, max_txqs);
3633 	else
3634 		ret = ice_cfg_vsi_lan(vsi->port_info, vsi->idx,
3635 				      vsi->tc_cfg.ena_tc, max_txqs);
3636 
3637 	if (ret) {
3638 		dev_err(dev, "VSI %d failed TC config, error %d\n",
3639 			vsi->vsi_num, ret);
3640 		goto out;
3641 	}
3642 	ice_vsi_update_q_map(vsi, ctx);
3643 	vsi->info.valid_sections = 0;
3644 
3645 	ice_vsi_cfg_netdev_tc(vsi, ena_tc);
3646 out:
3647 	kfree(ctx);
3648 	return ret;
3649 }
3650 
3651 /**
3652  * ice_update_ring_stats - Update ring statistics
3653  * @stats: stats to be updated
3654  * @pkts: number of processed packets
3655  * @bytes: number of processed bytes
3656  *
3657  * This function assumes that caller has acquired a u64_stats_sync lock.
3658  */
3659 static void ice_update_ring_stats(struct ice_q_stats *stats, u64 pkts, u64 bytes)
3660 {
3661 	stats->bytes += bytes;
3662 	stats->pkts += pkts;
3663 }
3664 
3665 /**
3666  * ice_update_tx_ring_stats - Update Tx ring specific counters
3667  * @tx_ring: ring to update
3668  * @pkts: number of processed packets
3669  * @bytes: number of processed bytes
3670  */
3671 void ice_update_tx_ring_stats(struct ice_tx_ring *tx_ring, u64 pkts, u64 bytes)
3672 {
3673 	u64_stats_update_begin(&tx_ring->syncp);
3674 	ice_update_ring_stats(&tx_ring->stats, pkts, bytes);
3675 	u64_stats_update_end(&tx_ring->syncp);
3676 }
3677 
3678 /**
3679  * ice_update_rx_ring_stats - Update Rx ring specific counters
3680  * @rx_ring: ring to update
3681  * @pkts: number of processed packets
3682  * @bytes: number of processed bytes
3683  */
3684 void ice_update_rx_ring_stats(struct ice_rx_ring *rx_ring, u64 pkts, u64 bytes)
3685 {
3686 	u64_stats_update_begin(&rx_ring->syncp);
3687 	ice_update_ring_stats(&rx_ring->stats, pkts, bytes);
3688 	u64_stats_update_end(&rx_ring->syncp);
3689 }
3690 
3691 /**
3692  * ice_is_dflt_vsi_in_use - check if the default forwarding VSI is being used
3693  * @pi: port info of the switch with default VSI
3694  *
3695  * Return true if the there is a single VSI in default forwarding VSI list
3696  */
3697 bool ice_is_dflt_vsi_in_use(struct ice_port_info *pi)
3698 {
3699 	bool exists = false;
3700 
3701 	ice_check_if_dflt_vsi(pi, 0, &exists);
3702 	return exists;
3703 }
3704 
3705 /**
3706  * ice_is_vsi_dflt_vsi - check if the VSI passed in is the default VSI
3707  * @vsi: VSI to compare against default forwarding VSI
3708  *
3709  * If this VSI passed in is the default forwarding VSI then return true, else
3710  * return false
3711  */
3712 bool ice_is_vsi_dflt_vsi(struct ice_vsi *vsi)
3713 {
3714 	return ice_check_if_dflt_vsi(vsi->port_info, vsi->idx, NULL);
3715 }
3716 
3717 /**
3718  * ice_set_dflt_vsi - set the default forwarding VSI
3719  * @vsi: VSI getting set as the default forwarding VSI on the switch
3720  *
3721  * If the VSI passed in is already the default VSI and it's enabled just return
3722  * success.
3723  *
3724  * Otherwise try to set the VSI passed in as the switch's default VSI and
3725  * return the result.
3726  */
3727 int ice_set_dflt_vsi(struct ice_vsi *vsi)
3728 {
3729 	struct device *dev;
3730 	int status;
3731 
3732 	if (!vsi)
3733 		return -EINVAL;
3734 
3735 	dev = ice_pf_to_dev(vsi->back);
3736 
3737 	/* the VSI passed in is already the default VSI */
3738 	if (ice_is_vsi_dflt_vsi(vsi)) {
3739 		dev_dbg(dev, "VSI %d passed in is already the default forwarding VSI, nothing to do\n",
3740 			vsi->vsi_num);
3741 		return 0;
3742 	}
3743 
3744 	status = ice_cfg_dflt_vsi(vsi->port_info, vsi->idx, true, ICE_FLTR_RX);
3745 	if (status) {
3746 		dev_err(dev, "Failed to set VSI %d as the default forwarding VSI, error %d\n",
3747 			vsi->vsi_num, status);
3748 		return status;
3749 	}
3750 
3751 	return 0;
3752 }
3753 
3754 /**
3755  * ice_clear_dflt_vsi - clear the default forwarding VSI
3756  * @vsi: VSI to remove from filter list
3757  *
3758  * If the switch has no default VSI or it's not enabled then return error.
3759  *
3760  * Otherwise try to clear the default VSI and return the result.
3761  */
3762 int ice_clear_dflt_vsi(struct ice_vsi *vsi)
3763 {
3764 	struct device *dev;
3765 	int status;
3766 
3767 	if (!vsi)
3768 		return -EINVAL;
3769 
3770 	dev = ice_pf_to_dev(vsi->back);
3771 
3772 	/* there is no default VSI configured */
3773 	if (!ice_is_dflt_vsi_in_use(vsi->port_info))
3774 		return -ENODEV;
3775 
3776 	status = ice_cfg_dflt_vsi(vsi->port_info, vsi->idx, false,
3777 				  ICE_FLTR_RX);
3778 	if (status) {
3779 		dev_err(dev, "Failed to clear the default forwarding VSI %d, error %d\n",
3780 			vsi->vsi_num, status);
3781 		return -EIO;
3782 	}
3783 
3784 	return 0;
3785 }
3786 
3787 /**
3788  * ice_get_link_speed_mbps - get link speed in Mbps
3789  * @vsi: the VSI whose link speed is being queried
3790  *
3791  * Return current VSI link speed and 0 if the speed is unknown.
3792  */
3793 int ice_get_link_speed_mbps(struct ice_vsi *vsi)
3794 {
3795 	switch (vsi->port_info->phy.link_info.link_speed) {
3796 	case ICE_AQ_LINK_SPEED_100GB:
3797 		return SPEED_100000;
3798 	case ICE_AQ_LINK_SPEED_50GB:
3799 		return SPEED_50000;
3800 	case ICE_AQ_LINK_SPEED_40GB:
3801 		return SPEED_40000;
3802 	case ICE_AQ_LINK_SPEED_25GB:
3803 		return SPEED_25000;
3804 	case ICE_AQ_LINK_SPEED_20GB:
3805 		return SPEED_20000;
3806 	case ICE_AQ_LINK_SPEED_10GB:
3807 		return SPEED_10000;
3808 	case ICE_AQ_LINK_SPEED_5GB:
3809 		return SPEED_5000;
3810 	case ICE_AQ_LINK_SPEED_2500MB:
3811 		return SPEED_2500;
3812 	case ICE_AQ_LINK_SPEED_1000MB:
3813 		return SPEED_1000;
3814 	case ICE_AQ_LINK_SPEED_100MB:
3815 		return SPEED_100;
3816 	case ICE_AQ_LINK_SPEED_10MB:
3817 		return SPEED_10;
3818 	case ICE_AQ_LINK_SPEED_UNKNOWN:
3819 	default:
3820 		return 0;
3821 	}
3822 }
3823 
3824 /**
3825  * ice_get_link_speed_kbps - get link speed in Kbps
3826  * @vsi: the VSI whose link speed is being queried
3827  *
3828  * Return current VSI link speed and 0 if the speed is unknown.
3829  */
3830 int ice_get_link_speed_kbps(struct ice_vsi *vsi)
3831 {
3832 	int speed_mbps;
3833 
3834 	speed_mbps = ice_get_link_speed_mbps(vsi);
3835 
3836 	return speed_mbps * 1000;
3837 }
3838 
3839 /**
3840  * ice_set_min_bw_limit - setup minimum BW limit for Tx based on min_tx_rate
3841  * @vsi: VSI to be configured
3842  * @min_tx_rate: min Tx rate in Kbps to be configured as BW limit
3843  *
3844  * If the min_tx_rate is specified as 0 that means to clear the minimum BW limit
3845  * profile, otherwise a non-zero value will force a minimum BW limit for the VSI
3846  * on TC 0.
3847  */
3848 int ice_set_min_bw_limit(struct ice_vsi *vsi, u64 min_tx_rate)
3849 {
3850 	struct ice_pf *pf = vsi->back;
3851 	struct device *dev;
3852 	int status;
3853 	int speed;
3854 
3855 	dev = ice_pf_to_dev(pf);
3856 	if (!vsi->port_info) {
3857 		dev_dbg(dev, "VSI %d, type %u specified doesn't have valid port_info\n",
3858 			vsi->idx, vsi->type);
3859 		return -EINVAL;
3860 	}
3861 
3862 	speed = ice_get_link_speed_kbps(vsi);
3863 	if (min_tx_rate > (u64)speed) {
3864 		dev_err(dev, "invalid min Tx rate %llu Kbps specified for %s %d is greater than current link speed %u Kbps\n",
3865 			min_tx_rate, ice_vsi_type_str(vsi->type), vsi->idx,
3866 			speed);
3867 		return -EINVAL;
3868 	}
3869 
3870 	/* Configure min BW for VSI limit */
3871 	if (min_tx_rate) {
3872 		status = ice_cfg_vsi_bw_lmt_per_tc(vsi->port_info, vsi->idx, 0,
3873 						   ICE_MIN_BW, min_tx_rate);
3874 		if (status) {
3875 			dev_err(dev, "failed to set min Tx rate(%llu Kbps) for %s %d\n",
3876 				min_tx_rate, ice_vsi_type_str(vsi->type),
3877 				vsi->idx);
3878 			return status;
3879 		}
3880 
3881 		dev_dbg(dev, "set min Tx rate(%llu Kbps) for %s\n",
3882 			min_tx_rate, ice_vsi_type_str(vsi->type));
3883 	} else {
3884 		status = ice_cfg_vsi_bw_dflt_lmt_per_tc(vsi->port_info,
3885 							vsi->idx, 0,
3886 							ICE_MIN_BW);
3887 		if (status) {
3888 			dev_err(dev, "failed to clear min Tx rate configuration for %s %d\n",
3889 				ice_vsi_type_str(vsi->type), vsi->idx);
3890 			return status;
3891 		}
3892 
3893 		dev_dbg(dev, "cleared min Tx rate configuration for %s %d\n",
3894 			ice_vsi_type_str(vsi->type), vsi->idx);
3895 	}
3896 
3897 	return 0;
3898 }
3899 
3900 /**
3901  * ice_set_max_bw_limit - setup maximum BW limit for Tx based on max_tx_rate
3902  * @vsi: VSI to be configured
3903  * @max_tx_rate: max Tx rate in Kbps to be configured as BW limit
3904  *
3905  * If the max_tx_rate is specified as 0 that means to clear the maximum BW limit
3906  * profile, otherwise a non-zero value will force a maximum BW limit for the VSI
3907  * on TC 0.
3908  */
3909 int ice_set_max_bw_limit(struct ice_vsi *vsi, u64 max_tx_rate)
3910 {
3911 	struct ice_pf *pf = vsi->back;
3912 	struct device *dev;
3913 	int status;
3914 	int speed;
3915 
3916 	dev = ice_pf_to_dev(pf);
3917 	if (!vsi->port_info) {
3918 		dev_dbg(dev, "VSI %d, type %u specified doesn't have valid port_info\n",
3919 			vsi->idx, vsi->type);
3920 		return -EINVAL;
3921 	}
3922 
3923 	speed = ice_get_link_speed_kbps(vsi);
3924 	if (max_tx_rate > (u64)speed) {
3925 		dev_err(dev, "invalid max Tx rate %llu Kbps specified for %s %d is greater than current link speed %u Kbps\n",
3926 			max_tx_rate, ice_vsi_type_str(vsi->type), vsi->idx,
3927 			speed);
3928 		return -EINVAL;
3929 	}
3930 
3931 	/* Configure max BW for VSI limit */
3932 	if (max_tx_rate) {
3933 		status = ice_cfg_vsi_bw_lmt_per_tc(vsi->port_info, vsi->idx, 0,
3934 						   ICE_MAX_BW, max_tx_rate);
3935 		if (status) {
3936 			dev_err(dev, "failed setting max Tx rate(%llu Kbps) for %s %d\n",
3937 				max_tx_rate, ice_vsi_type_str(vsi->type),
3938 				vsi->idx);
3939 			return status;
3940 		}
3941 
3942 		dev_dbg(dev, "set max Tx rate(%llu Kbps) for %s %d\n",
3943 			max_tx_rate, ice_vsi_type_str(vsi->type), vsi->idx);
3944 	} else {
3945 		status = ice_cfg_vsi_bw_dflt_lmt_per_tc(vsi->port_info,
3946 							vsi->idx, 0,
3947 							ICE_MAX_BW);
3948 		if (status) {
3949 			dev_err(dev, "failed clearing max Tx rate configuration for %s %d\n",
3950 				ice_vsi_type_str(vsi->type), vsi->idx);
3951 			return status;
3952 		}
3953 
3954 		dev_dbg(dev, "cleared max Tx rate configuration for %s %d\n",
3955 			ice_vsi_type_str(vsi->type), vsi->idx);
3956 	}
3957 
3958 	return 0;
3959 }
3960 
3961 /**
3962  * ice_set_link - turn on/off physical link
3963  * @vsi: VSI to modify physical link on
3964  * @ena: turn on/off physical link
3965  */
3966 int ice_set_link(struct ice_vsi *vsi, bool ena)
3967 {
3968 	struct device *dev = ice_pf_to_dev(vsi->back);
3969 	struct ice_port_info *pi = vsi->port_info;
3970 	struct ice_hw *hw = pi->hw;
3971 	int status;
3972 
3973 	if (vsi->type != ICE_VSI_PF)
3974 		return -EINVAL;
3975 
3976 	status = ice_aq_set_link_restart_an(pi, ena, NULL);
3977 
3978 	/* if link is owned by manageability, FW will return ICE_AQ_RC_EMODE.
3979 	 * this is not a fatal error, so print a warning message and return
3980 	 * a success code. Return an error if FW returns an error code other
3981 	 * than ICE_AQ_RC_EMODE
3982 	 */
3983 	if (status == -EIO) {
3984 		if (hw->adminq.sq_last_status == ICE_AQ_RC_EMODE)
3985 			dev_dbg(dev, "can't set link to %s, err %d aq_err %s. not fatal, continuing\n",
3986 				(ena ? "ON" : "OFF"), status,
3987 				ice_aq_str(hw->adminq.sq_last_status));
3988 	} else if (status) {
3989 		dev_err(dev, "can't set link to %s, err %d aq_err %s\n",
3990 			(ena ? "ON" : "OFF"), status,
3991 			ice_aq_str(hw->adminq.sq_last_status));
3992 		return status;
3993 	}
3994 
3995 	return 0;
3996 }
3997 
3998 /**
3999  * ice_vsi_add_vlan_zero - add VLAN 0 filter(s) for this VSI
4000  * @vsi: VSI used to add VLAN filters
4001  *
4002  * In Single VLAN Mode (SVM), single VLAN filters via ICE_SW_LKUP_VLAN are based
4003  * on the inner VLAN ID, so the VLAN TPID (i.e. 0x8100 or 0x888a8) doesn't
4004  * matter. In Double VLAN Mode (DVM), outer/single VLAN filters via
4005  * ICE_SW_LKUP_VLAN are based on the outer/single VLAN ID + VLAN TPID.
4006  *
4007  * For both modes add a VLAN 0 + no VLAN TPID filter to handle untagged traffic
4008  * when VLAN pruning is enabled. Also, this handles VLAN 0 priority tagged
4009  * traffic in SVM, since the VLAN TPID isn't part of filtering.
4010  *
4011  * If DVM is enabled then an explicit VLAN 0 + VLAN TPID filter needs to be
4012  * added to allow VLAN 0 priority tagged traffic in DVM, since the VLAN TPID is
4013  * part of filtering.
4014  */
4015 int ice_vsi_add_vlan_zero(struct ice_vsi *vsi)
4016 {
4017 	struct ice_vsi_vlan_ops *vlan_ops = ice_get_compat_vsi_vlan_ops(vsi);
4018 	struct ice_vlan vlan;
4019 	int err;
4020 
4021 	vlan = ICE_VLAN(0, 0, 0);
4022 	err = vlan_ops->add_vlan(vsi, &vlan);
4023 	if (err && err != -EEXIST)
4024 		return err;
4025 
4026 	/* in SVM both VLAN 0 filters are identical */
4027 	if (!ice_is_dvm_ena(&vsi->back->hw))
4028 		return 0;
4029 
4030 	vlan = ICE_VLAN(ETH_P_8021Q, 0, 0);
4031 	err = vlan_ops->add_vlan(vsi, &vlan);
4032 	if (err && err != -EEXIST)
4033 		return err;
4034 
4035 	return 0;
4036 }
4037 
4038 /**
4039  * ice_vsi_del_vlan_zero - delete VLAN 0 filter(s) for this VSI
4040  * @vsi: VSI used to add VLAN filters
4041  *
4042  * Delete the VLAN 0 filters in the same manner that they were added in
4043  * ice_vsi_add_vlan_zero.
4044  */
4045 int ice_vsi_del_vlan_zero(struct ice_vsi *vsi)
4046 {
4047 	struct ice_vsi_vlan_ops *vlan_ops = ice_get_compat_vsi_vlan_ops(vsi);
4048 	struct ice_vlan vlan;
4049 	int err;
4050 
4051 	vlan = ICE_VLAN(0, 0, 0);
4052 	err = vlan_ops->del_vlan(vsi, &vlan);
4053 	if (err && err != -EEXIST)
4054 		return err;
4055 
4056 	/* in SVM both VLAN 0 filters are identical */
4057 	if (!ice_is_dvm_ena(&vsi->back->hw))
4058 		return 0;
4059 
4060 	vlan = ICE_VLAN(ETH_P_8021Q, 0, 0);
4061 	err = vlan_ops->del_vlan(vsi, &vlan);
4062 	if (err && err != -EEXIST)
4063 		return err;
4064 
4065 	/* when deleting the last VLAN filter, make sure to disable the VLAN
4066 	 * promisc mode so the filter isn't left by accident
4067 	 */
4068 	return ice_clear_vsi_promisc(&vsi->back->hw, vsi->idx,
4069 				    ICE_MCAST_VLAN_PROMISC_BITS, 0);
4070 }
4071 
4072 /**
4073  * ice_vsi_num_zero_vlans - get number of VLAN 0 filters based on VLAN mode
4074  * @vsi: VSI used to get the VLAN mode
4075  *
4076  * If DVM is enabled then 2 VLAN 0 filters are added, else if SVM is enabled
4077  * then 1 VLAN 0 filter is added. See ice_vsi_add_vlan_zero for more details.
4078  */
4079 static u16 ice_vsi_num_zero_vlans(struct ice_vsi *vsi)
4080 {
4081 #define ICE_DVM_NUM_ZERO_VLAN_FLTRS	2
4082 #define ICE_SVM_NUM_ZERO_VLAN_FLTRS	1
4083 	/* no VLAN 0 filter is created when a port VLAN is active */
4084 	if (vsi->type == ICE_VSI_VF) {
4085 		if (WARN_ON(!vsi->vf))
4086 			return 0;
4087 
4088 		if (ice_vf_is_port_vlan_ena(vsi->vf))
4089 			return 0;
4090 	}
4091 
4092 	if (ice_is_dvm_ena(&vsi->back->hw))
4093 		return ICE_DVM_NUM_ZERO_VLAN_FLTRS;
4094 	else
4095 		return ICE_SVM_NUM_ZERO_VLAN_FLTRS;
4096 }
4097 
4098 /**
4099  * ice_vsi_has_non_zero_vlans - check if VSI has any non-zero VLANs
4100  * @vsi: VSI used to determine if any non-zero VLANs have been added
4101  */
4102 bool ice_vsi_has_non_zero_vlans(struct ice_vsi *vsi)
4103 {
4104 	return (vsi->num_vlan > ice_vsi_num_zero_vlans(vsi));
4105 }
4106 
4107 /**
4108  * ice_vsi_num_non_zero_vlans - get the number of non-zero VLANs for this VSI
4109  * @vsi: VSI used to get the number of non-zero VLANs added
4110  */
4111 u16 ice_vsi_num_non_zero_vlans(struct ice_vsi *vsi)
4112 {
4113 	return (vsi->num_vlan - ice_vsi_num_zero_vlans(vsi));
4114 }
4115 
4116 /**
4117  * ice_is_feature_supported
4118  * @pf: pointer to the struct ice_pf instance
4119  * @f: feature enum to be checked
4120  *
4121  * returns true if feature is supported, false otherwise
4122  */
4123 bool ice_is_feature_supported(struct ice_pf *pf, enum ice_feature f)
4124 {
4125 	if (f < 0 || f >= ICE_F_MAX)
4126 		return false;
4127 
4128 	return test_bit(f, pf->features);
4129 }
4130 
4131 /**
4132  * ice_set_feature_support
4133  * @pf: pointer to the struct ice_pf instance
4134  * @f: feature enum to set
4135  */
4136 static void ice_set_feature_support(struct ice_pf *pf, enum ice_feature f)
4137 {
4138 	if (f < 0 || f >= ICE_F_MAX)
4139 		return;
4140 
4141 	set_bit(f, pf->features);
4142 }
4143 
4144 /**
4145  * ice_clear_feature_support
4146  * @pf: pointer to the struct ice_pf instance
4147  * @f: feature enum to clear
4148  */
4149 void ice_clear_feature_support(struct ice_pf *pf, enum ice_feature f)
4150 {
4151 	if (f < 0 || f >= ICE_F_MAX)
4152 		return;
4153 
4154 	clear_bit(f, pf->features);
4155 }
4156 
4157 /**
4158  * ice_init_feature_support
4159  * @pf: pointer to the struct ice_pf instance
4160  *
4161  * called during init to setup supported feature
4162  */
4163 void ice_init_feature_support(struct ice_pf *pf)
4164 {
4165 	switch (pf->hw.device_id) {
4166 	case ICE_DEV_ID_E810C_BACKPLANE:
4167 	case ICE_DEV_ID_E810C_QSFP:
4168 	case ICE_DEV_ID_E810C_SFP:
4169 		ice_set_feature_support(pf, ICE_F_DSCP);
4170 		ice_set_feature_support(pf, ICE_F_PTP_EXTTS);
4171 		if (ice_is_e810t(&pf->hw)) {
4172 			ice_set_feature_support(pf, ICE_F_SMA_CTRL);
4173 			if (ice_gnss_is_gps_present(&pf->hw))
4174 				ice_set_feature_support(pf, ICE_F_GNSS);
4175 		}
4176 		break;
4177 	default:
4178 		break;
4179 	}
4180 }
4181 
4182 /**
4183  * ice_vsi_update_security - update security block in VSI
4184  * @vsi: pointer to VSI structure
4185  * @fill: function pointer to fill ctx
4186  */
4187 int
4188 ice_vsi_update_security(struct ice_vsi *vsi, void (*fill)(struct ice_vsi_ctx *))
4189 {
4190 	struct ice_vsi_ctx ctx = { 0 };
4191 
4192 	ctx.info = vsi->info;
4193 	ctx.info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SECURITY_VALID);
4194 	fill(&ctx);
4195 
4196 	if (ice_update_vsi(&vsi->back->hw, vsi->idx, &ctx, NULL))
4197 		return -ENODEV;
4198 
4199 	vsi->info = ctx.info;
4200 	return 0;
4201 }
4202 
4203 /**
4204  * ice_vsi_ctx_set_antispoof - set antispoof function in VSI ctx
4205  * @ctx: pointer to VSI ctx structure
4206  */
4207 void ice_vsi_ctx_set_antispoof(struct ice_vsi_ctx *ctx)
4208 {
4209 	ctx->info.sec_flags |= ICE_AQ_VSI_SEC_FLAG_ENA_MAC_ANTI_SPOOF |
4210 			       (ICE_AQ_VSI_SEC_TX_VLAN_PRUNE_ENA <<
4211 				ICE_AQ_VSI_SEC_TX_PRUNE_ENA_S);
4212 }
4213 
4214 /**
4215  * ice_vsi_ctx_clear_antispoof - clear antispoof function in VSI ctx
4216  * @ctx: pointer to VSI ctx structure
4217  */
4218 void ice_vsi_ctx_clear_antispoof(struct ice_vsi_ctx *ctx)
4219 {
4220 	ctx->info.sec_flags &= ~ICE_AQ_VSI_SEC_FLAG_ENA_MAC_ANTI_SPOOF &
4221 			       ~(ICE_AQ_VSI_SEC_TX_VLAN_PRUNE_ENA <<
4222 				 ICE_AQ_VSI_SEC_TX_PRUNE_ENA_S);
4223 }
4224 
4225 /**
4226  * ice_vsi_ctx_set_allow_override - allow destination override on VSI
4227  * @ctx: pointer to VSI ctx structure
4228  */
4229 void ice_vsi_ctx_set_allow_override(struct ice_vsi_ctx *ctx)
4230 {
4231 	ctx->info.sec_flags |= ICE_AQ_VSI_SEC_FLAG_ALLOW_DEST_OVRD;
4232 }
4233 
4234 /**
4235  * ice_vsi_ctx_clear_allow_override - turn off destination override on VSI
4236  * @ctx: pointer to VSI ctx structure
4237  */
4238 void ice_vsi_ctx_clear_allow_override(struct ice_vsi_ctx *ctx)
4239 {
4240 	ctx->info.sec_flags &= ~ICE_AQ_VSI_SEC_FLAG_ALLOW_DEST_OVRD;
4241 }
4242