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 30dee1ad47SJeff Kirsher /** 31dee1ad47SJeff Kirsher * ixgbevf_start_hw_vf - Prepare hardware for Tx/Rx 32dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 33dee1ad47SJeff Kirsher * 34dee1ad47SJeff Kirsher * Starts the hardware by filling the bus info structure and media type, clears 35dee1ad47SJeff Kirsher * all on chip counters, initializes receive address registers, multicast 36dee1ad47SJeff Kirsher * table, VLAN filter table, calls routine to set up link and flow control 37dee1ad47SJeff Kirsher * settings, and leaves transmit and receive units disabled and uninitialized 38dee1ad47SJeff Kirsher **/ 39dee1ad47SJeff Kirsher static s32 ixgbevf_start_hw_vf(struct ixgbe_hw *hw) 40dee1ad47SJeff Kirsher { 41dee1ad47SJeff Kirsher /* Clear adapter stopped flag */ 42dee1ad47SJeff Kirsher hw->adapter_stopped = false; 43dee1ad47SJeff Kirsher 44dee1ad47SJeff Kirsher return 0; 45dee1ad47SJeff Kirsher } 46dee1ad47SJeff Kirsher 47dee1ad47SJeff Kirsher /** 48dee1ad47SJeff Kirsher * ixgbevf_init_hw_vf - virtual function hardware initialization 49dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 50dee1ad47SJeff Kirsher * 51dee1ad47SJeff Kirsher * Initialize the hardware by resetting the hardware and then starting 52dee1ad47SJeff Kirsher * the hardware 53dee1ad47SJeff Kirsher **/ 54dee1ad47SJeff Kirsher static s32 ixgbevf_init_hw_vf(struct ixgbe_hw *hw) 55dee1ad47SJeff Kirsher { 56dee1ad47SJeff Kirsher s32 status = hw->mac.ops.start_hw(hw); 57dee1ad47SJeff Kirsher 58dee1ad47SJeff Kirsher hw->mac.ops.get_mac_addr(hw, hw->mac.addr); 59dee1ad47SJeff Kirsher 60dee1ad47SJeff Kirsher return status; 61dee1ad47SJeff Kirsher } 62dee1ad47SJeff Kirsher 63dee1ad47SJeff Kirsher /** 64dee1ad47SJeff Kirsher * ixgbevf_reset_hw_vf - Performs hardware reset 65dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 66dee1ad47SJeff Kirsher * 67dbedd44eSJoe Perches * Resets the hardware by resetting the transmit and receive units, masks and 68dee1ad47SJeff Kirsher * clears all interrupts. 69dee1ad47SJeff Kirsher **/ 70dee1ad47SJeff Kirsher static s32 ixgbevf_reset_hw_vf(struct ixgbe_hw *hw) 71dee1ad47SJeff Kirsher { 72dee1ad47SJeff Kirsher struct ixgbe_mbx_info *mbx = &hw->mbx; 73dee1ad47SJeff Kirsher u32 timeout = IXGBE_VF_INIT_TIMEOUT; 74dee1ad47SJeff Kirsher s32 ret_val = IXGBE_ERR_INVALID_MAC_ADDR; 75dee1ad47SJeff Kirsher u32 msgbuf[IXGBE_VF_PERMADDR_MSG_LEN]; 76dee1ad47SJeff Kirsher u8 *addr = (u8 *)(&msgbuf[1]); 77dee1ad47SJeff Kirsher 78dee1ad47SJeff Kirsher /* Call adapter stop to disable tx/rx and clear interrupts */ 79dee1ad47SJeff Kirsher hw->mac.ops.stop_adapter(hw); 80dee1ad47SJeff Kirsher 8131186785SAlexander Duyck /* reset the api version */ 8231186785SAlexander Duyck hw->api_version = ixgbe_mbox_api_10; 8331186785SAlexander Duyck 84dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VFCTRL, IXGBE_CTRL_RST); 85dee1ad47SJeff Kirsher IXGBE_WRITE_FLUSH(hw); 86dee1ad47SJeff Kirsher 87dee1ad47SJeff Kirsher /* we cannot reset while the RSTI / RSTD bits are asserted */ 88dee1ad47SJeff Kirsher while (!mbx->ops.check_for_rst(hw) && timeout) { 89dee1ad47SJeff Kirsher timeout--; 90dee1ad47SJeff Kirsher udelay(5); 91dee1ad47SJeff Kirsher } 92dee1ad47SJeff Kirsher 93dee1ad47SJeff Kirsher if (!timeout) 94dee1ad47SJeff Kirsher return IXGBE_ERR_RESET_FAILED; 95dee1ad47SJeff Kirsher 96dee1ad47SJeff Kirsher /* mailbox timeout can now become active */ 97dee1ad47SJeff Kirsher mbx->timeout = IXGBE_VF_MBX_INIT_TIMEOUT; 98dee1ad47SJeff Kirsher 99dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_RESET; 100dee1ad47SJeff Kirsher mbx->ops.write_posted(hw, msgbuf, 1); 101dee1ad47SJeff Kirsher 102012dc19aSJohn Fastabend mdelay(10); 103dee1ad47SJeff Kirsher 104dec0d8e4SJeff Kirsher /* set our "perm_addr" based on info provided by PF 105dec0d8e4SJeff Kirsher * also set up the mc_filter_type which is piggy backed 106dec0d8e4SJeff Kirsher * on the mac address in word 3 107dec0d8e4SJeff Kirsher */ 108dee1ad47SJeff Kirsher ret_val = mbx->ops.read_posted(hw, msgbuf, IXGBE_VF_PERMADDR_MSG_LEN); 109dee1ad47SJeff Kirsher if (ret_val) 110dee1ad47SJeff Kirsher return ret_val; 111dee1ad47SJeff Kirsher 112e1941a74SGreg Rose /* New versions of the PF may NACK the reset return message 113e1941a74SGreg Rose * to indicate that no MAC address has yet been assigned for 114e1941a74SGreg Rose * the VF. 115e1941a74SGreg Rose */ 116e1941a74SGreg Rose if (msgbuf[0] != (IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_ACK) && 117e1941a74SGreg Rose msgbuf[0] != (IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_NACK)) 118dee1ad47SJeff Kirsher return IXGBE_ERR_INVALID_MAC_ADDR; 119dee1ad47SJeff Kirsher 120ea99d832SJoe Perches memcpy(hw->mac.perm_addr, addr, ETH_ALEN); 121dee1ad47SJeff Kirsher hw->mac.mc_filter_type = msgbuf[IXGBE_VF_MC_TYPE_WORD]; 122dee1ad47SJeff Kirsher 123dee1ad47SJeff Kirsher return 0; 124dee1ad47SJeff Kirsher } 125dee1ad47SJeff Kirsher 126dee1ad47SJeff Kirsher /** 127dee1ad47SJeff Kirsher * ixgbevf_stop_hw_vf - Generic stop Tx/Rx units 128dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 129dee1ad47SJeff Kirsher * 130dee1ad47SJeff Kirsher * Sets the adapter_stopped flag within ixgbe_hw struct. Clears interrupts, 131dee1ad47SJeff Kirsher * disables transmit and receive units. The adapter_stopped flag is used by 132dee1ad47SJeff Kirsher * the shared code and drivers to determine if the adapter is in a stopped 133dee1ad47SJeff Kirsher * state and should not touch the hardware. 134dee1ad47SJeff Kirsher **/ 135dee1ad47SJeff Kirsher static s32 ixgbevf_stop_hw_vf(struct ixgbe_hw *hw) 136dee1ad47SJeff Kirsher { 137dee1ad47SJeff Kirsher u32 number_of_queues; 138dee1ad47SJeff Kirsher u32 reg_val; 139dee1ad47SJeff Kirsher u16 i; 140dee1ad47SJeff Kirsher 141dec0d8e4SJeff Kirsher /* Set the adapter_stopped flag so other driver functions stop touching 142dee1ad47SJeff Kirsher * the hardware 143dee1ad47SJeff Kirsher */ 144dee1ad47SJeff Kirsher hw->adapter_stopped = true; 145dee1ad47SJeff Kirsher 146dee1ad47SJeff Kirsher /* Disable the receive unit by stopped each queue */ 147dee1ad47SJeff Kirsher number_of_queues = hw->mac.max_rx_queues; 148dee1ad47SJeff Kirsher for (i = 0; i < number_of_queues; i++) { 149dee1ad47SJeff Kirsher reg_val = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i)); 150dee1ad47SJeff Kirsher if (reg_val & IXGBE_RXDCTL_ENABLE) { 151dee1ad47SJeff Kirsher reg_val &= ~IXGBE_RXDCTL_ENABLE; 152dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(i), reg_val); 153dee1ad47SJeff Kirsher } 154dee1ad47SJeff Kirsher } 155dee1ad47SJeff Kirsher 156dee1ad47SJeff Kirsher IXGBE_WRITE_FLUSH(hw); 157dee1ad47SJeff Kirsher 158dee1ad47SJeff Kirsher /* Clear interrupt mask to stop from interrupts being generated */ 159dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VTEIMC, IXGBE_VF_IRQ_CLEAR_MASK); 160dee1ad47SJeff Kirsher 161dee1ad47SJeff Kirsher /* Clear any pending interrupts */ 162dee1ad47SJeff Kirsher IXGBE_READ_REG(hw, IXGBE_VTEICR); 163dee1ad47SJeff Kirsher 164dee1ad47SJeff Kirsher /* Disable the transmit unit. Each queue must be disabled. */ 165dee1ad47SJeff Kirsher number_of_queues = hw->mac.max_tx_queues; 166dee1ad47SJeff Kirsher for (i = 0; i < number_of_queues; i++) { 167dee1ad47SJeff Kirsher reg_val = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i)); 168dee1ad47SJeff Kirsher if (reg_val & IXGBE_TXDCTL_ENABLE) { 169dee1ad47SJeff Kirsher reg_val &= ~IXGBE_TXDCTL_ENABLE; 170dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(i), reg_val); 171dee1ad47SJeff Kirsher } 172dee1ad47SJeff Kirsher } 173dee1ad47SJeff Kirsher 174dee1ad47SJeff Kirsher return 0; 175dee1ad47SJeff Kirsher } 176dee1ad47SJeff Kirsher 177dee1ad47SJeff Kirsher /** 178dee1ad47SJeff Kirsher * ixgbevf_mta_vector - Determines bit-vector in multicast table to set 179dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 180dee1ad47SJeff Kirsher * @mc_addr: the multicast address 181dee1ad47SJeff Kirsher * 182dee1ad47SJeff Kirsher * Extracts the 12 bits, from a multicast address, to determine which 183dee1ad47SJeff Kirsher * bit-vector to set in the multicast table. The hardware uses 12 bits, from 184dec0d8e4SJeff Kirsher * incoming Rx multicast addresses, to determine the bit-vector to check in 185dee1ad47SJeff Kirsher * the MTA. Which of the 4 combination, of 12-bits, the hardware uses is set 186dee1ad47SJeff Kirsher * by the MO field of the MCSTCTRL. The MO field is set during initialization 187dee1ad47SJeff Kirsher * to mc_filter_type. 188dee1ad47SJeff Kirsher **/ 189dee1ad47SJeff Kirsher static s32 ixgbevf_mta_vector(struct ixgbe_hw *hw, u8 *mc_addr) 190dee1ad47SJeff Kirsher { 191dee1ad47SJeff Kirsher u32 vector = 0; 192dee1ad47SJeff Kirsher 193dee1ad47SJeff Kirsher switch (hw->mac.mc_filter_type) { 194dee1ad47SJeff Kirsher case 0: /* use bits [47:36] of the address */ 195dee1ad47SJeff Kirsher vector = ((mc_addr[4] >> 4) | (((u16)mc_addr[5]) << 4)); 196dee1ad47SJeff Kirsher break; 197dee1ad47SJeff Kirsher case 1: /* use bits [46:35] of the address */ 198dee1ad47SJeff Kirsher vector = ((mc_addr[4] >> 3) | (((u16)mc_addr[5]) << 5)); 199dee1ad47SJeff Kirsher break; 200dee1ad47SJeff Kirsher case 2: /* use bits [45:34] of the address */ 201dee1ad47SJeff Kirsher vector = ((mc_addr[4] >> 2) | (((u16)mc_addr[5]) << 6)); 202dee1ad47SJeff Kirsher break; 203dee1ad47SJeff Kirsher case 3: /* use bits [43:32] of the address */ 204dee1ad47SJeff Kirsher vector = ((mc_addr[4]) | (((u16)mc_addr[5]) << 8)); 205dee1ad47SJeff Kirsher break; 206dee1ad47SJeff Kirsher default: /* Invalid mc_filter_type */ 207dee1ad47SJeff Kirsher break; 208dee1ad47SJeff Kirsher } 209dee1ad47SJeff Kirsher 210dee1ad47SJeff Kirsher /* vector can only be 12-bits or boundary will be exceeded */ 211dee1ad47SJeff Kirsher vector &= 0xFFF; 212dee1ad47SJeff Kirsher return vector; 213dee1ad47SJeff Kirsher } 214dee1ad47SJeff Kirsher 215dee1ad47SJeff Kirsher /** 216dee1ad47SJeff Kirsher * ixgbevf_get_mac_addr_vf - Read device MAC address 217dee1ad47SJeff Kirsher * @hw: pointer to the HW structure 218dee1ad47SJeff Kirsher * @mac_addr: pointer to storage for retrieved MAC address 219dee1ad47SJeff Kirsher **/ 220dee1ad47SJeff Kirsher static s32 ixgbevf_get_mac_addr_vf(struct ixgbe_hw *hw, u8 *mac_addr) 221dee1ad47SJeff Kirsher { 222ea99d832SJoe Perches memcpy(mac_addr, hw->mac.perm_addr, ETH_ALEN); 223dee1ad47SJeff Kirsher 224dee1ad47SJeff Kirsher return 0; 225dee1ad47SJeff Kirsher } 226dee1ad47SJeff Kirsher 227dee1ad47SJeff Kirsher static s32 ixgbevf_set_uc_addr_vf(struct ixgbe_hw *hw, u32 index, u8 *addr) 228dee1ad47SJeff Kirsher { 229dee1ad47SJeff Kirsher struct ixgbe_mbx_info *mbx = &hw->mbx; 230dee1ad47SJeff Kirsher u32 msgbuf[3]; 231dee1ad47SJeff Kirsher u8 *msg_addr = (u8 *)(&msgbuf[1]); 232dee1ad47SJeff Kirsher s32 ret_val; 233dee1ad47SJeff Kirsher 234dee1ad47SJeff Kirsher memset(msgbuf, 0, sizeof(msgbuf)); 235dec0d8e4SJeff Kirsher /* If index is one then this is the start of a new list and needs 236dee1ad47SJeff Kirsher * indication to the PF so it can do it's own list management. 237dee1ad47SJeff Kirsher * If it is zero then that tells the PF to just clear all of 238dee1ad47SJeff Kirsher * this VF's macvlans and there is no new list. 239dee1ad47SJeff Kirsher */ 240dee1ad47SJeff Kirsher msgbuf[0] |= index << IXGBE_VT_MSGINFO_SHIFT; 241dee1ad47SJeff Kirsher msgbuf[0] |= IXGBE_VF_SET_MACVLAN; 242dee1ad47SJeff Kirsher if (addr) 243d458cdf7SJoe Perches memcpy(msg_addr, addr, ETH_ALEN); 244dee1ad47SJeff Kirsher ret_val = mbx->ops.write_posted(hw, msgbuf, 3); 245dee1ad47SJeff Kirsher 246dee1ad47SJeff Kirsher if (!ret_val) 247dee1ad47SJeff Kirsher ret_val = mbx->ops.read_posted(hw, msgbuf, 3); 248dee1ad47SJeff Kirsher 249dee1ad47SJeff Kirsher msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 250dee1ad47SJeff Kirsher 251dee1ad47SJeff Kirsher if (!ret_val) 252dee1ad47SJeff Kirsher if (msgbuf[0] == 253dee1ad47SJeff Kirsher (IXGBE_VF_SET_MACVLAN | IXGBE_VT_MSGTYPE_NACK)) 254dee1ad47SJeff Kirsher ret_val = -ENOMEM; 255dee1ad47SJeff Kirsher 256dee1ad47SJeff Kirsher return ret_val; 257dee1ad47SJeff Kirsher } 258dee1ad47SJeff Kirsher 259dee1ad47SJeff Kirsher /** 260dee1ad47SJeff Kirsher * ixgbevf_set_rar_vf - set device MAC address 261dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 262dee1ad47SJeff Kirsher * @index: Receive address register to write 263dee1ad47SJeff Kirsher * @addr: Address to put into receive address register 264dee1ad47SJeff Kirsher * @vmdq: Unused in this implementation 265dee1ad47SJeff Kirsher **/ 266dee1ad47SJeff Kirsher static s32 ixgbevf_set_rar_vf(struct ixgbe_hw *hw, u32 index, u8 *addr, 267dee1ad47SJeff Kirsher u32 vmdq) 268dee1ad47SJeff Kirsher { 269dee1ad47SJeff Kirsher struct ixgbe_mbx_info *mbx = &hw->mbx; 270dee1ad47SJeff Kirsher u32 msgbuf[3]; 271dee1ad47SJeff Kirsher u8 *msg_addr = (u8 *)(&msgbuf[1]); 272dee1ad47SJeff Kirsher s32 ret_val; 273dee1ad47SJeff Kirsher 274dee1ad47SJeff Kirsher memset(msgbuf, 0, sizeof(msgbuf)); 275dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_SET_MAC_ADDR; 276d458cdf7SJoe Perches memcpy(msg_addr, addr, ETH_ALEN); 277dee1ad47SJeff Kirsher ret_val = mbx->ops.write_posted(hw, msgbuf, 3); 278dee1ad47SJeff Kirsher 279dee1ad47SJeff Kirsher if (!ret_val) 280dee1ad47SJeff Kirsher ret_val = mbx->ops.read_posted(hw, msgbuf, 3); 281dee1ad47SJeff Kirsher 282dee1ad47SJeff Kirsher msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 283dee1ad47SJeff Kirsher 284dee1ad47SJeff Kirsher /* if nacked the address was rejected, use "perm_addr" */ 285dee1ad47SJeff Kirsher if (!ret_val && 286dee1ad47SJeff Kirsher (msgbuf[0] == (IXGBE_VF_SET_MAC_ADDR | IXGBE_VT_MSGTYPE_NACK))) 287dee1ad47SJeff Kirsher ixgbevf_get_mac_addr_vf(hw, hw->mac.addr); 288dee1ad47SJeff Kirsher 289dee1ad47SJeff Kirsher return ret_val; 290dee1ad47SJeff Kirsher } 291dee1ad47SJeff Kirsher 2923a2c4033SGreg Rose static void ixgbevf_write_msg_read_ack(struct ixgbe_hw *hw, 2933a2c4033SGreg Rose u32 *msg, u16 size) 2943a2c4033SGreg Rose { 2953a2c4033SGreg Rose struct ixgbe_mbx_info *mbx = &hw->mbx; 2963a2c4033SGreg Rose u32 retmsg[IXGBE_VFMAILBOX_SIZE]; 2973a2c4033SGreg Rose s32 retval = mbx->ops.write_posted(hw, msg, size); 2983a2c4033SGreg Rose 2993a2c4033SGreg Rose if (!retval) 3003a2c4033SGreg Rose mbx->ops.read_posted(hw, retmsg, size); 3013a2c4033SGreg Rose } 3023a2c4033SGreg Rose 303dee1ad47SJeff Kirsher /** 304dee1ad47SJeff Kirsher * ixgbevf_update_mc_addr_list_vf - Update Multicast addresses 305dee1ad47SJeff Kirsher * @hw: pointer to the HW structure 306dee1ad47SJeff Kirsher * @netdev: pointer to net device structure 307dee1ad47SJeff Kirsher * 308dee1ad47SJeff Kirsher * Updates the Multicast Table Array. 309dee1ad47SJeff Kirsher **/ 310dee1ad47SJeff Kirsher static s32 ixgbevf_update_mc_addr_list_vf(struct ixgbe_hw *hw, 311dee1ad47SJeff Kirsher struct net_device *netdev) 312dee1ad47SJeff Kirsher { 313dee1ad47SJeff Kirsher struct netdev_hw_addr *ha; 314dee1ad47SJeff Kirsher u32 msgbuf[IXGBE_VFMAILBOX_SIZE]; 315dee1ad47SJeff Kirsher u16 *vector_list = (u16 *)&msgbuf[1]; 316dee1ad47SJeff Kirsher u32 cnt, i; 317dee1ad47SJeff Kirsher 318dee1ad47SJeff Kirsher /* Each entry in the list uses 1 16 bit word. We have 30 319dee1ad47SJeff Kirsher * 16 bit words available in our HW msg buffer (minus 1 for the 320dee1ad47SJeff Kirsher * msg type). That's 30 hash values if we pack 'em right. If 321dee1ad47SJeff Kirsher * there are more than 30 MC addresses to add then punt the 322dee1ad47SJeff Kirsher * extras for now and then add code to handle more than 30 later. 323dee1ad47SJeff Kirsher * It would be unusual for a server to request that many multi-cast 324dee1ad47SJeff Kirsher * addresses except for in large enterprise network environments. 325dee1ad47SJeff Kirsher */ 326dee1ad47SJeff Kirsher 327dee1ad47SJeff Kirsher cnt = netdev_mc_count(netdev); 328dee1ad47SJeff Kirsher if (cnt > 30) 329dee1ad47SJeff Kirsher cnt = 30; 330dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_SET_MULTICAST; 331dee1ad47SJeff Kirsher msgbuf[0] |= cnt << IXGBE_VT_MSGINFO_SHIFT; 332dee1ad47SJeff Kirsher 333dee1ad47SJeff Kirsher i = 0; 334dee1ad47SJeff Kirsher netdev_for_each_mc_addr(ha, netdev) { 335dee1ad47SJeff Kirsher if (i == cnt) 336dee1ad47SJeff Kirsher break; 33746acc460SBen Hutchings if (is_link_local_ether_addr(ha->addr)) 338b3343a2aSJohn Fastabend continue; 339b3343a2aSJohn Fastabend 340dee1ad47SJeff Kirsher vector_list[i++] = ixgbevf_mta_vector(hw, ha->addr); 341dee1ad47SJeff Kirsher } 342dee1ad47SJeff Kirsher 3433a2c4033SGreg Rose ixgbevf_write_msg_read_ack(hw, msgbuf, IXGBE_VFMAILBOX_SIZE); 344dee1ad47SJeff Kirsher 345dee1ad47SJeff Kirsher return 0; 346dee1ad47SJeff Kirsher } 347dee1ad47SJeff Kirsher 348dee1ad47SJeff Kirsher /** 349dec0d8e4SJeff Kirsher * ixgbevf_set_vfta_vf - Set/Unset VLAN filter table address 350dee1ad47SJeff Kirsher * @hw: pointer to the HW structure 351dee1ad47SJeff Kirsher * @vlan: 12 bit VLAN ID 352dee1ad47SJeff Kirsher * @vind: unused by VF drivers 353dee1ad47SJeff Kirsher * @vlan_on: if true then set bit, else clear bit 354dee1ad47SJeff Kirsher **/ 355dee1ad47SJeff Kirsher static s32 ixgbevf_set_vfta_vf(struct ixgbe_hw *hw, u32 vlan, u32 vind, 356dee1ad47SJeff Kirsher bool vlan_on) 357dee1ad47SJeff Kirsher { 3582ddc7fe1SAlexander Duyck struct ixgbe_mbx_info *mbx = &hw->mbx; 359dee1ad47SJeff Kirsher u32 msgbuf[2]; 3602ddc7fe1SAlexander Duyck s32 err; 361dee1ad47SJeff Kirsher 362dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_SET_VLAN; 363dee1ad47SJeff Kirsher msgbuf[1] = vlan; 364dee1ad47SJeff Kirsher /* Setting the 8 bit field MSG INFO to TRUE indicates "add" */ 365dee1ad47SJeff Kirsher msgbuf[0] |= vlan_on << IXGBE_VT_MSGINFO_SHIFT; 366dee1ad47SJeff Kirsher 3672ddc7fe1SAlexander Duyck err = mbx->ops.write_posted(hw, msgbuf, 2); 3682ddc7fe1SAlexander Duyck if (err) 3692ddc7fe1SAlexander Duyck goto mbx_err; 3703a2c4033SGreg Rose 3712ddc7fe1SAlexander Duyck err = mbx->ops.read_posted(hw, msgbuf, 2); 3722ddc7fe1SAlexander Duyck if (err) 3732ddc7fe1SAlexander Duyck goto mbx_err; 3742ddc7fe1SAlexander Duyck 3752ddc7fe1SAlexander Duyck /* remove extra bits from the message */ 3762ddc7fe1SAlexander Duyck msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 3772ddc7fe1SAlexander Duyck msgbuf[0] &= ~(0xFF << IXGBE_VT_MSGINFO_SHIFT); 3782ddc7fe1SAlexander Duyck 3792ddc7fe1SAlexander Duyck if (msgbuf[0] != (IXGBE_VF_SET_VLAN | IXGBE_VT_MSGTYPE_ACK)) 3802ddc7fe1SAlexander Duyck err = IXGBE_ERR_INVALID_ARGUMENT; 3812ddc7fe1SAlexander Duyck 3822ddc7fe1SAlexander Duyck mbx_err: 3832ddc7fe1SAlexander Duyck return err; 384dee1ad47SJeff Kirsher } 385dee1ad47SJeff Kirsher 386dee1ad47SJeff Kirsher /** 387dee1ad47SJeff Kirsher * ixgbevf_setup_mac_link_vf - Setup MAC link settings 388dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 389dee1ad47SJeff Kirsher * @speed: Unused in this implementation 390dee1ad47SJeff Kirsher * @autoneg: Unused in this implementation 391dee1ad47SJeff Kirsher * @autoneg_wait_to_complete: Unused in this implementation 392dee1ad47SJeff Kirsher * 393dee1ad47SJeff Kirsher * Do nothing and return success. VF drivers are not allowed to change 394dee1ad47SJeff Kirsher * global settings. Maintained for driver compatibility. 395dee1ad47SJeff Kirsher **/ 396dee1ad47SJeff Kirsher static s32 ixgbevf_setup_mac_link_vf(struct ixgbe_hw *hw, 397dee1ad47SJeff Kirsher ixgbe_link_speed speed, bool autoneg, 398dee1ad47SJeff Kirsher bool autoneg_wait_to_complete) 399dee1ad47SJeff Kirsher { 400dee1ad47SJeff Kirsher return 0; 401dee1ad47SJeff Kirsher } 402dee1ad47SJeff Kirsher 403dee1ad47SJeff Kirsher /** 404dee1ad47SJeff Kirsher * ixgbevf_check_mac_link_vf - Get link/speed status 405dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 406dee1ad47SJeff Kirsher * @speed: pointer to link speed 407dee1ad47SJeff Kirsher * @link_up: true is link is up, false otherwise 408dee1ad47SJeff Kirsher * @autoneg_wait_to_complete: true when waiting for completion is needed 409dee1ad47SJeff Kirsher * 410dee1ad47SJeff Kirsher * Reads the links register to determine if link is up and the current speed 411dee1ad47SJeff Kirsher **/ 412dee1ad47SJeff Kirsher static s32 ixgbevf_check_mac_link_vf(struct ixgbe_hw *hw, 413dee1ad47SJeff Kirsher ixgbe_link_speed *speed, 414dee1ad47SJeff Kirsher bool *link_up, 415dee1ad47SJeff Kirsher bool autoneg_wait_to_complete) 416dee1ad47SJeff Kirsher { 4174b2cd27fSAlexander Duyck struct ixgbe_mbx_info *mbx = &hw->mbx; 4184b2cd27fSAlexander Duyck struct ixgbe_mac_info *mac = &hw->mac; 4194b2cd27fSAlexander Duyck s32 ret_val = 0; 420dee1ad47SJeff Kirsher u32 links_reg; 4214b2cd27fSAlexander Duyck u32 in_msg = 0; 422dee1ad47SJeff Kirsher 4234b2cd27fSAlexander Duyck /* If we were hit with a reset drop the link */ 4244b2cd27fSAlexander Duyck if (!mbx->ops.check_for_rst(hw) || !mbx->timeout) 4254b2cd27fSAlexander Duyck mac->get_link_status = true; 426dee1ad47SJeff Kirsher 4274b2cd27fSAlexander Duyck if (!mac->get_link_status) 4284b2cd27fSAlexander Duyck goto out; 4294b2cd27fSAlexander Duyck 4304b2cd27fSAlexander Duyck /* if link status is down no point in checking to see if pf is up */ 431dee1ad47SJeff Kirsher links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 4324b2cd27fSAlexander Duyck if (!(links_reg & IXGBE_LINKS_UP)) 4334b2cd27fSAlexander Duyck goto out; 434dee1ad47SJeff Kirsher 435b8a2ca19SEmil Tantilov /* for SFP+ modules and DA cables on 82599 it can take up to 500usecs 436b8a2ca19SEmil Tantilov * before the link status is correct 437b8a2ca19SEmil Tantilov */ 438b8a2ca19SEmil Tantilov if (mac->type == ixgbe_mac_82599_vf) { 439b8a2ca19SEmil Tantilov int i; 440b8a2ca19SEmil Tantilov 441b8a2ca19SEmil Tantilov for (i = 0; i < 5; i++) { 442b8a2ca19SEmil Tantilov udelay(100); 443b8a2ca19SEmil Tantilov links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 444b8a2ca19SEmil Tantilov 445b8a2ca19SEmil Tantilov if (!(links_reg & IXGBE_LINKS_UP)) 446b8a2ca19SEmil Tantilov goto out; 447b8a2ca19SEmil Tantilov } 448b8a2ca19SEmil Tantilov } 449b8a2ca19SEmil Tantilov 45031a1b375SGreg Rose switch (links_reg & IXGBE_LINKS_SPEED_82599) { 45131a1b375SGreg Rose case IXGBE_LINKS_SPEED_10G_82599: 452dee1ad47SJeff Kirsher *speed = IXGBE_LINK_SPEED_10GB_FULL; 45331a1b375SGreg Rose break; 45431a1b375SGreg Rose case IXGBE_LINKS_SPEED_1G_82599: 455dee1ad47SJeff Kirsher *speed = IXGBE_LINK_SPEED_1GB_FULL; 45631a1b375SGreg Rose break; 45731a1b375SGreg Rose case IXGBE_LINKS_SPEED_100_82599: 45831a1b375SGreg Rose *speed = IXGBE_LINK_SPEED_100_FULL; 45931a1b375SGreg Rose break; 46031a1b375SGreg Rose } 461dee1ad47SJeff Kirsher 4624b2cd27fSAlexander Duyck /* if the read failed it could just be a mailbox collision, best wait 463dec0d8e4SJeff Kirsher * until we are called again and don't report an error 464dec0d8e4SJeff Kirsher */ 4654b2cd27fSAlexander Duyck if (mbx->ops.read(hw, &in_msg, 1)) 4664b2cd27fSAlexander Duyck goto out; 4674b2cd27fSAlexander Duyck 4684b2cd27fSAlexander Duyck if (!(in_msg & IXGBE_VT_MSGTYPE_CTS)) { 4694b2cd27fSAlexander Duyck /* msg is not CTS and is NACK we must have lost CTS status */ 4704b2cd27fSAlexander Duyck if (in_msg & IXGBE_VT_MSGTYPE_NACK) 4714b2cd27fSAlexander Duyck ret_val = -1; 4724b2cd27fSAlexander Duyck goto out; 4734b2cd27fSAlexander Duyck } 4744b2cd27fSAlexander Duyck 4754b2cd27fSAlexander Duyck /* the pf is talking, if we timed out in the past we reinit */ 4764b2cd27fSAlexander Duyck if (!mbx->timeout) { 4774b2cd27fSAlexander Duyck ret_val = -1; 4784b2cd27fSAlexander Duyck goto out; 4794b2cd27fSAlexander Duyck } 4804b2cd27fSAlexander Duyck 4814b2cd27fSAlexander Duyck /* if we passed all the tests above then the link is up and we no 482dec0d8e4SJeff Kirsher * longer need to check for link 483dec0d8e4SJeff Kirsher */ 4844b2cd27fSAlexander Duyck mac->get_link_status = false; 4854b2cd27fSAlexander Duyck 4864b2cd27fSAlexander Duyck out: 4874b2cd27fSAlexander Duyck *link_up = !mac->get_link_status; 4884b2cd27fSAlexander Duyck return ret_val; 489dee1ad47SJeff Kirsher } 490dee1ad47SJeff Kirsher 491dd1fe113SAlexander Duyck /** 492dd1fe113SAlexander Duyck * ixgbevf_rlpml_set_vf - Set the maximum receive packet length 493dd1fe113SAlexander Duyck * @hw: pointer to the HW structure 494dd1fe113SAlexander Duyck * @max_size: value to assign to max frame size 495dd1fe113SAlexander Duyck **/ 496dd1fe113SAlexander Duyck void ixgbevf_rlpml_set_vf(struct ixgbe_hw *hw, u16 max_size) 497dd1fe113SAlexander Duyck { 498dd1fe113SAlexander Duyck u32 msgbuf[2]; 499dd1fe113SAlexander Duyck 500dd1fe113SAlexander Duyck msgbuf[0] = IXGBE_VF_SET_LPE; 501dd1fe113SAlexander Duyck msgbuf[1] = max_size; 502dd1fe113SAlexander Duyck ixgbevf_write_msg_read_ack(hw, msgbuf, 2); 503dd1fe113SAlexander Duyck } 504dd1fe113SAlexander Duyck 50531186785SAlexander Duyck /** 50631186785SAlexander Duyck * ixgbevf_negotiate_api_version - Negotiate supported API version 50731186785SAlexander Duyck * @hw: pointer to the HW structure 50831186785SAlexander Duyck * @api: integer containing requested API version 50931186785SAlexander Duyck **/ 51031186785SAlexander Duyck int ixgbevf_negotiate_api_version(struct ixgbe_hw *hw, int api) 51131186785SAlexander Duyck { 51231186785SAlexander Duyck int err; 51331186785SAlexander Duyck u32 msg[3]; 51431186785SAlexander Duyck 51531186785SAlexander Duyck /* Negotiate the mailbox API version */ 51631186785SAlexander Duyck msg[0] = IXGBE_VF_API_NEGOTIATE; 51731186785SAlexander Duyck msg[1] = api; 51831186785SAlexander Duyck msg[2] = 0; 51931186785SAlexander Duyck err = hw->mbx.ops.write_posted(hw, msg, 3); 52031186785SAlexander Duyck 52131186785SAlexander Duyck if (!err) 52231186785SAlexander Duyck err = hw->mbx.ops.read_posted(hw, msg, 3); 52331186785SAlexander Duyck 52431186785SAlexander Duyck if (!err) { 52531186785SAlexander Duyck msg[0] &= ~IXGBE_VT_MSGTYPE_CTS; 52631186785SAlexander Duyck 52731186785SAlexander Duyck /* Store value and return 0 on success */ 52831186785SAlexander Duyck if (msg[0] == (IXGBE_VF_API_NEGOTIATE | IXGBE_VT_MSGTYPE_ACK)) { 52931186785SAlexander Duyck hw->api_version = api; 53031186785SAlexander Duyck return 0; 53131186785SAlexander Duyck } 53231186785SAlexander Duyck 53331186785SAlexander Duyck err = IXGBE_ERR_INVALID_ARGUMENT; 53431186785SAlexander Duyck } 53531186785SAlexander Duyck 53631186785SAlexander Duyck return err; 53731186785SAlexander Duyck } 53831186785SAlexander Duyck 53956e94095SAlexander Duyck int ixgbevf_get_queues(struct ixgbe_hw *hw, unsigned int *num_tcs, 54056e94095SAlexander Duyck unsigned int *default_tc) 54156e94095SAlexander Duyck { 54256e94095SAlexander Duyck int err; 54356e94095SAlexander Duyck u32 msg[5]; 54456e94095SAlexander Duyck 54556e94095SAlexander Duyck /* do nothing if API doesn't support ixgbevf_get_queues */ 54656e94095SAlexander Duyck switch (hw->api_version) { 54756e94095SAlexander Duyck case ixgbe_mbox_api_11: 54856e94095SAlexander Duyck break; 54956e94095SAlexander Duyck default: 55056e94095SAlexander Duyck return 0; 55156e94095SAlexander Duyck } 55256e94095SAlexander Duyck 55356e94095SAlexander Duyck /* Fetch queue configuration from the PF */ 55456e94095SAlexander Duyck msg[0] = IXGBE_VF_GET_QUEUE; 55556e94095SAlexander Duyck msg[1] = msg[2] = msg[3] = msg[4] = 0; 55656e94095SAlexander Duyck err = hw->mbx.ops.write_posted(hw, msg, 5); 55756e94095SAlexander Duyck 55856e94095SAlexander Duyck if (!err) 55956e94095SAlexander Duyck err = hw->mbx.ops.read_posted(hw, msg, 5); 56056e94095SAlexander Duyck 56156e94095SAlexander Duyck if (!err) { 56256e94095SAlexander Duyck msg[0] &= ~IXGBE_VT_MSGTYPE_CTS; 56356e94095SAlexander Duyck 564dec0d8e4SJeff Kirsher /* if we we didn't get an ACK there must have been 56556e94095SAlexander Duyck * some sort of mailbox error so we should treat it 56656e94095SAlexander Duyck * as such 56756e94095SAlexander Duyck */ 56856e94095SAlexander Duyck if (msg[0] != (IXGBE_VF_GET_QUEUE | IXGBE_VT_MSGTYPE_ACK)) 56956e94095SAlexander Duyck return IXGBE_ERR_MBX; 57056e94095SAlexander Duyck 57156e94095SAlexander Duyck /* record and validate values from message */ 57256e94095SAlexander Duyck hw->mac.max_tx_queues = msg[IXGBE_VF_TX_QUEUES]; 57356e94095SAlexander Duyck if (hw->mac.max_tx_queues == 0 || 57456e94095SAlexander Duyck hw->mac.max_tx_queues > IXGBE_VF_MAX_TX_QUEUES) 57556e94095SAlexander Duyck hw->mac.max_tx_queues = IXGBE_VF_MAX_TX_QUEUES; 57656e94095SAlexander Duyck 57756e94095SAlexander Duyck hw->mac.max_rx_queues = msg[IXGBE_VF_RX_QUEUES]; 57856e94095SAlexander Duyck if (hw->mac.max_rx_queues == 0 || 57956e94095SAlexander Duyck hw->mac.max_rx_queues > IXGBE_VF_MAX_RX_QUEUES) 58056e94095SAlexander Duyck hw->mac.max_rx_queues = IXGBE_VF_MAX_RX_QUEUES; 58156e94095SAlexander Duyck 58256e94095SAlexander Duyck *num_tcs = msg[IXGBE_VF_TRANS_VLAN]; 58356e94095SAlexander Duyck /* in case of unknown state assume we cannot tag frames */ 58456e94095SAlexander Duyck if (*num_tcs > hw->mac.max_rx_queues) 58556e94095SAlexander Duyck *num_tcs = 1; 58656e94095SAlexander Duyck 58756e94095SAlexander Duyck *default_tc = msg[IXGBE_VF_DEF_QUEUE]; 58856e94095SAlexander Duyck /* default to queue 0 on out-of-bounds queue number */ 58956e94095SAlexander Duyck if (*default_tc >= hw->mac.max_tx_queues) 59056e94095SAlexander Duyck *default_tc = 0; 59156e94095SAlexander Duyck } 59256e94095SAlexander Duyck 59356e94095SAlexander Duyck return err; 59456e94095SAlexander Duyck } 59556e94095SAlexander Duyck 5963d8fe98fSStephen Hemminger static const struct ixgbe_mac_operations ixgbevf_mac_ops = { 597dee1ad47SJeff Kirsher .init_hw = ixgbevf_init_hw_vf, 598dee1ad47SJeff Kirsher .reset_hw = ixgbevf_reset_hw_vf, 599dee1ad47SJeff Kirsher .start_hw = ixgbevf_start_hw_vf, 600dee1ad47SJeff Kirsher .get_mac_addr = ixgbevf_get_mac_addr_vf, 601dee1ad47SJeff Kirsher .stop_adapter = ixgbevf_stop_hw_vf, 602dee1ad47SJeff Kirsher .setup_link = ixgbevf_setup_mac_link_vf, 603dee1ad47SJeff Kirsher .check_link = ixgbevf_check_mac_link_vf, 604dee1ad47SJeff Kirsher .set_rar = ixgbevf_set_rar_vf, 605dee1ad47SJeff Kirsher .update_mc_addr_list = ixgbevf_update_mc_addr_list_vf, 606dee1ad47SJeff Kirsher .set_uc_addr = ixgbevf_set_uc_addr_vf, 607dee1ad47SJeff Kirsher .set_vfta = ixgbevf_set_vfta_vf, 608dee1ad47SJeff Kirsher }; 609dee1ad47SJeff Kirsher 6103d8fe98fSStephen Hemminger const struct ixgbevf_info ixgbevf_82599_vf_info = { 611dee1ad47SJeff Kirsher .mac = ixgbe_mac_82599_vf, 612dee1ad47SJeff Kirsher .mac_ops = &ixgbevf_mac_ops, 613dee1ad47SJeff Kirsher }; 614dee1ad47SJeff Kirsher 6153d8fe98fSStephen Hemminger const struct ixgbevf_info ixgbevf_X540_vf_info = { 616dee1ad47SJeff Kirsher .mac = ixgbe_mac_X540_vf, 617dee1ad47SJeff Kirsher .mac_ops = &ixgbevf_mac_ops, 618dee1ad47SJeff Kirsher }; 61947068b0dSEmil Tantilov 62047068b0dSEmil Tantilov const struct ixgbevf_info ixgbevf_X550_vf_info = { 62147068b0dSEmil Tantilov .mac = ixgbe_mac_X550_vf, 62247068b0dSEmil Tantilov .mac_ops = &ixgbevf_mac_ops, 62347068b0dSEmil Tantilov }; 62447068b0dSEmil Tantilov 62547068b0dSEmil Tantilov const struct ixgbevf_info ixgbevf_X550EM_x_vf_info = { 62647068b0dSEmil Tantilov .mac = ixgbe_mac_X550EM_x_vf, 62747068b0dSEmil Tantilov .mac_ops = &ixgbevf_mac_ops, 62847068b0dSEmil Tantilov }; 629