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

source code of linux/drivers/net/ethernet/intel/ice/ice_vf_lib.c