1dee1ad47SJeff Kirsher /******************************************************************************* 2dee1ad47SJeff Kirsher 3dee1ad47SJeff Kirsher Intel 82599 Virtual Function driver 4dec0d8e4SJeff Kirsher Copyright(c) 1999 - 2015 Intel Corporation. 5dee1ad47SJeff Kirsher 6dee1ad47SJeff Kirsher This program is free software; you can redistribute it and/or modify it 7dee1ad47SJeff Kirsher under the terms and conditions of the GNU General Public License, 8dee1ad47SJeff Kirsher version 2, as published by the Free Software Foundation. 9dee1ad47SJeff Kirsher 10dee1ad47SJeff Kirsher This program is distributed in the hope it will be useful, but WITHOUT 11dee1ad47SJeff Kirsher ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12dee1ad47SJeff Kirsher FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13dee1ad47SJeff Kirsher more details. 14dee1ad47SJeff Kirsher 15dee1ad47SJeff Kirsher You should have received a copy of the GNU General Public License along with 16dec0d8e4SJeff Kirsher this program; if not, see <http://www.gnu.org/licenses/>. 17dee1ad47SJeff Kirsher 18dee1ad47SJeff Kirsher The full GNU General Public License is included in this distribution in 19dee1ad47SJeff Kirsher the file called "COPYING". 20dee1ad47SJeff Kirsher 21dee1ad47SJeff Kirsher Contact Information: 22dee1ad47SJeff Kirsher e1000-devel Mailing List <e1000-devel@lists.sourceforge.net> 23dee1ad47SJeff Kirsher Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 24dee1ad47SJeff Kirsher 25dee1ad47SJeff Kirsher *******************************************************************************/ 26dee1ad47SJeff Kirsher 27dee1ad47SJeff Kirsher #include "vf.h" 28b5417bf8SStephen Hemminger #include "ixgbevf.h" 29dee1ad47SJeff Kirsher 30c6d45171SKY Srinivasan /* On Hyper-V, to reset, we need to read from this offset 31c6d45171SKY Srinivasan * from the PCI config space. This is the mechanism used on 32c6d45171SKY Srinivasan * Hyper-V to support PF/VF communication. 33c6d45171SKY Srinivasan */ 34c6d45171SKY Srinivasan #define IXGBE_HV_RESET_OFFSET 0x201 35c6d45171SKY Srinivasan 366a11e52bSTony Nguyen static inline s32 ixgbevf_write_msg_read_ack(struct ixgbe_hw *hw, u32 *msg, 376a11e52bSTony Nguyen u32 *retmsg, u16 size) 386a11e52bSTony Nguyen { 396a11e52bSTony Nguyen struct ixgbe_mbx_info *mbx = &hw->mbx; 406a11e52bSTony Nguyen s32 retval = mbx->ops.write_posted(hw, msg, size); 416a11e52bSTony Nguyen 426a11e52bSTony Nguyen if (retval) 436a11e52bSTony Nguyen return retval; 446a11e52bSTony Nguyen 456a11e52bSTony Nguyen return mbx->ops.read_posted(hw, retmsg, size); 466a11e52bSTony Nguyen } 476a11e52bSTony Nguyen 48dee1ad47SJeff Kirsher /** 49dee1ad47SJeff Kirsher * ixgbevf_start_hw_vf - Prepare hardware for Tx/Rx 50dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 51dee1ad47SJeff Kirsher * 52dee1ad47SJeff Kirsher * Starts the hardware by filling the bus info structure and media type, clears 53dee1ad47SJeff Kirsher * all on chip counters, initializes receive address registers, multicast 54dee1ad47SJeff Kirsher * table, VLAN filter table, calls routine to set up link and flow control 55dee1ad47SJeff Kirsher * settings, and leaves transmit and receive units disabled and uninitialized 56dee1ad47SJeff Kirsher **/ 57dee1ad47SJeff Kirsher static s32 ixgbevf_start_hw_vf(struct ixgbe_hw *hw) 58dee1ad47SJeff Kirsher { 59dee1ad47SJeff Kirsher /* Clear adapter stopped flag */ 60dee1ad47SJeff Kirsher hw->adapter_stopped = false; 61dee1ad47SJeff Kirsher 62dee1ad47SJeff Kirsher return 0; 63dee1ad47SJeff Kirsher } 64dee1ad47SJeff Kirsher 65dee1ad47SJeff Kirsher /** 66dee1ad47SJeff Kirsher * ixgbevf_init_hw_vf - virtual function hardware initialization 67dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 68dee1ad47SJeff Kirsher * 69dee1ad47SJeff Kirsher * Initialize the hardware by resetting the hardware and then starting 70dee1ad47SJeff Kirsher * the hardware 71dee1ad47SJeff Kirsher **/ 72dee1ad47SJeff Kirsher static s32 ixgbevf_init_hw_vf(struct ixgbe_hw *hw) 73dee1ad47SJeff Kirsher { 74dee1ad47SJeff Kirsher s32 status = hw->mac.ops.start_hw(hw); 75dee1ad47SJeff Kirsher 76dee1ad47SJeff Kirsher hw->mac.ops.get_mac_addr(hw, hw->mac.addr); 77dee1ad47SJeff Kirsher 78dee1ad47SJeff Kirsher return status; 79dee1ad47SJeff Kirsher } 80dee1ad47SJeff Kirsher 81dee1ad47SJeff Kirsher /** 82dee1ad47SJeff Kirsher * ixgbevf_reset_hw_vf - Performs hardware reset 83dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 84dee1ad47SJeff Kirsher * 85dbedd44eSJoe Perches * Resets the hardware by resetting the transmit and receive units, masks and 86dee1ad47SJeff Kirsher * clears all interrupts. 87dee1ad47SJeff Kirsher **/ 88dee1ad47SJeff Kirsher static s32 ixgbevf_reset_hw_vf(struct ixgbe_hw *hw) 89dee1ad47SJeff Kirsher { 90dee1ad47SJeff Kirsher struct ixgbe_mbx_info *mbx = &hw->mbx; 91dee1ad47SJeff Kirsher u32 timeout = IXGBE_VF_INIT_TIMEOUT; 92dee1ad47SJeff Kirsher s32 ret_val = IXGBE_ERR_INVALID_MAC_ADDR; 93dee1ad47SJeff Kirsher u32 msgbuf[IXGBE_VF_PERMADDR_MSG_LEN]; 94dee1ad47SJeff Kirsher u8 *addr = (u8 *)(&msgbuf[1]); 95dee1ad47SJeff Kirsher 96dee1ad47SJeff Kirsher /* Call adapter stop to disable tx/rx and clear interrupts */ 97dee1ad47SJeff Kirsher hw->mac.ops.stop_adapter(hw); 98dee1ad47SJeff Kirsher 9931186785SAlexander Duyck /* reset the api version */ 10031186785SAlexander Duyck hw->api_version = ixgbe_mbox_api_10; 10131186785SAlexander Duyck 102dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VFCTRL, IXGBE_CTRL_RST); 103dee1ad47SJeff Kirsher IXGBE_WRITE_FLUSH(hw); 104dee1ad47SJeff Kirsher 105dee1ad47SJeff Kirsher /* we cannot reset while the RSTI / RSTD bits are asserted */ 106dee1ad47SJeff Kirsher while (!mbx->ops.check_for_rst(hw) && timeout) { 107dee1ad47SJeff Kirsher timeout--; 108dee1ad47SJeff Kirsher udelay(5); 109dee1ad47SJeff Kirsher } 110dee1ad47SJeff Kirsher 111dee1ad47SJeff Kirsher if (!timeout) 112dee1ad47SJeff Kirsher return IXGBE_ERR_RESET_FAILED; 113dee1ad47SJeff Kirsher 114dee1ad47SJeff Kirsher /* mailbox timeout can now become active */ 115dee1ad47SJeff Kirsher mbx->timeout = IXGBE_VF_MBX_INIT_TIMEOUT; 116dee1ad47SJeff Kirsher 117dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_RESET; 118dee1ad47SJeff Kirsher mbx->ops.write_posted(hw, msgbuf, 1); 119dee1ad47SJeff Kirsher 120012dc19aSJohn Fastabend mdelay(10); 121dee1ad47SJeff Kirsher 122dec0d8e4SJeff Kirsher /* set our "perm_addr" based on info provided by PF 123dec0d8e4SJeff Kirsher * also set up the mc_filter_type which is piggy backed 124dec0d8e4SJeff Kirsher * on the mac address in word 3 125dec0d8e4SJeff Kirsher */ 126dee1ad47SJeff Kirsher ret_val = mbx->ops.read_posted(hw, msgbuf, IXGBE_VF_PERMADDR_MSG_LEN); 127dee1ad47SJeff Kirsher if (ret_val) 128dee1ad47SJeff Kirsher return ret_val; 129dee1ad47SJeff Kirsher 130e1941a74SGreg Rose /* New versions of the PF may NACK the reset return message 131e1941a74SGreg Rose * to indicate that no MAC address has yet been assigned for 132e1941a74SGreg Rose * the VF. 133e1941a74SGreg Rose */ 134e1941a74SGreg Rose if (msgbuf[0] != (IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_ACK) && 135e1941a74SGreg Rose msgbuf[0] != (IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_NACK)) 136dee1ad47SJeff Kirsher return IXGBE_ERR_INVALID_MAC_ADDR; 137dee1ad47SJeff Kirsher 138465fc643SEmil Tantilov if (msgbuf[0] == (IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_ACK)) 1390d8bb414SJeff Kirsher ether_addr_copy(hw->mac.perm_addr, addr); 140465fc643SEmil Tantilov 141dee1ad47SJeff Kirsher hw->mac.mc_filter_type = msgbuf[IXGBE_VF_MC_TYPE_WORD]; 142dee1ad47SJeff Kirsher 143dee1ad47SJeff Kirsher return 0; 144dee1ad47SJeff Kirsher } 145dee1ad47SJeff Kirsher 146dee1ad47SJeff Kirsher /** 147c6d45171SKY Srinivasan * Hyper-V variant; the VF/PF communication is through the PCI 148c6d45171SKY Srinivasan * config space. 149c6d45171SKY Srinivasan */ 150c6d45171SKY Srinivasan static s32 ixgbevf_hv_reset_hw_vf(struct ixgbe_hw *hw) 151c6d45171SKY Srinivasan { 152c6d45171SKY Srinivasan #if IS_ENABLED(CONFIG_PCI_MMCONFIG) 153c6d45171SKY Srinivasan struct ixgbevf_adapter *adapter = hw->back; 154c6d45171SKY Srinivasan int i; 155c6d45171SKY Srinivasan 156c6d45171SKY Srinivasan for (i = 0; i < 6; i++) 157c6d45171SKY Srinivasan pci_read_config_byte(adapter->pdev, 158c6d45171SKY Srinivasan (i + IXGBE_HV_RESET_OFFSET), 159c6d45171SKY Srinivasan &hw->mac.perm_addr[i]); 160c6d45171SKY Srinivasan return 0; 161c6d45171SKY Srinivasan #else 162c6d45171SKY Srinivasan pr_err("PCI_MMCONFIG needs to be enabled for Hyper-V\n"); 163c6d45171SKY Srinivasan return -EOPNOTSUPP; 164c6d45171SKY Srinivasan #endif 165c6d45171SKY Srinivasan } 166c6d45171SKY Srinivasan 167c6d45171SKY Srinivasan /** 168dee1ad47SJeff Kirsher * ixgbevf_stop_hw_vf - Generic stop Tx/Rx units 169dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 170dee1ad47SJeff Kirsher * 171dee1ad47SJeff Kirsher * Sets the adapter_stopped flag within ixgbe_hw struct. Clears interrupts, 172dee1ad47SJeff Kirsher * disables transmit and receive units. The adapter_stopped flag is used by 173dee1ad47SJeff Kirsher * the shared code and drivers to determine if the adapter is in a stopped 174dee1ad47SJeff Kirsher * state and should not touch the hardware. 175dee1ad47SJeff Kirsher **/ 176dee1ad47SJeff Kirsher static s32 ixgbevf_stop_hw_vf(struct ixgbe_hw *hw) 177dee1ad47SJeff Kirsher { 178dee1ad47SJeff Kirsher u32 number_of_queues; 179dee1ad47SJeff Kirsher u32 reg_val; 180dee1ad47SJeff Kirsher u16 i; 181dee1ad47SJeff Kirsher 182dec0d8e4SJeff Kirsher /* Set the adapter_stopped flag so other driver functions stop touching 183dee1ad47SJeff Kirsher * the hardware 184dee1ad47SJeff Kirsher */ 185dee1ad47SJeff Kirsher hw->adapter_stopped = true; 186dee1ad47SJeff Kirsher 187dee1ad47SJeff Kirsher /* Disable the receive unit by stopped each queue */ 188dee1ad47SJeff Kirsher number_of_queues = hw->mac.max_rx_queues; 189dee1ad47SJeff Kirsher for (i = 0; i < number_of_queues; i++) { 190dee1ad47SJeff Kirsher reg_val = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i)); 191dee1ad47SJeff Kirsher if (reg_val & IXGBE_RXDCTL_ENABLE) { 192dee1ad47SJeff Kirsher reg_val &= ~IXGBE_RXDCTL_ENABLE; 193dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(i), reg_val); 194dee1ad47SJeff Kirsher } 195dee1ad47SJeff Kirsher } 196dee1ad47SJeff Kirsher 197dee1ad47SJeff Kirsher IXGBE_WRITE_FLUSH(hw); 198dee1ad47SJeff Kirsher 199dee1ad47SJeff Kirsher /* Clear interrupt mask to stop from interrupts being generated */ 200dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VTEIMC, IXGBE_VF_IRQ_CLEAR_MASK); 201dee1ad47SJeff Kirsher 202dee1ad47SJeff Kirsher /* Clear any pending interrupts */ 203dee1ad47SJeff Kirsher IXGBE_READ_REG(hw, IXGBE_VTEICR); 204dee1ad47SJeff Kirsher 205dee1ad47SJeff Kirsher /* Disable the transmit unit. Each queue must be disabled. */ 206dee1ad47SJeff Kirsher number_of_queues = hw->mac.max_tx_queues; 207dee1ad47SJeff Kirsher for (i = 0; i < number_of_queues; i++) { 208dee1ad47SJeff Kirsher reg_val = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i)); 209dee1ad47SJeff Kirsher if (reg_val & IXGBE_TXDCTL_ENABLE) { 210dee1ad47SJeff Kirsher reg_val &= ~IXGBE_TXDCTL_ENABLE; 211dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(i), reg_val); 212dee1ad47SJeff Kirsher } 213dee1ad47SJeff Kirsher } 214dee1ad47SJeff Kirsher 215dee1ad47SJeff Kirsher return 0; 216dee1ad47SJeff Kirsher } 217dee1ad47SJeff Kirsher 218dee1ad47SJeff Kirsher /** 219dee1ad47SJeff Kirsher * ixgbevf_mta_vector - Determines bit-vector in multicast table to set 220dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 221dee1ad47SJeff Kirsher * @mc_addr: the multicast address 222dee1ad47SJeff Kirsher * 223dee1ad47SJeff Kirsher * Extracts the 12 bits, from a multicast address, to determine which 224dee1ad47SJeff Kirsher * bit-vector to set in the multicast table. The hardware uses 12 bits, from 225dec0d8e4SJeff Kirsher * incoming Rx multicast addresses, to determine the bit-vector to check in 226dee1ad47SJeff Kirsher * the MTA. Which of the 4 combination, of 12-bits, the hardware uses is set 227dee1ad47SJeff Kirsher * by the MO field of the MCSTCTRL. The MO field is set during initialization 228dee1ad47SJeff Kirsher * to mc_filter_type. 229dee1ad47SJeff Kirsher **/ 230dee1ad47SJeff Kirsher static s32 ixgbevf_mta_vector(struct ixgbe_hw *hw, u8 *mc_addr) 231dee1ad47SJeff Kirsher { 232dee1ad47SJeff Kirsher u32 vector = 0; 233dee1ad47SJeff Kirsher 234dee1ad47SJeff Kirsher switch (hw->mac.mc_filter_type) { 235dee1ad47SJeff Kirsher case 0: /* use bits [47:36] of the address */ 236dee1ad47SJeff Kirsher vector = ((mc_addr[4] >> 4) | (((u16)mc_addr[5]) << 4)); 237dee1ad47SJeff Kirsher break; 238dee1ad47SJeff Kirsher case 1: /* use bits [46:35] of the address */ 239dee1ad47SJeff Kirsher vector = ((mc_addr[4] >> 3) | (((u16)mc_addr[5]) << 5)); 240dee1ad47SJeff Kirsher break; 241dee1ad47SJeff Kirsher case 2: /* use bits [45:34] of the address */ 242dee1ad47SJeff Kirsher vector = ((mc_addr[4] >> 2) | (((u16)mc_addr[5]) << 6)); 243dee1ad47SJeff Kirsher break; 244dee1ad47SJeff Kirsher case 3: /* use bits [43:32] of the address */ 245dee1ad47SJeff Kirsher vector = ((mc_addr[4]) | (((u16)mc_addr[5]) << 8)); 246dee1ad47SJeff Kirsher break; 247dee1ad47SJeff Kirsher default: /* Invalid mc_filter_type */ 248dee1ad47SJeff Kirsher break; 249dee1ad47SJeff Kirsher } 250dee1ad47SJeff Kirsher 251dee1ad47SJeff Kirsher /* vector can only be 12-bits or boundary will be exceeded */ 252dee1ad47SJeff Kirsher vector &= 0xFFF; 253dee1ad47SJeff Kirsher return vector; 254dee1ad47SJeff Kirsher } 255dee1ad47SJeff Kirsher 256dee1ad47SJeff Kirsher /** 257dee1ad47SJeff Kirsher * ixgbevf_get_mac_addr_vf - Read device MAC address 258dee1ad47SJeff Kirsher * @hw: pointer to the HW structure 259dee1ad47SJeff Kirsher * @mac_addr: pointer to storage for retrieved MAC address 260dee1ad47SJeff Kirsher **/ 261dee1ad47SJeff Kirsher static s32 ixgbevf_get_mac_addr_vf(struct ixgbe_hw *hw, u8 *mac_addr) 262dee1ad47SJeff Kirsher { 2630d8bb414SJeff Kirsher ether_addr_copy(mac_addr, hw->mac.perm_addr); 264dee1ad47SJeff Kirsher 265dee1ad47SJeff Kirsher return 0; 266dee1ad47SJeff Kirsher } 267dee1ad47SJeff Kirsher 268dee1ad47SJeff Kirsher static s32 ixgbevf_set_uc_addr_vf(struct ixgbe_hw *hw, u32 index, u8 *addr) 269dee1ad47SJeff Kirsher { 270fc355e07SEmil Tantilov u32 msgbuf[3], msgbuf_chk; 271dee1ad47SJeff Kirsher u8 *msg_addr = (u8 *)(&msgbuf[1]); 272dee1ad47SJeff Kirsher s32 ret_val; 273dee1ad47SJeff Kirsher 274dee1ad47SJeff Kirsher memset(msgbuf, 0, sizeof(msgbuf)); 275dec0d8e4SJeff Kirsher /* If index is one then this is the start of a new list and needs 276dee1ad47SJeff Kirsher * indication to the PF so it can do it's own list management. 277dee1ad47SJeff Kirsher * If it is zero then that tells the PF to just clear all of 278dee1ad47SJeff Kirsher * this VF's macvlans and there is no new list. 279dee1ad47SJeff Kirsher */ 280dee1ad47SJeff Kirsher msgbuf[0] |= index << IXGBE_VT_MSGINFO_SHIFT; 281dee1ad47SJeff Kirsher msgbuf[0] |= IXGBE_VF_SET_MACVLAN; 282fc355e07SEmil Tantilov msgbuf_chk = msgbuf[0]; 283fc355e07SEmil Tantilov 284dee1ad47SJeff Kirsher if (addr) 2850d8bb414SJeff Kirsher ether_addr_copy(msg_addr, addr); 286dee1ad47SJeff Kirsher 287c6426971SEmil Tantilov ret_val = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 288c6426971SEmil Tantilov sizeof(msgbuf) / sizeof(u32)); 289fc355e07SEmil Tantilov if (!ret_val) { 290dee1ad47SJeff Kirsher msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 291dee1ad47SJeff Kirsher 292fc355e07SEmil Tantilov if (msgbuf[0] == (msgbuf_chk | IXGBE_VT_MSGTYPE_NACK)) 293fc355e07SEmil Tantilov return -ENOMEM; 294fc355e07SEmil Tantilov } 295dee1ad47SJeff Kirsher 296dee1ad47SJeff Kirsher return ret_val; 297dee1ad47SJeff Kirsher } 298dee1ad47SJeff Kirsher 299c6d45171SKY Srinivasan static s32 ixgbevf_hv_set_uc_addr_vf(struct ixgbe_hw *hw, u32 index, u8 *addr) 300c6d45171SKY Srinivasan { 301c6d45171SKY Srinivasan return -EOPNOTSUPP; 302c6d45171SKY Srinivasan } 303c6d45171SKY Srinivasan 304dee1ad47SJeff Kirsher /** 30594cf66f8SVlad Zolotarov * ixgbevf_get_reta_locked - get the RSS redirection table (RETA) contents. 30694cf66f8SVlad Zolotarov * @adapter: pointer to the port handle 30794cf66f8SVlad Zolotarov * @reta: buffer to fill with RETA contents. 30894cf66f8SVlad Zolotarov * @num_rx_queues: Number of Rx queues configured for this port 30994cf66f8SVlad Zolotarov * 31094cf66f8SVlad Zolotarov * The "reta" buffer should be big enough to contain 32 registers. 31194cf66f8SVlad Zolotarov * 31294cf66f8SVlad Zolotarov * Returns: 0 on success. 31394cf66f8SVlad Zolotarov * if API doesn't support this operation - (-EOPNOTSUPP). 31494cf66f8SVlad Zolotarov */ 31594cf66f8SVlad Zolotarov int ixgbevf_get_reta_locked(struct ixgbe_hw *hw, u32 *reta, int num_rx_queues) 31694cf66f8SVlad Zolotarov { 31794cf66f8SVlad Zolotarov int err, i, j; 31894cf66f8SVlad Zolotarov u32 msgbuf[IXGBE_VFMAILBOX_SIZE]; 31994cf66f8SVlad Zolotarov u32 *hw_reta = &msgbuf[1]; 32094cf66f8SVlad Zolotarov u32 mask = 0; 32194cf66f8SVlad Zolotarov 32294cf66f8SVlad Zolotarov /* We have to use a mailbox for 82599 and x540 devices only. 32394cf66f8SVlad Zolotarov * For these devices RETA has 128 entries. 32494cf66f8SVlad Zolotarov * Also these VFs support up to 4 RSS queues. Therefore PF will compress 32594cf66f8SVlad Zolotarov * 16 RETA entries in each DWORD giving 2 bits to each entry. 32694cf66f8SVlad Zolotarov */ 32794cf66f8SVlad Zolotarov int dwords = IXGBEVF_82599_RETA_SIZE / 16; 32894cf66f8SVlad Zolotarov 32994cf66f8SVlad Zolotarov /* We support the RSS querying for 82599 and x540 devices only. 33094cf66f8SVlad Zolotarov * Thus return an error if API doesn't support RETA querying or querying 33194cf66f8SVlad Zolotarov * is not supported for this device type. 33294cf66f8SVlad Zolotarov */ 33394cf66f8SVlad Zolotarov if (hw->api_version != ixgbe_mbox_api_12 || 33494cf66f8SVlad Zolotarov hw->mac.type >= ixgbe_mac_X550_vf) 33594cf66f8SVlad Zolotarov return -EOPNOTSUPP; 33694cf66f8SVlad Zolotarov 33794cf66f8SVlad Zolotarov msgbuf[0] = IXGBE_VF_GET_RETA; 33894cf66f8SVlad Zolotarov 33994cf66f8SVlad Zolotarov err = hw->mbx.ops.write_posted(hw, msgbuf, 1); 34094cf66f8SVlad Zolotarov 34194cf66f8SVlad Zolotarov if (err) 34294cf66f8SVlad Zolotarov return err; 34394cf66f8SVlad Zolotarov 34494cf66f8SVlad Zolotarov err = hw->mbx.ops.read_posted(hw, msgbuf, dwords + 1); 34594cf66f8SVlad Zolotarov 34694cf66f8SVlad Zolotarov if (err) 34794cf66f8SVlad Zolotarov return err; 34894cf66f8SVlad Zolotarov 34994cf66f8SVlad Zolotarov msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 35094cf66f8SVlad Zolotarov 35194cf66f8SVlad Zolotarov /* If the operation has been refused by a PF return -EPERM */ 35294cf66f8SVlad Zolotarov if (msgbuf[0] == (IXGBE_VF_GET_RETA | IXGBE_VT_MSGTYPE_NACK)) 35394cf66f8SVlad Zolotarov return -EPERM; 35494cf66f8SVlad Zolotarov 35594cf66f8SVlad Zolotarov /* If we didn't get an ACK there must have been 35694cf66f8SVlad Zolotarov * some sort of mailbox error so we should treat it 35794cf66f8SVlad Zolotarov * as such. 35894cf66f8SVlad Zolotarov */ 35994cf66f8SVlad Zolotarov if (msgbuf[0] != (IXGBE_VF_GET_RETA | IXGBE_VT_MSGTYPE_ACK)) 36094cf66f8SVlad Zolotarov return IXGBE_ERR_MBX; 36194cf66f8SVlad Zolotarov 36294cf66f8SVlad Zolotarov /* ixgbevf doesn't support more than 2 queues at the moment */ 36394cf66f8SVlad Zolotarov if (num_rx_queues > 1) 36494cf66f8SVlad Zolotarov mask = 0x1; 36594cf66f8SVlad Zolotarov 36694cf66f8SVlad Zolotarov for (i = 0; i < dwords; i++) 36794cf66f8SVlad Zolotarov for (j = 0; j < 16; j++) 36894cf66f8SVlad Zolotarov reta[i * 16 + j] = (hw_reta[i] >> (2 * j)) & mask; 36994cf66f8SVlad Zolotarov 37094cf66f8SVlad Zolotarov return 0; 37194cf66f8SVlad Zolotarov } 37294cf66f8SVlad Zolotarov 37394cf66f8SVlad Zolotarov /** 374ad1431e2SVlad Zolotarov * ixgbevf_get_rss_key_locked - get the RSS Random Key 375ad1431e2SVlad Zolotarov * @hw: pointer to the HW structure 376ad1431e2SVlad Zolotarov * @rss_key: buffer to fill with RSS Hash Key contents. 377ad1431e2SVlad Zolotarov * 378ad1431e2SVlad Zolotarov * The "rss_key" buffer should be big enough to contain 10 registers. 379ad1431e2SVlad Zolotarov * 380ad1431e2SVlad Zolotarov * Returns: 0 on success. 381ad1431e2SVlad Zolotarov * if API doesn't support this operation - (-EOPNOTSUPP). 382ad1431e2SVlad Zolotarov */ 383ad1431e2SVlad Zolotarov int ixgbevf_get_rss_key_locked(struct ixgbe_hw *hw, u8 *rss_key) 384ad1431e2SVlad Zolotarov { 385ad1431e2SVlad Zolotarov int err; 386ad1431e2SVlad Zolotarov u32 msgbuf[IXGBE_VFMAILBOX_SIZE]; 387ad1431e2SVlad Zolotarov 388ad1431e2SVlad Zolotarov /* We currently support the RSS Random Key retrieval for 82599 and x540 389ad1431e2SVlad Zolotarov * devices only. 390ad1431e2SVlad Zolotarov * 391ad1431e2SVlad Zolotarov * Thus return an error if API doesn't support RSS Random Key retrieval 392ad1431e2SVlad Zolotarov * or if the operation is not supported for this device type. 393ad1431e2SVlad Zolotarov */ 394ad1431e2SVlad Zolotarov if (hw->api_version != ixgbe_mbox_api_12 || 395ad1431e2SVlad Zolotarov hw->mac.type >= ixgbe_mac_X550_vf) 396ad1431e2SVlad Zolotarov return -EOPNOTSUPP; 397ad1431e2SVlad Zolotarov 398ad1431e2SVlad Zolotarov msgbuf[0] = IXGBE_VF_GET_RSS_KEY; 399ad1431e2SVlad Zolotarov err = hw->mbx.ops.write_posted(hw, msgbuf, 1); 400ad1431e2SVlad Zolotarov 401ad1431e2SVlad Zolotarov if (err) 402ad1431e2SVlad Zolotarov return err; 403ad1431e2SVlad Zolotarov 404ad1431e2SVlad Zolotarov err = hw->mbx.ops.read_posted(hw, msgbuf, 11); 405ad1431e2SVlad Zolotarov 406ad1431e2SVlad Zolotarov if (err) 407ad1431e2SVlad Zolotarov return err; 408ad1431e2SVlad Zolotarov 409ad1431e2SVlad Zolotarov msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 410ad1431e2SVlad Zolotarov 411ad1431e2SVlad Zolotarov /* If the operation has been refused by a PF return -EPERM */ 412ad1431e2SVlad Zolotarov if (msgbuf[0] == (IXGBE_VF_GET_RETA | IXGBE_VT_MSGTYPE_NACK)) 413ad1431e2SVlad Zolotarov return -EPERM; 414ad1431e2SVlad Zolotarov 415ad1431e2SVlad Zolotarov /* If we didn't get an ACK there must have been 416ad1431e2SVlad Zolotarov * some sort of mailbox error so we should treat it 417ad1431e2SVlad Zolotarov * as such. 418ad1431e2SVlad Zolotarov */ 419ad1431e2SVlad Zolotarov if (msgbuf[0] != (IXGBE_VF_GET_RSS_KEY | IXGBE_VT_MSGTYPE_ACK)) 420ad1431e2SVlad Zolotarov return IXGBE_ERR_MBX; 421ad1431e2SVlad Zolotarov 422ad1431e2SVlad Zolotarov memcpy(rss_key, msgbuf + 1, IXGBEVF_RSS_HASH_KEY_SIZE); 423ad1431e2SVlad Zolotarov 424ad1431e2SVlad Zolotarov return 0; 425ad1431e2SVlad Zolotarov } 426ad1431e2SVlad Zolotarov 427ad1431e2SVlad Zolotarov /** 428dee1ad47SJeff Kirsher * ixgbevf_set_rar_vf - set device MAC address 429dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 430dee1ad47SJeff Kirsher * @index: Receive address register to write 431dee1ad47SJeff Kirsher * @addr: Address to put into receive address register 432dee1ad47SJeff Kirsher * @vmdq: Unused in this implementation 433dee1ad47SJeff Kirsher **/ 434dee1ad47SJeff Kirsher static s32 ixgbevf_set_rar_vf(struct ixgbe_hw *hw, u32 index, u8 *addr, 435dee1ad47SJeff Kirsher u32 vmdq) 436dee1ad47SJeff Kirsher { 437dee1ad47SJeff Kirsher u32 msgbuf[3]; 438dee1ad47SJeff Kirsher u8 *msg_addr = (u8 *)(&msgbuf[1]); 439dee1ad47SJeff Kirsher s32 ret_val; 440dee1ad47SJeff Kirsher 441dee1ad47SJeff Kirsher memset(msgbuf, 0, sizeof(msgbuf)); 442dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_SET_MAC_ADDR; 4430d8bb414SJeff Kirsher ether_addr_copy(msg_addr, addr); 444dee1ad47SJeff Kirsher 445c6426971SEmil Tantilov ret_val = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 446c6426971SEmil Tantilov sizeof(msgbuf) / sizeof(u32)); 447dee1ad47SJeff Kirsher 448dee1ad47SJeff Kirsher msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 449dee1ad47SJeff Kirsher 450dee1ad47SJeff Kirsher /* if nacked the address was rejected, use "perm_addr" */ 451dee1ad47SJeff Kirsher if (!ret_val && 45232ca6868SEmil Tantilov (msgbuf[0] == (IXGBE_VF_SET_MAC_ADDR | IXGBE_VT_MSGTYPE_NACK))) { 453dee1ad47SJeff Kirsher ixgbevf_get_mac_addr_vf(hw, hw->mac.addr); 45432ca6868SEmil Tantilov return IXGBE_ERR_MBX; 45532ca6868SEmil Tantilov } 456dee1ad47SJeff Kirsher 457dee1ad47SJeff Kirsher return ret_val; 458dee1ad47SJeff Kirsher } 459dee1ad47SJeff Kirsher 460c6d45171SKY Srinivasan /** 461c6d45171SKY Srinivasan * ixgbevf_hv_set_rar_vf - set device MAC address Hyper-V variant 462c6d45171SKY Srinivasan * @hw: pointer to hardware structure 463c6d45171SKY Srinivasan * @index: Receive address register to write 464c6d45171SKY Srinivasan * @addr: Address to put into receive address register 465c6d45171SKY Srinivasan * @vmdq: Unused in this implementation 466c6d45171SKY Srinivasan * 467c6d45171SKY Srinivasan * We don't really allow setting the device MAC address. However, 468c6d45171SKY Srinivasan * if the address being set is the permanent MAC address we will 469c6d45171SKY Srinivasan * permit that. 470c6d45171SKY Srinivasan **/ 471c6d45171SKY Srinivasan static s32 ixgbevf_hv_set_rar_vf(struct ixgbe_hw *hw, u32 index, u8 *addr, 472c6d45171SKY Srinivasan u32 vmdq) 473c6d45171SKY Srinivasan { 474c6d45171SKY Srinivasan if (ether_addr_equal(addr, hw->mac.perm_addr)) 475c6d45171SKY Srinivasan return 0; 476c6d45171SKY Srinivasan 477c6d45171SKY Srinivasan return -EOPNOTSUPP; 478c6d45171SKY Srinivasan } 479c6d45171SKY Srinivasan 480dee1ad47SJeff Kirsher /** 481dee1ad47SJeff Kirsher * ixgbevf_update_mc_addr_list_vf - Update Multicast addresses 482dee1ad47SJeff Kirsher * @hw: pointer to the HW structure 483dee1ad47SJeff Kirsher * @netdev: pointer to net device structure 484dee1ad47SJeff Kirsher * 485dee1ad47SJeff Kirsher * Updates the Multicast Table Array. 486dee1ad47SJeff Kirsher **/ 487dee1ad47SJeff Kirsher static s32 ixgbevf_update_mc_addr_list_vf(struct ixgbe_hw *hw, 488dee1ad47SJeff Kirsher struct net_device *netdev) 489dee1ad47SJeff Kirsher { 490dee1ad47SJeff Kirsher struct netdev_hw_addr *ha; 491dee1ad47SJeff Kirsher u32 msgbuf[IXGBE_VFMAILBOX_SIZE]; 492dee1ad47SJeff Kirsher u16 *vector_list = (u16 *)&msgbuf[1]; 493dee1ad47SJeff Kirsher u32 cnt, i; 494dee1ad47SJeff Kirsher 495dee1ad47SJeff Kirsher /* Each entry in the list uses 1 16 bit word. We have 30 496dee1ad47SJeff Kirsher * 16 bit words available in our HW msg buffer (minus 1 for the 497dee1ad47SJeff Kirsher * msg type). That's 30 hash values if we pack 'em right. If 498dee1ad47SJeff Kirsher * there are more than 30 MC addresses to add then punt the 499dee1ad47SJeff Kirsher * extras for now and then add code to handle more than 30 later. 500dee1ad47SJeff Kirsher * It would be unusual for a server to request that many multi-cast 501dee1ad47SJeff Kirsher * addresses except for in large enterprise network environments. 502dee1ad47SJeff Kirsher */ 503dee1ad47SJeff Kirsher 504dee1ad47SJeff Kirsher cnt = netdev_mc_count(netdev); 505dee1ad47SJeff Kirsher if (cnt > 30) 506dee1ad47SJeff Kirsher cnt = 30; 507dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_SET_MULTICAST; 508dee1ad47SJeff Kirsher msgbuf[0] |= cnt << IXGBE_VT_MSGINFO_SHIFT; 509dee1ad47SJeff Kirsher 510dee1ad47SJeff Kirsher i = 0; 511dee1ad47SJeff Kirsher netdev_for_each_mc_addr(ha, netdev) { 512dee1ad47SJeff Kirsher if (i == cnt) 513dee1ad47SJeff Kirsher break; 51446acc460SBen Hutchings if (is_link_local_ether_addr(ha->addr)) 515b3343a2aSJohn Fastabend continue; 516b3343a2aSJohn Fastabend 517dee1ad47SJeff Kirsher vector_list[i++] = ixgbevf_mta_vector(hw, ha->addr); 518dee1ad47SJeff Kirsher } 519dee1ad47SJeff Kirsher 5206a11e52bSTony Nguyen ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, IXGBE_VFMAILBOX_SIZE); 521dee1ad47SJeff Kirsher 522dee1ad47SJeff Kirsher return 0; 523dee1ad47SJeff Kirsher } 524dee1ad47SJeff Kirsher 525dee1ad47SJeff Kirsher /** 526c6d45171SKY Srinivasan * Hyper-V variant - just a stub. 527c6d45171SKY Srinivasan */ 528c6d45171SKY Srinivasan static s32 ixgbevf_hv_update_mc_addr_list_vf(struct ixgbe_hw *hw, 529c6d45171SKY Srinivasan struct net_device *netdev) 530c6d45171SKY Srinivasan { 531c6d45171SKY Srinivasan return -EOPNOTSUPP; 532c6d45171SKY Srinivasan } 533c6d45171SKY Srinivasan 534c6d45171SKY Srinivasan /** 5358443c1a4SHiroshi Shimamoto * ixgbevf_update_xcast_mode - Update Multicast mode 5368443c1a4SHiroshi Shimamoto * @hw: pointer to the HW structure 5378443c1a4SHiroshi Shimamoto * @xcast_mode: new multicast mode 5388443c1a4SHiroshi Shimamoto * 5398443c1a4SHiroshi Shimamoto * Updates the Multicast Mode of VF. 5408443c1a4SHiroshi Shimamoto **/ 5418b44a8a0STony Nguyen static s32 ixgbevf_update_xcast_mode(struct ixgbe_hw *hw, int xcast_mode) 5428443c1a4SHiroshi Shimamoto { 5438443c1a4SHiroshi Shimamoto u32 msgbuf[2]; 5448443c1a4SHiroshi Shimamoto s32 err; 5458443c1a4SHiroshi Shimamoto 5468443c1a4SHiroshi Shimamoto switch (hw->api_version) { 5478443c1a4SHiroshi Shimamoto case ixgbe_mbox_api_12: 5488443c1a4SHiroshi Shimamoto break; 5498443c1a4SHiroshi Shimamoto default: 5508443c1a4SHiroshi Shimamoto return -EOPNOTSUPP; 5518443c1a4SHiroshi Shimamoto } 5528443c1a4SHiroshi Shimamoto 5538443c1a4SHiroshi Shimamoto msgbuf[0] = IXGBE_VF_UPDATE_XCAST_MODE; 5548443c1a4SHiroshi Shimamoto msgbuf[1] = xcast_mode; 5558443c1a4SHiroshi Shimamoto 556c6426971SEmil Tantilov err = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 557c6426971SEmil Tantilov sizeof(msgbuf) / sizeof(u32)); 5588443c1a4SHiroshi Shimamoto if (err) 5598443c1a4SHiroshi Shimamoto return err; 5608443c1a4SHiroshi Shimamoto 5618443c1a4SHiroshi Shimamoto msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 5628443c1a4SHiroshi Shimamoto if (msgbuf[0] == (IXGBE_VF_UPDATE_XCAST_MODE | IXGBE_VT_MSGTYPE_NACK)) 5638443c1a4SHiroshi Shimamoto return -EPERM; 5648443c1a4SHiroshi Shimamoto 5658443c1a4SHiroshi Shimamoto return 0; 5668443c1a4SHiroshi Shimamoto } 5678443c1a4SHiroshi Shimamoto 5688443c1a4SHiroshi Shimamoto /** 569c6d45171SKY Srinivasan * Hyper-V variant - just a stub. 570c6d45171SKY Srinivasan */ 5718b44a8a0STony Nguyen static s32 ixgbevf_hv_update_xcast_mode(struct ixgbe_hw *hw, int xcast_mode) 572c6d45171SKY Srinivasan { 573c6d45171SKY Srinivasan return -EOPNOTSUPP; 574c6d45171SKY Srinivasan } 575c6d45171SKY Srinivasan 576c6d45171SKY Srinivasan /** 577dec0d8e4SJeff Kirsher * ixgbevf_set_vfta_vf - Set/Unset VLAN filter table address 578dee1ad47SJeff Kirsher * @hw: pointer to the HW structure 579dee1ad47SJeff Kirsher * @vlan: 12 bit VLAN ID 580dee1ad47SJeff Kirsher * @vind: unused by VF drivers 581dee1ad47SJeff Kirsher * @vlan_on: if true then set bit, else clear bit 582dee1ad47SJeff Kirsher **/ 583dee1ad47SJeff Kirsher static s32 ixgbevf_set_vfta_vf(struct ixgbe_hw *hw, u32 vlan, u32 vind, 584dee1ad47SJeff Kirsher bool vlan_on) 585dee1ad47SJeff Kirsher { 586dee1ad47SJeff Kirsher u32 msgbuf[2]; 5872ddc7fe1SAlexander Duyck s32 err; 588dee1ad47SJeff Kirsher 589dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_SET_VLAN; 590dee1ad47SJeff Kirsher msgbuf[1] = vlan; 591dee1ad47SJeff Kirsher /* Setting the 8 bit field MSG INFO to TRUE indicates "add" */ 592dee1ad47SJeff Kirsher msgbuf[0] |= vlan_on << IXGBE_VT_MSGINFO_SHIFT; 593dee1ad47SJeff Kirsher 594c6426971SEmil Tantilov err = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 595c6426971SEmil Tantilov sizeof(msgbuf) / sizeof(u32)); 5962ddc7fe1SAlexander Duyck if (err) 5972ddc7fe1SAlexander Duyck goto mbx_err; 5982ddc7fe1SAlexander Duyck 5992ddc7fe1SAlexander Duyck /* remove extra bits from the message */ 6002ddc7fe1SAlexander Duyck msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 6012ddc7fe1SAlexander Duyck msgbuf[0] &= ~(0xFF << IXGBE_VT_MSGINFO_SHIFT); 6022ddc7fe1SAlexander Duyck 6032ddc7fe1SAlexander Duyck if (msgbuf[0] != (IXGBE_VF_SET_VLAN | IXGBE_VT_MSGTYPE_ACK)) 6042ddc7fe1SAlexander Duyck err = IXGBE_ERR_INVALID_ARGUMENT; 6052ddc7fe1SAlexander Duyck 6062ddc7fe1SAlexander Duyck mbx_err: 6072ddc7fe1SAlexander Duyck return err; 608dee1ad47SJeff Kirsher } 609dee1ad47SJeff Kirsher 610dee1ad47SJeff Kirsher /** 611c6d45171SKY Srinivasan * Hyper-V variant - just a stub. 612c6d45171SKY Srinivasan */ 613c6d45171SKY Srinivasan static s32 ixgbevf_hv_set_vfta_vf(struct ixgbe_hw *hw, u32 vlan, u32 vind, 614c6d45171SKY Srinivasan bool vlan_on) 615c6d45171SKY Srinivasan { 616c6d45171SKY Srinivasan return -EOPNOTSUPP; 617c6d45171SKY Srinivasan } 618c6d45171SKY Srinivasan 619c6d45171SKY Srinivasan /** 620dee1ad47SJeff Kirsher * ixgbevf_setup_mac_link_vf - Setup MAC link settings 621dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 622dee1ad47SJeff Kirsher * @speed: Unused in this implementation 623dee1ad47SJeff Kirsher * @autoneg: Unused in this implementation 624dee1ad47SJeff Kirsher * @autoneg_wait_to_complete: Unused in this implementation 625dee1ad47SJeff Kirsher * 626dee1ad47SJeff Kirsher * Do nothing and return success. VF drivers are not allowed to change 627dee1ad47SJeff Kirsher * global settings. Maintained for driver compatibility. 628dee1ad47SJeff Kirsher **/ 629dee1ad47SJeff Kirsher static s32 ixgbevf_setup_mac_link_vf(struct ixgbe_hw *hw, 630dee1ad47SJeff Kirsher ixgbe_link_speed speed, bool autoneg, 631dee1ad47SJeff Kirsher bool autoneg_wait_to_complete) 632dee1ad47SJeff Kirsher { 633dee1ad47SJeff Kirsher return 0; 634dee1ad47SJeff Kirsher } 635dee1ad47SJeff Kirsher 636dee1ad47SJeff Kirsher /** 637dee1ad47SJeff Kirsher * ixgbevf_check_mac_link_vf - Get link/speed status 638dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 639dee1ad47SJeff Kirsher * @speed: pointer to link speed 640dee1ad47SJeff Kirsher * @link_up: true is link is up, false otherwise 641dee1ad47SJeff Kirsher * @autoneg_wait_to_complete: true when waiting for completion is needed 642dee1ad47SJeff Kirsher * 643dee1ad47SJeff Kirsher * Reads the links register to determine if link is up and the current speed 644dee1ad47SJeff Kirsher **/ 645dee1ad47SJeff Kirsher static s32 ixgbevf_check_mac_link_vf(struct ixgbe_hw *hw, 646dee1ad47SJeff Kirsher ixgbe_link_speed *speed, 647dee1ad47SJeff Kirsher bool *link_up, 648dee1ad47SJeff Kirsher bool autoneg_wait_to_complete) 649dee1ad47SJeff Kirsher { 6504b2cd27fSAlexander Duyck struct ixgbe_mbx_info *mbx = &hw->mbx; 6514b2cd27fSAlexander Duyck struct ixgbe_mac_info *mac = &hw->mac; 6524b2cd27fSAlexander Duyck s32 ret_val = 0; 653dee1ad47SJeff Kirsher u32 links_reg; 6544b2cd27fSAlexander Duyck u32 in_msg = 0; 655dee1ad47SJeff Kirsher 6564b2cd27fSAlexander Duyck /* If we were hit with a reset drop the link */ 6574b2cd27fSAlexander Duyck if (!mbx->ops.check_for_rst(hw) || !mbx->timeout) 6584b2cd27fSAlexander Duyck mac->get_link_status = true; 659dee1ad47SJeff Kirsher 6604b2cd27fSAlexander Duyck if (!mac->get_link_status) 6614b2cd27fSAlexander Duyck goto out; 6624b2cd27fSAlexander Duyck 6634b2cd27fSAlexander Duyck /* if link status is down no point in checking to see if pf is up */ 664dee1ad47SJeff Kirsher links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 6654b2cd27fSAlexander Duyck if (!(links_reg & IXGBE_LINKS_UP)) 6664b2cd27fSAlexander Duyck goto out; 667dee1ad47SJeff Kirsher 668b8a2ca19SEmil Tantilov /* for SFP+ modules and DA cables on 82599 it can take up to 500usecs 669b8a2ca19SEmil Tantilov * before the link status is correct 670b8a2ca19SEmil Tantilov */ 671b8a2ca19SEmil Tantilov if (mac->type == ixgbe_mac_82599_vf) { 672b8a2ca19SEmil Tantilov int i; 673b8a2ca19SEmil Tantilov 674b8a2ca19SEmil Tantilov for (i = 0; i < 5; i++) { 675b8a2ca19SEmil Tantilov udelay(100); 676b8a2ca19SEmil Tantilov links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 677b8a2ca19SEmil Tantilov 678b8a2ca19SEmil Tantilov if (!(links_reg & IXGBE_LINKS_UP)) 679b8a2ca19SEmil Tantilov goto out; 680b8a2ca19SEmil Tantilov } 681b8a2ca19SEmil Tantilov } 682b8a2ca19SEmil Tantilov 68331a1b375SGreg Rose switch (links_reg & IXGBE_LINKS_SPEED_82599) { 68431a1b375SGreg Rose case IXGBE_LINKS_SPEED_10G_82599: 685dee1ad47SJeff Kirsher *speed = IXGBE_LINK_SPEED_10GB_FULL; 68631a1b375SGreg Rose break; 68731a1b375SGreg Rose case IXGBE_LINKS_SPEED_1G_82599: 688dee1ad47SJeff Kirsher *speed = IXGBE_LINK_SPEED_1GB_FULL; 68931a1b375SGreg Rose break; 69031a1b375SGreg Rose case IXGBE_LINKS_SPEED_100_82599: 69131a1b375SGreg Rose *speed = IXGBE_LINK_SPEED_100_FULL; 69231a1b375SGreg Rose break; 69331a1b375SGreg Rose } 694dee1ad47SJeff Kirsher 6954b2cd27fSAlexander Duyck /* if the read failed it could just be a mailbox collision, best wait 696dec0d8e4SJeff Kirsher * until we are called again and don't report an error 697dec0d8e4SJeff Kirsher */ 6984b2cd27fSAlexander Duyck if (mbx->ops.read(hw, &in_msg, 1)) 6994b2cd27fSAlexander Duyck goto out; 7004b2cd27fSAlexander Duyck 7014b2cd27fSAlexander Duyck if (!(in_msg & IXGBE_VT_MSGTYPE_CTS)) { 7024b2cd27fSAlexander Duyck /* msg is not CTS and is NACK we must have lost CTS status */ 7034b2cd27fSAlexander Duyck if (in_msg & IXGBE_VT_MSGTYPE_NACK) 7044b2cd27fSAlexander Duyck ret_val = -1; 7054b2cd27fSAlexander Duyck goto out; 7064b2cd27fSAlexander Duyck } 7074b2cd27fSAlexander Duyck 7084b2cd27fSAlexander Duyck /* the pf is talking, if we timed out in the past we reinit */ 7094b2cd27fSAlexander Duyck if (!mbx->timeout) { 7104b2cd27fSAlexander Duyck ret_val = -1; 7114b2cd27fSAlexander Duyck goto out; 7124b2cd27fSAlexander Duyck } 7134b2cd27fSAlexander Duyck 7144b2cd27fSAlexander Duyck /* if we passed all the tests above then the link is up and we no 715dec0d8e4SJeff Kirsher * longer need to check for link 716dec0d8e4SJeff Kirsher */ 7174b2cd27fSAlexander Duyck mac->get_link_status = false; 7184b2cd27fSAlexander Duyck 7194b2cd27fSAlexander Duyck out: 7204b2cd27fSAlexander Duyck *link_up = !mac->get_link_status; 7214b2cd27fSAlexander Duyck return ret_val; 722dee1ad47SJeff Kirsher } 723dee1ad47SJeff Kirsher 724dd1fe113SAlexander Duyck /** 725c6d45171SKY Srinivasan * Hyper-V variant; there is no mailbox communication. 726c6d45171SKY Srinivasan */ 727c6d45171SKY Srinivasan static s32 ixgbevf_hv_check_mac_link_vf(struct ixgbe_hw *hw, 728c6d45171SKY Srinivasan ixgbe_link_speed *speed, 729c6d45171SKY Srinivasan bool *link_up, 730c6d45171SKY Srinivasan bool autoneg_wait_to_complete) 731c6d45171SKY Srinivasan { 732c6d45171SKY Srinivasan struct ixgbe_mbx_info *mbx = &hw->mbx; 733c6d45171SKY Srinivasan struct ixgbe_mac_info *mac = &hw->mac; 734c6d45171SKY Srinivasan u32 links_reg; 735c6d45171SKY Srinivasan 736c6d45171SKY Srinivasan /* If we were hit with a reset drop the link */ 737c6d45171SKY Srinivasan if (!mbx->ops.check_for_rst(hw) || !mbx->timeout) 738c6d45171SKY Srinivasan mac->get_link_status = true; 739c6d45171SKY Srinivasan 740c6d45171SKY Srinivasan if (!mac->get_link_status) 741c6d45171SKY Srinivasan goto out; 742c6d45171SKY Srinivasan 743c6d45171SKY Srinivasan /* if link status is down no point in checking to see if pf is up */ 744c6d45171SKY Srinivasan links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 745c6d45171SKY Srinivasan if (!(links_reg & IXGBE_LINKS_UP)) 746c6d45171SKY Srinivasan goto out; 747c6d45171SKY Srinivasan 748c6d45171SKY Srinivasan /* for SFP+ modules and DA cables on 82599 it can take up to 500usecs 749c6d45171SKY Srinivasan * before the link status is correct 750c6d45171SKY Srinivasan */ 751c6d45171SKY Srinivasan if (mac->type == ixgbe_mac_82599_vf) { 752c6d45171SKY Srinivasan int i; 753c6d45171SKY Srinivasan 754c6d45171SKY Srinivasan for (i = 0; i < 5; i++) { 755c6d45171SKY Srinivasan udelay(100); 756c6d45171SKY Srinivasan links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 757c6d45171SKY Srinivasan 758c6d45171SKY Srinivasan if (!(links_reg & IXGBE_LINKS_UP)) 759c6d45171SKY Srinivasan goto out; 760c6d45171SKY Srinivasan } 761c6d45171SKY Srinivasan } 762c6d45171SKY Srinivasan 763c6d45171SKY Srinivasan switch (links_reg & IXGBE_LINKS_SPEED_82599) { 764c6d45171SKY Srinivasan case IXGBE_LINKS_SPEED_10G_82599: 765c6d45171SKY Srinivasan *speed = IXGBE_LINK_SPEED_10GB_FULL; 766c6d45171SKY Srinivasan break; 767c6d45171SKY Srinivasan case IXGBE_LINKS_SPEED_1G_82599: 768c6d45171SKY Srinivasan *speed = IXGBE_LINK_SPEED_1GB_FULL; 769c6d45171SKY Srinivasan break; 770c6d45171SKY Srinivasan case IXGBE_LINKS_SPEED_100_82599: 771c6d45171SKY Srinivasan *speed = IXGBE_LINK_SPEED_100_FULL; 772c6d45171SKY Srinivasan break; 773c6d45171SKY Srinivasan } 774c6d45171SKY Srinivasan 775c6d45171SKY Srinivasan /* if we passed all the tests above then the link is up and we no 776c6d45171SKY Srinivasan * longer need to check for link 777c6d45171SKY Srinivasan */ 778c6d45171SKY Srinivasan mac->get_link_status = false; 779c6d45171SKY Srinivasan 780c6d45171SKY Srinivasan out: 781c6d45171SKY Srinivasan *link_up = !mac->get_link_status; 782c6d45171SKY Srinivasan return 0; 783c6d45171SKY Srinivasan } 784c6d45171SKY Srinivasan 785c6d45171SKY Srinivasan /** 7862f8214feSAlexander Duyck * ixgbevf_set_rlpml_vf - Set the maximum receive packet length 787dd1fe113SAlexander Duyck * @hw: pointer to the HW structure 788dd1fe113SAlexander Duyck * @max_size: value to assign to max frame size 789dd1fe113SAlexander Duyck **/ 7906a11e52bSTony Nguyen static s32 ixgbevf_set_rlpml_vf(struct ixgbe_hw *hw, u16 max_size) 791dd1fe113SAlexander Duyck { 792dd1fe113SAlexander Duyck u32 msgbuf[2]; 7936a11e52bSTony Nguyen s32 ret_val; 794dd1fe113SAlexander Duyck 795dd1fe113SAlexander Duyck msgbuf[0] = IXGBE_VF_SET_LPE; 796dd1fe113SAlexander Duyck msgbuf[1] = max_size; 7976a11e52bSTony Nguyen 798c6426971SEmil Tantilov ret_val = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 799c6426971SEmil Tantilov sizeof(msgbuf) / sizeof(u32)); 8006a11e52bSTony Nguyen if (ret_val) 8016a11e52bSTony Nguyen return ret_val; 8026a11e52bSTony Nguyen if ((msgbuf[0] & IXGBE_VF_SET_LPE) && 8036a11e52bSTony Nguyen (msgbuf[0] & IXGBE_VT_MSGTYPE_NACK)) 8046a11e52bSTony Nguyen return IXGBE_ERR_MBX; 8056a11e52bSTony Nguyen 8066a11e52bSTony Nguyen return 0; 807dd1fe113SAlexander Duyck } 808dd1fe113SAlexander Duyck 80931186785SAlexander Duyck /** 8102f8214feSAlexander Duyck * ixgbevf_hv_set_rlpml_vf - Set the maximum receive packet length 811c6d45171SKY Srinivasan * @hw: pointer to the HW structure 812c6d45171SKY Srinivasan * @max_size: value to assign to max frame size 813c6d45171SKY Srinivasan * Hyper-V variant. 814c6d45171SKY Srinivasan **/ 8156a11e52bSTony Nguyen static s32 ixgbevf_hv_set_rlpml_vf(struct ixgbe_hw *hw, u16 max_size) 816c6d45171SKY Srinivasan { 817c6d45171SKY Srinivasan u32 reg; 818c6d45171SKY Srinivasan 819c6d45171SKY Srinivasan /* If we are on Hyper-V, we implement this functionality 820c6d45171SKY Srinivasan * differently. 821c6d45171SKY Srinivasan */ 822c6d45171SKY Srinivasan reg = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(0)); 823c6d45171SKY Srinivasan /* CRC == 4 */ 824c6d45171SKY Srinivasan reg |= ((max_size + 4) | IXGBE_RXDCTL_RLPML_EN); 825c6d45171SKY Srinivasan IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(0), reg); 8266a11e52bSTony Nguyen 8276a11e52bSTony Nguyen return 0; 828c6d45171SKY Srinivasan } 829c6d45171SKY Srinivasan 830c6d45171SKY Srinivasan /** 8317921f4dcSAlexander Duyck * ixgbevf_negotiate_api_version_vf - Negotiate supported API version 83231186785SAlexander Duyck * @hw: pointer to the HW structure 83331186785SAlexander Duyck * @api: integer containing requested API version 83431186785SAlexander Duyck **/ 8357921f4dcSAlexander Duyck static int ixgbevf_negotiate_api_version_vf(struct ixgbe_hw *hw, int api) 83631186785SAlexander Duyck { 83731186785SAlexander Duyck int err; 83831186785SAlexander Duyck u32 msg[3]; 83931186785SAlexander Duyck 84031186785SAlexander Duyck /* Negotiate the mailbox API version */ 84131186785SAlexander Duyck msg[0] = IXGBE_VF_API_NEGOTIATE; 84231186785SAlexander Duyck msg[1] = api; 84331186785SAlexander Duyck msg[2] = 0; 84431186785SAlexander Duyck 845c6426971SEmil Tantilov err = ixgbevf_write_msg_read_ack(hw, msg, msg, 846c6426971SEmil Tantilov sizeof(msg) / sizeof(u32)); 84731186785SAlexander Duyck if (!err) { 84831186785SAlexander Duyck msg[0] &= ~IXGBE_VT_MSGTYPE_CTS; 84931186785SAlexander Duyck 85031186785SAlexander Duyck /* Store value and return 0 on success */ 85131186785SAlexander Duyck if (msg[0] == (IXGBE_VF_API_NEGOTIATE | IXGBE_VT_MSGTYPE_ACK)) { 85231186785SAlexander Duyck hw->api_version = api; 85331186785SAlexander Duyck return 0; 85431186785SAlexander Duyck } 85531186785SAlexander Duyck 85631186785SAlexander Duyck err = IXGBE_ERR_INVALID_ARGUMENT; 85731186785SAlexander Duyck } 85831186785SAlexander Duyck 85931186785SAlexander Duyck return err; 86031186785SAlexander Duyck } 86131186785SAlexander Duyck 862c6d45171SKY Srinivasan /** 8632f8214feSAlexander Duyck * ixgbevf_hv_negotiate_api_version_vf - Negotiate supported API version 864c6d45171SKY Srinivasan * @hw: pointer to the HW structure 865c6d45171SKY Srinivasan * @api: integer containing requested API version 866c6d45171SKY Srinivasan * Hyper-V version - only ixgbe_mbox_api_10 supported. 867c6d45171SKY Srinivasan **/ 8682f8214feSAlexander Duyck static int ixgbevf_hv_negotiate_api_version_vf(struct ixgbe_hw *hw, int api) 869c6d45171SKY Srinivasan { 870c6d45171SKY Srinivasan /* Hyper-V only supports api version ixgbe_mbox_api_10 */ 871c6d45171SKY Srinivasan if (api != ixgbe_mbox_api_10) 872c6d45171SKY Srinivasan return IXGBE_ERR_INVALID_ARGUMENT; 873c6d45171SKY Srinivasan 874c6d45171SKY Srinivasan return 0; 875c6d45171SKY Srinivasan } 876c6d45171SKY Srinivasan 87756e94095SAlexander Duyck int ixgbevf_get_queues(struct ixgbe_hw *hw, unsigned int *num_tcs, 87856e94095SAlexander Duyck unsigned int *default_tc) 87956e94095SAlexander Duyck { 88056e94095SAlexander Duyck int err; 88156e94095SAlexander Duyck u32 msg[5]; 88256e94095SAlexander Duyck 88356e94095SAlexander Duyck /* do nothing if API doesn't support ixgbevf_get_queues */ 88456e94095SAlexander Duyck switch (hw->api_version) { 88556e94095SAlexander Duyck case ixgbe_mbox_api_11: 88694cf66f8SVlad Zolotarov case ixgbe_mbox_api_12: 88756e94095SAlexander Duyck break; 88856e94095SAlexander Duyck default: 88956e94095SAlexander Duyck return 0; 89056e94095SAlexander Duyck } 89156e94095SAlexander Duyck 89256e94095SAlexander Duyck /* Fetch queue configuration from the PF */ 89356e94095SAlexander Duyck msg[0] = IXGBE_VF_GET_QUEUE; 89456e94095SAlexander Duyck msg[1] = msg[2] = msg[3] = msg[4] = 0; 89556e94095SAlexander Duyck 896c6426971SEmil Tantilov err = ixgbevf_write_msg_read_ack(hw, msg, msg, 897c6426971SEmil Tantilov sizeof(msg) / sizeof(u32)); 89856e94095SAlexander Duyck if (!err) { 89956e94095SAlexander Duyck msg[0] &= ~IXGBE_VT_MSGTYPE_CTS; 90056e94095SAlexander Duyck 901dec0d8e4SJeff Kirsher /* if we we didn't get an ACK there must have been 90256e94095SAlexander Duyck * some sort of mailbox error so we should treat it 90356e94095SAlexander Duyck * as such 90456e94095SAlexander Duyck */ 90556e94095SAlexander Duyck if (msg[0] != (IXGBE_VF_GET_QUEUE | IXGBE_VT_MSGTYPE_ACK)) 90656e94095SAlexander Duyck return IXGBE_ERR_MBX; 90756e94095SAlexander Duyck 90856e94095SAlexander Duyck /* record and validate values from message */ 90956e94095SAlexander Duyck hw->mac.max_tx_queues = msg[IXGBE_VF_TX_QUEUES]; 91056e94095SAlexander Duyck if (hw->mac.max_tx_queues == 0 || 91156e94095SAlexander Duyck hw->mac.max_tx_queues > IXGBE_VF_MAX_TX_QUEUES) 91256e94095SAlexander Duyck hw->mac.max_tx_queues = IXGBE_VF_MAX_TX_QUEUES; 91356e94095SAlexander Duyck 91456e94095SAlexander Duyck hw->mac.max_rx_queues = msg[IXGBE_VF_RX_QUEUES]; 91556e94095SAlexander Duyck if (hw->mac.max_rx_queues == 0 || 91656e94095SAlexander Duyck hw->mac.max_rx_queues > IXGBE_VF_MAX_RX_QUEUES) 91756e94095SAlexander Duyck hw->mac.max_rx_queues = IXGBE_VF_MAX_RX_QUEUES; 91856e94095SAlexander Duyck 91956e94095SAlexander Duyck *num_tcs = msg[IXGBE_VF_TRANS_VLAN]; 92056e94095SAlexander Duyck /* in case of unknown state assume we cannot tag frames */ 92156e94095SAlexander Duyck if (*num_tcs > hw->mac.max_rx_queues) 92256e94095SAlexander Duyck *num_tcs = 1; 92356e94095SAlexander Duyck 92456e94095SAlexander Duyck *default_tc = msg[IXGBE_VF_DEF_QUEUE]; 92556e94095SAlexander Duyck /* default to queue 0 on out-of-bounds queue number */ 92656e94095SAlexander Duyck if (*default_tc >= hw->mac.max_tx_queues) 92756e94095SAlexander Duyck *default_tc = 0; 92856e94095SAlexander Duyck } 92956e94095SAlexander Duyck 93056e94095SAlexander Duyck return err; 93156e94095SAlexander Duyck } 93256e94095SAlexander Duyck 9333d8fe98fSStephen Hemminger static const struct ixgbe_mac_operations ixgbevf_mac_ops = { 934dee1ad47SJeff Kirsher .init_hw = ixgbevf_init_hw_vf, 935dee1ad47SJeff Kirsher .reset_hw = ixgbevf_reset_hw_vf, 936dee1ad47SJeff Kirsher .start_hw = ixgbevf_start_hw_vf, 937dee1ad47SJeff Kirsher .get_mac_addr = ixgbevf_get_mac_addr_vf, 938dee1ad47SJeff Kirsher .stop_adapter = ixgbevf_stop_hw_vf, 939dee1ad47SJeff Kirsher .setup_link = ixgbevf_setup_mac_link_vf, 940dee1ad47SJeff Kirsher .check_link = ixgbevf_check_mac_link_vf, 9417921f4dcSAlexander Duyck .negotiate_api_version = ixgbevf_negotiate_api_version_vf, 942dee1ad47SJeff Kirsher .set_rar = ixgbevf_set_rar_vf, 943dee1ad47SJeff Kirsher .update_mc_addr_list = ixgbevf_update_mc_addr_list_vf, 9448443c1a4SHiroshi Shimamoto .update_xcast_mode = ixgbevf_update_xcast_mode, 945dee1ad47SJeff Kirsher .set_uc_addr = ixgbevf_set_uc_addr_vf, 946dee1ad47SJeff Kirsher .set_vfta = ixgbevf_set_vfta_vf, 9472f8214feSAlexander Duyck .set_rlpml = ixgbevf_set_rlpml_vf, 948dee1ad47SJeff Kirsher }; 949dee1ad47SJeff Kirsher 950c6d45171SKY Srinivasan static const struct ixgbe_mac_operations ixgbevf_hv_mac_ops = { 951c6d45171SKY Srinivasan .init_hw = ixgbevf_init_hw_vf, 952c6d45171SKY Srinivasan .reset_hw = ixgbevf_hv_reset_hw_vf, 953c6d45171SKY Srinivasan .start_hw = ixgbevf_start_hw_vf, 954c6d45171SKY Srinivasan .get_mac_addr = ixgbevf_get_mac_addr_vf, 955c6d45171SKY Srinivasan .stop_adapter = ixgbevf_stop_hw_vf, 956c6d45171SKY Srinivasan .setup_link = ixgbevf_setup_mac_link_vf, 957c6d45171SKY Srinivasan .check_link = ixgbevf_hv_check_mac_link_vf, 9582f8214feSAlexander Duyck .negotiate_api_version = ixgbevf_hv_negotiate_api_version_vf, 959c6d45171SKY Srinivasan .set_rar = ixgbevf_hv_set_rar_vf, 960c6d45171SKY Srinivasan .update_mc_addr_list = ixgbevf_hv_update_mc_addr_list_vf, 961c6d45171SKY Srinivasan .update_xcast_mode = ixgbevf_hv_update_xcast_mode, 962c6d45171SKY Srinivasan .set_uc_addr = ixgbevf_hv_set_uc_addr_vf, 963c6d45171SKY Srinivasan .set_vfta = ixgbevf_hv_set_vfta_vf, 9642f8214feSAlexander Duyck .set_rlpml = ixgbevf_hv_set_rlpml_vf, 965c6d45171SKY Srinivasan }; 966c6d45171SKY Srinivasan 9673d8fe98fSStephen Hemminger const struct ixgbevf_info ixgbevf_82599_vf_info = { 968dee1ad47SJeff Kirsher .mac = ixgbe_mac_82599_vf, 969dee1ad47SJeff Kirsher .mac_ops = &ixgbevf_mac_ops, 970dee1ad47SJeff Kirsher }; 971dee1ad47SJeff Kirsher 972c6d45171SKY Srinivasan const struct ixgbevf_info ixgbevf_82599_vf_hv_info = { 973c6d45171SKY Srinivasan .mac = ixgbe_mac_82599_vf, 974c6d45171SKY Srinivasan .mac_ops = &ixgbevf_hv_mac_ops, 975c6d45171SKY Srinivasan }; 976c6d45171SKY Srinivasan 9773d8fe98fSStephen Hemminger const struct ixgbevf_info ixgbevf_X540_vf_info = { 978dee1ad47SJeff Kirsher .mac = ixgbe_mac_X540_vf, 979dee1ad47SJeff Kirsher .mac_ops = &ixgbevf_mac_ops, 980dee1ad47SJeff Kirsher }; 98147068b0dSEmil Tantilov 982c6d45171SKY Srinivasan const struct ixgbevf_info ixgbevf_X540_vf_hv_info = { 983c6d45171SKY Srinivasan .mac = ixgbe_mac_X540_vf, 984c6d45171SKY Srinivasan .mac_ops = &ixgbevf_hv_mac_ops, 985c6d45171SKY Srinivasan }; 986c6d45171SKY Srinivasan 98747068b0dSEmil Tantilov const struct ixgbevf_info ixgbevf_X550_vf_info = { 98847068b0dSEmil Tantilov .mac = ixgbe_mac_X550_vf, 98947068b0dSEmil Tantilov .mac_ops = &ixgbevf_mac_ops, 99047068b0dSEmil Tantilov }; 99147068b0dSEmil Tantilov 992c6d45171SKY Srinivasan const struct ixgbevf_info ixgbevf_X550_vf_hv_info = { 993c6d45171SKY Srinivasan .mac = ixgbe_mac_X550_vf, 994c6d45171SKY Srinivasan .mac_ops = &ixgbevf_hv_mac_ops, 995c6d45171SKY Srinivasan }; 996c6d45171SKY Srinivasan 99747068b0dSEmil Tantilov const struct ixgbevf_info ixgbevf_X550EM_x_vf_info = { 99847068b0dSEmil Tantilov .mac = ixgbe_mac_X550EM_x_vf, 99947068b0dSEmil Tantilov .mac_ops = &ixgbevf_mac_ops, 100047068b0dSEmil Tantilov }; 1001c6d45171SKY Srinivasan 1002c6d45171SKY Srinivasan const struct ixgbevf_info ixgbevf_X550EM_x_vf_hv_info = { 1003c6d45171SKY Srinivasan .mac = ixgbe_mac_X550EM_x_vf, 1004c6d45171SKY Srinivasan .mac_ops = &ixgbevf_hv_mac_ops, 1005c6d45171SKY Srinivasan }; 10061d94f987SDon Skidmore 10071d94f987SDon Skidmore const struct ixgbevf_info ixgbevf_x550em_a_vf_info = { 10081d94f987SDon Skidmore .mac = ixgbe_mac_x550em_a_vf, 10091d94f987SDon Skidmore .mac_ops = &ixgbevf_mac_ops, 10101d94f987SDon Skidmore }; 1011