1dee1ad47SJeff Kirsher /******************************************************************************* 2dee1ad47SJeff Kirsher 3dee1ad47SJeff Kirsher Intel 82599 Virtual Function driver 45c47a2b6SGreg Rose Copyright(c) 1999 - 2012 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 16dee1ad47SJeff Kirsher this program; if not, write to the Free Software Foundation, Inc., 17dee1ad47SJeff Kirsher 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. 18dee1ad47SJeff Kirsher 19dee1ad47SJeff Kirsher The full GNU General Public License is included in this distribution in 20dee1ad47SJeff Kirsher the file called "COPYING". 21dee1ad47SJeff Kirsher 22dee1ad47SJeff Kirsher Contact Information: 23dee1ad47SJeff Kirsher e1000-devel Mailing List <e1000-devel@lists.sourceforge.net> 24dee1ad47SJeff Kirsher Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 25dee1ad47SJeff Kirsher 26dee1ad47SJeff Kirsher *******************************************************************************/ 27dee1ad47SJeff Kirsher 28dee1ad47SJeff Kirsher #include "vf.h" 29b5417bf8SStephen Hemminger #include "ixgbevf.h" 30dee1ad47SJeff Kirsher 31dee1ad47SJeff Kirsher /** 32dee1ad47SJeff Kirsher * ixgbevf_start_hw_vf - Prepare hardware for Tx/Rx 33dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 34dee1ad47SJeff Kirsher * 35dee1ad47SJeff Kirsher * Starts the hardware by filling the bus info structure and media type, clears 36dee1ad47SJeff Kirsher * all on chip counters, initializes receive address registers, multicast 37dee1ad47SJeff Kirsher * table, VLAN filter table, calls routine to set up link and flow control 38dee1ad47SJeff Kirsher * settings, and leaves transmit and receive units disabled and uninitialized 39dee1ad47SJeff Kirsher **/ 40dee1ad47SJeff Kirsher static s32 ixgbevf_start_hw_vf(struct ixgbe_hw *hw) 41dee1ad47SJeff Kirsher { 42dee1ad47SJeff Kirsher /* Clear adapter stopped flag */ 43dee1ad47SJeff Kirsher hw->adapter_stopped = false; 44dee1ad47SJeff Kirsher 45dee1ad47SJeff Kirsher return 0; 46dee1ad47SJeff Kirsher } 47dee1ad47SJeff Kirsher 48dee1ad47SJeff Kirsher /** 49dee1ad47SJeff Kirsher * ixgbevf_init_hw_vf - virtual function hardware initialization 50dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 51dee1ad47SJeff Kirsher * 52dee1ad47SJeff Kirsher * Initialize the hardware by resetting the hardware and then starting 53dee1ad47SJeff Kirsher * the hardware 54dee1ad47SJeff Kirsher **/ 55dee1ad47SJeff Kirsher static s32 ixgbevf_init_hw_vf(struct ixgbe_hw *hw) 56dee1ad47SJeff Kirsher { 57dee1ad47SJeff Kirsher s32 status = hw->mac.ops.start_hw(hw); 58dee1ad47SJeff Kirsher 59dee1ad47SJeff Kirsher hw->mac.ops.get_mac_addr(hw, hw->mac.addr); 60dee1ad47SJeff Kirsher 61dee1ad47SJeff Kirsher return status; 62dee1ad47SJeff Kirsher } 63dee1ad47SJeff Kirsher 64dee1ad47SJeff Kirsher /** 65dee1ad47SJeff Kirsher * ixgbevf_reset_hw_vf - Performs hardware reset 66dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 67dee1ad47SJeff Kirsher * 68dee1ad47SJeff Kirsher * Resets the hardware by reseting the transmit and receive units, masks and 69dee1ad47SJeff Kirsher * clears all interrupts. 70dee1ad47SJeff Kirsher **/ 71dee1ad47SJeff Kirsher static s32 ixgbevf_reset_hw_vf(struct ixgbe_hw *hw) 72dee1ad47SJeff Kirsher { 73dee1ad47SJeff Kirsher struct ixgbe_mbx_info *mbx = &hw->mbx; 74dee1ad47SJeff Kirsher u32 timeout = IXGBE_VF_INIT_TIMEOUT; 75dee1ad47SJeff Kirsher s32 ret_val = IXGBE_ERR_INVALID_MAC_ADDR; 76dee1ad47SJeff Kirsher u32 msgbuf[IXGBE_VF_PERMADDR_MSG_LEN]; 77dee1ad47SJeff Kirsher u8 *addr = (u8 *)(&msgbuf[1]); 78dee1ad47SJeff Kirsher 79dee1ad47SJeff Kirsher /* Call adapter stop to disable tx/rx and clear interrupts */ 80dee1ad47SJeff Kirsher hw->mac.ops.stop_adapter(hw); 81dee1ad47SJeff Kirsher 8231186785SAlexander Duyck /* reset the api version */ 8331186785SAlexander Duyck hw->api_version = ixgbe_mbox_api_10; 8431186785SAlexander Duyck 85dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VFCTRL, IXGBE_CTRL_RST); 86dee1ad47SJeff Kirsher IXGBE_WRITE_FLUSH(hw); 87dee1ad47SJeff Kirsher 88dee1ad47SJeff Kirsher /* we cannot reset while the RSTI / RSTD bits are asserted */ 89dee1ad47SJeff Kirsher while (!mbx->ops.check_for_rst(hw) && timeout) { 90dee1ad47SJeff Kirsher timeout--; 91dee1ad47SJeff Kirsher udelay(5); 92dee1ad47SJeff Kirsher } 93dee1ad47SJeff Kirsher 94dee1ad47SJeff Kirsher if (!timeout) 95dee1ad47SJeff Kirsher return IXGBE_ERR_RESET_FAILED; 96dee1ad47SJeff Kirsher 97dee1ad47SJeff Kirsher /* mailbox timeout can now become active */ 98dee1ad47SJeff Kirsher mbx->timeout = IXGBE_VF_MBX_INIT_TIMEOUT; 99dee1ad47SJeff Kirsher 100dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_RESET; 101dee1ad47SJeff Kirsher mbx->ops.write_posted(hw, msgbuf, 1); 102dee1ad47SJeff Kirsher 103012dc19aSJohn Fastabend mdelay(10); 104dee1ad47SJeff Kirsher 105dee1ad47SJeff Kirsher /* set our "perm_addr" based on info provided by PF */ 106dee1ad47SJeff Kirsher /* also set up the mc_filter_type which is piggy backed 107dee1ad47SJeff Kirsher * on the mac address in word 3 */ 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 141dee1ad47SJeff Kirsher /* 142dee1ad47SJeff Kirsher * Set the adapter_stopped flag so other driver functions stop touching 143dee1ad47SJeff Kirsher * the hardware 144dee1ad47SJeff Kirsher */ 145dee1ad47SJeff Kirsher hw->adapter_stopped = true; 146dee1ad47SJeff Kirsher 147dee1ad47SJeff Kirsher /* Disable the receive unit by stopped each queue */ 148dee1ad47SJeff Kirsher number_of_queues = hw->mac.max_rx_queues; 149dee1ad47SJeff Kirsher for (i = 0; i < number_of_queues; i++) { 150dee1ad47SJeff Kirsher reg_val = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i)); 151dee1ad47SJeff Kirsher if (reg_val & IXGBE_RXDCTL_ENABLE) { 152dee1ad47SJeff Kirsher reg_val &= ~IXGBE_RXDCTL_ENABLE; 153dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(i), reg_val); 154dee1ad47SJeff Kirsher } 155dee1ad47SJeff Kirsher } 156dee1ad47SJeff Kirsher 157dee1ad47SJeff Kirsher IXGBE_WRITE_FLUSH(hw); 158dee1ad47SJeff Kirsher 159dee1ad47SJeff Kirsher /* Clear interrupt mask to stop from interrupts being generated */ 160dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VTEIMC, IXGBE_VF_IRQ_CLEAR_MASK); 161dee1ad47SJeff Kirsher 162dee1ad47SJeff Kirsher /* Clear any pending interrupts */ 163dee1ad47SJeff Kirsher IXGBE_READ_REG(hw, IXGBE_VTEICR); 164dee1ad47SJeff Kirsher 165dee1ad47SJeff Kirsher /* Disable the transmit unit. Each queue must be disabled. */ 166dee1ad47SJeff Kirsher number_of_queues = hw->mac.max_tx_queues; 167dee1ad47SJeff Kirsher for (i = 0; i < number_of_queues; i++) { 168dee1ad47SJeff Kirsher reg_val = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i)); 169dee1ad47SJeff Kirsher if (reg_val & IXGBE_TXDCTL_ENABLE) { 170dee1ad47SJeff Kirsher reg_val &= ~IXGBE_TXDCTL_ENABLE; 171dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(i), reg_val); 172dee1ad47SJeff Kirsher } 173dee1ad47SJeff Kirsher } 174dee1ad47SJeff Kirsher 175dee1ad47SJeff Kirsher return 0; 176dee1ad47SJeff Kirsher } 177dee1ad47SJeff Kirsher 178dee1ad47SJeff Kirsher /** 179dee1ad47SJeff Kirsher * ixgbevf_mta_vector - Determines bit-vector in multicast table to set 180dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 181dee1ad47SJeff Kirsher * @mc_addr: the multicast address 182dee1ad47SJeff Kirsher * 183dee1ad47SJeff Kirsher * Extracts the 12 bits, from a multicast address, to determine which 184dee1ad47SJeff Kirsher * bit-vector to set in the multicast table. The hardware uses 12 bits, from 185dee1ad47SJeff Kirsher * incoming rx multicast addresses, to determine the bit-vector to check in 186dee1ad47SJeff Kirsher * the MTA. Which of the 4 combination, of 12-bits, the hardware uses is set 187dee1ad47SJeff Kirsher * by the MO field of the MCSTCTRL. The MO field is set during initialization 188dee1ad47SJeff Kirsher * to mc_filter_type. 189dee1ad47SJeff Kirsher **/ 190dee1ad47SJeff Kirsher static s32 ixgbevf_mta_vector(struct ixgbe_hw *hw, u8 *mc_addr) 191dee1ad47SJeff Kirsher { 192dee1ad47SJeff Kirsher u32 vector = 0; 193dee1ad47SJeff Kirsher 194dee1ad47SJeff Kirsher switch (hw->mac.mc_filter_type) { 195dee1ad47SJeff Kirsher case 0: /* use bits [47:36] of the address */ 196dee1ad47SJeff Kirsher vector = ((mc_addr[4] >> 4) | (((u16)mc_addr[5]) << 4)); 197dee1ad47SJeff Kirsher break; 198dee1ad47SJeff Kirsher case 1: /* use bits [46:35] of the address */ 199dee1ad47SJeff Kirsher vector = ((mc_addr[4] >> 3) | (((u16)mc_addr[5]) << 5)); 200dee1ad47SJeff Kirsher break; 201dee1ad47SJeff Kirsher case 2: /* use bits [45:34] of the address */ 202dee1ad47SJeff Kirsher vector = ((mc_addr[4] >> 2) | (((u16)mc_addr[5]) << 6)); 203dee1ad47SJeff Kirsher break; 204dee1ad47SJeff Kirsher case 3: /* use bits [43:32] of the address */ 205dee1ad47SJeff Kirsher vector = ((mc_addr[4]) | (((u16)mc_addr[5]) << 8)); 206dee1ad47SJeff Kirsher break; 207dee1ad47SJeff Kirsher default: /* Invalid mc_filter_type */ 208dee1ad47SJeff Kirsher break; 209dee1ad47SJeff Kirsher } 210dee1ad47SJeff Kirsher 211dee1ad47SJeff Kirsher /* vector can only be 12-bits or boundary will be exceeded */ 212dee1ad47SJeff Kirsher vector &= 0xFFF; 213dee1ad47SJeff Kirsher return vector; 214dee1ad47SJeff Kirsher } 215dee1ad47SJeff Kirsher 216dee1ad47SJeff Kirsher /** 217dee1ad47SJeff Kirsher * ixgbevf_get_mac_addr_vf - Read device MAC address 218dee1ad47SJeff Kirsher * @hw: pointer to the HW structure 219dee1ad47SJeff Kirsher * @mac_addr: pointer to storage for retrieved MAC address 220dee1ad47SJeff Kirsher **/ 221dee1ad47SJeff Kirsher static s32 ixgbevf_get_mac_addr_vf(struct ixgbe_hw *hw, u8 *mac_addr) 222dee1ad47SJeff Kirsher { 223ea99d832SJoe Perches memcpy(mac_addr, hw->mac.perm_addr, ETH_ALEN); 224dee1ad47SJeff Kirsher 225dee1ad47SJeff Kirsher return 0; 226dee1ad47SJeff Kirsher } 227dee1ad47SJeff Kirsher 228dee1ad47SJeff Kirsher static s32 ixgbevf_set_uc_addr_vf(struct ixgbe_hw *hw, u32 index, u8 *addr) 229dee1ad47SJeff Kirsher { 230dee1ad47SJeff Kirsher struct ixgbe_mbx_info *mbx = &hw->mbx; 231dee1ad47SJeff Kirsher u32 msgbuf[3]; 232dee1ad47SJeff Kirsher u8 *msg_addr = (u8 *)(&msgbuf[1]); 233dee1ad47SJeff Kirsher s32 ret_val; 234dee1ad47SJeff Kirsher 235dee1ad47SJeff Kirsher memset(msgbuf, 0, sizeof(msgbuf)); 236dee1ad47SJeff Kirsher /* 237dee1ad47SJeff Kirsher * If index is one then this is the start of a new list and needs 238dee1ad47SJeff Kirsher * indication to the PF so it can do it's own list management. 239dee1ad47SJeff Kirsher * If it is zero then that tells the PF to just clear all of 240dee1ad47SJeff Kirsher * this VF's macvlans and there is no new list. 241dee1ad47SJeff Kirsher */ 242dee1ad47SJeff Kirsher msgbuf[0] |= index << IXGBE_VT_MSGINFO_SHIFT; 243dee1ad47SJeff Kirsher msgbuf[0] |= IXGBE_VF_SET_MACVLAN; 244dee1ad47SJeff Kirsher if (addr) 245d458cdf7SJoe Perches memcpy(msg_addr, addr, ETH_ALEN); 246dee1ad47SJeff Kirsher ret_val = mbx->ops.write_posted(hw, msgbuf, 3); 247dee1ad47SJeff Kirsher 248dee1ad47SJeff Kirsher if (!ret_val) 249dee1ad47SJeff Kirsher ret_val = mbx->ops.read_posted(hw, msgbuf, 3); 250dee1ad47SJeff Kirsher 251dee1ad47SJeff Kirsher msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 252dee1ad47SJeff Kirsher 253dee1ad47SJeff Kirsher if (!ret_val) 254dee1ad47SJeff Kirsher if (msgbuf[0] == 255dee1ad47SJeff Kirsher (IXGBE_VF_SET_MACVLAN | IXGBE_VT_MSGTYPE_NACK)) 256dee1ad47SJeff Kirsher ret_val = -ENOMEM; 257dee1ad47SJeff Kirsher 258dee1ad47SJeff Kirsher return ret_val; 259dee1ad47SJeff Kirsher } 260dee1ad47SJeff Kirsher 261dee1ad47SJeff Kirsher /** 262dee1ad47SJeff Kirsher * ixgbevf_set_rar_vf - set device MAC address 263dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 264dee1ad47SJeff Kirsher * @index: Receive address register to write 265dee1ad47SJeff Kirsher * @addr: Address to put into receive address register 266dee1ad47SJeff Kirsher * @vmdq: Unused in this implementation 267dee1ad47SJeff Kirsher **/ 268dee1ad47SJeff Kirsher static s32 ixgbevf_set_rar_vf(struct ixgbe_hw *hw, u32 index, u8 *addr, 269dee1ad47SJeff Kirsher u32 vmdq) 270dee1ad47SJeff Kirsher { 271dee1ad47SJeff Kirsher struct ixgbe_mbx_info *mbx = &hw->mbx; 272dee1ad47SJeff Kirsher u32 msgbuf[3]; 273dee1ad47SJeff Kirsher u8 *msg_addr = (u8 *)(&msgbuf[1]); 274dee1ad47SJeff Kirsher s32 ret_val; 275dee1ad47SJeff Kirsher 276dee1ad47SJeff Kirsher memset(msgbuf, 0, sizeof(msgbuf)); 277dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_SET_MAC_ADDR; 278d458cdf7SJoe Perches memcpy(msg_addr, addr, ETH_ALEN); 279dee1ad47SJeff Kirsher ret_val = mbx->ops.write_posted(hw, msgbuf, 3); 280dee1ad47SJeff Kirsher 281dee1ad47SJeff Kirsher if (!ret_val) 282dee1ad47SJeff Kirsher ret_val = mbx->ops.read_posted(hw, msgbuf, 3); 283dee1ad47SJeff Kirsher 284dee1ad47SJeff Kirsher msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 285dee1ad47SJeff Kirsher 286dee1ad47SJeff Kirsher /* if nacked the address was rejected, use "perm_addr" */ 287dee1ad47SJeff Kirsher if (!ret_val && 288dee1ad47SJeff Kirsher (msgbuf[0] == (IXGBE_VF_SET_MAC_ADDR | IXGBE_VT_MSGTYPE_NACK))) 289dee1ad47SJeff Kirsher ixgbevf_get_mac_addr_vf(hw, hw->mac.addr); 290dee1ad47SJeff Kirsher 291dee1ad47SJeff Kirsher return ret_val; 292dee1ad47SJeff Kirsher } 293dee1ad47SJeff Kirsher 2943a2c4033SGreg Rose static void ixgbevf_write_msg_read_ack(struct ixgbe_hw *hw, 2953a2c4033SGreg Rose u32 *msg, u16 size) 2963a2c4033SGreg Rose { 2973a2c4033SGreg Rose struct ixgbe_mbx_info *mbx = &hw->mbx; 2983a2c4033SGreg Rose u32 retmsg[IXGBE_VFMAILBOX_SIZE]; 2993a2c4033SGreg Rose s32 retval = mbx->ops.write_posted(hw, msg, size); 3003a2c4033SGreg Rose 3013a2c4033SGreg Rose if (!retval) 3023a2c4033SGreg Rose mbx->ops.read_posted(hw, retmsg, size); 3033a2c4033SGreg Rose } 3043a2c4033SGreg Rose 305dee1ad47SJeff Kirsher /** 306dee1ad47SJeff Kirsher * ixgbevf_update_mc_addr_list_vf - Update Multicast addresses 307dee1ad47SJeff Kirsher * @hw: pointer to the HW structure 308dee1ad47SJeff Kirsher * @netdev: pointer to net device structure 309dee1ad47SJeff Kirsher * 310dee1ad47SJeff Kirsher * Updates the Multicast Table Array. 311dee1ad47SJeff Kirsher **/ 312dee1ad47SJeff Kirsher static s32 ixgbevf_update_mc_addr_list_vf(struct ixgbe_hw *hw, 313dee1ad47SJeff Kirsher struct net_device *netdev) 314dee1ad47SJeff Kirsher { 315dee1ad47SJeff Kirsher struct netdev_hw_addr *ha; 316dee1ad47SJeff Kirsher u32 msgbuf[IXGBE_VFMAILBOX_SIZE]; 317dee1ad47SJeff Kirsher u16 *vector_list = (u16 *)&msgbuf[1]; 318dee1ad47SJeff Kirsher u32 cnt, i; 319dee1ad47SJeff Kirsher 320dee1ad47SJeff Kirsher /* Each entry in the list uses 1 16 bit word. We have 30 321dee1ad47SJeff Kirsher * 16 bit words available in our HW msg buffer (minus 1 for the 322dee1ad47SJeff Kirsher * msg type). That's 30 hash values if we pack 'em right. If 323dee1ad47SJeff Kirsher * there are more than 30 MC addresses to add then punt the 324dee1ad47SJeff Kirsher * extras for now and then add code to handle more than 30 later. 325dee1ad47SJeff Kirsher * It would be unusual for a server to request that many multi-cast 326dee1ad47SJeff Kirsher * addresses except for in large enterprise network environments. 327dee1ad47SJeff Kirsher */ 328dee1ad47SJeff Kirsher 329dee1ad47SJeff Kirsher cnt = netdev_mc_count(netdev); 330dee1ad47SJeff Kirsher if (cnt > 30) 331dee1ad47SJeff Kirsher cnt = 30; 332dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_SET_MULTICAST; 333dee1ad47SJeff Kirsher msgbuf[0] |= cnt << IXGBE_VT_MSGINFO_SHIFT; 334dee1ad47SJeff Kirsher 335dee1ad47SJeff Kirsher i = 0; 336dee1ad47SJeff Kirsher netdev_for_each_mc_addr(ha, netdev) { 337dee1ad47SJeff Kirsher if (i == cnt) 338dee1ad47SJeff Kirsher break; 33946acc460SBen Hutchings if (is_link_local_ether_addr(ha->addr)) 340b3343a2aSJohn Fastabend continue; 341b3343a2aSJohn Fastabend 342dee1ad47SJeff Kirsher vector_list[i++] = ixgbevf_mta_vector(hw, ha->addr); 343dee1ad47SJeff Kirsher } 344dee1ad47SJeff Kirsher 3453a2c4033SGreg Rose ixgbevf_write_msg_read_ack(hw, msgbuf, IXGBE_VFMAILBOX_SIZE); 346dee1ad47SJeff Kirsher 347dee1ad47SJeff Kirsher return 0; 348dee1ad47SJeff Kirsher } 349dee1ad47SJeff Kirsher 350dee1ad47SJeff Kirsher /** 351dee1ad47SJeff Kirsher * ixgbevf_set_vfta_vf - Set/Unset vlan filter table address 352dee1ad47SJeff Kirsher * @hw: pointer to the HW structure 353dee1ad47SJeff Kirsher * @vlan: 12 bit VLAN ID 354dee1ad47SJeff Kirsher * @vind: unused by VF drivers 355dee1ad47SJeff Kirsher * @vlan_on: if true then set bit, else clear bit 356dee1ad47SJeff Kirsher **/ 357dee1ad47SJeff Kirsher static s32 ixgbevf_set_vfta_vf(struct ixgbe_hw *hw, u32 vlan, u32 vind, 358dee1ad47SJeff Kirsher bool vlan_on) 359dee1ad47SJeff Kirsher { 3602ddc7fe1SAlexander Duyck struct ixgbe_mbx_info *mbx = &hw->mbx; 361dee1ad47SJeff Kirsher u32 msgbuf[2]; 3622ddc7fe1SAlexander Duyck s32 err; 363dee1ad47SJeff Kirsher 364dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_SET_VLAN; 365dee1ad47SJeff Kirsher msgbuf[1] = vlan; 366dee1ad47SJeff Kirsher /* Setting the 8 bit field MSG INFO to TRUE indicates "add" */ 367dee1ad47SJeff Kirsher msgbuf[0] |= vlan_on << IXGBE_VT_MSGINFO_SHIFT; 368dee1ad47SJeff Kirsher 3692ddc7fe1SAlexander Duyck err = mbx->ops.write_posted(hw, msgbuf, 2); 3702ddc7fe1SAlexander Duyck if (err) 3712ddc7fe1SAlexander Duyck goto mbx_err; 3723a2c4033SGreg Rose 3732ddc7fe1SAlexander Duyck err = mbx->ops.read_posted(hw, msgbuf, 2); 3742ddc7fe1SAlexander Duyck if (err) 3752ddc7fe1SAlexander Duyck goto mbx_err; 3762ddc7fe1SAlexander Duyck 3772ddc7fe1SAlexander Duyck /* remove extra bits from the message */ 3782ddc7fe1SAlexander Duyck msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 3792ddc7fe1SAlexander Duyck msgbuf[0] &= ~(0xFF << IXGBE_VT_MSGINFO_SHIFT); 3802ddc7fe1SAlexander Duyck 3812ddc7fe1SAlexander Duyck if (msgbuf[0] != (IXGBE_VF_SET_VLAN | IXGBE_VT_MSGTYPE_ACK)) 3822ddc7fe1SAlexander Duyck err = IXGBE_ERR_INVALID_ARGUMENT; 3832ddc7fe1SAlexander Duyck 3842ddc7fe1SAlexander Duyck mbx_err: 3852ddc7fe1SAlexander Duyck return err; 386dee1ad47SJeff Kirsher } 387dee1ad47SJeff Kirsher 388dee1ad47SJeff Kirsher /** 389dee1ad47SJeff Kirsher * ixgbevf_setup_mac_link_vf - Setup MAC link settings 390dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 391dee1ad47SJeff Kirsher * @speed: Unused in this implementation 392dee1ad47SJeff Kirsher * @autoneg: Unused in this implementation 393dee1ad47SJeff Kirsher * @autoneg_wait_to_complete: Unused in this implementation 394dee1ad47SJeff Kirsher * 395dee1ad47SJeff Kirsher * Do nothing and return success. VF drivers are not allowed to change 396dee1ad47SJeff Kirsher * global settings. Maintained for driver compatibility. 397dee1ad47SJeff Kirsher **/ 398dee1ad47SJeff Kirsher static s32 ixgbevf_setup_mac_link_vf(struct ixgbe_hw *hw, 399dee1ad47SJeff Kirsher ixgbe_link_speed speed, bool autoneg, 400dee1ad47SJeff Kirsher bool autoneg_wait_to_complete) 401dee1ad47SJeff Kirsher { 402dee1ad47SJeff Kirsher return 0; 403dee1ad47SJeff Kirsher } 404dee1ad47SJeff Kirsher 405dee1ad47SJeff Kirsher /** 406dee1ad47SJeff Kirsher * ixgbevf_check_mac_link_vf - Get link/speed status 407dee1ad47SJeff Kirsher * @hw: pointer to hardware structure 408dee1ad47SJeff Kirsher * @speed: pointer to link speed 409dee1ad47SJeff Kirsher * @link_up: true is link is up, false otherwise 410dee1ad47SJeff Kirsher * @autoneg_wait_to_complete: true when waiting for completion is needed 411dee1ad47SJeff Kirsher * 412dee1ad47SJeff Kirsher * Reads the links register to determine if link is up and the current speed 413dee1ad47SJeff Kirsher **/ 414dee1ad47SJeff Kirsher static s32 ixgbevf_check_mac_link_vf(struct ixgbe_hw *hw, 415dee1ad47SJeff Kirsher ixgbe_link_speed *speed, 416dee1ad47SJeff Kirsher bool *link_up, 417dee1ad47SJeff Kirsher bool autoneg_wait_to_complete) 418dee1ad47SJeff Kirsher { 4194b2cd27fSAlexander Duyck struct ixgbe_mbx_info *mbx = &hw->mbx; 4204b2cd27fSAlexander Duyck struct ixgbe_mac_info *mac = &hw->mac; 4214b2cd27fSAlexander Duyck s32 ret_val = 0; 422dee1ad47SJeff Kirsher u32 links_reg; 4234b2cd27fSAlexander Duyck u32 in_msg = 0; 424dee1ad47SJeff Kirsher 4254b2cd27fSAlexander Duyck /* If we were hit with a reset drop the link */ 4264b2cd27fSAlexander Duyck if (!mbx->ops.check_for_rst(hw) || !mbx->timeout) 4274b2cd27fSAlexander Duyck mac->get_link_status = true; 428dee1ad47SJeff Kirsher 4294b2cd27fSAlexander Duyck if (!mac->get_link_status) 4304b2cd27fSAlexander Duyck goto out; 4314b2cd27fSAlexander Duyck 4324b2cd27fSAlexander Duyck /* if link status is down no point in checking to see if pf is up */ 433dee1ad47SJeff Kirsher links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 4344b2cd27fSAlexander Duyck if (!(links_reg & IXGBE_LINKS_UP)) 4354b2cd27fSAlexander Duyck goto out; 436dee1ad47SJeff Kirsher 43731a1b375SGreg Rose switch (links_reg & IXGBE_LINKS_SPEED_82599) { 43831a1b375SGreg Rose case IXGBE_LINKS_SPEED_10G_82599: 439dee1ad47SJeff Kirsher *speed = IXGBE_LINK_SPEED_10GB_FULL; 44031a1b375SGreg Rose break; 44131a1b375SGreg Rose case IXGBE_LINKS_SPEED_1G_82599: 442dee1ad47SJeff Kirsher *speed = IXGBE_LINK_SPEED_1GB_FULL; 44331a1b375SGreg Rose break; 44431a1b375SGreg Rose case IXGBE_LINKS_SPEED_100_82599: 44531a1b375SGreg Rose *speed = IXGBE_LINK_SPEED_100_FULL; 44631a1b375SGreg Rose break; 44731a1b375SGreg Rose } 448dee1ad47SJeff Kirsher 4494b2cd27fSAlexander Duyck /* if the read failed it could just be a mailbox collision, best wait 4504b2cd27fSAlexander Duyck * until we are called again and don't report an error */ 4514b2cd27fSAlexander Duyck if (mbx->ops.read(hw, &in_msg, 1)) 4524b2cd27fSAlexander Duyck goto out; 4534b2cd27fSAlexander Duyck 4544b2cd27fSAlexander Duyck if (!(in_msg & IXGBE_VT_MSGTYPE_CTS)) { 4554b2cd27fSAlexander Duyck /* msg is not CTS and is NACK we must have lost CTS status */ 4564b2cd27fSAlexander Duyck if (in_msg & IXGBE_VT_MSGTYPE_NACK) 4574b2cd27fSAlexander Duyck ret_val = -1; 4584b2cd27fSAlexander Duyck goto out; 4594b2cd27fSAlexander Duyck } 4604b2cd27fSAlexander Duyck 4614b2cd27fSAlexander Duyck /* the pf is talking, if we timed out in the past we reinit */ 4624b2cd27fSAlexander Duyck if (!mbx->timeout) { 4634b2cd27fSAlexander Duyck ret_val = -1; 4644b2cd27fSAlexander Duyck goto out; 4654b2cd27fSAlexander Duyck } 4664b2cd27fSAlexander Duyck 4674b2cd27fSAlexander Duyck /* if we passed all the tests above then the link is up and we no 4684b2cd27fSAlexander Duyck * longer need to check for link */ 4694b2cd27fSAlexander Duyck mac->get_link_status = false; 4704b2cd27fSAlexander Duyck 4714b2cd27fSAlexander Duyck out: 4724b2cd27fSAlexander Duyck *link_up = !mac->get_link_status; 4734b2cd27fSAlexander Duyck return ret_val; 474dee1ad47SJeff Kirsher } 475dee1ad47SJeff Kirsher 476dd1fe113SAlexander Duyck /** 477dd1fe113SAlexander Duyck * ixgbevf_rlpml_set_vf - Set the maximum receive packet length 478dd1fe113SAlexander Duyck * @hw: pointer to the HW structure 479dd1fe113SAlexander Duyck * @max_size: value to assign to max frame size 480dd1fe113SAlexander Duyck **/ 481dd1fe113SAlexander Duyck void ixgbevf_rlpml_set_vf(struct ixgbe_hw *hw, u16 max_size) 482dd1fe113SAlexander Duyck { 483dd1fe113SAlexander Duyck u32 msgbuf[2]; 484dd1fe113SAlexander Duyck 485dd1fe113SAlexander Duyck msgbuf[0] = IXGBE_VF_SET_LPE; 486dd1fe113SAlexander Duyck msgbuf[1] = max_size; 487dd1fe113SAlexander Duyck ixgbevf_write_msg_read_ack(hw, msgbuf, 2); 488dd1fe113SAlexander Duyck } 489dd1fe113SAlexander Duyck 49031186785SAlexander Duyck /** 49131186785SAlexander Duyck * ixgbevf_negotiate_api_version - Negotiate supported API version 49231186785SAlexander Duyck * @hw: pointer to the HW structure 49331186785SAlexander Duyck * @api: integer containing requested API version 49431186785SAlexander Duyck **/ 49531186785SAlexander Duyck int ixgbevf_negotiate_api_version(struct ixgbe_hw *hw, int api) 49631186785SAlexander Duyck { 49731186785SAlexander Duyck int err; 49831186785SAlexander Duyck u32 msg[3]; 49931186785SAlexander Duyck 50031186785SAlexander Duyck /* Negotiate the mailbox API version */ 50131186785SAlexander Duyck msg[0] = IXGBE_VF_API_NEGOTIATE; 50231186785SAlexander Duyck msg[1] = api; 50331186785SAlexander Duyck msg[2] = 0; 50431186785SAlexander Duyck err = hw->mbx.ops.write_posted(hw, msg, 3); 50531186785SAlexander Duyck 50631186785SAlexander Duyck if (!err) 50731186785SAlexander Duyck err = hw->mbx.ops.read_posted(hw, msg, 3); 50831186785SAlexander Duyck 50931186785SAlexander Duyck if (!err) { 51031186785SAlexander Duyck msg[0] &= ~IXGBE_VT_MSGTYPE_CTS; 51131186785SAlexander Duyck 51231186785SAlexander Duyck /* Store value and return 0 on success */ 51331186785SAlexander Duyck if (msg[0] == (IXGBE_VF_API_NEGOTIATE | IXGBE_VT_MSGTYPE_ACK)) { 51431186785SAlexander Duyck hw->api_version = api; 51531186785SAlexander Duyck return 0; 51631186785SAlexander Duyck } 51731186785SAlexander Duyck 51831186785SAlexander Duyck err = IXGBE_ERR_INVALID_ARGUMENT; 51931186785SAlexander Duyck } 52031186785SAlexander Duyck 52131186785SAlexander Duyck return err; 52231186785SAlexander Duyck } 52331186785SAlexander Duyck 52456e94095SAlexander Duyck int ixgbevf_get_queues(struct ixgbe_hw *hw, unsigned int *num_tcs, 52556e94095SAlexander Duyck unsigned int *default_tc) 52656e94095SAlexander Duyck { 52756e94095SAlexander Duyck int err; 52856e94095SAlexander Duyck u32 msg[5]; 52956e94095SAlexander Duyck 53056e94095SAlexander Duyck /* do nothing if API doesn't support ixgbevf_get_queues */ 53156e94095SAlexander Duyck switch (hw->api_version) { 53256e94095SAlexander Duyck case ixgbe_mbox_api_11: 53356e94095SAlexander Duyck break; 53456e94095SAlexander Duyck default: 53556e94095SAlexander Duyck return 0; 53656e94095SAlexander Duyck } 53756e94095SAlexander Duyck 53856e94095SAlexander Duyck /* Fetch queue configuration from the PF */ 53956e94095SAlexander Duyck msg[0] = IXGBE_VF_GET_QUEUE; 54056e94095SAlexander Duyck msg[1] = msg[2] = msg[3] = msg[4] = 0; 54156e94095SAlexander Duyck err = hw->mbx.ops.write_posted(hw, msg, 5); 54256e94095SAlexander Duyck 54356e94095SAlexander Duyck if (!err) 54456e94095SAlexander Duyck err = hw->mbx.ops.read_posted(hw, msg, 5); 54556e94095SAlexander Duyck 54656e94095SAlexander Duyck if (!err) { 54756e94095SAlexander Duyck msg[0] &= ~IXGBE_VT_MSGTYPE_CTS; 54856e94095SAlexander Duyck 54956e94095SAlexander Duyck /* 55056e94095SAlexander Duyck * if we we didn't get an ACK there must have been 55156e94095SAlexander Duyck * some sort of mailbox error so we should treat it 55256e94095SAlexander Duyck * as such 55356e94095SAlexander Duyck */ 55456e94095SAlexander Duyck if (msg[0] != (IXGBE_VF_GET_QUEUE | IXGBE_VT_MSGTYPE_ACK)) 55556e94095SAlexander Duyck return IXGBE_ERR_MBX; 55656e94095SAlexander Duyck 55756e94095SAlexander Duyck /* record and validate values from message */ 55856e94095SAlexander Duyck hw->mac.max_tx_queues = msg[IXGBE_VF_TX_QUEUES]; 55956e94095SAlexander Duyck if (hw->mac.max_tx_queues == 0 || 56056e94095SAlexander Duyck hw->mac.max_tx_queues > IXGBE_VF_MAX_TX_QUEUES) 56156e94095SAlexander Duyck hw->mac.max_tx_queues = IXGBE_VF_MAX_TX_QUEUES; 56256e94095SAlexander Duyck 56356e94095SAlexander Duyck hw->mac.max_rx_queues = msg[IXGBE_VF_RX_QUEUES]; 56456e94095SAlexander Duyck if (hw->mac.max_rx_queues == 0 || 56556e94095SAlexander Duyck hw->mac.max_rx_queues > IXGBE_VF_MAX_RX_QUEUES) 56656e94095SAlexander Duyck hw->mac.max_rx_queues = IXGBE_VF_MAX_RX_QUEUES; 56756e94095SAlexander Duyck 56856e94095SAlexander Duyck *num_tcs = msg[IXGBE_VF_TRANS_VLAN]; 56956e94095SAlexander Duyck /* in case of unknown state assume we cannot tag frames */ 57056e94095SAlexander Duyck if (*num_tcs > hw->mac.max_rx_queues) 57156e94095SAlexander Duyck *num_tcs = 1; 57256e94095SAlexander Duyck 57356e94095SAlexander Duyck *default_tc = msg[IXGBE_VF_DEF_QUEUE]; 57456e94095SAlexander Duyck /* default to queue 0 on out-of-bounds queue number */ 57556e94095SAlexander Duyck if (*default_tc >= hw->mac.max_tx_queues) 57656e94095SAlexander Duyck *default_tc = 0; 57756e94095SAlexander Duyck } 57856e94095SAlexander Duyck 57956e94095SAlexander Duyck return err; 58056e94095SAlexander Duyck } 58156e94095SAlexander Duyck 5823d8fe98fSStephen Hemminger static const struct ixgbe_mac_operations ixgbevf_mac_ops = { 583dee1ad47SJeff Kirsher .init_hw = ixgbevf_init_hw_vf, 584dee1ad47SJeff Kirsher .reset_hw = ixgbevf_reset_hw_vf, 585dee1ad47SJeff Kirsher .start_hw = ixgbevf_start_hw_vf, 586dee1ad47SJeff Kirsher .get_mac_addr = ixgbevf_get_mac_addr_vf, 587dee1ad47SJeff Kirsher .stop_adapter = ixgbevf_stop_hw_vf, 588dee1ad47SJeff Kirsher .setup_link = ixgbevf_setup_mac_link_vf, 589dee1ad47SJeff Kirsher .check_link = ixgbevf_check_mac_link_vf, 590dee1ad47SJeff Kirsher .set_rar = ixgbevf_set_rar_vf, 591dee1ad47SJeff Kirsher .update_mc_addr_list = ixgbevf_update_mc_addr_list_vf, 592dee1ad47SJeff Kirsher .set_uc_addr = ixgbevf_set_uc_addr_vf, 593dee1ad47SJeff Kirsher .set_vfta = ixgbevf_set_vfta_vf, 594dee1ad47SJeff Kirsher }; 595dee1ad47SJeff Kirsher 5963d8fe98fSStephen Hemminger const struct ixgbevf_info ixgbevf_82599_vf_info = { 597dee1ad47SJeff Kirsher .mac = ixgbe_mac_82599_vf, 598dee1ad47SJeff Kirsher .mac_ops = &ixgbevf_mac_ops, 599dee1ad47SJeff Kirsher }; 600dee1ad47SJeff Kirsher 6013d8fe98fSStephen Hemminger const struct ixgbevf_info ixgbevf_X540_vf_info = { 602dee1ad47SJeff Kirsher .mac = ixgbe_mac_X540_vf, 603dee1ad47SJeff Kirsher .mac_ops = &ixgbevf_mac_ops, 604dee1ad47SJeff Kirsher }; 605