/* Intel Ethernet Switch Host Interface Driver * Copyright(c) 2013 - 2015 Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU General Public License, * version 2, as published by the Free Software Foundation. * * This program is distributed in the hope it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * * The full GNU General Public License is included in this distribution in * the file called "COPYING". * * Contact Information: * e1000-devel Mailing List * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 */ #include "fm10k.h" #include "fm10k_vf.h" #include "fm10k_pf.h" static s32 fm10k_iov_msg_error(struct fm10k_hw *hw, u32 **results, struct fm10k_mbx_info *mbx) { struct fm10k_vf_info *vf_info = (struct fm10k_vf_info *)mbx; struct fm10k_intfc *interface = hw->back; struct pci_dev *pdev = interface->pdev; dev_err(&pdev->dev, "Unknown message ID %u on VF %d\n", **results & FM10K_TLV_ID_MASK, vf_info->vf_idx); return fm10k_tlv_msg_error(hw, results, mbx); } static const struct fm10k_msg_data iov_mbx_data[] = { FM10K_TLV_MSG_TEST_HANDLER(fm10k_tlv_msg_test), FM10K_VF_MSG_MSIX_HANDLER(fm10k_iov_msg_msix_pf), FM10K_VF_MSG_MAC_VLAN_HANDLER(fm10k_iov_msg_mac_vlan_pf), FM10K_VF_MSG_LPORT_STATE_HANDLER(fm10k_iov_msg_lport_state_pf), FM10K_TLV_MSG_ERROR_HANDLER(fm10k_iov_msg_error), }; s32 fm10k_iov_event(struct fm10k_intfc *interface) { struct fm10k_hw *hw = &interface->hw; struct fm10k_iov_data *iov_data; s64 vflre; int i; /* if there is no iov_data then there is no mailboxes to process */ if (!ACCESS_ONCE(interface->iov_data)) return 0; rcu_read_lock(); iov_data = interface->iov_data; /* check again now that we are in the RCU block */ if (!iov_data) goto read_unlock; if (!(fm10k_read_reg(hw, FM10K_EICR) & FM10K_EICR_VFLR)) goto read_unlock; /* read VFLRE to determine if any VFs have been reset */ do { vflre = fm10k_read_reg(hw, FM10K_PFVFLRE(0)); vflre <<= 32; vflre |= fm10k_read_reg(hw, FM10K_PFVFLRE(1)); vflre = (vflre << 32) | (vflre >> 32); vflre |= fm10k_read_reg(hw, FM10K_PFVFLRE(0)); i = iov_data->num_vfs; for (vflre <<= 64 - i; vflre && i--; vflre += vflre) { struct fm10k_vf_info *vf_info = &iov_data->vf_info[i]; if (vflre >= 0) continue; hw->iov.ops.reset_resources(hw, vf_info); vf_info->mbx.ops.connect(hw, &vf_info->mbx); } } while (i != iov_data->num_vfs); read_unlock: rcu_read_unlock(); return 0; } s32 fm10k_iov_mbx(struct fm10k_intfc *interface) { struct fm10k_hw *hw = &interface->hw; struct fm10k_iov_data *iov_data; int i; /* if there is no iov_data then there is no mailboxes to process */ if (!ACCESS_ONCE(interface->iov_data)) return 0; rcu_read_lock(); iov_data = interface->iov_data; /* check again now that we are in the RCU block */ if (!iov_data) goto read_unlock; /* lock the mailbox for transmit and receive */ fm10k_mbx_lock(interface); /* Most VF messages sent to the PF cause the PF to respond by * requesting from the SM mailbox. This means that too many VF * messages processed at once could cause a mailbox timeout on the PF. * To prevent this, store a pointer to the next VF mbx to process. Use * that as the start of the loop so that we don't starve whichever VF * got ignored on the previous run. */ process_mbx: for (i = iov_data->next_vf_mbx ? : iov_data->num_vfs; i--;) { struct fm10k_vf_info *vf_info = &iov_data->vf_info[i]; struct fm10k_mbx_info *mbx = &vf_info->mbx; u16 glort = vf_info->glort; /* process the SM mailbox first to drain outgoing messages */ hw->mbx.ops.process(hw, &hw->mbx); /* verify port mapping is valid, if not reset port */ if (vf_info->vf_flags && !fm10k_glort_valid_pf(hw, glort)) hw->iov.ops.reset_lport(hw, vf_info); /* reset VFs that have mailbox timed out */ if (!mbx->timeout) { hw->iov.ops.reset_resources(hw, vf_info); mbx->ops.connect(hw, mbx); } /* guarantee we have free space in the SM mailbox */ if (!hw->mbx.ops.tx_ready(&hw->mbx, FM10K_VFMBX_MSG_MTU)) break; /* cleanup mailbox and process received messages */ mbx->ops.process(hw, mbx); } /* if we stopped processing mailboxes early, update next_vf_mbx. * Otherwise, reset next_vf_mbx, and restart loop so that we process * the remaining mailboxes we skipped at the start. */ if (i >= 0) { iov_data->next_vf_mbx = i + 1; } else if (iov_data->next_vf_mbx) { iov_data->next_vf_mbx = 0; goto process_mbx; } /* free the lock */ fm10k_mbx_unlock(interface); read_unlock: rcu_read_unlock(); return 0; } void fm10k_iov_suspend(struct pci_dev *pdev) { struct fm10k_intfc *interface = pci_get_drvdata(pdev); struct fm10k_iov_data *iov_data = interface->iov_data; struct fm10k_hw *hw = &interface->hw; int num_vfs, i; /* pull out num_vfs from iov_data */ num_vfs = iov_data ? iov_data->num_vfs : 0; /* shut down queue mapping for VFs */ fm10k_write_reg(hw, FM10K_DGLORTMAP(fm10k_dglort_vf_rss), FM10K_DGLORTMAP_NONE); /* Stop any active VFs and reset their resources */ for (i = 0; i < num_vfs; i++) { struct fm10k_vf_info *vf_info = &iov_data->vf_info[i]; hw->iov.ops.reset_resources(hw, vf_info); hw->iov.ops.reset_lport(hw, vf_info); } } int fm10k_iov_resume(struct pci_dev *pdev) { struct fm10k_intfc *interface = pci_get_drvdata(pdev); struct fm10k_iov_data *iov_data = interface->iov_data; struct fm10k_dglort_cfg dglort = { 0 }; struct fm10k_hw *hw = &interface->hw; int num_vfs, i; /* pull out num_vfs from iov_data */ num_vfs = iov_data ? iov_data->num_vfs : 0; /* return error if iov_data is not already populated */ if (!iov_data) return -ENOMEM; /* allocate hardware resources for the VFs */ hw->iov.ops.assign_resources(hw, num_vfs, num_vfs); /* configure DGLORT mapping for RSS */ dglort.glort = hw->mac.dglort_map & FM10K_DGLORTMAP_NONE; dglort.idx = fm10k_dglort_vf_rss; dglort.inner_rss = 1; dglort.rss_l = fls(fm10k_queues_per_pool(hw) - 1); dglort.queue_b = fm10k_vf_queue_index(hw, 0); dglort.vsi_l = fls(hw->iov.total_vfs - 1); dglort.vsi_b = 1; hw->mac.ops.configure_dglort_map(hw, &dglort); /* assign resources to the device */ for (i = 0; i < num_vfs; i++) { struct fm10k_vf_info *vf_info = &iov_data->vf_info[i]; /* allocate all but the last GLORT to the VFs */ if (i == ((~hw->mac.dglort_map) >> FM10K_DGLORTMAP_MASK_SHIFT)) break; /* assign GLORT to VF, and restrict it to multicast */ hw->iov.ops.set_lport(hw, vf_info, i, FM10K_VF_FLAG_MULTI_CAPABLE); /* assign our default vid to the VF following reset */ vf_info->sw_vid = hw->mac.default_vid; /* mailbox is disconnected so we don't send a message */ hw->iov.ops.assign_default_mac_vlan(hw, vf_info); /* now we are ready so we can connect */ vf_info->mbx.ops.connect(hw, &vf_info->mbx); } return 0; } s32 fm10k_iov_update_pvid(struct fm10k_intfc *interface, u16 glort, u16 pvid) { struct fm10k_iov_data *iov_data = interface->iov_data; struct fm10k_hw *hw = &interface->hw; struct fm10k_vf_info *vf_info; u16 vf_idx = (glort - hw->mac.dglort_map) & FM10K_DGLORTMAP_NONE; /* no IOV support, not our message to process */ if (!iov_data) return FM10K_ERR_PARAM; /* glort outside our range, not our message to process */ if (vf_idx >= iov_data->num_vfs) return FM10K_ERR_PARAM; /* determine if an update has occurred and if so notify the VF */ vf_info = &iov_data->vf_info[vf_idx]; if (vf_info->sw_vid != pvid) { vf_info->sw_vid = pvid; hw->iov.ops.assign_default_mac_vlan(hw, vf_info); } return 0; } static void fm10k_iov_free_data(struct pci_dev *pdev) { struct fm10k_intfc *interface = pci_get_drvdata(pdev); if (!interface->iov_data) return; /* reclaim hardware resources */ fm10k_iov_suspend(pdev); /* drop iov_data from interface */ kfree_rcu(interface->iov_data, rcu); interface->iov_data = NULL; } static s32 fm10k_iov_alloc_data(struct pci_dev *pdev, int num_vfs) { struct fm10k_intfc *interface = pci_get_drvdata(pdev); struct fm10k_iov_data *iov_data = interface->iov_data; struct fm10k_hw *hw = &interface->hw; size_t size; int i, err; /* return error if iov_data is already populated */ if (iov_data) return -EBUSY; /* The PF should always be able to assign resources */ if (!hw->iov.ops.assign_resources) return -ENODEV; /* nothing to do if no VFs are requested */ if (!num_vfs) return 0; /* allocate memory for VF storage */ size = offsetof(struct fm10k_iov_data, vf_info[num_vfs]); iov_data = kzalloc(size, GFP_KERNEL); if (!iov_data) return -ENOMEM; /* record number of VFs */ iov_data->num_vfs = num_vfs; /* loop through vf_info structures initializing each entry */ for (i = 0; i < num_vfs; i++) { struct fm10k_vf_info *vf_info = &iov_data->vf_info[i]; /* Record VF VSI value */ vf_info->vsi = i + 1; vf_info->vf_idx = i; /* initialize mailbox memory */ err = fm10k_pfvf_mbx_init(hw, &vf_info->mbx, iov_mbx_data, i); if (err) { dev_err(&pdev->dev, "Unable to initialize SR-IOV mailbox\n"); kfree(iov_data); return err; } } /* assign iov_data to interface */ interface->iov_data = iov_data; /* allocate hardware resources for the VFs */ fm10k_iov_resume(pdev); return 0; } void fm10k_iov_disable(struct pci_dev *pdev) { if (pci_num_vf(pdev) && pci_vfs_assigned(pdev)) dev_err(&pdev->dev, "Cannot disable SR-IOV while VFs are assigned\n"); else pci_disable_sriov(pdev); fm10k_iov_free_data(pdev); } static void fm10k_disable_aer_comp_abort(struct pci_dev *pdev) { u32 err_sev; int pos; pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ERR); if (!pos) return; pci_read_config_dword(pdev, pos + PCI_ERR_UNCOR_SEVER, &err_sev); err_sev &= ~PCI_ERR_UNC_COMP_ABORT; pci_write_config_dword(pdev, pos + PCI_ERR_UNCOR_SEVER, err_sev); } int fm10k_iov_configure(struct pci_dev *pdev, int num_vfs) { int current_vfs = pci_num_vf(pdev); int err = 0; if (current_vfs && pci_vfs_assigned(pdev)) { dev_err(&pdev->dev, "Cannot modify SR-IOV while VFs are assigned\n"); num_vfs = current_vfs; } else { pci_disable_sriov(pdev); fm10k_iov_free_data(pdev); } /* allocate resources for the VFs */ err = fm10k_iov_alloc_data(pdev, num_vfs); if (err) return err; /* allocate VFs if not already allocated */ if (num_vfs && (num_vfs != current_vfs)) { /* Disable completer abort error reporting as * the VFs can trigger this any time they read a queue * that they don't own. */ fm10k_disable_aer_comp_abort(pdev); err = pci_enable_sriov(pdev, num_vfs); if (err) { dev_err(&pdev->dev, "Enable PCI SR-IOV failed: %d\n", err); return err; } } return num_vfs; } int fm10k_ndo_set_vf_mac(struct net_device *netdev, int vf_idx, u8 *mac) { struct fm10k_intfc *interface = netdev_priv(netdev); struct fm10k_iov_data *iov_data = interface->iov_data; struct fm10k_hw *hw = &interface->hw; struct fm10k_vf_info *vf_info; /* verify SR-IOV is active and that vf idx is valid */ if (!iov_data || vf_idx >= iov_data->num_vfs) return -EINVAL; /* verify MAC addr is valid */ if (!is_zero_ether_addr(mac) && !is_valid_ether_addr(mac)) return -EINVAL; /* record new MAC address */ vf_info = &iov_data->vf_info[vf_idx]; ether_addr_copy(vf_info->mac, mac); /* assigning the MAC will send a mailbox message so lock is needed */ fm10k_mbx_lock(interface); /* assign MAC address to VF */ hw->iov.ops.assign_default_mac_vlan(hw, vf_info); fm10k_mbx_unlock(interface); return 0; } int fm10k_ndo_set_vf_vlan(struct net_device *netdev, int vf_idx, u16 vid, u8 qos) { struct fm10k_intfc *interface = netdev_priv(netdev); struct fm10k_iov_data *iov_data = interface->iov_data; struct fm10k_hw *hw = &interface->hw; struct fm10k_vf_info *vf_info; /* verify SR-IOV is active and that vf idx is valid */ if (!iov_data || vf_idx >= iov_data->num_vfs) return -EINVAL; /* QOS is unsupported and VLAN IDs accepted range 0-4094 */ if (qos || (vid > (VLAN_VID_MASK - 1))) return -EINVAL; vf_info = &iov_data->vf_info[vf_idx]; /* exit if there is nothing to do */ if (vf_info->pf_vid == vid) return 0; /* record default VLAN ID for VF */ vf_info->pf_vid = vid; /* assigning the VLAN will send a mailbox message so lock is needed */ fm10k_mbx_lock(interface); /* Clear the VLAN table for the VF */ hw->mac.ops.update_vlan(hw, FM10K_VLAN_ALL, vf_info->vsi, false); /* Update VF assignment and trigger reset */ hw->iov.ops.assign_default_mac_vlan(hw, vf_info); fm10k_mbx_unlock(interface); return 0; } int fm10k_ndo_set_vf_bw(struct net_device *netdev, int vf_idx, int __always_unused unused, int rate) { struct fm10k_intfc *interface = netdev_priv(netdev); struct fm10k_iov_data *iov_data = interface->iov_data; struct fm10k_hw *hw = &interface->hw; /* verify SR-IOV is active and that vf idx is valid */ if (!iov_data || vf_idx >= iov_data->num_vfs) return -EINVAL; /* rate limit cannot be less than 10Mbs or greater than link speed */ if (rate && ((rate < FM10K_VF_TC_MIN) || rate > FM10K_VF_TC_MAX)) return -EINVAL; /* store values */ iov_data->vf_info[vf_idx].rate = rate; /* update hardware configuration */ hw->iov.ops.configure_tc(hw, vf_idx, rate); return 0; } int fm10k_ndo_get_vf_config(struct net_device *netdev, int vf_idx, struct ifla_vf_info *ivi) { struct fm10k_intfc *interface = netdev_priv(netdev); struct fm10k_iov_data *iov_data = interface->iov_data; struct fm10k_vf_info *vf_info; /* verify SR-IOV is active and that vf idx is valid */ if (!iov_data || vf_idx >= iov_data->num_vfs) return -EINVAL; vf_info = &iov_data->vf_info[vf_idx]; ivi->vf = vf_idx; ivi->max_tx_rate = vf_info->rate; ivi->min_tx_rate = 0; ether_addr_copy(ivi->mac, vf_info->mac); ivi->vlan = vf_info->pf_vid; ivi->qos = 0; return 0; }