drivers/net/e1000e/lib.c

   1 /*******************************************************************************
   2
   3   Intel PRO/1000 Linux driver
   4   Copyright(c) 1999 - 2008 Intel Corporation.
   5
   6   This program is free software; you can redistribute it and/or modify it
   7   under the terms and conditions of the GNU General Public License,
   8   version 2, as published by the Free Software Foundation.
   9
  10   This program is distributed in the hope it will be useful, but WITHOUT
  11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13   more details.
  14
  15   You should have received a copy of the GNU General Public License along with
  16   this program; if not, write to the Free Software Foundation, Inc.,
  17   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  18
  19   The full GNU General Public License is included in this distribution in
  20   the file called "COPYING".
  21
  22   Contact Information:
  23   Linux NICS <linux.nics@intel.com>
  24   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  25   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  26
  27 *******************************************************************************/
  28
  29 #include <linux/netdevice.h>
  30 #include <linux/ethtool.h>
  31 #include <linux/delay.h>
  32 #include <linux/pci.h>
  33
  34 #include "e1000.h"
  35
  36 enum e1000_mng_mode {
  37         e1000_mng_mode_none = 0,
  38         e1000_mng_mode_asf,
  39         e1000_mng_mode_pt,
  40         e1000_mng_mode_ipmi,
  41         e1000_mng_mode_host_if_only
  42 };
  43
  44 #define E1000_FACTPS_MNGCG              0x20000000
  45
  46 /* Intel(R) Active Management Technology signature */
  47 #define E1000_IAMT_SIGNATURE            0x544D4149
  48
  49 /**
  50  *  e1000e_get_bus_info_pcie - Get PCIe bus information
  51  *  @hw: pointer to the HW structure
  52  *
  53  *  Determines and stores the system bus information for a particular
  54  *  network interface.  The following bus information is determined and stored:
  55  *  bus speed, bus width, type (PCIe), and PCIe function.
  56  **/
  57 s32 e1000e_get_bus_info_pcie(struct e1000_hw *hw)
  58 {
  59         struct e1000_bus_info *bus = &hw->bus;
  60         struct e1000_adapter *adapter = hw->adapter;
  61         u32 status;
  62         u16 pcie_link_status, pci_header_type, cap_offset;
  63
  64         cap_offset = pci_find_capability(adapter->pdev, PCI_CAP_ID_EXP);
  65         if (!cap_offset) {
  66                 bus->width = e1000_bus_width_unknown;
  67         } else {
  68                 pci_read_config_word(adapter->pdev,
  69                                      cap_offset + PCIE_LINK_STATUS,
  70                                      &pcie_link_status);
  71                 bus->width = (enum e1000_bus_width)((pcie_link_status &
  72                                                      PCIE_LINK_WIDTH_MASK) >>
  73                                                     PCIE_LINK_WIDTH_SHIFT);
  74         }
  75
  76         pci_read_config_word(adapter->pdev, PCI_HEADER_TYPE_REGISTER,
  77                              &pci_header_type);
  78         if (pci_header_type & PCI_HEADER_TYPE_MULTIFUNC) {
  79                 status = er32(STATUS);
  80                 bus->func = (status & E1000_STATUS_FUNC_MASK)
  81                             >> E1000_STATUS_FUNC_SHIFT;
  82         } else {
  83                 bus->func = 0;
  84         }
  85
  86         return 0;
  87 }
  88
  89 /**
  90  *  e1000e_write_vfta - Write value to VLAN filter table
  91  *  @hw: pointer to the HW structure
  92  *  @offset: register offset in VLAN filter table
  93  *  @value: register value written to VLAN filter table
  94  *
  95  *  Writes value at the given offset in the register array which stores
  96  *  the VLAN filter table.
  97  **/
  98 void e1000e_write_vfta(struct e1000_hw *hw, u32 offset, u32 value)
  99 {
 100         E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, value);
 101         e1e_flush();
 102 }
 103
 104 /**
 105  *  e1000e_init_rx_addrs - Initialize receive address's
 106  *  @hw: pointer to the HW structure
 107  *  @rar_count: receive address registers
 108  *
 109  *  Setups the receive address registers by setting the base receive address
 110  *  register to the devices MAC address and clearing all the other receive
 111  *  address registers to 0.
 112  **/
 113 void e1000e_init_rx_addrs(struct e1000_hw *hw, u16 rar_count)
 114 {
 115         u32 i;
 116
 117         /* Setup the receive address */
 118         hw_dbg(hw, "Programming MAC Address into RAR[0]\n");
 119
 120         e1000e_rar_set(hw, hw->mac.addr, 0);
 121
 122         /* Zero out the other (rar_entry_count - 1) receive addresses */
 123         hw_dbg(hw, "Clearing RAR[1-%u]\n", rar_count-1);
 124         for (i = 1; i < rar_count; i++) {
 125                 E1000_WRITE_REG_ARRAY(hw, E1000_RA, (i << 1), 0);
 126                 e1e_flush();
 127                 E1000_WRITE_REG_ARRAY(hw, E1000_RA, ((i << 1) + 1), 0);
 128                 e1e_flush();
 129         }
 130 }
 131
 132 /**
 133  *  e1000e_rar_set - Set receive address register
 134  *  @hw: pointer to the HW structure
 135  *  @addr: pointer to the receive address
 136  *  @index: receive address array register
 137  *
 138  *  Sets the receive address array register at index to the address passed
 139  *  in by addr.
 140  **/
 141 void e1000e_rar_set(struct e1000_hw *hw, u8 *addr, u32 index)
 142 {
 143         u32 rar_low, rar_high;
 144
 145         /*
 146          * HW expects these in little endian so we reverse the byte order
 147          * from network order (big endian) to little endian
 148          */
 149         rar_low = ((u32) addr[0] |
 150                    ((u32) addr[1] << 8) |
 151                     ((u32) addr[2] << 16) | ((u32) addr[3] << 24));
 152
 153         rar_high = ((u32) addr[4] | ((u32) addr[5] << 8));
 154
 155         rar_high |= E1000_RAH_AV;
 156
 157         E1000_WRITE_REG_ARRAY(hw, E1000_RA, (index << 1), rar_low);
 158         E1000_WRITE_REG_ARRAY(hw, E1000_RA, ((index << 1) + 1), rar_high);
 159 }
 160
 161 /**
 162  *  e1000_hash_mc_addr - Generate a multicast hash value
 163  *  @hw: pointer to the HW structure
 164  *  @mc_addr: pointer to a multicast address
 165  *
 166  *  Generates a multicast address hash value which is used to determine
 167  *  the multicast filter table array address and new table value.  See
 168  *  e1000_mta_set_generic()
 169  **/
 170 static u32 e1000_hash_mc_addr(struct e1000_hw *hw, u8 *mc_addr)
 171 {
 172         u32 hash_value, hash_mask;
 173         u8 bit_shift = 0;
 174
 175         /* Register count multiplied by bits per register */
 176         hash_mask = (hw->mac.mta_reg_count * 32) - 1;
 177
 178         /*
 179          * For a mc_filter_type of 0, bit_shift is the number of left-shifts
 180          * where 0xFF would still fall within the hash mask.
 181          */
 182         while (hash_mask >> bit_shift != 0xFF)
 183                 bit_shift++;
 184
 185         /*
 186          * The portion of the address that is used for the hash table
 187          * is determined by the mc_filter_type setting.
 188          * The algorithm is such that there is a total of 8 bits of shifting.
 189          * The bit_shift for a mc_filter_type of 0 represents the number of
 190          * left-shifts where the MSB of mc_addr[5] would still fall within
 191          * the hash_mask.  Case 0 does this exactly.  Since there are a total
 192          * of 8 bits of shifting, then mc_addr[4] will shift right the
 193          * remaining number of bits. Thus 8 - bit_shift.  The rest of the
 194          * cases are a variation of this algorithm...essentially raising the
 195          * number of bits to shift mc_addr[5] left, while still keeping the
 196          * 8-bit shifting total.
 197          *
 198          * For example, given the following Destination MAC Address and an
 199          * mta register count of 128 (thus a 4096-bit vector and 0xFFF mask),
 200          * we can see that the bit_shift for case 0 is 4.  These are the hash
 201          * values resulting from each mc_filter_type...
 202          * [0] [1] [2] [3] [4] [5]
 203          * 01  AA  00  12  34  56
 204          * LSB           MSB
 205          *
 206          * case 0: hash_value = ((0x34 >> 4) | (0x56 << 4)) & 0xFFF = 0x563
 207          * case 1: hash_value = ((0x34 >> 3) | (0x56 << 5)) & 0xFFF = 0xAC6
 208          * case 2: hash_value = ((0x34 >> 2) | (0x56 << 6)) & 0xFFF = 0x163
 209          * case 3: hash_value = ((0x34 >> 0) | (0x56 << 8)) & 0xFFF = 0x634
 210          */
 211         switch (hw->mac.mc_filter_type) {
 212         default:
 213         case 0:
 214                 break;
 215         case 1:
 216                 bit_shift += 1;
 217                 break;
 218         case 2:
 219                 bit_shift += 2;
 220                 break;
 221         case 3:
 222                 bit_shift += 4;
 223                 break;
 224         }
 225
 226         hash_value = hash_mask & (((mc_addr[4] >> (8 - bit_shift)) |
 227                                   (((u16) mc_addr[5]) << bit_shift)));
 228
 229         return hash_value;
 230 }
 231
 232 /**
 233  *  e1000e_update_mc_addr_list_generic - Update Multicast addresses
 234  *  @hw: pointer to the HW structure
 235  *  @mc_addr_list: array of multicast addresses to program
 236  *  @mc_addr_count: number of multicast addresses to program
 237  *  @rar_used_count: the first RAR register free to program
 238  *  @rar_count: total number of supported Receive Address Registers
 239  *
 240  *  Updates the Receive Address Registers and Multicast Table Array.
 241  *  The caller must have a packed mc_addr_list of multicast addresses.
 242  *  The parameter rar_count will usually be hw->mac.rar_entry_count
 243  *  unless there are workarounds that change this.
 244  **/
 245 void e1000e_update_mc_addr_list_generic(struct e1000_hw *hw,
 246                                         u8 *mc_addr_list, u32 mc_addr_count,
 247                                         u32 rar_used_count, u32 rar_count)
 248 {
 249         u32 i;
 250         u32 *mcarray = kzalloc(hw->mac.mta_reg_count * sizeof(u32), GFP_ATOMIC);
 251
 252         if (!mcarray) {
 253                 printk(KERN_ERR "multicast array memory allocation failed\n");
 254                 return;
 255         }
 256
 257         /*
 258          * Load the first set of multicast addresses into the exact
 259          * filters (RAR).  If there are not enough to fill the RAR
 260          * array, clear the filters.
 261          */
 262         for (i = rar_used_count; i < rar_count; i++) {
 263                 if (mc_addr_count) {
 264                         e1000e_rar_set(hw, mc_addr_list, i);
 265                         mc_addr_count--;
 266                         mc_addr_list += ETH_ALEN;
 267                 } else {
 268                         E1000_WRITE_REG_ARRAY(hw, E1000_RA, i << 1, 0);
 269                         e1e_flush();
 270                         E1000_WRITE_REG_ARRAY(hw, E1000_RA, (i << 1) + 1, 0);
 271                         e1e_flush();
 272                 }
 273         }
 274
 275         /* Load any remaining multicast addresses into the hash table. */
 276         for (; mc_addr_count > 0; mc_addr_count--) {
 277                 u32 hash_value, hash_reg, hash_bit, mta;
 278                 hash_value = e1000_hash_mc_addr(hw, mc_addr_list);
 279                 hw_dbg(hw, "Hash value = 0x%03X\n", hash_value);
 280                 hash_reg = (hash_value >> 5) & (hw->mac.mta_reg_count - 1);
 281                 hash_bit = hash_value & 0x1F;
 282                 mta = (1 << hash_bit);
 283                 mcarray[hash_reg] |= mta;
 284                 mc_addr_list += ETH_ALEN;
 285         }
 286
 287         /* write the hash table completely */
 288         for (i = 0; i < hw->mac.mta_reg_count; i++)
 289                 E1000_WRITE_REG_ARRAY(hw, E1000_MTA, i, mcarray[i]);
 290
 291         e1e_flush();
 292         kfree(mcarray);
 293 }
 294
 295 /**
 296  *  e1000e_clear_hw_cntrs_base - Clear base hardware counters
 297  *  @hw: pointer to the HW structure
 298  *
 299  *  Clears the base hardware counters by reading the counter registers.
 300  **/
 301 void e1000e_clear_hw_cntrs_base(struct e1000_hw *hw)
 302 {
 303         u32 temp;
 304
 305         temp = er32(CRCERRS);
 306         temp = er32(SYMERRS);
 307         temp = er32(MPC);
 308         temp = er32(SCC);
 309         temp = er32(ECOL);
 310         temp = er32(MCC);
 311         temp = er32(LATECOL);
 312         temp = er32(COLC);
 313         temp = er32(DC);
 314         temp = er32(SEC);
 315         temp = er32(RLEC);
 316         temp = er32(XONRXC);
 317         temp = er32(XONTXC);
 318         temp = er32(XOFFRXC);
 319         temp = er32(XOFFTXC);
 320         temp = er32(FCRUC);
 321         temp = er32(GPRC);
 322         temp = er32(BPRC);
 323         temp = er32(MPRC);
 324         temp = er32(GPTC);
 325         temp = er32(GORCL);
 326         temp = er32(GORCH);
 327         temp = er32(GOTCL);
 328         temp = er32(GOTCH);
 329         temp = er32(RNBC);
 330         temp = er32(RUC);
 331         temp = er32(RFC);
 332         temp = er32(ROC);
 333         temp = er32(RJC);
 334         temp = er32(TORL);
 335         temp = er32(TORH);
 336         temp = er32(TOTL);
 337         temp = er32(TOTH);
 338         temp = er32(TPR);
 339         temp = er32(TPT);
 340         temp = er32(MPTC);
 341         temp = er32(BPTC);
 342 }
 343
 344 /**
 345  *  e1000e_check_for_copper_link - Check for link (Copper)
 346  *  @hw: pointer to the HW structure
 347  *
 348  *  Checks to see of the link status of the hardware has changed.  If a
 349  *  change in link status has been detected, then we read the PHY registers
 350  *  to get the current speed/duplex if link exists.
 351  **/
 352 s32 e1000e_check_for_copper_link(struct e1000_hw *hw)
 353 {
 354         struct e1000_mac_info *mac = &hw->mac;
 355         s32 ret_val;
 356         bool link;
 357
 358         /*
 359          * We only want to go out to the PHY registers to see if Auto-Neg
 360          * has completed and/or if our link status has changed.  The
 361          * get_link_status flag is set upon receiving a Link Status
 362          * Change or Rx Sequence Error interrupt.
 363          */
 364         if (!mac->get_link_status)
 365                 return 0;
 366
 367         /*
 368          * First we want to see if the MII Status Register reports
 369          * link.  If so, then we want to get the current speed/duplex
 370          * of the PHY.
 371          */
 372         ret_val = e1000e_phy_has_link_generic(hw, 1, 0, &link);
 373         if (ret_val)
 374                 return ret_val;
 375
 376         if (!link)
 377                 return ret_val; /* No link detected */
 378
 379         mac->get_link_status = 0;
 380
 381         /*
 382          * Check if there was DownShift, must be checked
 383          * immediately after link-up
 384          */
 385         e1000e_check_downshift(hw);
 386
 387         /*
 388          * If we are forcing speed/duplex, then we simply return since
 389          * we have already determined whether we have link or not.
 390          */
 391         if (!mac->autoneg) {
 392                 ret_val = -E1000_ERR_CONFIG;
 393                 return ret_val;
 394         }
 395
 396         /*
 397          * Auto-Neg is enabled.  Auto Speed Detection takes care
 398          * of MAC speed/duplex configuration.  So we only need to
 399          * configure Collision Distance in the MAC.
 400          */
 401         e1000e_config_collision_dist(hw);
 402
 403         /*
 404          * Configure Flow Control now that Auto-Neg has completed.
 405          * First, we need to restore the desired flow control
 406          * settings because we may have had to re-autoneg with a
 407          * different link partner.
 408          */
 409         ret_val = e1000e_config_fc_after_link_up(hw);
 410         if (ret_val) {
 411                 hw_dbg(hw, "Error configuring flow control\n");
 412         }
 413
 414         return ret_val;
 415 }
 416
 417 /**
 418  *  e1000e_check_for_fiber_link - Check for link (Fiber)
 419  *  @hw: pointer to the HW structure
 420  *
 421  *  Checks for link up on the hardware.  If link is not up and we have
 422  *  a signal, then we need to force link up.
 423  **/
 424 s32 e1000e_check_for_fiber_link(struct e1000_hw *hw)
 425 {
 426         struct e1000_mac_info *mac = &hw->mac;
 427         u32 rxcw;
 428         u32 ctrl;
 429         u32 status;
 430         s32 ret_val;
 431
 432         ctrl = er32(CTRL);
 433         status = er32(STATUS);
 434         rxcw = er32(RXCW);
 435
 436         /*
 437          * If we don't have link (auto-negotiation failed or link partner
 438          * cannot auto-negotiate), the cable is plugged in (we have signal),
 439          * and our link partner is not trying to auto-negotiate with us (we
 440          * are receiving idles or data), we need to force link up. We also
 441          * need to give auto-negotiation time to complete, in case the cable
 442          * was just plugged in. The autoneg_failed flag does this.
 443          */
 444         /* (ctrl & E1000_CTRL_SWDPIN1) == 1 == have signal */
 445         if ((ctrl & E1000_CTRL_SWDPIN1) && (!(status & E1000_STATUS_LU)) &&
 446             (!(rxcw & E1000_RXCW_C))) {
 447                 if (mac->autoneg_failed == 0) {
 448                         mac->autoneg_failed = 1;
 449                         return 0;
 450                 }
 451                 hw_dbg(hw, "NOT RXing /C/, disable AutoNeg and force link.\n");
 452
 453                 /* Disable auto-negotiation in the TXCW register */
 454                 ew32(TXCW, (mac->txcw & ~E1000_TXCW_ANE));
 455
 456                 /* Force link-up and also force full-duplex. */
 457                 ctrl = er32(CTRL);
 458                 ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FD);
 459                 ew32(CTRL, ctrl);
 460
 461                 /* Configure Flow Control after forcing link up. */
 462                 ret_val = e1000e_config_fc_after_link_up(hw);
 463                 if (ret_val) {
 464                         hw_dbg(hw, "Error configuring flow control\n");
 465                         return ret_val;
 466                 }
 467         } else if ((ctrl & E1000_CTRL_SLU) && (rxcw & E1000_RXCW_C)) {
 468                 /*
 469                  * If we are forcing link and we are receiving /C/ ordered
 470                  * sets, re-enable auto-negotiation in the TXCW register
 471                  * and disable forced link in the Device Control register
 472                  * in an attempt to auto-negotiate with our link partner.
 473                  */
 474                 hw_dbg(hw, "RXing /C/, enable AutoNeg and stop forcing link.\n");
 475                 ew32(TXCW, mac->txcw);
 476                 ew32(CTRL, (ctrl & ~E1000_CTRL_SLU));
 477
 478                 mac->serdes_has_link = true;
 479         }
 480
 481         return 0;
 482 }
 483
 484 /**
 485  *  e1000e_check_for_serdes_link - Check for link (Serdes)
 486  *  @hw: pointer to the HW structure
 487  *
 488  *  Checks for link up on the hardware.  If link is not up and we have
 489  *  a signal, then we need to force link up.
 490  **/
 491 s32 e1000e_check_for_serdes_link(struct e1000_hw *hw)
 492 {
 493         struct e1000_mac_info *mac = &hw->mac;
 494         u32 rxcw;
 495         u32 ctrl;
 496         u32 status;
 497         s32 ret_val;
 498
 499         ctrl = er32(CTRL);
 500         status = er32(STATUS);
 501         rxcw = er32(RXCW);
 502
 503         /*
 504          * If we don't have link (auto-negotiation failed or link partner
 505          * cannot auto-negotiate), and our link partner is not trying to
 506          * auto-negotiate with us (we are receiving idles or data),
 507          * we need to force link up. We also need to give auto-negotiation
 508          * time to complete.
 509          */
 510         /* (ctrl & E1000_CTRL_SWDPIN1) == 1 == have signal */
 511         if ((!(status & E1000_STATUS_LU)) && (!(rxcw & E1000_RXCW_C))) {
 512                 if (mac->autoneg_failed == 0) {
 513                         mac->autoneg_failed = 1;
 514                         return 0;
 515                 }
 516                 hw_dbg(hw, "NOT RXing /C/, disable AutoNeg and force link.\n");
 517
 518                 /* Disable auto-negotiation in the TXCW register */
 519                 ew32(TXCW, (mac->txcw & ~E1000_TXCW_ANE));
 520
 521                 /* Force link-up and also force full-duplex. */
 522                 ctrl = er32(CTRL);
 523                 ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FD);
 524                 ew32(CTRL, ctrl);
 525
 526                 /* Configure Flow Control after forcing link up. */
 527                 ret_val = e1000e_config_fc_after_link_up(hw);
 528                 if (ret_val) {
 529                         hw_dbg(hw, "Error configuring flow control\n");
 530                         return ret_val;
 531                 }
 532         } else if ((ctrl & E1000_CTRL_SLU) && (rxcw & E1000_RXCW_C)) {
 533                 /*
 534                  * If we are forcing link and we are receiving /C/ ordered
 535                  * sets, re-enable auto-negotiation in the TXCW register
 536                  * and disable forced link in the Device Control register
 537                  * in an attempt to auto-negotiate with our link partner.
 538                  */
 539                 hw_dbg(hw, "RXing /C/, enable AutoNeg and stop forcing link.\n");
 540                 ew32(TXCW, mac->txcw);
 541                 ew32(CTRL, (ctrl & ~E1000_CTRL_SLU));
 542
 543                 mac->serdes_has_link = true;
 544         } else if (!(E1000_TXCW_ANE & er32(TXCW))) {
 545                 /*
 546                  * If we force link for non-auto-negotiation switch, check
 547                  * link status based on MAC synchronization for internal
 548                  * serdes media type.
 549                  */
 550                 /* SYNCH bit and IV bit are sticky. */
 551                 udelay(10);
 552                 rxcw = er32(RXCW);
 553                 if (rxcw & E1000_RXCW_SYNCH) {
 554                         if (!(rxcw & E1000_RXCW_IV)) {
 555                                 mac->serdes_has_link = true;
 556                                 hw_dbg(hw, "SERDES: Link up - forced.\n");
 557                         }
 558                 } else {
 559                         mac->serdes_has_link = false;
 560                         hw_dbg(hw, "SERDES: Link down - force failed.\n");
 561                 }
 562         }
 563
 564         if (E1000_TXCW_ANE & er32(TXCW)) {
 565                 status = er32(STATUS);
 566                 if (status & E1000_STATUS_LU) {
 567                         /* SYNCH bit and IV bit are sticky, so reread rxcw.  */
 568                         udelay(10);
 569                         rxcw = er32(RXCW);
 570                         if (rxcw & E1000_RXCW_SYNCH) {
 571                                 if (!(rxcw & E1000_RXCW_IV)) {
 572                                         mac->serdes_has_link = true;
 573                                         hw_dbg(hw, "SERDES: Link up - autoneg "
 574                                            "completed sucessfully.\n");
 575                                 } else {
 576                                         mac->serdes_has_link = false;
 577                                         hw_dbg(hw, "SERDES: Link down - invalid"
 578                                            "codewords detected in autoneg.\n");
 579                                 }
 580                         } else {
 581                                 mac->serdes_has_link = false;
 582                                 hw_dbg(hw, "SERDES: Link down - no sync.\n");
 583                         }
 584                 } else {
 585                         mac->serdes_has_link = false;
 586                         hw_dbg(hw, "SERDES: Link down - autoneg failed\n");
 587                 }
 588         }
 589
 590         return 0;
 591 }
 592
 593 /**
 594  *  e1000_set_default_fc_generic - Set flow control default values
 595  *  @hw: pointer to the HW structure
 596  *
 597  *  Read the EEPROM for the default values for flow control and store the
 598  *  values.
 599  **/
 600 static s32 e1000_set_default_fc_generic(struct e1000_hw *hw)
 601 {
 602         s32 ret_val;
 603         u16 nvm_data;
 604
 605         /*
 606          * Read and store word 0x0F of the EEPROM. This word contains bits
 607          * that determine the hardware's default PAUSE (flow control) mode,
 608          * a bit that determines whether the HW defaults to enabling or
 609          * disabling auto-negotiation, and the direction of the
 610          * SW defined pins. If there is no SW over-ride of the flow
 611          * control setting, then the variable hw->fc will
 612          * be initialized based on a value in the EEPROM.
 613          */
 614         ret_val = e1000_read_nvm(hw, NVM_INIT_CONTROL2_REG, 1, &nvm_data);
 615
 616         if (ret_val) {
 617                 hw_dbg(hw, "NVM Read Error\n");
 618                 return ret_val;
 619         }
 620
 621         if ((nvm_data & NVM_WORD0F_PAUSE_MASK) == 0)
 622                 hw->fc.requested_mode = e1000_fc_none;
 623         else if ((nvm_data & NVM_WORD0F_PAUSE_MASK) ==
 624                  NVM_WORD0F_ASM_DIR)
 625                 hw->fc.requested_mode = e1000_fc_tx_pause;
 626         else
 627                 hw->fc.requested_mode = e1000_fc_full;
 628
 629         return 0;
 630 }
 631
 632 /**
 633  *  e1000e_setup_link - Setup flow control and link settings
 634  *  @hw: pointer to the HW structure
 635  *
 636  *  Determines which flow control settings to use, then configures flow
 637  *  control.  Calls the appropriate media-specific link configuration
 638  *  function.  Assuming the adapter has a valid link partner, a valid link
 639  *  should be established.  Assumes the hardware has previously been reset
 640  *  and the transmitter and receiver are not enabled.
 641  **/
 642 s32 e1000e_setup_link(struct e1000_hw *hw)
 643 {
 644         struct e1000_mac_info *mac = &hw->mac;
 645         s32 ret_val;
 646
 647         /*
 648          * In the case of the phy reset being blocked, we already have a link.
 649          * We do not need to set it up again.
 650          */
 651         if (e1000_check_reset_block(hw))
 652                 return 0;
 653
 654         /*
 655          * If requested flow control is set to default, set flow control
 656          * based on the EEPROM flow control settings.
 657          */
 658         if (hw->fc.requested_mode == e1000_fc_default) {
 659                 ret_val = e1000_set_default_fc_generic(hw);
 660                 if (ret_val)
 661                         return ret_val;
 662         }
 663
 664         /*
 665          * Save off the requested flow control mode for use later.  Depending
 666          * on the link partner's capabilities, we may or may not use this mode.
 667          */
 668         hw->fc.current_mode = hw->fc.requested_mode;
 669
 670         hw_dbg(hw, "After fix-ups FlowControl is now = %x\n",
 671                 hw->fc.current_mode);
 672
 673         /* Call the necessary media_type subroutine to configure the link. */
 674         ret_val = mac->ops.setup_physical_interface(hw);
 675         if (ret_val)
 676                 return ret_val;
 677
 678         /*
 679          * Initialize the flow control address, type, and PAUSE timer
 680          * registers to their default values.  This is done even if flow
 681          * control is disabled, because it does not hurt anything to
 682          * initialize these registers.
 683          */
 684         hw_dbg(hw, "Initializing the Flow Control address, type and timer regs\n");
 685         ew32(FCT, FLOW_CONTROL_TYPE);
 686         ew32(FCAH, FLOW_CONTROL_ADDRESS_HIGH);
 687         ew32(FCAL, FLOW_CONTROL_ADDRESS_LOW);
 688
 689         ew32(FCTTV, hw->fc.pause_time);
 690
 691         return e1000e_set_fc_watermarks(hw);
 692 }
 693
 694 /**
 695  *  e1000_commit_fc_settings_generic - Configure flow control
 696  *  @hw: pointer to the HW structure
 697  *
 698  *  Write the flow control settings to the Transmit Config Word Register (TXCW)
 699  *  base on the flow control settings in e1000_mac_info.
 700  **/
 701 static s32 e1000_commit_fc_settings_generic(struct e1000_hw *hw)
 702 {
 703         struct e1000_mac_info *mac = &hw->mac;
 704         u32 txcw;
 705
 706         /*
 707          * Check for a software override of the flow control settings, and
 708          * setup the device accordingly.  If auto-negotiation is enabled, then
 709          * software will have to set the "PAUSE" bits to the correct value in
 710          * the Transmit Config Word Register (TXCW) and re-start auto-
 711          * negotiation.  However, if auto-negotiation is disabled, then
 712          * software will have to manually configure the two flow control enable
 713          * bits in the CTRL register.
 714          *
 715          * The possible values of the "fc" parameter are:
 716          *      0:  Flow control is completely disabled
 717          *      1:  Rx flow control is enabled (we can receive pause frames,
 718          *        but not send pause frames).
 719          *      2:  Tx flow control is enabled (we can send pause frames but we
 720          *        do not support receiving pause frames).
 721          *      3:  Both Rx and Tx flow control (symmetric) are enabled.
 722          */
 723         switch (hw->fc.current_mode) {
 724         case e1000_fc_none:
 725                 /* Flow control completely disabled by a software over-ride. */
 726                 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD);
 727                 break;
 728         case e1000_fc_rx_pause:
 729                 /*
 730                  * Rx Flow control is enabled and Tx Flow control is disabled
 731                  * by a software over-ride. Since there really isn't a way to
 732                  * advertise that we are capable of Rx Pause ONLY, we will
 733                  * advertise that we support both symmetric and asymmetric Rx
 734                  * PAUSE.  Later, we will disable the adapter's ability to send
 735                  * PAUSE frames.
 736                  */
 737                 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
 738                 break;
 739         case e1000_fc_tx_pause:
 740                 /*
 741                  * Tx Flow control is enabled, and Rx Flow control is disabled,
 742                  * by a software over-ride.
 743                  */
 744                 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_ASM_DIR);
 745                 break;
 746         case e1000_fc_full:
 747                 /*
 748                  * Flow control (both Rx and Tx) is enabled by a software
 749                  * over-ride.
 750                  */
 751                 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
 752                 break;
 753         default:
 754                 hw_dbg(hw, "Flow control param set incorrectly\n");
 755                 return -E1000_ERR_CONFIG;
 756                 break;
 757         }
 758
 759         ew32(TXCW, txcw);
 760         mac->txcw = txcw;
 761
 762         return 0;
 763 }
 764
 765 /**
 766  *  e1000_poll_fiber_serdes_link_generic - Poll for link up
 767  *  @hw: pointer to the HW structure
 768  *
 769  *  Polls for link up by reading the status register, if link fails to come
 770  *  up with auto-negotiation, then the link is forced if a signal is detected.
 771  **/
 772 static s32 e1000_poll_fiber_serdes_link_generic(struct e1000_hw *hw)
 773 {
 774         struct e1000_mac_info *mac = &hw->mac;
 775         u32 i, status;
 776         s32 ret_val;
 777
 778         /*
 779          * If we have a signal (the cable is plugged in, or assumed true for
 780          * serdes media) then poll for a "Link-Up" indication in the Device
 781          * Status Register.  Time-out if a link isn't seen in 500 milliseconds
 782          * seconds (Auto-negotiation should complete in less than 500
 783          * milliseconds even if the other end is doing it in SW).
 784          */
 785         for (i = 0; i < FIBER_LINK_UP_LIMIT; i++) {
 786                 msleep(10);
 787                 status = er32(STATUS);
 788                 if (status & E1000_STATUS_LU)
 789                         break;
 790         }
 791         if (i == FIBER_LINK_UP_LIMIT) {
 792                 hw_dbg(hw, "Never got a valid link from auto-neg!!!\n");
 793                 mac->autoneg_failed = 1;
 794                 /*
 795                  * AutoNeg failed to achieve a link, so we'll call
 796                  * mac->check_for_link. This routine will force the
 797                  * link up if we detect a signal. This will allow us to
 798                  * communicate with non-autonegotiating link partners.
 799                  */
 800                 ret_val = mac->ops.check_for_link(hw);
 801                 if (ret_val) {
 802                         hw_dbg(hw, "Error while checking for link\n");
 803                         return ret_val;
 804                 }
 805                 mac->autoneg_failed = 0;
 806         } else {
 807                 mac->autoneg_failed = 0;
 808                 hw_dbg(hw, "Valid Link Found\n");
 809         }
 810
 811         return 0;
 812 }
 813
 814 /**
 815  *  e1000e_setup_fiber_serdes_link - Setup link for fiber/serdes
 816  *  @hw: pointer to the HW structure
 817  *
 818  *  Configures collision distance and flow control for fiber and serdes
 819  *  links.  Upon successful setup, poll for link.
 820  **/
 821 s32 e1000e_setup_fiber_serdes_link(struct e1000_hw *hw)
 822 {
 823         u32 ctrl;
 824         s32 ret_val;
 825
 826         ctrl = er32(CTRL);
 827
 828         /* Take the link out of reset */
 829         ctrl &= ~E1000_CTRL_LRST;
 830
 831         e1000e_config_collision_dist(hw);
 832
 833         ret_val = e1000_commit_fc_settings_generic(hw);
 834         if (ret_val)
 835                 return ret_val;
 836
 837         /*
 838          * Since auto-negotiation is enabled, take the link out of reset (the
 839          * link will be in reset, because we previously reset the chip). This
 840          * will restart auto-negotiation.  If auto-negotiation is successful
 841          * then the link-up status bit will be set and the flow control enable
 842          * bits (RFCE and TFCE) will be set according to their negotiated value.
 843          */
 844         hw_dbg(hw, "Auto-negotiation enabled\n");
 845
 846         ew32(CTRL, ctrl);
 847         e1e_flush();
 848         msleep(1);
 849
 850         /*
 851          * For these adapters, the SW definable pin 1 is set when the optics
 852          * detect a signal.  If we have a signal, then poll for a "Link-Up"
 853          * indication.
 854          */
 855         if (hw->phy.media_type == e1000_media_type_internal_serdes ||
 856             (er32(CTRL) & E1000_CTRL_SWDPIN1)) {
 857                 ret_val = e1000_poll_fiber_serdes_link_generic(hw);
 858         } else {
 859                 hw_dbg(hw, "No signal detected\n");
 860         }
 861
 862         return 0;
 863 }
 864
 865 /**
 866  *  e1000e_config_collision_dist - Configure collision distance
 867  *  @hw: pointer to the HW structure
 868  *
 869  *  Configures the collision distance to the default value and is used
 870  *  during link setup. Currently no func pointer exists and all
 871  *  implementations are handled in the generic version of this function.
 872  **/
 873 void e1000e_config_collision_dist(struct e1000_hw *hw)
 874 {
 875         u32 tctl;
 876
 877         tctl = er32(TCTL);
 878
 879         tctl &= ~E1000_TCTL_COLD;
 880         tctl |= E1000_COLLISION_DISTANCE << E1000_COLD_SHIFT;
 881
 882         ew32(TCTL, tctl);
 883         e1e_flush();
 884 }
 885
 886 /**
 887  *  e1000e_set_fc_watermarks - Set flow control high/low watermarks
 888  *  @hw: pointer to the HW structure
 889  *
 890  *  Sets the flow control high/low threshold (watermark) registers.  If
 891  *  flow control XON frame transmission is enabled, then set XON frame
 892  *  transmission as well.
 893  **/
 894 s32 e1000e_set_fc_watermarks(struct e1000_hw *hw)
 895 {
 896         u32 fcrtl = 0, fcrth = 0;
 897
 898         /*
 899          * Set the flow control receive threshold registers.  Normally,
 900          * these registers will be set to a default threshold that may be
 901          * adjusted later by the driver's runtime code.  However, if the
 902          * ability to transmit pause frames is not enabled, then these
 903          * registers will be set to 0.
 904          */
 905         if (hw->fc.current_mode & e1000_fc_tx_pause) {
 906                 /*
 907                  * We need to set up the Receive Threshold high and low water
 908                  * marks as well as (optionally) enabling the transmission of
 909                  * XON frames.
 910                  */
 911                 fcrtl = hw->fc.low_water;
 912                 fcrtl |= E1000_FCRTL_XONE;
 913                 fcrth = hw->fc.high_water;
 914         }
 915         ew32(FCRTL, fcrtl);
 916         ew32(FCRTH, fcrth);
 917
 918         return 0;
 919 }
 920
 921 /**
 922  *  e1000e_force_mac_fc - Force the MAC's flow control settings
 923  *  @hw: pointer to the HW structure
 924  *
 925  *  Force the MAC's flow control settings.  Sets the TFCE and RFCE bits in the
 926  *  device control register to reflect the adapter settings.  TFCE and RFCE
 927  *  need to be explicitly set by software when a copper PHY is used because
 928  *  autonegotiation is managed by the PHY rather than the MAC.  Software must
 929  *  also configure these bits when link is forced on a fiber connection.
 930  **/
 931 s32 e1000e_force_mac_fc(struct e1000_hw *hw)
 932 {
 933         u32 ctrl;
 934
 935         ctrl = er32(CTRL);
 936
 937         /*
 938          * Because we didn't get link via the internal auto-negotiation
 939          * mechanism (we either forced link or we got link via PHY
 940          * auto-neg), we have to manually enable/disable transmit an
 941          * receive flow control.
 942          *
 943          * The "Case" statement below enables/disable flow control
 944          * according to the "hw->fc.current_mode" parameter.
 945          *
 946          * The possible values of the "fc" parameter are:
 947          *      0:  Flow control is completely disabled
 948          *      1:  Rx flow control is enabled (we can receive pause
 949          *        frames but not send pause frames).
 950          *      2:  Tx flow control is enabled (we can send pause frames
 951          *        frames but we do not receive pause frames).
 952          *      3:  Both Rx and Tx flow control (symmetric) is enabled.
 953          *  other:  No other values should be possible at this point.
 954          */
 955         hw_dbg(hw, "hw->fc.current_mode = %u\n", hw->fc.current_mode);
 956
 957         switch (hw->fc.current_mode) {
 958         case e1000_fc_none:
 959                 ctrl &= (~(E1000_CTRL_TFCE | E1000_CTRL_RFCE));
 960                 break;
 961         case e1000_fc_rx_pause:
 962                 ctrl &= (~E1000_CTRL_TFCE);
 963                 ctrl |= E1000_CTRL_RFCE;
 964                 break;
 965         case e1000_fc_tx_pause:
 966                 ctrl &= (~E1000_CTRL_RFCE);
 967                 ctrl |= E1000_CTRL_TFCE;
 968                 break;
 969         case e1000_fc_full:
 970                 ctrl |= (E1000_CTRL_TFCE | E1000_CTRL_RFCE);
 971                 break;
 972         default:
 973                 hw_dbg(hw, "Flow control param set incorrectly\n");
 974                 return -E1000_ERR_CONFIG;
 975         }
 976
 977         ew32(CTRL, ctrl);
 978
 979         return 0;
 980 }
 981
 982 /**
 983  *  e1000e_config_fc_after_link_up - Configures flow control after link
 984  *  @hw: pointer to the HW structure
 985  *
 986  *  Checks the status of auto-negotiation after link up to ensure that the
 987  *  speed and duplex were not forced.  If the link needed to be forced, then
 988  *  flow control needs to be forced also.  If auto-negotiation is enabled
 989  *  and did not fail, then we configure flow control based on our link
 990  *  partner.
 991  **/
 992 s32 e1000e_config_fc_after_link_up(struct e1000_hw *hw)
 993 {
 994         struct e1000_mac_info *mac = &hw->mac;
 995         s32 ret_val = 0;
 996         u16 mii_status_reg, mii_nway_adv_reg, mii_nway_lp_ability_reg;
 997         u16 speed, duplex;
 998
 999         /*
1000          * Check for the case where we have fiber media and auto-neg failed
1001          * so we had to force link.  In this case, we need to force the
1002          * configuration of the MAC to match the "fc" parameter.
1003          */
1004         if (mac->autoneg_failed) {
1005                 if (hw->phy.media_type == e1000_media_type_fiber ||
1006                     hw->phy.media_type == e1000_media_type_internal_serdes)
1007                         ret_val = e1000e_force_mac_fc(hw);
1008         } else {
1009                 if (hw->phy.media_type == e1000_media_type_copper)
1010                         ret_val = e1000e_force_mac_fc(hw);
1011         }
1012
1013         if (ret_val) {
1014                 hw_dbg(hw, "Error forcing flow control settings\n");
1015                 return ret_val;
1016         }
1017
1018         /*
1019          * Check for the case where we have copper media and auto-neg is
1020          * enabled.  In this case, we need to check and see if Auto-Neg
1021          * has completed, and if so, how the PHY and link partner has
1022          * flow control configured.
1023          */
1024         if ((hw->phy.media_type == e1000_media_type_copper) && mac->autoneg) {
1025                 /*
1026                  * Read the MII Status Register and check to see if AutoNeg
1027                  * has completed.  We read this twice because this reg has
1028                  * some "sticky" (latched) bits.
1029                  */
1030                 ret_val = e1e_rphy(hw, PHY_STATUS, &mii_status_reg);
1031                 if (ret_val)
1032                         return ret_val;
1033                 ret_val = e1e_rphy(hw, PHY_STATUS, &mii_status_reg);
1034                 if (ret_val)
1035                         return ret_val;
1036
1037                 if (!(mii_status_reg & MII_SR_AUTONEG_COMPLETE)) {
1038                         hw_dbg(hw, "Copper PHY and Auto Neg "
1039                                  "has not completed.\n");
1040                         return ret_val;
1041                 }
1042
1043                 /*
1044                  * The AutoNeg process has completed, so we now need to
1045                  * read both the Auto Negotiation Advertisement
1046                  * Register (Address 4) and the Auto_Negotiation Base
1047                  * Page Ability Register (Address 5) to determine how
1048                  * flow control was negotiated.
1049                  */
1050                 ret_val = e1e_rphy(hw, PHY_AUTONEG_ADV, &mii_nway_adv_reg);
1051                 if (ret_val)
1052                         return ret_val;
1053                 ret_val = e1e_rphy(hw, PHY_LP_ABILITY, &mii_nway_lp_ability_reg);
1054                 if (ret_val)
1055                         return ret_val;
1056
1057                 /*
1058                  * Two bits in the Auto Negotiation Advertisement Register
1059                  * (Address 4) and two bits in the Auto Negotiation Base
1060                  * Page Ability Register (Address 5) determine flow control
1061                  * for both the PHY and the link partner.  The following
1062                  * table, taken out of the IEEE 802.3ab/D6.0 dated March 25,
1063                  * 1999, describes these PAUSE resolution bits and how flow
1064                  * control is determined based upon these settings.
1065                  * NOTE:  DC = Don't Care
1066                  *
1067                  *   LOCAL DEVICE  |   LINK PARTNER
1068                  * PAUSE | ASM_DIR | PAUSE | ASM_DIR | NIC Resolution
1069                  *-------|---------|-------|---------|--------------------
1070                  *   0   |    0    |  DC   |   DC    | e1000_fc_none
1071                  *   0   |    1    |   0   |   DC    | e1000_fc_none
1072                  *   0   |    1    |   1   |    0    | e1000_fc_none
1073                  *   0   |    1    |   1   |    1    | e1000_fc_tx_pause
1074                  *   1   |    0    |   0   |   DC    | e1000_fc_none
1075                  *   1   |   DC    |   1   |   DC    | e1000_fc_full
1076                  *   1   |    1    |   0   |    0    | e1000_fc_none
1077                  *   1   |    1    |   0   |    1    | e1000_fc_rx_pause
1078                  *
1079                  *
1080                  * Are both PAUSE bits set to 1?  If so, this implies
1081                  * Symmetric Flow Control is enabled at both ends.  The
1082                  * ASM_DIR bits are irrelevant per the spec.
1083                  *
1084                  * For Symmetric Flow Control:
1085                  *
1086                  *   LOCAL DEVICE  |   LINK PARTNER
1087                  * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1088                  *-------|---------|-------|---------|--------------------
1089                  *   1   |   DC    |   1   |   DC    | E1000_fc_full
1090                  *
1091                  */
1092                 if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
1093                     (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE)) {
1094                         /*
1095                          * Now we need to check if the user selected Rx ONLY
1096                          * of pause frames.  In this case, we had to advertise
1097                          * FULL flow control because we could not advertise Rx
1098                          * ONLY. Hence, we must now check to see if we need to
1099                          * turn OFF  the TRANSMISSION of PAUSE frames.
1100                          */
1101                         if (hw->fc.requested_mode == e1000_fc_full) {
1102                                 hw->fc.current_mode = e1000_fc_full;
1103                                 hw_dbg(hw, "Flow Control = FULL.\r\n");
1104                         } else {
1105                                 hw->fc.current_mode = e1000_fc_rx_pause;
1106                                 hw_dbg(hw, "Flow Control = "
1107                                          "RX PAUSE frames only.\r\n");
1108                         }
1109                 }
1110                 /*
1111                  * For receiving PAUSE frames ONLY.
1112                  *
1113                  *   LOCAL DEVICE  |   LINK PARTNER
1114                  * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1115                  *-------|---------|-------|---------|--------------------
1116                  *   0   |    1    |   1   |    1    | e1000_fc_tx_pause
1117                  *
1118                  */
1119                 else if (!(mii_nway_adv_reg & NWAY_AR_PAUSE) &&
1120                           (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
1121                           (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
1122                           (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
1123                         hw->fc.current_mode = e1000_fc_tx_pause;
1124                         hw_dbg(hw, "Flow Control = Tx PAUSE frames only.\r\n");
1125                 }
1126                 /*
1127                  * For transmitting PAUSE frames ONLY.
1128                  *
1129                  *   LOCAL DEVICE  |   LINK PARTNER
1130                  * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1131                  *-------|---------|-------|---------|--------------------
1132                  *   1   |    1    |   0   |    1    | e1000_fc_rx_pause
1133                  *
1134                  */
1135                 else if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
1136                          (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
1137                          !(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
1138                          (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
1139                         hw->fc.current_mode = e1000_fc_rx_pause;
1140                         hw_dbg(hw, "Flow Control = Rx PAUSE frames only.\r\n");
1141                 } else {
1142                         /*
1143                          * Per the IEEE spec, at this point flow control
1144                          * should be disabled.
1145                          */
1146                         hw->fc.current_mode = e1000_fc_none;
1147                         hw_dbg(hw, "Flow Control = NONE.\r\n");
1148                 }
1149
1150                 /*
1151                  * Now we need to do one last check...  If we auto-
1152                  * negotiated to HALF DUPLEX, flow control should not be
1153                  * enabled per IEEE 802.3 spec.
1154                  */
1155                 ret_val = mac->ops.get_link_up_info(hw, &speed, &duplex);
1156                 if (ret_val) {
1157                         hw_dbg(hw, "Error getting link speed and duplex\n");
1158                         return ret_val;
1159                 }
1160
1161                 if (duplex == HALF_DUPLEX)
1162                         hw->fc.current_mode = e1000_fc_none;
1163
1164                 /*
1165                  * Now we call a subroutine to actually force the MAC
1166                  * controller to use the correct flow control settings.
1167                  */
1168                 ret_val = e1000e_force_mac_fc(hw);
1169                 if (ret_val) {
1170                         hw_dbg(hw, "Error forcing flow control settings\n");
1171                         return ret_val;
1172                 }
1173         }
1174
1175         return 0;
1176 }
1177
1178 /**
1179  *  e1000e_get_speed_and_duplex_copper - Retrieve current speed/duplex
1180  *  @hw: pointer to the HW structure
1181  *  @speed: stores the current speed
1182  *  @duplex: stores the current duplex
1183  *
1184  *  Read the status register for the current speed/duplex and store the current
1185  *  speed and duplex for copper connections.
1186  **/
1187 s32 e1000e_get_speed_and_duplex_copper(struct e1000_hw *hw, u16 *speed, u16 *duplex)
1188 {
1189         u32 status;
1190
1191         status = er32(STATUS);
1192         if (status & E1000_STATUS_SPEED_1000) {
1193                 *speed = SPEED_1000;
1194                 hw_dbg(hw, "1000 Mbs, ");
1195         } else if (status & E1000_STATUS_SPEED_100) {
1196                 *speed = SPEED_100;
1197                 hw_dbg(hw, "100 Mbs, ");
1198         } else {
1199                 *speed = SPEED_10;
1200                 hw_dbg(hw, "10 Mbs, ");
1201         }
1202
1203         if (status & E1000_STATUS_FD) {
1204                 *duplex = FULL_DUPLEX;
1205                 hw_dbg(hw, "Full Duplex\n");
1206         } else {
1207                 *duplex = HALF_DUPLEX;
1208                 hw_dbg(hw, "Half Duplex\n");
1209         }
1210
1211         return 0;
1212 }
1213
1214 /**
1215  *  e1000e_get_speed_and_duplex_fiber_serdes - Retrieve current speed/duplex
1216  *  @hw: pointer to the HW structure
1217  *  @speed: stores the current speed
1218  *  @duplex: stores the current duplex
1219  *
1220  *  Sets the speed and duplex to gigabit full duplex (the only possible option)
1221  *  for fiber/serdes links.
1222  **/
1223 s32 e1000e_get_speed_and_duplex_fiber_serdes(struct e1000_hw *hw, u16 *speed, u16 *duplex)
1224 {
1225         *speed = SPEED_1000;
1226         *duplex = FULL_DUPLEX;
1227
1228         return 0;
1229 }
1230
1231 /**
1232  *  e1000e_get_hw_semaphore - Acquire hardware semaphore
1233  *  @hw: pointer to the HW structure
1234  *
1235  *  Acquire the HW semaphore to access the PHY or NVM
1236  **/
1237 s32 e1000e_get_hw_semaphore(struct e1000_hw *hw)
1238 {
1239         u32 swsm;
1240         s32 timeout = hw->nvm.word_size + 1;
1241         s32 i = 0;
1242
1243         /* Get the SW semaphore */
1244         while (i < timeout) {
1245                 swsm = er32(SWSM);
1246                 if (!(swsm & E1000_SWSM_SMBI))
1247                         break;
1248
1249                 udelay(50);
1250                 i++;
1251         }
1252
1253         if (i == timeout) {
1254                 hw_dbg(hw, "Driver can't access device - SMBI bit is set.\n");
1255                 return -E1000_ERR_NVM;
1256         }
1257
1258         /* Get the FW semaphore. */
1259         for (i = 0; i < timeout; i++) {
1260                 swsm = er32(SWSM);
1261                 ew32(SWSM, swsm | E1000_SWSM_SWESMBI);
1262
1263                 /* Semaphore acquired if bit latched */
1264                 if (er32(SWSM) & E1000_SWSM_SWESMBI)
1265                         break;
1266
1267                 udelay(50);
1268         }
1269
1270         if (i == timeout) {
1271                 /* Release semaphores */
1272                 e1000e_put_hw_semaphore(hw);
1273                 hw_dbg(hw, "Driver can't access the NVM\n");
1274                 return -E1000_ERR_NVM;
1275         }
1276
1277         return 0;
1278 }
1279
1280 /**
1281  *  e1000e_put_hw_semaphore - Release hardware semaphore
1282  *  @hw: pointer to the HW structure
1283  *
1284  *  Release hardware semaphore used to access the PHY or NVM
1285  **/
1286 void e1000e_put_hw_semaphore(struct e1000_hw *hw)
1287 {
1288         u32 swsm;
1289
1290         swsm = er32(SWSM);
1291         swsm &= ~(E1000_SWSM_SMBI | E1000_SWSM_SWESMBI);
1292         ew32(SWSM, swsm);
1293 }
1294
1295 /**
1296  *  e1000e_get_auto_rd_done - Check for auto read completion
1297  *  @hw: pointer to the HW structure
1298  *
1299  *  Check EEPROM for Auto Read done bit.
1300  **/
1301 s32 e1000e_get_auto_rd_done(struct e1000_hw *hw)
1302 {
1303         s32 i = 0;
1304
1305         while (i < AUTO_READ_DONE_TIMEOUT) {
1306                 if (er32(EECD) & E1000_EECD_AUTO_RD)
1307                         break;
1308                 msleep(1);
1309                 i++;
1310         }
1311
1312         if (i == AUTO_READ_DONE_TIMEOUT) {
1313                 hw_dbg(hw, "Auto read by HW from NVM has not completed.\n");
1314                 return -E1000_ERR_RESET;
1315         }
1316
1317         return 0;
1318 }
1319
1320 /**
1321  *  e1000e_valid_led_default - Verify a valid default LED config
1322  *  @hw: pointer to the HW structure
1323  *  @data: pointer to the NVM (EEPROM)
1324  *
1325  *  Read the EEPROM for the current default LED configuration.  If the
1326  *  LED configuration is not valid, set to a valid LED configuration.
1327  **/
1328 s32 e1000e_valid_led_default(struct e1000_hw *hw, u16 *data)
1329 {
1330         s32 ret_val;
1331
1332         ret_val = e1000_read_nvm(hw, NVM_ID_LED_SETTINGS, 1, data);
1333         if (ret_val) {
1334                 hw_dbg(hw, "NVM Read Error\n");
1335                 return ret_val;
1336         }
1337
1338         if (*data == ID_LED_RESERVED_0000 || *data == ID_LED_RESERVED_FFFF)
1339                 *data = ID_LED_DEFAULT;
1340
1341         return 0;
1342 }
1343
1344 /**
1345  *  e1000e_id_led_init -
1346  *  @hw: pointer to the HW structure
1347  *
1348  **/
1349 s32 e1000e_id_led_init(struct e1000_hw *hw)
1350 {
1351         struct e1000_mac_info *mac = &hw->mac;
1352         s32 ret_val;
1353         const u32 ledctl_mask = 0x000000FF;
1354         const u32 ledctl_on = E1000_LEDCTL_MODE_LED_ON;
1355         const u32 ledctl_off = E1000_LEDCTL_MODE_LED_OFF;
1356         u16 data, i, temp;
1357         const u16 led_mask = 0x0F;
1358
1359         ret_val = hw->nvm.ops.valid_led_default(hw, &data);
1360         if (ret_val)
1361                 return ret_val;
1362
1363         mac->ledctl_default = er32(LEDCTL);
1364         mac->ledctl_mode1 = mac->ledctl_default;
1365         mac->ledctl_mode2 = mac->ledctl_default;
1366
1367         for (i = 0; i < 4; i++) {
1368                 temp = (data >> (i << 2)) & led_mask;
1369                 switch (temp) {
1370                 case ID_LED_ON1_DEF2:
1371                 case ID_LED_ON1_ON2:
1372                 case ID_LED_ON1_OFF2:
1373                         mac->ledctl_mode1 &= ~(ledctl_mask << (i << 3));
1374                         mac->ledctl_mode1 |= ledctl_on << (i << 3);
1375                         break;
1376                 case ID_LED_OFF1_DEF2:
1377                 case ID_LED_OFF1_ON2:
1378                 case ID_LED_OFF1_OFF2:
1379                         mac->ledctl_mode1 &= ~(ledctl_mask << (i << 3));
1380                         mac->ledctl_mode1 |= ledctl_off << (i << 3);
1381                         break;
1382                 default:
1383                         /* Do nothing */
1384                         break;
1385                 }
1386                 switch (temp) {
1387                 case ID_LED_DEF1_ON2:
1388                 case ID_LED_ON1_ON2:
1389                 case ID_LED_OFF1_ON2:
1390                         mac->ledctl_mode2 &= ~(ledctl_mask << (i << 3));
1391                         mac->ledctl_mode2 |= ledctl_on << (i << 3);
1392                         break;
1393                 case ID_LED_DEF1_OFF2:
1394                 case ID_LED_ON1_OFF2:
1395                 case ID_LED_OFF1_OFF2:
1396                         mac->ledctl_mode2 &= ~(ledctl_mask << (i << 3));
1397                         mac->ledctl_mode2 |= ledctl_off << (i << 3);
1398                         break;
1399                 default:
1400                         /* Do nothing */
1401                         break;
1402                 }
1403         }
1404
1405         return 0;
1406 }
1407
1408 /**
1409  *  e1000e_setup_led_generic - Configures SW controllable LED
1410  *  @hw: pointer to the HW structure
1411  *
1412  *  This prepares the SW controllable LED for use and saves the current state
1413  *  of the LED so it can be later restored.
1414  **/
1415 s32 e1000e_setup_led_generic(struct e1000_hw *hw)
1416 {
1417         u32 ledctl;
1418
1419         if (hw->mac.ops.setup_led != e1000e_setup_led_generic) {
1420                 return -E1000_ERR_CONFIG;
1421         }
1422
1423         if (hw->phy.media_type == e1000_media_type_fiber) {
1424                 ledctl = er32(LEDCTL);
1425                 hw->mac.ledctl_default = ledctl;
1426                 /* Turn off LED0 */
1427                 ledctl &= ~(E1000_LEDCTL_LED0_IVRT |
1428                             E1000_LEDCTL_LED0_BLINK |
1429                             E1000_LEDCTL_LED0_MODE_MASK);
1430                 ledctl |= (E1000_LEDCTL_MODE_LED_OFF <<
1431                            E1000_LEDCTL_LED0_MODE_SHIFT);
1432                 ew32(LEDCTL, ledctl);
1433         } else if (hw->phy.media_type == e1000_media_type_copper) {
1434                 ew32(LEDCTL, hw->mac.ledctl_mode1);
1435         }
1436
1437         return 0;
1438 }
1439
1440 /**
1441  *  e1000e_cleanup_led_generic - Set LED config to default operation
1442  *  @hw: pointer to the HW structure
1443  *
1444  *  Remove the current LED configuration and set the LED configuration
1445  *  to the default value, saved from the EEPROM.
1446  **/
1447 s32 e1000e_cleanup_led_generic(struct e1000_hw *hw)
1448 {
1449         ew32(LEDCTL, hw->mac.ledctl_default);
1450         return 0;
1451 }
1452
1453 /**
1454  *  e1000e_blink_led - Blink LED
1455  *  @hw: pointer to the HW structure
1456  *
1457  *  Blink the LEDs which are set to be on.
1458  **/
1459 s32 e1000e_blink_led(struct e1000_hw *hw)
1460 {
1461         u32 ledctl_blink = 0;
1462         u32 i;
1463
1464         if (hw->phy.media_type == e1000_media_type_fiber) {
1465                 /* always blink LED0 for PCI-E fiber */
1466                 ledctl_blink = E1000_LEDCTL_LED0_BLINK |
1467                      (E1000_LEDCTL_MODE_LED_ON << E1000_LEDCTL_LED0_MODE_SHIFT);
1468         } else {
1469                 /*
1470                  * set the blink bit for each LED that's "on" (0x0E)
1471                  * in ledctl_mode2
1472                  */
1473                 ledctl_blink = hw->mac.ledctl_mode2;
1474                 for (i = 0; i < 4; i++)
1475                         if (((hw->mac.ledctl_mode2 >> (i * 8)) & 0xFF) ==
1476                             E1000_LEDCTL_MODE_LED_ON)
1477                                 ledctl_blink |= (E1000_LEDCTL_LED0_BLINK <<
1478                                                  (i * 8));
1479         }
1480
1481         ew32(LEDCTL, ledctl_blink);
1482
1483         return 0;
1484 }
1485
1486 /**
1487  *  e1000e_led_on_generic - Turn LED on
1488  *  @hw: pointer to the HW structure
1489  *
1490  *  Turn LED on.
1491  **/
1492 s32 e1000e_led_on_generic(struct e1000_hw *hw)
1493 {
1494         u32 ctrl;
1495
1496         switch (hw->phy.media_type) {
1497         case e1000_media_type_fiber:
1498                 ctrl = er32(CTRL);
1499                 ctrl &= ~E1000_CTRL_SWDPIN0;
1500                 ctrl |= E1000_CTRL_SWDPIO0;
1501                 ew32(CTRL, ctrl);
1502                 break;
1503         case e1000_media_type_copper:
1504                 ew32(LEDCTL, hw->mac.ledctl_mode2);
1505                 break;
1506         default:
1507                 break;
1508         }
1509
1510         return 0;
1511 }
1512
1513 /**
1514  *  e1000e_led_off_generic - Turn LED off
1515  *  @hw: pointer to the HW structure
1516  *
1517  *  Turn LED off.
1518  **/
1519 s32 e1000e_led_off_generic(struct e1000_hw *hw)
1520 {
1521         u32 ctrl;
1522
1523         switch (hw->phy.media_type) {
1524         case e1000_media_type_fiber:
1525                 ctrl = er32(CTRL);
1526                 ctrl |= E1000_CTRL_SWDPIN0;
1527                 ctrl |= E1000_CTRL_SWDPIO0;
1528                 ew32(CTRL, ctrl);
1529                 break;
1530         case e1000_media_type_copper:
1531                 ew32(LEDCTL, hw->mac.ledctl_mode1);
1532                 break;
1533         default:
1534                 break;
1535         }
1536
1537         return 0;
1538 }
1539
1540 /**
1541  *  e1000e_set_pcie_no_snoop - Set PCI-express capabilities
1542  *  @hw: pointer to the HW structure
1543  *  @no_snoop: bitmap of snoop events
1544  *
1545  *  Set the PCI-express register to snoop for events enabled in 'no_snoop'.
1546  **/
1547 void e1000e_set_pcie_no_snoop(struct e1000_hw *hw, u32 no_snoop)
1548 {
1549         u32 gcr;
1550
1551         if (no_snoop) {
1552                 gcr = er32(GCR);
1553                 gcr &= ~(PCIE_NO_SNOOP_ALL);
1554                 gcr |= no_snoop;
1555                 ew32(GCR, gcr);
1556         }
1557 }
1558
1559 /**
1560  *  e1000e_disable_pcie_master - Disables PCI-express master access
1561  *  @hw: pointer to the HW structure
1562  *
1563  *  Returns 0 if successful, else returns -10
1564  *  (-E1000_ERR_MASTER_REQUESTS_PENDING) if master disable bit has not caused
1565  *  the master requests to be disabled.
1566  *
1567  *  Disables PCI-Express master access and verifies there are no pending
1568  *  requests.
1569  **/
1570 s32 e1000e_disable_pcie_master(struct e1000_hw *hw)
1571 {
1572         u32 ctrl;
1573         s32 timeout = MASTER_DISABLE_TIMEOUT;
1574
1575         ctrl = er32(CTRL);
1576         ctrl |= E1000_CTRL_GIO_MASTER_DISABLE;
1577         ew32(CTRL, ctrl);
1578
1579         while (timeout) {
1580                 if (!(er32(STATUS) &
1581                       E1000_STATUS_GIO_MASTER_ENABLE))
1582                         break;
1583                 udelay(100);
1584                 timeout--;
1585         }
1586
1587         if (!timeout) {
1588                 hw_dbg(hw, "Master requests are pending.\n");
1589                 return -E1000_ERR_MASTER_REQUESTS_PENDING;
1590         }
1591
1592         return 0;
1593 }
1594
1595 /**
1596  *  e1000e_reset_adaptive - Reset Adaptive Interframe Spacing
1597  *  @hw: pointer to the HW structure
1598  *
1599  *  Reset the Adaptive Interframe Spacing throttle to default values.
1600  **/
1601 void e1000e_reset_adaptive(struct e1000_hw *hw)
1602 {
1603         struct e1000_mac_info *mac = &hw->mac;
1604
1605         mac->current_ifs_val = 0;
1606         mac->ifs_min_val = IFS_MIN;
1607         mac->ifs_max_val = IFS_MAX;
1608         mac->ifs_step_size = IFS_STEP;
1609         mac->ifs_ratio = IFS_RATIO;
1610
1611         mac->in_ifs_mode = 0;
1612         ew32(AIT, 0);
1613 }
1614
1615 /**
1616  *  e1000e_update_adaptive - Update Adaptive Interframe Spacing
1617  *  @hw: pointer to the HW structure
1618  *
1619  *  Update the Adaptive Interframe Spacing Throttle value based on the
1620  *  time between transmitted packets and time between collisions.
1621  **/
1622 void e1000e_update_adaptive(struct e1000_hw *hw)
1623 {
1624         struct e1000_mac_info *mac = &hw->mac;
1625
1626         if ((mac->collision_delta * mac->ifs_ratio) > mac->tx_packet_delta) {
1627                 if (mac->tx_packet_delta > MIN_NUM_XMITS) {
1628                         mac->in_ifs_mode = 1;
1629                         if (mac->current_ifs_val < mac->ifs_max_val) {
1630                                 if (!mac->current_ifs_val)
1631                                         mac->current_ifs_val = mac->ifs_min_val;
1632                                 else
1633                                         mac->current_ifs_val +=
1634                                                 mac->ifs_step_size;
1635                                 ew32(AIT, mac->current_ifs_val);
1636                         }
1637                 }
1638         } else {
1639                 if (mac->in_ifs_mode &&
1640                     (mac->tx_packet_delta <= MIN_NUM_XMITS)) {
1641                         mac->current_ifs_val = 0;
1642                         mac->in_ifs_mode = 0;
1643                         ew32(AIT, 0);
1644                 }
1645         }
1646 }
1647
1648 /**
1649  *  e1000_raise_eec_clk - Raise EEPROM clock
1650  *  @hw: pointer to the HW structure
1651  *  @eecd: pointer to the EEPROM
1652  *
1653  *  Enable/Raise the EEPROM clock bit.
1654  **/
1655 static void e1000_raise_eec_clk(struct e1000_hw *hw, u32 *eecd)
1656 {
1657         *eecd = *eecd | E1000_EECD_SK;
1658         ew32(EECD, *eecd);
1659         e1e_flush();
1660         udelay(hw->nvm.delay_usec);
1661 }
1662
1663 /**
1664  *  e1000_lower_eec_clk - Lower EEPROM clock
1665  *  @hw: pointer to the HW structure
1666  *  @eecd: pointer to the EEPROM
1667  *
1668  *  Clear/Lower the EEPROM clock bit.
1669  **/
1670 static void e1000_lower_eec_clk(struct e1000_hw *hw, u32 *eecd)
1671 {
1672         *eecd = *eecd & ~E1000_EECD_SK;
1673         ew32(EECD, *eecd);
1674         e1e_flush();
1675         udelay(hw->nvm.delay_usec);
1676 }
1677
1678 /**
1679  *  e1000_shift_out_eec_bits - Shift data bits our to the EEPROM
1680  *  @hw: pointer to the HW structure
1681  *  @data: data to send to the EEPROM
1682  *  @count: number of bits to shift out
1683  *
1684  *  We need to shift 'count' bits out to the EEPROM.  So, the value in the
1685  *  "data" parameter will be shifted out to the EEPROM one bit at a time.
1686  *  In order to do this, "data" must be broken down into bits.
1687  **/
1688 static void e1000_shift_out_eec_bits(struct e1000_hw *hw, u16 data, u16 count)
1689 {
1690         struct e1000_nvm_info *nvm = &hw->nvm;
1691         u32 eecd = er32(EECD);
1692         u32 mask;
1693
1694         mask = 0x01 << (count - 1);
1695         if (nvm->type == e1000_nvm_eeprom_spi)
1696                 eecd |= E1000_EECD_DO;
1697
1698         do {
1699                 eecd &= ~E1000_EECD_DI;
1700
1701                 if (data & mask)
1702                         eecd |= E1000_EECD_DI;
1703
1704                 ew32(EECD, eecd);
1705                 e1e_flush();
1706
1707                 udelay(nvm->delay_usec);
1708
1709                 e1000_raise_eec_clk(hw, &eecd);
1710                 e1000_lower_eec_clk(hw, &eecd);
1711
1712                 mask >>= 1;
1713         } while (mask);
1714
1715         eecd &= ~E1000_EECD_DI;
1716         ew32(EECD, eecd);
1717 }
1718
1719 /**
1720  *  e1000_shift_in_eec_bits - Shift data bits in from the EEPROM
1721  *  @hw: pointer to the HW structure
1722  *  @count: number of bits to shift in
1723  *
1724  *  In order to read a register from the EEPROM, we need to shift 'count' bits
1725  *  in from the EEPROM.  Bits are "shifted in" by raising the clock input to
1726  *  the EEPROM (setting the SK bit), and then reading the value of the data out
1727  *  "DO" bit.  During this "shifting in" process the data in "DI" bit should
1728  *  always be clear.
1729  **/
1730 static u16 e1000_shift_in_eec_bits(struct e1000_hw *hw, u16 count)
1731 {
1732         u32 eecd;
1733         u32 i;
1734         u16 data;
1735
1736         eecd = er32(EECD);
1737
1738         eecd &= ~(E1000_EECD_DO | E1000_EECD_DI);
1739         data = 0;
1740
1741         for (i = 0; i < count; i++) {
1742                 data <<= 1;
1743                 e1000_raise_eec_clk(hw, &eecd);
1744
1745                 eecd = er32(EECD);
1746
1747                 eecd &= ~E1000_EECD_DI;
1748                 if (eecd & E1000_EECD_DO)
1749                         data |= 1;
1750
1751                 e1000_lower_eec_clk(hw, &eecd);
1752         }
1753
1754         return data;
1755 }
1756
1757 /**
1758  *  e1000e_poll_eerd_eewr_done - Poll for EEPROM read/write completion
1759  *  @hw: pointer to the HW structure
1760  *  @ee_reg: EEPROM flag for polling
1761  *
1762  *  Polls the EEPROM status bit for either read or write completion based
1763  *  upon the value of 'ee_reg'.
1764  **/
1765 s32 e1000e_poll_eerd_eewr_done(struct e1000_hw *hw, int ee_reg)
1766 {
1767         u32 attempts = 100000;
1768         u32 i, reg = 0;
1769
1770         for (i = 0; i < attempts; i++) {
1771                 if (ee_reg == E1000_NVM_POLL_READ)
1772                         reg = er32(EERD);
1773                 else
1774                         reg = er32(EEWR);
1775
1776                 if (reg & E1000_NVM_RW_REG_DONE)
1777                         return 0;
1778
1779                 udelay(5);
1780         }
1781
1782         return -E1000_ERR_NVM;
1783 }
1784
1785 /**
1786  *  e1000e_acquire_nvm - Generic request for access to EEPROM
1787  *  @hw: pointer to the HW structure
1788  *
1789  *  Set the EEPROM access request bit and wait for EEPROM access grant bit.
1790  *  Return successful if access grant bit set, else clear the request for
1791  *  EEPROM access and return -E1000_ERR_NVM (-1).
1792  **/
1793 s32 e1000e_acquire_nvm(struct e1000_hw *hw)
1794 {
1795         u32 eecd = er32(EECD);
1796         s32 timeout = E1000_NVM_GRANT_ATTEMPTS;
1797
1798         ew32(EECD, eecd | E1000_EECD_REQ);
1799         eecd = er32(EECD);
1800
1801         while (timeout) {
1802                 if (eecd & E1000_EECD_GNT)
1803                         break;
1804                 udelay(5);
1805                 eecd = er32(EECD);
1806                 timeout--;
1807         }
1808
1809         if (!timeout) {
1810                 eecd &= ~E1000_EECD_REQ;
1811                 ew32(EECD, eecd);
1812                 hw_dbg(hw, "Could not acquire NVM grant\n");
1813                 return -E1000_ERR_NVM;
1814         }
1815
1816         return 0;
1817 }
1818
1819 /**
1820  *  e1000_standby_nvm - Return EEPROM to standby state
1821  *  @hw: pointer to the HW structure
1822  *
1823  *  Return the EEPROM to a standby state.
1824  **/
1825 static void e1000_standby_nvm(struct e1000_hw *hw)
1826 {
1827         struct e1000_nvm_info *nvm = &hw->nvm;
1828         u32 eecd = er32(EECD);
1829
1830         if (nvm->type == e1000_nvm_eeprom_spi) {
1831                 /* Toggle CS to flush commands */
1832                 eecd |= E1000_EECD_CS;
1833                 ew32(EECD, eecd);
1834                 e1e_flush();
1835                 udelay(nvm->delay_usec);
1836                 eecd &= ~E1000_EECD_CS;
1837                 ew32(EECD, eecd);
1838                 e1e_flush();
1839                 udelay(nvm->delay_usec);
1840         }
1841 }
1842
1843 /**
1844  *  e1000_stop_nvm - Terminate EEPROM command
1845  *  @hw: pointer to the HW structure
1846  *
1847  *  Terminates the current command by inverting the EEPROM's chip select pin.
1848  **/
1849 static void e1000_stop_nvm(struct e1000_hw *hw)
1850 {
1851         u32 eecd;
1852
1853         eecd = er32(EECD);
1854         if (hw->nvm.type == e1000_nvm_eeprom_spi) {
1855                 /* Pull CS high */
1856                 eecd |= E1000_EECD_CS;
1857                 e1000_lower_eec_clk(hw, &eecd);
1858         }
1859 }
1860
1861 /**
1862  *  e1000e_release_nvm - Release exclusive access to EEPROM
1863  *  @hw: pointer to the HW structure
1864  *
1865  *  Stop any current commands to the EEPROM and clear the EEPROM request bit.
1866  **/
1867 void e1000e_release_nvm(struct e1000_hw *hw)
1868 {
1869         u32 eecd;
1870
1871         e1000_stop_nvm(hw);
1872
1873         eecd = er32(EECD);
1874         eecd &= ~E1000_EECD_REQ;
1875         ew32(EECD, eecd);
1876 }
1877
1878 /**
1879  *  e1000_ready_nvm_eeprom - Prepares EEPROM for read/write
1880  *  @hw: pointer to the HW structure
1881  *
1882  *  Setups the EEPROM for reading and writing.
1883  **/
1884 static s32 e1000_ready_nvm_eeprom(struct e1000_hw *hw)
1885 {
1886         struct e1000_nvm_info *nvm = &hw->nvm;
1887         u32 eecd = er32(EECD);
1888         u16 timeout = 0;
1889         u8 spi_stat_reg;
1890
1891         if (nvm->type == e1000_nvm_eeprom_spi) {
1892                 /* Clear SK and CS */
1893                 eecd &= ~(E1000_EECD_CS | E1000_EECD_SK);
1894                 ew32(EECD, eecd);
1895                 udelay(1);
1896                 timeout = NVM_MAX_RETRY_SPI;
1897
1898                 /*
1899                  * Read "Status Register" repeatedly until the LSB is cleared.
1900                  * The EEPROM will signal that the command has been completed
1901                  * by clearing bit 0 of the internal status register.  If it's
1902                  * not cleared within 'timeout', then error out.
1903                  */
1904                 while (timeout) {
1905                         e1000_shift_out_eec_bits(hw, NVM_RDSR_OPCODE_SPI,
1906                                                  hw->nvm.opcode_bits);
1907                         spi_stat_reg = (u8)e1000_shift_in_eec_bits(hw, 8);
1908                         if (!(spi_stat_reg & NVM_STATUS_RDY_SPI))
1909                                 break;
1910
1911                         udelay(5);
1912                         e1000_standby_nvm(hw);
1913                         timeout--;
1914                 }
1915
1916                 if (!timeout) {
1917                         hw_dbg(hw, "SPI NVM Status error\n");
1918                         return -E1000_ERR_NVM;
1919                 }
1920         }
1921
1922         return 0;
1923 }
1924
1925 /**
1926  *  e1000e_read_nvm_eerd - Reads EEPROM using EERD register
1927  *  @hw: pointer to the HW structure
1928  *  @offset: offset of word in the EEPROM to read
1929  *  @words: number of words to read
1930  *  @data: word read from the EEPROM
1931  *
1932  *  Reads a 16 bit word from the EEPROM using the EERD register.
1933  **/
1934 s32 e1000e_read_nvm_eerd(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
1935 {
1936         struct e1000_nvm_info *nvm = &hw->nvm;
1937         u32 i, eerd = 0;
1938         s32 ret_val = 0;
1939
1940         /*
1941          * A check for invalid values:  offset too large, too many words,
1942          * too many words for the offset, and not enough words.
1943          */
1944         if ((offset >= nvm->word_size) || (words > (nvm->word_size - offset)) ||
1945             (words == 0)) {
1946                 hw_dbg(hw, "nvm parameter(s) out of bounds\n");
1947                 return -E1000_ERR_NVM;
1948         }
1949
1950         for (i = 0; i < words; i++) {
1951                 eerd = ((offset+i) << E1000_NVM_RW_ADDR_SHIFT) +
1952                        E1000_NVM_RW_REG_START;
1953
1954                 ew32(EERD, eerd);
1955                 ret_val = e1000e_poll_eerd_eewr_done(hw, E1000_NVM_POLL_READ);
1956                 if (ret_val)
1957                         break;
1958
1959                 data[i] = (er32(EERD) >> E1000_NVM_RW_REG_DATA);
1960         }
1961
1962         return ret_val;
1963 }
1964
1965 /**
1966  *  e1000e_write_nvm_spi - Write to EEPROM using SPI
1967  *  @hw: pointer to the HW structure
1968  *  @offset: offset within the EEPROM to be written to
1969  *  @words: number of words to write
1970  *  @data: 16 bit word(s) to be written to the EEPROM
1971  *
1972  *  Writes data to EEPROM at offset using SPI interface.
1973  *
1974  *  If e1000e_update_nvm_checksum is not called after this function , the
1975  *  EEPROM will most likely contain an invalid checksum.
1976  **/
1977 s32 e1000e_write_nvm_spi(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
1978 {
1979         struct e1000_nvm_info *nvm = &hw->nvm;
1980         s32 ret_val;
1981         u16 widx = 0;
1982
1983         /*
1984          * A check for invalid values:  offset too large, too many words,
1985          * and not enough words.
1986          */
1987         if ((offset >= nvm->word_size) || (words > (nvm->word_size - offset)) ||
1988             (words == 0)) {
1989                 hw_dbg(hw, "nvm parameter(s) out of bounds\n");
1990                 return -E1000_ERR_NVM;
1991         }
1992
1993         ret_val = nvm->ops.acquire_nvm(hw);
1994         if (ret_val)
1995                 return ret_val;
1996
1997         msleep(10);
1998
1999         while (widx < words) {
2000                 u8 write_opcode = NVM_WRITE_OPCODE_SPI;
2001
2002                 ret_val = e1000_ready_nvm_eeprom(hw);
2003                 if (ret_val) {
2004                         nvm->ops.release_nvm(hw);
2005                         return ret_val;
2006                 }
2007
2008                 e1000_standby_nvm(hw);
2009
2010                 /* Send the WRITE ENABLE command (8 bit opcode) */
2011                 e1000_shift_out_eec_bits(hw, NVM_WREN_OPCODE_SPI,
2012                                          nvm->opcode_bits);
2013
2014                 e1000_standby_nvm(hw);
2015
2016                 /*
2017                  * Some SPI eeproms use the 8th address bit embedded in the
2018                  * opcode
2019                  */
2020                 if ((nvm->address_bits == 8) && (offset >= 128))
2021                         write_opcode |= NVM_A8_OPCODE_SPI;
2022
2023                 /* Send the Write command (8-bit opcode + addr) */
2024                 e1000_shift_out_eec_bits(hw, write_opcode, nvm->opcode_bits);
2025                 e1000_shift_out_eec_bits(hw, (u16)((offset + widx) * 2),
2026                                          nvm->address_bits);
2027
2028                 /* Loop to allow for up to whole page write of eeprom */
2029                 while (widx < words) {
2030                         u16 word_out = data[widx];
2031                         word_out = (word_out >> 8) | (word_out << 8);
2032                         e1000_shift_out_eec_bits(hw, word_out, 16);
2033                         widx++;
2034
2035                         if ((((offset + widx) * 2) % nvm->page_size) == 0) {
2036                                 e1000_standby_nvm(hw);
2037                                 break;
2038                         }
2039                 }
2040         }
2041
2042         msleep(10);
2043         nvm->ops.release_nvm(hw);
2044         return 0;
2045 }
2046
2047 /**
2048  *  e1000e_read_mac_addr - Read device MAC address
2049  *  @hw: pointer to the HW structure
2050  *
2051  *  Reads the device MAC address from the EEPROM and stores the value.
2052  *  Since devices with two ports use the same EEPROM, we increment the
2053  *  last bit in the MAC address for the second port.
2054  **/
2055 s32 e1000e_read_mac_addr(struct e1000_hw *hw)
2056 {
2057         s32 ret_val;
2058         u16 offset, nvm_data, i;
2059         u16 mac_addr_offset = 0;
2060
2061         if (hw->mac.type == e1000_82571) {
2062                 /* Check for an alternate MAC address.  An alternate MAC
2063                  * address can be setup by pre-boot software and must be
2064                  * treated like a permanent address and must override the
2065                  * actual permanent MAC address.*/
2066                 ret_val = e1000_read_nvm(hw, NVM_ALT_MAC_ADDR_PTR, 1,
2067                                          &mac_addr_offset);
2068                 if (ret_val) {
2069                         hw_dbg(hw, "NVM Read Error\n");
2070                         return ret_val;
2071                 }
2072                 if (mac_addr_offset == 0xFFFF)
2073                         mac_addr_offset = 0;
2074
2075                 if (mac_addr_offset) {
2076                         if (hw->bus.func == E1000_FUNC_1)
2077                                 mac_addr_offset += ETH_ALEN/sizeof(u16);
2078
2079                         /* make sure we have a valid mac address here
2080                         * before using it */
2081                         ret_val = e1000_read_nvm(hw, mac_addr_offset, 1,
2082                                                  &nvm_data);
2083                         if (ret_val) {
2084                                 hw_dbg(hw, "NVM Read Error\n");
2085                                 return ret_val;
2086                         }
2087                         if (nvm_data & 0x0001)
2088                                 mac_addr_offset = 0;
2089                 }
2090
2091                 if (mac_addr_offset)
2092                 hw->dev_spec.e82571.alt_mac_addr_is_present = 1;
2093         }
2094
2095         for (i = 0; i < ETH_ALEN; i += 2) {
2096                 offset = mac_addr_offset + (i >> 1);
2097                 ret_val = e1000_read_nvm(hw, offset, 1, &nvm_data);
2098                 if (ret_val) {
2099                         hw_dbg(hw, "NVM Read Error\n");
2100                         return ret_val;
2101                 }
2102                 hw->mac.perm_addr[i] = (u8)(nvm_data & 0xFF);
2103                 hw->mac.perm_addr[i+1] = (u8)(nvm_data >> 8);
2104         }
2105
2106         /* Flip last bit of mac address if we're on second port */
2107         if (!mac_addr_offset && hw->bus.func == E1000_FUNC_1)
2108                 hw->mac.perm_addr[5] ^= 1;
2109
2110         for (i = 0; i < ETH_ALEN; i++)
2111                 hw->mac.addr[i] = hw->mac.perm_addr[i];
2112
2113         return 0;
2114 }
2115
2116 /**
2117  *  e1000e_validate_nvm_checksum_generic - Validate EEPROM checksum
2118  *  @hw: pointer to the HW structure
2119  *
2120  *  Calculates the EEPROM checksum by reading/adding each word of the EEPROM
2121  *  and then verifies that the sum of the EEPROM is equal to 0xBABA.
2122  **/
2123 s32 e1000e_validate_nvm_checksum_generic(struct e1000_hw *hw)
2124 {
2125         s32 ret_val;
2126         u16 checksum = 0;
2127         u16 i, nvm_data;
2128
2129         for (i = 0; i < (NVM_CHECKSUM_REG + 1); i++) {
2130                 ret_val = e1000_read_nvm(hw, i, 1, &nvm_data);
2131                 if (ret_val) {
2132                         hw_dbg(hw, "NVM Read Error\n");
2133                         return ret_val;
2134                 }
2135                 checksum += nvm_data;
2136         }
2137
2138         if (checksum != (u16) NVM_SUM) {
2139                 hw_dbg(hw, "NVM Checksum Invalid\n");
2140                 return -E1000_ERR_NVM;
2141         }
2142
2143         return 0;
2144 }
2145
2146 /**
2147  *  e1000e_update_nvm_checksum_generic - Update EEPROM checksum
2148  *  @hw: pointer to the HW structure
2149  *
2150  *  Updates the EEPROM checksum by reading/adding each word of the EEPROM
2151  *  up to the checksum.  Then calculates the EEPROM checksum and writes the
2152  *  value to the EEPROM.
2153  **/
2154 s32 e1000e_update_nvm_checksum_generic(struct e1000_hw *hw)
2155 {
2156         s32 ret_val;
2157         u16 checksum = 0;
2158         u16 i, nvm_data;
2159
2160         for (i = 0; i < NVM_CHECKSUM_REG; i++) {
2161                 ret_val = e1000_read_nvm(hw, i, 1, &nvm_data);
2162                 if (ret_val) {
2163                         hw_dbg(hw, "NVM Read Error while updating checksum.\n");
2164                         return ret_val;
2165                 }
2166                 checksum += nvm_data;
2167         }
2168         checksum = (u16) NVM_SUM - checksum;
2169         ret_val = e1000_write_nvm(hw, NVM_CHECKSUM_REG, 1, &checksum);
2170         if (ret_val)
2171                 hw_dbg(hw, "NVM Write Error while updating checksum.\n");
2172
2173         return ret_val;
2174 }
2175
2176 /**
2177  *  e1000e_reload_nvm - Reloads EEPROM
2178  *  @hw: pointer to the HW structure
2179  *
2180  *  Reloads the EEPROM by setting the "Reinitialize from EEPROM" bit in the
2181  *  extended control register.
2182  **/
2183 void e1000e_reload_nvm(struct e1000_hw *hw)
2184 {
2185         u32 ctrl_ext;
2186
2187         udelay(10);
2188         ctrl_ext = er32(CTRL_EXT);
2189         ctrl_ext |= E1000_CTRL_EXT_EE_RST;
2190         ew32(CTRL_EXT, ctrl_ext);
2191         e1e_flush();
2192 }
2193
2194 /**
2195  *  e1000_calculate_checksum - Calculate checksum for buffer
2196  *  @buffer: pointer to EEPROM
2197  *  @length: size of EEPROM to calculate a checksum for
2198  *
2199  *  Calculates the checksum for some buffer on a specified length.  The
2200  *  checksum calculated is returned.
2201  **/
2202 static u8 e1000_calculate_checksum(u8 *buffer, u32 length)
2203 {
2204         u32 i;
2205         u8  sum = 0;
2206
2207         if (!buffer)
2208                 return 0;
2209
2210         for (i = 0; i < length; i++)
2211                 sum += buffer[i];
2212
2213         return (u8) (0 - sum);
2214 }
2215
2216 /**
2217  *  e1000_mng_enable_host_if - Checks host interface is enabled
2218  *  @hw: pointer to the HW structure
2219  *
2220  *  Returns E1000_success upon success, else E1000_ERR_HOST_INTERFACE_COMMAND
2221  *
2222  *  This function checks whether the HOST IF is enabled for command operation
2223  *  and also checks whether the previous command is completed.  It busy waits
2224  *  in case of previous command is not completed.
2225  **/
2226 static s32 e1000_mng_enable_host_if(struct e1000_hw *hw)
2227 {
2228         u32 hicr;
2229         u8 i;
2230
2231         /* Check that the host interface is enabled. */
2232         hicr = er32(HICR);
2233         if ((hicr & E1000_HICR_EN) == 0) {
2234                 hw_dbg(hw, "E1000_HOST_EN bit disabled.\n");
2235                 return -E1000_ERR_HOST_INTERFACE_COMMAND;
2236         }
2237         /* check the previous command is completed */
2238         for (i = 0; i < E1000_MNG_DHCP_COMMAND_TIMEOUT; i++) {
2239                 hicr = er32(HICR);
2240                 if (!(hicr & E1000_HICR_C))
2241                         break;
2242                 mdelay(1);
2243         }
2244
2245         if (i == E1000_MNG_DHCP_COMMAND_TIMEOUT) {
2246                 hw_dbg(hw, "Previous command timeout failed .\n");
2247                 return -E1000_ERR_HOST_INTERFACE_COMMAND;
2248         }
2249
2250         return 0;
2251 }
2252
2253 /**
2254  *  e1000e_check_mng_mode_generic - check management mode
2255  *  @hw: pointer to the HW structure
2256  *
2257  *  Reads the firmware semaphore register and returns true (>0) if
2258  *  manageability is enabled, else false (0).
2259  **/
2260 bool e1000e_check_mng_mode_generic(struct e1000_hw *hw)
2261 {
2262         u32 fwsm = er32(FWSM);
2263
2264         return (fwsm & E1000_FWSM_MODE_MASK) ==
2265                 (E1000_MNG_IAMT_MODE << E1000_FWSM_MODE_SHIFT);
2266 }
2267
2268 /**
2269  *  e1000e_enable_tx_pkt_filtering - Enable packet filtering on Tx
2270  *  @hw: pointer to the HW structure
2271  *
2272  *  Enables packet filtering on transmit packets if manageability is enabled
2273  *  and host interface is enabled.
2274  **/
2275 bool e1000e_enable_tx_pkt_filtering(struct e1000_hw *hw)
2276 {
2277         struct e1000_host_mng_dhcp_cookie *hdr = &hw->mng_cookie;
2278         u32 *buffer = (u32 *)&hw->mng_cookie;
2279         u32 offset;
2280         s32 ret_val, hdr_csum, csum;
2281         u8 i, len;
2282
2283         /* No manageability, no filtering */
2284         if (!e1000e_check_mng_mode(hw)) {
2285                 hw->mac.tx_pkt_filtering = 0;
2286                 return 0;
2287         }
2288
2289         /*
2290          * If we can't read from the host interface for whatever
2291          * reason, disable filtering.
2292          */
2293         ret_val = e1000_mng_enable_host_if(hw);
2294         if (ret_val != 0) {
2295                 hw->mac.tx_pkt_filtering = 0;
2296                 return ret_val;
2297         }
2298
2299         /* Read in the header.  Length and offset are in dwords. */
2300         len    = E1000_MNG_DHCP_COOKIE_LENGTH >> 2;
2301         offset = E1000_MNG_DHCP_COOKIE_OFFSET >> 2;
2302         for (i = 0; i < len; i++)
2303                 *(buffer + i) = E1000_READ_REG_ARRAY(hw, E1000_HOST_IF, offset + i);
2304         hdr_csum = hdr->checksum;
2305         hdr->checksum = 0;
2306         csum = e1000_calculate_checksum((u8 *)hdr,
2307                                         E1000_MNG_DHCP_COOKIE_LENGTH);
2308         /*
2309          * If either the checksums or signature don't match, then
2310          * the cookie area isn't considered valid, in which case we
2311          * take the safe route of assuming Tx filtering is enabled.
2312          */
2313         if ((hdr_csum != csum) || (hdr->signature != E1000_IAMT_SIGNATURE)) {
2314                 hw->mac.tx_pkt_filtering = 1;
2315                 return 1;
2316         }
2317
2318         /* Cookie area is valid, make the final check for filtering. */
2319         if (!(hdr->status & E1000_MNG_DHCP_COOKIE_STATUS_PARSING)) {
2320                 hw->mac.tx_pkt_filtering = 0;
2321                 return 0;
2322         }
2323
2324         hw->mac.tx_pkt_filtering = 1;
2325         return 1;
2326 }
2327
2328 /**
2329  *  e1000_mng_write_cmd_header - Writes manageability command header
2330  *  @hw: pointer to the HW structure
2331  *  @hdr: pointer to the host interface command header
2332  *
2333  *  Writes the command header after does the checksum calculation.
2334  **/
2335 static s32 e1000_mng_write_cmd_header(struct e1000_hw *hw,
2336                                   struct e1000_host_mng_command_header *hdr)
2337 {
2338         u16 i, length = sizeof(struct e1000_host_mng_command_header);
2339
2340         /* Write the whole command header structure with new checksum. */
2341
2342         hdr->checksum = e1000_calculate_checksum((u8 *)hdr, length);
2343
2344         length >>= 2;
2345         /* Write the relevant command block into the ram area. */
2346         for (i = 0; i < length; i++) {
2347                 E1000_WRITE_REG_ARRAY(hw, E1000_HOST_IF, i,
2348                                             *((u32 *) hdr + i));
2349                 e1e_flush();
2350         }
2351
2352         return 0;
2353 }
2354
2355 /**
2356  *  e1000_mng_host_if_write - Writes to the manageability host interface
2357  *  @hw: pointer to the HW structure
2358  *  @buffer: pointer to the host interface buffer
2359  *  @length: size of the buffer
2360  *  @offset: location in the buffer to write to
2361  *  @sum: sum of the data (not checksum)
2362  *
2363  *  This function writes the buffer content at the offset given on the host if.
2364  *  It also does alignment considerations to do the writes in most efficient
2365  *  way.  Also fills up the sum of the buffer in *buffer parameter.
2366  **/
2367 static s32 e1000_mng_host_if_write(struct e1000_hw *hw, u8 *buffer,
2368                                    u16 length, u16 offset, u8 *sum)
2369 {
2370         u8 *tmp;
2371         u8 *bufptr = buffer;
2372         u32 data = 0;
2373         u16 remaining, i, j, prev_bytes;
2374
2375         /* sum = only sum of the data and it is not checksum */
2376
2377         if (length == 0 || offset + length > E1000_HI_MAX_MNG_DATA_LENGTH)
2378                 return -E1000_ERR_PARAM;
2379
2380         tmp = (u8 *)&data;
2381         prev_bytes = offset & 0x3;
2382         offset >>= 2;
2383
2384         if (prev_bytes) {
2385                 data = E1000_READ_REG_ARRAY(hw, E1000_HOST_IF, offset);
2386                 for (j = prev_bytes; j < sizeof(u32); j++) {
2387                         *(tmp + j) = *bufptr++;
2388                         *sum += *(tmp + j);
2389                 }
2390                 E1000_WRITE_REG_ARRAY(hw, E1000_HOST_IF, offset, data);
2391                 length -= j - prev_bytes;
2392                 offset++;
2393         }
2394
2395         remaining = length & 0x3;
2396         length -= remaining;
2397
2398         /* Calculate length in DWORDs */
2399         length >>= 2;
2400
2401         /*
2402          * The device driver writes the relevant command block into the
2403          * ram area.
2404          */
2405         for (i = 0; i < length; i++) {
2406                 for (j = 0; j < sizeof(u32); j++) {
2407                         *(tmp + j) = *bufptr++;
2408                         *sum += *(tmp + j);
2409                 }
2410
2411                 E1000_WRITE_REG_ARRAY(hw, E1000_HOST_IF, offset + i, data);
2412         }
2413         if (remaining) {
2414                 for (j = 0; j < sizeof(u32); j++) {
2415                         if (j < remaining)
2416                                 *(tmp + j) = *bufptr++;
2417                         else
2418                                 *(tmp + j) = 0;
2419
2420                         *sum += *(tmp + j);
2421                 }
2422                 E1000_WRITE_REG_ARRAY(hw, E1000_HOST_IF, offset + i, data);
2423         }
2424
2425         return 0;
2426 }
2427
2428 /**
2429  *  e1000e_mng_write_dhcp_info - Writes DHCP info to host interface
2430  *  @hw: pointer to the HW structure
2431  *  @buffer: pointer to the host interface
2432  *  @length: size of the buffer
2433  *
2434  *  Writes the DHCP information to the host interface.
2435  **/
2436 s32 e1000e_mng_write_dhcp_info(struct e1000_hw *hw, u8 *buffer, u16 length)
2437 {
2438         struct e1000_host_mng_command_header hdr;
2439         s32 ret_val;
2440         u32 hicr;
2441
2442         hdr.command_id = E1000_MNG_DHCP_TX_PAYLOAD_CMD;
2443         hdr.command_length = length;
2444         hdr.reserved1 = 0;
2445         hdr.reserved2 = 0;
2446         hdr.checksum = 0;
2447
2448         /* Enable the host interface */
2449         ret_val = e1000_mng_enable_host_if(hw);
2450         if (ret_val)
2451                 return ret_val;
2452
2453         /* Populate the host interface with the contents of "buffer". */
2454         ret_val = e1000_mng_host_if_write(hw, buffer, length,
2455                                           sizeof(hdr), &(hdr.checksum));
2456         if (ret_val)
2457                 return ret_val;
2458
2459         /* Write the manageability command header */
2460         ret_val = e1000_mng_write_cmd_header(hw, &hdr);
2461         if (ret_val)
2462                 return ret_val;
2463
2464         /* Tell the ARC a new command is pending. */
2465         hicr = er32(HICR);
2466         ew32(HICR, hicr | E1000_HICR_C);
2467
2468         return 0;
2469 }
2470
2471 /**
2472  *  e1000e_enable_mng_pass_thru - Enable processing of ARP's
2473  *  @hw: pointer to the HW structure
2474  *
2475  *  Verifies the hardware needs to allow ARPs to be processed by the host.
2476  **/
2477 bool e1000e_enable_mng_pass_thru(struct e1000_hw *hw)
2478 {
2479         u32 manc;
2480         u32 fwsm, factps;
2481         bool ret_val = 0;
2482
2483         manc = er32(MANC);
2484
2485         if (!(manc & E1000_MANC_RCV_TCO_EN) ||
2486             !(manc & E1000_MANC_EN_MAC_ADDR_FILTER))
2487                 return ret_val;
2488
2489         if (hw->mac.arc_subsystem_valid) {
2490                 fwsm = er32(FWSM);
2491                 factps = er32(FACTPS);
2492
2493                 if (!(factps & E1000_FACTPS_MNGCG) &&
2494                     ((fwsm & E1000_FWSM_MODE_MASK) ==
2495                      (e1000_mng_mode_pt << E1000_FWSM_MODE_SHIFT))) {
2496                         ret_val = 1;
2497                         return ret_val;
2498                 }
2499         } else {
2500                 if ((manc & E1000_MANC_SMBUS_EN) &&
2501                     !(manc & E1000_MANC_ASF_EN)) {
2502                         ret_val = 1;
2503                         return ret_val;
2504                 }
2505         }
2506
2507         return ret_val;
2508 }
2509
2510 s32 e1000e_read_pba_num(struct e1000_hw *hw, u32 *pba_num)
2511 {
2512         s32 ret_val;
2513         u16 nvm_data;
2514
2515         ret_val = e1000_read_nvm(hw, NVM_PBA_OFFSET_0, 1, &nvm_data);
2516         if (ret_val) {
2517                 hw_dbg(hw, "NVM Read Error\n");
2518                 return ret_val;
2519         }
2520         *pba_num = (u32)(nvm_data << 16);
2521
2522         ret_val = e1000_read_nvm(hw, NVM_PBA_OFFSET_1, 1, &nvm_data);
2523         if (ret_val) {
2524                 hw_dbg(hw, "NVM Read Error\n");
2525                 return ret_val;
2526         }
2527         *pba_num |= nvm_data;
2528
2529         return 0;
2530 }