1 /****************************************************************************** 2 SPDX-License-Identifier: BSD-3-Clause 3 4 Copyright (c) 2001-2015, Intel Corporation 5 All rights reserved. 6 7 Redistribution and use in source and binary forms, with or without 8 modification, are permitted provided that the following conditions are met: 9 10 1. Redistributions of source code must retain the above copyright notice, 11 this list of conditions and the following disclaimer. 12 13 2. Redistributions in binary form must reproduce the above copyright 14 notice, this list of conditions and the following disclaimer in the 15 documentation and/or other materials provided with the distribution. 16 17 3. Neither the name of the Intel Corporation nor the names of its 18 contributors may be used to endorse or promote products derived from 19 this software without specific prior written permission. 20 21 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 22 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 25 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 26 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 27 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 30 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 31 POSSIBILITY OF SUCH DAMAGE. 32 33 ******************************************************************************/ 34 /*$FreeBSD$*/ 35 36 37 #include "e1000_api.h" 38 39 40 static s32 e1000_init_phy_params_vf(struct e1000_hw *hw); 41 static s32 e1000_init_nvm_params_vf(struct e1000_hw *hw); 42 static void e1000_release_vf(struct e1000_hw *hw); 43 static s32 e1000_acquire_vf(struct e1000_hw *hw); 44 static s32 e1000_setup_link_vf(struct e1000_hw *hw); 45 static s32 e1000_get_bus_info_pcie_vf(struct e1000_hw *hw); 46 static s32 e1000_init_mac_params_vf(struct e1000_hw *hw); 47 static s32 e1000_check_for_link_vf(struct e1000_hw *hw); 48 static s32 e1000_get_link_up_info_vf(struct e1000_hw *hw, u16 *speed, 49 u16 *duplex); 50 static s32 e1000_init_hw_vf(struct e1000_hw *hw); 51 static s32 e1000_reset_hw_vf(struct e1000_hw *hw); 52 static void e1000_update_mc_addr_list_vf(struct e1000_hw *hw, u8 *, u32); 53 static int e1000_rar_set_vf(struct e1000_hw *, u8 *, u32); 54 static s32 e1000_read_mac_addr_vf(struct e1000_hw *); 55 56 /** 57 * e1000_init_phy_params_vf - Inits PHY params 58 * @hw: pointer to the HW structure 59 * 60 * Doesn't do much - there's no PHY available to the VF. 61 **/ 62 static s32 e1000_init_phy_params_vf(struct e1000_hw *hw) 63 { 64 DEBUGFUNC("e1000_init_phy_params_vf"); 65 hw->phy.type = e1000_phy_vf; 66 hw->phy.ops.acquire = e1000_acquire_vf; 67 hw->phy.ops.release = e1000_release_vf; 68 69 return E1000_SUCCESS; 70 } 71 72 /** 73 * e1000_init_nvm_params_vf - Inits NVM params 74 * @hw: pointer to the HW structure 75 * 76 * Doesn't do much - there's no NVM available to the VF. 77 **/ 78 static s32 e1000_init_nvm_params_vf(struct e1000_hw *hw) 79 { 80 DEBUGFUNC("e1000_init_nvm_params_vf"); 81 hw->nvm.type = e1000_nvm_none; 82 hw->nvm.ops.acquire = e1000_acquire_vf; 83 hw->nvm.ops.release = e1000_release_vf; 84 85 return E1000_SUCCESS; 86 } 87 88 /** 89 * e1000_init_mac_params_vf - Inits MAC params 90 * @hw: pointer to the HW structure 91 **/ 92 static s32 e1000_init_mac_params_vf(struct e1000_hw *hw) 93 { 94 struct e1000_mac_info *mac = &hw->mac; 95 96 DEBUGFUNC("e1000_init_mac_params_vf"); 97 98 /* Set media type */ 99 /* 100 * Virtual functions don't care what they're media type is as they 101 * have no direct access to the PHY, or the media. That is handled 102 * by the physical function driver. 103 */ 104 hw->phy.media_type = e1000_media_type_unknown; 105 106 /* No ASF features for the VF driver */ 107 mac->asf_firmware_present = FALSE; 108 /* ARC subsystem not supported */ 109 mac->arc_subsystem_valid = FALSE; 110 /* Disable adaptive IFS mode so the generic funcs don't do anything */ 111 mac->adaptive_ifs = FALSE; 112 /* VF's have no MTA Registers - PF feature only */ 113 mac->mta_reg_count = 128; 114 /* VF's have no access to RAR entries */ 115 mac->rar_entry_count = 1; 116 117 /* Function pointers */ 118 /* link setup */ 119 mac->ops.setup_link = e1000_setup_link_vf; 120 /* bus type/speed/width */ 121 mac->ops.get_bus_info = e1000_get_bus_info_pcie_vf; 122 /* reset */ 123 mac->ops.reset_hw = e1000_reset_hw_vf; 124 /* hw initialization */ 125 mac->ops.init_hw = e1000_init_hw_vf; 126 /* check for link */ 127 mac->ops.check_for_link = e1000_check_for_link_vf; 128 /* link info */ 129 mac->ops.get_link_up_info = e1000_get_link_up_info_vf; 130 /* multicast address update */ 131 mac->ops.update_mc_addr_list = e1000_update_mc_addr_list_vf; 132 /* set mac address */ 133 mac->ops.rar_set = e1000_rar_set_vf; 134 /* read mac address */ 135 mac->ops.read_mac_addr = e1000_read_mac_addr_vf; 136 137 138 return E1000_SUCCESS; 139 } 140 141 /** 142 * e1000_init_function_pointers_vf - Inits function pointers 143 * @hw: pointer to the HW structure 144 **/ 145 void e1000_init_function_pointers_vf(struct e1000_hw *hw) 146 { 147 DEBUGFUNC("e1000_init_function_pointers_vf"); 148 149 hw->mac.ops.init_params = e1000_init_mac_params_vf; 150 hw->nvm.ops.init_params = e1000_init_nvm_params_vf; 151 hw->phy.ops.init_params = e1000_init_phy_params_vf; 152 hw->mbx.ops.init_params = e1000_init_mbx_params_vf; 153 } 154 155 /** 156 * e1000_acquire_vf - Acquire rights to access PHY or NVM. 157 * @hw: pointer to the HW structure 158 * 159 * There is no PHY or NVM so we want all attempts to acquire these to fail. 160 * In addition, the MAC registers to access PHY/NVM don't exist so we don't 161 * even want any SW to attempt to use them. 162 **/ 163 static s32 e1000_acquire_vf(struct e1000_hw E1000_UNUSEDARG *hw) 164 { 165 return -E1000_ERR_PHY; 166 } 167 168 /** 169 * e1000_release_vf - Release PHY or NVM 170 * @hw: pointer to the HW structure 171 * 172 * There is no PHY or NVM so we want all attempts to acquire these to fail. 173 * In addition, the MAC registers to access PHY/NVM don't exist so we don't 174 * even want any SW to attempt to use them. 175 **/ 176 static void e1000_release_vf(struct e1000_hw E1000_UNUSEDARG *hw) 177 { 178 return; 179 } 180 181 /** 182 * e1000_setup_link_vf - Sets up link. 183 * @hw: pointer to the HW structure 184 * 185 * Virtual functions cannot change link. 186 **/ 187 static s32 e1000_setup_link_vf(struct e1000_hw E1000_UNUSEDARG *hw) 188 { 189 DEBUGFUNC("e1000_setup_link_vf"); 190 191 return E1000_SUCCESS; 192 } 193 194 /** 195 * e1000_get_bus_info_pcie_vf - Gets the bus info. 196 * @hw: pointer to the HW structure 197 * 198 * Virtual functions are not really on their own bus. 199 **/ 200 static s32 e1000_get_bus_info_pcie_vf(struct e1000_hw *hw) 201 { 202 struct e1000_bus_info *bus = &hw->bus; 203 204 DEBUGFUNC("e1000_get_bus_info_pcie_vf"); 205 206 /* Do not set type PCI-E because we don't want disable master to run */ 207 bus->type = e1000_bus_type_reserved; 208 bus->speed = e1000_bus_speed_2500; 209 210 return 0; 211 } 212 213 /** 214 * e1000_get_link_up_info_vf - Gets link info. 215 * @hw: pointer to the HW structure 216 * @speed: pointer to 16 bit value to store link speed. 217 * @duplex: pointer to 16 bit value to store duplex. 218 * 219 * Since we cannot read the PHY and get accurate link info, we must rely upon 220 * the status register's data which is often stale and inaccurate. 221 **/ 222 static s32 e1000_get_link_up_info_vf(struct e1000_hw *hw, u16 *speed, 223 u16 *duplex) 224 { 225 s32 status; 226 227 DEBUGFUNC("e1000_get_link_up_info_vf"); 228 229 status = E1000_READ_REG(hw, E1000_STATUS); 230 if (status & E1000_STATUS_SPEED_1000) { 231 *speed = SPEED_1000; 232 DEBUGOUT("1000 Mbs, "); 233 } else if (status & E1000_STATUS_SPEED_100) { 234 *speed = SPEED_100; 235 DEBUGOUT("100 Mbs, "); 236 } else { 237 *speed = SPEED_10; 238 DEBUGOUT("10 Mbs, "); 239 } 240 241 if (status & E1000_STATUS_FD) { 242 *duplex = FULL_DUPLEX; 243 DEBUGOUT("Full Duplex\n"); 244 } else { 245 *duplex = HALF_DUPLEX; 246 DEBUGOUT("Half Duplex\n"); 247 } 248 249 return E1000_SUCCESS; 250 } 251 252 /** 253 * e1000_reset_hw_vf - Resets the HW 254 * @hw: pointer to the HW structure 255 * 256 * VF's provide a function level reset. This is done using bit 26 of ctrl_reg. 257 * This is all the reset we can perform on a VF. 258 **/ 259 static s32 e1000_reset_hw_vf(struct e1000_hw *hw) 260 { 261 struct e1000_mbx_info *mbx = &hw->mbx; 262 u32 timeout = E1000_VF_INIT_TIMEOUT; 263 s32 ret_val = -E1000_ERR_MAC_INIT; 264 u32 ctrl, msgbuf[3]; 265 u8 *addr = (u8 *)(&msgbuf[1]); 266 267 DEBUGFUNC("e1000_reset_hw_vf"); 268 269 DEBUGOUT("Issuing a function level reset to MAC\n"); 270 ctrl = E1000_READ_REG(hw, E1000_CTRL); 271 E1000_WRITE_REG(hw, E1000_CTRL, ctrl | E1000_CTRL_RST); 272 273 /* we cannot reset while the RSTI / RSTD bits are asserted */ 274 while (!mbx->ops.check_for_rst(hw, 0) && timeout) { 275 timeout--; 276 usec_delay(5); 277 } 278 279 if (timeout) { 280 /* mailbox timeout can now become active */ 281 mbx->timeout = E1000_VF_MBX_INIT_TIMEOUT; 282 283 msgbuf[0] = E1000_VF_RESET; 284 mbx->ops.write_posted(hw, msgbuf, 1, 0); 285 286 msec_delay(10); 287 288 /* set our "perm_addr" based on info provided by PF */ 289 ret_val = mbx->ops.read_posted(hw, msgbuf, 3, 0); 290 if (!ret_val) { 291 if (msgbuf[0] == (E1000_VF_RESET | 292 E1000_VT_MSGTYPE_ACK)) 293 memcpy(hw->mac.perm_addr, addr, 6); 294 else 295 ret_val = -E1000_ERR_MAC_INIT; 296 } 297 } 298 299 return ret_val; 300 } 301 302 /** 303 * e1000_init_hw_vf - Inits the HW 304 * @hw: pointer to the HW structure 305 * 306 * Not much to do here except clear the PF Reset indication if there is one. 307 **/ 308 static s32 e1000_init_hw_vf(struct e1000_hw *hw) 309 { 310 DEBUGFUNC("e1000_init_hw_vf"); 311 312 /* attempt to set and restore our mac address */ 313 e1000_rar_set_vf(hw, hw->mac.addr, 0); 314 315 return E1000_SUCCESS; 316 } 317 318 /** 319 * e1000_rar_set_vf - set device MAC address 320 * @hw: pointer to the HW structure 321 * @addr: pointer to the receive address 322 * @index receive address array register 323 **/ 324 static int e1000_rar_set_vf(struct e1000_hw *hw, u8 *addr, 325 u32 E1000_UNUSEDARG index) 326 { 327 struct e1000_mbx_info *mbx = &hw->mbx; 328 u32 msgbuf[3]; 329 u8 *msg_addr = (u8 *)(&msgbuf[1]); 330 s32 ret_val; 331 332 memset(msgbuf, 0, 12); 333 msgbuf[0] = E1000_VF_SET_MAC_ADDR; 334 memcpy(msg_addr, addr, 6); 335 ret_val = mbx->ops.write_posted(hw, msgbuf, 3, 0); 336 337 if (!ret_val) 338 ret_val = mbx->ops.read_posted(hw, msgbuf, 3, 0); 339 340 msgbuf[0] &= ~E1000_VT_MSGTYPE_CTS; 341 342 /* if nacked the address was rejected, use "perm_addr" */ 343 if (!ret_val && 344 (msgbuf[0] == (E1000_VF_SET_MAC_ADDR | E1000_VT_MSGTYPE_NACK))) 345 e1000_read_mac_addr_vf(hw); 346 347 return E1000_SUCCESS; 348 } 349 350 /** 351 * e1000_hash_mc_addr_vf - Generate a multicast hash value 352 * @hw: pointer to the HW structure 353 * @mc_addr: pointer to a multicast address 354 * 355 * Generates a multicast address hash value which is used to determine 356 * the multicast filter table array address and new table value. 357 **/ 358 static u32 e1000_hash_mc_addr_vf(struct e1000_hw *hw, u8 *mc_addr) 359 { 360 u32 hash_value, hash_mask; 361 u8 bit_shift = 0; 362 363 DEBUGFUNC("e1000_hash_mc_addr_generic"); 364 365 /* Register count multiplied by bits per register */ 366 hash_mask = (hw->mac.mta_reg_count * 32) - 1; 367 368 /* 369 * The bit_shift is the number of left-shifts 370 * where 0xFF would still fall within the hash mask. 371 */ 372 while (hash_mask >> bit_shift != 0xFF) 373 bit_shift++; 374 375 hash_value = hash_mask & (((mc_addr[4] >> (8 - bit_shift)) | 376 (((u16) mc_addr[5]) << bit_shift))); 377 378 return hash_value; 379 } 380 381 static void e1000_write_msg_read_ack(struct e1000_hw *hw, 382 u32 *msg, u16 size) 383 { 384 struct e1000_mbx_info *mbx = &hw->mbx; 385 u32 retmsg[E1000_VFMAILBOX_SIZE]; 386 s32 retval = mbx->ops.write_posted(hw, msg, size, 0); 387 388 if (!retval) 389 mbx->ops.read_posted(hw, retmsg, E1000_VFMAILBOX_SIZE, 0); 390 } 391 392 /** 393 * e1000_update_mc_addr_list_vf - Update Multicast addresses 394 * @hw: pointer to the HW structure 395 * @mc_addr_list: array of multicast addresses to program 396 * @mc_addr_count: number of multicast addresses to program 397 * 398 * Updates the Multicast Table Array. 399 * The caller must have a packed mc_addr_list of multicast addresses. 400 **/ 401 void e1000_update_mc_addr_list_vf(struct e1000_hw *hw, 402 u8 *mc_addr_list, u32 mc_addr_count) 403 { 404 u32 msgbuf[E1000_VFMAILBOX_SIZE]; 405 u16 *hash_list = (u16 *)&msgbuf[1]; 406 u32 hash_value; 407 u32 i; 408 409 DEBUGFUNC("e1000_update_mc_addr_list_vf"); 410 411 /* Each entry in the list uses 1 16 bit word. We have 30 412 * 16 bit words available in our HW msg buffer (minus 1 for the 413 * msg type). That's 30 hash values if we pack 'em right. If 414 * there are more than 30 MC addresses to add then punt the 415 * extras for now and then add code to handle more than 30 later. 416 * It would be unusual for a server to request that many multi-cast 417 * addresses except for in large enterprise network environments. 418 */ 419 420 DEBUGOUT1("MC Addr Count = %d\n", mc_addr_count); 421 422 if (mc_addr_count > 30) { 423 msgbuf[0] |= E1000_VF_SET_MULTICAST_OVERFLOW; 424 mc_addr_count = 30; 425 } 426 427 msgbuf[0] = E1000_VF_SET_MULTICAST; 428 msgbuf[0] |= mc_addr_count << E1000_VT_MSGINFO_SHIFT; 429 430 for (i = 0; i < mc_addr_count; i++) { 431 hash_value = e1000_hash_mc_addr_vf(hw, mc_addr_list); 432 DEBUGOUT1("Hash value = 0x%03X\n", hash_value); 433 hash_list[i] = hash_value & 0x0FFF; 434 mc_addr_list += ETH_ADDR_LEN; 435 } 436 437 e1000_write_msg_read_ack(hw, msgbuf, E1000_VFMAILBOX_SIZE); 438 } 439 440 /** 441 * e1000_vfta_set_vf - Set/Unset vlan filter table address 442 * @hw: pointer to the HW structure 443 * @vid: determines the vfta register and bit to set/unset 444 * @set: if TRUE then set bit, else clear bit 445 **/ 446 void e1000_vfta_set_vf(struct e1000_hw *hw, u16 vid, bool set) 447 { 448 u32 msgbuf[2]; 449 450 msgbuf[0] = E1000_VF_SET_VLAN; 451 msgbuf[1] = vid; 452 /* Setting the 8 bit field MSG INFO to TRUE indicates "add" */ 453 if (set) 454 msgbuf[0] |= E1000_VF_SET_VLAN_ADD; 455 456 e1000_write_msg_read_ack(hw, msgbuf, 2); 457 } 458 459 /** e1000_rlpml_set_vf - Set the maximum receive packet length 460 * @hw: pointer to the HW structure 461 * @max_size: value to assign to max frame size 462 **/ 463 void e1000_rlpml_set_vf(struct e1000_hw *hw, u16 max_size) 464 { 465 u32 msgbuf[2]; 466 467 msgbuf[0] = E1000_VF_SET_LPE; 468 msgbuf[1] = max_size; 469 470 e1000_write_msg_read_ack(hw, msgbuf, 2); 471 } 472 473 /** 474 * e1000_promisc_set_vf - Set flags for Unicast or Multicast promisc 475 * @hw: pointer to the HW structure 476 * @uni: boolean indicating unicast promisc status 477 * @multi: boolean indicating multicast promisc status 478 **/ 479 s32 e1000_promisc_set_vf(struct e1000_hw *hw, enum e1000_promisc_type type) 480 { 481 struct e1000_mbx_info *mbx = &hw->mbx; 482 u32 msgbuf = E1000_VF_SET_PROMISC; 483 s32 ret_val; 484 485 switch (type) { 486 case e1000_promisc_multicast: 487 msgbuf |= E1000_VF_SET_PROMISC_MULTICAST; 488 break; 489 case e1000_promisc_enabled: 490 msgbuf |= E1000_VF_SET_PROMISC_MULTICAST; 491 case e1000_promisc_unicast: 492 msgbuf |= E1000_VF_SET_PROMISC_UNICAST; 493 case e1000_promisc_disabled: 494 break; 495 default: 496 return -E1000_ERR_MAC_INIT; 497 } 498 499 ret_val = mbx->ops.write_posted(hw, &msgbuf, 1, 0); 500 501 if (!ret_val) 502 ret_val = mbx->ops.read_posted(hw, &msgbuf, 1, 0); 503 504 if (!ret_val && !(msgbuf & E1000_VT_MSGTYPE_ACK)) 505 ret_val = -E1000_ERR_MAC_INIT; 506 507 return ret_val; 508 } 509 510 /** 511 * e1000_read_mac_addr_vf - Read device MAC address 512 * @hw: pointer to the HW structure 513 **/ 514 static s32 e1000_read_mac_addr_vf(struct e1000_hw *hw) 515 { 516 int i; 517 518 for (i = 0; i < ETH_ADDR_LEN; i++) 519 hw->mac.addr[i] = hw->mac.perm_addr[i]; 520 521 return E1000_SUCCESS; 522 } 523 524 /** 525 * e1000_check_for_link_vf - Check for link for a virtual interface 526 * @hw: pointer to the HW structure 527 * 528 * Checks to see if the underlying PF is still talking to the VF and 529 * if it is then it reports the link state to the hardware, otherwise 530 * it reports link down and returns an error. 531 **/ 532 static s32 e1000_check_for_link_vf(struct e1000_hw *hw) 533 { 534 struct e1000_mbx_info *mbx = &hw->mbx; 535 struct e1000_mac_info *mac = &hw->mac; 536 s32 ret_val = E1000_SUCCESS; 537 u32 in_msg = 0; 538 539 DEBUGFUNC("e1000_check_for_link_vf"); 540 541 /* 542 * We only want to run this if there has been a rst asserted. 543 * in this case that could mean a link change, device reset, 544 * or a virtual function reset 545 */ 546 547 /* If we were hit with a reset or timeout drop the link */ 548 if (!mbx->ops.check_for_rst(hw, 0) || !mbx->timeout) 549 mac->get_link_status = TRUE; 550 551 if (!mac->get_link_status) 552 goto out; 553 554 /* if link status is down no point in checking to see if pf is up */ 555 if (!(E1000_READ_REG(hw, E1000_STATUS) & E1000_STATUS_LU)) 556 goto out; 557 558 /* if the read failed it could just be a mailbox collision, best wait 559 * until we are called again and don't report an error */ 560 if (mbx->ops.read(hw, &in_msg, 1, 0)) 561 goto out; 562 563 /* if incoming message isn't clear to send we are waiting on response */ 564 if (!(in_msg & E1000_VT_MSGTYPE_CTS)) { 565 /* message is not CTS and is NACK we have lost CTS status */ 566 if (in_msg & E1000_VT_MSGTYPE_NACK) 567 ret_val = -E1000_ERR_MAC_INIT; 568 goto out; 569 } 570 571 /* at this point we know the PF is talking to us, check and see if 572 * we are still accepting timeout or if we had a timeout failure. 573 * if we failed then we will need to reinit */ 574 if (!mbx->timeout) { 575 ret_val = -E1000_ERR_MAC_INIT; 576 goto out; 577 } 578 579 /* if we passed all the tests above then the link is up and we no 580 * longer need to check for link */ 581 mac->get_link_status = FALSE; 582 583 out: 584 return ret_val; 585 } 586 587