1109aba47SJacob Keller // SPDX-License-Identifier: GPL-2.0 2109aba47SJacob Keller /* Copyright (C) 2022, Intel Corporation. */ 3109aba47SJacob Keller 4109aba47SJacob Keller #include "ice_vf_lib_private.h" 5109aba47SJacob Keller #include "ice.h" 6109aba47SJacob Keller #include "ice_lib.h" 7109aba47SJacob Keller #include "ice_fltr.h" 8109aba47SJacob Keller #include "ice_virtchnl_allowlist.h" 9109aba47SJacob Keller 10109aba47SJacob Keller /* Public functions which may be accessed by all driver files */ 11109aba47SJacob Keller 12109aba47SJacob Keller /** 13109aba47SJacob Keller * ice_get_vf_by_id - Get pointer to VF by ID 14109aba47SJacob Keller * @pf: the PF private structure 15109aba47SJacob Keller * @vf_id: the VF ID to locate 16109aba47SJacob Keller * 17109aba47SJacob Keller * Locate and return a pointer to the VF structure associated with a given ID. 18109aba47SJacob Keller * Returns NULL if the ID does not have a valid VF structure associated with 19109aba47SJacob Keller * it. 20109aba47SJacob Keller * 21109aba47SJacob Keller * This function takes a reference to the VF, which must be released by 22109aba47SJacob Keller * calling ice_put_vf() once the caller is finished accessing the VF structure 23109aba47SJacob Keller * returned. 24109aba47SJacob Keller */ 25109aba47SJacob Keller struct ice_vf *ice_get_vf_by_id(struct ice_pf *pf, u16 vf_id) 26109aba47SJacob Keller { 27109aba47SJacob Keller struct ice_vf *vf; 28109aba47SJacob Keller 29109aba47SJacob Keller rcu_read_lock(); 30109aba47SJacob Keller hash_for_each_possible_rcu(pf->vfs.table, vf, entry, vf_id) { 31109aba47SJacob Keller if (vf->vf_id == vf_id) { 32109aba47SJacob Keller struct ice_vf *found; 33109aba47SJacob Keller 34109aba47SJacob Keller if (kref_get_unless_zero(&vf->refcnt)) 35109aba47SJacob Keller found = vf; 36109aba47SJacob Keller else 37109aba47SJacob Keller found = NULL; 38109aba47SJacob Keller 39109aba47SJacob Keller rcu_read_unlock(); 40109aba47SJacob Keller return found; 41109aba47SJacob Keller } 42109aba47SJacob Keller } 43109aba47SJacob Keller rcu_read_unlock(); 44109aba47SJacob Keller 45109aba47SJacob Keller return NULL; 46109aba47SJacob Keller } 47109aba47SJacob Keller 48109aba47SJacob Keller /** 49109aba47SJacob Keller * ice_release_vf - Release VF associated with a refcount 50109aba47SJacob Keller * @ref: the kref decremented to zero 51109aba47SJacob Keller * 52109aba47SJacob Keller * Callback function for kref_put to release a VF once its reference count has 53109aba47SJacob Keller * hit zero. 54109aba47SJacob Keller */ 55109aba47SJacob Keller static void ice_release_vf(struct kref *ref) 56109aba47SJacob Keller { 57109aba47SJacob Keller struct ice_vf *vf = container_of(ref, struct ice_vf, refcnt); 58109aba47SJacob Keller 599c6f7878SJacob Keller vf->vf_ops->free(vf); 60109aba47SJacob Keller } 61109aba47SJacob Keller 62109aba47SJacob Keller /** 63109aba47SJacob Keller * ice_put_vf - Release a reference to a VF 64109aba47SJacob Keller * @vf: the VF structure to decrease reference count on 65109aba47SJacob Keller * 66109aba47SJacob Keller * Decrease the reference count for a VF, and free the entry if it is no 67109aba47SJacob Keller * longer in use. 68109aba47SJacob Keller * 69109aba47SJacob Keller * This must be called after ice_get_vf_by_id() once the reference to the VF 70109aba47SJacob Keller * structure is no longer used. Otherwise, the VF structure will never be 71109aba47SJacob Keller * freed. 72109aba47SJacob Keller */ 73109aba47SJacob Keller void ice_put_vf(struct ice_vf *vf) 74109aba47SJacob Keller { 75109aba47SJacob Keller kref_put(&vf->refcnt, ice_release_vf); 76109aba47SJacob Keller } 77109aba47SJacob Keller 78109aba47SJacob Keller /** 79109aba47SJacob Keller * ice_has_vfs - Return true if the PF has any associated VFs 80109aba47SJacob Keller * @pf: the PF private structure 81109aba47SJacob Keller * 82109aba47SJacob Keller * Return whether or not the PF has any allocated VFs. 83109aba47SJacob Keller * 84109aba47SJacob Keller * Note that this function only guarantees that there are no VFs at the point 85109aba47SJacob Keller * of calling it. It does not guarantee that no more VFs will be added. 86109aba47SJacob Keller */ 87109aba47SJacob Keller bool ice_has_vfs(struct ice_pf *pf) 88109aba47SJacob Keller { 89109aba47SJacob Keller /* A simple check that the hash table is not empty does not require 90109aba47SJacob Keller * the mutex or rcu_read_lock. 91109aba47SJacob Keller */ 92109aba47SJacob Keller return !hash_empty(pf->vfs.table); 93109aba47SJacob Keller } 94109aba47SJacob Keller 95109aba47SJacob Keller /** 96109aba47SJacob Keller * ice_get_num_vfs - Get number of allocated VFs 97109aba47SJacob Keller * @pf: the PF private structure 98109aba47SJacob Keller * 99109aba47SJacob Keller * Return the total number of allocated VFs. NOTE: VF IDs are not guaranteed 100109aba47SJacob Keller * to be contiguous. Do not assume that a VF ID is guaranteed to be less than 101109aba47SJacob Keller * the output of this function. 102109aba47SJacob Keller */ 103109aba47SJacob Keller u16 ice_get_num_vfs(struct ice_pf *pf) 104109aba47SJacob Keller { 105109aba47SJacob Keller struct ice_vf *vf; 106109aba47SJacob Keller unsigned int bkt; 107109aba47SJacob Keller u16 num_vfs = 0; 108109aba47SJacob Keller 109109aba47SJacob Keller rcu_read_lock(); 110109aba47SJacob Keller ice_for_each_vf_rcu(pf, bkt, vf) 111109aba47SJacob Keller num_vfs++; 112109aba47SJacob Keller rcu_read_unlock(); 113109aba47SJacob Keller 114109aba47SJacob Keller return num_vfs; 115109aba47SJacob Keller } 116109aba47SJacob Keller 117109aba47SJacob Keller /** 118109aba47SJacob Keller * ice_get_vf_vsi - get VF's VSI based on the stored index 119109aba47SJacob Keller * @vf: VF used to get VSI 120109aba47SJacob Keller */ 121109aba47SJacob Keller struct ice_vsi *ice_get_vf_vsi(struct ice_vf *vf) 122109aba47SJacob Keller { 123109aba47SJacob Keller if (vf->lan_vsi_idx == ICE_NO_VSI) 124109aba47SJacob Keller return NULL; 125109aba47SJacob Keller 126109aba47SJacob Keller return vf->pf->vsi[vf->lan_vsi_idx]; 127109aba47SJacob Keller } 128109aba47SJacob Keller 129109aba47SJacob Keller /** 130109aba47SJacob Keller * ice_is_vf_disabled 131109aba47SJacob Keller * @vf: pointer to the VF info 132109aba47SJacob Keller * 133109aba47SJacob Keller * If the PF has been disabled, there is no need resetting VF until PF is 134109aba47SJacob Keller * active again. Similarly, if the VF has been disabled, this means something 135109aba47SJacob Keller * else is resetting the VF, so we shouldn't continue. 136109aba47SJacob Keller * 137109aba47SJacob Keller * Returns true if the caller should consider the VF as disabled whether 138109aba47SJacob Keller * because that single VF is explicitly disabled or because the PF is 139109aba47SJacob Keller * currently disabled. 140109aba47SJacob Keller */ 141109aba47SJacob Keller bool ice_is_vf_disabled(struct ice_vf *vf) 142109aba47SJacob Keller { 143109aba47SJacob Keller struct ice_pf *pf = vf->pf; 144109aba47SJacob Keller 145109aba47SJacob Keller return (test_bit(ICE_VF_DIS, pf->state) || 146109aba47SJacob Keller test_bit(ICE_VF_STATE_DIS, vf->vf_states)); 147109aba47SJacob Keller } 148109aba47SJacob Keller 149109aba47SJacob Keller /** 150109aba47SJacob Keller * ice_wait_on_vf_reset - poll to make sure a given VF is ready after reset 151109aba47SJacob Keller * @vf: The VF being resseting 152109aba47SJacob Keller * 153109aba47SJacob Keller * The max poll time is about ~800ms, which is about the maximum time it takes 154109aba47SJacob Keller * for a VF to be reset and/or a VF driver to be removed. 155109aba47SJacob Keller */ 156109aba47SJacob Keller static void ice_wait_on_vf_reset(struct ice_vf *vf) 157109aba47SJacob Keller { 158109aba47SJacob Keller int i; 159109aba47SJacob Keller 160109aba47SJacob Keller for (i = 0; i < ICE_MAX_VF_RESET_TRIES; i++) { 161109aba47SJacob Keller if (test_bit(ICE_VF_STATE_INIT, vf->vf_states)) 162109aba47SJacob Keller break; 163109aba47SJacob Keller msleep(ICE_MAX_VF_RESET_SLEEP_MS); 164109aba47SJacob Keller } 165109aba47SJacob Keller } 166109aba47SJacob Keller 167109aba47SJacob Keller /** 168109aba47SJacob Keller * ice_check_vf_ready_for_cfg - check if VF is ready to be configured/queried 169109aba47SJacob Keller * @vf: VF to check if it's ready to be configured/queried 170109aba47SJacob Keller * 171109aba47SJacob Keller * The purpose of this function is to make sure the VF is not in reset, not 172109aba47SJacob Keller * disabled, and initialized so it can be configured and/or queried by a host 173109aba47SJacob Keller * administrator. 174109aba47SJacob Keller */ 175109aba47SJacob Keller int ice_check_vf_ready_for_cfg(struct ice_vf *vf) 176109aba47SJacob Keller { 177109aba47SJacob Keller ice_wait_on_vf_reset(vf); 178109aba47SJacob Keller 179109aba47SJacob Keller if (ice_is_vf_disabled(vf)) 180109aba47SJacob Keller return -EINVAL; 181109aba47SJacob Keller 1825a57ee83SJacob Keller if (ice_check_vf_init(vf)) 183109aba47SJacob Keller return -EBUSY; 184109aba47SJacob Keller 185109aba47SJacob Keller return 0; 186109aba47SJacob Keller } 187109aba47SJacob Keller 188109aba47SJacob Keller /** 1897255355aSDawid Wesierski * ice_check_vf_ready_for_reset - check if VF is ready to be reset 1907255355aSDawid Wesierski * @vf: VF to check if it's ready to be reset 1917255355aSDawid Wesierski * 1927255355aSDawid Wesierski * The purpose of this function is to ensure that the VF is not in reset, 1937255355aSDawid Wesierski * disabled, and is both initialized and active, thus enabling us to safely 1947255355aSDawid Wesierski * initialize another reset. 1957255355aSDawid Wesierski */ 1967255355aSDawid Wesierski int ice_check_vf_ready_for_reset(struct ice_vf *vf) 1977255355aSDawid Wesierski { 1987255355aSDawid Wesierski int ret; 1997255355aSDawid Wesierski 2007255355aSDawid Wesierski ret = ice_check_vf_ready_for_cfg(vf); 2017255355aSDawid Wesierski if (!ret && !test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) 2027255355aSDawid Wesierski ret = -EAGAIN; 2037255355aSDawid Wesierski 2047255355aSDawid Wesierski return ret; 2057255355aSDawid Wesierski } 2067255355aSDawid Wesierski 2077255355aSDawid Wesierski /** 20816686d7fSJacob Keller * ice_trigger_vf_reset - Reset a VF on HW 20916686d7fSJacob Keller * @vf: pointer to the VF structure 21016686d7fSJacob Keller * @is_vflr: true if VFLR was issued, false if not 21116686d7fSJacob Keller * @is_pfr: true if the reset was triggered due to a previous PFR 21216686d7fSJacob Keller * 21316686d7fSJacob Keller * Trigger hardware to start a reset for a particular VF. Expects the caller 21416686d7fSJacob Keller * to wait the proper amount of time to allow hardware to reset the VF before 21516686d7fSJacob Keller * it cleans up and restores VF functionality. 21616686d7fSJacob Keller */ 21716686d7fSJacob Keller static void ice_trigger_vf_reset(struct ice_vf *vf, bool is_vflr, bool is_pfr) 21816686d7fSJacob Keller { 21916686d7fSJacob Keller /* Inform VF that it is no longer active, as a warning */ 22016686d7fSJacob Keller clear_bit(ICE_VF_STATE_ACTIVE, vf->vf_states); 22116686d7fSJacob Keller 22216686d7fSJacob Keller /* Disable VF's configuration API during reset. The flag is re-enabled 22316686d7fSJacob Keller * when it's safe again to access VF's VSI. 22416686d7fSJacob Keller */ 22516686d7fSJacob Keller clear_bit(ICE_VF_STATE_INIT, vf->vf_states); 22616686d7fSJacob Keller 22716686d7fSJacob Keller /* VF_MBX_ARQLEN and VF_MBX_ATQLEN are cleared by PFR, so the driver 22816686d7fSJacob Keller * needs to clear them in the case of VFR/VFLR. If this is done for 22916686d7fSJacob Keller * PFR, it can mess up VF resets because the VF driver may already 23016686d7fSJacob Keller * have started cleanup by the time we get here. 23116686d7fSJacob Keller */ 23216686d7fSJacob Keller if (!is_pfr) 23316686d7fSJacob Keller vf->vf_ops->clear_mbx_register(vf); 23416686d7fSJacob Keller 23516686d7fSJacob Keller vf->vf_ops->trigger_reset_register(vf, is_vflr); 23616686d7fSJacob Keller } 23716686d7fSJacob Keller 23816686d7fSJacob Keller static void ice_vf_clear_counters(struct ice_vf *vf) 23916686d7fSJacob Keller { 24016686d7fSJacob Keller struct ice_vsi *vsi = ice_get_vf_vsi(vf); 24116686d7fSJacob Keller 242baeb705fSJacob Keller if (vsi) 24316686d7fSJacob Keller vsi->num_vlan = 0; 244baeb705fSJacob Keller 245baeb705fSJacob Keller vf->num_mac = 0; 24616686d7fSJacob Keller memset(&vf->mdd_tx_events, 0, sizeof(vf->mdd_tx_events)); 24716686d7fSJacob Keller memset(&vf->mdd_rx_events, 0, sizeof(vf->mdd_rx_events)); 24816686d7fSJacob Keller } 24916686d7fSJacob Keller 25016686d7fSJacob Keller /** 25116686d7fSJacob Keller * ice_vf_pre_vsi_rebuild - tasks to be done prior to VSI rebuild 25216686d7fSJacob Keller * @vf: VF to perform pre VSI rebuild tasks 25316686d7fSJacob Keller * 25416686d7fSJacob Keller * These tasks are items that don't need to be amortized since they are most 25516686d7fSJacob Keller * likely called in a for loop with all VF(s) in the reset_all_vfs() case. 25616686d7fSJacob Keller */ 25716686d7fSJacob Keller static void ice_vf_pre_vsi_rebuild(struct ice_vf *vf) 25816686d7fSJacob Keller { 259537dfe06SJacob Keller /* Close any IRQ mapping now */ 260537dfe06SJacob Keller if (vf->vf_ops->irq_close) 261537dfe06SJacob Keller vf->vf_ops->irq_close(vf); 262537dfe06SJacob Keller 26316686d7fSJacob Keller ice_vf_clear_counters(vf); 26416686d7fSJacob Keller vf->vf_ops->clear_reset_trigger(vf); 26516686d7fSJacob Keller } 26616686d7fSJacob Keller 26716686d7fSJacob Keller /** 2685531bb85SJacob Keller * ice_vf_recreate_vsi - Release and re-create the VF's VSI 2695531bb85SJacob Keller * @vf: VF to recreate the VSI for 2705531bb85SJacob Keller * 2715531bb85SJacob Keller * This is only called when a single VF is being reset (i.e. VVF, VFLR, host 2725531bb85SJacob Keller * VF configuration change, etc) 2735531bb85SJacob Keller * 2745531bb85SJacob Keller * It releases and then re-creates a new VSI. 2755531bb85SJacob Keller */ 2765531bb85SJacob Keller static int ice_vf_recreate_vsi(struct ice_vf *vf) 2775531bb85SJacob Keller { 2785531bb85SJacob Keller struct ice_pf *pf = vf->pf; 2795531bb85SJacob Keller int err; 2805531bb85SJacob Keller 2815531bb85SJacob Keller ice_vf_vsi_release(vf); 2825531bb85SJacob Keller 2835531bb85SJacob Keller err = vf->vf_ops->create_vsi(vf); 2845531bb85SJacob Keller if (err) { 2855531bb85SJacob Keller dev_err(ice_pf_to_dev(pf), 2865531bb85SJacob Keller "Failed to recreate the VF%u's VSI, error %d\n", 2875531bb85SJacob Keller vf->vf_id, err); 2885531bb85SJacob Keller return err; 2895531bb85SJacob Keller } 2905531bb85SJacob Keller 2915531bb85SJacob Keller return 0; 2925531bb85SJacob Keller } 2935531bb85SJacob Keller 2945531bb85SJacob Keller /** 29516686d7fSJacob Keller * ice_vf_rebuild_vsi - rebuild the VF's VSI 29616686d7fSJacob Keller * @vf: VF to rebuild the VSI for 29716686d7fSJacob Keller * 29816686d7fSJacob Keller * This is only called when all VF(s) are being reset (i.e. PCIe Reset on the 29916686d7fSJacob Keller * host, PFR, CORER, etc.). 3005531bb85SJacob Keller * 3015531bb85SJacob Keller * It reprograms the VSI configuration back into hardware. 30216686d7fSJacob Keller */ 30316686d7fSJacob Keller static int ice_vf_rebuild_vsi(struct ice_vf *vf) 30416686d7fSJacob Keller { 30516686d7fSJacob Keller struct ice_vsi *vsi = ice_get_vf_vsi(vf); 30616686d7fSJacob Keller struct ice_pf *pf = vf->pf; 30716686d7fSJacob Keller 308baeb705fSJacob Keller if (WARN_ON(!vsi)) 309baeb705fSJacob Keller return -EINVAL; 310baeb705fSJacob Keller 3116624e780SMichal Swiatkowski if (ice_vsi_rebuild(vsi, ICE_VSI_FLAG_INIT)) { 31216686d7fSJacob Keller dev_err(ice_pf_to_dev(pf), "failed to rebuild VF %d VSI\n", 31316686d7fSJacob Keller vf->vf_id); 31416686d7fSJacob Keller return -EIO; 31516686d7fSJacob Keller } 31616686d7fSJacob Keller /* vsi->idx will remain the same in this case so don't update 31716686d7fSJacob Keller * vf->lan_vsi_idx 31816686d7fSJacob Keller */ 31916686d7fSJacob Keller vsi->vsi_num = ice_get_hw_vsi_num(&pf->hw, vsi->idx); 32016686d7fSJacob Keller vf->lan_vsi_num = vsi->vsi_num; 32116686d7fSJacob Keller 32216686d7fSJacob Keller return 0; 32316686d7fSJacob Keller } 32416686d7fSJacob Keller 32516686d7fSJacob Keller /** 326*cc9c60c9SJan Sokolowski * ice_vf_rebuild_host_vlan_cfg - add VLAN 0 filter or rebuild the Port VLAN 327*cc9c60c9SJan Sokolowski * @vf: VF to add MAC filters for 328*cc9c60c9SJan Sokolowski * @vsi: Pointer to VSI 329*cc9c60c9SJan Sokolowski * 330*cc9c60c9SJan Sokolowski * Called after a VF VSI has been re-added/rebuilt during reset. The PF driver 331*cc9c60c9SJan Sokolowski * always re-adds either a VLAN 0 or port VLAN based filter after reset. 332*cc9c60c9SJan Sokolowski */ 333*cc9c60c9SJan Sokolowski static int ice_vf_rebuild_host_vlan_cfg(struct ice_vf *vf, struct ice_vsi *vsi) 334*cc9c60c9SJan Sokolowski { 335*cc9c60c9SJan Sokolowski struct ice_vsi_vlan_ops *vlan_ops = ice_get_compat_vsi_vlan_ops(vsi); 336*cc9c60c9SJan Sokolowski struct device *dev = ice_pf_to_dev(vf->pf); 337*cc9c60c9SJan Sokolowski int err; 338*cc9c60c9SJan Sokolowski 339*cc9c60c9SJan Sokolowski if (ice_vf_is_port_vlan_ena(vf)) { 340*cc9c60c9SJan Sokolowski err = vlan_ops->set_port_vlan(vsi, &vf->port_vlan_info); 341*cc9c60c9SJan Sokolowski if (err) { 342*cc9c60c9SJan Sokolowski dev_err(dev, "failed to configure port VLAN via VSI parameters for VF %u, error %d\n", 343*cc9c60c9SJan Sokolowski vf->vf_id, err); 344*cc9c60c9SJan Sokolowski return err; 345*cc9c60c9SJan Sokolowski } 346*cc9c60c9SJan Sokolowski 347*cc9c60c9SJan Sokolowski err = vlan_ops->add_vlan(vsi, &vf->port_vlan_info); 348*cc9c60c9SJan Sokolowski } else { 349*cc9c60c9SJan Sokolowski err = ice_vsi_add_vlan_zero(vsi); 350*cc9c60c9SJan Sokolowski } 351*cc9c60c9SJan Sokolowski 352*cc9c60c9SJan Sokolowski if (err) { 353*cc9c60c9SJan Sokolowski dev_err(dev, "failed to add VLAN %u filter for VF %u during VF rebuild, error %d\n", 354*cc9c60c9SJan Sokolowski ice_vf_is_port_vlan_ena(vf) ? 355*cc9c60c9SJan Sokolowski ice_vf_get_port_vlan_id(vf) : 0, vf->vf_id, err); 356*cc9c60c9SJan Sokolowski return err; 357*cc9c60c9SJan Sokolowski } 358*cc9c60c9SJan Sokolowski 359*cc9c60c9SJan Sokolowski err = vlan_ops->ena_rx_filtering(vsi); 360*cc9c60c9SJan Sokolowski if (err) 361*cc9c60c9SJan Sokolowski dev_warn(dev, "failed to enable Rx VLAN filtering for VF %d VSI %d during VF rebuild, error %d\n", 362*cc9c60c9SJan Sokolowski vf->vf_id, vsi->idx, err); 363*cc9c60c9SJan Sokolowski 364*cc9c60c9SJan Sokolowski return 0; 365*cc9c60c9SJan Sokolowski } 366*cc9c60c9SJan Sokolowski 367*cc9c60c9SJan Sokolowski /** 368*cc9c60c9SJan Sokolowski * ice_vf_rebuild_host_tx_rate_cfg - re-apply the Tx rate limiting configuration 369*cc9c60c9SJan Sokolowski * @vf: VF to re-apply the configuration for 370*cc9c60c9SJan Sokolowski * 371*cc9c60c9SJan Sokolowski * Called after a VF VSI has been re-added/rebuild during reset. The PF driver 372*cc9c60c9SJan Sokolowski * needs to re-apply the host configured Tx rate limiting configuration. 373*cc9c60c9SJan Sokolowski */ 374*cc9c60c9SJan Sokolowski static int ice_vf_rebuild_host_tx_rate_cfg(struct ice_vf *vf) 375*cc9c60c9SJan Sokolowski { 376*cc9c60c9SJan Sokolowski struct device *dev = ice_pf_to_dev(vf->pf); 377*cc9c60c9SJan Sokolowski struct ice_vsi *vsi = ice_get_vf_vsi(vf); 378*cc9c60c9SJan Sokolowski int err; 379*cc9c60c9SJan Sokolowski 380*cc9c60c9SJan Sokolowski if (WARN_ON(!vsi)) 381*cc9c60c9SJan Sokolowski return -EINVAL; 382*cc9c60c9SJan Sokolowski 383*cc9c60c9SJan Sokolowski if (vf->min_tx_rate) { 384*cc9c60c9SJan Sokolowski err = ice_set_min_bw_limit(vsi, (u64)vf->min_tx_rate * 1000); 385*cc9c60c9SJan Sokolowski if (err) { 386*cc9c60c9SJan Sokolowski dev_err(dev, "failed to set min Tx rate to %d Mbps for VF %u, error %d\n", 387*cc9c60c9SJan Sokolowski vf->min_tx_rate, vf->vf_id, err); 388*cc9c60c9SJan Sokolowski return err; 389*cc9c60c9SJan Sokolowski } 390*cc9c60c9SJan Sokolowski } 391*cc9c60c9SJan Sokolowski 392*cc9c60c9SJan Sokolowski if (vf->max_tx_rate) { 393*cc9c60c9SJan Sokolowski err = ice_set_max_bw_limit(vsi, (u64)vf->max_tx_rate * 1000); 394*cc9c60c9SJan Sokolowski if (err) { 395*cc9c60c9SJan Sokolowski dev_err(dev, "failed to set max Tx rate to %d Mbps for VF %u, error %d\n", 396*cc9c60c9SJan Sokolowski vf->max_tx_rate, vf->vf_id, err); 397*cc9c60c9SJan Sokolowski return err; 398*cc9c60c9SJan Sokolowski } 399*cc9c60c9SJan Sokolowski } 400*cc9c60c9SJan Sokolowski 401*cc9c60c9SJan Sokolowski return 0; 402*cc9c60c9SJan Sokolowski } 403*cc9c60c9SJan Sokolowski 404*cc9c60c9SJan Sokolowski /** 405*cc9c60c9SJan Sokolowski * ice_vf_set_host_trust_cfg - set trust setting based on pre-reset value 406*cc9c60c9SJan Sokolowski * @vf: VF to configure trust setting for 407*cc9c60c9SJan Sokolowski */ 408*cc9c60c9SJan Sokolowski static void ice_vf_set_host_trust_cfg(struct ice_vf *vf) 409*cc9c60c9SJan Sokolowski { 410*cc9c60c9SJan Sokolowski if (vf->trusted) 411*cc9c60c9SJan Sokolowski set_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps); 412*cc9c60c9SJan Sokolowski else 413*cc9c60c9SJan Sokolowski clear_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps); 414*cc9c60c9SJan Sokolowski } 415*cc9c60c9SJan Sokolowski 416*cc9c60c9SJan Sokolowski /** 417*cc9c60c9SJan Sokolowski * ice_vf_rebuild_host_mac_cfg - add broadcast and the VF's perm_addr/LAA 418*cc9c60c9SJan Sokolowski * @vf: VF to add MAC filters for 419*cc9c60c9SJan Sokolowski * 420*cc9c60c9SJan Sokolowski * Called after a VF VSI has been re-added/rebuilt during reset. The PF driver 421*cc9c60c9SJan Sokolowski * always re-adds a broadcast filter and the VF's perm_addr/LAA after reset. 422*cc9c60c9SJan Sokolowski */ 423*cc9c60c9SJan Sokolowski static int ice_vf_rebuild_host_mac_cfg(struct ice_vf *vf) 424*cc9c60c9SJan Sokolowski { 425*cc9c60c9SJan Sokolowski struct device *dev = ice_pf_to_dev(vf->pf); 426*cc9c60c9SJan Sokolowski struct ice_vsi *vsi = ice_get_vf_vsi(vf); 427*cc9c60c9SJan Sokolowski u8 broadcast[ETH_ALEN]; 428*cc9c60c9SJan Sokolowski int status; 429*cc9c60c9SJan Sokolowski 430*cc9c60c9SJan Sokolowski if (WARN_ON(!vsi)) 431*cc9c60c9SJan Sokolowski return -EINVAL; 432*cc9c60c9SJan Sokolowski 433*cc9c60c9SJan Sokolowski if (ice_is_eswitch_mode_switchdev(vf->pf)) 434*cc9c60c9SJan Sokolowski return 0; 435*cc9c60c9SJan Sokolowski 436*cc9c60c9SJan Sokolowski eth_broadcast_addr(broadcast); 437*cc9c60c9SJan Sokolowski status = ice_fltr_add_mac(vsi, broadcast, ICE_FWD_TO_VSI); 438*cc9c60c9SJan Sokolowski if (status) { 439*cc9c60c9SJan Sokolowski dev_err(dev, "failed to add broadcast MAC filter for VF %u, error %d\n", 440*cc9c60c9SJan Sokolowski vf->vf_id, status); 441*cc9c60c9SJan Sokolowski return status; 442*cc9c60c9SJan Sokolowski } 443*cc9c60c9SJan Sokolowski 444*cc9c60c9SJan Sokolowski vf->num_mac++; 445*cc9c60c9SJan Sokolowski 446*cc9c60c9SJan Sokolowski if (is_valid_ether_addr(vf->hw_lan_addr)) { 447*cc9c60c9SJan Sokolowski status = ice_fltr_add_mac(vsi, vf->hw_lan_addr, 448*cc9c60c9SJan Sokolowski ICE_FWD_TO_VSI); 449*cc9c60c9SJan Sokolowski if (status) { 450*cc9c60c9SJan Sokolowski dev_err(dev, "failed to add default unicast MAC filter %pM for VF %u, error %d\n", 451*cc9c60c9SJan Sokolowski &vf->hw_lan_addr[0], vf->vf_id, 452*cc9c60c9SJan Sokolowski status); 453*cc9c60c9SJan Sokolowski return status; 454*cc9c60c9SJan Sokolowski } 455*cc9c60c9SJan Sokolowski vf->num_mac++; 456*cc9c60c9SJan Sokolowski 457*cc9c60c9SJan Sokolowski ether_addr_copy(vf->dev_lan_addr, vf->hw_lan_addr); 458*cc9c60c9SJan Sokolowski } 459*cc9c60c9SJan Sokolowski 460*cc9c60c9SJan Sokolowski return 0; 461*cc9c60c9SJan Sokolowski } 462*cc9c60c9SJan Sokolowski 463*cc9c60c9SJan Sokolowski /** 464*cc9c60c9SJan Sokolowski * ice_vf_rebuild_aggregator_node_cfg - rebuild aggregator node config 465*cc9c60c9SJan Sokolowski * @vsi: Pointer to VSI 466*cc9c60c9SJan Sokolowski * 467*cc9c60c9SJan Sokolowski * This function moves VSI into corresponding scheduler aggregator node 468*cc9c60c9SJan Sokolowski * based on cached value of "aggregator node info" per VSI 469*cc9c60c9SJan Sokolowski */ 470*cc9c60c9SJan Sokolowski static void ice_vf_rebuild_aggregator_node_cfg(struct ice_vsi *vsi) 471*cc9c60c9SJan Sokolowski { 472*cc9c60c9SJan Sokolowski struct ice_pf *pf = vsi->back; 473*cc9c60c9SJan Sokolowski struct device *dev; 474*cc9c60c9SJan Sokolowski int status; 475*cc9c60c9SJan Sokolowski 476*cc9c60c9SJan Sokolowski if (!vsi->agg_node) 477*cc9c60c9SJan Sokolowski return; 478*cc9c60c9SJan Sokolowski 479*cc9c60c9SJan Sokolowski dev = ice_pf_to_dev(pf); 480*cc9c60c9SJan Sokolowski if (vsi->agg_node->num_vsis == ICE_MAX_VSIS_IN_AGG_NODE) { 481*cc9c60c9SJan Sokolowski dev_dbg(dev, 482*cc9c60c9SJan Sokolowski "agg_id %u already has reached max_num_vsis %u\n", 483*cc9c60c9SJan Sokolowski vsi->agg_node->agg_id, vsi->agg_node->num_vsis); 484*cc9c60c9SJan Sokolowski return; 485*cc9c60c9SJan Sokolowski } 486*cc9c60c9SJan Sokolowski 487*cc9c60c9SJan Sokolowski status = ice_move_vsi_to_agg(pf->hw.port_info, vsi->agg_node->agg_id, 488*cc9c60c9SJan Sokolowski vsi->idx, vsi->tc_cfg.ena_tc); 489*cc9c60c9SJan Sokolowski if (status) 490*cc9c60c9SJan Sokolowski dev_dbg(dev, "unable to move VSI idx %u into aggregator %u node", 491*cc9c60c9SJan Sokolowski vsi->idx, vsi->agg_node->agg_id); 492*cc9c60c9SJan Sokolowski else 493*cc9c60c9SJan Sokolowski vsi->agg_node->num_vsis++; 494*cc9c60c9SJan Sokolowski } 495*cc9c60c9SJan Sokolowski 496*cc9c60c9SJan Sokolowski /** 497*cc9c60c9SJan Sokolowski * ice_vf_rebuild_host_cfg - host admin configuration is persistent across reset 498*cc9c60c9SJan Sokolowski * @vf: VF to rebuild host configuration on 499*cc9c60c9SJan Sokolowski */ 500*cc9c60c9SJan Sokolowski static void ice_vf_rebuild_host_cfg(struct ice_vf *vf) 501*cc9c60c9SJan Sokolowski { 502*cc9c60c9SJan Sokolowski struct device *dev = ice_pf_to_dev(vf->pf); 503*cc9c60c9SJan Sokolowski struct ice_vsi *vsi = ice_get_vf_vsi(vf); 504*cc9c60c9SJan Sokolowski 505*cc9c60c9SJan Sokolowski if (WARN_ON(!vsi)) 506*cc9c60c9SJan Sokolowski return; 507*cc9c60c9SJan Sokolowski 508*cc9c60c9SJan Sokolowski ice_vf_set_host_trust_cfg(vf); 509*cc9c60c9SJan Sokolowski 510*cc9c60c9SJan Sokolowski if (ice_vf_rebuild_host_mac_cfg(vf)) 511*cc9c60c9SJan Sokolowski dev_err(dev, "failed to rebuild default MAC configuration for VF %d\n", 512*cc9c60c9SJan Sokolowski vf->vf_id); 513*cc9c60c9SJan Sokolowski 514*cc9c60c9SJan Sokolowski if (ice_vf_rebuild_host_vlan_cfg(vf, vsi)) 515*cc9c60c9SJan Sokolowski dev_err(dev, "failed to rebuild VLAN configuration for VF %u\n", 516*cc9c60c9SJan Sokolowski vf->vf_id); 517*cc9c60c9SJan Sokolowski 518*cc9c60c9SJan Sokolowski if (ice_vf_rebuild_host_tx_rate_cfg(vf)) 519*cc9c60c9SJan Sokolowski dev_err(dev, "failed to rebuild Tx rate limiting configuration for VF %u\n", 520*cc9c60c9SJan Sokolowski vf->vf_id); 521*cc9c60c9SJan Sokolowski 522*cc9c60c9SJan Sokolowski if (ice_vsi_apply_spoofchk(vsi, vf->spoofchk)) 523*cc9c60c9SJan Sokolowski dev_err(dev, "failed to rebuild spoofchk configuration for VF %d\n", 524*cc9c60c9SJan Sokolowski vf->vf_id); 525*cc9c60c9SJan Sokolowski 526*cc9c60c9SJan Sokolowski /* rebuild aggregator node config for main VF VSI */ 527*cc9c60c9SJan Sokolowski ice_vf_rebuild_aggregator_node_cfg(vsi); 528*cc9c60c9SJan Sokolowski } 529*cc9c60c9SJan Sokolowski 530*cc9c60c9SJan Sokolowski /** 531*cc9c60c9SJan Sokolowski * ice_set_vf_state_qs_dis - Set VF queues state to disabled 532*cc9c60c9SJan Sokolowski * @vf: pointer to the VF structure 533*cc9c60c9SJan Sokolowski */ 534*cc9c60c9SJan Sokolowski static void ice_set_vf_state_qs_dis(struct ice_vf *vf) 535*cc9c60c9SJan Sokolowski { 536*cc9c60c9SJan Sokolowski /* Clear Rx/Tx enabled queues flag */ 537*cc9c60c9SJan Sokolowski bitmap_zero(vf->txq_ena, ICE_MAX_RSS_QS_PER_VF); 538*cc9c60c9SJan Sokolowski bitmap_zero(vf->rxq_ena, ICE_MAX_RSS_QS_PER_VF); 539*cc9c60c9SJan Sokolowski clear_bit(ICE_VF_STATE_QS_ENA, vf->vf_states); 540*cc9c60c9SJan Sokolowski } 541*cc9c60c9SJan Sokolowski 542*cc9c60c9SJan Sokolowski /** 543*cc9c60c9SJan Sokolowski * ice_vf_set_initialized - VF is ready for VIRTCHNL communication 544*cc9c60c9SJan Sokolowski * @vf: VF to set in initialized state 545*cc9c60c9SJan Sokolowski * 546*cc9c60c9SJan Sokolowski * After this function the VF will be ready to receive/handle the 547*cc9c60c9SJan Sokolowski * VIRTCHNL_OP_GET_VF_RESOURCES message 548*cc9c60c9SJan Sokolowski */ 549*cc9c60c9SJan Sokolowski static void ice_vf_set_initialized(struct ice_vf *vf) 550*cc9c60c9SJan Sokolowski { 551*cc9c60c9SJan Sokolowski ice_set_vf_state_qs_dis(vf); 552*cc9c60c9SJan Sokolowski clear_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states); 553*cc9c60c9SJan Sokolowski clear_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states); 554*cc9c60c9SJan Sokolowski clear_bit(ICE_VF_STATE_DIS, vf->vf_states); 555*cc9c60c9SJan Sokolowski set_bit(ICE_VF_STATE_INIT, vf->vf_states); 556*cc9c60c9SJan Sokolowski memset(&vf->vlan_v2_caps, 0, sizeof(vf->vlan_v2_caps)); 557*cc9c60c9SJan Sokolowski } 558*cc9c60c9SJan Sokolowski 559*cc9c60c9SJan Sokolowski /** 560aeead3d0SJacob Keller * ice_vf_post_vsi_rebuild - Reset tasks that occur after VSI rebuild 561aeead3d0SJacob Keller * @vf: the VF being reset 562aeead3d0SJacob Keller * 563aeead3d0SJacob Keller * Perform reset tasks which must occur after the VSI has been re-created or 564aeead3d0SJacob Keller * rebuilt during a VF reset. 565aeead3d0SJacob Keller */ 566aeead3d0SJacob Keller static void ice_vf_post_vsi_rebuild(struct ice_vf *vf) 567aeead3d0SJacob Keller { 568aeead3d0SJacob Keller ice_vf_rebuild_host_cfg(vf); 569aeead3d0SJacob Keller ice_vf_set_initialized(vf); 570aeead3d0SJacob Keller 571aeead3d0SJacob Keller vf->vf_ops->post_vsi_rebuild(vf); 572aeead3d0SJacob Keller } 573aeead3d0SJacob Keller 574aeead3d0SJacob Keller /** 575d7393425SMichal Wilczynski * ice_is_any_vf_in_unicast_promisc - check if any VF(s) 576d7393425SMichal Wilczynski * are in unicast promiscuous mode 577109aba47SJacob Keller * @pf: PF structure for accessing VF(s) 578109aba47SJacob Keller * 579d7393425SMichal Wilczynski * Return false if no VF(s) are in unicast promiscuous mode, 580109aba47SJacob Keller * else return true 581109aba47SJacob Keller */ 582d7393425SMichal Wilczynski bool ice_is_any_vf_in_unicast_promisc(struct ice_pf *pf) 583109aba47SJacob Keller { 584109aba47SJacob Keller bool is_vf_promisc = false; 585109aba47SJacob Keller struct ice_vf *vf; 586109aba47SJacob Keller unsigned int bkt; 587109aba47SJacob Keller 588109aba47SJacob Keller rcu_read_lock(); 589109aba47SJacob Keller ice_for_each_vf_rcu(pf, bkt, vf) { 590109aba47SJacob Keller /* found a VF that has promiscuous mode configured */ 591d7393425SMichal Wilczynski if (test_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states)) { 592109aba47SJacob Keller is_vf_promisc = true; 593109aba47SJacob Keller break; 594109aba47SJacob Keller } 595109aba47SJacob Keller } 596109aba47SJacob Keller rcu_read_unlock(); 597109aba47SJacob Keller 598109aba47SJacob Keller return is_vf_promisc; 599109aba47SJacob Keller } 600109aba47SJacob Keller 601109aba47SJacob Keller /** 602a419526dSMichal Wilczynski * ice_vf_get_promisc_masks - Calculate masks for promiscuous modes 603a419526dSMichal Wilczynski * @vf: the VF pointer 604a419526dSMichal Wilczynski * @vsi: the VSI to configure 605a419526dSMichal Wilczynski * @ucast_m: promiscuous mask to apply to unicast 606a419526dSMichal Wilczynski * @mcast_m: promiscuous mask to apply to multicast 607a419526dSMichal Wilczynski * 608a419526dSMichal Wilczynski * Decide which mask should be used for unicast and multicast filter, 609a419526dSMichal Wilczynski * based on presence of VLANs 610a419526dSMichal Wilczynski */ 611a419526dSMichal Wilczynski void 612a419526dSMichal Wilczynski ice_vf_get_promisc_masks(struct ice_vf *vf, struct ice_vsi *vsi, 613a419526dSMichal Wilczynski u8 *ucast_m, u8 *mcast_m) 614a419526dSMichal Wilczynski { 615a419526dSMichal Wilczynski if (ice_vf_is_port_vlan_ena(vf) || 616a419526dSMichal Wilczynski ice_vsi_has_non_zero_vlans(vsi)) { 617a419526dSMichal Wilczynski *mcast_m = ICE_MCAST_VLAN_PROMISC_BITS; 618a419526dSMichal Wilczynski *ucast_m = ICE_UCAST_VLAN_PROMISC_BITS; 619a419526dSMichal Wilczynski } else { 620a419526dSMichal Wilczynski *mcast_m = ICE_MCAST_PROMISC_BITS; 621a419526dSMichal Wilczynski *ucast_m = ICE_UCAST_PROMISC_BITS; 622a419526dSMichal Wilczynski } 623a419526dSMichal Wilczynski } 624a419526dSMichal Wilczynski 625a419526dSMichal Wilczynski /** 626a419526dSMichal Wilczynski * ice_vf_clear_all_promisc_modes - Clear promisc/allmulticast on VF VSI 627a419526dSMichal Wilczynski * @vf: the VF pointer 628a419526dSMichal Wilczynski * @vsi: the VSI to configure 629a419526dSMichal Wilczynski * 630a419526dSMichal Wilczynski * Clear all promiscuous/allmulticast filters for a VF 631a419526dSMichal Wilczynski */ 632a419526dSMichal Wilczynski static int 633a419526dSMichal Wilczynski ice_vf_clear_all_promisc_modes(struct ice_vf *vf, struct ice_vsi *vsi) 634a419526dSMichal Wilczynski { 635a419526dSMichal Wilczynski struct ice_pf *pf = vf->pf; 636a419526dSMichal Wilczynski u8 ucast_m, mcast_m; 637a419526dSMichal Wilczynski int ret = 0; 638a419526dSMichal Wilczynski 639a419526dSMichal Wilczynski ice_vf_get_promisc_masks(vf, vsi, &ucast_m, &mcast_m); 640a419526dSMichal Wilczynski if (test_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states)) { 641a419526dSMichal Wilczynski if (!test_bit(ICE_FLAG_VF_TRUE_PROMISC_ENA, pf->flags)) { 642a419526dSMichal Wilczynski if (ice_is_dflt_vsi_in_use(vsi->port_info)) 643a419526dSMichal Wilczynski ret = ice_clear_dflt_vsi(vsi); 644a419526dSMichal Wilczynski } else { 645a419526dSMichal Wilczynski ret = ice_vf_clear_vsi_promisc(vf, vsi, ucast_m); 646a419526dSMichal Wilczynski } 647a419526dSMichal Wilczynski 648a419526dSMichal Wilczynski if (ret) { 649a419526dSMichal Wilczynski dev_err(ice_pf_to_dev(vf->pf), "Disabling promiscuous mode failed\n"); 650a419526dSMichal Wilczynski } else { 651a419526dSMichal Wilczynski clear_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states); 652a419526dSMichal Wilczynski dev_info(ice_pf_to_dev(vf->pf), "Disabling promiscuous mode succeeded\n"); 653a419526dSMichal Wilczynski } 654a419526dSMichal Wilczynski } 655a419526dSMichal Wilczynski 656a419526dSMichal Wilczynski if (test_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states)) { 657a419526dSMichal Wilczynski ret = ice_vf_clear_vsi_promisc(vf, vsi, mcast_m); 658a419526dSMichal Wilczynski if (ret) { 659a419526dSMichal Wilczynski dev_err(ice_pf_to_dev(vf->pf), "Disabling allmulticast mode failed\n"); 660a419526dSMichal Wilczynski } else { 661a419526dSMichal Wilczynski clear_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states); 662a419526dSMichal Wilczynski dev_info(ice_pf_to_dev(vf->pf), "Disabling allmulticast mode succeeded\n"); 663a419526dSMichal Wilczynski } 664a419526dSMichal Wilczynski } 665a419526dSMichal Wilczynski return ret; 666a419526dSMichal Wilczynski } 667a419526dSMichal Wilczynski 668a419526dSMichal Wilczynski /** 669109aba47SJacob Keller * ice_vf_set_vsi_promisc - Enable promiscuous mode for a VF VSI 670109aba47SJacob Keller * @vf: the VF to configure 671109aba47SJacob Keller * @vsi: the VF's VSI 672109aba47SJacob Keller * @promisc_m: the promiscuous mode to enable 673109aba47SJacob Keller */ 674109aba47SJacob Keller int 675109aba47SJacob Keller ice_vf_set_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m) 676109aba47SJacob Keller { 677109aba47SJacob Keller struct ice_hw *hw = &vsi->back->hw; 678109aba47SJacob Keller int status; 679109aba47SJacob Keller 680109aba47SJacob Keller if (ice_vf_is_port_vlan_ena(vf)) 681109aba47SJacob Keller status = ice_fltr_set_vsi_promisc(hw, vsi->idx, promisc_m, 682109aba47SJacob Keller ice_vf_get_port_vlan_id(vf)); 683109aba47SJacob Keller else if (ice_vsi_has_non_zero_vlans(vsi)) 684109aba47SJacob Keller status = ice_fltr_set_vlan_vsi_promisc(hw, vsi, promisc_m); 685109aba47SJacob Keller else 686109aba47SJacob Keller status = ice_fltr_set_vsi_promisc(hw, vsi->idx, promisc_m, 0); 687109aba47SJacob Keller 688109aba47SJacob Keller if (status && status != -EEXIST) { 689109aba47SJacob Keller dev_err(ice_pf_to_dev(vsi->back), "enable Tx/Rx filter promiscuous mode on VF-%u failed, error: %d\n", 690109aba47SJacob Keller vf->vf_id, status); 691109aba47SJacob Keller return status; 692109aba47SJacob Keller } 693109aba47SJacob Keller 694109aba47SJacob Keller return 0; 695109aba47SJacob Keller } 696109aba47SJacob Keller 697109aba47SJacob Keller /** 698109aba47SJacob Keller * ice_vf_clear_vsi_promisc - Disable promiscuous mode for a VF VSI 699109aba47SJacob Keller * @vf: the VF to configure 700109aba47SJacob Keller * @vsi: the VF's VSI 701109aba47SJacob Keller * @promisc_m: the promiscuous mode to disable 702109aba47SJacob Keller */ 703109aba47SJacob Keller int 704109aba47SJacob Keller ice_vf_clear_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m) 705109aba47SJacob Keller { 706109aba47SJacob Keller struct ice_hw *hw = &vsi->back->hw; 707109aba47SJacob Keller int status; 708109aba47SJacob Keller 709109aba47SJacob Keller if (ice_vf_is_port_vlan_ena(vf)) 710109aba47SJacob Keller status = ice_fltr_clear_vsi_promisc(hw, vsi->idx, promisc_m, 711109aba47SJacob Keller ice_vf_get_port_vlan_id(vf)); 712109aba47SJacob Keller else if (ice_vsi_has_non_zero_vlans(vsi)) 713109aba47SJacob Keller status = ice_fltr_clear_vlan_vsi_promisc(hw, vsi, promisc_m); 714109aba47SJacob Keller else 715109aba47SJacob Keller status = ice_fltr_clear_vsi_promisc(hw, vsi->idx, promisc_m, 0); 716109aba47SJacob Keller 717109aba47SJacob Keller if (status && status != -ENOENT) { 718109aba47SJacob Keller dev_err(ice_pf_to_dev(vsi->back), "disable Tx/Rx filter promiscuous mode on VF-%u failed, error: %d\n", 719109aba47SJacob Keller vf->vf_id, status); 720109aba47SJacob Keller return status; 721109aba47SJacob Keller } 722109aba47SJacob Keller 723109aba47SJacob Keller return 0; 724109aba47SJacob Keller } 725109aba47SJacob Keller 726109aba47SJacob Keller /** 72716686d7fSJacob Keller * ice_reset_all_vfs - reset all allocated VFs in one go 72816686d7fSJacob Keller * @pf: pointer to the PF structure 72916686d7fSJacob Keller * 73000be8197SJacob Keller * Reset all VFs at once, in response to a PF or other device reset. 73100be8197SJacob Keller * 73216686d7fSJacob Keller * First, tell the hardware to reset each VF, then do all the waiting in one 73316686d7fSJacob Keller * chunk, and finally finish restoring each VF after the wait. This is useful 73416686d7fSJacob Keller * during PF routines which need to reset all VFs, as otherwise it must perform 73516686d7fSJacob Keller * these resets in a serialized fashion. 73616686d7fSJacob Keller */ 737fe99d1c0SJacob Keller void ice_reset_all_vfs(struct ice_pf *pf) 73816686d7fSJacob Keller { 73916686d7fSJacob Keller struct device *dev = ice_pf_to_dev(pf); 74016686d7fSJacob Keller struct ice_hw *hw = &pf->hw; 74116686d7fSJacob Keller struct ice_vf *vf; 74216686d7fSJacob Keller unsigned int bkt; 74316686d7fSJacob Keller 74416686d7fSJacob Keller /* If we don't have any VFs, then there is nothing to reset */ 74516686d7fSJacob Keller if (!ice_has_vfs(pf)) 746fe99d1c0SJacob Keller return; 74716686d7fSJacob Keller 74816686d7fSJacob Keller mutex_lock(&pf->vfs.table_lock); 74916686d7fSJacob Keller 75016686d7fSJacob Keller /* clear all malicious info if the VFs are getting reset */ 75116686d7fSJacob Keller ice_for_each_vf(pf, bkt, vf) 7528cd8a6b1SJacob Keller ice_mbx_clear_malvf(&vf->mbx_info); 75316686d7fSJacob Keller 75416686d7fSJacob Keller /* If VFs have been disabled, there is no need to reset */ 75516686d7fSJacob Keller if (test_and_set_bit(ICE_VF_DIS, pf->state)) { 75616686d7fSJacob Keller mutex_unlock(&pf->vfs.table_lock); 757fe99d1c0SJacob Keller return; 75816686d7fSJacob Keller } 75916686d7fSJacob Keller 76016686d7fSJacob Keller /* Begin reset on all VFs at once */ 76116686d7fSJacob Keller ice_for_each_vf(pf, bkt, vf) 762dac57288SJacob Keller ice_trigger_vf_reset(vf, true, true); 76316686d7fSJacob Keller 76416686d7fSJacob Keller /* HW requires some time to make sure it can flush the FIFO for a VF 76516686d7fSJacob Keller * when it resets it. Now that we've triggered all of the VFs, iterate 76616686d7fSJacob Keller * the table again and wait for each VF to complete. 76716686d7fSJacob Keller */ 76816686d7fSJacob Keller ice_for_each_vf(pf, bkt, vf) { 76916686d7fSJacob Keller if (!vf->vf_ops->poll_reset_status(vf)) { 77016686d7fSJacob Keller /* Display a warning if at least one VF didn't manage 77116686d7fSJacob Keller * to reset in time, but continue on with the 77216686d7fSJacob Keller * operation. 77316686d7fSJacob Keller */ 77416686d7fSJacob Keller dev_warn(dev, "VF %u reset check timeout\n", vf->vf_id); 77516686d7fSJacob Keller break; 77616686d7fSJacob Keller } 77716686d7fSJacob Keller } 77816686d7fSJacob Keller 77916686d7fSJacob Keller /* free VF resources to begin resetting the VSI state */ 78016686d7fSJacob Keller ice_for_each_vf(pf, bkt, vf) { 78116686d7fSJacob Keller mutex_lock(&vf->cfg_lock); 78216686d7fSJacob Keller 78316686d7fSJacob Keller vf->driver_caps = 0; 78416686d7fSJacob Keller ice_vc_set_default_allowlist(vf); 78516686d7fSJacob Keller 78616686d7fSJacob Keller ice_vf_fdir_exit(vf); 78716686d7fSJacob Keller ice_vf_fdir_init(vf); 78816686d7fSJacob Keller /* clean VF control VSI when resetting VFs since it should be 78916686d7fSJacob Keller * setup only when VF creates its first FDIR rule. 79016686d7fSJacob Keller */ 79116686d7fSJacob Keller if (vf->ctrl_vsi_idx != ICE_NO_VSI) 79216686d7fSJacob Keller ice_vf_ctrl_invalidate_vsi(vf); 79316686d7fSJacob Keller 79416686d7fSJacob Keller ice_vf_pre_vsi_rebuild(vf); 79516686d7fSJacob Keller ice_vf_rebuild_vsi(vf); 796aeead3d0SJacob Keller ice_vf_post_vsi_rebuild(vf); 79716686d7fSJacob Keller 79816686d7fSJacob Keller mutex_unlock(&vf->cfg_lock); 79916686d7fSJacob Keller } 80016686d7fSJacob Keller 80116686d7fSJacob Keller if (ice_is_eswitch_mode_switchdev(pf)) 80216686d7fSJacob Keller if (ice_eswitch_rebuild(pf)) 80316686d7fSJacob Keller dev_warn(dev, "eswitch rebuild failed\n"); 80416686d7fSJacob Keller 80516686d7fSJacob Keller ice_flush(hw); 80616686d7fSJacob Keller clear_bit(ICE_VF_DIS, pf->state); 80716686d7fSJacob Keller 80816686d7fSJacob Keller mutex_unlock(&pf->vfs.table_lock); 80916686d7fSJacob Keller } 81016686d7fSJacob Keller 81116686d7fSJacob Keller /** 8129dbb33daSJacob Keller * ice_notify_vf_reset - Notify VF of a reset event 8139dbb33daSJacob Keller * @vf: pointer to the VF structure 8149dbb33daSJacob Keller */ 8159dbb33daSJacob Keller static void ice_notify_vf_reset(struct ice_vf *vf) 8169dbb33daSJacob Keller { 8179dbb33daSJacob Keller struct ice_hw *hw = &vf->pf->hw; 8189dbb33daSJacob Keller struct virtchnl_pf_event pfe; 8199dbb33daSJacob Keller 8209dbb33daSJacob Keller /* Bail out if VF is in disabled state, neither initialized, nor active 8219dbb33daSJacob Keller * state - otherwise proceed with notifications 8229dbb33daSJacob Keller */ 8239dbb33daSJacob Keller if ((!test_bit(ICE_VF_STATE_INIT, vf->vf_states) && 8249dbb33daSJacob Keller !test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) || 8259dbb33daSJacob Keller test_bit(ICE_VF_STATE_DIS, vf->vf_states)) 8269dbb33daSJacob Keller return; 8279dbb33daSJacob Keller 8289dbb33daSJacob Keller pfe.event = VIRTCHNL_EVENT_RESET_IMPENDING; 8299dbb33daSJacob Keller pfe.severity = PF_EVENT_SEVERITY_CERTAIN_DOOM; 8309dbb33daSJacob Keller ice_aq_send_msg_to_vf(hw, vf->vf_id, VIRTCHNL_OP_EVENT, 8319dbb33daSJacob Keller VIRTCHNL_STATUS_SUCCESS, (u8 *)&pfe, sizeof(pfe), 8329dbb33daSJacob Keller NULL); 8339dbb33daSJacob Keller } 8349dbb33daSJacob Keller 8359dbb33daSJacob Keller /** 83616686d7fSJacob Keller * ice_reset_vf - Reset a particular VF 83716686d7fSJacob Keller * @vf: pointer to the VF structure 8387eb517e4SJacob Keller * @flags: flags controlling behavior of the reset 8397eb517e4SJacob Keller * 8407eb517e4SJacob Keller * Flags: 8417eb517e4SJacob Keller * ICE_VF_RESET_VFLR - Indicates a reset is due to VFLR event 8429dbb33daSJacob Keller * ICE_VF_RESET_NOTIFY - Send VF a notification prior to reset 843f5f085c0SJacob Keller * ICE_VF_RESET_LOCK - Acquire VF cfg_lock before resetting 84416686d7fSJacob Keller * 84519c3e1edSJacob Keller * Returns 0 if the VF is currently in reset, if resets are disabled, or if 84619c3e1edSJacob Keller * the VF resets successfully. Returns an error code if the VF fails to 8474fe193ccSJacob Keller * rebuild. 84816686d7fSJacob Keller */ 8497eb517e4SJacob Keller int ice_reset_vf(struct ice_vf *vf, u32 flags) 85016686d7fSJacob Keller { 85116686d7fSJacob Keller struct ice_pf *pf = vf->pf; 85216686d7fSJacob Keller struct ice_vsi *vsi; 85316686d7fSJacob Keller struct device *dev; 854f5f085c0SJacob Keller int err = 0; 85516686d7fSJacob Keller bool rsd; 85616686d7fSJacob Keller 85716686d7fSJacob Keller dev = ice_pf_to_dev(pf); 85816686d7fSJacob Keller 8599dbb33daSJacob Keller if (flags & ICE_VF_RESET_NOTIFY) 8609dbb33daSJacob Keller ice_notify_vf_reset(vf); 8619dbb33daSJacob Keller 86216686d7fSJacob Keller if (test_bit(ICE_VF_RESETS_DISABLED, pf->state)) { 86316686d7fSJacob Keller dev_dbg(dev, "Trying to reset VF %d, but all VF resets are disabled\n", 86416686d7fSJacob Keller vf->vf_id); 8654fe193ccSJacob Keller return 0; 86616686d7fSJacob Keller } 86716686d7fSJacob Keller 86816686d7fSJacob Keller if (ice_is_vf_disabled(vf)) { 869efe41860SPrzemyslaw Patynowski vsi = ice_get_vf_vsi(vf); 870cf90b743SMichal Jaron if (!vsi) { 871cf90b743SMichal Jaron dev_dbg(dev, "VF is already removed\n"); 872efe41860SPrzemyslaw Patynowski return -EINVAL; 873cf90b743SMichal Jaron } 874efe41860SPrzemyslaw Patynowski ice_vsi_stop_lan_tx_rings(vsi, ICE_NO_RESET, vf->vf_id); 875f23df522SNorbert Zulinski 876f23df522SNorbert Zulinski if (ice_vsi_is_rx_queue_active(vsi)) 877efe41860SPrzemyslaw Patynowski ice_vsi_stop_all_rx_rings(vsi); 878f23df522SNorbert Zulinski 87916686d7fSJacob Keller dev_dbg(dev, "VF is already disabled, there is no need for resetting it, telling VM, all is fine %d\n", 88016686d7fSJacob Keller vf->vf_id); 8814fe193ccSJacob Keller return 0; 88216686d7fSJacob Keller } 88316686d7fSJacob Keller 884f5f085c0SJacob Keller if (flags & ICE_VF_RESET_LOCK) 885f5f085c0SJacob Keller mutex_lock(&vf->cfg_lock); 886f5f085c0SJacob Keller else 887f5f085c0SJacob Keller lockdep_assert_held(&vf->cfg_lock); 888f5f085c0SJacob Keller 88916686d7fSJacob Keller /* Set VF disable bit state here, before triggering reset */ 89016686d7fSJacob Keller set_bit(ICE_VF_STATE_DIS, vf->vf_states); 8917eb517e4SJacob Keller ice_trigger_vf_reset(vf, flags & ICE_VF_RESET_VFLR, false); 89216686d7fSJacob Keller 89316686d7fSJacob Keller vsi = ice_get_vf_vsi(vf); 894baeb705fSJacob Keller if (WARN_ON(!vsi)) { 895baeb705fSJacob Keller err = -EIO; 896baeb705fSJacob Keller goto out_unlock; 897baeb705fSJacob Keller } 89816686d7fSJacob Keller 89916686d7fSJacob Keller ice_dis_vf_qs(vf); 90016686d7fSJacob Keller 90116686d7fSJacob Keller /* Call Disable LAN Tx queue AQ whether or not queues are 90216686d7fSJacob Keller * enabled. This is needed for successful completion of VFR. 90316686d7fSJacob Keller */ 90416686d7fSJacob Keller ice_dis_vsi_txq(vsi->port_info, vsi->idx, 0, 0, NULL, NULL, 90516686d7fSJacob Keller NULL, vf->vf_ops->reset_type, vf->vf_id, NULL); 90616686d7fSJacob Keller 90716686d7fSJacob Keller /* poll VPGEN_VFRSTAT reg to make sure 90816686d7fSJacob Keller * that reset is complete 90916686d7fSJacob Keller */ 91016686d7fSJacob Keller rsd = vf->vf_ops->poll_reset_status(vf); 91116686d7fSJacob Keller 91216686d7fSJacob Keller /* Display a warning if VF didn't manage to reset in time, but need to 91316686d7fSJacob Keller * continue on with the operation. 91416686d7fSJacob Keller */ 91516686d7fSJacob Keller if (!rsd) 91616686d7fSJacob Keller dev_warn(dev, "VF reset check timeout on VF %d\n", vf->vf_id); 91716686d7fSJacob Keller 91816686d7fSJacob Keller vf->driver_caps = 0; 91916686d7fSJacob Keller ice_vc_set_default_allowlist(vf); 92016686d7fSJacob Keller 92116686d7fSJacob Keller /* disable promiscuous modes in case they were enabled 92216686d7fSJacob Keller * ignore any error if disabling process failed 92316686d7fSJacob Keller */ 924a419526dSMichal Wilczynski ice_vf_clear_all_promisc_modes(vf, vsi); 92516686d7fSJacob Keller 92616686d7fSJacob Keller ice_vf_fdir_exit(vf); 92716686d7fSJacob Keller ice_vf_fdir_init(vf); 92816686d7fSJacob Keller /* clean VF control VSI when resetting VF since it should be setup 92916686d7fSJacob Keller * only when VF creates its first FDIR rule. 93016686d7fSJacob Keller */ 93116686d7fSJacob Keller if (vf->ctrl_vsi_idx != ICE_NO_VSI) 93216686d7fSJacob Keller ice_vf_ctrl_vsi_release(vf); 93316686d7fSJacob Keller 93416686d7fSJacob Keller ice_vf_pre_vsi_rebuild(vf); 93516686d7fSJacob Keller 9365531bb85SJacob Keller if (ice_vf_recreate_vsi(vf)) { 93716686d7fSJacob Keller dev_err(dev, "Failed to release and setup the VF%u's VSI\n", 93816686d7fSJacob Keller vf->vf_id); 939f5f085c0SJacob Keller err = -EFAULT; 940f5f085c0SJacob Keller goto out_unlock; 94116686d7fSJacob Keller } 94216686d7fSJacob Keller 943aeead3d0SJacob Keller ice_vf_post_vsi_rebuild(vf); 94416686d7fSJacob Keller vsi = ice_get_vf_vsi(vf); 945baeb705fSJacob Keller if (WARN_ON(!vsi)) { 946baeb705fSJacob Keller err = -EINVAL; 947baeb705fSJacob Keller goto out_unlock; 948baeb705fSJacob Keller } 949baeb705fSJacob Keller 95016686d7fSJacob Keller ice_eswitch_update_repr(vsi); 95116686d7fSJacob Keller 95216686d7fSJacob Keller /* if the VF has been reset allow it to come up again */ 9538cd8a6b1SJacob Keller ice_mbx_clear_malvf(&vf->mbx_info); 95416686d7fSJacob Keller 955f5f085c0SJacob Keller out_unlock: 956f5f085c0SJacob Keller if (flags & ICE_VF_RESET_LOCK) 957f5f085c0SJacob Keller mutex_unlock(&vf->cfg_lock); 958f5f085c0SJacob Keller 959f5f085c0SJacob Keller return err; 96016686d7fSJacob Keller } 96116686d7fSJacob Keller 96216686d7fSJacob Keller /** 963fa4a15c8SJacob Keller * ice_set_vf_state_dis - Set VF state to disabled 964fa4a15c8SJacob Keller * @vf: pointer to the VF structure 965fa4a15c8SJacob Keller */ 966fa4a15c8SJacob Keller void ice_set_vf_state_dis(struct ice_vf *vf) 967fa4a15c8SJacob Keller { 968fa4a15c8SJacob Keller ice_set_vf_state_qs_dis(vf); 969fa4a15c8SJacob Keller vf->vf_ops->clear_reset_state(vf); 970fa4a15c8SJacob Keller } 971fa4a15c8SJacob Keller 972109aba47SJacob Keller /* Private functions only accessed from other virtualization files */ 973109aba47SJacob Keller 974109aba47SJacob Keller /** 975b5dcff1fSJacob Keller * ice_initialize_vf_entry - Initialize a VF entry 976b5dcff1fSJacob Keller * @vf: pointer to the VF structure 977b5dcff1fSJacob Keller */ 978b5dcff1fSJacob Keller void ice_initialize_vf_entry(struct ice_vf *vf) 979b5dcff1fSJacob Keller { 980b5dcff1fSJacob Keller struct ice_pf *pf = vf->pf; 981b5dcff1fSJacob Keller struct ice_vfs *vfs; 982b5dcff1fSJacob Keller 983b5dcff1fSJacob Keller vfs = &pf->vfs; 984b5dcff1fSJacob Keller 985b5dcff1fSJacob Keller /* assign default capabilities */ 986b5dcff1fSJacob Keller vf->spoofchk = true; 987b5dcff1fSJacob Keller vf->num_vf_qs = vfs->num_qps_per; 988b5dcff1fSJacob Keller ice_vc_set_default_allowlist(vf); 989b5dcff1fSJacob Keller ice_virtchnl_set_dflt_ops(vf); 990b5dcff1fSJacob Keller 991b5dcff1fSJacob Keller /* ctrl_vsi_idx will be set to a valid value only when iAVF 992b5dcff1fSJacob Keller * creates its first fdir rule. 993b5dcff1fSJacob Keller */ 994b5dcff1fSJacob Keller ice_vf_ctrl_invalidate_vsi(vf); 995b5dcff1fSJacob Keller ice_vf_fdir_init(vf); 996b5dcff1fSJacob Keller 997e4eaf893SJacob Keller /* Initialize mailbox info for this VF */ 998e4eaf893SJacob Keller ice_mbx_init_vf_info(&pf->hw, &vf->mbx_info); 999e4eaf893SJacob Keller 1000b5dcff1fSJacob Keller mutex_init(&vf->cfg_lock); 1001b5dcff1fSJacob Keller } 1002b5dcff1fSJacob Keller 1003b5dcff1fSJacob Keller /** 1004109aba47SJacob Keller * ice_dis_vf_qs - Disable the VF queues 1005109aba47SJacob Keller * @vf: pointer to the VF structure 1006109aba47SJacob Keller */ 1007109aba47SJacob Keller void ice_dis_vf_qs(struct ice_vf *vf) 1008109aba47SJacob Keller { 1009109aba47SJacob Keller struct ice_vsi *vsi = ice_get_vf_vsi(vf); 1010109aba47SJacob Keller 1011baeb705fSJacob Keller if (WARN_ON(!vsi)) 1012baeb705fSJacob Keller return; 1013baeb705fSJacob Keller 1014109aba47SJacob Keller ice_vsi_stop_lan_tx_rings(vsi, ICE_NO_RESET, vf->vf_id); 1015109aba47SJacob Keller ice_vsi_stop_all_rx_rings(vsi); 1016109aba47SJacob Keller ice_set_vf_state_qs_dis(vf); 1017109aba47SJacob Keller } 1018109aba47SJacob Keller 1019109aba47SJacob Keller /** 1020e384cf35SMd Fahad Iqbal Polash * ice_err_to_virt_err - translate errors for VF return code 1021e384cf35SMd Fahad Iqbal Polash * @err: error return code 1022e384cf35SMd Fahad Iqbal Polash */ 1023e384cf35SMd Fahad Iqbal Polash enum virtchnl_status_code ice_err_to_virt_err(int err) 1024e384cf35SMd Fahad Iqbal Polash { 1025e384cf35SMd Fahad Iqbal Polash switch (err) { 1026e384cf35SMd Fahad Iqbal Polash case 0: 1027e384cf35SMd Fahad Iqbal Polash return VIRTCHNL_STATUS_SUCCESS; 1028e384cf35SMd Fahad Iqbal Polash case -EINVAL: 1029e384cf35SMd Fahad Iqbal Polash case -ENODEV: 1030e384cf35SMd Fahad Iqbal Polash return VIRTCHNL_STATUS_ERR_PARAM; 1031e384cf35SMd Fahad Iqbal Polash case -ENOMEM: 1032e384cf35SMd Fahad Iqbal Polash return VIRTCHNL_STATUS_ERR_NO_MEMORY; 1033e384cf35SMd Fahad Iqbal Polash case -EALREADY: 1034e384cf35SMd Fahad Iqbal Polash case -EBUSY: 1035e384cf35SMd Fahad Iqbal Polash case -EIO: 1036e384cf35SMd Fahad Iqbal Polash case -ENOSPC: 1037e384cf35SMd Fahad Iqbal Polash return VIRTCHNL_STATUS_ERR_ADMIN_QUEUE_ERROR; 1038e384cf35SMd Fahad Iqbal Polash default: 1039e384cf35SMd Fahad Iqbal Polash return VIRTCHNL_STATUS_ERR_NOT_SUPPORTED; 1040e384cf35SMd Fahad Iqbal Polash } 1041e384cf35SMd Fahad Iqbal Polash } 1042e384cf35SMd Fahad Iqbal Polash 1043e384cf35SMd Fahad Iqbal Polash /** 1044109aba47SJacob Keller * ice_check_vf_init - helper to check if VF init complete 1045109aba47SJacob Keller * @vf: the pointer to the VF to check 1046109aba47SJacob Keller */ 10475a57ee83SJacob Keller int ice_check_vf_init(struct ice_vf *vf) 1048109aba47SJacob Keller { 10495a57ee83SJacob Keller struct ice_pf *pf = vf->pf; 10505a57ee83SJacob Keller 1051109aba47SJacob Keller if (!test_bit(ICE_VF_STATE_INIT, vf->vf_states)) { 1052109aba47SJacob Keller dev_err(ice_pf_to_dev(pf), "VF ID: %u in reset. Try again.\n", 1053109aba47SJacob Keller vf->vf_id); 1054109aba47SJacob Keller return -EBUSY; 1055109aba47SJacob Keller } 1056109aba47SJacob Keller return 0; 1057109aba47SJacob Keller } 1058109aba47SJacob Keller 1059109aba47SJacob Keller /** 1060109aba47SJacob Keller * ice_vf_get_port_info - Get the VF's port info structure 1061109aba47SJacob Keller * @vf: VF used to get the port info structure for 1062109aba47SJacob Keller */ 1063109aba47SJacob Keller struct ice_port_info *ice_vf_get_port_info(struct ice_vf *vf) 1064109aba47SJacob Keller { 1065109aba47SJacob Keller return vf->pf->hw.port_info; 1066109aba47SJacob Keller } 1067109aba47SJacob Keller 106871c114e8SJacob Keller /** 106971c114e8SJacob Keller * ice_cfg_mac_antispoof - Configure MAC antispoof checking behavior 107071c114e8SJacob Keller * @vsi: the VSI to configure 107171c114e8SJacob Keller * @enable: whether to enable or disable the spoof checking 107271c114e8SJacob Keller * 107371c114e8SJacob Keller * Configure a VSI to enable (or disable) spoof checking behavior. 107471c114e8SJacob Keller */ 1075109aba47SJacob Keller static int ice_cfg_mac_antispoof(struct ice_vsi *vsi, bool enable) 1076109aba47SJacob Keller { 1077109aba47SJacob Keller struct ice_vsi_ctx *ctx; 1078109aba47SJacob Keller int err; 1079109aba47SJacob Keller 1080109aba47SJacob Keller ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 1081109aba47SJacob Keller if (!ctx) 1082109aba47SJacob Keller return -ENOMEM; 1083109aba47SJacob Keller 1084109aba47SJacob Keller ctx->info.sec_flags = vsi->info.sec_flags; 1085109aba47SJacob Keller ctx->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SECURITY_VALID); 1086109aba47SJacob Keller 1087109aba47SJacob Keller if (enable) 1088109aba47SJacob Keller ctx->info.sec_flags |= ICE_AQ_VSI_SEC_FLAG_ENA_MAC_ANTI_SPOOF; 1089109aba47SJacob Keller else 1090109aba47SJacob Keller ctx->info.sec_flags &= ~ICE_AQ_VSI_SEC_FLAG_ENA_MAC_ANTI_SPOOF; 1091109aba47SJacob Keller 1092109aba47SJacob Keller err = ice_update_vsi(&vsi->back->hw, vsi->idx, ctx, NULL); 1093109aba47SJacob Keller if (err) 1094109aba47SJacob Keller dev_err(ice_pf_to_dev(vsi->back), "Failed to configure Tx MAC anti-spoof %s for VSI %d, error %d\n", 1095109aba47SJacob Keller enable ? "ON" : "OFF", vsi->vsi_num, err); 1096109aba47SJacob Keller else 1097109aba47SJacob Keller vsi->info.sec_flags = ctx->info.sec_flags; 1098109aba47SJacob Keller 1099109aba47SJacob Keller kfree(ctx); 1100109aba47SJacob Keller 1101109aba47SJacob Keller return err; 1102109aba47SJacob Keller } 1103109aba47SJacob Keller 1104109aba47SJacob Keller /** 1105109aba47SJacob Keller * ice_vsi_ena_spoofchk - enable Tx spoof checking for this VSI 1106109aba47SJacob Keller * @vsi: VSI to enable Tx spoof checking for 1107109aba47SJacob Keller */ 1108109aba47SJacob Keller static int ice_vsi_ena_spoofchk(struct ice_vsi *vsi) 1109109aba47SJacob Keller { 1110109aba47SJacob Keller struct ice_vsi_vlan_ops *vlan_ops; 1111664d4646SSylwester Dziedziuch int err = 0; 1112109aba47SJacob Keller 1113109aba47SJacob Keller vlan_ops = ice_get_compat_vsi_vlan_ops(vsi); 1114109aba47SJacob Keller 1115664d4646SSylwester Dziedziuch /* Allow VF with VLAN 0 only to send all tagged traffic */ 1116664d4646SSylwester Dziedziuch if (vsi->type != ICE_VSI_VF || ice_vsi_has_non_zero_vlans(vsi)) { 1117109aba47SJacob Keller err = vlan_ops->ena_tx_filtering(vsi); 1118109aba47SJacob Keller if (err) 1119109aba47SJacob Keller return err; 1120664d4646SSylwester Dziedziuch } 1121109aba47SJacob Keller 1122109aba47SJacob Keller return ice_cfg_mac_antispoof(vsi, true); 1123109aba47SJacob Keller } 1124109aba47SJacob Keller 1125109aba47SJacob Keller /** 1126109aba47SJacob Keller * ice_vsi_dis_spoofchk - disable Tx spoof checking for this VSI 1127109aba47SJacob Keller * @vsi: VSI to disable Tx spoof checking for 1128109aba47SJacob Keller */ 1129109aba47SJacob Keller static int ice_vsi_dis_spoofchk(struct ice_vsi *vsi) 1130109aba47SJacob Keller { 1131109aba47SJacob Keller struct ice_vsi_vlan_ops *vlan_ops; 1132109aba47SJacob Keller int err; 1133109aba47SJacob Keller 1134109aba47SJacob Keller vlan_ops = ice_get_compat_vsi_vlan_ops(vsi); 1135109aba47SJacob Keller 1136109aba47SJacob Keller err = vlan_ops->dis_tx_filtering(vsi); 1137109aba47SJacob Keller if (err) 1138109aba47SJacob Keller return err; 1139109aba47SJacob Keller 1140109aba47SJacob Keller return ice_cfg_mac_antispoof(vsi, false); 1141109aba47SJacob Keller } 1142109aba47SJacob Keller 1143109aba47SJacob Keller /** 1144109aba47SJacob Keller * ice_vsi_apply_spoofchk - Apply Tx spoof checking setting to a VSI 1145109aba47SJacob Keller * @vsi: VSI associated to the VF 1146109aba47SJacob Keller * @enable: whether to enable or disable the spoof checking 1147109aba47SJacob Keller */ 1148109aba47SJacob Keller int ice_vsi_apply_spoofchk(struct ice_vsi *vsi, bool enable) 1149109aba47SJacob Keller { 1150109aba47SJacob Keller int err; 1151109aba47SJacob Keller 1152109aba47SJacob Keller if (enable) 1153109aba47SJacob Keller err = ice_vsi_ena_spoofchk(vsi); 1154109aba47SJacob Keller else 1155109aba47SJacob Keller err = ice_vsi_dis_spoofchk(vsi); 1156109aba47SJacob Keller 1157109aba47SJacob Keller return err; 1158109aba47SJacob Keller } 1159109aba47SJacob Keller 1160109aba47SJacob Keller /** 1161109aba47SJacob Keller * ice_is_vf_trusted 1162109aba47SJacob Keller * @vf: pointer to the VF info 1163109aba47SJacob Keller */ 1164109aba47SJacob Keller bool ice_is_vf_trusted(struct ice_vf *vf) 1165109aba47SJacob Keller { 1166109aba47SJacob Keller return test_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps); 1167109aba47SJacob Keller } 1168109aba47SJacob Keller 1169109aba47SJacob Keller /** 1170109aba47SJacob Keller * ice_vf_has_no_qs_ena - check if the VF has any Rx or Tx queues enabled 1171109aba47SJacob Keller * @vf: the VF to check 1172109aba47SJacob Keller * 1173109aba47SJacob Keller * Returns true if the VF has no Rx and no Tx queues enabled and returns false 1174109aba47SJacob Keller * otherwise 1175109aba47SJacob Keller */ 1176109aba47SJacob Keller bool ice_vf_has_no_qs_ena(struct ice_vf *vf) 1177109aba47SJacob Keller { 1178109aba47SJacob Keller return (!bitmap_weight(vf->rxq_ena, ICE_MAX_RSS_QS_PER_VF) && 1179109aba47SJacob Keller !bitmap_weight(vf->txq_ena, ICE_MAX_RSS_QS_PER_VF)); 1180109aba47SJacob Keller } 1181109aba47SJacob Keller 1182109aba47SJacob Keller /** 1183109aba47SJacob Keller * ice_is_vf_link_up - check if the VF's link is up 1184109aba47SJacob Keller * @vf: VF to check if link is up 1185109aba47SJacob Keller */ 1186109aba47SJacob Keller bool ice_is_vf_link_up(struct ice_vf *vf) 1187109aba47SJacob Keller { 11885a57ee83SJacob Keller struct ice_port_info *pi = ice_vf_get_port_info(vf); 1189109aba47SJacob Keller 11905a57ee83SJacob Keller if (ice_check_vf_init(vf)) 1191109aba47SJacob Keller return false; 1192109aba47SJacob Keller 1193109aba47SJacob Keller if (ice_vf_has_no_qs_ena(vf)) 1194109aba47SJacob Keller return false; 1195109aba47SJacob Keller else if (vf->link_forced) 1196109aba47SJacob Keller return vf->link_up; 1197109aba47SJacob Keller else 11985a57ee83SJacob Keller return pi->phy.link_info.link_info & 1199109aba47SJacob Keller ICE_AQ_LINK_UP; 1200109aba47SJacob Keller } 1201109aba47SJacob Keller 1202109aba47SJacob Keller /** 1203109aba47SJacob Keller * ice_vf_ctrl_invalidate_vsi - invalidate ctrl_vsi_idx to remove VSI access 1204109aba47SJacob Keller * @vf: VF that control VSI is being invalidated on 1205109aba47SJacob Keller */ 1206109aba47SJacob Keller void ice_vf_ctrl_invalidate_vsi(struct ice_vf *vf) 1207109aba47SJacob Keller { 1208109aba47SJacob Keller vf->ctrl_vsi_idx = ICE_NO_VSI; 1209109aba47SJacob Keller } 1210109aba47SJacob Keller 1211109aba47SJacob Keller /** 1212109aba47SJacob Keller * ice_vf_ctrl_vsi_release - invalidate the VF's control VSI after freeing it 1213109aba47SJacob Keller * @vf: VF that control VSI is being released on 1214109aba47SJacob Keller */ 1215109aba47SJacob Keller void ice_vf_ctrl_vsi_release(struct ice_vf *vf) 1216109aba47SJacob Keller { 1217109aba47SJacob Keller ice_vsi_release(vf->pf->vsi[vf->ctrl_vsi_idx]); 1218109aba47SJacob Keller ice_vf_ctrl_invalidate_vsi(vf); 1219109aba47SJacob Keller } 1220109aba47SJacob Keller 1221109aba47SJacob Keller /** 1222109aba47SJacob Keller * ice_vf_ctrl_vsi_setup - Set up a VF control VSI 1223109aba47SJacob Keller * @vf: VF to setup control VSI for 1224109aba47SJacob Keller * 1225109aba47SJacob Keller * Returns pointer to the successfully allocated VSI struct on success, 1226109aba47SJacob Keller * otherwise returns NULL on failure. 1227109aba47SJacob Keller */ 1228109aba47SJacob Keller struct ice_vsi *ice_vf_ctrl_vsi_setup(struct ice_vf *vf) 1229109aba47SJacob Keller { 12305e509ab2SJacob Keller struct ice_vsi_cfg_params params = {}; 1231109aba47SJacob Keller struct ice_pf *pf = vf->pf; 1232109aba47SJacob Keller struct ice_vsi *vsi; 1233109aba47SJacob Keller 12345e509ab2SJacob Keller params.type = ICE_VSI_CTRL; 12355e509ab2SJacob Keller params.pi = ice_vf_get_port_info(vf); 12365e509ab2SJacob Keller params.vf = vf; 12375e509ab2SJacob Keller params.flags = ICE_VSI_FLAG_INIT; 12385e509ab2SJacob Keller 12395e509ab2SJacob Keller vsi = ice_vsi_setup(pf, ¶ms); 1240109aba47SJacob Keller if (!vsi) { 1241109aba47SJacob Keller dev_err(ice_pf_to_dev(pf), "Failed to create VF control VSI\n"); 1242109aba47SJacob Keller ice_vf_ctrl_invalidate_vsi(vf); 1243109aba47SJacob Keller } 1244109aba47SJacob Keller 1245109aba47SJacob Keller return vsi; 1246109aba47SJacob Keller } 1247109aba47SJacob Keller 1248109aba47SJacob Keller /** 1249b1b56942SJacob Keller * ice_vf_init_host_cfg - Initialize host admin configuration 1250b1b56942SJacob Keller * @vf: VF to initialize 1251b1b56942SJacob Keller * @vsi: the VSI created at initialization 1252b1b56942SJacob Keller * 1253b1b56942SJacob Keller * Initialize the VF host configuration. Called during VF creation to setup 1254b1b56942SJacob Keller * VLAN 0, add the VF VSI broadcast filter, and setup spoof checking. It 1255b1b56942SJacob Keller * should only be called during VF creation. 1256b1b56942SJacob Keller */ 1257b1b56942SJacob Keller int ice_vf_init_host_cfg(struct ice_vf *vf, struct ice_vsi *vsi) 1258b1b56942SJacob Keller { 1259b1b56942SJacob Keller struct ice_vsi_vlan_ops *vlan_ops; 1260b1b56942SJacob Keller struct ice_pf *pf = vf->pf; 1261b1b56942SJacob Keller u8 broadcast[ETH_ALEN]; 1262b1b56942SJacob Keller struct device *dev; 1263b1b56942SJacob Keller int err; 1264b1b56942SJacob Keller 1265b1b56942SJacob Keller dev = ice_pf_to_dev(pf); 1266b1b56942SJacob Keller 1267b1b56942SJacob Keller err = ice_vsi_add_vlan_zero(vsi); 1268b1b56942SJacob Keller if (err) { 1269b1b56942SJacob Keller dev_warn(dev, "Failed to add VLAN 0 filter for VF %d\n", 1270b1b56942SJacob Keller vf->vf_id); 1271b1b56942SJacob Keller return err; 1272b1b56942SJacob Keller } 1273b1b56942SJacob Keller 1274b1b56942SJacob Keller vlan_ops = ice_get_compat_vsi_vlan_ops(vsi); 1275b1b56942SJacob Keller err = vlan_ops->ena_rx_filtering(vsi); 1276b1b56942SJacob Keller if (err) { 1277b1b56942SJacob Keller dev_warn(dev, "Failed to enable Rx VLAN filtering for VF %d\n", 1278b1b56942SJacob Keller vf->vf_id); 1279b1b56942SJacob Keller return err; 1280b1b56942SJacob Keller } 1281b1b56942SJacob Keller 1282b1b56942SJacob Keller eth_broadcast_addr(broadcast); 1283b1b56942SJacob Keller err = ice_fltr_add_mac(vsi, broadcast, ICE_FWD_TO_VSI); 1284b1b56942SJacob Keller if (err) { 1285b1b56942SJacob Keller dev_err(dev, "Failed to add broadcast MAC filter for VF %d, status %d\n", 1286b1b56942SJacob Keller vf->vf_id, err); 1287b1b56942SJacob Keller return err; 1288b1b56942SJacob Keller } 1289b1b56942SJacob Keller 1290b1b56942SJacob Keller vf->num_mac = 1; 1291b1b56942SJacob Keller 1292b1b56942SJacob Keller err = ice_vsi_apply_spoofchk(vsi, vf->spoofchk); 1293b1b56942SJacob Keller if (err) { 1294b1b56942SJacob Keller dev_warn(dev, "Failed to initialize spoofchk setting for VF %d\n", 1295b1b56942SJacob Keller vf->vf_id); 1296b1b56942SJacob Keller return err; 1297b1b56942SJacob Keller } 1298b1b56942SJacob Keller 1299b1b56942SJacob Keller return 0; 1300b1b56942SJacob Keller } 1301b1b56942SJacob Keller 1302b1b56942SJacob Keller /** 1303109aba47SJacob Keller * ice_vf_invalidate_vsi - invalidate vsi_idx/vsi_num to remove VSI access 1304109aba47SJacob Keller * @vf: VF to remove access to VSI for 1305109aba47SJacob Keller */ 1306109aba47SJacob Keller void ice_vf_invalidate_vsi(struct ice_vf *vf) 1307109aba47SJacob Keller { 1308109aba47SJacob Keller vf->lan_vsi_idx = ICE_NO_VSI; 1309109aba47SJacob Keller vf->lan_vsi_num = ICE_NO_VSI; 1310109aba47SJacob Keller } 1311109aba47SJacob Keller 1312109aba47SJacob Keller /** 13131efee073SJacob Keller * ice_vf_vsi_release - Release the VF VSI and invalidate indexes 13141efee073SJacob Keller * @vf: pointer to the VF structure 13151efee073SJacob Keller * 13161efee073SJacob Keller * Release the VF associated with this VSI and then invalidate the VSI 13171efee073SJacob Keller * indexes. 13181efee073SJacob Keller */ 13191efee073SJacob Keller void ice_vf_vsi_release(struct ice_vf *vf) 13201efee073SJacob Keller { 13211efee073SJacob Keller struct ice_vsi *vsi = ice_get_vf_vsi(vf); 13221efee073SJacob Keller 13231efee073SJacob Keller if (WARN_ON(!vsi)) 13241efee073SJacob Keller return; 13251efee073SJacob Keller 13261efee073SJacob Keller ice_vsi_release(vsi); 13271efee073SJacob Keller ice_vf_invalidate_vsi(vf); 13281efee073SJacob Keller } 13291efee073SJacob Keller 13301efee073SJacob Keller /** 1331369bb5a2SPiotr Raczynski * ice_get_vf_ctrl_vsi - Get first VF control VSI pointer 1332369bb5a2SPiotr Raczynski * @pf: the PF private structure 1333369bb5a2SPiotr Raczynski * @vsi: pointer to the VSI 1334369bb5a2SPiotr Raczynski * 1335369bb5a2SPiotr Raczynski * Return first found VF control VSI other than the vsi 1336369bb5a2SPiotr Raczynski * passed by parameter. This function is used to determine 1337369bb5a2SPiotr Raczynski * whether new resources have to be allocated for control VSI 1338369bb5a2SPiotr Raczynski * or they can be shared with existing one. 1339369bb5a2SPiotr Raczynski * 1340369bb5a2SPiotr Raczynski * Return found VF control VSI pointer other itself. Return 1341369bb5a2SPiotr Raczynski * NULL Otherwise. 1342369bb5a2SPiotr Raczynski * 1343369bb5a2SPiotr Raczynski */ 1344369bb5a2SPiotr Raczynski struct ice_vsi *ice_get_vf_ctrl_vsi(struct ice_pf *pf, struct ice_vsi *vsi) 1345369bb5a2SPiotr Raczynski { 1346369bb5a2SPiotr Raczynski struct ice_vsi *ctrl_vsi = NULL; 1347369bb5a2SPiotr Raczynski struct ice_vf *vf; 1348369bb5a2SPiotr Raczynski unsigned int bkt; 1349369bb5a2SPiotr Raczynski 1350369bb5a2SPiotr Raczynski rcu_read_lock(); 1351369bb5a2SPiotr Raczynski ice_for_each_vf_rcu(pf, bkt, vf) { 1352369bb5a2SPiotr Raczynski if (vf != vsi->vf && vf->ctrl_vsi_idx != ICE_NO_VSI) { 1353369bb5a2SPiotr Raczynski ctrl_vsi = pf->vsi[vf->ctrl_vsi_idx]; 1354369bb5a2SPiotr Raczynski break; 1355369bb5a2SPiotr Raczynski } 1356369bb5a2SPiotr Raczynski } 1357369bb5a2SPiotr Raczynski 1358369bb5a2SPiotr Raczynski rcu_read_unlock(); 1359369bb5a2SPiotr Raczynski return ctrl_vsi; 1360369bb5a2SPiotr Raczynski } 1361