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 */ 33341e544cdSDon Skidmore switch (hw->api_version) { 33441e544cdSDon Skidmore case ixgbe_mbox_api_13: 33541e544cdSDon Skidmore case ixgbe_mbox_api_12: 33682fb670cSTony Nguyen if (hw->mac.type < ixgbe_mac_X550_vf) 33741e544cdSDon Skidmore break; 33880666035STony Nguyen /* fall through */ 33941e544cdSDon Skidmore default: 34094cf66f8SVlad Zolotarov return -EOPNOTSUPP; 34141e544cdSDon Skidmore } 34294cf66f8SVlad Zolotarov 34394cf66f8SVlad Zolotarov msgbuf[0] = IXGBE_VF_GET_RETA; 34494cf66f8SVlad Zolotarov 34594cf66f8SVlad Zolotarov err = hw->mbx.ops.write_posted(hw, msgbuf, 1); 34694cf66f8SVlad Zolotarov 34794cf66f8SVlad Zolotarov if (err) 34894cf66f8SVlad Zolotarov return err; 34994cf66f8SVlad Zolotarov 35094cf66f8SVlad Zolotarov err = hw->mbx.ops.read_posted(hw, msgbuf, dwords + 1); 35194cf66f8SVlad Zolotarov 35294cf66f8SVlad Zolotarov if (err) 35394cf66f8SVlad Zolotarov return err; 35494cf66f8SVlad Zolotarov 35594cf66f8SVlad Zolotarov msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 35694cf66f8SVlad Zolotarov 35794cf66f8SVlad Zolotarov /* If the operation has been refused by a PF return -EPERM */ 35894cf66f8SVlad Zolotarov if (msgbuf[0] == (IXGBE_VF_GET_RETA | IXGBE_VT_MSGTYPE_NACK)) 35994cf66f8SVlad Zolotarov return -EPERM; 36094cf66f8SVlad Zolotarov 36194cf66f8SVlad Zolotarov /* If we didn't get an ACK there must have been 36294cf66f8SVlad Zolotarov * some sort of mailbox error so we should treat it 36394cf66f8SVlad Zolotarov * as such. 36494cf66f8SVlad Zolotarov */ 36594cf66f8SVlad Zolotarov if (msgbuf[0] != (IXGBE_VF_GET_RETA | IXGBE_VT_MSGTYPE_ACK)) 36694cf66f8SVlad Zolotarov return IXGBE_ERR_MBX; 36794cf66f8SVlad Zolotarov 36894cf66f8SVlad Zolotarov /* ixgbevf doesn't support more than 2 queues at the moment */ 36994cf66f8SVlad Zolotarov if (num_rx_queues > 1) 37094cf66f8SVlad Zolotarov mask = 0x1; 37194cf66f8SVlad Zolotarov 37294cf66f8SVlad Zolotarov for (i = 0; i < dwords; i++) 37394cf66f8SVlad Zolotarov for (j = 0; j < 16; j++) 37494cf66f8SVlad Zolotarov reta[i * 16 + j] = (hw_reta[i] >> (2 * j)) & mask; 37594cf66f8SVlad Zolotarov 37694cf66f8SVlad Zolotarov return 0; 37794cf66f8SVlad Zolotarov } 37894cf66f8SVlad Zolotarov 37994cf66f8SVlad Zolotarov /** 380ad1431e2SVlad Zolotarov * ixgbevf_get_rss_key_locked - get the RSS Random Key 381ad1431e2SVlad Zolotarov * @hw: pointer to the HW structure 382ad1431e2SVlad Zolotarov * @rss_key: buffer to fill with RSS Hash Key contents. 383ad1431e2SVlad Zolotarov * 384ad1431e2SVlad Zolotarov * The "rss_key" buffer should be big enough to contain 10 registers. 385ad1431e2SVlad Zolotarov * 386ad1431e2SVlad Zolotarov * Returns: 0 on success. 387ad1431e2SVlad Zolotarov * if API doesn't support this operation - (-EOPNOTSUPP). 388ad1431e2SVlad Zolotarov */ 389ad1431e2SVlad Zolotarov int ixgbevf_get_rss_key_locked(struct ixgbe_hw *hw, u8 *rss_key) 390ad1431e2SVlad Zolotarov { 391ad1431e2SVlad Zolotarov int err; 392ad1431e2SVlad Zolotarov u32 msgbuf[IXGBE_VFMAILBOX_SIZE]; 393ad1431e2SVlad Zolotarov 394ad1431e2SVlad Zolotarov /* We currently support the RSS Random Key retrieval for 82599 and x540 395ad1431e2SVlad Zolotarov * devices only. 396ad1431e2SVlad Zolotarov * 397ad1431e2SVlad Zolotarov * Thus return an error if API doesn't support RSS Random Key retrieval 398ad1431e2SVlad Zolotarov * or if the operation is not supported for this device type. 399ad1431e2SVlad Zolotarov */ 40041e544cdSDon Skidmore switch (hw->api_version) { 40141e544cdSDon Skidmore case ixgbe_mbox_api_13: 40241e544cdSDon Skidmore case ixgbe_mbox_api_12: 40382fb670cSTony Nguyen if (hw->mac.type < ixgbe_mac_X550_vf) 40441e544cdSDon Skidmore break; 40580666035STony Nguyen /* fall through */ 40641e544cdSDon Skidmore default: 407ad1431e2SVlad Zolotarov return -EOPNOTSUPP; 40841e544cdSDon Skidmore } 409ad1431e2SVlad Zolotarov 410ad1431e2SVlad Zolotarov msgbuf[0] = IXGBE_VF_GET_RSS_KEY; 411ad1431e2SVlad Zolotarov err = hw->mbx.ops.write_posted(hw, msgbuf, 1); 412ad1431e2SVlad Zolotarov 413ad1431e2SVlad Zolotarov if (err) 414ad1431e2SVlad Zolotarov return err; 415ad1431e2SVlad Zolotarov 416ad1431e2SVlad Zolotarov err = hw->mbx.ops.read_posted(hw, msgbuf, 11); 417ad1431e2SVlad Zolotarov 418ad1431e2SVlad Zolotarov if (err) 419ad1431e2SVlad Zolotarov return err; 420ad1431e2SVlad Zolotarov 421ad1431e2SVlad Zolotarov msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 422ad1431e2SVlad Zolotarov 423ad1431e2SVlad Zolotarov /* If the operation has been refused by a PF return -EPERM */ 42482fb670cSTony Nguyen if (msgbuf[0] == (IXGBE_VF_GET_RSS_KEY | IXGBE_VT_MSGTYPE_NACK)) 425ad1431e2SVlad Zolotarov return -EPERM; 426ad1431e2SVlad Zolotarov 427ad1431e2SVlad Zolotarov /* If we didn't get an ACK there must have been 428ad1431e2SVlad Zolotarov * some sort of mailbox error so we should treat it 429ad1431e2SVlad Zolotarov * as such. 430ad1431e2SVlad Zolotarov */ 431ad1431e2SVlad Zolotarov if (msgbuf[0] != (IXGBE_VF_GET_RSS_KEY | IXGBE_VT_MSGTYPE_ACK)) 432ad1431e2SVlad Zolotarov return IXGBE_ERR_MBX; 433ad1431e2SVlad Zolotarov 434ad1431e2SVlad Zolotarov memcpy(rss_key, msgbuf + 1, IXGBEVF_RSS_HASH_KEY_SIZE); 435ad1431e2SVlad Zolotarov 436ad1431e2SVlad Zolotarov return 0; 437ad1431e2SVlad Zolotarov } 438ad1431e2SVlad Zolotarov 439ad1431e2SVlad Zolotarov /** 440dee1ad47SJeff Kirsher * ixgbevf_set_rar_vf - set device MAC address 441dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 442dee1ad47SJeff Kirsher * @index: Receive address register to write 443dee1ad47SJeff Kirsher * @addr: Address to put into receive address register 444dee1ad47SJeff Kirsher * @vmdq: Unused in this implementation 445dee1ad47SJeff Kirsher **/ 446dee1ad47SJeff Kirsher static s32 ixgbevf_set_rar_vf(struct ixgbe_hw *hw, u32 index, u8 *addr, 447dee1ad47SJeff Kirsher u32 vmdq) 448dee1ad47SJeff Kirsher { 449dee1ad47SJeff Kirsher u32 msgbuf[3]; 450dee1ad47SJeff Kirsher u8 *msg_addr = (u8 *)(&msgbuf[1]); 451dee1ad47SJeff Kirsher s32 ret_val; 452dee1ad47SJeff Kirsher 453dee1ad47SJeff Kirsher memset(msgbuf, 0, sizeof(msgbuf)); 454dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_SET_MAC_ADDR; 4550d8bb414SJeff Kirsher ether_addr_copy(msg_addr, addr); 456dee1ad47SJeff Kirsher 457c6426971SEmil Tantilov ret_val = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 458c6426971SEmil Tantilov sizeof(msgbuf) / sizeof(u32)); 459dee1ad47SJeff Kirsher 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. 539c6d45171SKY Srinivasan */ 540c6d45171SKY Srinivasan static s32 ixgbevf_hv_update_mc_addr_list_vf(struct ixgbe_hw *hw, 541c6d45171SKY Srinivasan struct net_device *netdev) 542c6d45171SKY Srinivasan { 543c6d45171SKY Srinivasan return -EOPNOTSUPP; 544c6d45171SKY Srinivasan } 545c6d45171SKY Srinivasan 546c6d45171SKY Srinivasan /** 5478443c1a4SHiroshi Shimamoto * ixgbevf_update_xcast_mode - Update Multicast mode 5488443c1a4SHiroshi Shimamoto * @hw: pointer to the HW structure 5498443c1a4SHiroshi Shimamoto * @xcast_mode: new multicast mode 5508443c1a4SHiroshi Shimamoto * 5518443c1a4SHiroshi Shimamoto * Updates the Multicast Mode of VF. 5528443c1a4SHiroshi Shimamoto **/ 5538b44a8a0STony Nguyen static s32 ixgbevf_update_xcast_mode(struct ixgbe_hw *hw, int xcast_mode) 5548443c1a4SHiroshi Shimamoto { 5558443c1a4SHiroshi Shimamoto u32 msgbuf[2]; 5568443c1a4SHiroshi Shimamoto s32 err; 5578443c1a4SHiroshi Shimamoto 5588443c1a4SHiroshi Shimamoto switch (hw->api_version) { 5598443c1a4SHiroshi Shimamoto case ixgbe_mbox_api_12: 56041e544cdSDon Skidmore /* promisc introduced in 1.3 version */ 56141e544cdSDon Skidmore if (xcast_mode == IXGBEVF_XCAST_MODE_PROMISC) 56241e544cdSDon Skidmore return -EOPNOTSUPP; 56341e544cdSDon Skidmore /* Fall threw */ 56441e544cdSDon Skidmore case ixgbe_mbox_api_13: 5658443c1a4SHiroshi Shimamoto break; 5668443c1a4SHiroshi Shimamoto default: 5678443c1a4SHiroshi Shimamoto return -EOPNOTSUPP; 5688443c1a4SHiroshi Shimamoto } 5698443c1a4SHiroshi Shimamoto 5708443c1a4SHiroshi Shimamoto msgbuf[0] = IXGBE_VF_UPDATE_XCAST_MODE; 5718443c1a4SHiroshi Shimamoto msgbuf[1] = xcast_mode; 5728443c1a4SHiroshi Shimamoto 573c6426971SEmil Tantilov err = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 574c6426971SEmil Tantilov sizeof(msgbuf) / sizeof(u32)); 5758443c1a4SHiroshi Shimamoto if (err) 5768443c1a4SHiroshi Shimamoto return err; 5778443c1a4SHiroshi Shimamoto 5788443c1a4SHiroshi Shimamoto msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 5798443c1a4SHiroshi Shimamoto if (msgbuf[0] == (IXGBE_VF_UPDATE_XCAST_MODE | IXGBE_VT_MSGTYPE_NACK)) 5808443c1a4SHiroshi Shimamoto return -EPERM; 5818443c1a4SHiroshi Shimamoto 5828443c1a4SHiroshi Shimamoto return 0; 5838443c1a4SHiroshi Shimamoto } 5848443c1a4SHiroshi Shimamoto 5858443c1a4SHiroshi Shimamoto /** 586c6d45171SKY Srinivasan * Hyper-V variant - just a stub. 587c6d45171SKY Srinivasan */ 5888b44a8a0STony Nguyen static s32 ixgbevf_hv_update_xcast_mode(struct ixgbe_hw *hw, int xcast_mode) 589c6d45171SKY Srinivasan { 590c6d45171SKY Srinivasan return -EOPNOTSUPP; 591c6d45171SKY Srinivasan } 592c6d45171SKY Srinivasan 593c6d45171SKY Srinivasan /** 594dec0d8e4SJeff Kirsher * ixgbevf_set_vfta_vf - Set/Unset VLAN filter table address 595dee1ad47SJeff Kirsher * @hw: pointer to the HW structure 596dee1ad47SJeff Kirsher * @vlan: 12 bit VLAN ID 597dee1ad47SJeff Kirsher * @vind: unused by VF drivers 598dee1ad47SJeff Kirsher * @vlan_on: if true then set bit, else clear bit 599dee1ad47SJeff Kirsher **/ 600dee1ad47SJeff Kirsher static s32 ixgbevf_set_vfta_vf(struct ixgbe_hw *hw, u32 vlan, u32 vind, 601dee1ad47SJeff Kirsher bool vlan_on) 602dee1ad47SJeff Kirsher { 603dee1ad47SJeff Kirsher u32 msgbuf[2]; 6042ddc7fe1SAlexander Duyck s32 err; 605dee1ad47SJeff Kirsher 606dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_SET_VLAN; 607dee1ad47SJeff Kirsher msgbuf[1] = vlan; 608dee1ad47SJeff Kirsher /* Setting the 8 bit field MSG INFO to TRUE indicates "add" */ 609dee1ad47SJeff Kirsher msgbuf[0] |= vlan_on << IXGBE_VT_MSGINFO_SHIFT; 610dee1ad47SJeff Kirsher 611c6426971SEmil Tantilov err = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 612c6426971SEmil Tantilov sizeof(msgbuf) / sizeof(u32)); 6132ddc7fe1SAlexander Duyck if (err) 6142ddc7fe1SAlexander Duyck goto mbx_err; 6152ddc7fe1SAlexander Duyck 6162ddc7fe1SAlexander Duyck /* remove extra bits from the message */ 6172ddc7fe1SAlexander Duyck msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 6182ddc7fe1SAlexander Duyck msgbuf[0] &= ~(0xFF << IXGBE_VT_MSGINFO_SHIFT); 6192ddc7fe1SAlexander Duyck 6202ddc7fe1SAlexander Duyck if (msgbuf[0] != (IXGBE_VF_SET_VLAN | IXGBE_VT_MSGTYPE_ACK)) 6212ddc7fe1SAlexander Duyck err = IXGBE_ERR_INVALID_ARGUMENT; 6222ddc7fe1SAlexander Duyck 6232ddc7fe1SAlexander Duyck mbx_err: 6242ddc7fe1SAlexander Duyck return err; 625dee1ad47SJeff Kirsher } 626dee1ad47SJeff Kirsher 627dee1ad47SJeff Kirsher /** 628c6d45171SKY Srinivasan * Hyper-V variant - just a stub. 629c6d45171SKY Srinivasan */ 630c6d45171SKY Srinivasan static s32 ixgbevf_hv_set_vfta_vf(struct ixgbe_hw *hw, u32 vlan, u32 vind, 631c6d45171SKY Srinivasan bool vlan_on) 632c6d45171SKY Srinivasan { 633c6d45171SKY Srinivasan return -EOPNOTSUPP; 634c6d45171SKY Srinivasan } 635c6d45171SKY Srinivasan 636c6d45171SKY Srinivasan /** 637dee1ad47SJeff Kirsher * ixgbevf_setup_mac_link_vf - Setup MAC link settings 638dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 639dee1ad47SJeff Kirsher * @speed: Unused in this implementation 640dee1ad47SJeff Kirsher * @autoneg: Unused in this implementation 641dee1ad47SJeff Kirsher * @autoneg_wait_to_complete: Unused in this implementation 642dee1ad47SJeff Kirsher * 643dee1ad47SJeff Kirsher * Do nothing and return success. VF drivers are not allowed to change 644dee1ad47SJeff Kirsher * global settings. Maintained for driver compatibility. 645dee1ad47SJeff Kirsher **/ 646dee1ad47SJeff Kirsher static s32 ixgbevf_setup_mac_link_vf(struct ixgbe_hw *hw, 647dee1ad47SJeff Kirsher ixgbe_link_speed speed, bool autoneg, 648dee1ad47SJeff Kirsher bool autoneg_wait_to_complete) 649dee1ad47SJeff Kirsher { 650dee1ad47SJeff Kirsher return 0; 651dee1ad47SJeff Kirsher } 652dee1ad47SJeff Kirsher 653dee1ad47SJeff Kirsher /** 654dee1ad47SJeff Kirsher * ixgbevf_check_mac_link_vf - Get link/speed status 655dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 656dee1ad47SJeff Kirsher * @speed: pointer to link speed 657dee1ad47SJeff Kirsher * @link_up: true is link is up, false otherwise 658dee1ad47SJeff Kirsher * @autoneg_wait_to_complete: true when waiting for completion is needed 659dee1ad47SJeff Kirsher * 660dee1ad47SJeff Kirsher * Reads the links register to determine if link is up and the current speed 661dee1ad47SJeff Kirsher **/ 662dee1ad47SJeff Kirsher static s32 ixgbevf_check_mac_link_vf(struct ixgbe_hw *hw, 663dee1ad47SJeff Kirsher ixgbe_link_speed *speed, 664dee1ad47SJeff Kirsher bool *link_up, 665dee1ad47SJeff Kirsher bool autoneg_wait_to_complete) 666dee1ad47SJeff Kirsher { 6674b2cd27fSAlexander Duyck struct ixgbe_mbx_info *mbx = &hw->mbx; 6684b2cd27fSAlexander Duyck struct ixgbe_mac_info *mac = &hw->mac; 6694b2cd27fSAlexander Duyck s32 ret_val = 0; 670dee1ad47SJeff Kirsher u32 links_reg; 6714b2cd27fSAlexander Duyck u32 in_msg = 0; 672dee1ad47SJeff Kirsher 6734b2cd27fSAlexander Duyck /* If we were hit with a reset drop the link */ 6744b2cd27fSAlexander Duyck if (!mbx->ops.check_for_rst(hw) || !mbx->timeout) 6754b2cd27fSAlexander Duyck mac->get_link_status = true; 676dee1ad47SJeff Kirsher 6774b2cd27fSAlexander Duyck if (!mac->get_link_status) 6784b2cd27fSAlexander Duyck goto out; 6794b2cd27fSAlexander Duyck 6804b2cd27fSAlexander Duyck /* if link status is down no point in checking to see if pf is up */ 681dee1ad47SJeff Kirsher links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 6824b2cd27fSAlexander Duyck if (!(links_reg & IXGBE_LINKS_UP)) 6834b2cd27fSAlexander Duyck goto out; 684dee1ad47SJeff Kirsher 685b8a2ca19SEmil Tantilov /* for SFP+ modules and DA cables on 82599 it can take up to 500usecs 686b8a2ca19SEmil Tantilov * before the link status is correct 687b8a2ca19SEmil Tantilov */ 688b8a2ca19SEmil Tantilov if (mac->type == ixgbe_mac_82599_vf) { 689b8a2ca19SEmil Tantilov int i; 690b8a2ca19SEmil Tantilov 691b8a2ca19SEmil Tantilov for (i = 0; i < 5; i++) { 692b8a2ca19SEmil Tantilov udelay(100); 693b8a2ca19SEmil Tantilov links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 694b8a2ca19SEmil Tantilov 695b8a2ca19SEmil Tantilov if (!(links_reg & IXGBE_LINKS_UP)) 696b8a2ca19SEmil Tantilov goto out; 697b8a2ca19SEmil Tantilov } 698b8a2ca19SEmil Tantilov } 699b8a2ca19SEmil Tantilov 70031a1b375SGreg Rose switch (links_reg & IXGBE_LINKS_SPEED_82599) { 70131a1b375SGreg Rose case IXGBE_LINKS_SPEED_10G_82599: 702dee1ad47SJeff Kirsher *speed = IXGBE_LINK_SPEED_10GB_FULL; 70331a1b375SGreg Rose break; 70431a1b375SGreg Rose case IXGBE_LINKS_SPEED_1G_82599: 705dee1ad47SJeff Kirsher *speed = IXGBE_LINK_SPEED_1GB_FULL; 70631a1b375SGreg Rose break; 70731a1b375SGreg Rose case IXGBE_LINKS_SPEED_100_82599: 70831a1b375SGreg Rose *speed = IXGBE_LINK_SPEED_100_FULL; 70931a1b375SGreg Rose break; 71031a1b375SGreg Rose } 711dee1ad47SJeff Kirsher 7124b2cd27fSAlexander Duyck /* if the read failed it could just be a mailbox collision, best wait 713dec0d8e4SJeff Kirsher * until we are called again and don't report an error 714dec0d8e4SJeff Kirsher */ 7154b2cd27fSAlexander Duyck if (mbx->ops.read(hw, &in_msg, 1)) 7164b2cd27fSAlexander Duyck goto out; 7174b2cd27fSAlexander Duyck 7184b2cd27fSAlexander Duyck if (!(in_msg & IXGBE_VT_MSGTYPE_CTS)) { 7194b2cd27fSAlexander Duyck /* msg is not CTS and is NACK we must have lost CTS status */ 7204b2cd27fSAlexander Duyck if (in_msg & IXGBE_VT_MSGTYPE_NACK) 7214b2cd27fSAlexander Duyck ret_val = -1; 7224b2cd27fSAlexander Duyck goto out; 7234b2cd27fSAlexander Duyck } 7244b2cd27fSAlexander Duyck 7254b2cd27fSAlexander Duyck /* the pf is talking, if we timed out in the past we reinit */ 7264b2cd27fSAlexander Duyck if (!mbx->timeout) { 7274b2cd27fSAlexander Duyck ret_val = -1; 7284b2cd27fSAlexander Duyck goto out; 7294b2cd27fSAlexander Duyck } 7304b2cd27fSAlexander Duyck 7314b2cd27fSAlexander Duyck /* if we passed all the tests above then the link is up and we no 732dec0d8e4SJeff Kirsher * longer need to check for link 733dec0d8e4SJeff Kirsher */ 7344b2cd27fSAlexander Duyck mac->get_link_status = false; 7354b2cd27fSAlexander Duyck 7364b2cd27fSAlexander Duyck out: 7374b2cd27fSAlexander Duyck *link_up = !mac->get_link_status; 7384b2cd27fSAlexander Duyck return ret_val; 739dee1ad47SJeff Kirsher } 740dee1ad47SJeff Kirsher 741dd1fe113SAlexander Duyck /** 742c6d45171SKY Srinivasan * Hyper-V variant; there is no mailbox communication. 743c6d45171SKY Srinivasan */ 744c6d45171SKY Srinivasan static s32 ixgbevf_hv_check_mac_link_vf(struct ixgbe_hw *hw, 745c6d45171SKY Srinivasan ixgbe_link_speed *speed, 746c6d45171SKY Srinivasan bool *link_up, 747c6d45171SKY Srinivasan bool autoneg_wait_to_complete) 748c6d45171SKY Srinivasan { 749c6d45171SKY Srinivasan struct ixgbe_mbx_info *mbx = &hw->mbx; 750c6d45171SKY Srinivasan struct ixgbe_mac_info *mac = &hw->mac; 751c6d45171SKY Srinivasan u32 links_reg; 752c6d45171SKY Srinivasan 753c6d45171SKY Srinivasan /* If we were hit with a reset drop the link */ 754c6d45171SKY Srinivasan if (!mbx->ops.check_for_rst(hw) || !mbx->timeout) 755c6d45171SKY Srinivasan mac->get_link_status = true; 756c6d45171SKY Srinivasan 757c6d45171SKY Srinivasan if (!mac->get_link_status) 758c6d45171SKY Srinivasan goto out; 759c6d45171SKY Srinivasan 760c6d45171SKY Srinivasan /* if link status is down no point in checking to see if pf is up */ 761c6d45171SKY Srinivasan links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 762c6d45171SKY Srinivasan if (!(links_reg & IXGBE_LINKS_UP)) 763c6d45171SKY Srinivasan goto out; 764c6d45171SKY Srinivasan 765c6d45171SKY Srinivasan /* for SFP+ modules and DA cables on 82599 it can take up to 500usecs 766c6d45171SKY Srinivasan * before the link status is correct 767c6d45171SKY Srinivasan */ 768c6d45171SKY Srinivasan if (mac->type == ixgbe_mac_82599_vf) { 769c6d45171SKY Srinivasan int i; 770c6d45171SKY Srinivasan 771c6d45171SKY Srinivasan for (i = 0; i < 5; i++) { 772c6d45171SKY Srinivasan udelay(100); 773c6d45171SKY Srinivasan links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 774c6d45171SKY Srinivasan 775c6d45171SKY Srinivasan if (!(links_reg & IXGBE_LINKS_UP)) 776c6d45171SKY Srinivasan goto out; 777c6d45171SKY Srinivasan } 778c6d45171SKY Srinivasan } 779c6d45171SKY Srinivasan 780c6d45171SKY Srinivasan switch (links_reg & IXGBE_LINKS_SPEED_82599) { 781c6d45171SKY Srinivasan case IXGBE_LINKS_SPEED_10G_82599: 782c6d45171SKY Srinivasan *speed = IXGBE_LINK_SPEED_10GB_FULL; 783c6d45171SKY Srinivasan break; 784c6d45171SKY Srinivasan case IXGBE_LINKS_SPEED_1G_82599: 785c6d45171SKY Srinivasan *speed = IXGBE_LINK_SPEED_1GB_FULL; 786c6d45171SKY Srinivasan break; 787c6d45171SKY Srinivasan case IXGBE_LINKS_SPEED_100_82599: 788c6d45171SKY Srinivasan *speed = IXGBE_LINK_SPEED_100_FULL; 789c6d45171SKY Srinivasan break; 790c6d45171SKY Srinivasan } 791c6d45171SKY Srinivasan 792c6d45171SKY Srinivasan /* if we passed all the tests above then the link is up and we no 793c6d45171SKY Srinivasan * longer need to check for link 794c6d45171SKY Srinivasan */ 795c6d45171SKY Srinivasan mac->get_link_status = false; 796c6d45171SKY Srinivasan 797c6d45171SKY Srinivasan out: 798c6d45171SKY Srinivasan *link_up = !mac->get_link_status; 799c6d45171SKY Srinivasan return 0; 800c6d45171SKY Srinivasan } 801c6d45171SKY Srinivasan 802c6d45171SKY Srinivasan /** 8032f8214feSAlexander Duyck * ixgbevf_set_rlpml_vf - Set the maximum receive packet length 804dd1fe113SAlexander Duyck * @hw: pointer to the HW structure 805dd1fe113SAlexander Duyck * @max_size: value to assign to max frame size 806dd1fe113SAlexander Duyck **/ 8076a11e52bSTony Nguyen static s32 ixgbevf_set_rlpml_vf(struct ixgbe_hw *hw, u16 max_size) 808dd1fe113SAlexander Duyck { 809dd1fe113SAlexander Duyck u32 msgbuf[2]; 8106a11e52bSTony Nguyen s32 ret_val; 811dd1fe113SAlexander Duyck 812dd1fe113SAlexander Duyck msgbuf[0] = IXGBE_VF_SET_LPE; 813dd1fe113SAlexander Duyck msgbuf[1] = max_size; 8146a11e52bSTony Nguyen 815c6426971SEmil Tantilov ret_val = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 816c6426971SEmil Tantilov sizeof(msgbuf) / sizeof(u32)); 8176a11e52bSTony Nguyen if (ret_val) 8186a11e52bSTony Nguyen return ret_val; 8196a11e52bSTony Nguyen if ((msgbuf[0] & IXGBE_VF_SET_LPE) && 8206a11e52bSTony Nguyen (msgbuf[0] & IXGBE_VT_MSGTYPE_NACK)) 8216a11e52bSTony Nguyen return IXGBE_ERR_MBX; 8226a11e52bSTony Nguyen 8236a11e52bSTony Nguyen return 0; 824dd1fe113SAlexander Duyck } 825dd1fe113SAlexander Duyck 82631186785SAlexander Duyck /** 8272f8214feSAlexander Duyck * ixgbevf_hv_set_rlpml_vf - Set the maximum receive packet length 828c6d45171SKY Srinivasan * @hw: pointer to the HW structure 829c6d45171SKY Srinivasan * @max_size: value to assign to max frame size 830c6d45171SKY Srinivasan * Hyper-V variant. 831c6d45171SKY Srinivasan **/ 8326a11e52bSTony Nguyen static s32 ixgbevf_hv_set_rlpml_vf(struct ixgbe_hw *hw, u16 max_size) 833c6d45171SKY Srinivasan { 834c6d45171SKY Srinivasan u32 reg; 835c6d45171SKY Srinivasan 836c6d45171SKY Srinivasan /* If we are on Hyper-V, we implement this functionality 837c6d45171SKY Srinivasan * differently. 838c6d45171SKY Srinivasan */ 839c6d45171SKY Srinivasan reg = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(0)); 840c6d45171SKY Srinivasan /* CRC == 4 */ 841c6d45171SKY Srinivasan reg |= ((max_size + 4) | IXGBE_RXDCTL_RLPML_EN); 842c6d45171SKY Srinivasan IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(0), reg); 8436a11e52bSTony Nguyen 8446a11e52bSTony Nguyen return 0; 845c6d45171SKY Srinivasan } 846c6d45171SKY Srinivasan 847c6d45171SKY Srinivasan /** 8487921f4dcSAlexander Duyck * ixgbevf_negotiate_api_version_vf - Negotiate supported API version 84931186785SAlexander Duyck * @hw: pointer to the HW structure 85031186785SAlexander Duyck * @api: integer containing requested API version 85131186785SAlexander Duyck **/ 8527921f4dcSAlexander Duyck static int ixgbevf_negotiate_api_version_vf(struct ixgbe_hw *hw, int api) 85331186785SAlexander Duyck { 85431186785SAlexander Duyck int err; 85531186785SAlexander Duyck u32 msg[3]; 85631186785SAlexander Duyck 85731186785SAlexander Duyck /* Negotiate the mailbox API version */ 85831186785SAlexander Duyck msg[0] = IXGBE_VF_API_NEGOTIATE; 85931186785SAlexander Duyck msg[1] = api; 86031186785SAlexander Duyck msg[2] = 0; 86131186785SAlexander Duyck 862c6426971SEmil Tantilov err = ixgbevf_write_msg_read_ack(hw, msg, msg, 863c6426971SEmil Tantilov sizeof(msg) / sizeof(u32)); 86431186785SAlexander Duyck if (!err) { 86531186785SAlexander Duyck msg[0] &= ~IXGBE_VT_MSGTYPE_CTS; 86631186785SAlexander Duyck 86731186785SAlexander Duyck /* Store value and return 0 on success */ 86831186785SAlexander Duyck if (msg[0] == (IXGBE_VF_API_NEGOTIATE | IXGBE_VT_MSGTYPE_ACK)) { 86931186785SAlexander Duyck hw->api_version = api; 87031186785SAlexander Duyck return 0; 87131186785SAlexander Duyck } 87231186785SAlexander Duyck 87331186785SAlexander Duyck err = IXGBE_ERR_INVALID_ARGUMENT; 87431186785SAlexander Duyck } 87531186785SAlexander Duyck 87631186785SAlexander Duyck return err; 87731186785SAlexander Duyck } 87831186785SAlexander Duyck 879c6d45171SKY Srinivasan /** 8802f8214feSAlexander Duyck * ixgbevf_hv_negotiate_api_version_vf - Negotiate supported API version 881c6d45171SKY Srinivasan * @hw: pointer to the HW structure 882c6d45171SKY Srinivasan * @api: integer containing requested API version 883c6d45171SKY Srinivasan * Hyper-V version - only ixgbe_mbox_api_10 supported. 884c6d45171SKY Srinivasan **/ 8852f8214feSAlexander Duyck static int ixgbevf_hv_negotiate_api_version_vf(struct ixgbe_hw *hw, int api) 886c6d45171SKY Srinivasan { 887c6d45171SKY Srinivasan /* Hyper-V only supports api version ixgbe_mbox_api_10 */ 888c6d45171SKY Srinivasan if (api != ixgbe_mbox_api_10) 889c6d45171SKY Srinivasan return IXGBE_ERR_INVALID_ARGUMENT; 890c6d45171SKY Srinivasan 891c6d45171SKY Srinivasan return 0; 892c6d45171SKY Srinivasan } 893c6d45171SKY Srinivasan 89456e94095SAlexander Duyck int ixgbevf_get_queues(struct ixgbe_hw *hw, unsigned int *num_tcs, 89556e94095SAlexander Duyck unsigned int *default_tc) 89656e94095SAlexander Duyck { 89756e94095SAlexander Duyck int err; 89856e94095SAlexander Duyck u32 msg[5]; 89956e94095SAlexander Duyck 90056e94095SAlexander Duyck /* do nothing if API doesn't support ixgbevf_get_queues */ 90156e94095SAlexander Duyck switch (hw->api_version) { 90256e94095SAlexander Duyck case ixgbe_mbox_api_11: 90394cf66f8SVlad Zolotarov case ixgbe_mbox_api_12: 90441e544cdSDon Skidmore case ixgbe_mbox_api_13: 90556e94095SAlexander Duyck break; 90656e94095SAlexander Duyck default: 90756e94095SAlexander Duyck return 0; 90856e94095SAlexander Duyck } 90956e94095SAlexander Duyck 91056e94095SAlexander Duyck /* Fetch queue configuration from the PF */ 91156e94095SAlexander Duyck msg[0] = IXGBE_VF_GET_QUEUE; 91256e94095SAlexander Duyck msg[1] = msg[2] = msg[3] = msg[4] = 0; 91356e94095SAlexander Duyck 914c6426971SEmil Tantilov err = ixgbevf_write_msg_read_ack(hw, msg, msg, 915c6426971SEmil Tantilov sizeof(msg) / sizeof(u32)); 91656e94095SAlexander Duyck if (!err) { 91756e94095SAlexander Duyck msg[0] &= ~IXGBE_VT_MSGTYPE_CTS; 91856e94095SAlexander Duyck 919dec0d8e4SJeff Kirsher /* if we we didn't get an ACK there must have been 92056e94095SAlexander Duyck * some sort of mailbox error so we should treat it 92156e94095SAlexander Duyck * as such 92256e94095SAlexander Duyck */ 92356e94095SAlexander Duyck if (msg[0] != (IXGBE_VF_GET_QUEUE | IXGBE_VT_MSGTYPE_ACK)) 92456e94095SAlexander Duyck return IXGBE_ERR_MBX; 92556e94095SAlexander Duyck 92656e94095SAlexander Duyck /* record and validate values from message */ 92756e94095SAlexander Duyck hw->mac.max_tx_queues = msg[IXGBE_VF_TX_QUEUES]; 92856e94095SAlexander Duyck if (hw->mac.max_tx_queues == 0 || 92956e94095SAlexander Duyck hw->mac.max_tx_queues > IXGBE_VF_MAX_TX_QUEUES) 93056e94095SAlexander Duyck hw->mac.max_tx_queues = IXGBE_VF_MAX_TX_QUEUES; 93156e94095SAlexander Duyck 93256e94095SAlexander Duyck hw->mac.max_rx_queues = msg[IXGBE_VF_RX_QUEUES]; 93356e94095SAlexander Duyck if (hw->mac.max_rx_queues == 0 || 93456e94095SAlexander Duyck hw->mac.max_rx_queues > IXGBE_VF_MAX_RX_QUEUES) 93556e94095SAlexander Duyck hw->mac.max_rx_queues = IXGBE_VF_MAX_RX_QUEUES; 93656e94095SAlexander Duyck 93756e94095SAlexander Duyck *num_tcs = msg[IXGBE_VF_TRANS_VLAN]; 93856e94095SAlexander Duyck /* in case of unknown state assume we cannot tag frames */ 93956e94095SAlexander Duyck if (*num_tcs > hw->mac.max_rx_queues) 94056e94095SAlexander Duyck *num_tcs = 1; 94156e94095SAlexander Duyck 94256e94095SAlexander Duyck *default_tc = msg[IXGBE_VF_DEF_QUEUE]; 94356e94095SAlexander Duyck /* default to queue 0 on out-of-bounds queue number */ 94456e94095SAlexander Duyck if (*default_tc >= hw->mac.max_tx_queues) 94556e94095SAlexander Duyck *default_tc = 0; 94656e94095SAlexander Duyck } 94756e94095SAlexander Duyck 94856e94095SAlexander Duyck return err; 94956e94095SAlexander Duyck } 95056e94095SAlexander Duyck 9513d8fe98fSStephen Hemminger static const struct ixgbe_mac_operations ixgbevf_mac_ops = { 952dee1ad47SJeff Kirsher .init_hw = ixgbevf_init_hw_vf, 953dee1ad47SJeff Kirsher .reset_hw = ixgbevf_reset_hw_vf, 954dee1ad47SJeff Kirsher .start_hw = ixgbevf_start_hw_vf, 955dee1ad47SJeff Kirsher .get_mac_addr = ixgbevf_get_mac_addr_vf, 956dee1ad47SJeff Kirsher .stop_adapter = ixgbevf_stop_hw_vf, 957dee1ad47SJeff Kirsher .setup_link = ixgbevf_setup_mac_link_vf, 958dee1ad47SJeff Kirsher .check_link = ixgbevf_check_mac_link_vf, 9597921f4dcSAlexander Duyck .negotiate_api_version = ixgbevf_negotiate_api_version_vf, 960dee1ad47SJeff Kirsher .set_rar = ixgbevf_set_rar_vf, 961dee1ad47SJeff Kirsher .update_mc_addr_list = ixgbevf_update_mc_addr_list_vf, 9628443c1a4SHiroshi Shimamoto .update_xcast_mode = ixgbevf_update_xcast_mode, 963dee1ad47SJeff Kirsher .set_uc_addr = ixgbevf_set_uc_addr_vf, 964dee1ad47SJeff Kirsher .set_vfta = ixgbevf_set_vfta_vf, 9652f8214feSAlexander Duyck .set_rlpml = ixgbevf_set_rlpml_vf, 966dee1ad47SJeff Kirsher }; 967dee1ad47SJeff Kirsher 968c6d45171SKY Srinivasan static const struct ixgbe_mac_operations ixgbevf_hv_mac_ops = { 969c6d45171SKY Srinivasan .init_hw = ixgbevf_init_hw_vf, 970c6d45171SKY Srinivasan .reset_hw = ixgbevf_hv_reset_hw_vf, 971c6d45171SKY Srinivasan .start_hw = ixgbevf_start_hw_vf, 972c6d45171SKY Srinivasan .get_mac_addr = ixgbevf_get_mac_addr_vf, 973c6d45171SKY Srinivasan .stop_adapter = ixgbevf_stop_hw_vf, 974c6d45171SKY Srinivasan .setup_link = ixgbevf_setup_mac_link_vf, 975c6d45171SKY Srinivasan .check_link = ixgbevf_hv_check_mac_link_vf, 9762f8214feSAlexander Duyck .negotiate_api_version = ixgbevf_hv_negotiate_api_version_vf, 977c6d45171SKY Srinivasan .set_rar = ixgbevf_hv_set_rar_vf, 978c6d45171SKY Srinivasan .update_mc_addr_list = ixgbevf_hv_update_mc_addr_list_vf, 979c6d45171SKY Srinivasan .update_xcast_mode = ixgbevf_hv_update_xcast_mode, 980c6d45171SKY Srinivasan .set_uc_addr = ixgbevf_hv_set_uc_addr_vf, 981c6d45171SKY Srinivasan .set_vfta = ixgbevf_hv_set_vfta_vf, 9822f8214feSAlexander Duyck .set_rlpml = ixgbevf_hv_set_rlpml_vf, 983c6d45171SKY Srinivasan }; 984c6d45171SKY Srinivasan 9853d8fe98fSStephen Hemminger const struct ixgbevf_info ixgbevf_82599_vf_info = { 986dee1ad47SJeff Kirsher .mac = ixgbe_mac_82599_vf, 987dee1ad47SJeff Kirsher .mac_ops = &ixgbevf_mac_ops, 988dee1ad47SJeff Kirsher }; 989dee1ad47SJeff Kirsher 990c6d45171SKY Srinivasan const struct ixgbevf_info ixgbevf_82599_vf_hv_info = { 991c6d45171SKY Srinivasan .mac = ixgbe_mac_82599_vf, 992c6d45171SKY Srinivasan .mac_ops = &ixgbevf_hv_mac_ops, 993c6d45171SKY Srinivasan }; 994c6d45171SKY Srinivasan 9953d8fe98fSStephen Hemminger const struct ixgbevf_info ixgbevf_X540_vf_info = { 996dee1ad47SJeff Kirsher .mac = ixgbe_mac_X540_vf, 997dee1ad47SJeff Kirsher .mac_ops = &ixgbevf_mac_ops, 998dee1ad47SJeff Kirsher }; 99947068b0dSEmil Tantilov 1000c6d45171SKY Srinivasan const struct ixgbevf_info ixgbevf_X540_vf_hv_info = { 1001c6d45171SKY Srinivasan .mac = ixgbe_mac_X540_vf, 1002c6d45171SKY Srinivasan .mac_ops = &ixgbevf_hv_mac_ops, 1003c6d45171SKY Srinivasan }; 1004c6d45171SKY Srinivasan 100547068b0dSEmil Tantilov const struct ixgbevf_info ixgbevf_X550_vf_info = { 100647068b0dSEmil Tantilov .mac = ixgbe_mac_X550_vf, 100747068b0dSEmil Tantilov .mac_ops = &ixgbevf_mac_ops, 100847068b0dSEmil Tantilov }; 100947068b0dSEmil Tantilov 1010c6d45171SKY Srinivasan const struct ixgbevf_info ixgbevf_X550_vf_hv_info = { 1011c6d45171SKY Srinivasan .mac = ixgbe_mac_X550_vf, 1012c6d45171SKY Srinivasan .mac_ops = &ixgbevf_hv_mac_ops, 1013c6d45171SKY Srinivasan }; 1014c6d45171SKY Srinivasan 101547068b0dSEmil Tantilov const struct ixgbevf_info ixgbevf_X550EM_x_vf_info = { 101647068b0dSEmil Tantilov .mac = ixgbe_mac_X550EM_x_vf, 101747068b0dSEmil Tantilov .mac_ops = &ixgbevf_mac_ops, 101847068b0dSEmil Tantilov }; 1019c6d45171SKY Srinivasan 1020c6d45171SKY Srinivasan const struct ixgbevf_info ixgbevf_X550EM_x_vf_hv_info = { 1021c6d45171SKY Srinivasan .mac = ixgbe_mac_X550EM_x_vf, 1022c6d45171SKY Srinivasan .mac_ops = &ixgbevf_hv_mac_ops, 1023c6d45171SKY Srinivasan }; 10241d94f987SDon Skidmore 10251d94f987SDon Skidmore const struct ixgbevf_info ixgbevf_x550em_a_vf_info = { 10261d94f987SDon Skidmore .mac = ixgbe_mac_x550em_a_vf, 10271d94f987SDon Skidmore .mac_ops = &ixgbevf_mac_ops, 10281d94f987SDon Skidmore }; 1029