1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright(c) 2009 - 2018 Intel Corporation. */ 3 4 #include <linux/etherdevice.h> 5 6 #include "vf.h" 7 8 static s32 e1000_check_for_link_vf(struct e1000_hw *hw); 9 static s32 e1000_get_link_up_info_vf(struct e1000_hw *hw, u16 *speed, 10 u16 *duplex); 11 static s32 e1000_init_hw_vf(struct e1000_hw *hw); 12 static s32 e1000_reset_hw_vf(struct e1000_hw *hw); 13 14 static void e1000_update_mc_addr_list_vf(struct e1000_hw *hw, u8 *, 15 u32, u32, u32); 16 static void e1000_rar_set_vf(struct e1000_hw *, u8 *, u32); 17 static s32 e1000_read_mac_addr_vf(struct e1000_hw *); 18 static s32 e1000_set_uc_addr_vf(struct e1000_hw *hw, u32 subcmd, u8 *addr); 19 static s32 e1000_set_vfta_vf(struct e1000_hw *, u16, bool); 20 21 /** 22 * e1000_init_mac_params_vf - Inits MAC params 23 * @hw: pointer to the HW structure 24 **/ 25 static s32 e1000_init_mac_params_vf(struct e1000_hw *hw) 26 { 27 struct e1000_mac_info *mac = &hw->mac; 28 29 /* VF's have no MTA Registers - PF feature only */ 30 mac->mta_reg_count = 128; 31 /* VF's have no access to RAR entries */ 32 mac->rar_entry_count = 1; 33 34 /* Function pointers */ 35 /* reset */ 36 mac->ops.reset_hw = e1000_reset_hw_vf; 37 /* hw initialization */ 38 mac->ops.init_hw = e1000_init_hw_vf; 39 /* check for link */ 40 mac->ops.check_for_link = e1000_check_for_link_vf; 41 /* link info */ 42 mac->ops.get_link_up_info = e1000_get_link_up_info_vf; 43 /* multicast address update */ 44 mac->ops.update_mc_addr_list = e1000_update_mc_addr_list_vf; 45 /* set mac address */ 46 mac->ops.rar_set = e1000_rar_set_vf; 47 /* read mac address */ 48 mac->ops.read_mac_addr = e1000_read_mac_addr_vf; 49 /* set mac filter */ 50 mac->ops.set_uc_addr = e1000_set_uc_addr_vf; 51 /* set vlan filter table array */ 52 mac->ops.set_vfta = e1000_set_vfta_vf; 53 54 return E1000_SUCCESS; 55 } 56 57 /** 58 * e1000_init_function_pointers_vf - Inits function pointers 59 * @hw: pointer to the HW structure 60 **/ 61 void e1000_init_function_pointers_vf(struct e1000_hw *hw) 62 { 63 hw->mac.ops.init_params = e1000_init_mac_params_vf; 64 hw->mbx.ops.init_params = e1000_init_mbx_params_vf; 65 } 66 67 /** 68 * e1000_get_link_up_info_vf - Gets link info. 69 * @hw: pointer to the HW structure 70 * @speed: pointer to 16 bit value to store link speed. 71 * @duplex: pointer to 16 bit value to store duplex. 72 * 73 * Since we cannot read the PHY and get accurate link info, we must rely upon 74 * the status register's data which is often stale and inaccurate. 75 **/ 76 static s32 e1000_get_link_up_info_vf(struct e1000_hw *hw, u16 *speed, 77 u16 *duplex) 78 { 79 s32 status; 80 81 status = er32(STATUS); 82 if (status & E1000_STATUS_SPEED_1000) 83 *speed = SPEED_1000; 84 else if (status & E1000_STATUS_SPEED_100) 85 *speed = SPEED_100; 86 else 87 *speed = SPEED_10; 88 89 if (status & E1000_STATUS_FD) 90 *duplex = FULL_DUPLEX; 91 else 92 *duplex = HALF_DUPLEX; 93 94 return E1000_SUCCESS; 95 } 96 97 /** 98 * e1000_reset_hw_vf - Resets the HW 99 * @hw: pointer to the HW structure 100 * 101 * VF's provide a function level reset. This is done using bit 26 of ctrl_reg. 102 * This is all the reset we can perform on a VF. 103 **/ 104 static s32 e1000_reset_hw_vf(struct e1000_hw *hw) 105 { 106 struct e1000_mbx_info *mbx = &hw->mbx; 107 u32 timeout = E1000_VF_INIT_TIMEOUT; 108 u32 ret_val = -E1000_ERR_MAC_INIT; 109 u32 msgbuf[3]; 110 u8 *addr = (u8 *)(&msgbuf[1]); 111 u32 ctrl; 112 113 /* assert VF queue/interrupt reset */ 114 ctrl = er32(CTRL); 115 ew32(CTRL, ctrl | E1000_CTRL_RST); 116 117 /* we cannot initialize while the RSTI / RSTD bits are asserted */ 118 while (!mbx->ops.check_for_rst(hw) && timeout) { 119 timeout--; 120 udelay(5); 121 } 122 123 if (timeout) { 124 /* mailbox timeout can now become active */ 125 mbx->timeout = E1000_VF_MBX_INIT_TIMEOUT; 126 127 /* notify PF of VF reset completion */ 128 msgbuf[0] = E1000_VF_RESET; 129 mbx->ops.write_posted(hw, msgbuf, 1); 130 131 mdelay(10); 132 133 /* set our "perm_addr" based on info provided by PF */ 134 ret_val = mbx->ops.read_posted(hw, msgbuf, 3); 135 if (!ret_val) { 136 switch (msgbuf[0]) { 137 case E1000_VF_RESET | E1000_VT_MSGTYPE_ACK: 138 memcpy(hw->mac.perm_addr, addr, ETH_ALEN); 139 break; 140 case E1000_VF_RESET | E1000_VT_MSGTYPE_NACK: 141 eth_zero_addr(hw->mac.perm_addr); 142 break; 143 default: 144 ret_val = -E1000_ERR_MAC_INIT; 145 } 146 } 147 } 148 149 return ret_val; 150 } 151 152 /** 153 * e1000_init_hw_vf - Inits the HW 154 * @hw: pointer to the HW structure 155 * 156 * Not much to do here except clear the PF Reset indication if there is one. 157 **/ 158 static s32 e1000_init_hw_vf(struct e1000_hw *hw) 159 { 160 /* attempt to set and restore our mac address */ 161 e1000_rar_set_vf(hw, hw->mac.addr, 0); 162 163 return E1000_SUCCESS; 164 } 165 166 /** 167 * e1000_hash_mc_addr_vf - Generate a multicast hash value 168 * @hw: pointer to the HW structure 169 * @mc_addr: pointer to a multicast address 170 * 171 * Generates a multicast address hash value which is used to determine 172 * the multicast filter table array address and new table value. See 173 * e1000_mta_set_generic() 174 **/ 175 static u32 e1000_hash_mc_addr_vf(struct e1000_hw *hw, u8 *mc_addr) 176 { 177 u32 hash_value, hash_mask; 178 u8 bit_shift = 0; 179 180 /* Register count multiplied by bits per register */ 181 hash_mask = (hw->mac.mta_reg_count * 32) - 1; 182 183 /* The bit_shift is the number of left-shifts 184 * where 0xFF would still fall within the hash mask. 185 */ 186 while (hash_mask >> bit_shift != 0xFF) 187 bit_shift++; 188 189 hash_value = hash_mask & (((mc_addr[4] >> (8 - bit_shift)) | 190 (((u16)mc_addr[5]) << bit_shift))); 191 192 return hash_value; 193 } 194 195 /** 196 * e1000_update_mc_addr_list_vf - Update Multicast addresses 197 * @hw: pointer to the HW structure 198 * @mc_addr_list: array of multicast addresses to program 199 * @mc_addr_count: number of multicast addresses to program 200 * @rar_used_count: the first RAR register free to program 201 * @rar_count: total number of supported Receive Address Registers 202 * 203 * Updates the Receive Address Registers and Multicast Table Array. 204 * The caller must have a packed mc_addr_list of multicast addresses. 205 * The parameter rar_count will usually be hw->mac.rar_entry_count 206 * unless there are workarounds that change this. 207 **/ 208 static void e1000_update_mc_addr_list_vf(struct e1000_hw *hw, 209 u8 *mc_addr_list, u32 mc_addr_count, 210 u32 rar_used_count, u32 rar_count) 211 { 212 struct e1000_mbx_info *mbx = &hw->mbx; 213 u32 msgbuf[E1000_VFMAILBOX_SIZE]; 214 u16 *hash_list = (u16 *)&msgbuf[1]; 215 u32 hash_value; 216 u32 cnt, i; 217 s32 ret_val; 218 219 /* Each entry in the list uses 1 16 bit word. We have 30 220 * 16 bit words available in our HW msg buffer (minus 1 for the 221 * msg type). That's 30 hash values if we pack 'em right. If 222 * there are more than 30 MC addresses to add then punt the 223 * extras for now and then add code to handle more than 30 later. 224 * It would be unusual for a server to request that many multi-cast 225 * addresses except for in large enterprise network environments. 226 */ 227 228 cnt = (mc_addr_count > 30) ? 30 : mc_addr_count; 229 msgbuf[0] = E1000_VF_SET_MULTICAST; 230 msgbuf[0] |= cnt << E1000_VT_MSGINFO_SHIFT; 231 232 for (i = 0; i < cnt; i++) { 233 hash_value = e1000_hash_mc_addr_vf(hw, mc_addr_list); 234 hash_list[i] = hash_value & 0x0FFFF; 235 mc_addr_list += ETH_ALEN; 236 } 237 238 ret_val = mbx->ops.write_posted(hw, msgbuf, E1000_VFMAILBOX_SIZE); 239 if (!ret_val) 240 mbx->ops.read_posted(hw, msgbuf, 1); 241 } 242 243 /** 244 * e1000_set_vfta_vf - Set/Unset vlan filter table address 245 * @hw: pointer to the HW structure 246 * @vid: determines the vfta register and bit to set/unset 247 * @set: if true then set bit, else clear bit 248 **/ 249 static s32 e1000_set_vfta_vf(struct e1000_hw *hw, u16 vid, bool set) 250 { 251 struct e1000_mbx_info *mbx = &hw->mbx; 252 u32 msgbuf[2]; 253 s32 err; 254 255 msgbuf[0] = E1000_VF_SET_VLAN; 256 msgbuf[1] = vid; 257 /* Setting the 8 bit field MSG INFO to true indicates "add" */ 258 if (set) 259 msgbuf[0] |= BIT(E1000_VT_MSGINFO_SHIFT); 260 261 mbx->ops.write_posted(hw, msgbuf, 2); 262 263 err = mbx->ops.read_posted(hw, msgbuf, 2); 264 265 msgbuf[0] &= ~E1000_VT_MSGTYPE_CTS; 266 267 /* if nacked the vlan was rejected */ 268 if (!err && (msgbuf[0] == (E1000_VF_SET_VLAN | E1000_VT_MSGTYPE_NACK))) 269 err = -E1000_ERR_MAC_INIT; 270 271 return err; 272 } 273 274 /** 275 * e1000_rlpml_set_vf - Set the maximum receive packet length 276 * @hw: pointer to the HW structure 277 * @max_size: value to assign to max frame size 278 **/ 279 void e1000_rlpml_set_vf(struct e1000_hw *hw, u16 max_size) 280 { 281 struct e1000_mbx_info *mbx = &hw->mbx; 282 u32 msgbuf[2]; 283 s32 ret_val; 284 285 msgbuf[0] = E1000_VF_SET_LPE; 286 msgbuf[1] = max_size; 287 288 ret_val = mbx->ops.write_posted(hw, msgbuf, 2); 289 if (!ret_val) 290 mbx->ops.read_posted(hw, msgbuf, 1); 291 } 292 293 /** 294 * e1000_rar_set_vf - set device MAC address 295 * @hw: pointer to the HW structure 296 * @addr: pointer to the receive address 297 * @index: receive address array register 298 **/ 299 static void e1000_rar_set_vf(struct e1000_hw *hw, u8 *addr, u32 index) 300 { 301 struct e1000_mbx_info *mbx = &hw->mbx; 302 u32 msgbuf[3]; 303 u8 *msg_addr = (u8 *)(&msgbuf[1]); 304 s32 ret_val; 305 306 memset(msgbuf, 0, 12); 307 msgbuf[0] = E1000_VF_SET_MAC_ADDR; 308 memcpy(msg_addr, addr, ETH_ALEN); 309 ret_val = mbx->ops.write_posted(hw, msgbuf, 3); 310 311 if (!ret_val) 312 ret_val = mbx->ops.read_posted(hw, msgbuf, 3); 313 314 msgbuf[0] &= ~E1000_VT_MSGTYPE_CTS; 315 316 /* if nacked the address was rejected, use "perm_addr" */ 317 if (!ret_val && 318 (msgbuf[0] == (E1000_VF_SET_MAC_ADDR | E1000_VT_MSGTYPE_NACK))) 319 e1000_read_mac_addr_vf(hw); 320 } 321 322 /** 323 * e1000_read_mac_addr_vf - Read device MAC address 324 * @hw: pointer to the HW structure 325 **/ 326 static s32 e1000_read_mac_addr_vf(struct e1000_hw *hw) 327 { 328 memcpy(hw->mac.addr, hw->mac.perm_addr, ETH_ALEN); 329 330 return E1000_SUCCESS; 331 } 332 333 /** 334 * e1000_set_uc_addr_vf - Set or clear unicast filters 335 * @hw: pointer to the HW structure 336 * @sub_cmd: add or clear filters 337 * @addr: pointer to the filter MAC address 338 **/ 339 static s32 e1000_set_uc_addr_vf(struct e1000_hw *hw, u32 sub_cmd, u8 *addr) 340 { 341 struct e1000_mbx_info *mbx = &hw->mbx; 342 u32 msgbuf[3], msgbuf_chk; 343 u8 *msg_addr = (u8 *)(&msgbuf[1]); 344 s32 ret_val; 345 346 memset(msgbuf, 0, sizeof(msgbuf)); 347 msgbuf[0] |= sub_cmd; 348 msgbuf[0] |= E1000_VF_SET_MAC_ADDR; 349 msgbuf_chk = msgbuf[0]; 350 351 if (addr) 352 memcpy(msg_addr, addr, ETH_ALEN); 353 354 ret_val = mbx->ops.write_posted(hw, msgbuf, 3); 355 356 if (!ret_val) 357 ret_val = mbx->ops.read_posted(hw, msgbuf, 3); 358 359 msgbuf[0] &= ~E1000_VT_MSGTYPE_CTS; 360 361 if (!ret_val) { 362 msgbuf[0] &= ~E1000_VT_MSGTYPE_CTS; 363 364 if (msgbuf[0] == (msgbuf_chk | E1000_VT_MSGTYPE_NACK)) 365 return -ENOSPC; 366 } 367 368 return ret_val; 369 } 370 371 /** 372 * e1000_check_for_link_vf - Check for link for a virtual interface 373 * @hw: pointer to the HW structure 374 * 375 * Checks to see if the underlying PF is still talking to the VF and 376 * if it is then it reports the link state to the hardware, otherwise 377 * it reports link down and returns an error. 378 **/ 379 static s32 e1000_check_for_link_vf(struct e1000_hw *hw) 380 { 381 struct e1000_mbx_info *mbx = &hw->mbx; 382 struct e1000_mac_info *mac = &hw->mac; 383 s32 ret_val = E1000_SUCCESS; 384 u32 in_msg = 0; 385 386 /* We only want to run this if there has been a rst asserted. 387 * in this case that could mean a link change, device reset, 388 * or a virtual function reset 389 */ 390 391 /* If we were hit with a reset or timeout drop the link */ 392 if (!mbx->ops.check_for_rst(hw) || !mbx->timeout) 393 mac->get_link_status = true; 394 395 if (!mac->get_link_status) 396 goto out; 397 398 /* if link status is down no point in checking to see if PF is up */ 399 if (!(er32(STATUS) & E1000_STATUS_LU)) 400 goto out; 401 402 /* if the read failed it could just be a mailbox collision, best wait 403 * until we are called again and don't report an error 404 */ 405 if (mbx->ops.read(hw, &in_msg, 1)) 406 goto out; 407 408 /* if incoming message isn't clear to send we are waiting on response */ 409 if (!(in_msg & E1000_VT_MSGTYPE_CTS)) { 410 /* msg is not CTS and is NACK we must have lost CTS status */ 411 if (in_msg & E1000_VT_MSGTYPE_NACK) 412 ret_val = -E1000_ERR_MAC_INIT; 413 goto out; 414 } 415 416 /* the PF is talking, if we timed out in the past we reinit */ 417 if (!mbx->timeout) { 418 ret_val = -E1000_ERR_MAC_INIT; 419 goto out; 420 } 421 422 /* if we passed all the tests above then the link is up and we no 423 * longer need to check for link 424 */ 425 mac->get_link_status = false; 426 427 out: 428 return ret_val; 429 } 430 431