1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2022, Intel Corporation. */
3 
4 #include "ice_vf_lib_private.h"
5 #include "ice.h"
6 #include "ice_lib.h"
7 #include "ice_fltr.h"
8 #include "ice_virtchnl_allowlist.h"
9 
10 /* Public functions which may be accessed by all driver files */
11 
12 /**
13  * ice_get_vf_by_id - Get pointer to VF by ID
14  * @pf: the PF private structure
15  * @vf_id: the VF ID to locate
16  *
17  * Locate and return a pointer to the VF structure associated with a given ID.
18  * Returns NULL if the ID does not have a valid VF structure associated with
19  * it.
20  *
21  * This function takes a reference to the VF, which must be released by
22  * calling ice_put_vf() once the caller is finished accessing the VF structure
23  * returned.
24  */
25 struct ice_vf *ice_get_vf_by_id(struct ice_pf *pf, u16 vf_id)
26 {
27 	struct ice_vf *vf;
28 
29 	rcu_read_lock();
30 	hash_for_each_possible_rcu(pf->vfs.table, vf, entry, vf_id) {
31 		if (vf->vf_id == vf_id) {
32 			struct ice_vf *found;
33 
34 			if (kref_get_unless_zero(&vf->refcnt))
35 				found = vf;
36 			else
37 				found = NULL;
38 
39 			rcu_read_unlock();
40 			return found;
41 		}
42 	}
43 	rcu_read_unlock();
44 
45 	return NULL;
46 }
47 
48 /**
49  * ice_release_vf - Release VF associated with a refcount
50  * @ref: the kref decremented to zero
51  *
52  * Callback function for kref_put to release a VF once its reference count has
53  * hit zero.
54  */
55 static void ice_release_vf(struct kref *ref)
56 {
57 	struct ice_vf *vf = container_of(ref, struct ice_vf, refcnt);
58 
59 	vf->vf_ops->free(vf);
60 }
61 
62 /**
63  * ice_put_vf - Release a reference to a VF
64  * @vf: the VF structure to decrease reference count on
65  *
66  * Decrease the reference count for a VF, and free the entry if it is no
67  * longer in use.
68  *
69  * This must be called after ice_get_vf_by_id() once the reference to the VF
70  * structure is no longer used. Otherwise, the VF structure will never be
71  * freed.
72  */
73 void ice_put_vf(struct ice_vf *vf)
74 {
75 	kref_put(&vf->refcnt, ice_release_vf);
76 }
77 
78 /**
79  * ice_has_vfs - Return true if the PF has any associated VFs
80  * @pf: the PF private structure
81  *
82  * Return whether or not the PF has any allocated VFs.
83  *
84  * Note that this function only guarantees that there are no VFs at the point
85  * of calling it. It does not guarantee that no more VFs will be added.
86  */
87 bool ice_has_vfs(struct ice_pf *pf)
88 {
89 	/* A simple check that the hash table is not empty does not require
90 	 * the mutex or rcu_read_lock.
91 	 */
92 	return !hash_empty(pf->vfs.table);
93 }
94 
95 /**
96  * ice_get_num_vfs - Get number of allocated VFs
97  * @pf: the PF private structure
98  *
99  * Return the total number of allocated VFs. NOTE: VF IDs are not guaranteed
100  * to be contiguous. Do not assume that a VF ID is guaranteed to be less than
101  * the output of this function.
102  */
103 u16 ice_get_num_vfs(struct ice_pf *pf)
104 {
105 	struct ice_vf *vf;
106 	unsigned int bkt;
107 	u16 num_vfs = 0;
108 
109 	rcu_read_lock();
110 	ice_for_each_vf_rcu(pf, bkt, vf)
111 		num_vfs++;
112 	rcu_read_unlock();
113 
114 	return num_vfs;
115 }
116 
117 /**
118  * ice_get_vf_vsi - get VF's VSI based on the stored index
119  * @vf: VF used to get VSI
120  */
121 struct ice_vsi *ice_get_vf_vsi(struct ice_vf *vf)
122 {
123 	if (vf->lan_vsi_idx == ICE_NO_VSI)
124 		return NULL;
125 
126 	return vf->pf->vsi[vf->lan_vsi_idx];
127 }
128 
129 /**
130  * ice_is_vf_disabled
131  * @vf: pointer to the VF info
132  *
133  * If the PF has been disabled, there is no need resetting VF until PF is
134  * active again. Similarly, if the VF has been disabled, this means something
135  * else is resetting the VF, so we shouldn't continue.
136  *
137  * Returns true if the caller should consider the VF as disabled whether
138  * because that single VF is explicitly disabled or because the PF is
139  * currently disabled.
140  */
141 bool ice_is_vf_disabled(struct ice_vf *vf)
142 {
143 	struct ice_pf *pf = vf->pf;
144 
145 	return (test_bit(ICE_VF_DIS, pf->state) ||
146 		test_bit(ICE_VF_STATE_DIS, vf->vf_states));
147 }
148 
149 /**
150  * ice_wait_on_vf_reset - poll to make sure a given VF is ready after reset
151  * @vf: The VF being resseting
152  *
153  * The max poll time is about ~800ms, which is about the maximum time it takes
154  * for a VF to be reset and/or a VF driver to be removed.
155  */
156 static void ice_wait_on_vf_reset(struct ice_vf *vf)
157 {
158 	int i;
159 
160 	for (i = 0; i < ICE_MAX_VF_RESET_TRIES; i++) {
161 		if (test_bit(ICE_VF_STATE_INIT, vf->vf_states))
162 			break;
163 		msleep(ICE_MAX_VF_RESET_SLEEP_MS);
164 	}
165 }
166 
167 /**
168  * ice_check_vf_ready_for_cfg - check if VF is ready to be configured/queried
169  * @vf: VF to check if it's ready to be configured/queried
170  *
171  * The purpose of this function is to make sure the VF is not in reset, not
172  * disabled, and initialized so it can be configured and/or queried by a host
173  * administrator.
174  */
175 int ice_check_vf_ready_for_cfg(struct ice_vf *vf)
176 {
177 	ice_wait_on_vf_reset(vf);
178 
179 	if (ice_is_vf_disabled(vf))
180 		return -EINVAL;
181 
182 	if (ice_check_vf_init(vf))
183 		return -EBUSY;
184 
185 	return 0;
186 }
187 
188 /**
189  * ice_trigger_vf_reset - Reset a VF on HW
190  * @vf: pointer to the VF structure
191  * @is_vflr: true if VFLR was issued, false if not
192  * @is_pfr: true if the reset was triggered due to a previous PFR
193  *
194  * Trigger hardware to start a reset for a particular VF. Expects the caller
195  * to wait the proper amount of time to allow hardware to reset the VF before
196  * it cleans up and restores VF functionality.
197  */
198 static void ice_trigger_vf_reset(struct ice_vf *vf, bool is_vflr, bool is_pfr)
199 {
200 	/* Inform VF that it is no longer active, as a warning */
201 	clear_bit(ICE_VF_STATE_ACTIVE, vf->vf_states);
202 
203 	/* Disable VF's configuration API during reset. The flag is re-enabled
204 	 * when it's safe again to access VF's VSI.
205 	 */
206 	clear_bit(ICE_VF_STATE_INIT, vf->vf_states);
207 
208 	/* VF_MBX_ARQLEN and VF_MBX_ATQLEN are cleared by PFR, so the driver
209 	 * needs to clear them in the case of VFR/VFLR. If this is done for
210 	 * PFR, it can mess up VF resets because the VF driver may already
211 	 * have started cleanup by the time we get here.
212 	 */
213 	if (!is_pfr)
214 		vf->vf_ops->clear_mbx_register(vf);
215 
216 	vf->vf_ops->trigger_reset_register(vf, is_vflr);
217 }
218 
219 static void ice_vf_clear_counters(struct ice_vf *vf)
220 {
221 	struct ice_vsi *vsi = ice_get_vf_vsi(vf);
222 
223 	if (vsi)
224 		vsi->num_vlan = 0;
225 
226 	vf->num_mac = 0;
227 	memset(&vf->mdd_tx_events, 0, sizeof(vf->mdd_tx_events));
228 	memset(&vf->mdd_rx_events, 0, sizeof(vf->mdd_rx_events));
229 }
230 
231 /**
232  * ice_vf_pre_vsi_rebuild - tasks to be done prior to VSI rebuild
233  * @vf: VF to perform pre VSI rebuild tasks
234  *
235  * These tasks are items that don't need to be amortized since they are most
236  * likely called in a for loop with all VF(s) in the reset_all_vfs() case.
237  */
238 static void ice_vf_pre_vsi_rebuild(struct ice_vf *vf)
239 {
240 	/* Close any IRQ mapping now */
241 	if (vf->vf_ops->irq_close)
242 		vf->vf_ops->irq_close(vf);
243 
244 	ice_vf_clear_counters(vf);
245 	vf->vf_ops->clear_reset_trigger(vf);
246 }
247 
248 /**
249  * ice_vf_recreate_vsi - Release and re-create the VF's VSI
250  * @vf: VF to recreate the VSI for
251  *
252  * This is only called when a single VF is being reset (i.e. VVF, VFLR, host
253  * VF configuration change, etc)
254  *
255  * It releases and then re-creates a new VSI.
256  */
257 static int ice_vf_recreate_vsi(struct ice_vf *vf)
258 {
259 	struct ice_pf *pf = vf->pf;
260 	int err;
261 
262 	ice_vf_vsi_release(vf);
263 
264 	err = vf->vf_ops->create_vsi(vf);
265 	if (err) {
266 		dev_err(ice_pf_to_dev(pf),
267 			"Failed to recreate the VF%u's VSI, error %d\n",
268 			vf->vf_id, err);
269 		return err;
270 	}
271 
272 	return 0;
273 }
274 
275 /**
276  * ice_vf_rebuild_vsi - rebuild the VF's VSI
277  * @vf: VF to rebuild the VSI for
278  *
279  * This is only called when all VF(s) are being reset (i.e. PCIe Reset on the
280  * host, PFR, CORER, etc.).
281  *
282  * It reprograms the VSI configuration back into hardware.
283  */
284 static int ice_vf_rebuild_vsi(struct ice_vf *vf)
285 {
286 	struct ice_vsi *vsi = ice_get_vf_vsi(vf);
287 	struct ice_pf *pf = vf->pf;
288 
289 	if (WARN_ON(!vsi))
290 		return -EINVAL;
291 
292 	if (ice_vsi_rebuild(vsi, ICE_VSI_FLAG_INIT)) {
293 		dev_err(ice_pf_to_dev(pf), "failed to rebuild VF %d VSI\n",
294 			vf->vf_id);
295 		return -EIO;
296 	}
297 	/* vsi->idx will remain the same in this case so don't update
298 	 * vf->lan_vsi_idx
299 	 */
300 	vsi->vsi_num = ice_get_hw_vsi_num(&pf->hw, vsi->idx);
301 	vf->lan_vsi_num = vsi->vsi_num;
302 
303 	return 0;
304 }
305 
306 /**
307  * ice_vf_post_vsi_rebuild - Reset tasks that occur after VSI rebuild
308  * @vf: the VF being reset
309  *
310  * Perform reset tasks which must occur after the VSI has been re-created or
311  * rebuilt during a VF reset.
312  */
313 static void ice_vf_post_vsi_rebuild(struct ice_vf *vf)
314 {
315 	ice_vf_rebuild_host_cfg(vf);
316 	ice_vf_set_initialized(vf);
317 
318 	vf->vf_ops->post_vsi_rebuild(vf);
319 }
320 
321 /**
322  * ice_is_any_vf_in_unicast_promisc - check if any VF(s)
323  * are in unicast promiscuous mode
324  * @pf: PF structure for accessing VF(s)
325  *
326  * Return false if no VF(s) are in unicast promiscuous mode,
327  * else return true
328  */
329 bool ice_is_any_vf_in_unicast_promisc(struct ice_pf *pf)
330 {
331 	bool is_vf_promisc = false;
332 	struct ice_vf *vf;
333 	unsigned int bkt;
334 
335 	rcu_read_lock();
336 	ice_for_each_vf_rcu(pf, bkt, vf) {
337 		/* found a VF that has promiscuous mode configured */
338 		if (test_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states)) {
339 			is_vf_promisc = true;
340 			break;
341 		}
342 	}
343 	rcu_read_unlock();
344 
345 	return is_vf_promisc;
346 }
347 
348 /**
349  * ice_vf_get_promisc_masks - Calculate masks for promiscuous modes
350  * @vf: the VF pointer
351  * @vsi: the VSI to configure
352  * @ucast_m: promiscuous mask to apply to unicast
353  * @mcast_m: promiscuous mask to apply to multicast
354  *
355  * Decide which mask should be used for unicast and multicast filter,
356  * based on presence of VLANs
357  */
358 void
359 ice_vf_get_promisc_masks(struct ice_vf *vf, struct ice_vsi *vsi,
360 			 u8 *ucast_m, u8 *mcast_m)
361 {
362 	if (ice_vf_is_port_vlan_ena(vf) ||
363 	    ice_vsi_has_non_zero_vlans(vsi)) {
364 		*mcast_m = ICE_MCAST_VLAN_PROMISC_BITS;
365 		*ucast_m = ICE_UCAST_VLAN_PROMISC_BITS;
366 	} else {
367 		*mcast_m = ICE_MCAST_PROMISC_BITS;
368 		*ucast_m = ICE_UCAST_PROMISC_BITS;
369 	}
370 }
371 
372 /**
373  * ice_vf_clear_all_promisc_modes - Clear promisc/allmulticast on VF VSI
374  * @vf: the VF pointer
375  * @vsi: the VSI to configure
376  *
377  * Clear all promiscuous/allmulticast filters for a VF
378  */
379 static int
380 ice_vf_clear_all_promisc_modes(struct ice_vf *vf, struct ice_vsi *vsi)
381 {
382 	struct ice_pf *pf = vf->pf;
383 	u8 ucast_m, mcast_m;
384 	int ret = 0;
385 
386 	ice_vf_get_promisc_masks(vf, vsi, &ucast_m, &mcast_m);
387 	if (test_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states)) {
388 		if (!test_bit(ICE_FLAG_VF_TRUE_PROMISC_ENA, pf->flags)) {
389 			if (ice_is_dflt_vsi_in_use(vsi->port_info))
390 				ret = ice_clear_dflt_vsi(vsi);
391 		} else {
392 			ret = ice_vf_clear_vsi_promisc(vf, vsi, ucast_m);
393 		}
394 
395 		if (ret) {
396 			dev_err(ice_pf_to_dev(vf->pf), "Disabling promiscuous mode failed\n");
397 		} else {
398 			clear_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states);
399 			dev_info(ice_pf_to_dev(vf->pf), "Disabling promiscuous mode succeeded\n");
400 		}
401 	}
402 
403 	if (test_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states)) {
404 		ret = ice_vf_clear_vsi_promisc(vf, vsi, mcast_m);
405 		if (ret) {
406 			dev_err(ice_pf_to_dev(vf->pf), "Disabling allmulticast mode failed\n");
407 		} else {
408 			clear_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states);
409 			dev_info(ice_pf_to_dev(vf->pf), "Disabling allmulticast mode succeeded\n");
410 		}
411 	}
412 	return ret;
413 }
414 
415 /**
416  * ice_vf_set_vsi_promisc - Enable promiscuous mode for a VF VSI
417  * @vf: the VF to configure
418  * @vsi: the VF's VSI
419  * @promisc_m: the promiscuous mode to enable
420  */
421 int
422 ice_vf_set_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m)
423 {
424 	struct ice_hw *hw = &vsi->back->hw;
425 	int status;
426 
427 	if (ice_vf_is_port_vlan_ena(vf))
428 		status = ice_fltr_set_vsi_promisc(hw, vsi->idx, promisc_m,
429 						  ice_vf_get_port_vlan_id(vf));
430 	else if (ice_vsi_has_non_zero_vlans(vsi))
431 		status = ice_fltr_set_vlan_vsi_promisc(hw, vsi, promisc_m);
432 	else
433 		status = ice_fltr_set_vsi_promisc(hw, vsi->idx, promisc_m, 0);
434 
435 	if (status && status != -EEXIST) {
436 		dev_err(ice_pf_to_dev(vsi->back), "enable Tx/Rx filter promiscuous mode on VF-%u failed, error: %d\n",
437 			vf->vf_id, status);
438 		return status;
439 	}
440 
441 	return 0;
442 }
443 
444 /**
445  * ice_vf_clear_vsi_promisc - Disable promiscuous mode for a VF VSI
446  * @vf: the VF to configure
447  * @vsi: the VF's VSI
448  * @promisc_m: the promiscuous mode to disable
449  */
450 int
451 ice_vf_clear_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m)
452 {
453 	struct ice_hw *hw = &vsi->back->hw;
454 	int status;
455 
456 	if (ice_vf_is_port_vlan_ena(vf))
457 		status = ice_fltr_clear_vsi_promisc(hw, vsi->idx, promisc_m,
458 						    ice_vf_get_port_vlan_id(vf));
459 	else if (ice_vsi_has_non_zero_vlans(vsi))
460 		status = ice_fltr_clear_vlan_vsi_promisc(hw, vsi, promisc_m);
461 	else
462 		status = ice_fltr_clear_vsi_promisc(hw, vsi->idx, promisc_m, 0);
463 
464 	if (status && status != -ENOENT) {
465 		dev_err(ice_pf_to_dev(vsi->back), "disable Tx/Rx filter promiscuous mode on VF-%u failed, error: %d\n",
466 			vf->vf_id, status);
467 		return status;
468 	}
469 
470 	return 0;
471 }
472 
473 /**
474  * ice_reset_all_vfs - reset all allocated VFs in one go
475  * @pf: pointer to the PF structure
476  *
477  * Reset all VFs at once, in response to a PF or other device reset.
478  *
479  * First, tell the hardware to reset each VF, then do all the waiting in one
480  * chunk, and finally finish restoring each VF after the wait. This is useful
481  * during PF routines which need to reset all VFs, as otherwise it must perform
482  * these resets in a serialized fashion.
483  */
484 void ice_reset_all_vfs(struct ice_pf *pf)
485 {
486 	struct device *dev = ice_pf_to_dev(pf);
487 	struct ice_hw *hw = &pf->hw;
488 	struct ice_vf *vf;
489 	unsigned int bkt;
490 
491 	/* If we don't have any VFs, then there is nothing to reset */
492 	if (!ice_has_vfs(pf))
493 		return;
494 
495 	mutex_lock(&pf->vfs.table_lock);
496 
497 	/* clear all malicious info if the VFs are getting reset */
498 	ice_for_each_vf(pf, bkt, vf)
499 		ice_mbx_clear_malvf(&vf->mbx_info);
500 
501 	/* If VFs have been disabled, there is no need to reset */
502 	if (test_and_set_bit(ICE_VF_DIS, pf->state)) {
503 		mutex_unlock(&pf->vfs.table_lock);
504 		return;
505 	}
506 
507 	/* Begin reset on all VFs at once */
508 	ice_for_each_vf(pf, bkt, vf)
509 		ice_trigger_vf_reset(vf, true, true);
510 
511 	/* HW requires some time to make sure it can flush the FIFO for a VF
512 	 * when it resets it. Now that we've triggered all of the VFs, iterate
513 	 * the table again and wait for each VF to complete.
514 	 */
515 	ice_for_each_vf(pf, bkt, vf) {
516 		if (!vf->vf_ops->poll_reset_status(vf)) {
517 			/* Display a warning if at least one VF didn't manage
518 			 * to reset in time, but continue on with the
519 			 * operation.
520 			 */
521 			dev_warn(dev, "VF %u reset check timeout\n", vf->vf_id);
522 			break;
523 		}
524 	}
525 
526 	/* free VF resources to begin resetting the VSI state */
527 	ice_for_each_vf(pf, bkt, vf) {
528 		mutex_lock(&vf->cfg_lock);
529 
530 		vf->driver_caps = 0;
531 		ice_vc_set_default_allowlist(vf);
532 
533 		ice_vf_fdir_exit(vf);
534 		ice_vf_fdir_init(vf);
535 		/* clean VF control VSI when resetting VFs since it should be
536 		 * setup only when VF creates its first FDIR rule.
537 		 */
538 		if (vf->ctrl_vsi_idx != ICE_NO_VSI)
539 			ice_vf_ctrl_invalidate_vsi(vf);
540 
541 		ice_vf_pre_vsi_rebuild(vf);
542 		ice_vf_rebuild_vsi(vf);
543 		ice_vf_post_vsi_rebuild(vf);
544 
545 		mutex_unlock(&vf->cfg_lock);
546 	}
547 
548 	if (ice_is_eswitch_mode_switchdev(pf))
549 		if (ice_eswitch_rebuild(pf))
550 			dev_warn(dev, "eswitch rebuild failed\n");
551 
552 	ice_flush(hw);
553 	clear_bit(ICE_VF_DIS, pf->state);
554 
555 	mutex_unlock(&pf->vfs.table_lock);
556 }
557 
558 /**
559  * ice_notify_vf_reset - Notify VF of a reset event
560  * @vf: pointer to the VF structure
561  */
562 static void ice_notify_vf_reset(struct ice_vf *vf)
563 {
564 	struct ice_hw *hw = &vf->pf->hw;
565 	struct virtchnl_pf_event pfe;
566 
567 	/* Bail out if VF is in disabled state, neither initialized, nor active
568 	 * state - otherwise proceed with notifications
569 	 */
570 	if ((!test_bit(ICE_VF_STATE_INIT, vf->vf_states) &&
571 	     !test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) ||
572 	    test_bit(ICE_VF_STATE_DIS, vf->vf_states))
573 		return;
574 
575 	pfe.event = VIRTCHNL_EVENT_RESET_IMPENDING;
576 	pfe.severity = PF_EVENT_SEVERITY_CERTAIN_DOOM;
577 	ice_aq_send_msg_to_vf(hw, vf->vf_id, VIRTCHNL_OP_EVENT,
578 			      VIRTCHNL_STATUS_SUCCESS, (u8 *)&pfe, sizeof(pfe),
579 			      NULL);
580 }
581 
582 /**
583  * ice_reset_vf - Reset a particular VF
584  * @vf: pointer to the VF structure
585  * @flags: flags controlling behavior of the reset
586  *
587  * Flags:
588  *   ICE_VF_RESET_VFLR - Indicates a reset is due to VFLR event
589  *   ICE_VF_RESET_NOTIFY - Send VF a notification prior to reset
590  *   ICE_VF_RESET_LOCK - Acquire VF cfg_lock before resetting
591  *
592  * Returns 0 if the VF is currently in reset, if resets are disabled, or if
593  * the VF resets successfully. Returns an error code if the VF fails to
594  * rebuild.
595  */
596 int ice_reset_vf(struct ice_vf *vf, u32 flags)
597 {
598 	struct ice_pf *pf = vf->pf;
599 	struct ice_vsi *vsi;
600 	struct device *dev;
601 	int err = 0;
602 	bool rsd;
603 
604 	dev = ice_pf_to_dev(pf);
605 
606 	if (flags & ICE_VF_RESET_NOTIFY)
607 		ice_notify_vf_reset(vf);
608 
609 	if (test_bit(ICE_VF_RESETS_DISABLED, pf->state)) {
610 		dev_dbg(dev, "Trying to reset VF %d, but all VF resets are disabled\n",
611 			vf->vf_id);
612 		return 0;
613 	}
614 
615 	if (ice_is_vf_disabled(vf)) {
616 		vsi = ice_get_vf_vsi(vf);
617 		if (!vsi) {
618 			dev_dbg(dev, "VF is already removed\n");
619 			return -EINVAL;
620 		}
621 		ice_vsi_stop_lan_tx_rings(vsi, ICE_NO_RESET, vf->vf_id);
622 
623 		if (ice_vsi_is_rx_queue_active(vsi))
624 			ice_vsi_stop_all_rx_rings(vsi);
625 
626 		dev_dbg(dev, "VF is already disabled, there is no need for resetting it, telling VM, all is fine %d\n",
627 			vf->vf_id);
628 		return 0;
629 	}
630 
631 	if (flags & ICE_VF_RESET_LOCK)
632 		mutex_lock(&vf->cfg_lock);
633 	else
634 		lockdep_assert_held(&vf->cfg_lock);
635 
636 	/* Set VF disable bit state here, before triggering reset */
637 	set_bit(ICE_VF_STATE_DIS, vf->vf_states);
638 	ice_trigger_vf_reset(vf, flags & ICE_VF_RESET_VFLR, false);
639 
640 	vsi = ice_get_vf_vsi(vf);
641 	if (WARN_ON(!vsi)) {
642 		err = -EIO;
643 		goto out_unlock;
644 	}
645 
646 	ice_dis_vf_qs(vf);
647 
648 	/* Call Disable LAN Tx queue AQ whether or not queues are
649 	 * enabled. This is needed for successful completion of VFR.
650 	 */
651 	ice_dis_vsi_txq(vsi->port_info, vsi->idx, 0, 0, NULL, NULL,
652 			NULL, vf->vf_ops->reset_type, vf->vf_id, NULL);
653 
654 	/* poll VPGEN_VFRSTAT reg to make sure
655 	 * that reset is complete
656 	 */
657 	rsd = vf->vf_ops->poll_reset_status(vf);
658 
659 	/* Display a warning if VF didn't manage to reset in time, but need to
660 	 * continue on with the operation.
661 	 */
662 	if (!rsd)
663 		dev_warn(dev, "VF reset check timeout on VF %d\n", vf->vf_id);
664 
665 	vf->driver_caps = 0;
666 	ice_vc_set_default_allowlist(vf);
667 
668 	/* disable promiscuous modes in case they were enabled
669 	 * ignore any error if disabling process failed
670 	 */
671 	ice_vf_clear_all_promisc_modes(vf, vsi);
672 
673 	ice_eswitch_del_vf_mac_rule(vf);
674 
675 	ice_vf_fdir_exit(vf);
676 	ice_vf_fdir_init(vf);
677 	/* clean VF control VSI when resetting VF since it should be setup
678 	 * only when VF creates its first FDIR rule.
679 	 */
680 	if (vf->ctrl_vsi_idx != ICE_NO_VSI)
681 		ice_vf_ctrl_vsi_release(vf);
682 
683 	ice_vf_pre_vsi_rebuild(vf);
684 
685 	if (ice_vf_recreate_vsi(vf)) {
686 		dev_err(dev, "Failed to release and setup the VF%u's VSI\n",
687 			vf->vf_id);
688 		err = -EFAULT;
689 		goto out_unlock;
690 	}
691 
692 	ice_vf_post_vsi_rebuild(vf);
693 	vsi = ice_get_vf_vsi(vf);
694 	if (WARN_ON(!vsi)) {
695 		err = -EINVAL;
696 		goto out_unlock;
697 	}
698 
699 	ice_eswitch_update_repr(vsi);
700 	ice_eswitch_replay_vf_mac_rule(vf);
701 
702 	/* if the VF has been reset allow it to come up again */
703 	ice_mbx_clear_malvf(&vf->mbx_info);
704 
705 out_unlock:
706 	if (flags & ICE_VF_RESET_LOCK)
707 		mutex_unlock(&vf->cfg_lock);
708 
709 	return err;
710 }
711 
712 /**
713  * ice_set_vf_state_qs_dis - Set VF queues state to disabled
714  * @vf: pointer to the VF structure
715  */
716 static void ice_set_vf_state_qs_dis(struct ice_vf *vf)
717 {
718 	/* Clear Rx/Tx enabled queues flag */
719 	bitmap_zero(vf->txq_ena, ICE_MAX_RSS_QS_PER_VF);
720 	bitmap_zero(vf->rxq_ena, ICE_MAX_RSS_QS_PER_VF);
721 	clear_bit(ICE_VF_STATE_QS_ENA, vf->vf_states);
722 }
723 
724 /**
725  * ice_set_vf_state_dis - Set VF state to disabled
726  * @vf: pointer to the VF structure
727  */
728 void ice_set_vf_state_dis(struct ice_vf *vf)
729 {
730 	ice_set_vf_state_qs_dis(vf);
731 	vf->vf_ops->clear_reset_state(vf);
732 }
733 
734 /* Private functions only accessed from other virtualization files */
735 
736 /**
737  * ice_initialize_vf_entry - Initialize a VF entry
738  * @vf: pointer to the VF structure
739  */
740 void ice_initialize_vf_entry(struct ice_vf *vf)
741 {
742 	struct ice_pf *pf = vf->pf;
743 	struct ice_vfs *vfs;
744 
745 	vfs = &pf->vfs;
746 
747 	/* assign default capabilities */
748 	vf->spoofchk = true;
749 	vf->num_vf_qs = vfs->num_qps_per;
750 	ice_vc_set_default_allowlist(vf);
751 	ice_virtchnl_set_dflt_ops(vf);
752 
753 	/* ctrl_vsi_idx will be set to a valid value only when iAVF
754 	 * creates its first fdir rule.
755 	 */
756 	ice_vf_ctrl_invalidate_vsi(vf);
757 	ice_vf_fdir_init(vf);
758 
759 	/* Initialize mailbox info for this VF */
760 	ice_mbx_init_vf_info(&pf->hw, &vf->mbx_info);
761 
762 	mutex_init(&vf->cfg_lock);
763 }
764 
765 /**
766  * ice_dis_vf_qs - Disable the VF queues
767  * @vf: pointer to the VF structure
768  */
769 void ice_dis_vf_qs(struct ice_vf *vf)
770 {
771 	struct ice_vsi *vsi = ice_get_vf_vsi(vf);
772 
773 	if (WARN_ON(!vsi))
774 		return;
775 
776 	ice_vsi_stop_lan_tx_rings(vsi, ICE_NO_RESET, vf->vf_id);
777 	ice_vsi_stop_all_rx_rings(vsi);
778 	ice_set_vf_state_qs_dis(vf);
779 }
780 
781 /**
782  * ice_err_to_virt_err - translate errors for VF return code
783  * @err: error return code
784  */
785 enum virtchnl_status_code ice_err_to_virt_err(int err)
786 {
787 	switch (err) {
788 	case 0:
789 		return VIRTCHNL_STATUS_SUCCESS;
790 	case -EINVAL:
791 	case -ENODEV:
792 		return VIRTCHNL_STATUS_ERR_PARAM;
793 	case -ENOMEM:
794 		return VIRTCHNL_STATUS_ERR_NO_MEMORY;
795 	case -EALREADY:
796 	case -EBUSY:
797 	case -EIO:
798 	case -ENOSPC:
799 		return VIRTCHNL_STATUS_ERR_ADMIN_QUEUE_ERROR;
800 	default:
801 		return VIRTCHNL_STATUS_ERR_NOT_SUPPORTED;
802 	}
803 }
804 
805 /**
806  * ice_check_vf_init - helper to check if VF init complete
807  * @vf: the pointer to the VF to check
808  */
809 int ice_check_vf_init(struct ice_vf *vf)
810 {
811 	struct ice_pf *pf = vf->pf;
812 
813 	if (!test_bit(ICE_VF_STATE_INIT, vf->vf_states)) {
814 		dev_err(ice_pf_to_dev(pf), "VF ID: %u in reset. Try again.\n",
815 			vf->vf_id);
816 		return -EBUSY;
817 	}
818 	return 0;
819 }
820 
821 /**
822  * ice_vf_get_port_info - Get the VF's port info structure
823  * @vf: VF used to get the port info structure for
824  */
825 struct ice_port_info *ice_vf_get_port_info(struct ice_vf *vf)
826 {
827 	return vf->pf->hw.port_info;
828 }
829 
830 /**
831  * ice_cfg_mac_antispoof - Configure MAC antispoof checking behavior
832  * @vsi: the VSI to configure
833  * @enable: whether to enable or disable the spoof checking
834  *
835  * Configure a VSI to enable (or disable) spoof checking behavior.
836  */
837 static int ice_cfg_mac_antispoof(struct ice_vsi *vsi, bool enable)
838 {
839 	struct ice_vsi_ctx *ctx;
840 	int err;
841 
842 	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
843 	if (!ctx)
844 		return -ENOMEM;
845 
846 	ctx->info.sec_flags = vsi->info.sec_flags;
847 	ctx->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SECURITY_VALID);
848 
849 	if (enable)
850 		ctx->info.sec_flags |= ICE_AQ_VSI_SEC_FLAG_ENA_MAC_ANTI_SPOOF;
851 	else
852 		ctx->info.sec_flags &= ~ICE_AQ_VSI_SEC_FLAG_ENA_MAC_ANTI_SPOOF;
853 
854 	err = ice_update_vsi(&vsi->back->hw, vsi->idx, ctx, NULL);
855 	if (err)
856 		dev_err(ice_pf_to_dev(vsi->back), "Failed to configure Tx MAC anti-spoof %s for VSI %d, error %d\n",
857 			enable ? "ON" : "OFF", vsi->vsi_num, err);
858 	else
859 		vsi->info.sec_flags = ctx->info.sec_flags;
860 
861 	kfree(ctx);
862 
863 	return err;
864 }
865 
866 /**
867  * ice_vsi_ena_spoofchk - enable Tx spoof checking for this VSI
868  * @vsi: VSI to enable Tx spoof checking for
869  */
870 static int ice_vsi_ena_spoofchk(struct ice_vsi *vsi)
871 {
872 	struct ice_vsi_vlan_ops *vlan_ops;
873 	int err = 0;
874 
875 	vlan_ops = ice_get_compat_vsi_vlan_ops(vsi);
876 
877 	/* Allow VF with VLAN 0 only to send all tagged traffic */
878 	if (vsi->type != ICE_VSI_VF || ice_vsi_has_non_zero_vlans(vsi)) {
879 		err = vlan_ops->ena_tx_filtering(vsi);
880 		if (err)
881 			return err;
882 	}
883 
884 	return ice_cfg_mac_antispoof(vsi, true);
885 }
886 
887 /**
888  * ice_vsi_dis_spoofchk - disable Tx spoof checking for this VSI
889  * @vsi: VSI to disable Tx spoof checking for
890  */
891 static int ice_vsi_dis_spoofchk(struct ice_vsi *vsi)
892 {
893 	struct ice_vsi_vlan_ops *vlan_ops;
894 	int err;
895 
896 	vlan_ops = ice_get_compat_vsi_vlan_ops(vsi);
897 
898 	err = vlan_ops->dis_tx_filtering(vsi);
899 	if (err)
900 		return err;
901 
902 	return ice_cfg_mac_antispoof(vsi, false);
903 }
904 
905 /**
906  * ice_vsi_apply_spoofchk - Apply Tx spoof checking setting to a VSI
907  * @vsi: VSI associated to the VF
908  * @enable: whether to enable or disable the spoof checking
909  */
910 int ice_vsi_apply_spoofchk(struct ice_vsi *vsi, bool enable)
911 {
912 	int err;
913 
914 	if (enable)
915 		err = ice_vsi_ena_spoofchk(vsi);
916 	else
917 		err = ice_vsi_dis_spoofchk(vsi);
918 
919 	return err;
920 }
921 
922 /**
923  * ice_is_vf_trusted
924  * @vf: pointer to the VF info
925  */
926 bool ice_is_vf_trusted(struct ice_vf *vf)
927 {
928 	return test_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
929 }
930 
931 /**
932  * ice_vf_has_no_qs_ena - check if the VF has any Rx or Tx queues enabled
933  * @vf: the VF to check
934  *
935  * Returns true if the VF has no Rx and no Tx queues enabled and returns false
936  * otherwise
937  */
938 bool ice_vf_has_no_qs_ena(struct ice_vf *vf)
939 {
940 	return (!bitmap_weight(vf->rxq_ena, ICE_MAX_RSS_QS_PER_VF) &&
941 		!bitmap_weight(vf->txq_ena, ICE_MAX_RSS_QS_PER_VF));
942 }
943 
944 /**
945  * ice_is_vf_link_up - check if the VF's link is up
946  * @vf: VF to check if link is up
947  */
948 bool ice_is_vf_link_up(struct ice_vf *vf)
949 {
950 	struct ice_port_info *pi = ice_vf_get_port_info(vf);
951 
952 	if (ice_check_vf_init(vf))
953 		return false;
954 
955 	if (ice_vf_has_no_qs_ena(vf))
956 		return false;
957 	else if (vf->link_forced)
958 		return vf->link_up;
959 	else
960 		return pi->phy.link_info.link_info &
961 			ICE_AQ_LINK_UP;
962 }
963 
964 /**
965  * ice_vf_set_host_trust_cfg - set trust setting based on pre-reset value
966  * @vf: VF to configure trust setting for
967  */
968 static void ice_vf_set_host_trust_cfg(struct ice_vf *vf)
969 {
970 	if (vf->trusted)
971 		set_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
972 	else
973 		clear_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
974 }
975 
976 /**
977  * ice_vf_rebuild_host_mac_cfg - add broadcast and the VF's perm_addr/LAA
978  * @vf: VF to add MAC filters for
979  *
980  * Called after a VF VSI has been re-added/rebuilt during reset. The PF driver
981  * always re-adds a broadcast filter and the VF's perm_addr/LAA after reset.
982  */
983 static int ice_vf_rebuild_host_mac_cfg(struct ice_vf *vf)
984 {
985 	struct device *dev = ice_pf_to_dev(vf->pf);
986 	struct ice_vsi *vsi = ice_get_vf_vsi(vf);
987 	u8 broadcast[ETH_ALEN];
988 	int status;
989 
990 	if (WARN_ON(!vsi))
991 		return -EINVAL;
992 
993 	if (ice_is_eswitch_mode_switchdev(vf->pf))
994 		return 0;
995 
996 	eth_broadcast_addr(broadcast);
997 	status = ice_fltr_add_mac(vsi, broadcast, ICE_FWD_TO_VSI);
998 	if (status) {
999 		dev_err(dev, "failed to add broadcast MAC filter for VF %u, error %d\n",
1000 			vf->vf_id, status);
1001 		return status;
1002 	}
1003 
1004 	vf->num_mac++;
1005 
1006 	if (is_valid_ether_addr(vf->hw_lan_addr)) {
1007 		status = ice_fltr_add_mac(vsi, vf->hw_lan_addr,
1008 					  ICE_FWD_TO_VSI);
1009 		if (status) {
1010 			dev_err(dev, "failed to add default unicast MAC filter %pM for VF %u, error %d\n",
1011 				&vf->hw_lan_addr[0], vf->vf_id,
1012 				status);
1013 			return status;
1014 		}
1015 		vf->num_mac++;
1016 
1017 		ether_addr_copy(vf->dev_lan_addr, vf->hw_lan_addr);
1018 	}
1019 
1020 	return 0;
1021 }
1022 
1023 /**
1024  * ice_vf_rebuild_host_vlan_cfg - add VLAN 0 filter or rebuild the Port VLAN
1025  * @vf: VF to add MAC filters for
1026  * @vsi: Pointer to VSI
1027  *
1028  * Called after a VF VSI has been re-added/rebuilt during reset. The PF driver
1029  * always re-adds either a VLAN 0 or port VLAN based filter after reset.
1030  */
1031 static int ice_vf_rebuild_host_vlan_cfg(struct ice_vf *vf, struct ice_vsi *vsi)
1032 {
1033 	struct ice_vsi_vlan_ops *vlan_ops = ice_get_compat_vsi_vlan_ops(vsi);
1034 	struct device *dev = ice_pf_to_dev(vf->pf);
1035 	int err;
1036 
1037 	if (ice_vf_is_port_vlan_ena(vf)) {
1038 		err = vlan_ops->set_port_vlan(vsi, &vf->port_vlan_info);
1039 		if (err) {
1040 			dev_err(dev, "failed to configure port VLAN via VSI parameters for VF %u, error %d\n",
1041 				vf->vf_id, err);
1042 			return err;
1043 		}
1044 
1045 		err = vlan_ops->add_vlan(vsi, &vf->port_vlan_info);
1046 	} else {
1047 		err = ice_vsi_add_vlan_zero(vsi);
1048 	}
1049 
1050 	if (err) {
1051 		dev_err(dev, "failed to add VLAN %u filter for VF %u during VF rebuild, error %d\n",
1052 			ice_vf_is_port_vlan_ena(vf) ?
1053 			ice_vf_get_port_vlan_id(vf) : 0, vf->vf_id, err);
1054 		return err;
1055 	}
1056 
1057 	err = vlan_ops->ena_rx_filtering(vsi);
1058 	if (err)
1059 		dev_warn(dev, "failed to enable Rx VLAN filtering for VF %d VSI %d during VF rebuild, error %d\n",
1060 			 vf->vf_id, vsi->idx, err);
1061 
1062 	return 0;
1063 }
1064 
1065 /**
1066  * ice_vf_rebuild_host_tx_rate_cfg - re-apply the Tx rate limiting configuration
1067  * @vf: VF to re-apply the configuration for
1068  *
1069  * Called after a VF VSI has been re-added/rebuild during reset. The PF driver
1070  * needs to re-apply the host configured Tx rate limiting configuration.
1071  */
1072 static int ice_vf_rebuild_host_tx_rate_cfg(struct ice_vf *vf)
1073 {
1074 	struct device *dev = ice_pf_to_dev(vf->pf);
1075 	struct ice_vsi *vsi = ice_get_vf_vsi(vf);
1076 	int err;
1077 
1078 	if (WARN_ON(!vsi))
1079 		return -EINVAL;
1080 
1081 	if (vf->min_tx_rate) {
1082 		err = ice_set_min_bw_limit(vsi, (u64)vf->min_tx_rate * 1000);
1083 		if (err) {
1084 			dev_err(dev, "failed to set min Tx rate to %d Mbps for VF %u, error %d\n",
1085 				vf->min_tx_rate, vf->vf_id, err);
1086 			return err;
1087 		}
1088 	}
1089 
1090 	if (vf->max_tx_rate) {
1091 		err = ice_set_max_bw_limit(vsi, (u64)vf->max_tx_rate * 1000);
1092 		if (err) {
1093 			dev_err(dev, "failed to set max Tx rate to %d Mbps for VF %u, error %d\n",
1094 				vf->max_tx_rate, vf->vf_id, err);
1095 			return err;
1096 		}
1097 	}
1098 
1099 	return 0;
1100 }
1101 
1102 /**
1103  * ice_vf_rebuild_aggregator_node_cfg - rebuild aggregator node config
1104  * @vsi: Pointer to VSI
1105  *
1106  * This function moves VSI into corresponding scheduler aggregator node
1107  * based on cached value of "aggregator node info" per VSI
1108  */
1109 static void ice_vf_rebuild_aggregator_node_cfg(struct ice_vsi *vsi)
1110 {
1111 	struct ice_pf *pf = vsi->back;
1112 	struct device *dev;
1113 	int status;
1114 
1115 	if (!vsi->agg_node)
1116 		return;
1117 
1118 	dev = ice_pf_to_dev(pf);
1119 	if (vsi->agg_node->num_vsis == ICE_MAX_VSIS_IN_AGG_NODE) {
1120 		dev_dbg(dev,
1121 			"agg_id %u already has reached max_num_vsis %u\n",
1122 			vsi->agg_node->agg_id, vsi->agg_node->num_vsis);
1123 		return;
1124 	}
1125 
1126 	status = ice_move_vsi_to_agg(pf->hw.port_info, vsi->agg_node->agg_id,
1127 				     vsi->idx, vsi->tc_cfg.ena_tc);
1128 	if (status)
1129 		dev_dbg(dev, "unable to move VSI idx %u into aggregator %u node",
1130 			vsi->idx, vsi->agg_node->agg_id);
1131 	else
1132 		vsi->agg_node->num_vsis++;
1133 }
1134 
1135 /**
1136  * ice_vf_rebuild_host_cfg - host admin configuration is persistent across reset
1137  * @vf: VF to rebuild host configuration on
1138  */
1139 void ice_vf_rebuild_host_cfg(struct ice_vf *vf)
1140 {
1141 	struct device *dev = ice_pf_to_dev(vf->pf);
1142 	struct ice_vsi *vsi = ice_get_vf_vsi(vf);
1143 
1144 	if (WARN_ON(!vsi))
1145 		return;
1146 
1147 	ice_vf_set_host_trust_cfg(vf);
1148 
1149 	if (ice_vf_rebuild_host_mac_cfg(vf))
1150 		dev_err(dev, "failed to rebuild default MAC configuration for VF %d\n",
1151 			vf->vf_id);
1152 
1153 	if (ice_vf_rebuild_host_vlan_cfg(vf, vsi))
1154 		dev_err(dev, "failed to rebuild VLAN configuration for VF %u\n",
1155 			vf->vf_id);
1156 
1157 	if (ice_vf_rebuild_host_tx_rate_cfg(vf))
1158 		dev_err(dev, "failed to rebuild Tx rate limiting configuration for VF %u\n",
1159 			vf->vf_id);
1160 
1161 	if (ice_vsi_apply_spoofchk(vsi, vf->spoofchk))
1162 		dev_err(dev, "failed to rebuild spoofchk configuration for VF %d\n",
1163 			vf->vf_id);
1164 
1165 	/* rebuild aggregator node config for main VF VSI */
1166 	ice_vf_rebuild_aggregator_node_cfg(vsi);
1167 }
1168 
1169 /**
1170  * ice_vf_ctrl_invalidate_vsi - invalidate ctrl_vsi_idx to remove VSI access
1171  * @vf: VF that control VSI is being invalidated on
1172  */
1173 void ice_vf_ctrl_invalidate_vsi(struct ice_vf *vf)
1174 {
1175 	vf->ctrl_vsi_idx = ICE_NO_VSI;
1176 }
1177 
1178 /**
1179  * ice_vf_ctrl_vsi_release - invalidate the VF's control VSI after freeing it
1180  * @vf: VF that control VSI is being released on
1181  */
1182 void ice_vf_ctrl_vsi_release(struct ice_vf *vf)
1183 {
1184 	ice_vsi_release(vf->pf->vsi[vf->ctrl_vsi_idx]);
1185 	ice_vf_ctrl_invalidate_vsi(vf);
1186 }
1187 
1188 /**
1189  * ice_vf_ctrl_vsi_setup - Set up a VF control VSI
1190  * @vf: VF to setup control VSI for
1191  *
1192  * Returns pointer to the successfully allocated VSI struct on success,
1193  * otherwise returns NULL on failure.
1194  */
1195 struct ice_vsi *ice_vf_ctrl_vsi_setup(struct ice_vf *vf)
1196 {
1197 	struct ice_vsi_cfg_params params = {};
1198 	struct ice_pf *pf = vf->pf;
1199 	struct ice_vsi *vsi;
1200 
1201 	params.type = ICE_VSI_CTRL;
1202 	params.pi = ice_vf_get_port_info(vf);
1203 	params.vf = vf;
1204 	params.flags = ICE_VSI_FLAG_INIT;
1205 
1206 	vsi = ice_vsi_setup(pf, &params);
1207 	if (!vsi) {
1208 		dev_err(ice_pf_to_dev(pf), "Failed to create VF control VSI\n");
1209 		ice_vf_ctrl_invalidate_vsi(vf);
1210 	}
1211 
1212 	return vsi;
1213 }
1214 
1215 /**
1216  * ice_vf_init_host_cfg - Initialize host admin configuration
1217  * @vf: VF to initialize
1218  * @vsi: the VSI created at initialization
1219  *
1220  * Initialize the VF host configuration. Called during VF creation to setup
1221  * VLAN 0, add the VF VSI broadcast filter, and setup spoof checking. It
1222  * should only be called during VF creation.
1223  */
1224 int ice_vf_init_host_cfg(struct ice_vf *vf, struct ice_vsi *vsi)
1225 {
1226 	struct ice_vsi_vlan_ops *vlan_ops;
1227 	struct ice_pf *pf = vf->pf;
1228 	u8 broadcast[ETH_ALEN];
1229 	struct device *dev;
1230 	int err;
1231 
1232 	dev = ice_pf_to_dev(pf);
1233 
1234 	err = ice_vsi_add_vlan_zero(vsi);
1235 	if (err) {
1236 		dev_warn(dev, "Failed to add VLAN 0 filter for VF %d\n",
1237 			 vf->vf_id);
1238 		return err;
1239 	}
1240 
1241 	vlan_ops = ice_get_compat_vsi_vlan_ops(vsi);
1242 	err = vlan_ops->ena_rx_filtering(vsi);
1243 	if (err) {
1244 		dev_warn(dev, "Failed to enable Rx VLAN filtering for VF %d\n",
1245 			 vf->vf_id);
1246 		return err;
1247 	}
1248 
1249 	eth_broadcast_addr(broadcast);
1250 	err = ice_fltr_add_mac(vsi, broadcast, ICE_FWD_TO_VSI);
1251 	if (err) {
1252 		dev_err(dev, "Failed to add broadcast MAC filter for VF %d, status %d\n",
1253 			vf->vf_id, err);
1254 		return err;
1255 	}
1256 
1257 	vf->num_mac = 1;
1258 
1259 	err = ice_vsi_apply_spoofchk(vsi, vf->spoofchk);
1260 	if (err) {
1261 		dev_warn(dev, "Failed to initialize spoofchk setting for VF %d\n",
1262 			 vf->vf_id);
1263 		return err;
1264 	}
1265 
1266 	return 0;
1267 }
1268 
1269 /**
1270  * ice_vf_invalidate_vsi - invalidate vsi_idx/vsi_num to remove VSI access
1271  * @vf: VF to remove access to VSI for
1272  */
1273 void ice_vf_invalidate_vsi(struct ice_vf *vf)
1274 {
1275 	vf->lan_vsi_idx = ICE_NO_VSI;
1276 	vf->lan_vsi_num = ICE_NO_VSI;
1277 }
1278 
1279 /**
1280  * ice_vf_vsi_release - Release the VF VSI and invalidate indexes
1281  * @vf: pointer to the VF structure
1282  *
1283  * Release the VF associated with this VSI and then invalidate the VSI
1284  * indexes.
1285  */
1286 void ice_vf_vsi_release(struct ice_vf *vf)
1287 {
1288 	struct ice_vsi *vsi = ice_get_vf_vsi(vf);
1289 
1290 	if (WARN_ON(!vsi))
1291 		return;
1292 
1293 	ice_vsi_release(vsi);
1294 	ice_vf_invalidate_vsi(vf);
1295 }
1296 
1297 /**
1298  * ice_vf_set_initialized - VF is ready for VIRTCHNL communication
1299  * @vf: VF to set in initialized state
1300  *
1301  * After this function the VF will be ready to receive/handle the
1302  * VIRTCHNL_OP_GET_VF_RESOURCES message
1303  */
1304 void ice_vf_set_initialized(struct ice_vf *vf)
1305 {
1306 	ice_set_vf_state_qs_dis(vf);
1307 	clear_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states);
1308 	clear_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states);
1309 	clear_bit(ICE_VF_STATE_DIS, vf->vf_states);
1310 	set_bit(ICE_VF_STATE_INIT, vf->vf_states);
1311 	memset(&vf->vlan_v2_caps, 0, sizeof(vf->vlan_v2_caps));
1312 }
1313