1/****************************************************************************** 2 SPDX-License-Identifier: BSD-3-Clause 3 4 Copyright (c) 2001-2020, 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 35 36#include "e1000_api.h" 37 38 39static s32 e1000_init_phy_params_vf(struct e1000_hw *hw); 40static s32 e1000_init_nvm_params_vf(struct e1000_hw *hw); 41static void e1000_release_vf(struct e1000_hw *hw); 42static s32 e1000_acquire_vf(struct e1000_hw *hw); 43static s32 e1000_setup_link_vf(struct e1000_hw *hw); 44static s32 e1000_get_bus_info_pcie_vf(struct e1000_hw *hw); 45static s32 e1000_init_mac_params_vf(struct e1000_hw *hw); 46static s32 e1000_check_for_link_vf(struct e1000_hw *hw); 47static s32 e1000_get_link_up_info_vf(struct e1000_hw *hw, u16 *speed, 48 u16 *duplex); 49static s32 e1000_init_hw_vf(struct e1000_hw *hw); 50static s32 e1000_reset_hw_vf(struct e1000_hw *hw); 51static void e1000_update_mc_addr_list_vf(struct e1000_hw *hw, u8 *, u32); 52static int e1000_rar_set_vf(struct e1000_hw *, u8 *, u32); 53static s32 e1000_read_mac_addr_vf(struct e1000_hw *); 54 55/** 56 * e1000_init_phy_params_vf - Inits PHY params 57 * @hw: pointer to the HW structure 58 * 59 * Doesn't do much - there's no PHY available to the VF. 60 **/ 61static s32 e1000_init_phy_params_vf(struct e1000_hw *hw) 62{ 63 DEBUGFUNC("e1000_init_phy_params_vf"); 64 hw->phy.type = e1000_phy_vf; 65 hw->phy.ops.acquire = e1000_acquire_vf; 66 hw->phy.ops.release = e1000_release_vf; 67 68 return E1000_SUCCESS; 69} 70 71/** 72 * e1000_init_nvm_params_vf - Inits NVM params 73 * @hw: pointer to the HW structure 74 * 75 * Doesn't do much - there's no NVM available to the VF. 76 **/ 77static s32 e1000_init_nvm_params_vf(struct e1000_hw *hw) 78{ 79 DEBUGFUNC("e1000_init_nvm_params_vf"); 80 hw->nvm.type = e1000_nvm_none; 81 hw->nvm.ops.acquire = e1000_acquire_vf; 82 hw->nvm.ops.release = e1000_release_vf; 83 84 return E1000_SUCCESS; 85} 86 87/** 88 * e1000_init_mac_params_vf - Inits MAC params 89 * @hw: pointer to the HW structure 90 **/ 91static s32 e1000_init_mac_params_vf(struct e1000_hw *hw) 92{ 93 struct e1000_mac_info *mac = &hw->mac; 94 95 DEBUGFUNC("e1000_init_mac_params_vf"); 96 97 /* Set media type */ 98 /* 99 * Virtual functions don't care what they're media type is as they 100 * have no direct access to the PHY, or the media. That is handled 101 * by the physical function driver. 102 */ 103 hw->phy.media_type = e1000_media_type_unknown; 104 105 /* No ASF features for the VF driver */ 106 mac->asf_firmware_present = false; 107 /* ARC subsystem not supported */ 108 mac->arc_subsystem_valid = false; 109 /* Disable adaptive IFS mode so the generic funcs don't do anything */ 110 mac->adaptive_ifs = false; 111 /* VF's have no MTA Registers - PF feature only */ 112 mac->mta_reg_count = 128; 113 /* VF's have no access to RAR entries */ 114 mac->rar_entry_count = 1; 115 116 /* Function pointers */ 117 /* link setup */ 118 mac->ops.setup_link = e1000_setup_link_vf; 119 /* bus type/speed/width */ 120 mac->ops.get_bus_info = e1000_get_bus_info_pcie_vf; 121 /* reset */ 122 mac->ops.reset_hw = e1000_reset_hw_vf; 123 /* hw initialization */ 124 mac->ops.init_hw = e1000_init_hw_vf; 125 /* check for link */ 126 mac->ops.check_for_link = e1000_check_for_link_vf; 127 /* link info */ 128 mac->ops.get_link_up_info = e1000_get_link_up_info_vf; 129 /* multicast address update */ 130 mac->ops.update_mc_addr_list = e1000_update_mc_addr_list_vf; 131 /* set mac address */ 132 mac->ops.rar_set = e1000_rar_set_vf; 133 /* read mac address */ 134 mac->ops.read_mac_addr = e1000_read_mac_addr_vf; 135 136 137 return E1000_SUCCESS; 138} 139 140/** 141 * e1000_init_function_pointers_vf - Inits function pointers 142 * @hw: pointer to the HW structure 143 **/ 144void e1000_init_function_pointers_vf(struct e1000_hw *hw) 145{ 146 DEBUGFUNC("e1000_init_function_pointers_vf"); 147 148 hw->mac.ops.init_params = e1000_init_mac_params_vf; 149 hw->nvm.ops.init_params = e1000_init_nvm_params_vf; 150 hw->phy.ops.init_params = e1000_init_phy_params_vf; 151 hw->mbx.ops.init_params = e1000_init_mbx_params_vf; 152} 153 154/** 155 * e1000_acquire_vf - Acquire rights to access PHY or NVM. 156 * @hw: pointer to the HW structure 157 * 158 * There is no PHY or NVM so we want all attempts to acquire these to fail. 159 * In addition, the MAC registers to access PHY/NVM don't exist so we don't 160 * even want any SW to attempt to use them. 161 **/ 162static s32 e1000_acquire_vf(struct e1000_hw E1000_UNUSEDARG *hw) 163{ 164 return -E1000_ERR_PHY; 165} 166 167/** 168 * e1000_release_vf - Release PHY or NVM 169 * @hw: pointer to the HW structure 170 * 171 * There is no PHY or NVM so we want all attempts to acquire these to fail. 172 * In addition, the MAC registers to access PHY/NVM don't exist so we don't 173 * even want any SW to attempt to use them. 174 **/ 175static void e1000_release_vf(struct e1000_hw E1000_UNUSEDARG *hw) 176{ 177 return; 178} 179 180/** 181 * e1000_setup_link_vf - Sets up link. 182 * @hw: pointer to the HW structure 183 * 184 * Virtual functions cannot change link. 185 **/ 186static s32 e1000_setup_link_vf(struct e1000_hw E1000_UNUSEDARG *hw) 187{ 188 DEBUGFUNC("e1000_setup_link_vf"); 189 190 return E1000_SUCCESS; 191} 192 193/** 194 * e1000_get_bus_info_pcie_vf - Gets the bus info. 195 * @hw: pointer to the HW structure 196 * 197 * Virtual functions are not really on their own bus. 198 **/ 199static s32 e1000_get_bus_info_pcie_vf(struct e1000_hw *hw) 200{ 201 struct e1000_bus_info *bus = &hw->bus; 202 203 DEBUGFUNC("e1000_get_bus_info_pcie_vf"); 204 205 /* Do not set type PCI-E because we don't want disable master to run */ 206 bus->type = e1000_bus_type_reserved; 207 bus->speed = e1000_bus_speed_2500; 208 209 return 0; 210} 211 212/** 213 * e1000_get_link_up_info_vf - Gets link info. 214 * @hw: pointer to the HW structure 215 * @speed: pointer to 16 bit value to store link speed. 216 * @duplex: pointer to 16 bit value to store duplex. 217 * 218 * Since we cannot read the PHY and get accurate link info, we must rely upon 219 * the status register's data which is often stale and inaccurate. 220 **/ 221static s32 e1000_get_link_up_info_vf(struct e1000_hw *hw, u16 *speed, 222 u16 *duplex) 223{ 224 s32 status; 225 226 DEBUGFUNC("e1000_get_link_up_info_vf"); 227 228 status = E1000_READ_REG(hw, E1000_STATUS); 229 if (status & E1000_STATUS_SPEED_1000) { 230 *speed = SPEED_1000; 231 DEBUGOUT("1000 Mbs, "); 232 } else if (status & E1000_STATUS_SPEED_100) { 233 *speed = SPEED_100; 234 DEBUGOUT("100 Mbs, "); 235 } else { 236 *speed = SPEED_10; 237 DEBUGOUT("10 Mbs, "); 238 } 239 240 if (status & E1000_STATUS_FD) { 241 *duplex = FULL_DUPLEX; 242 DEBUGOUT("Full Duplex\n"); 243 } else { 244 *duplex = HALF_DUPLEX; 245 DEBUGOUT("Half Duplex\n"); 246 } 247 248 return E1000_SUCCESS; 249} 250 251/** 252 * e1000_reset_hw_vf - Resets the HW 253 * @hw: pointer to the HW structure 254 * 255 * VF's provide a function level reset. This is done using bit 26 of ctrl_reg. 256 * This is all the reset we can perform on a VF. 257 **/ 258static s32 e1000_reset_hw_vf(struct e1000_hw *hw) 259{ 260 struct e1000_mbx_info *mbx = &hw->mbx; 261 u32 timeout = E1000_VF_INIT_TIMEOUT; 262 s32 ret_val = -E1000_ERR_MAC_INIT; 263 u32 ctrl, msgbuf[3]; 264 u8 *addr = (u8 *)(&msgbuf[1]); 265 266 DEBUGFUNC("e1000_reset_hw_vf"); 267 268 DEBUGOUT("Issuing a function level reset to MAC\n"); 269 ctrl = E1000_READ_REG(hw, E1000_CTRL); 270 E1000_WRITE_REG(hw, E1000_CTRL, ctrl | E1000_CTRL_RST); 271 272 /* we cannot reset while the RSTI / RSTD bits are asserted */ 273 while (!mbx->ops.check_for_rst(hw, 0) && timeout) { 274 timeout--; 275 usec_delay(5); 276 } 277 278 if (timeout) { 279 /* mailbox timeout can now become active */ 280 mbx->timeout = E1000_VF_MBX_INIT_TIMEOUT; 281 282 msgbuf[0] = E1000_VF_RESET; 283 mbx->ops.write_posted(hw, msgbuf, 1, 0); 284 285 msec_delay(10); 286 287 /* set our "perm_addr" based on info provided by PF */ 288 ret_val = mbx->ops.read_posted(hw, msgbuf, 3, 0); 289 if (!ret_val) { 290 if (msgbuf[0] == (E1000_VF_RESET | 291 E1000_VT_MSGTYPE_ACK)) 292 memcpy(hw->mac.perm_addr, addr, 6); 293 else 294 ret_val = -E1000_ERR_MAC_INIT; 295 } 296 } 297 298 return ret_val; 299} 300 301/** 302 * e1000_init_hw_vf - Inits the HW 303 * @hw: pointer to the HW structure 304 * 305 * Not much to do here except clear the PF Reset indication if there is one. 306 **/ 307static s32 e1000_init_hw_vf(struct e1000_hw *hw) 308{ 309 DEBUGFUNC("e1000_init_hw_vf"); 310 311 /* attempt to set and restore our mac address */ 312 e1000_rar_set_vf(hw, hw->mac.addr, 0); 313 314 return E1000_SUCCESS; 315} 316 317/** 318 * e1000_rar_set_vf - set device MAC address 319 * @hw: pointer to the HW structure 320 * @addr: pointer to the receive address 321 * @index receive address array register 322 **/ 323static int e1000_rar_set_vf(struct e1000_hw *hw, u8 *addr, 324 u32 E1000_UNUSEDARG index) 325{ 326 struct e1000_mbx_info *mbx = &hw->mbx; 327 u32 msgbuf[3]; 328 u8 *msg_addr = (u8 *)(&msgbuf[1]); 329 s32 ret_val; 330 331 memset(msgbuf, 0, 12); 332 msgbuf[0] = E1000_VF_SET_MAC_ADDR; 333 memcpy(msg_addr, addr, 6); 334 ret_val = mbx->ops.write_posted(hw, msgbuf, 3, 0); 335 336 if (!ret_val) 337 ret_val = mbx->ops.read_posted(hw, msgbuf, 3, 0); 338 339 msgbuf[0] &= ~E1000_VT_MSGTYPE_CTS; 340 341 /* if nacked the address was rejected, use "perm_addr" */ 342 if (!ret_val && 343 (msgbuf[0] == (E1000_VF_SET_MAC_ADDR | E1000_VT_MSGTYPE_NACK))) 344 e1000_read_mac_addr_vf(hw); 345 346 return E1000_SUCCESS; 347} 348 349/** 350 * e1000_hash_mc_addr_vf - Generate a multicast hash value 351 * @hw: pointer to the HW structure 352 * @mc_addr: pointer to a multicast address 353 * 354 * Generates a multicast address hash value which is used to determine 355 * the multicast filter table array address and new table value. 356 **/ 357static u32 e1000_hash_mc_addr_vf(struct e1000_hw *hw, u8 *mc_addr) 358{ 359 u32 hash_value, hash_mask; 360 u8 bit_shift = 0; 361 362 DEBUGFUNC("e1000_hash_mc_addr_generic"); 363 364 /* Register count multiplied by bits per register */ 365 hash_mask = (hw->mac.mta_reg_count * 32) - 1; 366 367 /* 368 * The bit_shift is the number of left-shifts 369 * where 0xFF would still fall within the hash mask. 370 */ 371 while (hash_mask >> bit_shift != 0xFF) 372 bit_shift++; 373 374 hash_value = hash_mask & (((mc_addr[4] >> (8 - bit_shift)) | 375 (((u16) mc_addr[5]) << bit_shift))); 376 377 return hash_value; 378} 379 380static void e1000_write_msg_read_ack(struct e1000_hw *hw, 381 u32 *msg, u16 size) 382{ 383 struct e1000_mbx_info *mbx = &hw->mbx; 384 u32 retmsg[E1000_VFMAILBOX_SIZE]; 385 s32 retval = mbx->ops.write_posted(hw, msg, size, 0); 386 387 if (!retval) 388 mbx->ops.read_posted(hw, retmsg, E1000_VFMAILBOX_SIZE, 0); 389} 390 391/** 392 * e1000_update_mc_addr_list_vf - Update Multicast addresses 393 * @hw: pointer to the HW structure 394 * @mc_addr_list: array of multicast addresses to program 395 * @mc_addr_count: number of multicast addresses to program 396 * 397 * Updates the Multicast Table Array. 398 * The caller must have a packed mc_addr_list of multicast addresses. 399 **/ 400void e1000_update_mc_addr_list_vf(struct e1000_hw *hw, 401 u8 *mc_addr_list, u32 mc_addr_count) 402{ 403 u32 msgbuf[E1000_VFMAILBOX_SIZE]; 404 u16 *hash_list = (u16 *)&msgbuf[1]; 405 u32 hash_value; 406 u32 i; 407 408 DEBUGFUNC("e1000_update_mc_addr_list_vf"); 409 410 /* Each entry in the list uses 1 16 bit word. We have 30 411 * 16 bit words available in our HW msg buffer (minus 1 for the 412 * msg type). That's 30 hash values if we pack 'em right. If 413 * there are more than 30 MC addresses to add then punt the 414 * extras for now and then add code to handle more than 30 later. 415 * It would be unusual for a server to request that many multi-cast 416 * addresses except for in large enterprise network environments. 417 */ 418 419 DEBUGOUT1("MC Addr Count = %d\n", mc_addr_count); 420 421 msgbuf[0] = E1000_VF_SET_MULTICAST; 422 423 if (mc_addr_count > 30) { 424 msgbuf[0] |= E1000_VF_SET_MULTICAST_OVERFLOW; 425 mc_addr_count = 30; 426 } 427 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 += ETHER_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 **/ 446void 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 **/ 463void 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 **/ 479s32 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 /* FALLTHROUGH */ 492 case e1000_promisc_unicast: 493 msgbuf |= E1000_VF_SET_PROMISC_UNICAST; 494 /* FALLTHROUGH */ 495 case e1000_promisc_disabled: 496 break; 497 default: 498 return -E1000_ERR_MAC_INIT; 499 } 500 501 ret_val = mbx->ops.write_posted(hw, &msgbuf, 1, 0); 502 503 if (!ret_val) 504 ret_val = mbx->ops.read_posted(hw, &msgbuf, 1, 0); 505 506 if (!ret_val && !(msgbuf & E1000_VT_MSGTYPE_ACK)) 507 ret_val = -E1000_ERR_MAC_INIT; 508 509 return ret_val; 510} 511 512/** 513 * e1000_read_mac_addr_vf - Read device MAC address 514 * @hw: pointer to the HW structure 515 **/ 516static s32 e1000_read_mac_addr_vf(struct e1000_hw *hw) 517{ 518 int i; 519 520 for (i = 0; i < ETHER_ADDR_LEN; i++) 521 hw->mac.addr[i] = hw->mac.perm_addr[i]; 522 523 return E1000_SUCCESS; 524} 525 526/** 527 * e1000_check_for_link_vf - Check for link for a virtual interface 528 * @hw: pointer to the HW structure 529 * 530 * Checks to see if the underlying PF is still talking to the VF and 531 * if it is then it reports the link state to the hardware, otherwise 532 * it reports link down and returns an error. 533 **/ 534static s32 e1000_check_for_link_vf(struct e1000_hw *hw) 535{ 536 struct e1000_mbx_info *mbx = &hw->mbx; 537 struct e1000_mac_info *mac = &hw->mac; 538 s32 ret_val = E1000_SUCCESS; 539 u32 in_msg = 0; 540 541 DEBUGFUNC("e1000_check_for_link_vf"); 542 543 /* 544 * We only want to run this if there has been a rst asserted. 545 * in this case that could mean a link change, device reset, 546 * or a virtual function reset 547 */ 548 549 /* If we were hit with a reset or timeout drop the link */ 550 if (!mbx->ops.check_for_rst(hw, 0) || !mbx->timeout) 551 mac->get_link_status = true; 552 553 if (!mac->get_link_status) 554 goto out; 555 556 /* if link status is down no point in checking to see if pf is up */ 557 if (!(E1000_READ_REG(hw, E1000_STATUS) & E1000_STATUS_LU)) 558 goto out; 559 560 /* if the read failed it could just be a mailbox collision, best wait 561 * until we are called again and don't report an error */ 562 if (mbx->ops.read(hw, &in_msg, 1, 0)) 563 goto out; 564 565 /* if incoming message isn't clear to send we are waiting on response */ 566 if (!(in_msg & E1000_VT_MSGTYPE_CTS)) { 567 /* message is not CTS and is NACK we have lost CTS status */ 568 if (in_msg & E1000_VT_MSGTYPE_NACK) 569 ret_val = -E1000_ERR_MAC_INIT; 570 goto out; 571 } 572 573 /* at this point we know the PF is talking to us, check and see if 574 * we are still accepting timeout or if we had a timeout failure. 575 * if we failed then we will need to reinit */ 576 if (!mbx->timeout) { 577 ret_val = -E1000_ERR_MAC_INIT; 578 goto out; 579 } 580 581 /* if we passed all the tests above then the link is up and we no 582 * longer need to check for link */ 583 mac->get_link_status = false; 584 585out: 586 return ret_val; 587} 588 589