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. 149e23cf38fSTony Nguyen * @hw: pointer to private hardware struct 150c6d45171SKY Srinivasan */ 151c6d45171SKY Srinivasan static s32 ixgbevf_hv_reset_hw_vf(struct ixgbe_hw *hw) 152c6d45171SKY Srinivasan { 153c6d45171SKY Srinivasan #if IS_ENABLED(CONFIG_PCI_MMCONFIG) 154c6d45171SKY Srinivasan struct ixgbevf_adapter *adapter = hw->back; 155c6d45171SKY Srinivasan int i; 156c6d45171SKY Srinivasan 157c6d45171SKY Srinivasan for (i = 0; i < 6; i++) 158c6d45171SKY Srinivasan pci_read_config_byte(adapter->pdev, 159c6d45171SKY Srinivasan (i + IXGBE_HV_RESET_OFFSET), 160c6d45171SKY Srinivasan &hw->mac.perm_addr[i]); 161c6d45171SKY Srinivasan return 0; 162c6d45171SKY Srinivasan #else 163c6d45171SKY Srinivasan pr_err("PCI_MMCONFIG needs to be enabled for Hyper-V\n"); 164c6d45171SKY Srinivasan return -EOPNOTSUPP; 165c6d45171SKY Srinivasan #endif 166c6d45171SKY Srinivasan } 167c6d45171SKY Srinivasan 168c6d45171SKY Srinivasan /** 169dee1ad47SJeff Kirsher * ixgbevf_stop_hw_vf - Generic stop Tx/Rx units 170dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 171dee1ad47SJeff Kirsher * 172dee1ad47SJeff Kirsher * Sets the adapter_stopped flag within ixgbe_hw struct. Clears interrupts, 173dee1ad47SJeff Kirsher * disables transmit and receive units. The adapter_stopped flag is used by 174dee1ad47SJeff Kirsher * the shared code and drivers to determine if the adapter is in a stopped 175dee1ad47SJeff Kirsher * state and should not touch the hardware. 176dee1ad47SJeff Kirsher **/ 177dee1ad47SJeff Kirsher static s32 ixgbevf_stop_hw_vf(struct ixgbe_hw *hw) 178dee1ad47SJeff Kirsher { 179dee1ad47SJeff Kirsher u32 number_of_queues; 180dee1ad47SJeff Kirsher u32 reg_val; 181dee1ad47SJeff Kirsher u16 i; 182dee1ad47SJeff Kirsher 183dec0d8e4SJeff Kirsher /* Set the adapter_stopped flag so other driver functions stop touching 184dee1ad47SJeff Kirsher * the hardware 185dee1ad47SJeff Kirsher */ 186dee1ad47SJeff Kirsher hw->adapter_stopped = true; 187dee1ad47SJeff Kirsher 188dee1ad47SJeff Kirsher /* Disable the receive unit by stopped each queue */ 189dee1ad47SJeff Kirsher number_of_queues = hw->mac.max_rx_queues; 190dee1ad47SJeff Kirsher for (i = 0; i < number_of_queues; i++) { 191dee1ad47SJeff Kirsher reg_val = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i)); 192dee1ad47SJeff Kirsher if (reg_val & IXGBE_RXDCTL_ENABLE) { 193dee1ad47SJeff Kirsher reg_val &= ~IXGBE_RXDCTL_ENABLE; 194dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(i), reg_val); 195dee1ad47SJeff Kirsher } 196dee1ad47SJeff Kirsher } 197dee1ad47SJeff Kirsher 198dee1ad47SJeff Kirsher IXGBE_WRITE_FLUSH(hw); 199dee1ad47SJeff Kirsher 200dee1ad47SJeff Kirsher /* Clear interrupt mask to stop from interrupts being generated */ 201dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VTEIMC, IXGBE_VF_IRQ_CLEAR_MASK); 202dee1ad47SJeff Kirsher 203dee1ad47SJeff Kirsher /* Clear any pending interrupts */ 204dee1ad47SJeff Kirsher IXGBE_READ_REG(hw, IXGBE_VTEICR); 205dee1ad47SJeff Kirsher 206dee1ad47SJeff Kirsher /* Disable the transmit unit. Each queue must be disabled. */ 207dee1ad47SJeff Kirsher number_of_queues = hw->mac.max_tx_queues; 208dee1ad47SJeff Kirsher for (i = 0; i < number_of_queues; i++) { 209dee1ad47SJeff Kirsher reg_val = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i)); 210dee1ad47SJeff Kirsher if (reg_val & IXGBE_TXDCTL_ENABLE) { 211dee1ad47SJeff Kirsher reg_val &= ~IXGBE_TXDCTL_ENABLE; 212dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(i), reg_val); 213dee1ad47SJeff Kirsher } 214dee1ad47SJeff Kirsher } 215dee1ad47SJeff Kirsher 216dee1ad47SJeff Kirsher return 0; 217dee1ad47SJeff Kirsher } 218dee1ad47SJeff Kirsher 219dee1ad47SJeff Kirsher /** 220dee1ad47SJeff Kirsher * ixgbevf_mta_vector - Determines bit-vector in multicast table to set 221dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 222dee1ad47SJeff Kirsher * @mc_addr: the multicast address 223dee1ad47SJeff Kirsher * 224dee1ad47SJeff Kirsher * Extracts the 12 bits, from a multicast address, to determine which 225dee1ad47SJeff Kirsher * bit-vector to set in the multicast table. The hardware uses 12 bits, from 226dec0d8e4SJeff Kirsher * incoming Rx multicast addresses, to determine the bit-vector to check in 227dee1ad47SJeff Kirsher * the MTA. Which of the 4 combination, of 12-bits, the hardware uses is set 228dee1ad47SJeff Kirsher * by the MO field of the MCSTCTRL. The MO field is set during initialization 229dee1ad47SJeff Kirsher * to mc_filter_type. 230dee1ad47SJeff Kirsher **/ 231dee1ad47SJeff Kirsher static s32 ixgbevf_mta_vector(struct ixgbe_hw *hw, u8 *mc_addr) 232dee1ad47SJeff Kirsher { 233dee1ad47SJeff Kirsher u32 vector = 0; 234dee1ad47SJeff Kirsher 235dee1ad47SJeff Kirsher switch (hw->mac.mc_filter_type) { 236dee1ad47SJeff Kirsher case 0: /* use bits [47:36] of the address */ 237dee1ad47SJeff Kirsher vector = ((mc_addr[4] >> 4) | (((u16)mc_addr[5]) << 4)); 238dee1ad47SJeff Kirsher break; 239dee1ad47SJeff Kirsher case 1: /* use bits [46:35] of the address */ 240dee1ad47SJeff Kirsher vector = ((mc_addr[4] >> 3) | (((u16)mc_addr[5]) << 5)); 241dee1ad47SJeff Kirsher break; 242dee1ad47SJeff Kirsher case 2: /* use bits [45:34] of the address */ 243dee1ad47SJeff Kirsher vector = ((mc_addr[4] >> 2) | (((u16)mc_addr[5]) << 6)); 244dee1ad47SJeff Kirsher break; 245dee1ad47SJeff Kirsher case 3: /* use bits [43:32] of the address */ 246dee1ad47SJeff Kirsher vector = ((mc_addr[4]) | (((u16)mc_addr[5]) << 8)); 247dee1ad47SJeff Kirsher break; 248dee1ad47SJeff Kirsher default: /* Invalid mc_filter_type */ 249dee1ad47SJeff Kirsher break; 250dee1ad47SJeff Kirsher } 251dee1ad47SJeff Kirsher 252dee1ad47SJeff Kirsher /* vector can only be 12-bits or boundary will be exceeded */ 253dee1ad47SJeff Kirsher vector &= 0xFFF; 254dee1ad47SJeff Kirsher return vector; 255dee1ad47SJeff Kirsher } 256dee1ad47SJeff Kirsher 257dee1ad47SJeff Kirsher /** 258dee1ad47SJeff Kirsher * ixgbevf_get_mac_addr_vf - Read device MAC address 259dee1ad47SJeff Kirsher * @hw: pointer to the HW structure 260dee1ad47SJeff Kirsher * @mac_addr: pointer to storage for retrieved MAC address 261dee1ad47SJeff Kirsher **/ 262dee1ad47SJeff Kirsher static s32 ixgbevf_get_mac_addr_vf(struct ixgbe_hw *hw, u8 *mac_addr) 263dee1ad47SJeff Kirsher { 2640d8bb414SJeff Kirsher ether_addr_copy(mac_addr, hw->mac.perm_addr); 265dee1ad47SJeff Kirsher 266dee1ad47SJeff Kirsher return 0; 267dee1ad47SJeff Kirsher } 268dee1ad47SJeff Kirsher 269dee1ad47SJeff Kirsher static s32 ixgbevf_set_uc_addr_vf(struct ixgbe_hw *hw, u32 index, u8 *addr) 270dee1ad47SJeff Kirsher { 271fc355e07SEmil Tantilov u32 msgbuf[3], msgbuf_chk; 272dee1ad47SJeff Kirsher u8 *msg_addr = (u8 *)(&msgbuf[1]); 273dee1ad47SJeff Kirsher s32 ret_val; 274dee1ad47SJeff Kirsher 275dee1ad47SJeff Kirsher memset(msgbuf, 0, sizeof(msgbuf)); 276dec0d8e4SJeff Kirsher /* If index is one then this is the start of a new list and needs 277dee1ad47SJeff Kirsher * indication to the PF so it can do it's own list management. 278dee1ad47SJeff Kirsher * If it is zero then that tells the PF to just clear all of 279dee1ad47SJeff Kirsher * this VF's macvlans and there is no new list. 280dee1ad47SJeff Kirsher */ 281dee1ad47SJeff Kirsher msgbuf[0] |= index << IXGBE_VT_MSGINFO_SHIFT; 282dee1ad47SJeff Kirsher msgbuf[0] |= IXGBE_VF_SET_MACVLAN; 283fc355e07SEmil Tantilov msgbuf_chk = msgbuf[0]; 284fc355e07SEmil Tantilov 285dee1ad47SJeff Kirsher if (addr) 2860d8bb414SJeff Kirsher ether_addr_copy(msg_addr, addr); 287dee1ad47SJeff Kirsher 288c6426971SEmil Tantilov ret_val = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 2894078ea37SColin Ian King ARRAY_SIZE(msgbuf)); 290fc355e07SEmil Tantilov if (!ret_val) { 291dee1ad47SJeff Kirsher msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 292dee1ad47SJeff Kirsher 293fc355e07SEmil Tantilov if (msgbuf[0] == (msgbuf_chk | IXGBE_VT_MSGTYPE_NACK)) 294fc355e07SEmil Tantilov return -ENOMEM; 295fc355e07SEmil Tantilov } 296dee1ad47SJeff Kirsher 297dee1ad47SJeff Kirsher return ret_val; 298dee1ad47SJeff Kirsher } 299dee1ad47SJeff Kirsher 300c6d45171SKY Srinivasan static s32 ixgbevf_hv_set_uc_addr_vf(struct ixgbe_hw *hw, u32 index, u8 *addr) 301c6d45171SKY Srinivasan { 302c6d45171SKY Srinivasan return -EOPNOTSUPP; 303c6d45171SKY Srinivasan } 304c6d45171SKY Srinivasan 305dee1ad47SJeff Kirsher /** 30694cf66f8SVlad Zolotarov * ixgbevf_get_reta_locked - get the RSS redirection table (RETA) contents. 307e23cf38fSTony Nguyen * @hw: pointer to hardware structure 30894cf66f8SVlad Zolotarov * @reta: buffer to fill with RETA contents. 30994cf66f8SVlad Zolotarov * @num_rx_queues: Number of Rx queues configured for this port 31094cf66f8SVlad Zolotarov * 31194cf66f8SVlad Zolotarov * The "reta" buffer should be big enough to contain 32 registers. 31294cf66f8SVlad Zolotarov * 31394cf66f8SVlad Zolotarov * Returns: 0 on success. 31494cf66f8SVlad Zolotarov * if API doesn't support this operation - (-EOPNOTSUPP). 31594cf66f8SVlad Zolotarov */ 31694cf66f8SVlad Zolotarov int ixgbevf_get_reta_locked(struct ixgbe_hw *hw, u32 *reta, int num_rx_queues) 31794cf66f8SVlad Zolotarov { 31894cf66f8SVlad Zolotarov int err, i, j; 31994cf66f8SVlad Zolotarov u32 msgbuf[IXGBE_VFMAILBOX_SIZE]; 32094cf66f8SVlad Zolotarov u32 *hw_reta = &msgbuf[1]; 32194cf66f8SVlad Zolotarov u32 mask = 0; 32294cf66f8SVlad Zolotarov 32394cf66f8SVlad Zolotarov /* We have to use a mailbox for 82599 and x540 devices only. 32494cf66f8SVlad Zolotarov * For these devices RETA has 128 entries. 32594cf66f8SVlad Zolotarov * Also these VFs support up to 4 RSS queues. Therefore PF will compress 32694cf66f8SVlad Zolotarov * 16 RETA entries in each DWORD giving 2 bits to each entry. 32794cf66f8SVlad Zolotarov */ 32894cf66f8SVlad Zolotarov int dwords = IXGBEVF_82599_RETA_SIZE / 16; 32994cf66f8SVlad Zolotarov 33094cf66f8SVlad Zolotarov /* We support the RSS querying for 82599 and x540 devices only. 33194cf66f8SVlad Zolotarov * Thus return an error if API doesn't support RETA querying or querying 33294cf66f8SVlad Zolotarov * is not supported for this device type. 33394cf66f8SVlad Zolotarov */ 33441e544cdSDon Skidmore switch (hw->api_version) { 33541e544cdSDon Skidmore case ixgbe_mbox_api_13: 33641e544cdSDon Skidmore case ixgbe_mbox_api_12: 33782fb670cSTony Nguyen if (hw->mac.type < ixgbe_mac_X550_vf) 33841e544cdSDon Skidmore break; 33980666035STony Nguyen /* fall through */ 34041e544cdSDon Skidmore default: 34194cf66f8SVlad Zolotarov return -EOPNOTSUPP; 34241e544cdSDon Skidmore } 34394cf66f8SVlad Zolotarov 34494cf66f8SVlad Zolotarov msgbuf[0] = IXGBE_VF_GET_RETA; 34594cf66f8SVlad Zolotarov 34694cf66f8SVlad Zolotarov err = hw->mbx.ops.write_posted(hw, msgbuf, 1); 34794cf66f8SVlad Zolotarov 34894cf66f8SVlad Zolotarov if (err) 34994cf66f8SVlad Zolotarov return err; 35094cf66f8SVlad Zolotarov 35194cf66f8SVlad Zolotarov err = hw->mbx.ops.read_posted(hw, msgbuf, dwords + 1); 35294cf66f8SVlad Zolotarov 35394cf66f8SVlad Zolotarov if (err) 35494cf66f8SVlad Zolotarov return err; 35594cf66f8SVlad Zolotarov 35694cf66f8SVlad Zolotarov msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 35794cf66f8SVlad Zolotarov 35894cf66f8SVlad Zolotarov /* If the operation has been refused by a PF return -EPERM */ 35994cf66f8SVlad Zolotarov if (msgbuf[0] == (IXGBE_VF_GET_RETA | IXGBE_VT_MSGTYPE_NACK)) 36094cf66f8SVlad Zolotarov return -EPERM; 36194cf66f8SVlad Zolotarov 36294cf66f8SVlad Zolotarov /* If we didn't get an ACK there must have been 36394cf66f8SVlad Zolotarov * some sort of mailbox error so we should treat it 36494cf66f8SVlad Zolotarov * as such. 36594cf66f8SVlad Zolotarov */ 36694cf66f8SVlad Zolotarov if (msgbuf[0] != (IXGBE_VF_GET_RETA | IXGBE_VT_MSGTYPE_ACK)) 36794cf66f8SVlad Zolotarov return IXGBE_ERR_MBX; 36894cf66f8SVlad Zolotarov 36994cf66f8SVlad Zolotarov /* ixgbevf doesn't support more than 2 queues at the moment */ 37094cf66f8SVlad Zolotarov if (num_rx_queues > 1) 37194cf66f8SVlad Zolotarov mask = 0x1; 37294cf66f8SVlad Zolotarov 37394cf66f8SVlad Zolotarov for (i = 0; i < dwords; i++) 37494cf66f8SVlad Zolotarov for (j = 0; j < 16; j++) 37594cf66f8SVlad Zolotarov reta[i * 16 + j] = (hw_reta[i] >> (2 * j)) & mask; 37694cf66f8SVlad Zolotarov 37794cf66f8SVlad Zolotarov return 0; 37894cf66f8SVlad Zolotarov } 37994cf66f8SVlad Zolotarov 38094cf66f8SVlad Zolotarov /** 381ad1431e2SVlad Zolotarov * ixgbevf_get_rss_key_locked - get the RSS Random Key 382ad1431e2SVlad Zolotarov * @hw: pointer to the HW structure 383ad1431e2SVlad Zolotarov * @rss_key: buffer to fill with RSS Hash Key contents. 384ad1431e2SVlad Zolotarov * 385ad1431e2SVlad Zolotarov * The "rss_key" buffer should be big enough to contain 10 registers. 386ad1431e2SVlad Zolotarov * 387ad1431e2SVlad Zolotarov * Returns: 0 on success. 388ad1431e2SVlad Zolotarov * if API doesn't support this operation - (-EOPNOTSUPP). 389ad1431e2SVlad Zolotarov */ 390ad1431e2SVlad Zolotarov int ixgbevf_get_rss_key_locked(struct ixgbe_hw *hw, u8 *rss_key) 391ad1431e2SVlad Zolotarov { 392ad1431e2SVlad Zolotarov int err; 393ad1431e2SVlad Zolotarov u32 msgbuf[IXGBE_VFMAILBOX_SIZE]; 394ad1431e2SVlad Zolotarov 395ad1431e2SVlad Zolotarov /* We currently support the RSS Random Key retrieval for 82599 and x540 396ad1431e2SVlad Zolotarov * devices only. 397ad1431e2SVlad Zolotarov * 398ad1431e2SVlad Zolotarov * Thus return an error if API doesn't support RSS Random Key retrieval 399ad1431e2SVlad Zolotarov * or if the operation is not supported for this device type. 400ad1431e2SVlad Zolotarov */ 40141e544cdSDon Skidmore switch (hw->api_version) { 40241e544cdSDon Skidmore case ixgbe_mbox_api_13: 40341e544cdSDon Skidmore case ixgbe_mbox_api_12: 40482fb670cSTony Nguyen if (hw->mac.type < ixgbe_mac_X550_vf) 40541e544cdSDon Skidmore break; 40680666035STony Nguyen /* fall through */ 40741e544cdSDon Skidmore default: 408ad1431e2SVlad Zolotarov return -EOPNOTSUPP; 40941e544cdSDon Skidmore } 410ad1431e2SVlad Zolotarov 411ad1431e2SVlad Zolotarov msgbuf[0] = IXGBE_VF_GET_RSS_KEY; 412ad1431e2SVlad Zolotarov err = hw->mbx.ops.write_posted(hw, msgbuf, 1); 413ad1431e2SVlad Zolotarov 414ad1431e2SVlad Zolotarov if (err) 415ad1431e2SVlad Zolotarov return err; 416ad1431e2SVlad Zolotarov 417ad1431e2SVlad Zolotarov err = hw->mbx.ops.read_posted(hw, msgbuf, 11); 418ad1431e2SVlad Zolotarov 419ad1431e2SVlad Zolotarov if (err) 420ad1431e2SVlad Zolotarov return err; 421ad1431e2SVlad Zolotarov 422ad1431e2SVlad Zolotarov msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 423ad1431e2SVlad Zolotarov 424ad1431e2SVlad Zolotarov /* If the operation has been refused by a PF return -EPERM */ 42582fb670cSTony Nguyen if (msgbuf[0] == (IXGBE_VF_GET_RSS_KEY | IXGBE_VT_MSGTYPE_NACK)) 426ad1431e2SVlad Zolotarov return -EPERM; 427ad1431e2SVlad Zolotarov 428ad1431e2SVlad Zolotarov /* If we didn't get an ACK there must have been 429ad1431e2SVlad Zolotarov * some sort of mailbox error so we should treat it 430ad1431e2SVlad Zolotarov * as such. 431ad1431e2SVlad Zolotarov */ 432ad1431e2SVlad Zolotarov if (msgbuf[0] != (IXGBE_VF_GET_RSS_KEY | IXGBE_VT_MSGTYPE_ACK)) 433ad1431e2SVlad Zolotarov return IXGBE_ERR_MBX; 434ad1431e2SVlad Zolotarov 435ad1431e2SVlad Zolotarov memcpy(rss_key, msgbuf + 1, IXGBEVF_RSS_HASH_KEY_SIZE); 436ad1431e2SVlad Zolotarov 437ad1431e2SVlad Zolotarov return 0; 438ad1431e2SVlad Zolotarov } 439ad1431e2SVlad Zolotarov 440ad1431e2SVlad Zolotarov /** 441dee1ad47SJeff Kirsher * ixgbevf_set_rar_vf - set device MAC address 442dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 443dee1ad47SJeff Kirsher * @index: Receive address register to write 444dee1ad47SJeff Kirsher * @addr: Address to put into receive address register 445dee1ad47SJeff Kirsher * @vmdq: Unused in this implementation 446dee1ad47SJeff Kirsher **/ 447dee1ad47SJeff Kirsher static s32 ixgbevf_set_rar_vf(struct ixgbe_hw *hw, u32 index, u8 *addr, 448dee1ad47SJeff Kirsher u32 vmdq) 449dee1ad47SJeff Kirsher { 450dee1ad47SJeff Kirsher u32 msgbuf[3]; 451dee1ad47SJeff Kirsher u8 *msg_addr = (u8 *)(&msgbuf[1]); 452dee1ad47SJeff Kirsher s32 ret_val; 453dee1ad47SJeff Kirsher 454dee1ad47SJeff Kirsher memset(msgbuf, 0, sizeof(msgbuf)); 455dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_SET_MAC_ADDR; 4560d8bb414SJeff Kirsher ether_addr_copy(msg_addr, addr); 457dee1ad47SJeff Kirsher 458c6426971SEmil Tantilov ret_val = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 4594078ea37SColin Ian King ARRAY_SIZE(msgbuf)); 460dee1ad47SJeff Kirsher msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 461dee1ad47SJeff Kirsher 462dee1ad47SJeff Kirsher /* if nacked the address was rejected, use "perm_addr" */ 463dee1ad47SJeff Kirsher if (!ret_val && 46432ca6868SEmil Tantilov (msgbuf[0] == (IXGBE_VF_SET_MAC_ADDR | IXGBE_VT_MSGTYPE_NACK))) { 465dee1ad47SJeff Kirsher ixgbevf_get_mac_addr_vf(hw, hw->mac.addr); 46632ca6868SEmil Tantilov return IXGBE_ERR_MBX; 46732ca6868SEmil Tantilov } 468dee1ad47SJeff Kirsher 469dee1ad47SJeff Kirsher return ret_val; 470dee1ad47SJeff Kirsher } 471dee1ad47SJeff Kirsher 472c6d45171SKY Srinivasan /** 473c6d45171SKY Srinivasan * ixgbevf_hv_set_rar_vf - set device MAC address Hyper-V variant 474c6d45171SKY Srinivasan * @hw: pointer to hardware structure 475c6d45171SKY Srinivasan * @index: Receive address register to write 476c6d45171SKY Srinivasan * @addr: Address to put into receive address register 477c6d45171SKY Srinivasan * @vmdq: Unused in this implementation 478c6d45171SKY Srinivasan * 479c6d45171SKY Srinivasan * We don't really allow setting the device MAC address. However, 480c6d45171SKY Srinivasan * if the address being set is the permanent MAC address we will 481c6d45171SKY Srinivasan * permit that. 482c6d45171SKY Srinivasan **/ 483c6d45171SKY Srinivasan static s32 ixgbevf_hv_set_rar_vf(struct ixgbe_hw *hw, u32 index, u8 *addr, 484c6d45171SKY Srinivasan u32 vmdq) 485c6d45171SKY Srinivasan { 486c6d45171SKY Srinivasan if (ether_addr_equal(addr, hw->mac.perm_addr)) 487c6d45171SKY Srinivasan return 0; 488c6d45171SKY Srinivasan 489c6d45171SKY Srinivasan return -EOPNOTSUPP; 490c6d45171SKY Srinivasan } 491c6d45171SKY Srinivasan 492dee1ad47SJeff Kirsher /** 493dee1ad47SJeff Kirsher * ixgbevf_update_mc_addr_list_vf - Update Multicast addresses 494dee1ad47SJeff Kirsher * @hw: pointer to the HW structure 495dee1ad47SJeff Kirsher * @netdev: pointer to net device structure 496dee1ad47SJeff Kirsher * 497dee1ad47SJeff Kirsher * Updates the Multicast Table Array. 498dee1ad47SJeff Kirsher **/ 499dee1ad47SJeff Kirsher static s32 ixgbevf_update_mc_addr_list_vf(struct ixgbe_hw *hw, 500dee1ad47SJeff Kirsher struct net_device *netdev) 501dee1ad47SJeff Kirsher { 502dee1ad47SJeff Kirsher struct netdev_hw_addr *ha; 503dee1ad47SJeff Kirsher u32 msgbuf[IXGBE_VFMAILBOX_SIZE]; 504dee1ad47SJeff Kirsher u16 *vector_list = (u16 *)&msgbuf[1]; 505dee1ad47SJeff Kirsher u32 cnt, i; 506dee1ad47SJeff Kirsher 507dee1ad47SJeff Kirsher /* Each entry in the list uses 1 16 bit word. We have 30 508dee1ad47SJeff Kirsher * 16 bit words available in our HW msg buffer (minus 1 for the 509dee1ad47SJeff Kirsher * msg type). That's 30 hash values if we pack 'em right. If 510dee1ad47SJeff Kirsher * there are more than 30 MC addresses to add then punt the 511dee1ad47SJeff Kirsher * extras for now and then add code to handle more than 30 later. 512dee1ad47SJeff Kirsher * It would be unusual for a server to request that many multi-cast 513dee1ad47SJeff Kirsher * addresses except for in large enterprise network environments. 514dee1ad47SJeff Kirsher */ 515dee1ad47SJeff Kirsher 516dee1ad47SJeff Kirsher cnt = netdev_mc_count(netdev); 517dee1ad47SJeff Kirsher if (cnt > 30) 518dee1ad47SJeff Kirsher cnt = 30; 519dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_SET_MULTICAST; 520dee1ad47SJeff Kirsher msgbuf[0] |= cnt << IXGBE_VT_MSGINFO_SHIFT; 521dee1ad47SJeff Kirsher 522dee1ad47SJeff Kirsher i = 0; 523dee1ad47SJeff Kirsher netdev_for_each_mc_addr(ha, netdev) { 524dee1ad47SJeff Kirsher if (i == cnt) 525dee1ad47SJeff Kirsher break; 52646acc460SBen Hutchings if (is_link_local_ether_addr(ha->addr)) 527b3343a2aSJohn Fastabend continue; 528b3343a2aSJohn Fastabend 529dee1ad47SJeff Kirsher vector_list[i++] = ixgbevf_mta_vector(hw, ha->addr); 530dee1ad47SJeff Kirsher } 531dee1ad47SJeff Kirsher 5326a11e52bSTony Nguyen ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, IXGBE_VFMAILBOX_SIZE); 533dee1ad47SJeff Kirsher 534dee1ad47SJeff Kirsher return 0; 535dee1ad47SJeff Kirsher } 536dee1ad47SJeff Kirsher 537dee1ad47SJeff Kirsher /** 538c6d45171SKY Srinivasan * Hyper-V variant - just a stub. 539e23cf38fSTony Nguyen * @hw: unused 540e23cf38fSTony Nguyen * @netdev: unused 541c6d45171SKY Srinivasan */ 542c6d45171SKY Srinivasan static s32 ixgbevf_hv_update_mc_addr_list_vf(struct ixgbe_hw *hw, 543c6d45171SKY Srinivasan struct net_device *netdev) 544c6d45171SKY Srinivasan { 545c6d45171SKY Srinivasan return -EOPNOTSUPP; 546c6d45171SKY Srinivasan } 547c6d45171SKY Srinivasan 548c6d45171SKY Srinivasan /** 5498443c1a4SHiroshi Shimamoto * ixgbevf_update_xcast_mode - Update Multicast mode 5508443c1a4SHiroshi Shimamoto * @hw: pointer to the HW structure 5518443c1a4SHiroshi Shimamoto * @xcast_mode: new multicast mode 5528443c1a4SHiroshi Shimamoto * 5538443c1a4SHiroshi Shimamoto * Updates the Multicast Mode of VF. 5548443c1a4SHiroshi Shimamoto **/ 5558b44a8a0STony Nguyen static s32 ixgbevf_update_xcast_mode(struct ixgbe_hw *hw, int xcast_mode) 5568443c1a4SHiroshi Shimamoto { 5578443c1a4SHiroshi Shimamoto u32 msgbuf[2]; 5588443c1a4SHiroshi Shimamoto s32 err; 5598443c1a4SHiroshi Shimamoto 5608443c1a4SHiroshi Shimamoto switch (hw->api_version) { 5618443c1a4SHiroshi Shimamoto case ixgbe_mbox_api_12: 56241e544cdSDon Skidmore /* promisc introduced in 1.3 version */ 56341e544cdSDon Skidmore if (xcast_mode == IXGBEVF_XCAST_MODE_PROMISC) 56441e544cdSDon Skidmore return -EOPNOTSUPP; 56541e544cdSDon Skidmore /* Fall threw */ 56641e544cdSDon Skidmore case ixgbe_mbox_api_13: 5678443c1a4SHiroshi Shimamoto break; 5688443c1a4SHiroshi Shimamoto default: 5698443c1a4SHiroshi Shimamoto return -EOPNOTSUPP; 5708443c1a4SHiroshi Shimamoto } 5718443c1a4SHiroshi Shimamoto 5728443c1a4SHiroshi Shimamoto msgbuf[0] = IXGBE_VF_UPDATE_XCAST_MODE; 5738443c1a4SHiroshi Shimamoto msgbuf[1] = xcast_mode; 5748443c1a4SHiroshi Shimamoto 575c6426971SEmil Tantilov err = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 5764078ea37SColin Ian King ARRAY_SIZE(msgbuf)); 5778443c1a4SHiroshi Shimamoto if (err) 5788443c1a4SHiroshi Shimamoto return err; 5798443c1a4SHiroshi Shimamoto 5808443c1a4SHiroshi Shimamoto msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 5818443c1a4SHiroshi Shimamoto if (msgbuf[0] == (IXGBE_VF_UPDATE_XCAST_MODE | IXGBE_VT_MSGTYPE_NACK)) 5828443c1a4SHiroshi Shimamoto return -EPERM; 5838443c1a4SHiroshi Shimamoto 5848443c1a4SHiroshi Shimamoto return 0; 5858443c1a4SHiroshi Shimamoto } 5868443c1a4SHiroshi Shimamoto 5878443c1a4SHiroshi Shimamoto /** 588c6d45171SKY Srinivasan * Hyper-V variant - just a stub. 589e23cf38fSTony Nguyen * @hw: unused 590e23cf38fSTony Nguyen * @xcast_mode: unused 591c6d45171SKY Srinivasan */ 5928b44a8a0STony Nguyen static s32 ixgbevf_hv_update_xcast_mode(struct ixgbe_hw *hw, int xcast_mode) 593c6d45171SKY Srinivasan { 594c6d45171SKY Srinivasan return -EOPNOTSUPP; 595c6d45171SKY Srinivasan } 596c6d45171SKY Srinivasan 597c6d45171SKY Srinivasan /** 598dec0d8e4SJeff Kirsher * ixgbevf_set_vfta_vf - Set/Unset VLAN filter table address 599dee1ad47SJeff Kirsher * @hw: pointer to the HW structure 600dee1ad47SJeff Kirsher * @vlan: 12 bit VLAN ID 601dee1ad47SJeff Kirsher * @vind: unused by VF drivers 602dee1ad47SJeff Kirsher * @vlan_on: if true then set bit, else clear bit 603dee1ad47SJeff Kirsher **/ 604dee1ad47SJeff Kirsher static s32 ixgbevf_set_vfta_vf(struct ixgbe_hw *hw, u32 vlan, u32 vind, 605dee1ad47SJeff Kirsher bool vlan_on) 606dee1ad47SJeff Kirsher { 607dee1ad47SJeff Kirsher u32 msgbuf[2]; 6082ddc7fe1SAlexander Duyck s32 err; 609dee1ad47SJeff Kirsher 610dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_SET_VLAN; 611dee1ad47SJeff Kirsher msgbuf[1] = vlan; 612dee1ad47SJeff Kirsher /* Setting the 8 bit field MSG INFO to TRUE indicates "add" */ 613dee1ad47SJeff Kirsher msgbuf[0] |= vlan_on << IXGBE_VT_MSGINFO_SHIFT; 614dee1ad47SJeff Kirsher 615c6426971SEmil Tantilov err = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 6164078ea37SColin Ian King ARRAY_SIZE(msgbuf)); 6172ddc7fe1SAlexander Duyck if (err) 6182ddc7fe1SAlexander Duyck goto mbx_err; 6192ddc7fe1SAlexander Duyck 6202ddc7fe1SAlexander Duyck /* remove extra bits from the message */ 6212ddc7fe1SAlexander Duyck msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 6222ddc7fe1SAlexander Duyck msgbuf[0] &= ~(0xFF << IXGBE_VT_MSGINFO_SHIFT); 6232ddc7fe1SAlexander Duyck 6242ddc7fe1SAlexander Duyck if (msgbuf[0] != (IXGBE_VF_SET_VLAN | IXGBE_VT_MSGTYPE_ACK)) 6252ddc7fe1SAlexander Duyck err = IXGBE_ERR_INVALID_ARGUMENT; 6262ddc7fe1SAlexander Duyck 6272ddc7fe1SAlexander Duyck mbx_err: 6282ddc7fe1SAlexander Duyck return err; 629dee1ad47SJeff Kirsher } 630dee1ad47SJeff Kirsher 631dee1ad47SJeff Kirsher /** 632c6d45171SKY Srinivasan * Hyper-V variant - just a stub. 633e23cf38fSTony Nguyen * @hw: unused 634e23cf38fSTony Nguyen * @vlan: unused 635e23cf38fSTony Nguyen * @vind: unused 636e23cf38fSTony Nguyen * @vlan_on: unused 637c6d45171SKY Srinivasan */ 638c6d45171SKY Srinivasan static s32 ixgbevf_hv_set_vfta_vf(struct ixgbe_hw *hw, u32 vlan, u32 vind, 639c6d45171SKY Srinivasan bool vlan_on) 640c6d45171SKY Srinivasan { 641c6d45171SKY Srinivasan return -EOPNOTSUPP; 642c6d45171SKY Srinivasan } 643c6d45171SKY Srinivasan 644c6d45171SKY Srinivasan /** 645dee1ad47SJeff Kirsher * ixgbevf_setup_mac_link_vf - Setup MAC link settings 646dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 647dee1ad47SJeff Kirsher * @speed: Unused in this implementation 648dee1ad47SJeff Kirsher * @autoneg: Unused in this implementation 649dee1ad47SJeff Kirsher * @autoneg_wait_to_complete: Unused in this implementation 650dee1ad47SJeff Kirsher * 651dee1ad47SJeff Kirsher * Do nothing and return success. VF drivers are not allowed to change 652dee1ad47SJeff Kirsher * global settings. Maintained for driver compatibility. 653dee1ad47SJeff Kirsher **/ 654dee1ad47SJeff Kirsher static s32 ixgbevf_setup_mac_link_vf(struct ixgbe_hw *hw, 655dee1ad47SJeff Kirsher ixgbe_link_speed speed, bool autoneg, 656dee1ad47SJeff Kirsher bool autoneg_wait_to_complete) 657dee1ad47SJeff Kirsher { 658dee1ad47SJeff Kirsher return 0; 659dee1ad47SJeff Kirsher } 660dee1ad47SJeff Kirsher 661dee1ad47SJeff Kirsher /** 662dee1ad47SJeff Kirsher * ixgbevf_check_mac_link_vf - Get link/speed status 663dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 664dee1ad47SJeff Kirsher * @speed: pointer to link speed 665dee1ad47SJeff Kirsher * @link_up: true is link is up, false otherwise 666e23cf38fSTony Nguyen * @autoneg_wait_to_complete: unused 667dee1ad47SJeff Kirsher * 668dee1ad47SJeff Kirsher * Reads the links register to determine if link is up and the current speed 669dee1ad47SJeff Kirsher **/ 670dee1ad47SJeff Kirsher static s32 ixgbevf_check_mac_link_vf(struct ixgbe_hw *hw, 671dee1ad47SJeff Kirsher ixgbe_link_speed *speed, 672dee1ad47SJeff Kirsher bool *link_up, 673dee1ad47SJeff Kirsher bool autoneg_wait_to_complete) 674dee1ad47SJeff Kirsher { 6754b2cd27fSAlexander Duyck struct ixgbe_mbx_info *mbx = &hw->mbx; 6764b2cd27fSAlexander Duyck struct ixgbe_mac_info *mac = &hw->mac; 6774b2cd27fSAlexander Duyck s32 ret_val = 0; 678dee1ad47SJeff Kirsher u32 links_reg; 6794b2cd27fSAlexander Duyck u32 in_msg = 0; 680dee1ad47SJeff Kirsher 6814b2cd27fSAlexander Duyck /* If we were hit with a reset drop the link */ 6824b2cd27fSAlexander Duyck if (!mbx->ops.check_for_rst(hw) || !mbx->timeout) 6834b2cd27fSAlexander Duyck mac->get_link_status = true; 684dee1ad47SJeff Kirsher 6854b2cd27fSAlexander Duyck if (!mac->get_link_status) 6864b2cd27fSAlexander Duyck goto out; 6874b2cd27fSAlexander Duyck 6884b2cd27fSAlexander Duyck /* if link status is down no point in checking to see if pf is up */ 689dee1ad47SJeff Kirsher links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 6904b2cd27fSAlexander Duyck if (!(links_reg & IXGBE_LINKS_UP)) 6914b2cd27fSAlexander Duyck goto out; 692dee1ad47SJeff Kirsher 693b8a2ca19SEmil Tantilov /* for SFP+ modules and DA cables on 82599 it can take up to 500usecs 694b8a2ca19SEmil Tantilov * before the link status is correct 695b8a2ca19SEmil Tantilov */ 696b8a2ca19SEmil Tantilov if (mac->type == ixgbe_mac_82599_vf) { 697b8a2ca19SEmil Tantilov int i; 698b8a2ca19SEmil Tantilov 699b8a2ca19SEmil Tantilov for (i = 0; i < 5; i++) { 700b8a2ca19SEmil Tantilov udelay(100); 701b8a2ca19SEmil Tantilov links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 702b8a2ca19SEmil Tantilov 703b8a2ca19SEmil Tantilov if (!(links_reg & IXGBE_LINKS_UP)) 704b8a2ca19SEmil Tantilov goto out; 705b8a2ca19SEmil Tantilov } 706b8a2ca19SEmil Tantilov } 707b8a2ca19SEmil Tantilov 70831a1b375SGreg Rose switch (links_reg & IXGBE_LINKS_SPEED_82599) { 70931a1b375SGreg Rose case IXGBE_LINKS_SPEED_10G_82599: 710dee1ad47SJeff Kirsher *speed = IXGBE_LINK_SPEED_10GB_FULL; 71131a1b375SGreg Rose break; 71231a1b375SGreg Rose case IXGBE_LINKS_SPEED_1G_82599: 713dee1ad47SJeff Kirsher *speed = IXGBE_LINK_SPEED_1GB_FULL; 71431a1b375SGreg Rose break; 71531a1b375SGreg Rose case IXGBE_LINKS_SPEED_100_82599: 71631a1b375SGreg Rose *speed = IXGBE_LINK_SPEED_100_FULL; 71731a1b375SGreg Rose break; 71831a1b375SGreg Rose } 719dee1ad47SJeff Kirsher 7204b2cd27fSAlexander Duyck /* if the read failed it could just be a mailbox collision, best wait 721dec0d8e4SJeff Kirsher * until we are called again and don't report an error 722dec0d8e4SJeff Kirsher */ 7234b2cd27fSAlexander Duyck if (mbx->ops.read(hw, &in_msg, 1)) 7244b2cd27fSAlexander Duyck goto out; 7254b2cd27fSAlexander Duyck 7264b2cd27fSAlexander Duyck if (!(in_msg & IXGBE_VT_MSGTYPE_CTS)) { 7274b2cd27fSAlexander Duyck /* msg is not CTS and is NACK we must have lost CTS status */ 7284b2cd27fSAlexander Duyck if (in_msg & IXGBE_VT_MSGTYPE_NACK) 7294b2cd27fSAlexander Duyck ret_val = -1; 7304b2cd27fSAlexander Duyck goto out; 7314b2cd27fSAlexander Duyck } 7324b2cd27fSAlexander Duyck 7334b2cd27fSAlexander Duyck /* the pf is talking, if we timed out in the past we reinit */ 7344b2cd27fSAlexander Duyck if (!mbx->timeout) { 7354b2cd27fSAlexander Duyck ret_val = -1; 7364b2cd27fSAlexander Duyck goto out; 7374b2cd27fSAlexander Duyck } 7384b2cd27fSAlexander Duyck 7394b2cd27fSAlexander Duyck /* if we passed all the tests above then the link is up and we no 740dec0d8e4SJeff Kirsher * longer need to check for link 741dec0d8e4SJeff Kirsher */ 7424b2cd27fSAlexander Duyck mac->get_link_status = false; 7434b2cd27fSAlexander Duyck 7444b2cd27fSAlexander Duyck out: 7454b2cd27fSAlexander Duyck *link_up = !mac->get_link_status; 7464b2cd27fSAlexander Duyck return ret_val; 747dee1ad47SJeff Kirsher } 748dee1ad47SJeff Kirsher 749dd1fe113SAlexander Duyck /** 750c6d45171SKY Srinivasan * Hyper-V variant; there is no mailbox communication. 751e23cf38fSTony Nguyen * @hw: pointer to private hardware struct 752e23cf38fSTony Nguyen * @speed: pointer to link speed 753e23cf38fSTony Nguyen * @link_up: true is link is up, false otherwise 754e23cf38fSTony Nguyen * @autoneg_wait_to_complete: unused 755c6d45171SKY Srinivasan */ 756c6d45171SKY Srinivasan static s32 ixgbevf_hv_check_mac_link_vf(struct ixgbe_hw *hw, 757c6d45171SKY Srinivasan ixgbe_link_speed *speed, 758c6d45171SKY Srinivasan bool *link_up, 759c6d45171SKY Srinivasan bool autoneg_wait_to_complete) 760c6d45171SKY Srinivasan { 761c6d45171SKY Srinivasan struct ixgbe_mbx_info *mbx = &hw->mbx; 762c6d45171SKY Srinivasan struct ixgbe_mac_info *mac = &hw->mac; 763c6d45171SKY Srinivasan u32 links_reg; 764c6d45171SKY Srinivasan 765c6d45171SKY Srinivasan /* If we were hit with a reset drop the link */ 766c6d45171SKY Srinivasan if (!mbx->ops.check_for_rst(hw) || !mbx->timeout) 767c6d45171SKY Srinivasan mac->get_link_status = true; 768c6d45171SKY Srinivasan 769c6d45171SKY Srinivasan if (!mac->get_link_status) 770c6d45171SKY Srinivasan goto out; 771c6d45171SKY Srinivasan 772c6d45171SKY Srinivasan /* if link status is down no point in checking to see if pf is up */ 773c6d45171SKY Srinivasan links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 774c6d45171SKY Srinivasan if (!(links_reg & IXGBE_LINKS_UP)) 775c6d45171SKY Srinivasan goto out; 776c6d45171SKY Srinivasan 777c6d45171SKY Srinivasan /* for SFP+ modules and DA cables on 82599 it can take up to 500usecs 778c6d45171SKY Srinivasan * before the link status is correct 779c6d45171SKY Srinivasan */ 780c6d45171SKY Srinivasan if (mac->type == ixgbe_mac_82599_vf) { 781c6d45171SKY Srinivasan int i; 782c6d45171SKY Srinivasan 783c6d45171SKY Srinivasan for (i = 0; i < 5; i++) { 784c6d45171SKY Srinivasan udelay(100); 785c6d45171SKY Srinivasan links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 786c6d45171SKY Srinivasan 787c6d45171SKY Srinivasan if (!(links_reg & IXGBE_LINKS_UP)) 788c6d45171SKY Srinivasan goto out; 789c6d45171SKY Srinivasan } 790c6d45171SKY Srinivasan } 791c6d45171SKY Srinivasan 792c6d45171SKY Srinivasan switch (links_reg & IXGBE_LINKS_SPEED_82599) { 793c6d45171SKY Srinivasan case IXGBE_LINKS_SPEED_10G_82599: 794c6d45171SKY Srinivasan *speed = IXGBE_LINK_SPEED_10GB_FULL; 795c6d45171SKY Srinivasan break; 796c6d45171SKY Srinivasan case IXGBE_LINKS_SPEED_1G_82599: 797c6d45171SKY Srinivasan *speed = IXGBE_LINK_SPEED_1GB_FULL; 798c6d45171SKY Srinivasan break; 799c6d45171SKY Srinivasan case IXGBE_LINKS_SPEED_100_82599: 800c6d45171SKY Srinivasan *speed = IXGBE_LINK_SPEED_100_FULL; 801c6d45171SKY Srinivasan break; 802c6d45171SKY Srinivasan } 803c6d45171SKY Srinivasan 804c6d45171SKY Srinivasan /* if we passed all the tests above then the link is up and we no 805c6d45171SKY Srinivasan * longer need to check for link 806c6d45171SKY Srinivasan */ 807c6d45171SKY Srinivasan mac->get_link_status = false; 808c6d45171SKY Srinivasan 809c6d45171SKY Srinivasan out: 810c6d45171SKY Srinivasan *link_up = !mac->get_link_status; 811c6d45171SKY Srinivasan return 0; 812c6d45171SKY Srinivasan } 813c6d45171SKY Srinivasan 814c6d45171SKY Srinivasan /** 8152f8214feSAlexander Duyck * ixgbevf_set_rlpml_vf - Set the maximum receive packet length 816dd1fe113SAlexander Duyck * @hw: pointer to the HW structure 817dd1fe113SAlexander Duyck * @max_size: value to assign to max frame size 818dd1fe113SAlexander Duyck **/ 8196a11e52bSTony Nguyen static s32 ixgbevf_set_rlpml_vf(struct ixgbe_hw *hw, u16 max_size) 820dd1fe113SAlexander Duyck { 821dd1fe113SAlexander Duyck u32 msgbuf[2]; 8226a11e52bSTony Nguyen s32 ret_val; 823dd1fe113SAlexander Duyck 824dd1fe113SAlexander Duyck msgbuf[0] = IXGBE_VF_SET_LPE; 825dd1fe113SAlexander Duyck msgbuf[1] = max_size; 8266a11e52bSTony Nguyen 827c6426971SEmil Tantilov ret_val = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 8284078ea37SColin Ian King ARRAY_SIZE(msgbuf)); 8296a11e52bSTony Nguyen if (ret_val) 8306a11e52bSTony Nguyen return ret_val; 8316a11e52bSTony Nguyen if ((msgbuf[0] & IXGBE_VF_SET_LPE) && 8326a11e52bSTony Nguyen (msgbuf[0] & IXGBE_VT_MSGTYPE_NACK)) 8336a11e52bSTony Nguyen return IXGBE_ERR_MBX; 8346a11e52bSTony Nguyen 8356a11e52bSTony Nguyen return 0; 836dd1fe113SAlexander Duyck } 837dd1fe113SAlexander Duyck 83831186785SAlexander Duyck /** 8392f8214feSAlexander Duyck * ixgbevf_hv_set_rlpml_vf - Set the maximum receive packet length 840c6d45171SKY Srinivasan * @hw: pointer to the HW structure 841c6d45171SKY Srinivasan * @max_size: value to assign to max frame size 842c6d45171SKY Srinivasan * Hyper-V variant. 843c6d45171SKY Srinivasan **/ 8446a11e52bSTony Nguyen static s32 ixgbevf_hv_set_rlpml_vf(struct ixgbe_hw *hw, u16 max_size) 845c6d45171SKY Srinivasan { 846c6d45171SKY Srinivasan u32 reg; 847c6d45171SKY Srinivasan 848c6d45171SKY Srinivasan /* If we are on Hyper-V, we implement this functionality 849c6d45171SKY Srinivasan * differently. 850c6d45171SKY Srinivasan */ 851c6d45171SKY Srinivasan reg = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(0)); 852c6d45171SKY Srinivasan /* CRC == 4 */ 853c6d45171SKY Srinivasan reg |= ((max_size + 4) | IXGBE_RXDCTL_RLPML_EN); 854c6d45171SKY Srinivasan IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(0), reg); 8556a11e52bSTony Nguyen 8566a11e52bSTony Nguyen return 0; 857c6d45171SKY Srinivasan } 858c6d45171SKY Srinivasan 859c6d45171SKY Srinivasan /** 8607921f4dcSAlexander Duyck * ixgbevf_negotiate_api_version_vf - Negotiate supported API version 86131186785SAlexander Duyck * @hw: pointer to the HW structure 86231186785SAlexander Duyck * @api: integer containing requested API version 86331186785SAlexander Duyck **/ 8647921f4dcSAlexander Duyck static int ixgbevf_negotiate_api_version_vf(struct ixgbe_hw *hw, int api) 86531186785SAlexander Duyck { 86631186785SAlexander Duyck int err; 86731186785SAlexander Duyck u32 msg[3]; 86831186785SAlexander Duyck 86931186785SAlexander Duyck /* Negotiate the mailbox API version */ 87031186785SAlexander Duyck msg[0] = IXGBE_VF_API_NEGOTIATE; 87131186785SAlexander Duyck msg[1] = api; 87231186785SAlexander Duyck msg[2] = 0; 87331186785SAlexander Duyck 8744078ea37SColin Ian King err = ixgbevf_write_msg_read_ack(hw, msg, msg, ARRAY_SIZE(msg)); 87531186785SAlexander Duyck if (!err) { 87631186785SAlexander Duyck msg[0] &= ~IXGBE_VT_MSGTYPE_CTS; 87731186785SAlexander Duyck 87831186785SAlexander Duyck /* Store value and return 0 on success */ 87931186785SAlexander Duyck if (msg[0] == (IXGBE_VF_API_NEGOTIATE | IXGBE_VT_MSGTYPE_ACK)) { 88031186785SAlexander Duyck hw->api_version = api; 88131186785SAlexander Duyck return 0; 88231186785SAlexander Duyck } 88331186785SAlexander Duyck 88431186785SAlexander Duyck err = IXGBE_ERR_INVALID_ARGUMENT; 88531186785SAlexander Duyck } 88631186785SAlexander Duyck 88731186785SAlexander Duyck return err; 88831186785SAlexander Duyck } 88931186785SAlexander Duyck 890c6d45171SKY Srinivasan /** 8912f8214feSAlexander Duyck * ixgbevf_hv_negotiate_api_version_vf - Negotiate supported API version 892c6d45171SKY Srinivasan * @hw: pointer to the HW structure 893c6d45171SKY Srinivasan * @api: integer containing requested API version 894c6d45171SKY Srinivasan * Hyper-V version - only ixgbe_mbox_api_10 supported. 895c6d45171SKY Srinivasan **/ 8962f8214feSAlexander Duyck static int ixgbevf_hv_negotiate_api_version_vf(struct ixgbe_hw *hw, int api) 897c6d45171SKY Srinivasan { 898c6d45171SKY Srinivasan /* Hyper-V only supports api version ixgbe_mbox_api_10 */ 899c6d45171SKY Srinivasan if (api != ixgbe_mbox_api_10) 900c6d45171SKY Srinivasan return IXGBE_ERR_INVALID_ARGUMENT; 901c6d45171SKY Srinivasan 902c6d45171SKY Srinivasan return 0; 903c6d45171SKY Srinivasan } 904c6d45171SKY Srinivasan 90556e94095SAlexander Duyck int ixgbevf_get_queues(struct ixgbe_hw *hw, unsigned int *num_tcs, 90656e94095SAlexander Duyck unsigned int *default_tc) 90756e94095SAlexander Duyck { 90856e94095SAlexander Duyck int err; 90956e94095SAlexander Duyck u32 msg[5]; 91056e94095SAlexander Duyck 91156e94095SAlexander Duyck /* do nothing if API doesn't support ixgbevf_get_queues */ 91256e94095SAlexander Duyck switch (hw->api_version) { 91356e94095SAlexander Duyck case ixgbe_mbox_api_11: 91494cf66f8SVlad Zolotarov case ixgbe_mbox_api_12: 91541e544cdSDon Skidmore case ixgbe_mbox_api_13: 91656e94095SAlexander Duyck break; 91756e94095SAlexander Duyck default: 91856e94095SAlexander Duyck return 0; 91956e94095SAlexander Duyck } 92056e94095SAlexander Duyck 92156e94095SAlexander Duyck /* Fetch queue configuration from the PF */ 92256e94095SAlexander Duyck msg[0] = IXGBE_VF_GET_QUEUE; 92356e94095SAlexander Duyck msg[1] = msg[2] = msg[3] = msg[4] = 0; 92456e94095SAlexander Duyck 9254078ea37SColin Ian King err = ixgbevf_write_msg_read_ack(hw, msg, msg, ARRAY_SIZE(msg)); 92656e94095SAlexander Duyck if (!err) { 92756e94095SAlexander Duyck msg[0] &= ~IXGBE_VT_MSGTYPE_CTS; 92856e94095SAlexander Duyck 929dec0d8e4SJeff Kirsher /* if we we didn't get an ACK there must have been 93056e94095SAlexander Duyck * some sort of mailbox error so we should treat it 93156e94095SAlexander Duyck * as such 93256e94095SAlexander Duyck */ 93356e94095SAlexander Duyck if (msg[0] != (IXGBE_VF_GET_QUEUE | IXGBE_VT_MSGTYPE_ACK)) 93456e94095SAlexander Duyck return IXGBE_ERR_MBX; 93556e94095SAlexander Duyck 93656e94095SAlexander Duyck /* record and validate values from message */ 93756e94095SAlexander Duyck hw->mac.max_tx_queues = msg[IXGBE_VF_TX_QUEUES]; 93856e94095SAlexander Duyck if (hw->mac.max_tx_queues == 0 || 93956e94095SAlexander Duyck hw->mac.max_tx_queues > IXGBE_VF_MAX_TX_QUEUES) 94056e94095SAlexander Duyck hw->mac.max_tx_queues = IXGBE_VF_MAX_TX_QUEUES; 94156e94095SAlexander Duyck 94256e94095SAlexander Duyck hw->mac.max_rx_queues = msg[IXGBE_VF_RX_QUEUES]; 94356e94095SAlexander Duyck if (hw->mac.max_rx_queues == 0 || 94456e94095SAlexander Duyck hw->mac.max_rx_queues > IXGBE_VF_MAX_RX_QUEUES) 94556e94095SAlexander Duyck hw->mac.max_rx_queues = IXGBE_VF_MAX_RX_QUEUES; 94656e94095SAlexander Duyck 94756e94095SAlexander Duyck *num_tcs = msg[IXGBE_VF_TRANS_VLAN]; 94856e94095SAlexander Duyck /* in case of unknown state assume we cannot tag frames */ 94956e94095SAlexander Duyck if (*num_tcs > hw->mac.max_rx_queues) 95056e94095SAlexander Duyck *num_tcs = 1; 95156e94095SAlexander Duyck 95256e94095SAlexander Duyck *default_tc = msg[IXGBE_VF_DEF_QUEUE]; 95356e94095SAlexander Duyck /* default to queue 0 on out-of-bounds queue number */ 95456e94095SAlexander Duyck if (*default_tc >= hw->mac.max_tx_queues) 95556e94095SAlexander Duyck *default_tc = 0; 95656e94095SAlexander Duyck } 95756e94095SAlexander Duyck 95856e94095SAlexander Duyck return err; 95956e94095SAlexander Duyck } 96056e94095SAlexander Duyck 9613d8fe98fSStephen Hemminger static const struct ixgbe_mac_operations ixgbevf_mac_ops = { 962dee1ad47SJeff Kirsher .init_hw = ixgbevf_init_hw_vf, 963dee1ad47SJeff Kirsher .reset_hw = ixgbevf_reset_hw_vf, 964dee1ad47SJeff Kirsher .start_hw = ixgbevf_start_hw_vf, 965dee1ad47SJeff Kirsher .get_mac_addr = ixgbevf_get_mac_addr_vf, 966dee1ad47SJeff Kirsher .stop_adapter = ixgbevf_stop_hw_vf, 967dee1ad47SJeff Kirsher .setup_link = ixgbevf_setup_mac_link_vf, 968dee1ad47SJeff Kirsher .check_link = ixgbevf_check_mac_link_vf, 9697921f4dcSAlexander Duyck .negotiate_api_version = ixgbevf_negotiate_api_version_vf, 970dee1ad47SJeff Kirsher .set_rar = ixgbevf_set_rar_vf, 971dee1ad47SJeff Kirsher .update_mc_addr_list = ixgbevf_update_mc_addr_list_vf, 9728443c1a4SHiroshi Shimamoto .update_xcast_mode = ixgbevf_update_xcast_mode, 973dee1ad47SJeff Kirsher .set_uc_addr = ixgbevf_set_uc_addr_vf, 974dee1ad47SJeff Kirsher .set_vfta = ixgbevf_set_vfta_vf, 9752f8214feSAlexander Duyck .set_rlpml = ixgbevf_set_rlpml_vf, 976dee1ad47SJeff Kirsher }; 977dee1ad47SJeff Kirsher 978c6d45171SKY Srinivasan static const struct ixgbe_mac_operations ixgbevf_hv_mac_ops = { 979c6d45171SKY Srinivasan .init_hw = ixgbevf_init_hw_vf, 980c6d45171SKY Srinivasan .reset_hw = ixgbevf_hv_reset_hw_vf, 981c6d45171SKY Srinivasan .start_hw = ixgbevf_start_hw_vf, 982c6d45171SKY Srinivasan .get_mac_addr = ixgbevf_get_mac_addr_vf, 983c6d45171SKY Srinivasan .stop_adapter = ixgbevf_stop_hw_vf, 984c6d45171SKY Srinivasan .setup_link = ixgbevf_setup_mac_link_vf, 985c6d45171SKY Srinivasan .check_link = ixgbevf_hv_check_mac_link_vf, 9862f8214feSAlexander Duyck .negotiate_api_version = ixgbevf_hv_negotiate_api_version_vf, 987c6d45171SKY Srinivasan .set_rar = ixgbevf_hv_set_rar_vf, 988c6d45171SKY Srinivasan .update_mc_addr_list = ixgbevf_hv_update_mc_addr_list_vf, 989c6d45171SKY Srinivasan .update_xcast_mode = ixgbevf_hv_update_xcast_mode, 990c6d45171SKY Srinivasan .set_uc_addr = ixgbevf_hv_set_uc_addr_vf, 991c6d45171SKY Srinivasan .set_vfta = ixgbevf_hv_set_vfta_vf, 9922f8214feSAlexander Duyck .set_rlpml = ixgbevf_hv_set_rlpml_vf, 993c6d45171SKY Srinivasan }; 994c6d45171SKY Srinivasan 9953d8fe98fSStephen Hemminger const struct ixgbevf_info ixgbevf_82599_vf_info = { 996dee1ad47SJeff Kirsher .mac = ixgbe_mac_82599_vf, 997dee1ad47SJeff Kirsher .mac_ops = &ixgbevf_mac_ops, 998dee1ad47SJeff Kirsher }; 999dee1ad47SJeff Kirsher 1000c6d45171SKY Srinivasan const struct ixgbevf_info ixgbevf_82599_vf_hv_info = { 1001c6d45171SKY Srinivasan .mac = ixgbe_mac_82599_vf, 1002c6d45171SKY Srinivasan .mac_ops = &ixgbevf_hv_mac_ops, 1003c6d45171SKY Srinivasan }; 1004c6d45171SKY Srinivasan 10053d8fe98fSStephen Hemminger const struct ixgbevf_info ixgbevf_X540_vf_info = { 1006dee1ad47SJeff Kirsher .mac = ixgbe_mac_X540_vf, 1007dee1ad47SJeff Kirsher .mac_ops = &ixgbevf_mac_ops, 1008dee1ad47SJeff Kirsher }; 100947068b0dSEmil Tantilov 1010c6d45171SKY Srinivasan const struct ixgbevf_info ixgbevf_X540_vf_hv_info = { 1011c6d45171SKY Srinivasan .mac = ixgbe_mac_X540_vf, 1012c6d45171SKY Srinivasan .mac_ops = &ixgbevf_hv_mac_ops, 1013c6d45171SKY Srinivasan }; 1014c6d45171SKY Srinivasan 101547068b0dSEmil Tantilov const struct ixgbevf_info ixgbevf_X550_vf_info = { 101647068b0dSEmil Tantilov .mac = ixgbe_mac_X550_vf, 101747068b0dSEmil Tantilov .mac_ops = &ixgbevf_mac_ops, 101847068b0dSEmil Tantilov }; 101947068b0dSEmil Tantilov 1020c6d45171SKY Srinivasan const struct ixgbevf_info ixgbevf_X550_vf_hv_info = { 1021c6d45171SKY Srinivasan .mac = ixgbe_mac_X550_vf, 1022c6d45171SKY Srinivasan .mac_ops = &ixgbevf_hv_mac_ops, 1023c6d45171SKY Srinivasan }; 1024c6d45171SKY Srinivasan 102547068b0dSEmil Tantilov const struct ixgbevf_info ixgbevf_X550EM_x_vf_info = { 102647068b0dSEmil Tantilov .mac = ixgbe_mac_X550EM_x_vf, 102747068b0dSEmil Tantilov .mac_ops = &ixgbevf_mac_ops, 102847068b0dSEmil Tantilov }; 1029c6d45171SKY Srinivasan 1030c6d45171SKY Srinivasan const struct ixgbevf_info ixgbevf_X550EM_x_vf_hv_info = { 1031c6d45171SKY Srinivasan .mac = ixgbe_mac_X550EM_x_vf, 1032c6d45171SKY Srinivasan .mac_ops = &ixgbevf_hv_mac_ops, 1033c6d45171SKY Srinivasan }; 10341d94f987SDon Skidmore 10351d94f987SDon Skidmore const struct ixgbevf_info ixgbevf_x550em_a_vf_info = { 10361d94f987SDon Skidmore .mac = ixgbe_mac_x550em_a_vf, 10371d94f987SDon Skidmore .mac_ops = &ixgbevf_mac_ops, 10381d94f987SDon Skidmore }; 1039