From: Przemek Kitszel Remove final portion of the stuff that stays within virtchnl.c, (separate commits to have nicer, removal-only, history). Signed-off-by: Przemek Kitszel Signed-off-by: Tony Nguyen --- drivers/net/ethernet/intel/ice/virt/queues.c | 2392 ------------------ 1 file changed, 2392 deletions(-) diff --git a/drivers/net/ethernet/intel/ice/virt/queues.c b/drivers/net/ethernet/intel/ice/virt/queues.c index c1da10aa2151..7544580ccc37 100644 --- a/drivers/net/ethernet/intel/ice/virt/queues.c +++ b/drivers/net/ethernet/intel/ice/virt/queues.c @@ -912,379 +912,6 @@ static int ice_vc_cfg_qs_msg(struct ice_vf *vf, u8 *msg) VIRTCHNL_STATUS_ERR_PARAM, NULL, 0); } -/** - * ice_can_vf_change_mac - * @vf: pointer to the VF info - * - * Return true if the VF is allowed to change its MAC filters, false otherwise - */ -static bool ice_can_vf_change_mac(struct ice_vf *vf) -{ - /* If the VF MAC address has been set administratively (via the - * ndo_set_vf_mac command), then deny permission to the VF to - * add/delete unicast MAC addresses, unless the VF is trusted - */ - if (vf->pf_set_mac && !ice_is_vf_trusted(vf)) - return false; - - return true; -} - -/** - * ice_vc_ether_addr_type - get type of virtchnl_ether_addr - * @vc_ether_addr: used to extract the type - */ -static u8 -ice_vc_ether_addr_type(struct virtchnl_ether_addr *vc_ether_addr) -{ - return (vc_ether_addr->type & VIRTCHNL_ETHER_ADDR_TYPE_MASK); -} - -/** - * ice_is_vc_addr_legacy - check if the MAC address is from an older VF - * @vc_ether_addr: VIRTCHNL structure that contains MAC and type - */ -static bool -ice_is_vc_addr_legacy(struct virtchnl_ether_addr *vc_ether_addr) -{ - u8 type = ice_vc_ether_addr_type(vc_ether_addr); - - return (type == VIRTCHNL_ETHER_ADDR_LEGACY); -} - -/** - * ice_is_vc_addr_primary - check if the MAC address is the VF's primary MAC - * @vc_ether_addr: VIRTCHNL structure that contains MAC and type - * - * This function should only be called when the MAC address in - * virtchnl_ether_addr is a valid unicast MAC - */ -static bool -ice_is_vc_addr_primary(struct virtchnl_ether_addr __maybe_unused *vc_ether_addr) -{ - u8 type = ice_vc_ether_addr_type(vc_ether_addr); - - return (type == VIRTCHNL_ETHER_ADDR_PRIMARY); -} - -/** - * ice_vfhw_mac_add - update the VF's cached hardware MAC if allowed - * @vf: VF to update - * @vc_ether_addr: structure from VIRTCHNL with MAC to add - */ -static void -ice_vfhw_mac_add(struct ice_vf *vf, struct virtchnl_ether_addr *vc_ether_addr) -{ - u8 *mac_addr = vc_ether_addr->addr; - - if (!is_valid_ether_addr(mac_addr)) - return; - - /* only allow legacy VF drivers to set the device and hardware MAC if it - * is zero and allow new VF drivers to set the hardware MAC if the type - * was correctly specified over VIRTCHNL - */ - if ((ice_is_vc_addr_legacy(vc_ether_addr) && - is_zero_ether_addr(vf->hw_lan_addr)) || - ice_is_vc_addr_primary(vc_ether_addr)) { - ether_addr_copy(vf->dev_lan_addr, mac_addr); - ether_addr_copy(vf->hw_lan_addr, mac_addr); - } - - /* hardware and device MACs are already set, but its possible that the - * VF driver sent the VIRTCHNL_OP_ADD_ETH_ADDR message before the - * VIRTCHNL_OP_DEL_ETH_ADDR when trying to update its MAC, so save it - * away for the legacy VF driver case as it will be updated in the - * delete flow for this case - */ - if (ice_is_vc_addr_legacy(vc_ether_addr)) { - ether_addr_copy(vf->legacy_last_added_umac.addr, - mac_addr); - vf->legacy_last_added_umac.time_modified = jiffies; - } -} - -/** - * ice_is_mc_lldp_eth_addr - check if the given MAC is a multicast LLDP address - * @mac: address to check - * - * Return: true if the address is one of the three possible LLDP multicast - * addresses, false otherwise. - */ -static bool ice_is_mc_lldp_eth_addr(const u8 *mac) -{ - const u8 lldp_mac_base[] = {0x01, 0x80, 0xc2, 0x00, 0x00}; - - if (memcmp(mac, lldp_mac_base, sizeof(lldp_mac_base))) - return false; - - return (mac[5] == 0x0e || mac[5] == 0x03 || mac[5] == 0x00); -} - -/** - * ice_vc_can_add_mac - check if the VF is allowed to add a given MAC - * @vf: a VF to add the address to - * @mac: address to check - * - * Return: true if the VF is allowed to add such MAC address, false otherwise. - */ -static bool ice_vc_can_add_mac(const struct ice_vf *vf, const u8 *mac) -{ - struct device *dev = ice_pf_to_dev(vf->pf); - - if (is_unicast_ether_addr(mac) && - !ice_can_vf_change_mac((struct ice_vf *)vf)) { - dev_err(dev, - "VF attempting to override administratively set MAC address, bring down and up the VF interface to resume normal operation\n"); - return false; - } - - if (!vf->trusted && ice_is_mc_lldp_eth_addr(mac)) { - dev_warn(dev, - "An untrusted VF %u is attempting to configure an LLDP multicast address\n", - vf->vf_id); - return false; - } - - return true; -} - -/** - * ice_vc_add_mac_addr - attempt to add the MAC address passed in - * @vf: pointer to the VF info - * @vsi: pointer to the VF's VSI - * @vc_ether_addr: VIRTCHNL MAC address structure used to add MAC - */ -static int -ice_vc_add_mac_addr(struct ice_vf *vf, struct ice_vsi *vsi, - struct virtchnl_ether_addr *vc_ether_addr) -{ - struct device *dev = ice_pf_to_dev(vf->pf); - u8 *mac_addr = vc_ether_addr->addr; - int ret; - - /* device MAC already added */ - if (ether_addr_equal(mac_addr, vf->dev_lan_addr)) - return 0; - - if (!ice_vc_can_add_mac(vf, mac_addr)) - return -EPERM; - - ret = ice_fltr_add_mac(vsi, mac_addr, ICE_FWD_TO_VSI); - if (ret == -EEXIST) { - dev_dbg(dev, "MAC %pM already exists for VF %d\n", mac_addr, - vf->vf_id); - /* don't return since we might need to update - * the primary MAC in ice_vfhw_mac_add() below - */ - } else if (ret) { - dev_err(dev, "Failed to add MAC %pM for VF %d\n, error %d\n", - mac_addr, vf->vf_id, ret); - return ret; - } else { - vf->num_mac++; - if (ice_is_mc_lldp_eth_addr(mac_addr)) - ice_vf_update_mac_lldp_num(vf, vsi, true); - } - - ice_vfhw_mac_add(vf, vc_ether_addr); - - return ret; -} - -/** - * ice_is_legacy_umac_expired - check if last added legacy unicast MAC expired - * @last_added_umac: structure used to check expiration - */ -static bool ice_is_legacy_umac_expired(struct ice_time_mac *last_added_umac) -{ -#define ICE_LEGACY_VF_MAC_CHANGE_EXPIRE_TIME msecs_to_jiffies(3000) - return time_is_before_jiffies(last_added_umac->time_modified + - ICE_LEGACY_VF_MAC_CHANGE_EXPIRE_TIME); -} - -/** - * ice_update_legacy_cached_mac - update cached hardware MAC for legacy VF - * @vf: VF to update - * @vc_ether_addr: structure from VIRTCHNL with MAC to check - * - * only update cached hardware MAC for legacy VF drivers on delete - * because we cannot guarantee order/type of MAC from the VF driver - */ -static void -ice_update_legacy_cached_mac(struct ice_vf *vf, - struct virtchnl_ether_addr *vc_ether_addr) -{ - if (!ice_is_vc_addr_legacy(vc_ether_addr) || - ice_is_legacy_umac_expired(&vf->legacy_last_added_umac)) - return; - - ether_addr_copy(vf->dev_lan_addr, vf->legacy_last_added_umac.addr); - ether_addr_copy(vf->hw_lan_addr, vf->legacy_last_added_umac.addr); -} - -/** - * ice_vfhw_mac_del - update the VF's cached hardware MAC if allowed - * @vf: VF to update - * @vc_ether_addr: structure from VIRTCHNL with MAC to delete - */ -static void -ice_vfhw_mac_del(struct ice_vf *vf, struct virtchnl_ether_addr *vc_ether_addr) -{ - u8 *mac_addr = vc_ether_addr->addr; - - if (!is_valid_ether_addr(mac_addr) || - !ether_addr_equal(vf->dev_lan_addr, mac_addr)) - return; - - /* allow the device MAC to be repopulated in the add flow and don't - * clear the hardware MAC (i.e. hw_lan_addr) here as that is meant - * to be persistent on VM reboot and across driver unload/load, which - * won't work if we clear the hardware MAC here - */ - eth_zero_addr(vf->dev_lan_addr); - - ice_update_legacy_cached_mac(vf, vc_ether_addr); -} - -/** - * ice_vc_del_mac_addr - attempt to delete the MAC address passed in - * @vf: pointer to the VF info - * @vsi: pointer to the VF's VSI - * @vc_ether_addr: VIRTCHNL MAC address structure used to delete MAC - */ -static int -ice_vc_del_mac_addr(struct ice_vf *vf, struct ice_vsi *vsi, - struct virtchnl_ether_addr *vc_ether_addr) -{ - struct device *dev = ice_pf_to_dev(vf->pf); - u8 *mac_addr = vc_ether_addr->addr; - int status; - - if (!ice_can_vf_change_mac(vf) && - ether_addr_equal(vf->dev_lan_addr, mac_addr)) - return 0; - - status = ice_fltr_remove_mac(vsi, mac_addr, ICE_FWD_TO_VSI); - if (status == -ENOENT) { - dev_err(dev, "MAC %pM does not exist for VF %d\n", mac_addr, - vf->vf_id); - return -ENOENT; - } else if (status) { - dev_err(dev, "Failed to delete MAC %pM for VF %d, error %d\n", - mac_addr, vf->vf_id, status); - return -EIO; - } - - ice_vfhw_mac_del(vf, vc_ether_addr); - - vf->num_mac--; - if (ice_is_mc_lldp_eth_addr(mac_addr)) - ice_vf_update_mac_lldp_num(vf, vsi, false); - - return 0; -} - -/** - * ice_vc_handle_mac_addr_msg - * @vf: pointer to the VF info - * @msg: pointer to the msg buffer - * @set: true if MAC filters are being set, false otherwise - * - * add guest MAC address filter - */ -static int -ice_vc_handle_mac_addr_msg(struct ice_vf *vf, u8 *msg, bool set) -{ - int (*ice_vc_cfg_mac) - (struct ice_vf *vf, struct ice_vsi *vsi, - struct virtchnl_ether_addr *virtchnl_ether_addr); - enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS; - struct virtchnl_ether_addr_list *al = - (struct virtchnl_ether_addr_list *)msg; - struct ice_pf *pf = vf->pf; - enum virtchnl_ops vc_op; - struct ice_vsi *vsi; - int i; - - if (set) { - vc_op = VIRTCHNL_OP_ADD_ETH_ADDR; - ice_vc_cfg_mac = ice_vc_add_mac_addr; - } else { - vc_op = VIRTCHNL_OP_DEL_ETH_ADDR; - ice_vc_cfg_mac = ice_vc_del_mac_addr; - } - - if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states) || - !ice_vc_isvalid_vsi_id(vf, al->vsi_id)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto handle_mac_exit; - } - - /* If this VF is not privileged, then we can't add more than a - * limited number of addresses. Check to make sure that the - * additions do not push us over the limit. - */ - if (set && !ice_is_vf_trusted(vf) && - (vf->num_mac + al->num_elements) > ICE_MAX_MACADDR_PER_VF) { - dev_err(ice_pf_to_dev(pf), "Can't add more MAC addresses, because VF-%d is not trusted, switch the VF to trusted mode in order to add more functionalities\n", - vf->vf_id); - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto handle_mac_exit; - } - - vsi = ice_get_vf_vsi(vf); - if (!vsi) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto handle_mac_exit; - } - - for (i = 0; i < al->num_elements; i++) { - u8 *mac_addr = al->list[i].addr; - int result; - - if (is_broadcast_ether_addr(mac_addr) || - is_zero_ether_addr(mac_addr)) - continue; - - result = ice_vc_cfg_mac(vf, vsi, &al->list[i]); - if (result == -EEXIST || result == -ENOENT) { - continue; - } else if (result) { - v_ret = VIRTCHNL_STATUS_ERR_ADMIN_QUEUE_ERROR; - goto handle_mac_exit; - } - } - -handle_mac_exit: - /* send the response to the VF */ - return ice_vc_send_msg_to_vf(vf, vc_op, v_ret, NULL, 0); -} - -/** - * ice_vc_add_mac_addr_msg - * @vf: pointer to the VF info - * @msg: pointer to the msg buffer - * - * add guest MAC address filter - */ -static int ice_vc_add_mac_addr_msg(struct ice_vf *vf, u8 *msg) -{ - return ice_vc_handle_mac_addr_msg(vf, msg, true); -} - -/** - * ice_vc_del_mac_addr_msg - * @vf: pointer to the VF info - * @msg: pointer to the msg buffer - * - * remove guest MAC address filter - */ -static int ice_vc_del_mac_addr_msg(struct ice_vf *vf, u8 *msg) -{ - return ice_vc_handle_mac_addr_msg(vf, msg, false); -} - /** * ice_vc_request_qs_msg * @vf: pointer to the VF info @@ -1345,2022 +972,3 @@ static int ice_vc_request_qs_msg(struct ice_vf *vf, u8 *msg) v_ret, (u8 *)vfres, sizeof(*vfres)); } -/** - * ice_vf_vlan_offload_ena - determine if capabilities support VLAN offloads - * @caps: VF driver negotiated capabilities - * - * Return true if VIRTCHNL_VF_OFFLOAD_VLAN capability is set, else return false - */ -static bool ice_vf_vlan_offload_ena(u32 caps) -{ - return !!(caps & VIRTCHNL_VF_OFFLOAD_VLAN); -} - -/** - * ice_is_vlan_promisc_allowed - check if VLAN promiscuous config is allowed - * @vf: VF used to determine if VLAN promiscuous config is allowed - */ -bool ice_is_vlan_promisc_allowed(struct ice_vf *vf) -{ - if ((test_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states) || - test_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states)) && - test_bit(ICE_FLAG_VF_TRUE_PROMISC_ENA, vf->pf->flags)) - return true; - - return false; -} - -/** - * ice_vf_ena_vlan_promisc - Enable Tx/Rx VLAN promiscuous for the VLAN - * @vf: VF to enable VLAN promisc on - * @vsi: VF's VSI used to enable VLAN promiscuous mode - * @vlan: VLAN used to enable VLAN promiscuous - * - * This function should only be called if VLAN promiscuous mode is allowed, - * which can be determined via ice_is_vlan_promisc_allowed(). - */ -int ice_vf_ena_vlan_promisc(struct ice_vf *vf, struct ice_vsi *vsi, - struct ice_vlan *vlan) -{ - u8 promisc_m = 0; - int status; - - if (test_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states)) - promisc_m |= ICE_UCAST_VLAN_PROMISC_BITS; - if (test_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states)) - promisc_m |= ICE_MCAST_VLAN_PROMISC_BITS; - - if (!promisc_m) - return 0; - - status = ice_fltr_set_vsi_promisc(&vsi->back->hw, vsi->idx, promisc_m, - vlan->vid); - if (status && status != -EEXIST) - return status; - - return 0; -} - -/** - * ice_vf_dis_vlan_promisc - Disable Tx/Rx VLAN promiscuous for the VLAN - * @vsi: VF's VSI used to disable VLAN promiscuous mode for - * @vlan: VLAN used to disable VLAN promiscuous - * - * This function should only be called if VLAN promiscuous mode is allowed, - * which can be determined via ice_is_vlan_promisc_allowed(). - */ -static int ice_vf_dis_vlan_promisc(struct ice_vsi *vsi, struct ice_vlan *vlan) -{ - u8 promisc_m = ICE_UCAST_VLAN_PROMISC_BITS | ICE_MCAST_VLAN_PROMISC_BITS; - int status; - - status = ice_fltr_clear_vsi_promisc(&vsi->back->hw, vsi->idx, promisc_m, - vlan->vid); - if (status && status != -ENOENT) - return status; - - return 0; -} - -/** - * ice_vf_has_max_vlans - check if VF already has the max allowed VLAN filters - * @vf: VF to check against - * @vsi: VF's VSI - * - * If the VF is trusted then the VF is allowed to add as many VLANs as it - * wants to, so return false. - * - * When the VF is untrusted compare the number of non-zero VLANs + 1 to the max - * allowed VLANs for an untrusted VF. Return the result of this comparison. - */ -static bool ice_vf_has_max_vlans(struct ice_vf *vf, struct ice_vsi *vsi) -{ - if (ice_is_vf_trusted(vf)) - return false; - -#define ICE_VF_ADDED_VLAN_ZERO_FLTRS 1 - return ((ice_vsi_num_non_zero_vlans(vsi) + - ICE_VF_ADDED_VLAN_ZERO_FLTRS) >= ICE_MAX_VLAN_PER_VF); -} - -/** - * ice_vc_process_vlan_msg - * @vf: pointer to the VF info - * @msg: pointer to the msg buffer - * @add_v: Add VLAN if true, otherwise delete VLAN - * - * Process virtchnl op to add or remove programmed guest VLAN ID - */ -static int ice_vc_process_vlan_msg(struct ice_vf *vf, u8 *msg, bool add_v) -{ - enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS; - struct virtchnl_vlan_filter_list *vfl = - (struct virtchnl_vlan_filter_list *)msg; - struct ice_pf *pf = vf->pf; - bool vlan_promisc = false; - struct ice_vsi *vsi; - struct device *dev; - int status = 0; - int i; - - dev = ice_pf_to_dev(pf); - if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto error_param; - } - - if (!ice_vf_vlan_offload_ena(vf->driver_caps)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto error_param; - } - - if (!ice_vc_isvalid_vsi_id(vf, vfl->vsi_id)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto error_param; - } - - for (i = 0; i < vfl->num_elements; i++) { - if (vfl->vlan_id[i] >= VLAN_N_VID) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - dev_err(dev, "invalid VF VLAN id %d\n", - vfl->vlan_id[i]); - goto error_param; - } - } - - vsi = ice_get_vf_vsi(vf); - if (!vsi) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto error_param; - } - - if (add_v && ice_vf_has_max_vlans(vf, vsi)) { - dev_info(dev, "VF-%d is not trusted, switch the VF to trusted mode, in order to add more VLAN addresses\n", - vf->vf_id); - /* There is no need to let VF know about being not trusted, - * so we can just return success message here - */ - goto error_param; - } - - /* in DVM a VF can add/delete inner VLAN filters when - * VIRTCHNL_VF_OFFLOAD_VLAN is negotiated, so only reject in SVM - */ - if (ice_vf_is_port_vlan_ena(vf) && !ice_is_dvm_ena(&pf->hw)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto error_param; - } - - /* in DVM VLAN promiscuous is based on the outer VLAN, which would be - * the port VLAN if VIRTCHNL_VF_OFFLOAD_VLAN was negotiated, so only - * allow vlan_promisc = true in SVM and if no port VLAN is configured - */ - vlan_promisc = ice_is_vlan_promisc_allowed(vf) && - !ice_is_dvm_ena(&pf->hw) && - !ice_vf_is_port_vlan_ena(vf); - - if (add_v) { - for (i = 0; i < vfl->num_elements; i++) { - u16 vid = vfl->vlan_id[i]; - struct ice_vlan vlan; - - if (ice_vf_has_max_vlans(vf, vsi)) { - dev_info(dev, "VF-%d is not trusted, switch the VF to trusted mode, in order to add more VLAN addresses\n", - vf->vf_id); - /* There is no need to let VF know about being - * not trusted, so we can just return success - * message here as well. - */ - goto error_param; - } - - /* we add VLAN 0 by default for each VF so we can enable - * Tx VLAN anti-spoof without triggering MDD events so - * we don't need to add it again here - */ - if (!vid) - continue; - - vlan = ICE_VLAN(ETH_P_8021Q, vid, 0); - status = vsi->inner_vlan_ops.add_vlan(vsi, &vlan); - if (status) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto error_param; - } - - /* Enable VLAN filtering on first non-zero VLAN */ - if (!vlan_promisc && vid && !ice_is_dvm_ena(&pf->hw)) { - if (vf->spoofchk) { - status = vsi->inner_vlan_ops.ena_tx_filtering(vsi); - if (status) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - dev_err(dev, "Enable VLAN anti-spoofing on VLAN ID: %d failed error-%d\n", - vid, status); - goto error_param; - } - } - if (vsi->inner_vlan_ops.ena_rx_filtering(vsi)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - dev_err(dev, "Enable VLAN pruning on VLAN ID: %d failed error-%d\n", - vid, status); - goto error_param; - } - } else if (vlan_promisc) { - status = ice_vf_ena_vlan_promisc(vf, vsi, &vlan); - if (status) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - dev_err(dev, "Enable Unicast/multicast promiscuous mode on VLAN ID:%d failed error-%d\n", - vid, status); - } - } - } - } else { - /* In case of non_trusted VF, number of VLAN elements passed - * to PF for removal might be greater than number of VLANs - * filter programmed for that VF - So, use actual number of - * VLANS added earlier with add VLAN opcode. In order to avoid - * removing VLAN that doesn't exist, which result to sending - * erroneous failed message back to the VF - */ - int num_vf_vlan; - - num_vf_vlan = vsi->num_vlan; - for (i = 0; i < vfl->num_elements && i < num_vf_vlan; i++) { - u16 vid = vfl->vlan_id[i]; - struct ice_vlan vlan; - - /* we add VLAN 0 by default for each VF so we can enable - * Tx VLAN anti-spoof without triggering MDD events so - * we don't want a VIRTCHNL request to remove it - */ - if (!vid) - continue; - - vlan = ICE_VLAN(ETH_P_8021Q, vid, 0); - status = vsi->inner_vlan_ops.del_vlan(vsi, &vlan); - if (status) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto error_param; - } - - /* Disable VLAN filtering when only VLAN 0 is left */ - if (!ice_vsi_has_non_zero_vlans(vsi)) { - vsi->inner_vlan_ops.dis_tx_filtering(vsi); - vsi->inner_vlan_ops.dis_rx_filtering(vsi); - } - - if (vlan_promisc) - ice_vf_dis_vlan_promisc(vsi, &vlan); - } - } - -error_param: - /* send the response to the VF */ - if (add_v) - return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_ADD_VLAN, v_ret, - NULL, 0); - else - return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_DEL_VLAN, v_ret, - NULL, 0); -} - -/** - * ice_vc_add_vlan_msg - * @vf: pointer to the VF info - * @msg: pointer to the msg buffer - * - * Add and program guest VLAN ID - */ -static int ice_vc_add_vlan_msg(struct ice_vf *vf, u8 *msg) -{ - return ice_vc_process_vlan_msg(vf, msg, true); -} - -/** - * ice_vc_remove_vlan_msg - * @vf: pointer to the VF info - * @msg: pointer to the msg buffer - * - * remove programmed guest VLAN ID - */ -static int ice_vc_remove_vlan_msg(struct ice_vf *vf, u8 *msg) -{ - return ice_vc_process_vlan_msg(vf, msg, false); -} - -/** - * ice_vsi_is_rxq_crc_strip_dis - check if Rx queue CRC strip is disabled or not - * @vsi: pointer to the VF VSI info - */ -static bool ice_vsi_is_rxq_crc_strip_dis(struct ice_vsi *vsi) -{ - unsigned int i; - - ice_for_each_alloc_rxq(vsi, i) - if (vsi->rx_rings[i]->flags & ICE_RX_FLAGS_CRC_STRIP_DIS) - return true; - - return false; -} - -/** - * ice_vc_ena_vlan_stripping - * @vf: pointer to the VF info - * - * Enable VLAN header stripping for a given VF - */ -static int ice_vc_ena_vlan_stripping(struct ice_vf *vf) -{ - enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS; - struct ice_vsi *vsi; - - if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto error_param; - } - - if (!ice_vf_vlan_offload_ena(vf->driver_caps)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto error_param; - } - - vsi = ice_get_vf_vsi(vf); - if (!vsi) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto error_param; - } - - if (vsi->inner_vlan_ops.ena_stripping(vsi, ETH_P_8021Q)) - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - else - vf->vlan_strip_ena |= ICE_INNER_VLAN_STRIP_ENA; - -error_param: - return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_ENABLE_VLAN_STRIPPING, - v_ret, NULL, 0); -} - -/** - * ice_vc_dis_vlan_stripping - * @vf: pointer to the VF info - * - * Disable VLAN header stripping for a given VF - */ -static int ice_vc_dis_vlan_stripping(struct ice_vf *vf) -{ - enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS; - struct ice_vsi *vsi; - - if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto error_param; - } - - if (!ice_vf_vlan_offload_ena(vf->driver_caps)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto error_param; - } - - vsi = ice_get_vf_vsi(vf); - if (!vsi) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto error_param; - } - - if (vsi->inner_vlan_ops.dis_stripping(vsi)) - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - else - vf->vlan_strip_ena &= ~ICE_INNER_VLAN_STRIP_ENA; - -error_param: - return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_DISABLE_VLAN_STRIPPING, - v_ret, NULL, 0); -} - -/** - * ice_vc_get_rss_hashcfg - return the RSS Hash configuration - * @vf: pointer to the VF info - */ -static int ice_vc_get_rss_hashcfg(struct ice_vf *vf) -{ - enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS; - struct virtchnl_rss_hashcfg *vrh = NULL; - int len = 0, ret; - - if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto err; - } - - if (!test_bit(ICE_FLAG_RSS_ENA, vf->pf->flags)) { - dev_err(ice_pf_to_dev(vf->pf), "RSS not supported by PF\n"); - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto err; - } - - len = sizeof(struct virtchnl_rss_hashcfg); - vrh = kzalloc(len, GFP_KERNEL); - if (!vrh) { - v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY; - len = 0; - goto err; - } - - vrh->hashcfg = ICE_DEFAULT_RSS_HASHCFG; -err: - /* send the response back to the VF */ - ret = ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_GET_RSS_HASHCFG_CAPS, v_ret, - (u8 *)vrh, len); - kfree(vrh); - return ret; -} - -/** - * ice_vc_set_rss_hashcfg - set RSS Hash configuration bits for the VF - * @vf: pointer to the VF info - * @msg: pointer to the msg buffer - */ -static int ice_vc_set_rss_hashcfg(struct ice_vf *vf, u8 *msg) -{ - struct virtchnl_rss_hashcfg *vrh = (struct virtchnl_rss_hashcfg *)msg; - enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS; - struct ice_pf *pf = vf->pf; - struct ice_vsi *vsi; - struct device *dev; - int status; - - dev = ice_pf_to_dev(pf); - - if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto err; - } - - if (!test_bit(ICE_FLAG_RSS_ENA, pf->flags)) { - dev_err(dev, "RSS not supported by PF\n"); - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto err; - } - - vsi = ice_get_vf_vsi(vf); - if (!vsi) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto err; - } - - /* clear all previously programmed RSS configuration to allow VF drivers - * the ability to customize the RSS configuration and/or completely - * disable RSS - */ - status = ice_rem_vsi_rss_cfg(&pf->hw, vsi->idx); - if (status && !vrh->hashcfg) { - /* only report failure to clear the current RSS configuration if - * that was clearly the VF's intention (i.e. vrh->hashcfg = 0) - */ - v_ret = ice_err_to_virt_err(status); - goto err; - } else if (status) { - /* allow the VF to update the RSS configuration even on failure - * to clear the current RSS confguration in an attempt to keep - * RSS in a working state - */ - dev_warn(dev, "Failed to clear the RSS configuration for VF %u\n", - vf->vf_id); - } - - if (vrh->hashcfg) { - status = ice_add_avf_rss_cfg(&pf->hw, vsi, vrh->hashcfg); - v_ret = ice_err_to_virt_err(status); - } - - /* save the requested VF configuration */ - if (!v_ret) - vf->rss_hashcfg = vrh->hashcfg; - - /* send the response to the VF */ -err: - return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_SET_RSS_HASHCFG, v_ret, - NULL, 0); -} - -/** - * ice_vc_query_rxdid - query RXDID supported by DDP package - * @vf: pointer to VF info - * - * Called from VF to query a bitmap of supported flexible - * descriptor RXDIDs of a DDP package. - */ -static int ice_vc_query_rxdid(struct ice_vf *vf) -{ - enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS; - struct ice_pf *pf = vf->pf; - u64 rxdid; - - if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto err; - } - - if (!(vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RX_FLEX_DESC)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto err; - } - - rxdid = pf->supported_rxdids; - -err: - return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_GET_SUPPORTED_RXDIDS, - v_ret, (u8 *)&rxdid, sizeof(rxdid)); -} - -/** - * ice_vf_init_vlan_stripping - enable/disable VLAN stripping on initialization - * @vf: VF to enable/disable VLAN stripping for on initialization - * - * Set the default for VLAN stripping based on whether a port VLAN is configured - * and the current VLAN mode of the device. - */ -static int ice_vf_init_vlan_stripping(struct ice_vf *vf) -{ - struct ice_vsi *vsi = ice_get_vf_vsi(vf); - - vf->vlan_strip_ena = 0; - - if (!vsi) - return -EINVAL; - - /* don't modify stripping if port VLAN is configured in SVM since the - * port VLAN is based on the inner/single VLAN in SVM - */ - if (ice_vf_is_port_vlan_ena(vf) && !ice_is_dvm_ena(&vsi->back->hw)) - return 0; - - if (ice_vf_vlan_offload_ena(vf->driver_caps)) { - int err; - - err = vsi->inner_vlan_ops.ena_stripping(vsi, ETH_P_8021Q); - if (!err) - vf->vlan_strip_ena |= ICE_INNER_VLAN_STRIP_ENA; - return err; - } - - return vsi->inner_vlan_ops.dis_stripping(vsi); -} - -static u16 ice_vc_get_max_vlan_fltrs(struct ice_vf *vf) -{ - if (vf->trusted) - return VLAN_N_VID; - else - return ICE_MAX_VLAN_PER_VF; -} - -/** - * ice_vf_outer_vlan_not_allowed - check if outer VLAN can be used - * @vf: VF that being checked for - * - * When the device is in double VLAN mode, check whether or not the outer VLAN - * is allowed. - */ -static bool ice_vf_outer_vlan_not_allowed(struct ice_vf *vf) -{ - if (ice_vf_is_port_vlan_ena(vf)) - return true; - - return false; -} - -/** - * ice_vc_set_dvm_caps - set VLAN capabilities when the device is in DVM - * @vf: VF that capabilities are being set for - * @caps: VLAN capabilities to populate - * - * Determine VLAN capabilities support based on whether a port VLAN is - * configured. If a port VLAN is configured then the VF should use the inner - * filtering/offload capabilities since the port VLAN is using the outer VLAN - * capabilies. - */ -static void -ice_vc_set_dvm_caps(struct ice_vf *vf, struct virtchnl_vlan_caps *caps) -{ - struct virtchnl_vlan_supported_caps *supported_caps; - - if (ice_vf_outer_vlan_not_allowed(vf)) { - /* until support for inner VLAN filtering is added when a port - * VLAN is configured, only support software offloaded inner - * VLANs when a port VLAN is confgured in DVM - */ - supported_caps = &caps->filtering.filtering_support; - supported_caps->inner = VIRTCHNL_VLAN_UNSUPPORTED; - - supported_caps = &caps->offloads.stripping_support; - supported_caps->inner = VIRTCHNL_VLAN_ETHERTYPE_8100 | - VIRTCHNL_VLAN_TOGGLE | - VIRTCHNL_VLAN_TAG_LOCATION_L2TAG1; - supported_caps->outer = VIRTCHNL_VLAN_UNSUPPORTED; - - supported_caps = &caps->offloads.insertion_support; - supported_caps->inner = VIRTCHNL_VLAN_ETHERTYPE_8100 | - VIRTCHNL_VLAN_TOGGLE | - VIRTCHNL_VLAN_TAG_LOCATION_L2TAG1; - supported_caps->outer = VIRTCHNL_VLAN_UNSUPPORTED; - - caps->offloads.ethertype_init = VIRTCHNL_VLAN_ETHERTYPE_8100; - caps->offloads.ethertype_match = - VIRTCHNL_ETHERTYPE_STRIPPING_MATCHES_INSERTION; - } else { - supported_caps = &caps->filtering.filtering_support; - supported_caps->inner = VIRTCHNL_VLAN_UNSUPPORTED; - supported_caps->outer = VIRTCHNL_VLAN_ETHERTYPE_8100 | - VIRTCHNL_VLAN_ETHERTYPE_88A8 | - VIRTCHNL_VLAN_ETHERTYPE_9100 | - VIRTCHNL_VLAN_ETHERTYPE_AND; - caps->filtering.ethertype_init = VIRTCHNL_VLAN_ETHERTYPE_8100 | - VIRTCHNL_VLAN_ETHERTYPE_88A8 | - VIRTCHNL_VLAN_ETHERTYPE_9100; - - supported_caps = &caps->offloads.stripping_support; - supported_caps->inner = VIRTCHNL_VLAN_TOGGLE | - VIRTCHNL_VLAN_ETHERTYPE_8100 | - VIRTCHNL_VLAN_TAG_LOCATION_L2TAG1; - supported_caps->outer = VIRTCHNL_VLAN_TOGGLE | - VIRTCHNL_VLAN_ETHERTYPE_8100 | - VIRTCHNL_VLAN_ETHERTYPE_88A8 | - VIRTCHNL_VLAN_ETHERTYPE_9100 | - VIRTCHNL_VLAN_ETHERTYPE_XOR | - VIRTCHNL_VLAN_TAG_LOCATION_L2TAG2_2; - - supported_caps = &caps->offloads.insertion_support; - supported_caps->inner = VIRTCHNL_VLAN_TOGGLE | - VIRTCHNL_VLAN_ETHERTYPE_8100 | - VIRTCHNL_VLAN_TAG_LOCATION_L2TAG1; - supported_caps->outer = VIRTCHNL_VLAN_TOGGLE | - VIRTCHNL_VLAN_ETHERTYPE_8100 | - VIRTCHNL_VLAN_ETHERTYPE_88A8 | - VIRTCHNL_VLAN_ETHERTYPE_9100 | - VIRTCHNL_VLAN_ETHERTYPE_XOR | - VIRTCHNL_VLAN_TAG_LOCATION_L2TAG2; - - caps->offloads.ethertype_init = VIRTCHNL_VLAN_ETHERTYPE_8100; - - caps->offloads.ethertype_match = - VIRTCHNL_ETHERTYPE_STRIPPING_MATCHES_INSERTION; - } - - caps->filtering.max_filters = ice_vc_get_max_vlan_fltrs(vf); -} - -/** - * ice_vc_set_svm_caps - set VLAN capabilities when the device is in SVM - * @vf: VF that capabilities are being set for - * @caps: VLAN capabilities to populate - * - * Determine VLAN capabilities support based on whether a port VLAN is - * configured. If a port VLAN is configured then the VF does not have any VLAN - * filtering or offload capabilities since the port VLAN is using the inner VLAN - * capabilities in single VLAN mode (SVM). Otherwise allow the VF to use inner - * VLAN fitlering and offload capabilities. - */ -static void -ice_vc_set_svm_caps(struct ice_vf *vf, struct virtchnl_vlan_caps *caps) -{ - struct virtchnl_vlan_supported_caps *supported_caps; - - if (ice_vf_is_port_vlan_ena(vf)) { - supported_caps = &caps->filtering.filtering_support; - supported_caps->inner = VIRTCHNL_VLAN_UNSUPPORTED; - supported_caps->outer = VIRTCHNL_VLAN_UNSUPPORTED; - - supported_caps = &caps->offloads.stripping_support; - supported_caps->inner = VIRTCHNL_VLAN_UNSUPPORTED; - supported_caps->outer = VIRTCHNL_VLAN_UNSUPPORTED; - - supported_caps = &caps->offloads.insertion_support; - supported_caps->inner = VIRTCHNL_VLAN_UNSUPPORTED; - supported_caps->outer = VIRTCHNL_VLAN_UNSUPPORTED; - - caps->offloads.ethertype_init = VIRTCHNL_VLAN_UNSUPPORTED; - caps->offloads.ethertype_match = VIRTCHNL_VLAN_UNSUPPORTED; - caps->filtering.max_filters = 0; - } else { - supported_caps = &caps->filtering.filtering_support; - supported_caps->inner = VIRTCHNL_VLAN_ETHERTYPE_8100; - supported_caps->outer = VIRTCHNL_VLAN_UNSUPPORTED; - caps->filtering.ethertype_init = VIRTCHNL_VLAN_ETHERTYPE_8100; - - supported_caps = &caps->offloads.stripping_support; - supported_caps->inner = VIRTCHNL_VLAN_ETHERTYPE_8100 | - VIRTCHNL_VLAN_TOGGLE | - VIRTCHNL_VLAN_TAG_LOCATION_L2TAG1; - supported_caps->outer = VIRTCHNL_VLAN_UNSUPPORTED; - - supported_caps = &caps->offloads.insertion_support; - supported_caps->inner = VIRTCHNL_VLAN_ETHERTYPE_8100 | - VIRTCHNL_VLAN_TOGGLE | - VIRTCHNL_VLAN_TAG_LOCATION_L2TAG1; - supported_caps->outer = VIRTCHNL_VLAN_UNSUPPORTED; - - caps->offloads.ethertype_init = VIRTCHNL_VLAN_ETHERTYPE_8100; - caps->offloads.ethertype_match = - VIRTCHNL_ETHERTYPE_STRIPPING_MATCHES_INSERTION; - caps->filtering.max_filters = ice_vc_get_max_vlan_fltrs(vf); - } -} - -/** - * ice_vc_get_offload_vlan_v2_caps - determine VF's VLAN capabilities - * @vf: VF to determine VLAN capabilities for - * - * This will only be called if the VF and PF successfully negotiated - * VIRTCHNL_VF_OFFLOAD_VLAN_V2. - * - * Set VLAN capabilities based on the current VLAN mode and whether a port VLAN - * is configured or not. - */ -static int ice_vc_get_offload_vlan_v2_caps(struct ice_vf *vf) -{ - enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS; - struct virtchnl_vlan_caps *caps = NULL; - int err, len = 0; - - if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - caps = kzalloc(sizeof(*caps), GFP_KERNEL); - if (!caps) { - v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY; - goto out; - } - len = sizeof(*caps); - - if (ice_is_dvm_ena(&vf->pf->hw)) - ice_vc_set_dvm_caps(vf, caps); - else - ice_vc_set_svm_caps(vf, caps); - - /* store negotiated caps to prevent invalid VF messages */ - memcpy(&vf->vlan_v2_caps, caps, sizeof(*caps)); - -out: - err = ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS, - v_ret, (u8 *)caps, len); - kfree(caps); - return err; -} - -/** - * ice_vc_validate_vlan_tpid - validate VLAN TPID - * @filtering_caps: negotiated/supported VLAN filtering capabilities - * @tpid: VLAN TPID used for validation - * - * Convert the VLAN TPID to a VIRTCHNL_VLAN_ETHERTYPE_* and then compare against - * the negotiated/supported filtering caps to see if the VLAN TPID is valid. - */ -static bool ice_vc_validate_vlan_tpid(u16 filtering_caps, u16 tpid) -{ - enum virtchnl_vlan_support vlan_ethertype = VIRTCHNL_VLAN_UNSUPPORTED; - - switch (tpid) { - case ETH_P_8021Q: - vlan_ethertype = VIRTCHNL_VLAN_ETHERTYPE_8100; - break; - case ETH_P_8021AD: - vlan_ethertype = VIRTCHNL_VLAN_ETHERTYPE_88A8; - break; - case ETH_P_QINQ1: - vlan_ethertype = VIRTCHNL_VLAN_ETHERTYPE_9100; - break; - } - - if (!(filtering_caps & vlan_ethertype)) - return false; - - return true; -} - -/** - * ice_vc_is_valid_vlan - validate the virtchnl_vlan - * @vc_vlan: virtchnl_vlan to validate - * - * If the VLAN TCI and VLAN TPID are 0, then this filter is invalid, so return - * false. Otherwise return true. - */ -static bool ice_vc_is_valid_vlan(struct virtchnl_vlan *vc_vlan) -{ - if (!vc_vlan->tci || !vc_vlan->tpid) - return false; - - return true; -} - -/** - * ice_vc_validate_vlan_filter_list - validate the filter list from the VF - * @vfc: negotiated/supported VLAN filtering capabilities - * @vfl: VLAN filter list from VF to validate - * - * Validate all of the filters in the VLAN filter list from the VF. If any of - * the checks fail then return false. Otherwise return true. - */ -static bool -ice_vc_validate_vlan_filter_list(struct virtchnl_vlan_filtering_caps *vfc, - struct virtchnl_vlan_filter_list_v2 *vfl) -{ - u16 i; - - if (!vfl->num_elements) - return false; - - for (i = 0; i < vfl->num_elements; i++) { - struct virtchnl_vlan_supported_caps *filtering_support = - &vfc->filtering_support; - struct virtchnl_vlan_filter *vlan_fltr = &vfl->filters[i]; - struct virtchnl_vlan *outer = &vlan_fltr->outer; - struct virtchnl_vlan *inner = &vlan_fltr->inner; - - if ((ice_vc_is_valid_vlan(outer) && - filtering_support->outer == VIRTCHNL_VLAN_UNSUPPORTED) || - (ice_vc_is_valid_vlan(inner) && - filtering_support->inner == VIRTCHNL_VLAN_UNSUPPORTED)) - return false; - - if ((outer->tci_mask && - !(filtering_support->outer & VIRTCHNL_VLAN_FILTER_MASK)) || - (inner->tci_mask && - !(filtering_support->inner & VIRTCHNL_VLAN_FILTER_MASK))) - return false; - - if (((outer->tci & VLAN_PRIO_MASK) && - !(filtering_support->outer & VIRTCHNL_VLAN_PRIO)) || - ((inner->tci & VLAN_PRIO_MASK) && - !(filtering_support->inner & VIRTCHNL_VLAN_PRIO))) - return false; - - if ((ice_vc_is_valid_vlan(outer) && - !ice_vc_validate_vlan_tpid(filtering_support->outer, - outer->tpid)) || - (ice_vc_is_valid_vlan(inner) && - !ice_vc_validate_vlan_tpid(filtering_support->inner, - inner->tpid))) - return false; - } - - return true; -} - -/** - * ice_vc_to_vlan - transform from struct virtchnl_vlan to struct ice_vlan - * @vc_vlan: struct virtchnl_vlan to transform - */ -static struct ice_vlan ice_vc_to_vlan(struct virtchnl_vlan *vc_vlan) -{ - struct ice_vlan vlan = { 0 }; - - vlan.prio = FIELD_GET(VLAN_PRIO_MASK, vc_vlan->tci); - vlan.vid = vc_vlan->tci & VLAN_VID_MASK; - vlan.tpid = vc_vlan->tpid; - - return vlan; -} - -/** - * ice_vc_vlan_action - action to perform on the virthcnl_vlan - * @vsi: VF's VSI used to perform the action - * @vlan_action: function to perform the action with (i.e. add/del) - * @vlan: VLAN filter to perform the action with - */ -static int -ice_vc_vlan_action(struct ice_vsi *vsi, - int (*vlan_action)(struct ice_vsi *, struct ice_vlan *), - struct ice_vlan *vlan) -{ - int err; - - err = vlan_action(vsi, vlan); - if (err) - return err; - - return 0; -} - -/** - * ice_vc_del_vlans - delete VLAN(s) from the virtchnl filter list - * @vf: VF used to delete the VLAN(s) - * @vsi: VF's VSI used to delete the VLAN(s) - * @vfl: virthchnl filter list used to delete the filters - */ -static int -ice_vc_del_vlans(struct ice_vf *vf, struct ice_vsi *vsi, - struct virtchnl_vlan_filter_list_v2 *vfl) -{ - bool vlan_promisc = ice_is_vlan_promisc_allowed(vf); - int err; - u16 i; - - for (i = 0; i < vfl->num_elements; i++) { - struct virtchnl_vlan_filter *vlan_fltr = &vfl->filters[i]; - struct virtchnl_vlan *vc_vlan; - - vc_vlan = &vlan_fltr->outer; - if (ice_vc_is_valid_vlan(vc_vlan)) { - struct ice_vlan vlan = ice_vc_to_vlan(vc_vlan); - - err = ice_vc_vlan_action(vsi, - vsi->outer_vlan_ops.del_vlan, - &vlan); - if (err) - return err; - - if (vlan_promisc) - ice_vf_dis_vlan_promisc(vsi, &vlan); - - /* Disable VLAN filtering when only VLAN 0 is left */ - if (!ice_vsi_has_non_zero_vlans(vsi) && ice_is_dvm_ena(&vsi->back->hw)) { - err = vsi->outer_vlan_ops.dis_tx_filtering(vsi); - if (err) - return err; - } - } - - vc_vlan = &vlan_fltr->inner; - if (ice_vc_is_valid_vlan(vc_vlan)) { - struct ice_vlan vlan = ice_vc_to_vlan(vc_vlan); - - err = ice_vc_vlan_action(vsi, - vsi->inner_vlan_ops.del_vlan, - &vlan); - if (err) - return err; - - /* no support for VLAN promiscuous on inner VLAN unless - * we are in Single VLAN Mode (SVM) - */ - if (!ice_is_dvm_ena(&vsi->back->hw)) { - if (vlan_promisc) - ice_vf_dis_vlan_promisc(vsi, &vlan); - - /* Disable VLAN filtering when only VLAN 0 is left */ - if (!ice_vsi_has_non_zero_vlans(vsi)) { - err = vsi->inner_vlan_ops.dis_tx_filtering(vsi); - if (err) - return err; - } - } - } - } - - return 0; -} - -/** - * ice_vc_remove_vlan_v2_msg - virtchnl handler for VIRTCHNL_OP_DEL_VLAN_V2 - * @vf: VF the message was received from - * @msg: message received from the VF - */ -static int ice_vc_remove_vlan_v2_msg(struct ice_vf *vf, u8 *msg) -{ - struct virtchnl_vlan_filter_list_v2 *vfl = - (struct virtchnl_vlan_filter_list_v2 *)msg; - enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS; - struct ice_vsi *vsi; - - if (!ice_vc_validate_vlan_filter_list(&vf->vlan_v2_caps.filtering, - vfl)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - if (!ice_vc_isvalid_vsi_id(vf, vfl->vport_id)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - vsi = ice_get_vf_vsi(vf); - if (!vsi) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - if (ice_vc_del_vlans(vf, vsi, vfl)) - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - -out: - return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_DEL_VLAN_V2, v_ret, NULL, - 0); -} - -/** - * ice_vc_add_vlans - add VLAN(s) from the virtchnl filter list - * @vf: VF used to add the VLAN(s) - * @vsi: VF's VSI used to add the VLAN(s) - * @vfl: virthchnl filter list used to add the filters - */ -static int -ice_vc_add_vlans(struct ice_vf *vf, struct ice_vsi *vsi, - struct virtchnl_vlan_filter_list_v2 *vfl) -{ - bool vlan_promisc = ice_is_vlan_promisc_allowed(vf); - int err; - u16 i; - - for (i = 0; i < vfl->num_elements; i++) { - struct virtchnl_vlan_filter *vlan_fltr = &vfl->filters[i]; - struct virtchnl_vlan *vc_vlan; - - vc_vlan = &vlan_fltr->outer; - if (ice_vc_is_valid_vlan(vc_vlan)) { - struct ice_vlan vlan = ice_vc_to_vlan(vc_vlan); - - err = ice_vc_vlan_action(vsi, - vsi->outer_vlan_ops.add_vlan, - &vlan); - if (err) - return err; - - if (vlan_promisc) { - err = ice_vf_ena_vlan_promisc(vf, vsi, &vlan); - if (err) - return err; - } - - /* Enable VLAN filtering on first non-zero VLAN */ - if (vf->spoofchk && vlan.vid && ice_is_dvm_ena(&vsi->back->hw)) { - err = vsi->outer_vlan_ops.ena_tx_filtering(vsi); - if (err) - return err; - } - } - - vc_vlan = &vlan_fltr->inner; - if (ice_vc_is_valid_vlan(vc_vlan)) { - struct ice_vlan vlan = ice_vc_to_vlan(vc_vlan); - - err = ice_vc_vlan_action(vsi, - vsi->inner_vlan_ops.add_vlan, - &vlan); - if (err) - return err; - - /* no support for VLAN promiscuous on inner VLAN unless - * we are in Single VLAN Mode (SVM) - */ - if (!ice_is_dvm_ena(&vsi->back->hw)) { - if (vlan_promisc) { - err = ice_vf_ena_vlan_promisc(vf, vsi, - &vlan); - if (err) - return err; - } - - /* Enable VLAN filtering on first non-zero VLAN */ - if (vf->spoofchk && vlan.vid) { - err = vsi->inner_vlan_ops.ena_tx_filtering(vsi); - if (err) - return err; - } - } - } - } - - return 0; -} - -/** - * ice_vc_validate_add_vlan_filter_list - validate add filter list from the VF - * @vsi: VF VSI used to get number of existing VLAN filters - * @vfc: negotiated/supported VLAN filtering capabilities - * @vfl: VLAN filter list from VF to validate - * - * Validate all of the filters in the VLAN filter list from the VF during the - * VIRTCHNL_OP_ADD_VLAN_V2 opcode. If any of the checks fail then return false. - * Otherwise return true. - */ -static bool -ice_vc_validate_add_vlan_filter_list(struct ice_vsi *vsi, - struct virtchnl_vlan_filtering_caps *vfc, - struct virtchnl_vlan_filter_list_v2 *vfl) -{ - u16 num_requested_filters = ice_vsi_num_non_zero_vlans(vsi) + - vfl->num_elements; - - if (num_requested_filters > vfc->max_filters) - return false; - - return ice_vc_validate_vlan_filter_list(vfc, vfl); -} - -/** - * ice_vc_add_vlan_v2_msg - virtchnl handler for VIRTCHNL_OP_ADD_VLAN_V2 - * @vf: VF the message was received from - * @msg: message received from the VF - */ -static int ice_vc_add_vlan_v2_msg(struct ice_vf *vf, u8 *msg) -{ - enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS; - struct virtchnl_vlan_filter_list_v2 *vfl = - (struct virtchnl_vlan_filter_list_v2 *)msg; - struct ice_vsi *vsi; - - if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - if (!ice_vc_isvalid_vsi_id(vf, vfl->vport_id)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - vsi = ice_get_vf_vsi(vf); - if (!vsi) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - if (!ice_vc_validate_add_vlan_filter_list(vsi, - &vf->vlan_v2_caps.filtering, - vfl)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - if (ice_vc_add_vlans(vf, vsi, vfl)) - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - -out: - return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_ADD_VLAN_V2, v_ret, NULL, - 0); -} - -/** - * ice_vc_valid_vlan_setting - validate VLAN setting - * @negotiated_settings: negotiated VLAN settings during VF init - * @ethertype_setting: ethertype(s) requested for the VLAN setting - */ -static bool -ice_vc_valid_vlan_setting(u32 negotiated_settings, u32 ethertype_setting) -{ - if (ethertype_setting && !(negotiated_settings & ethertype_setting)) - return false; - - /* only allow a single VIRTCHNL_VLAN_ETHERTYPE if - * VIRTHCNL_VLAN_ETHERTYPE_AND is not negotiated/supported - */ - if (!(negotiated_settings & VIRTCHNL_VLAN_ETHERTYPE_AND) && - hweight32(ethertype_setting) > 1) - return false; - - /* ability to modify the VLAN setting was not negotiated */ - if (!(negotiated_settings & VIRTCHNL_VLAN_TOGGLE)) - return false; - - return true; -} - -/** - * ice_vc_valid_vlan_setting_msg - validate the VLAN setting message - * @caps: negotiated VLAN settings during VF init - * @msg: message to validate - * - * Used to validate any VLAN virtchnl message sent as a - * virtchnl_vlan_setting structure. Validates the message against the - * negotiated/supported caps during VF driver init. - */ -static bool -ice_vc_valid_vlan_setting_msg(struct virtchnl_vlan_supported_caps *caps, - struct virtchnl_vlan_setting *msg) -{ - if ((!msg->outer_ethertype_setting && - !msg->inner_ethertype_setting) || - (!caps->outer && !caps->inner)) - return false; - - if (msg->outer_ethertype_setting && - !ice_vc_valid_vlan_setting(caps->outer, - msg->outer_ethertype_setting)) - return false; - - if (msg->inner_ethertype_setting && - !ice_vc_valid_vlan_setting(caps->inner, - msg->inner_ethertype_setting)) - return false; - - return true; -} - -/** - * ice_vc_get_tpid - transform from VIRTCHNL_VLAN_ETHERTYPE_* to VLAN TPID - * @ethertype_setting: VIRTCHNL_VLAN_ETHERTYPE_* used to get VLAN TPID - * @tpid: VLAN TPID to populate - */ -static int ice_vc_get_tpid(u32 ethertype_setting, u16 *tpid) -{ - switch (ethertype_setting) { - case VIRTCHNL_VLAN_ETHERTYPE_8100: - *tpid = ETH_P_8021Q; - break; - case VIRTCHNL_VLAN_ETHERTYPE_88A8: - *tpid = ETH_P_8021AD; - break; - case VIRTCHNL_VLAN_ETHERTYPE_9100: - *tpid = ETH_P_QINQ1; - break; - default: - *tpid = 0; - return -EINVAL; - } - - return 0; -} - -/** - * ice_vc_ena_vlan_offload - enable VLAN offload based on the ethertype_setting - * @vsi: VF's VSI used to enable the VLAN offload - * @ena_offload: function used to enable the VLAN offload - * @ethertype_setting: VIRTCHNL_VLAN_ETHERTYPE_* to enable offloads for - */ -static int -ice_vc_ena_vlan_offload(struct ice_vsi *vsi, - int (*ena_offload)(struct ice_vsi *vsi, u16 tpid), - u32 ethertype_setting) -{ - u16 tpid; - int err; - - err = ice_vc_get_tpid(ethertype_setting, &tpid); - if (err) - return err; - - err = ena_offload(vsi, tpid); - if (err) - return err; - - return 0; -} - -/** - * ice_vc_ena_vlan_stripping_v2_msg - * @vf: VF the message was received from - * @msg: message received from the VF - * - * virthcnl handler for VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2 - */ -static int ice_vc_ena_vlan_stripping_v2_msg(struct ice_vf *vf, u8 *msg) -{ - enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS; - struct virtchnl_vlan_supported_caps *stripping_support; - struct virtchnl_vlan_setting *strip_msg = - (struct virtchnl_vlan_setting *)msg; - u32 ethertype_setting; - struct ice_vsi *vsi; - - if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - if (!ice_vc_isvalid_vsi_id(vf, strip_msg->vport_id)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - vsi = ice_get_vf_vsi(vf); - if (!vsi) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - stripping_support = &vf->vlan_v2_caps.offloads.stripping_support; - if (!ice_vc_valid_vlan_setting_msg(stripping_support, strip_msg)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - if (ice_vsi_is_rxq_crc_strip_dis(vsi)) { - v_ret = VIRTCHNL_STATUS_ERR_NOT_SUPPORTED; - goto out; - } - - ethertype_setting = strip_msg->outer_ethertype_setting; - if (ethertype_setting) { - if (ice_vc_ena_vlan_offload(vsi, - vsi->outer_vlan_ops.ena_stripping, - ethertype_setting)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } else { - enum ice_l2tsel l2tsel = - ICE_L2TSEL_EXTRACT_FIRST_TAG_L2TAG2_2ND; - - /* PF tells the VF that the outer VLAN tag is always - * extracted to VIRTCHNL_VLAN_TAG_LOCATION_L2TAG2_2 and - * inner is always extracted to - * VIRTCHNL_VLAN_TAG_LOCATION_L2TAG1. This is needed to - * support outer stripping so the first tag always ends - * up in L2TAG2_2ND and the second/inner tag, if - * enabled, is extracted in L2TAG1. - */ - ice_vsi_update_l2tsel(vsi, l2tsel); - - vf->vlan_strip_ena |= ICE_OUTER_VLAN_STRIP_ENA; - } - } - - ethertype_setting = strip_msg->inner_ethertype_setting; - if (ethertype_setting && - ice_vc_ena_vlan_offload(vsi, vsi->inner_vlan_ops.ena_stripping, - ethertype_setting)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - if (ethertype_setting) - vf->vlan_strip_ena |= ICE_INNER_VLAN_STRIP_ENA; - -out: - return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2, - v_ret, NULL, 0); -} - -/** - * ice_vc_dis_vlan_stripping_v2_msg - * @vf: VF the message was received from - * @msg: message received from the VF - * - * virthcnl handler for VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2 - */ -static int ice_vc_dis_vlan_stripping_v2_msg(struct ice_vf *vf, u8 *msg) -{ - enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS; - struct virtchnl_vlan_supported_caps *stripping_support; - struct virtchnl_vlan_setting *strip_msg = - (struct virtchnl_vlan_setting *)msg; - u32 ethertype_setting; - struct ice_vsi *vsi; - - if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - if (!ice_vc_isvalid_vsi_id(vf, strip_msg->vport_id)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - vsi = ice_get_vf_vsi(vf); - if (!vsi) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - stripping_support = &vf->vlan_v2_caps.offloads.stripping_support; - if (!ice_vc_valid_vlan_setting_msg(stripping_support, strip_msg)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - ethertype_setting = strip_msg->outer_ethertype_setting; - if (ethertype_setting) { - if (vsi->outer_vlan_ops.dis_stripping(vsi)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } else { - enum ice_l2tsel l2tsel = - ICE_L2TSEL_EXTRACT_FIRST_TAG_L2TAG1; - - /* PF tells the VF that the outer VLAN tag is always - * extracted to VIRTCHNL_VLAN_TAG_LOCATION_L2TAG2_2 and - * inner is always extracted to - * VIRTCHNL_VLAN_TAG_LOCATION_L2TAG1. This is needed to - * support inner stripping while outer stripping is - * disabled so that the first and only tag is extracted - * in L2TAG1. - */ - ice_vsi_update_l2tsel(vsi, l2tsel); - - vf->vlan_strip_ena &= ~ICE_OUTER_VLAN_STRIP_ENA; - } - } - - ethertype_setting = strip_msg->inner_ethertype_setting; - if (ethertype_setting && vsi->inner_vlan_ops.dis_stripping(vsi)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - if (ethertype_setting) - vf->vlan_strip_ena &= ~ICE_INNER_VLAN_STRIP_ENA; - -out: - return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2, - v_ret, NULL, 0); -} - -/** - * ice_vc_ena_vlan_insertion_v2_msg - * @vf: VF the message was received from - * @msg: message received from the VF - * - * virthcnl handler for VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2 - */ -static int ice_vc_ena_vlan_insertion_v2_msg(struct ice_vf *vf, u8 *msg) -{ - enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS; - struct virtchnl_vlan_supported_caps *insertion_support; - struct virtchnl_vlan_setting *insertion_msg = - (struct virtchnl_vlan_setting *)msg; - u32 ethertype_setting; - struct ice_vsi *vsi; - - if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - if (!ice_vc_isvalid_vsi_id(vf, insertion_msg->vport_id)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - vsi = ice_get_vf_vsi(vf); - if (!vsi) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - insertion_support = &vf->vlan_v2_caps.offloads.insertion_support; - if (!ice_vc_valid_vlan_setting_msg(insertion_support, insertion_msg)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - ethertype_setting = insertion_msg->outer_ethertype_setting; - if (ethertype_setting && - ice_vc_ena_vlan_offload(vsi, vsi->outer_vlan_ops.ena_insertion, - ethertype_setting)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - ethertype_setting = insertion_msg->inner_ethertype_setting; - if (ethertype_setting && - ice_vc_ena_vlan_offload(vsi, vsi->inner_vlan_ops.ena_insertion, - ethertype_setting)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - -out: - return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2, - v_ret, NULL, 0); -} - -/** - * ice_vc_dis_vlan_insertion_v2_msg - * @vf: VF the message was received from - * @msg: message received from the VF - * - * virthcnl handler for VIRTCHNL_OP_DISABLE_VLAN_INSERTION_V2 - */ -static int ice_vc_dis_vlan_insertion_v2_msg(struct ice_vf *vf, u8 *msg) -{ - enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS; - struct virtchnl_vlan_supported_caps *insertion_support; - struct virtchnl_vlan_setting *insertion_msg = - (struct virtchnl_vlan_setting *)msg; - u32 ethertype_setting; - struct ice_vsi *vsi; - - if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - if (!ice_vc_isvalid_vsi_id(vf, insertion_msg->vport_id)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - vsi = ice_get_vf_vsi(vf); - if (!vsi) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - insertion_support = &vf->vlan_v2_caps.offloads.insertion_support; - if (!ice_vc_valid_vlan_setting_msg(insertion_support, insertion_msg)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - ethertype_setting = insertion_msg->outer_ethertype_setting; - if (ethertype_setting && vsi->outer_vlan_ops.dis_insertion(vsi)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - - ethertype_setting = insertion_msg->inner_ethertype_setting; - if (ethertype_setting && vsi->inner_vlan_ops.dis_insertion(vsi)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto out; - } - -out: - return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_DISABLE_VLAN_INSERTION_V2, - v_ret, NULL, 0); -} - -static int ice_vc_get_ptp_cap(struct ice_vf *vf, - const struct virtchnl_ptp_caps *msg) -{ - enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_ERR_PARAM; - u32 caps = VIRTCHNL_1588_PTP_CAP_RX_TSTAMP | - VIRTCHNL_1588_PTP_CAP_READ_PHC; - - if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) - goto err; - - v_ret = VIRTCHNL_STATUS_SUCCESS; - - if (msg->caps & caps) - vf->ptp_caps = caps; - -err: - /* send the response back to the VF */ - return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_1588_PTP_GET_CAPS, v_ret, - (u8 *)&vf->ptp_caps, - sizeof(struct virtchnl_ptp_caps)); -} - -static int ice_vc_get_phc_time(struct ice_vf *vf) -{ - enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_ERR_PARAM; - struct virtchnl_phc_time *phc_time = NULL; - struct ice_pf *pf = vf->pf; - u32 len = 0; - int ret; - - if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) - goto err; - - v_ret = VIRTCHNL_STATUS_SUCCESS; - - phc_time = kzalloc(sizeof(*phc_time), GFP_KERNEL); - if (!phc_time) { - v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY; - goto err; - } - - len = sizeof(*phc_time); - - phc_time->time = ice_ptp_read_src_clk_reg(pf, NULL); - -err: - /* send the response back to the VF */ - ret = ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_1588_PTP_GET_TIME, v_ret, - (u8 *)phc_time, len); - kfree(phc_time); - return ret; -} - -static const struct ice_virtchnl_ops ice_virtchnl_dflt_ops = { - .get_ver_msg = ice_vc_get_ver_msg, - .get_vf_res_msg = ice_vc_get_vf_res_msg, - .reset_vf = ice_vc_reset_vf_msg, - .add_mac_addr_msg = ice_vc_add_mac_addr_msg, - .del_mac_addr_msg = ice_vc_del_mac_addr_msg, - .cfg_qs_msg = ice_vc_cfg_qs_msg, - .ena_qs_msg = ice_vc_ena_qs_msg, - .dis_qs_msg = ice_vc_dis_qs_msg, - .request_qs_msg = ice_vc_request_qs_msg, - .cfg_irq_map_msg = ice_vc_cfg_irq_map_msg, - .config_rss_key = ice_vc_config_rss_key, - .config_rss_lut = ice_vc_config_rss_lut, - .config_rss_hfunc = ice_vc_config_rss_hfunc, - .get_stats_msg = ice_vc_get_stats_msg, - .cfg_promiscuous_mode_msg = ice_vc_cfg_promiscuous_mode_msg, - .add_vlan_msg = ice_vc_add_vlan_msg, - .remove_vlan_msg = ice_vc_remove_vlan_msg, - .query_rxdid = ice_vc_query_rxdid, - .get_rss_hashcfg = ice_vc_get_rss_hashcfg, - .set_rss_hashcfg = ice_vc_set_rss_hashcfg, - .ena_vlan_stripping = ice_vc_ena_vlan_stripping, - .dis_vlan_stripping = ice_vc_dis_vlan_stripping, - .handle_rss_cfg_msg = ice_vc_handle_rss_cfg, - .add_fdir_fltr_msg = ice_vc_add_fdir_fltr, - .del_fdir_fltr_msg = ice_vc_del_fdir_fltr, - .get_offload_vlan_v2_caps = ice_vc_get_offload_vlan_v2_caps, - .add_vlan_v2_msg = ice_vc_add_vlan_v2_msg, - .remove_vlan_v2_msg = ice_vc_remove_vlan_v2_msg, - .ena_vlan_stripping_v2_msg = ice_vc_ena_vlan_stripping_v2_msg, - .dis_vlan_stripping_v2_msg = ice_vc_dis_vlan_stripping_v2_msg, - .ena_vlan_insertion_v2_msg = ice_vc_ena_vlan_insertion_v2_msg, - .dis_vlan_insertion_v2_msg = ice_vc_dis_vlan_insertion_v2_msg, - .get_qos_caps = ice_vc_get_qos_caps, - .cfg_q_bw = ice_vc_cfg_q_bw, - .cfg_q_quanta = ice_vc_cfg_q_quanta, - .get_ptp_cap = ice_vc_get_ptp_cap, - .get_phc_time = ice_vc_get_phc_time, - /* If you add a new op here please make sure to add it to - * ice_virtchnl_repr_ops as well. - */ -}; - -/** - * ice_virtchnl_set_dflt_ops - Switch to default virtchnl ops - * @vf: the VF to switch ops - */ -void ice_virtchnl_set_dflt_ops(struct ice_vf *vf) -{ - vf->virtchnl_ops = &ice_virtchnl_dflt_ops; -} - -/** - * ice_vc_repr_add_mac - * @vf: pointer to VF - * @msg: virtchannel message - * - * When port representors are created, we do not add MAC rule - * to firmware, we store it so that PF could report same - * MAC as VF. - */ -static int ice_vc_repr_add_mac(struct ice_vf *vf, u8 *msg) -{ - enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS; - struct virtchnl_ether_addr_list *al = - (struct virtchnl_ether_addr_list *)msg; - struct ice_vsi *vsi; - struct ice_pf *pf; - int i; - - if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states) || - !ice_vc_isvalid_vsi_id(vf, al->vsi_id)) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto handle_mac_exit; - } - - pf = vf->pf; - - vsi = ice_get_vf_vsi(vf); - if (!vsi) { - v_ret = VIRTCHNL_STATUS_ERR_PARAM; - goto handle_mac_exit; - } - - for (i = 0; i < al->num_elements; i++) { - u8 *mac_addr = al->list[i].addr; - - if (!is_unicast_ether_addr(mac_addr) || - ether_addr_equal(mac_addr, vf->hw_lan_addr)) - continue; - - if (vf->pf_set_mac) { - dev_err(ice_pf_to_dev(pf), "VF attempting to override administratively set MAC address\n"); - v_ret = VIRTCHNL_STATUS_ERR_NOT_SUPPORTED; - goto handle_mac_exit; - } - - ice_vfhw_mac_add(vf, &al->list[i]); - break; - } - -handle_mac_exit: - return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_ADD_ETH_ADDR, - v_ret, NULL, 0); -} - -/** - * ice_vc_repr_del_mac - response with success for deleting MAC - * @vf: pointer to VF - * @msg: virtchannel message - * - * Respond with success to not break normal VF flow. - * For legacy VF driver try to update cached MAC address. - */ -static int -ice_vc_repr_del_mac(struct ice_vf __always_unused *vf, u8 __always_unused *msg) -{ - struct virtchnl_ether_addr_list *al = - (struct virtchnl_ether_addr_list *)msg; - - ice_update_legacy_cached_mac(vf, &al->list[0]); - - return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_DEL_ETH_ADDR, - VIRTCHNL_STATUS_SUCCESS, NULL, 0); -} - -static int -ice_vc_repr_cfg_promiscuous_mode(struct ice_vf *vf, u8 __always_unused *msg) -{ - dev_dbg(ice_pf_to_dev(vf->pf), - "Can't config promiscuous mode in switchdev mode for VF %d\n", - vf->vf_id); - return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE, - VIRTCHNL_STATUS_ERR_NOT_SUPPORTED, - NULL, 0); -} - -static const struct ice_virtchnl_ops ice_virtchnl_repr_ops = { - .get_ver_msg = ice_vc_get_ver_msg, - .get_vf_res_msg = ice_vc_get_vf_res_msg, - .reset_vf = ice_vc_reset_vf_msg, - .add_mac_addr_msg = ice_vc_repr_add_mac, - .del_mac_addr_msg = ice_vc_repr_del_mac, - .cfg_qs_msg = ice_vc_cfg_qs_msg, - .ena_qs_msg = ice_vc_ena_qs_msg, - .dis_qs_msg = ice_vc_dis_qs_msg, - .request_qs_msg = ice_vc_request_qs_msg, - .cfg_irq_map_msg = ice_vc_cfg_irq_map_msg, - .config_rss_key = ice_vc_config_rss_key, - .config_rss_lut = ice_vc_config_rss_lut, - .config_rss_hfunc = ice_vc_config_rss_hfunc, - .get_stats_msg = ice_vc_get_stats_msg, - .cfg_promiscuous_mode_msg = ice_vc_repr_cfg_promiscuous_mode, - .add_vlan_msg = ice_vc_add_vlan_msg, - .remove_vlan_msg = ice_vc_remove_vlan_msg, - .query_rxdid = ice_vc_query_rxdid, - .get_rss_hashcfg = ice_vc_get_rss_hashcfg, - .set_rss_hashcfg = ice_vc_set_rss_hashcfg, - .ena_vlan_stripping = ice_vc_ena_vlan_stripping, - .dis_vlan_stripping = ice_vc_dis_vlan_stripping, - .handle_rss_cfg_msg = ice_vc_handle_rss_cfg, - .add_fdir_fltr_msg = ice_vc_add_fdir_fltr, - .del_fdir_fltr_msg = ice_vc_del_fdir_fltr, - .get_offload_vlan_v2_caps = ice_vc_get_offload_vlan_v2_caps, - .add_vlan_v2_msg = ice_vc_add_vlan_v2_msg, - .remove_vlan_v2_msg = ice_vc_remove_vlan_v2_msg, - .ena_vlan_stripping_v2_msg = ice_vc_ena_vlan_stripping_v2_msg, - .dis_vlan_stripping_v2_msg = ice_vc_dis_vlan_stripping_v2_msg, - .ena_vlan_insertion_v2_msg = ice_vc_ena_vlan_insertion_v2_msg, - .dis_vlan_insertion_v2_msg = ice_vc_dis_vlan_insertion_v2_msg, - .get_qos_caps = ice_vc_get_qos_caps, - .cfg_q_bw = ice_vc_cfg_q_bw, - .cfg_q_quanta = ice_vc_cfg_q_quanta, - .get_ptp_cap = ice_vc_get_ptp_cap, - .get_phc_time = ice_vc_get_phc_time, -}; - -/** - * ice_virtchnl_set_repr_ops - Switch to representor virtchnl ops - * @vf: the VF to switch ops - */ -void ice_virtchnl_set_repr_ops(struct ice_vf *vf) -{ - vf->virtchnl_ops = &ice_virtchnl_repr_ops; -} - -/** - * ice_is_malicious_vf - check if this vf might be overflowing mailbox - * @vf: the VF to check - * @mbxdata: data about the state of the mailbox - * - * Detect if a given VF might be malicious and attempting to overflow the PF - * mailbox. If so, log a warning message and ignore this event. - */ -static bool -ice_is_malicious_vf(struct ice_vf *vf, struct ice_mbx_data *mbxdata) -{ - bool report_malvf = false; - struct device *dev; - struct ice_pf *pf; - int status; - - pf = vf->pf; - dev = ice_pf_to_dev(pf); - - if (test_bit(ICE_VF_STATE_DIS, vf->vf_states)) - return vf->mbx_info.malicious; - - /* check to see if we have a newly malicious VF */ - status = ice_mbx_vf_state_handler(&pf->hw, mbxdata, &vf->mbx_info, - &report_malvf); - if (status) - dev_warn_ratelimited(dev, "Unable to check status of mailbox overflow for VF %u MAC %pM, status %d\n", - vf->vf_id, vf->dev_lan_addr, status); - - if (report_malvf) { - struct ice_vsi *pf_vsi = ice_get_main_vsi(pf); - u8 zero_addr[ETH_ALEN] = {}; - - dev_warn(dev, "VF MAC %pM on PF MAC %pM is generating asynchronous messages and may be overflowing the PF message queue. Please see the Adapter User Guide for more information\n", - vf->dev_lan_addr, - pf_vsi ? pf_vsi->netdev->dev_addr : zero_addr); - } - - return vf->mbx_info.malicious; -} - -/** - * ice_vc_process_vf_msg - Process request from VF - * @pf: pointer to the PF structure - * @event: pointer to the AQ event - * @mbxdata: information used to detect VF attempting mailbox overflow - * - * Called from the common asq/arq handler to process request from VF. When this - * flow is used for devices with hardware VF to PF message queue overflow - * support (ICE_F_MBX_LIMIT) mbxdata is set to NULL and ice_is_malicious_vf - * check is skipped. - */ -void ice_vc_process_vf_msg(struct ice_pf *pf, struct ice_rq_event_info *event, - struct ice_mbx_data *mbxdata) -{ - u32 v_opcode = le32_to_cpu(event->desc.cookie_high); - s16 vf_id = le16_to_cpu(event->desc.retval); - const struct ice_virtchnl_ops *ops; - u16 msglen = event->msg_len; - u8 *msg = event->msg_buf; - struct ice_vf *vf = NULL; - struct device *dev; - int err = 0; - - dev = ice_pf_to_dev(pf); - - vf = ice_get_vf_by_id(pf, vf_id); - if (!vf) { - dev_err(dev, "Unable to locate VF for message from VF ID %d, opcode %d, len %d\n", - vf_id, v_opcode, msglen); - return; - } - - mutex_lock(&vf->cfg_lock); - - /* Check if the VF is trying to overflow the mailbox */ - if (mbxdata && ice_is_malicious_vf(vf, mbxdata)) - goto finish; - - /* Check if VF is disabled. */ - if (test_bit(ICE_VF_STATE_DIS, vf->vf_states)) { - err = -EPERM; - goto error_handler; - } - - ops = vf->virtchnl_ops; - - /* Perform basic checks on the msg */ - err = virtchnl_vc_validate_vf_msg(&vf->vf_ver, v_opcode, msg, msglen); - if (err) { - if (err == VIRTCHNL_STATUS_ERR_PARAM) - err = -EPERM; - else - err = -EINVAL; - } - -error_handler: - if (err) { - ice_vc_send_msg_to_vf(vf, v_opcode, VIRTCHNL_STATUS_ERR_PARAM, - NULL, 0); - dev_err(dev, "Invalid message from VF %d, opcode %d, len %d, error %d\n", - vf_id, v_opcode, msglen, err); - goto finish; - } - - if (!ice_vc_is_opcode_allowed(vf, v_opcode)) { - ice_vc_send_msg_to_vf(vf, v_opcode, - VIRTCHNL_STATUS_ERR_NOT_SUPPORTED, NULL, - 0); - goto finish; - } - - switch (v_opcode) { - case VIRTCHNL_OP_VERSION: - err = ops->get_ver_msg(vf, msg); - break; - case VIRTCHNL_OP_GET_VF_RESOURCES: - err = ops->get_vf_res_msg(vf, msg); - if (ice_vf_init_vlan_stripping(vf)) - dev_dbg(dev, "Failed to initialize VLAN stripping for VF %d\n", - vf->vf_id); - ice_vc_notify_vf_link_state(vf); - break; - case VIRTCHNL_OP_RESET_VF: - ops->reset_vf(vf); - break; - case VIRTCHNL_OP_ADD_ETH_ADDR: - err = ops->add_mac_addr_msg(vf, msg); - break; - case VIRTCHNL_OP_DEL_ETH_ADDR: - err = ops->del_mac_addr_msg(vf, msg); - break; - case VIRTCHNL_OP_CONFIG_VSI_QUEUES: - err = ops->cfg_qs_msg(vf, msg); - break; - case VIRTCHNL_OP_ENABLE_QUEUES: - err = ops->ena_qs_msg(vf, msg); - ice_vc_notify_vf_link_state(vf); - break; - case VIRTCHNL_OP_DISABLE_QUEUES: - err = ops->dis_qs_msg(vf, msg); - break; - case VIRTCHNL_OP_REQUEST_QUEUES: - err = ops->request_qs_msg(vf, msg); - break; - case VIRTCHNL_OP_CONFIG_IRQ_MAP: - err = ops->cfg_irq_map_msg(vf, msg); - break; - case VIRTCHNL_OP_CONFIG_RSS_KEY: - err = ops->config_rss_key(vf, msg); - break; - case VIRTCHNL_OP_CONFIG_RSS_LUT: - err = ops->config_rss_lut(vf, msg); - break; - case VIRTCHNL_OP_CONFIG_RSS_HFUNC: - err = ops->config_rss_hfunc(vf, msg); - break; - case VIRTCHNL_OP_GET_STATS: - err = ops->get_stats_msg(vf, msg); - break; - case VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE: - err = ops->cfg_promiscuous_mode_msg(vf, msg); - break; - case VIRTCHNL_OP_ADD_VLAN: - err = ops->add_vlan_msg(vf, msg); - break; - case VIRTCHNL_OP_DEL_VLAN: - err = ops->remove_vlan_msg(vf, msg); - break; - case VIRTCHNL_OP_GET_SUPPORTED_RXDIDS: - err = ops->query_rxdid(vf); - break; - case VIRTCHNL_OP_GET_RSS_HASHCFG_CAPS: - err = ops->get_rss_hashcfg(vf); - break; - case VIRTCHNL_OP_SET_RSS_HASHCFG: - err = ops->set_rss_hashcfg(vf, msg); - break; - case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING: - err = ops->ena_vlan_stripping(vf); - break; - case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING: - err = ops->dis_vlan_stripping(vf); - break; - case VIRTCHNL_OP_ADD_FDIR_FILTER: - err = ops->add_fdir_fltr_msg(vf, msg); - break; - case VIRTCHNL_OP_DEL_FDIR_FILTER: - err = ops->del_fdir_fltr_msg(vf, msg); - break; - case VIRTCHNL_OP_ADD_RSS_CFG: - err = ops->handle_rss_cfg_msg(vf, msg, true); - break; - case VIRTCHNL_OP_DEL_RSS_CFG: - err = ops->handle_rss_cfg_msg(vf, msg, false); - break; - case VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS: - err = ops->get_offload_vlan_v2_caps(vf); - break; - case VIRTCHNL_OP_ADD_VLAN_V2: - err = ops->add_vlan_v2_msg(vf, msg); - break; - case VIRTCHNL_OP_DEL_VLAN_V2: - err = ops->remove_vlan_v2_msg(vf, msg); - break; - case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2: - err = ops->ena_vlan_stripping_v2_msg(vf, msg); - break; - case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2: - err = ops->dis_vlan_stripping_v2_msg(vf, msg); - break; - case VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2: - err = ops->ena_vlan_insertion_v2_msg(vf, msg); - break; - case VIRTCHNL_OP_DISABLE_VLAN_INSERTION_V2: - err = ops->dis_vlan_insertion_v2_msg(vf, msg); - break; - case VIRTCHNL_OP_GET_QOS_CAPS: - err = ops->get_qos_caps(vf); - break; - case VIRTCHNL_OP_CONFIG_QUEUE_BW: - err = ops->cfg_q_bw(vf, msg); - break; - case VIRTCHNL_OP_CONFIG_QUANTA: - err = ops->cfg_q_quanta(vf, msg); - break; - case VIRTCHNL_OP_1588_PTP_GET_CAPS: - err = ops->get_ptp_cap(vf, (const void *)msg); - break; - case VIRTCHNL_OP_1588_PTP_GET_TIME: - err = ops->get_phc_time(vf); - break; - case VIRTCHNL_OP_UNKNOWN: - default: - dev_err(dev, "Unsupported opcode %d from VF %d\n", v_opcode, - vf_id); - err = ice_vc_send_msg_to_vf(vf, v_opcode, - VIRTCHNL_STATUS_ERR_NOT_SUPPORTED, - NULL, 0); - break; - } - if (err) { - /* Helper function cares less about error return values here - * as it is busy with pending work. - */ - dev_info(dev, "PF failed to honor VF %d, opcode %d, error %d\n", - vf_id, v_opcode, err); - } - -finish: - mutex_unlock(&vf->cfg_lock); - ice_put_vf(vf); -} -- 2.47.1