sys/dev/e1000/e1000_mac.c

   1 /******************************************************************************
   2   SPDX-License-Identifier: BSD-3-Clause
   3
   4   Copyright (c) 2001-2015, Intel Corporation
   5   All rights reserved.
   6
   7   Redistribution and use in source and binary forms, with or without
   8   modification, are permitted provided that the following conditions are met:
   9
  10    1. Redistributions of source code must retain the above copyright notice,
  11       this list of conditions and the following disclaimer.
  12
  13    2. Redistributions in binary form must reproduce the above copyright
  14       notice, this list of conditions and the following disclaimer in the
  15       documentation and/or other materials provided with the distribution.
  16
  17    3. Neither the name of the Intel Corporation nor the names of its
  18       contributors may be used to endorse or promote products derived from
  19       this software without specific prior written permission.
  20
  21   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  22   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  25   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  29   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31   POSSIBILITY OF SUCH DAMAGE.
  32
  33 ******************************************************************************/
  34 /*$FreeBSD$*/
  35
  36 #include "e1000_api.h"
  37
  38 static s32 e1000_validate_mdi_setting_generic(struct e1000_hw *hw);
  39 static void e1000_set_lan_id_multi_port_pcie(struct e1000_hw *hw);
  40 static void e1000_config_collision_dist_generic(struct e1000_hw *hw);
  41 static int e1000_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index);
  42
  43 /**
  44  *  e1000_init_mac_ops_generic - Initialize MAC function pointers
  45  *  @hw: pointer to the HW structure
  46  *
  47  *  Setups up the function pointers to no-op functions
  48  **/
  49 void e1000_init_mac_ops_generic(struct e1000_hw *hw)
  50 {
  51         struct e1000_mac_info *mac = &hw->mac;
  52         DEBUGFUNC("e1000_init_mac_ops_generic");
  53
  54         /* General Setup */
  55         mac->ops.init_params = e1000_null_ops_generic;
  56         mac->ops.init_hw = e1000_null_ops_generic;
  57         mac->ops.reset_hw = e1000_null_ops_generic;
  58         mac->ops.setup_physical_interface = e1000_null_ops_generic;
  59         mac->ops.get_bus_info = e1000_null_ops_generic;
  60         mac->ops.set_lan_id = e1000_set_lan_id_multi_port_pcie;
  61         mac->ops.read_mac_addr = e1000_read_mac_addr_generic;
  62         mac->ops.config_collision_dist = e1000_config_collision_dist_generic;
  63         mac->ops.clear_hw_cntrs = e1000_null_mac_generic;
  64         /* LED */
  65         mac->ops.cleanup_led = e1000_null_ops_generic;
  66         mac->ops.setup_led = e1000_null_ops_generic;
  67         mac->ops.blink_led = e1000_null_ops_generic;
  68         mac->ops.led_on = e1000_null_ops_generic;
  69         mac->ops.led_off = e1000_null_ops_generic;
  70         /* LINK */
  71         mac->ops.setup_link = e1000_null_ops_generic;
  72         mac->ops.get_link_up_info = e1000_null_link_info;
  73         mac->ops.check_for_link = e1000_null_ops_generic;
  74         mac->ops.set_obff_timer = e1000_null_set_obff_timer;
  75         /* Management */
  76         mac->ops.check_mng_mode = e1000_null_mng_mode;
  77         /* VLAN, MC, etc. */
  78         mac->ops.update_mc_addr_list = e1000_null_update_mc;
  79         mac->ops.clear_vfta = e1000_null_mac_generic;
  80         mac->ops.write_vfta = e1000_null_write_vfta;
  81         mac->ops.rar_set = e1000_rar_set_generic;
  82         mac->ops.validate_mdi_setting = e1000_validate_mdi_setting_generic;
  83 }
  84
  85 /**
  86  *  e1000_null_ops_generic - No-op function, returns 0
  87  *  @hw: pointer to the HW structure
  88  **/
  89 s32 e1000_null_ops_generic(struct e1000_hw E1000_UNUSEDARG *hw)
  90 {
  91         DEBUGFUNC("e1000_null_ops_generic");
  92         return E1000_SUCCESS;
  93 }
  94
  95 /**
  96  *  e1000_null_mac_generic - No-op function, return void
  97  *  @hw: pointer to the HW structure
  98  **/
  99 void e1000_null_mac_generic(struct e1000_hw E1000_UNUSEDARG *hw)
 100 {
 101         DEBUGFUNC("e1000_null_mac_generic");
 102         return;
 103 }
 104
 105 /**
 106  *  e1000_null_link_info - No-op function, return 0
 107  *  @hw: pointer to the HW structure
 108  **/
 109 s32 e1000_null_link_info(struct e1000_hw E1000_UNUSEDARG *hw,
 110                          u16 E1000_UNUSEDARG *s, u16 E1000_UNUSEDARG *d)
 111 {
 112         DEBUGFUNC("e1000_null_link_info");
 113         return E1000_SUCCESS;
 114 }
 115
 116 /**
 117  *  e1000_null_mng_mode - No-op function, return FALSE
 118  *  @hw: pointer to the HW structure
 119  **/
 120 bool e1000_null_mng_mode(struct e1000_hw E1000_UNUSEDARG *hw)
 121 {
 122         DEBUGFUNC("e1000_null_mng_mode");
 123         return FALSE;
 124 }
 125
 126 /**
 127  *  e1000_null_update_mc - No-op function, return void
 128  *  @hw: pointer to the HW structure
 129  **/
 130 void e1000_null_update_mc(struct e1000_hw E1000_UNUSEDARG *hw,
 131                           u8 E1000_UNUSEDARG *h, u32 E1000_UNUSEDARG a)
 132 {
 133         DEBUGFUNC("e1000_null_update_mc");
 134         return;
 135 }
 136
 137 /**
 138  *  e1000_null_write_vfta - No-op function, return void
 139  *  @hw: pointer to the HW structure
 140  **/
 141 void e1000_null_write_vfta(struct e1000_hw E1000_UNUSEDARG *hw,
 142                            u32 E1000_UNUSEDARG a, u32 E1000_UNUSEDARG b)
 143 {
 144         DEBUGFUNC("e1000_null_write_vfta");
 145         return;
 146 }
 147
 148 /**
 149  *  e1000_null_rar_set - No-op function, return 0
 150  *  @hw: pointer to the HW structure
 151  **/
 152 int e1000_null_rar_set(struct e1000_hw E1000_UNUSEDARG *hw,
 153                         u8 E1000_UNUSEDARG *h, u32 E1000_UNUSEDARG a)
 154 {
 155         DEBUGFUNC("e1000_null_rar_set");
 156         return E1000_SUCCESS;
 157 }
 158
 159 /**
 160  *  e1000_null_set_obff_timer - No-op function, return 0
 161  *  @hw: pointer to the HW structure
 162  **/
 163 s32 e1000_null_set_obff_timer(struct e1000_hw E1000_UNUSEDARG *hw,
 164                               u32 E1000_UNUSEDARG a)
 165 {
 166         DEBUGFUNC("e1000_null_set_obff_timer");
 167         return E1000_SUCCESS;
 168 }
 169
 170 /**
 171  *  e1000_get_bus_info_pci_generic - Get PCI(x) bus information
 172  *  @hw: pointer to the HW structure
 173  *
 174  *  Determines and stores the system bus information for a particular
 175  *  network interface.  The following bus information is determined and stored:
 176  *  bus speed, bus width, type (PCI/PCIx), and PCI(-x) function.
 177  **/
 178 s32 e1000_get_bus_info_pci_generic(struct e1000_hw *hw)
 179 {
 180         struct e1000_mac_info *mac = &hw->mac;
 181         struct e1000_bus_info *bus = &hw->bus;
 182         u32 status = E1000_READ_REG(hw, E1000_STATUS);
 183         s32 ret_val = E1000_SUCCESS;
 184
 185         DEBUGFUNC("e1000_get_bus_info_pci_generic");
 186
 187         /* PCI or PCI-X? */
 188         bus->type = (status & E1000_STATUS_PCIX_MODE)
 189                         ? e1000_bus_type_pcix
 190                         : e1000_bus_type_pci;
 191
 192         /* Bus speed */
 193         if (bus->type == e1000_bus_type_pci) {
 194                 bus->speed = (status & E1000_STATUS_PCI66)
 195                              ? e1000_bus_speed_66
 196                              : e1000_bus_speed_33;
 197         } else {
 198                 switch (status & E1000_STATUS_PCIX_SPEED) {
 199                 case E1000_STATUS_PCIX_SPEED_66:
 200                         bus->speed = e1000_bus_speed_66;
 201                         break;
 202                 case E1000_STATUS_PCIX_SPEED_100:
 203                         bus->speed = e1000_bus_speed_100;
 204                         break;
 205                 case E1000_STATUS_PCIX_SPEED_133:
 206                         bus->speed = e1000_bus_speed_133;
 207                         break;
 208                 default:
 209                         bus->speed = e1000_bus_speed_reserved;
 210                         break;
 211                 }
 212         }
 213
 214         /* Bus width */
 215         bus->width = (status & E1000_STATUS_BUS64)
 216                      ? e1000_bus_width_64
 217                      : e1000_bus_width_32;
 218
 219         /* Which PCI(-X) function? */
 220         mac->ops.set_lan_id(hw);
 221
 222         return ret_val;
 223 }
 224
 225 /**
 226  *  e1000_get_bus_info_pcie_generic - Get PCIe bus information
 227  *  @hw: pointer to the HW structure
 228  *
 229  *  Determines and stores the system bus information for a particular
 230  *  network interface.  The following bus information is determined and stored:
 231  *  bus speed, bus width, type (PCIe), and PCIe function.
 232  **/
 233 s32 e1000_get_bus_info_pcie_generic(struct e1000_hw *hw)
 234 {
 235         struct e1000_mac_info *mac = &hw->mac;
 236         struct e1000_bus_info *bus = &hw->bus;
 237         s32 ret_val;
 238         u16 pcie_link_status;
 239
 240         DEBUGFUNC("e1000_get_bus_info_pcie_generic");
 241
 242         bus->type = e1000_bus_type_pci_express;
 243
 244         ret_val = e1000_read_pcie_cap_reg(hw, PCIE_LINK_STATUS,
 245                                           &pcie_link_status);
 246         if (ret_val) {
 247                 bus->width = e1000_bus_width_unknown;
 248                 bus->speed = e1000_bus_speed_unknown;
 249         } else {
 250                 switch (pcie_link_status & PCIE_LINK_SPEED_MASK) {
 251                 case PCIE_LINK_SPEED_2500:
 252                         bus->speed = e1000_bus_speed_2500;
 253                         break;
 254                 case PCIE_LINK_SPEED_5000:
 255                         bus->speed = e1000_bus_speed_5000;
 256                         break;
 257                 default:
 258                         bus->speed = e1000_bus_speed_unknown;
 259                         break;
 260                 }
 261
 262                 bus->width = (enum e1000_bus_width)((pcie_link_status &
 263                               PCIE_LINK_WIDTH_MASK) >> PCIE_LINK_WIDTH_SHIFT);
 264         }
 265
 266         mac->ops.set_lan_id(hw);
 267
 268         return E1000_SUCCESS;
 269 }
 270
 271 /**
 272  *  e1000_set_lan_id_multi_port_pcie - Set LAN id for PCIe multiple port devices
 273  *
 274  *  @hw: pointer to the HW structure
 275  *
 276  *  Determines the LAN function id by reading memory-mapped registers
 277  *  and swaps the port value if requested.
 278  **/
 279 static void e1000_set_lan_id_multi_port_pcie(struct e1000_hw *hw)
 280 {
 281         struct e1000_bus_info *bus = &hw->bus;
 282         u32 reg;
 283
 284         /* The status register reports the correct function number
 285          * for the device regardless of function swap state.
 286          */
 287         reg = E1000_READ_REG(hw, E1000_STATUS);
 288         bus->func = (reg & E1000_STATUS_FUNC_MASK) >> E1000_STATUS_FUNC_SHIFT;
 289 }
 290
 291 /**
 292  *  e1000_set_lan_id_multi_port_pci - Set LAN id for PCI multiple port devices
 293  *  @hw: pointer to the HW structure
 294  *
 295  *  Determines the LAN function id by reading PCI config space.
 296  **/
 297 void e1000_set_lan_id_multi_port_pci(struct e1000_hw *hw)
 298 {
 299         struct e1000_bus_info *bus = &hw->bus;
 300         u16 pci_header_type;
 301         u32 status;
 302
 303         e1000_read_pci_cfg(hw, PCI_HEADER_TYPE_REGISTER, &pci_header_type);
 304         if (pci_header_type & PCI_HEADER_TYPE_MULTIFUNC) {
 305                 status = E1000_READ_REG(hw, E1000_STATUS);
 306                 bus->func = (status & E1000_STATUS_FUNC_MASK)
 307                             >> E1000_STATUS_FUNC_SHIFT;
 308         } else {
 309                 bus->func = 0;
 310         }
 311 }
 312
 313 /**
 314  *  e1000_set_lan_id_single_port - Set LAN id for a single port device
 315  *  @hw: pointer to the HW structure
 316  *
 317  *  Sets the LAN function id to zero for a single port device.
 318  **/
 319 void e1000_set_lan_id_single_port(struct e1000_hw *hw)
 320 {
 321         struct e1000_bus_info *bus = &hw->bus;
 322
 323         bus->func = 0;
 324 }
 325
 326 /**
 327  *  e1000_clear_vfta_generic - Clear VLAN filter table
 328  *  @hw: pointer to the HW structure
 329  *
 330  *  Clears the register array which contains the VLAN filter table by
 331  *  setting all the values to 0.
 332  **/
 333 void e1000_clear_vfta_generic(struct e1000_hw *hw)
 334 {
 335         u32 offset;
 336
 337         DEBUGFUNC("e1000_clear_vfta_generic");
 338
 339         for (offset = 0; offset < E1000_VLAN_FILTER_TBL_SIZE; offset++) {
 340                 E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, 0);
 341                 E1000_WRITE_FLUSH(hw);
 342         }
 343 }
 344
 345 /**
 346  *  e1000_write_vfta_generic - Write value to VLAN filter table
 347  *  @hw: pointer to the HW structure
 348  *  @offset: register offset in VLAN filter table
 349  *  @value: register value written to VLAN filter table
 350  *
 351  *  Writes value at the given offset in the register array which stores
 352  *  the VLAN filter table.
 353  **/
 354 void e1000_write_vfta_generic(struct e1000_hw *hw, u32 offset, u32 value)
 355 {
 356         DEBUGFUNC("e1000_write_vfta_generic");
 357
 358         E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, value);
 359         E1000_WRITE_FLUSH(hw);
 360 }
 361
 362 /**
 363  *  e1000_init_rx_addrs_generic - Initialize receive address's
 364  *  @hw: pointer to the HW structure
 365  *  @rar_count: receive address registers
 366  *
 367  *  Setup the receive address registers by setting the base receive address
 368  *  register to the devices MAC address and clearing all the other receive
 369  *  address registers to 0.
 370  **/
 371 void e1000_init_rx_addrs_generic(struct e1000_hw *hw, u16 rar_count)
 372 {
 373         u32 i;
 374         u8 mac_addr[ETH_ADDR_LEN] = {0};
 375
 376         DEBUGFUNC("e1000_init_rx_addrs_generic");
 377
 378         /* Setup the receive address */
 379         DEBUGOUT("Programming MAC Address into RAR[0]\n");
 380
 381         hw->mac.ops.rar_set(hw, hw->mac.addr, 0);
 382
 383         /* Zero out the other (rar_entry_count - 1) receive addresses */
 384         DEBUGOUT1("Clearing RAR[1-%u]\n", rar_count-1);
 385         for (i = 1; i < rar_count; i++)
 386                 hw->mac.ops.rar_set(hw, mac_addr, i);
 387 }
 388
 389 /**
 390  *  e1000_check_alt_mac_addr_generic - Check for alternate MAC addr
 391  *  @hw: pointer to the HW structure
 392  *
 393  *  Checks the nvm for an alternate MAC address.  An alternate MAC address
 394  *  can be setup by pre-boot software and must be treated like a permanent
 395  *  address and must override the actual permanent MAC address. If an
 396  *  alternate MAC address is found it is programmed into RAR0, replacing
 397  *  the permanent address that was installed into RAR0 by the Si on reset.
 398  *  This function will return SUCCESS unless it encounters an error while
 399  *  reading the EEPROM.
 400  **/
 401 s32 e1000_check_alt_mac_addr_generic(struct e1000_hw *hw)
 402 {
 403         u32 i;
 404         s32 ret_val;
 405         u16 offset, nvm_alt_mac_addr_offset, nvm_data;
 406         u8 alt_mac_addr[ETH_ADDR_LEN];
 407
 408         DEBUGFUNC("e1000_check_alt_mac_addr_generic");
 409
 410         ret_val = hw->nvm.ops.read(hw, NVM_COMPAT, 1, &nvm_data);
 411         if (ret_val)
 412                 return ret_val;
 413
 414         /* not supported on older hardware or 82573 */
 415         if ((hw->mac.type < e1000_82571) || (hw->mac.type == e1000_82573))
 416                 return E1000_SUCCESS;
 417
 418         /* Alternate MAC address is handled by the option ROM for 82580
 419          * and newer. SW support not required.
 420          */
 421         if (hw->mac.type >= e1000_82580)
 422                 return E1000_SUCCESS;
 423
 424         ret_val = hw->nvm.ops.read(hw, NVM_ALT_MAC_ADDR_PTR, 1,
 425                                    &nvm_alt_mac_addr_offset);
 426         if (ret_val) {
 427                 DEBUGOUT("NVM Read Error\n");
 428                 return ret_val;
 429         }
 430
 431         if ((nvm_alt_mac_addr_offset == 0xFFFF) ||
 432             (nvm_alt_mac_addr_offset == 0x0000))
 433                 /* There is no Alternate MAC Address */
 434                 return E1000_SUCCESS;
 435
 436         if (hw->bus.func == E1000_FUNC_1)
 437                 nvm_alt_mac_addr_offset += E1000_ALT_MAC_ADDRESS_OFFSET_LAN1;
 438         if (hw->bus.func == E1000_FUNC_2)
 439                 nvm_alt_mac_addr_offset += E1000_ALT_MAC_ADDRESS_OFFSET_LAN2;
 440
 441         if (hw->bus.func == E1000_FUNC_3)
 442                 nvm_alt_mac_addr_offset += E1000_ALT_MAC_ADDRESS_OFFSET_LAN3;
 443         for (i = 0; i < ETH_ADDR_LEN; i += 2) {
 444                 offset = nvm_alt_mac_addr_offset + (i >> 1);
 445                 ret_val = hw->nvm.ops.read(hw, offset, 1, &nvm_data);
 446                 if (ret_val) {
 447                         DEBUGOUT("NVM Read Error\n");
 448                         return ret_val;
 449                 }
 450
 451                 alt_mac_addr[i] = (u8)(nvm_data & 0xFF);
 452                 alt_mac_addr[i + 1] = (u8)(nvm_data >> 8);
 453         }
 454
 455         /* if multicast bit is set, the alternate address will not be used */
 456         if (alt_mac_addr[0] & 0x01) {
 457                 DEBUGOUT("Ignoring Alternate Mac Address with MC bit set\n");
 458                 return E1000_SUCCESS;
 459         }
 460
 461         /* We have a valid alternate MAC address, and we want to treat it the
 462          * same as the normal permanent MAC address stored by the HW into the
 463          * RAR. Do this by mapping this address into RAR0.
 464          */
 465         hw->mac.ops.rar_set(hw, alt_mac_addr, 0);
 466
 467         return E1000_SUCCESS;
 468 }
 469
 470 /**
 471  *  e1000_rar_set_generic - Set receive address register
 472  *  @hw: pointer to the HW structure
 473  *  @addr: pointer to the receive address
 474  *  @index: receive address array register
 475  *
 476  *  Sets the receive address array register at index to the address passed
 477  *  in by addr.
 478  **/
 479 static int e1000_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index)
 480 {
 481         u32 rar_low, rar_high;
 482
 483         DEBUGFUNC("e1000_rar_set_generic");
 484
 485         /* HW expects these in little endian so we reverse the byte order
 486          * from network order (big endian) to little endian
 487          */
 488         rar_low = ((u32) addr[0] | ((u32) addr[1] << 8) |
 489                    ((u32) addr[2] << 16) | ((u32) addr[3] << 24));
 490
 491         rar_high = ((u32) addr[4] | ((u32) addr[5] << 8));
 492
 493         /* If MAC address zero, no need to set the AV bit */
 494         if (rar_low || rar_high)
 495                 rar_high |= E1000_RAH_AV;
 496
 497         /* Some bridges will combine consecutive 32-bit writes into
 498          * a single burst write, which will malfunction on some parts.
 499          * The flushes avoid this.
 500          */
 501         E1000_WRITE_REG(hw, E1000_RAL(index), rar_low);
 502         E1000_WRITE_FLUSH(hw);
 503         E1000_WRITE_REG(hw, E1000_RAH(index), rar_high);
 504         E1000_WRITE_FLUSH(hw);
 505
 506         return E1000_SUCCESS;
 507 }
 508
 509 /**
 510  *  e1000_hash_mc_addr_generic - Generate a multicast hash value
 511  *  @hw: pointer to the HW structure
 512  *  @mc_addr: pointer to a multicast address
 513  *
 514  *  Generates a multicast address hash value which is used to determine
 515  *  the multicast filter table array address and new table value.
 516  **/
 517 u32 e1000_hash_mc_addr_generic(struct e1000_hw *hw, u8 *mc_addr)
 518 {
 519         u32 hash_value, hash_mask;
 520         u8 bit_shift = 0;
 521
 522         DEBUGFUNC("e1000_hash_mc_addr_generic");
 523
 524         /* Register count multiplied by bits per register */
 525         hash_mask = (hw->mac.mta_reg_count * 32) - 1;
 526
 527         /* For a mc_filter_type of 0, bit_shift is the number of left-shifts
 528          * where 0xFF would still fall within the hash mask.
 529          */
 530         while (hash_mask >> bit_shift != 0xFF)
 531                 bit_shift++;
 532
 533         /* The portion of the address that is used for the hash table
 534          * is determined by the mc_filter_type setting.
 535          * The algorithm is such that there is a total of 8 bits of shifting.
 536          * The bit_shift for a mc_filter_type of 0 represents the number of
 537          * left-shifts where the MSB of mc_addr[5] would still fall within
 538          * the hash_mask.  Case 0 does this exactly.  Since there are a total
 539          * of 8 bits of shifting, then mc_addr[4] will shift right the
 540          * remaining number of bits. Thus 8 - bit_shift.  The rest of the
 541          * cases are a variation of this algorithm...essentially raising the
 542          * number of bits to shift mc_addr[5] left, while still keeping the
 543          * 8-bit shifting total.
 544          *
 545          * For example, given the following Destination MAC Address and an
 546          * mta register count of 128 (thus a 4096-bit vector and 0xFFF mask),
 547          * we can see that the bit_shift for case 0 is 4.  These are the hash
 548          * values resulting from each mc_filter_type...
 549          * [0] [1] [2] [3] [4] [5]
 550          * 01  AA  00  12  34  56
 551          * LSB           MSB
 552          *
 553          * case 0: hash_value = ((0x34 >> 4) | (0x56 << 4)) & 0xFFF = 0x563
 554          * case 1: hash_value = ((0x34 >> 3) | (0x56 << 5)) & 0xFFF = 0xAC6
 555          * case 2: hash_value = ((0x34 >> 2) | (0x56 << 6)) & 0xFFF = 0x163
 556          * case 3: hash_value = ((0x34 >> 0) | (0x56 << 8)) & 0xFFF = 0x634
 557          */
 558         switch (hw->mac.mc_filter_type) {
 559         default:
 560         case 0:
 561                 break;
 562         case 1:
 563                 bit_shift += 1;
 564                 break;
 565         case 2:
 566                 bit_shift += 2;
 567                 break;
 568         case 3:
 569                 bit_shift += 4;
 570                 break;
 571         }
 572
 573         hash_value = hash_mask & (((mc_addr[4] >> (8 - bit_shift)) |
 574                                   (((u16) mc_addr[5]) << bit_shift)));
 575
 576         return hash_value;
 577 }
 578
 579 /**
 580  *  e1000_update_mc_addr_list_generic - Update Multicast addresses
 581  *  @hw: pointer to the HW structure
 582  *  @mc_addr_list: array of multicast addresses to program
 583  *  @mc_addr_count: number of multicast addresses to program
 584  *
 585  *  Updates entire Multicast Table Array.
 586  *  The caller must have a packed mc_addr_list of multicast addresses.
 587  **/
 588 void e1000_update_mc_addr_list_generic(struct e1000_hw *hw,
 589                                        u8 *mc_addr_list, u32 mc_addr_count)
 590 {
 591         u32 hash_value, hash_bit, hash_reg;
 592         int i;
 593
 594         DEBUGFUNC("e1000_update_mc_addr_list_generic");
 595
 596         /* clear mta_shadow */
 597         memset(&hw->mac.mta_shadow, 0, sizeof(hw->mac.mta_shadow));
 598
 599         /* update mta_shadow from mc_addr_list */
 600         for (i = 0; (u32) i < mc_addr_count; i++) {
 601                 hash_value = e1000_hash_mc_addr_generic(hw, mc_addr_list);
 602
 603                 hash_reg = (hash_value >> 5) & (hw->mac.mta_reg_count - 1);
 604                 hash_bit = hash_value & 0x1F;
 605
 606                 hw->mac.mta_shadow[hash_reg] |= (1 << hash_bit);
 607                 mc_addr_list += (ETH_ADDR_LEN);
 608         }
 609
 610         /* replace the entire MTA table */
 611         for (i = hw->mac.mta_reg_count - 1; i >= 0; i--)
 612                 E1000_WRITE_REG_ARRAY(hw, E1000_MTA, i, hw->mac.mta_shadow[i]);
 613         E1000_WRITE_FLUSH(hw);
 614 }
 615
 616 /**
 617  *  e1000_pcix_mmrbc_workaround_generic - Fix incorrect MMRBC value
 618  *  @hw: pointer to the HW structure
 619  *
 620  *  In certain situations, a system BIOS may report that the PCIx maximum
 621  *  memory read byte count (MMRBC) value is higher than than the actual
 622  *  value. We check the PCIx command register with the current PCIx status
 623  *  register.
 624  **/
 625 void e1000_pcix_mmrbc_workaround_generic(struct e1000_hw *hw)
 626 {
 627         u16 cmd_mmrbc;
 628         u16 pcix_cmd;
 629         u16 pcix_stat_hi_word;
 630         u16 stat_mmrbc;
 631
 632         DEBUGFUNC("e1000_pcix_mmrbc_workaround_generic");
 633
 634         /* Workaround for PCI-X issue when BIOS sets MMRBC incorrectly */
 635         if (hw->bus.type != e1000_bus_type_pcix)
 636                 return;
 637
 638         e1000_read_pci_cfg(hw, PCIX_COMMAND_REGISTER, &pcix_cmd);
 639         e1000_read_pci_cfg(hw, PCIX_STATUS_REGISTER_HI, &pcix_stat_hi_word);
 640         cmd_mmrbc = (pcix_cmd & PCIX_COMMAND_MMRBC_MASK) >>
 641                      PCIX_COMMAND_MMRBC_SHIFT;
 642         stat_mmrbc = (pcix_stat_hi_word & PCIX_STATUS_HI_MMRBC_MASK) >>
 643                       PCIX_STATUS_HI_MMRBC_SHIFT;
 644         if (stat_mmrbc == PCIX_STATUS_HI_MMRBC_4K)
 645                 stat_mmrbc = PCIX_STATUS_HI_MMRBC_2K;
 646         if (cmd_mmrbc > stat_mmrbc) {
 647                 pcix_cmd &= ~PCIX_COMMAND_MMRBC_MASK;
 648                 pcix_cmd |= stat_mmrbc << PCIX_COMMAND_MMRBC_SHIFT;
 649                 e1000_write_pci_cfg(hw, PCIX_COMMAND_REGISTER, &pcix_cmd);
 650         }
 651 }
 652
 653 /**
 654  *  e1000_clear_hw_cntrs_base_generic - Clear base hardware counters
 655  *  @hw: pointer to the HW structure
 656  *
 657  *  Clears the base hardware counters by reading the counter registers.
 658  **/
 659 void e1000_clear_hw_cntrs_base_generic(struct e1000_hw *hw)
 660 {
 661         DEBUGFUNC("e1000_clear_hw_cntrs_base_generic");
 662
 663         E1000_READ_REG(hw, E1000_CRCERRS);
 664         E1000_READ_REG(hw, E1000_SYMERRS);
 665         E1000_READ_REG(hw, E1000_MPC);
 666         E1000_READ_REG(hw, E1000_SCC);
 667         E1000_READ_REG(hw, E1000_ECOL);
 668         E1000_READ_REG(hw, E1000_MCC);
 669         E1000_READ_REG(hw, E1000_LATECOL);
 670         E1000_READ_REG(hw, E1000_COLC);
 671         E1000_READ_REG(hw, E1000_DC);
 672         E1000_READ_REG(hw, E1000_SEC);
 673         E1000_READ_REG(hw, E1000_RLEC);
 674         E1000_READ_REG(hw, E1000_XONRXC);
 675         E1000_READ_REG(hw, E1000_XONTXC);
 676         E1000_READ_REG(hw, E1000_XOFFRXC);
 677         E1000_READ_REG(hw, E1000_XOFFTXC);
 678         E1000_READ_REG(hw, E1000_FCRUC);
 679         E1000_READ_REG(hw, E1000_GPRC);
 680         E1000_READ_REG(hw, E1000_BPRC);
 681         E1000_READ_REG(hw, E1000_MPRC);
 682         E1000_READ_REG(hw, E1000_GPTC);
 683         E1000_READ_REG(hw, E1000_GORCL);
 684         E1000_READ_REG(hw, E1000_GORCH);
 685         E1000_READ_REG(hw, E1000_GOTCL);
 686         E1000_READ_REG(hw, E1000_GOTCH);
 687         E1000_READ_REG(hw, E1000_RNBC);
 688         E1000_READ_REG(hw, E1000_RUC);
 689         E1000_READ_REG(hw, E1000_RFC);
 690         E1000_READ_REG(hw, E1000_ROC);
 691         E1000_READ_REG(hw, E1000_RJC);
 692         E1000_READ_REG(hw, E1000_TORL);
 693         E1000_READ_REG(hw, E1000_TORH);
 694         E1000_READ_REG(hw, E1000_TOTL);
 695         E1000_READ_REG(hw, E1000_TOTH);
 696         E1000_READ_REG(hw, E1000_TPR);
 697         E1000_READ_REG(hw, E1000_TPT);
 698         E1000_READ_REG(hw, E1000_MPTC);
 699         E1000_READ_REG(hw, E1000_BPTC);
 700 }
 701
 702 /**
 703  *  e1000_check_for_copper_link_generic - Check for link (Copper)
 704  *  @hw: pointer to the HW structure
 705  *
 706  *  Checks to see of the link status of the hardware has changed.  If a
 707  *  change in link status has been detected, then we read the PHY registers
 708  *  to get the current speed/duplex if link exists.
 709  **/
 710 s32 e1000_check_for_copper_link_generic(struct e1000_hw *hw)
 711 {
 712         struct e1000_mac_info *mac = &hw->mac;
 713         s32 ret_val;
 714         bool link;
 715
 716         DEBUGFUNC("e1000_check_for_copper_link");
 717
 718         /* We only want to go out to the PHY registers to see if Auto-Neg
 719          * has completed and/or if our link status has changed.  The
 720          * get_link_status flag is set upon receiving a Link Status
 721          * Change or Rx Sequence Error interrupt.
 722          */
 723         if (!mac->get_link_status)
 724                 return E1000_SUCCESS;
 725
 726         /* First we want to see if the MII Status Register reports
 727          * link.  If so, then we want to get the current speed/duplex
 728          * of the PHY.
 729          */
 730         ret_val = e1000_phy_has_link_generic(hw, 1, 0, &link);
 731         if (ret_val)
 732                 return ret_val;
 733
 734         if (!link)
 735                 return E1000_SUCCESS; /* No link detected */
 736
 737         mac->get_link_status = FALSE;
 738
 739         /* Check if there was DownShift, must be checked
 740          * immediately after link-up
 741          */
 742         e1000_check_downshift_generic(hw);
 743
 744         /* If we are forcing speed/duplex, then we simply return since
 745          * we have already determined whether we have link or not.
 746          */
 747         if (!mac->autoneg)
 748                 return -E1000_ERR_CONFIG;
 749
 750         /* Auto-Neg is enabled.  Auto Speed Detection takes care
 751          * of MAC speed/duplex configuration.  So we only need to
 752          * configure Collision Distance in the MAC.
 753          */
 754         mac->ops.config_collision_dist(hw);
 755
 756         /* Configure Flow Control now that Auto-Neg has completed.
 757          * First, we need to restore the desired flow control
 758          * settings because we may have had to re-autoneg with a
 759          * different link partner.
 760          */
 761         ret_val = e1000_config_fc_after_link_up_generic(hw);
 762         if (ret_val)
 763                 DEBUGOUT("Error configuring flow control\n");
 764
 765         return ret_val;
 766 }
 767
 768 /**
 769  *  e1000_check_for_fiber_link_generic - Check for link (Fiber)
 770  *  @hw: pointer to the HW structure
 771  *
 772  *  Checks for link up on the hardware.  If link is not up and we have
 773  *  a signal, then we need to force link up.
 774  **/
 775 s32 e1000_check_for_fiber_link_generic(struct e1000_hw *hw)
 776 {
 777         struct e1000_mac_info *mac = &hw->mac;
 778         u32 rxcw;
 779         u32 ctrl;
 780         u32 status;
 781         s32 ret_val;
 782
 783         DEBUGFUNC("e1000_check_for_fiber_link_generic");
 784
 785         ctrl = E1000_READ_REG(hw, E1000_CTRL);
 786         status = E1000_READ_REG(hw, E1000_STATUS);
 787         rxcw = E1000_READ_REG(hw, E1000_RXCW);
 788
 789         /* If we don't have link (auto-negotiation failed or link partner
 790          * cannot auto-negotiate), the cable is plugged in (we have signal),
 791          * and our link partner is not trying to auto-negotiate with us (we
 792          * are receiving idles or data), we need to force link up. We also
 793          * need to give auto-negotiation time to complete, in case the cable
 794          * was just plugged in. The autoneg_failed flag does this.
 795          */
 796         /* (ctrl & E1000_CTRL_SWDPIN1) == 1 == have signal */
 797         if ((ctrl & E1000_CTRL_SWDPIN1) && !(status & E1000_STATUS_LU) &&
 798             !(rxcw & E1000_RXCW_C)) {
 799                 if (!mac->autoneg_failed) {
 800                         mac->autoneg_failed = TRUE;
 801                         return E1000_SUCCESS;
 802                 }
 803                 DEBUGOUT("NOT Rx'ing /C/, disable AutoNeg and force link.\n");
 804
 805                 /* Disable auto-negotiation in the TXCW register */
 806                 E1000_WRITE_REG(hw, E1000_TXCW, (mac->txcw & ~E1000_TXCW_ANE));
 807
 808                 /* Force link-up and also force full-duplex. */
 809                 ctrl = E1000_READ_REG(hw, E1000_CTRL);
 810                 ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FD);
 811                 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
 812
 813                 /* Configure Flow Control after forcing link up. */
 814                 ret_val = e1000_config_fc_after_link_up_generic(hw);
 815                 if (ret_val) {
 816                         DEBUGOUT("Error configuring flow control\n");
 817                         return ret_val;
 818                 }
 819         } else if ((ctrl & E1000_CTRL_SLU) && (rxcw & E1000_RXCW_C)) {
 820                 /* If we are forcing link and we are receiving /C/ ordered
 821                  * sets, re-enable auto-negotiation in the TXCW register
 822                  * and disable forced link in the Device Control register
 823                  * in an attempt to auto-negotiate with our link partner.
 824                  */
 825                 DEBUGOUT("Rx'ing /C/, enable AutoNeg and stop forcing link.\n");
 826                 E1000_WRITE_REG(hw, E1000_TXCW, mac->txcw);
 827                 E1000_WRITE_REG(hw, E1000_CTRL, (ctrl & ~E1000_CTRL_SLU));
 828
 829                 mac->serdes_has_link = TRUE;
 830         }
 831
 832         return E1000_SUCCESS;
 833 }
 834
 835 /**
 836  *  e1000_check_for_serdes_link_generic - Check for link (Serdes)
 837  *  @hw: pointer to the HW structure
 838  *
 839  *  Checks for link up on the hardware.  If link is not up and we have
 840  *  a signal, then we need to force link up.
 841  **/
 842 s32 e1000_check_for_serdes_link_generic(struct e1000_hw *hw)
 843 {
 844         struct e1000_mac_info *mac = &hw->mac;
 845         u32 rxcw;
 846         u32 ctrl;
 847         u32 status;
 848         s32 ret_val;
 849
 850         DEBUGFUNC("e1000_check_for_serdes_link_generic");
 851
 852         ctrl = E1000_READ_REG(hw, E1000_CTRL);
 853         status = E1000_READ_REG(hw, E1000_STATUS);
 854         rxcw = E1000_READ_REG(hw, E1000_RXCW);
 855
 856         /* If we don't have link (auto-negotiation failed or link partner
 857          * cannot auto-negotiate), and our link partner is not trying to
 858          * auto-negotiate with us (we are receiving idles or data),
 859          * we need to force link up. We also need to give auto-negotiation
 860          * time to complete.
 861          */
 862         /* (ctrl & E1000_CTRL_SWDPIN1) == 1 == have signal */
 863         if (!(status & E1000_STATUS_LU) && !(rxcw & E1000_RXCW_C)) {
 864                 if (!mac->autoneg_failed) {
 865                         mac->autoneg_failed = TRUE;
 866                         return E1000_SUCCESS;
 867                 }
 868                 DEBUGOUT("NOT Rx'ing /C/, disable AutoNeg and force link.\n");
 869
 870                 /* Disable auto-negotiation in the TXCW register */
 871                 E1000_WRITE_REG(hw, E1000_TXCW, (mac->txcw & ~E1000_TXCW_ANE));
 872
 873                 /* Force link-up and also force full-duplex. */
 874                 ctrl = E1000_READ_REG(hw, E1000_CTRL);
 875                 ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FD);
 876                 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
 877
 878                 /* Configure Flow Control after forcing link up. */
 879                 ret_val = e1000_config_fc_after_link_up_generic(hw);
 880                 if (ret_val) {
 881                         DEBUGOUT("Error configuring flow control\n");
 882                         return ret_val;
 883                 }
 884         } else if ((ctrl & E1000_CTRL_SLU) && (rxcw & E1000_RXCW_C)) {
 885                 /* If we are forcing link and we are receiving /C/ ordered
 886                  * sets, re-enable auto-negotiation in the TXCW register
 887                  * and disable forced link in the Device Control register
 888                  * in an attempt to auto-negotiate with our link partner.
 889                  */
 890                 DEBUGOUT("Rx'ing /C/, enable AutoNeg and stop forcing link.\n");
 891                 E1000_WRITE_REG(hw, E1000_TXCW, mac->txcw);
 892                 E1000_WRITE_REG(hw, E1000_CTRL, (ctrl & ~E1000_CTRL_SLU));
 893
 894                 mac->serdes_has_link = TRUE;
 895         } else if (!(E1000_TXCW_ANE & E1000_READ_REG(hw, E1000_TXCW))) {
 896                 /* If we force link for non-auto-negotiation switch, check
 897                  * link status based on MAC synchronization for internal
 898                  * serdes media type.
 899                  */
 900                 /* SYNCH bit and IV bit are sticky. */
 901                 usec_delay(10);
 902                 rxcw = E1000_READ_REG(hw, E1000_RXCW);
 903                 if (rxcw & E1000_RXCW_SYNCH) {
 904                         if (!(rxcw & E1000_RXCW_IV)) {
 905                                 mac->serdes_has_link = TRUE;
 906                                 DEBUGOUT("SERDES: Link up - forced.\n");
 907                         }
 908                 } else {
 909                         mac->serdes_has_link = FALSE;
 910                         DEBUGOUT("SERDES: Link down - force failed.\n");
 911                 }
 912         }
 913
 914         if (E1000_TXCW_ANE & E1000_READ_REG(hw, E1000_TXCW)) {
 915                 status = E1000_READ_REG(hw, E1000_STATUS);
 916                 if (status & E1000_STATUS_LU) {
 917                         /* SYNCH bit and IV bit are sticky, so reread rxcw. */
 918                         usec_delay(10);
 919                         rxcw = E1000_READ_REG(hw, E1000_RXCW);
 920                         if (rxcw & E1000_RXCW_SYNCH) {
 921                                 if (!(rxcw & E1000_RXCW_IV)) {
 922                                         mac->serdes_has_link = TRUE;
 923                                         DEBUGOUT("SERDES: Link up - autoneg completed successfully.\n");
 924                                 } else {
 925                                         mac->serdes_has_link = FALSE;
 926                                         DEBUGOUT("SERDES: Link down - invalid codewords detected in autoneg.\n");
 927                                 }
 928                         } else {
 929                                 mac->serdes_has_link = FALSE;
 930                                 DEBUGOUT("SERDES: Link down - no sync.\n");
 931                         }
 932                 } else {
 933                         mac->serdes_has_link = FALSE;
 934                         DEBUGOUT("SERDES: Link down - autoneg failed\n");
 935                 }
 936         }
 937
 938         return E1000_SUCCESS;
 939 }
 940
 941 /**
 942  *  e1000_set_default_fc_generic - Set flow control default values
 943  *  @hw: pointer to the HW structure
 944  *
 945  *  Read the EEPROM for the default values for flow control and store the
 946  *  values.
 947  **/
 948 s32 e1000_set_default_fc_generic(struct e1000_hw *hw)
 949 {
 950         s32 ret_val;
 951         u16 nvm_data;
 952         u16 nvm_offset = 0;
 953
 954         DEBUGFUNC("e1000_set_default_fc_generic");
 955
 956         /* Read and store word 0x0F of the EEPROM. This word contains bits
 957          * that determine the hardware's default PAUSE (flow control) mode,
 958          * a bit that determines whether the HW defaults to enabling or
 959          * disabling auto-negotiation, and the direction of the
 960          * SW defined pins. If there is no SW over-ride of the flow
 961          * control setting, then the variable hw->fc will
 962          * be initialized based on a value in the EEPROM.
 963          */
 964         if (hw->mac.type == e1000_i350) {
 965                 nvm_offset = NVM_82580_LAN_FUNC_OFFSET(hw->bus.func);
 966                 ret_val = hw->nvm.ops.read(hw,
 967                                            NVM_INIT_CONTROL2_REG +
 968                                            nvm_offset,
 969                                            1, &nvm_data);
 970         } else {
 971                 ret_val = hw->nvm.ops.read(hw,
 972                                            NVM_INIT_CONTROL2_REG,
 973                                            1, &nvm_data);
 974         }
 975
 976
 977         if (ret_val) {
 978                 DEBUGOUT("NVM Read Error\n");
 979                 return ret_val;
 980         }
 981
 982         if (!(nvm_data & NVM_WORD0F_PAUSE_MASK))
 983                 hw->fc.requested_mode = e1000_fc_none;
 984         else if ((nvm_data & NVM_WORD0F_PAUSE_MASK) ==
 985                  NVM_WORD0F_ASM_DIR)
 986                 hw->fc.requested_mode = e1000_fc_tx_pause;
 987         else
 988                 hw->fc.requested_mode = e1000_fc_full;
 989
 990         return E1000_SUCCESS;
 991 }
 992
 993 /**
 994  *  e1000_setup_link_generic - Setup flow control and link settings
 995  *  @hw: pointer to the HW structure
 996  *
 997  *  Determines which flow control settings to use, then configures flow
 998  *  control.  Calls the appropriate media-specific link configuration
 999  *  function.  Assuming the adapter has a valid link partner, a valid link
1000  *  should be established.  Assumes the hardware has previously been reset
1001  *  and the transmitter and receiver are not enabled.
1002  **/
1003 s32 e1000_setup_link_generic(struct e1000_hw *hw)
1004 {
1005         s32 ret_val;
1006
1007         DEBUGFUNC("e1000_setup_link_generic");
1008
1009         /* In the case of the phy reset being blocked, we already have a link.
1010          * We do not need to set it up again.
1011          */
1012         if (hw->phy.ops.check_reset_block && hw->phy.ops.check_reset_block(hw))
1013                 return E1000_SUCCESS;
1014
1015         /* If requested flow control is set to default, set flow control
1016          * based on the EEPROM flow control settings.
1017          */
1018         if (hw->fc.requested_mode == e1000_fc_default) {
1019                 ret_val = e1000_set_default_fc_generic(hw);
1020                 if (ret_val)
1021                         return ret_val;
1022         }
1023
1024         /* Save off the requested flow control mode for use later.  Depending
1025          * on the link partner's capabilities, we may or may not use this mode.
1026          */
1027         hw->fc.current_mode = hw->fc.requested_mode;
1028
1029         DEBUGOUT1("After fix-ups FlowControl is now = %x\n",
1030                 hw->fc.current_mode);
1031
1032         /* Call the necessary media_type subroutine to configure the link. */
1033         ret_val = hw->mac.ops.setup_physical_interface(hw);
1034         if (ret_val)
1035                 return ret_val;
1036
1037         /* Initialize the flow control address, type, and PAUSE timer
1038          * registers to their default values.  This is done even if flow
1039          * control is disabled, because it does not hurt anything to
1040          * initialize these registers.
1041          */
1042         DEBUGOUT("Initializing the Flow Control address, type and timer regs\n");
1043         E1000_WRITE_REG(hw, E1000_FCT, FLOW_CONTROL_TYPE);
1044         E1000_WRITE_REG(hw, E1000_FCAH, FLOW_CONTROL_ADDRESS_HIGH);
1045         E1000_WRITE_REG(hw, E1000_FCAL, FLOW_CONTROL_ADDRESS_LOW);
1046
1047         E1000_WRITE_REG(hw, E1000_FCTTV, hw->fc.pause_time);
1048
1049         return e1000_set_fc_watermarks_generic(hw);
1050 }
1051
1052 /**
1053  *  e1000_commit_fc_settings_generic - Configure flow control
1054  *  @hw: pointer to the HW structure
1055  *
1056  *  Write the flow control settings to the Transmit Config Word Register (TXCW)
1057  *  base on the flow control settings in e1000_mac_info.
1058  **/
1059 s32 e1000_commit_fc_settings_generic(struct e1000_hw *hw)
1060 {
1061         struct e1000_mac_info *mac = &hw->mac;
1062         u32 txcw;
1063
1064         DEBUGFUNC("e1000_commit_fc_settings_generic");
1065
1066         /* Check for a software override of the flow control settings, and
1067          * setup the device accordingly.  If auto-negotiation is enabled, then
1068          * software will have to set the "PAUSE" bits to the correct value in
1069          * the Transmit Config Word Register (TXCW) and re-start auto-
1070          * negotiation.  However, if auto-negotiation is disabled, then
1071          * software will have to manually configure the two flow control enable
1072          * bits in the CTRL register.
1073          *
1074          * The possible values of the "fc" parameter are:
1075          *      0:  Flow control is completely disabled
1076          *      1:  Rx flow control is enabled (we can receive pause frames,
1077          *          but not send pause frames).
1078          *      2:  Tx flow control is enabled (we can send pause frames but we
1079          *          do not support receiving pause frames).
1080          *      3:  Both Rx and Tx flow control (symmetric) are enabled.
1081          */
1082         switch (hw->fc.current_mode) {
1083         case e1000_fc_none:
1084                 /* Flow control completely disabled by a software over-ride. */
1085                 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD);
1086                 break;
1087         case e1000_fc_rx_pause:
1088                 /* Rx Flow control is enabled and Tx Flow control is disabled
1089                  * by a software over-ride. Since there really isn't a way to
1090                  * advertise that we are capable of Rx Pause ONLY, we will
1091                  * advertise that we support both symmetric and asymmetric Rx
1092                  * PAUSE.  Later, we will disable the adapter's ability to send
1093                  * PAUSE frames.
1094                  */
1095                 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
1096                 break;
1097         case e1000_fc_tx_pause:
1098                 /* Tx Flow control is enabled, and Rx Flow control is disabled,
1099                  * by a software over-ride.
1100                  */
1101                 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_ASM_DIR);
1102                 break;
1103         case e1000_fc_full:
1104                 /* Flow control (both Rx and Tx) is enabled by a software
1105                  * over-ride.
1106                  */
1107                 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
1108                 break;
1109         default:
1110                 DEBUGOUT("Flow control param set incorrectly\n");
1111                 return -E1000_ERR_CONFIG;
1112                 break;
1113         }
1114
1115         E1000_WRITE_REG(hw, E1000_TXCW, txcw);
1116         mac->txcw = txcw;
1117
1118         return E1000_SUCCESS;
1119 }
1120
1121 /**
1122  *  e1000_poll_fiber_serdes_link_generic - Poll for link up
1123  *  @hw: pointer to the HW structure
1124  *
1125  *  Polls for link up by reading the status register, if link fails to come
1126  *  up with auto-negotiation, then the link is forced if a signal is detected.
1127  **/
1128 s32 e1000_poll_fiber_serdes_link_generic(struct e1000_hw *hw)
1129 {
1130         struct e1000_mac_info *mac = &hw->mac;
1131         u32 i, status;
1132         s32 ret_val;
1133
1134         DEBUGFUNC("e1000_poll_fiber_serdes_link_generic");
1135
1136         /* If we have a signal (the cable is plugged in, or assumed TRUE for
1137          * serdes media) then poll for a "Link-Up" indication in the Device
1138          * Status Register.  Time-out if a link isn't seen in 500 milliseconds
1139          * seconds (Auto-negotiation should complete in less than 500
1140          * milliseconds even if the other end is doing it in SW).
1141          */
1142         for (i = 0; i < FIBER_LINK_UP_LIMIT; i++) {
1143                 msec_delay(10);
1144                 status = E1000_READ_REG(hw, E1000_STATUS);
1145                 if (status & E1000_STATUS_LU)
1146                         break;
1147         }
1148         if (i == FIBER_LINK_UP_LIMIT) {
1149                 DEBUGOUT("Never got a valid link from auto-neg!!!\n");
1150                 mac->autoneg_failed = TRUE;
1151                 /* AutoNeg failed to achieve a link, so we'll call
1152                  * mac->check_for_link. This routine will force the
1153                  * link up if we detect a signal. This will allow us to
1154                  * communicate with non-autonegotiating link partners.
1155                  */
1156                 ret_val = mac->ops.check_for_link(hw);
1157                 if (ret_val) {
1158                         DEBUGOUT("Error while checking for link\n");
1159                         return ret_val;
1160                 }
1161                 mac->autoneg_failed = FALSE;
1162         } else {
1163                 mac->autoneg_failed = FALSE;
1164                 DEBUGOUT("Valid Link Found\n");
1165         }
1166
1167         return E1000_SUCCESS;
1168 }
1169
1170 /**
1171  *  e1000_setup_fiber_serdes_link_generic - Setup link for fiber/serdes
1172  *  @hw: pointer to the HW structure
1173  *
1174  *  Configures collision distance and flow control for fiber and serdes
1175  *  links.  Upon successful setup, poll for link.
1176  **/
1177 s32 e1000_setup_fiber_serdes_link_generic(struct e1000_hw *hw)
1178 {
1179         u32 ctrl;
1180         s32 ret_val;
1181
1182         DEBUGFUNC("e1000_setup_fiber_serdes_link_generic");
1183
1184         ctrl = E1000_READ_REG(hw, E1000_CTRL);
1185
1186         /* Take the link out of reset */
1187         ctrl &= ~E1000_CTRL_LRST;
1188
1189         hw->mac.ops.config_collision_dist(hw);
1190
1191         ret_val = e1000_commit_fc_settings_generic(hw);
1192         if (ret_val)
1193                 return ret_val;
1194
1195         /* Since auto-negotiation is enabled, take the link out of reset (the
1196          * link will be in reset, because we previously reset the chip). This
1197          * will restart auto-negotiation.  If auto-negotiation is successful
1198          * then the link-up status bit will be set and the flow control enable
1199          * bits (RFCE and TFCE) will be set according to their negotiated value.
1200          */
1201         DEBUGOUT("Auto-negotiation enabled\n");
1202
1203         E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1204         E1000_WRITE_FLUSH(hw);
1205         msec_delay(1);
1206
1207         /* For these adapters, the SW definable pin 1 is set when the optics
1208          * detect a signal.  If we have a signal, then poll for a "Link-Up"
1209          * indication.
1210          */
1211         if (hw->phy.media_type == e1000_media_type_internal_serdes ||
1212             (E1000_READ_REG(hw, E1000_CTRL) & E1000_CTRL_SWDPIN1)) {
1213                 ret_val = e1000_poll_fiber_serdes_link_generic(hw);
1214         } else {
1215                 DEBUGOUT("No signal detected\n");
1216         }
1217
1218         return ret_val;
1219 }
1220
1221 /**
1222  *  e1000_config_collision_dist_generic - Configure collision distance
1223  *  @hw: pointer to the HW structure
1224  *
1225  *  Configures the collision distance to the default value and is used
1226  *  during link setup.
1227  **/
1228 static void e1000_config_collision_dist_generic(struct e1000_hw *hw)
1229 {
1230         u32 tctl;
1231
1232         DEBUGFUNC("e1000_config_collision_dist_generic");
1233
1234         tctl = E1000_READ_REG(hw, E1000_TCTL);
1235
1236         tctl &= ~E1000_TCTL_COLD;
1237         tctl |= E1000_COLLISION_DISTANCE << E1000_COLD_SHIFT;
1238
1239         E1000_WRITE_REG(hw, E1000_TCTL, tctl);
1240         E1000_WRITE_FLUSH(hw);
1241 }
1242
1243 /**
1244  *  e1000_set_fc_watermarks_generic - Set flow control high/low watermarks
1245  *  @hw: pointer to the HW structure
1246  *
1247  *  Sets the flow control high/low threshold (watermark) registers.  If
1248  *  flow control XON frame transmission is enabled, then set XON frame
1249  *  transmission as well.
1250  **/
1251 s32 e1000_set_fc_watermarks_generic(struct e1000_hw *hw)
1252 {
1253         u32 fcrtl = 0, fcrth = 0;
1254
1255         DEBUGFUNC("e1000_set_fc_watermarks_generic");
1256
1257         /* Set the flow control receive threshold registers.  Normally,
1258          * these registers will be set to a default threshold that may be
1259          * adjusted later by the driver's runtime code.  However, if the
1260          * ability to transmit pause frames is not enabled, then these
1261          * registers will be set to 0.
1262          */
1263         if (hw->fc.current_mode & e1000_fc_tx_pause) {
1264                 /* We need to set up the Receive Threshold high and low water
1265                  * marks as well as (optionally) enabling the transmission of
1266                  * XON frames.
1267                  */
1268                 fcrtl = hw->fc.low_water;
1269                 if (hw->fc.send_xon)
1270                         fcrtl |= E1000_FCRTL_XONE;
1271
1272                 fcrth = hw->fc.high_water;
1273         }
1274         E1000_WRITE_REG(hw, E1000_FCRTL, fcrtl);
1275         E1000_WRITE_REG(hw, E1000_FCRTH, fcrth);
1276
1277         return E1000_SUCCESS;
1278 }
1279
1280 /**
1281  *  e1000_force_mac_fc_generic - Force the MAC's flow control settings
1282  *  @hw: pointer to the HW structure
1283  *
1284  *  Force the MAC's flow control settings.  Sets the TFCE and RFCE bits in the
1285  *  device control register to reflect the adapter settings.  TFCE and RFCE
1286  *  need to be explicitly set by software when a copper PHY is used because
1287  *  autonegotiation is managed by the PHY rather than the MAC.  Software must
1288  *  also configure these bits when link is forced on a fiber connection.
1289  **/
1290 s32 e1000_force_mac_fc_generic(struct e1000_hw *hw)
1291 {
1292         u32 ctrl;
1293
1294         DEBUGFUNC("e1000_force_mac_fc_generic");
1295
1296         ctrl = E1000_READ_REG(hw, E1000_CTRL);
1297
1298         /* Because we didn't get link via the internal auto-negotiation
1299          * mechanism (we either forced link or we got link via PHY
1300          * auto-neg), we have to manually enable/disable transmit an
1301          * receive flow control.
1302          *
1303          * The "Case" statement below enables/disable flow control
1304          * according to the "hw->fc.current_mode" parameter.
1305          *
1306          * The possible values of the "fc" parameter are:
1307          *      0:  Flow control is completely disabled
1308          *      1:  Rx flow control is enabled (we can receive pause
1309          *          frames but not send pause frames).
1310          *      2:  Tx flow control is enabled (we can send pause frames
1311          *          frames but we do not receive pause frames).
1312          *      3:  Both Rx and Tx flow control (symmetric) is enabled.
1313          *  other:  No other values should be possible at this point.
1314          */
1315         DEBUGOUT1("hw->fc.current_mode = %u\n", hw->fc.current_mode);
1316
1317         switch (hw->fc.current_mode) {
1318         case e1000_fc_none:
1319                 ctrl &= (~(E1000_CTRL_TFCE | E1000_CTRL_RFCE));
1320                 break;
1321         case e1000_fc_rx_pause:
1322                 ctrl &= (~E1000_CTRL_TFCE);
1323                 ctrl |= E1000_CTRL_RFCE;
1324                 break;
1325         case e1000_fc_tx_pause:
1326                 ctrl &= (~E1000_CTRL_RFCE);
1327                 ctrl |= E1000_CTRL_TFCE;
1328                 break;
1329         case e1000_fc_full:
1330                 ctrl |= (E1000_CTRL_TFCE | E1000_CTRL_RFCE);
1331                 break;
1332         default:
1333                 DEBUGOUT("Flow control param set incorrectly\n");
1334                 return -E1000_ERR_CONFIG;
1335         }
1336
1337         E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1338
1339         return E1000_SUCCESS;
1340 }
1341
1342 /**
1343  *  e1000_config_fc_after_link_up_generic - Configures flow control after link
1344  *  @hw: pointer to the HW structure
1345  *
1346  *  Checks the status of auto-negotiation after link up to ensure that the
1347  *  speed and duplex were not forced.  If the link needed to be forced, then
1348  *  flow control needs to be forced also.  If auto-negotiation is enabled
1349  *  and did not fail, then we configure flow control based on our link
1350  *  partner.
1351  **/
1352 s32 e1000_config_fc_after_link_up_generic(struct e1000_hw *hw)
1353 {
1354         struct e1000_mac_info *mac = &hw->mac;
1355         s32 ret_val = E1000_SUCCESS;
1356         u32 pcs_status_reg, pcs_adv_reg, pcs_lp_ability_reg, pcs_ctrl_reg;
1357         u16 mii_status_reg, mii_nway_adv_reg, mii_nway_lp_ability_reg;
1358         u16 speed, duplex;
1359
1360         DEBUGFUNC("e1000_config_fc_after_link_up_generic");
1361
1362         /* Check for the case where we have fiber media and auto-neg failed
1363          * so we had to force link.  In this case, we need to force the
1364          * configuration of the MAC to match the "fc" parameter.
1365          */
1366         if (mac->autoneg_failed) {
1367                 if (hw->phy.media_type == e1000_media_type_fiber ||
1368                     hw->phy.media_type == e1000_media_type_internal_serdes)
1369                         ret_val = e1000_force_mac_fc_generic(hw);
1370         } else {
1371                 if (hw->phy.media_type == e1000_media_type_copper)
1372                         ret_val = e1000_force_mac_fc_generic(hw);
1373         }
1374
1375         if (ret_val) {
1376                 DEBUGOUT("Error forcing flow control settings\n");
1377                 return ret_val;
1378         }
1379
1380         /* Check for the case where we have copper media and auto-neg is
1381          * enabled.  In this case, we need to check and see if Auto-Neg
1382          * has completed, and if so, how the PHY and link partner has
1383          * flow control configured.
1384          */
1385         if ((hw->phy.media_type == e1000_media_type_copper) && mac->autoneg) {
1386                 /* Read the MII Status Register and check to see if AutoNeg
1387                  * has completed.  We read this twice because this reg has
1388                  * some "sticky" (latched) bits.
1389                  */
1390                 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &mii_status_reg);
1391                 if (ret_val)
1392                         return ret_val;
1393                 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &mii_status_reg);
1394                 if (ret_val)
1395                         return ret_val;
1396
1397                 if (!(mii_status_reg & MII_SR_AUTONEG_COMPLETE)) {
1398                         DEBUGOUT("Copper PHY and Auto Neg has not completed.\n");
1399                         return ret_val;
1400                 }
1401
1402                 /* The AutoNeg process has completed, so we now need to
1403                  * read both the Auto Negotiation Advertisement
1404                  * Register (Address 4) and the Auto_Negotiation Base
1405                  * Page Ability Register (Address 5) to determine how
1406                  * flow control was negotiated.
1407                  */
1408                 ret_val = hw->phy.ops.read_reg(hw, PHY_AUTONEG_ADV,
1409                                                &mii_nway_adv_reg);
1410                 if (ret_val)
1411                         return ret_val;
1412                 ret_val = hw->phy.ops.read_reg(hw, PHY_LP_ABILITY,
1413                                                &mii_nway_lp_ability_reg);
1414                 if (ret_val)
1415                         return ret_val;
1416
1417                 /* Two bits in the Auto Negotiation Advertisement Register
1418                  * (Address 4) and two bits in the Auto Negotiation Base
1419                  * Page Ability Register (Address 5) determine flow control
1420                  * for both the PHY and the link partner.  The following
1421                  * table, taken out of the IEEE 802.3ab/D6.0 dated March 25,
1422                  * 1999, describes these PAUSE resolution bits and how flow
1423                  * control is determined based upon these settings.
1424                  * NOTE:  DC = Don't Care
1425                  *
1426                  *   LOCAL DEVICE  |   LINK PARTNER
1427                  * PAUSE | ASM_DIR | PAUSE | ASM_DIR | NIC Resolution
1428                  *-------|---------|-------|---------|--------------------
1429                  *   0   |    0    |  DC   |   DC    | e1000_fc_none
1430                  *   0   |    1    |   0   |   DC    | e1000_fc_none
1431                  *   0   |    1    |   1   |    0    | e1000_fc_none
1432                  *   0   |    1    |   1   |    1    | e1000_fc_tx_pause
1433                  *   1   |    0    |   0   |   DC    | e1000_fc_none
1434                  *   1   |   DC    |   1   |   DC    | e1000_fc_full
1435                  *   1   |    1    |   0   |    0    | e1000_fc_none
1436                  *   1   |    1    |   0   |    1    | e1000_fc_rx_pause
1437                  *
1438                  * Are both PAUSE bits set to 1?  If so, this implies
1439                  * Symmetric Flow Control is enabled at both ends.  The
1440                  * ASM_DIR bits are irrelevant per the spec.
1441                  *
1442                  * For Symmetric Flow Control:
1443                  *
1444                  *   LOCAL DEVICE  |   LINK PARTNER
1445                  * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1446                  *-------|---------|-------|---------|--------------------
1447                  *   1   |   DC    |   1   |   DC    | E1000_fc_full
1448                  *
1449                  */
1450                 if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
1451                     (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE)) {
1452                         /* Now we need to check if the user selected Rx ONLY
1453                          * of pause frames.  In this case, we had to advertise
1454                          * FULL flow control because we could not advertise Rx
1455                          * ONLY. Hence, we must now check to see if we need to
1456                          * turn OFF the TRANSMISSION of PAUSE frames.
1457                          */
1458                         if (hw->fc.requested_mode == e1000_fc_full) {
1459                                 hw->fc.current_mode = e1000_fc_full;
1460                                 DEBUGOUT("Flow Control = FULL.\n");
1461                         } else {
1462                                 hw->fc.current_mode = e1000_fc_rx_pause;
1463                                 DEBUGOUT("Flow Control = Rx PAUSE frames only.\n");
1464                         }
1465                 }
1466                 /* For receiving PAUSE frames ONLY.
1467                  *
1468                  *   LOCAL DEVICE  |   LINK PARTNER
1469                  * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1470                  *-------|---------|-------|---------|--------------------
1471                  *   0   |    1    |   1   |    1    | e1000_fc_tx_pause
1472                  */
1473                 else if (!(mii_nway_adv_reg & NWAY_AR_PAUSE) &&
1474                           (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
1475                           (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
1476                           (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
1477                         hw->fc.current_mode = e1000_fc_tx_pause;
1478                         DEBUGOUT("Flow Control = Tx PAUSE frames only.\n");
1479                 }
1480                 /* For transmitting PAUSE frames ONLY.
1481                  *
1482                  *   LOCAL DEVICE  |   LINK PARTNER
1483                  * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1484                  *-------|---------|-------|---------|--------------------
1485                  *   1   |    1    |   0   |    1    | e1000_fc_rx_pause
1486                  */
1487                 else if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
1488                          (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
1489                          !(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
1490                          (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
1491                         hw->fc.current_mode = e1000_fc_rx_pause;
1492                         DEBUGOUT("Flow Control = Rx PAUSE frames only.\n");
1493                 } else {
1494                         /* Per the IEEE spec, at this point flow control
1495                          * should be disabled.
1496                          */
1497                         hw->fc.current_mode = e1000_fc_none;
1498                         DEBUGOUT("Flow Control = NONE.\n");
1499                 }
1500
1501                 /* Now we need to do one last check...  If we auto-
1502                  * negotiated to HALF DUPLEX, flow control should not be
1503                  * enabled per IEEE 802.3 spec.
1504                  */
1505                 ret_val = mac->ops.get_link_up_info(hw, &speed, &duplex);
1506                 if (ret_val) {
1507                         DEBUGOUT("Error getting link speed and duplex\n");
1508                         return ret_val;
1509                 }
1510
1511                 if (duplex == HALF_DUPLEX)
1512                         hw->fc.current_mode = e1000_fc_none;
1513
1514                 /* Now we call a subroutine to actually force the MAC
1515                  * controller to use the correct flow control settings.
1516                  */
1517                 ret_val = e1000_force_mac_fc_generic(hw);
1518                 if (ret_val) {
1519                         DEBUGOUT("Error forcing flow control settings\n");
1520                         return ret_val;
1521                 }
1522         }
1523
1524         /* Check for the case where we have SerDes media and auto-neg is
1525          * enabled.  In this case, we need to check and see if Auto-Neg
1526          * has completed, and if so, how the PHY and link partner has
1527          * flow control configured.
1528          */
1529         if ((hw->phy.media_type == e1000_media_type_internal_serdes) &&
1530             mac->autoneg) {
1531                 /* Read the PCS_LSTS and check to see if AutoNeg
1532                  * has completed.
1533                  */
1534                 pcs_status_reg = E1000_READ_REG(hw, E1000_PCS_LSTAT);
1535
1536                 if (!(pcs_status_reg & E1000_PCS_LSTS_AN_COMPLETE)) {
1537                         DEBUGOUT("PCS Auto Neg has not completed.\n");
1538                         return ret_val;
1539                 }
1540
1541                 /* The AutoNeg process has completed, so we now need to
1542                  * read both the Auto Negotiation Advertisement
1543                  * Register (PCS_ANADV) and the Auto_Negotiation Base
1544                  * Page Ability Register (PCS_LPAB) to determine how
1545                  * flow control was negotiated.
1546                  */
1547                 pcs_adv_reg = E1000_READ_REG(hw, E1000_PCS_ANADV);
1548                 pcs_lp_ability_reg = E1000_READ_REG(hw, E1000_PCS_LPAB);
1549
1550                 /* Two bits in the Auto Negotiation Advertisement Register
1551                  * (PCS_ANADV) and two bits in the Auto Negotiation Base
1552                  * Page Ability Register (PCS_LPAB) determine flow control
1553                  * for both the PHY and the link partner.  The following
1554                  * table, taken out of the IEEE 802.3ab/D6.0 dated March 25,
1555                  * 1999, describes these PAUSE resolution bits and how flow
1556                  * control is determined based upon these settings.
1557                  * NOTE:  DC = Don't Care
1558                  *
1559                  *   LOCAL DEVICE  |   LINK PARTNER
1560                  * PAUSE | ASM_DIR | PAUSE | ASM_DIR | NIC Resolution
1561                  *-------|---------|-------|---------|--------------------
1562                  *   0   |    0    |  DC   |   DC    | e1000_fc_none
1563                  *   0   |    1    |   0   |   DC    | e1000_fc_none
1564                  *   0   |    1    |   1   |    0    | e1000_fc_none
1565                  *   0   |    1    |   1   |    1    | e1000_fc_tx_pause
1566                  *   1   |    0    |   0   |   DC    | e1000_fc_none
1567                  *   1   |   DC    |   1   |   DC    | e1000_fc_full
1568                  *   1   |    1    |   0   |    0    | e1000_fc_none
1569                  *   1   |    1    |   0   |    1    | e1000_fc_rx_pause
1570                  *
1571                  * Are both PAUSE bits set to 1?  If so, this implies
1572                  * Symmetric Flow Control is enabled at both ends.  The
1573                  * ASM_DIR bits are irrelevant per the spec.
1574                  *
1575                  * For Symmetric Flow Control:
1576                  *
1577                  *   LOCAL DEVICE  |   LINK PARTNER
1578                  * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1579                  *-------|---------|-------|---------|--------------------
1580                  *   1   |   DC    |   1   |   DC    | e1000_fc_full
1581                  *
1582                  */
1583                 if ((pcs_adv_reg & E1000_TXCW_PAUSE) &&
1584                     (pcs_lp_ability_reg & E1000_TXCW_PAUSE)) {
1585                         /* Now we need to check if the user selected Rx ONLY
1586                          * of pause frames.  In this case, we had to advertise
1587                          * FULL flow control because we could not advertise Rx
1588                          * ONLY. Hence, we must now check to see if we need to
1589                          * turn OFF the TRANSMISSION of PAUSE frames.
1590                          */
1591                         if (hw->fc.requested_mode == e1000_fc_full) {
1592                                 hw->fc.current_mode = e1000_fc_full;
1593                                 DEBUGOUT("Flow Control = FULL.\n");
1594                         } else {
1595                                 hw->fc.current_mode = e1000_fc_rx_pause;
1596                                 DEBUGOUT("Flow Control = Rx PAUSE frames only.\n");
1597                         }
1598                 }
1599                 /* For receiving PAUSE frames ONLY.
1600                  *
1601                  *   LOCAL DEVICE  |   LINK PARTNER
1602                  * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1603                  *-------|---------|-------|---------|--------------------
1604                  *   0   |    1    |   1   |    1    | e1000_fc_tx_pause
1605                  */
1606                 else if (!(pcs_adv_reg & E1000_TXCW_PAUSE) &&
1607                           (pcs_adv_reg & E1000_TXCW_ASM_DIR) &&
1608                           (pcs_lp_ability_reg & E1000_TXCW_PAUSE) &&
1609                           (pcs_lp_ability_reg & E1000_TXCW_ASM_DIR)) {
1610                         hw->fc.current_mode = e1000_fc_tx_pause;
1611                         DEBUGOUT("Flow Control = Tx PAUSE frames only.\n");
1612                 }
1613                 /* For transmitting PAUSE frames ONLY.
1614                  *
1615                  *   LOCAL DEVICE  |   LINK PARTNER
1616                  * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1617                  *-------|---------|-------|---------|--------------------
1618                  *   1   |    1    |   0   |    1    | e1000_fc_rx_pause
1619                  */
1620                 else if ((pcs_adv_reg & E1000_TXCW_PAUSE) &&
1621                          (pcs_adv_reg & E1000_TXCW_ASM_DIR) &&
1622                          !(pcs_lp_ability_reg & E1000_TXCW_PAUSE) &&
1623                          (pcs_lp_ability_reg & E1000_TXCW_ASM_DIR)) {
1624                         hw->fc.current_mode = e1000_fc_rx_pause;
1625                         DEBUGOUT("Flow Control = Rx PAUSE frames only.\n");
1626                 } else {
1627                         /* Per the IEEE spec, at this point flow control
1628                          * should be disabled.
1629                          */
1630                         hw->fc.current_mode = e1000_fc_none;
1631                         DEBUGOUT("Flow Control = NONE.\n");
1632                 }
1633
1634                 /* Now we call a subroutine to actually force the MAC
1635                  * controller to use the correct flow control settings.
1636                  */
1637                 pcs_ctrl_reg = E1000_READ_REG(hw, E1000_PCS_LCTL);
1638                 pcs_ctrl_reg |= E1000_PCS_LCTL_FORCE_FCTRL;
1639                 E1000_WRITE_REG(hw, E1000_PCS_LCTL, pcs_ctrl_reg);
1640
1641                 ret_val = e1000_force_mac_fc_generic(hw);
1642                 if (ret_val) {
1643                         DEBUGOUT("Error forcing flow control settings\n");
1644                         return ret_val;
1645                 }
1646         }
1647
1648         return E1000_SUCCESS;
1649 }
1650
1651 /**
1652  *  e1000_get_speed_and_duplex_copper_generic - Retrieve current speed/duplex
1653  *  @hw: pointer to the HW structure
1654  *  @speed: stores the current speed
1655  *  @duplex: stores the current duplex
1656  *
1657  *  Read the status register for the current speed/duplex and store the current
1658  *  speed and duplex for copper connections.
1659  **/
1660 s32 e1000_get_speed_and_duplex_copper_generic(struct e1000_hw *hw, u16 *speed,
1661                                               u16 *duplex)
1662 {
1663         u32 status;
1664
1665         DEBUGFUNC("e1000_get_speed_and_duplex_copper_generic");
1666
1667         status = E1000_READ_REG(hw, E1000_STATUS);
1668         if (status & E1000_STATUS_SPEED_1000) {
1669                 *speed = SPEED_1000;
1670                 DEBUGOUT("1000 Mbs, ");
1671         } else if (status & E1000_STATUS_SPEED_100) {
1672                 *speed = SPEED_100;
1673                 DEBUGOUT("100 Mbs, ");
1674         } else {
1675                 *speed = SPEED_10;
1676                 DEBUGOUT("10 Mbs, ");
1677         }
1678
1679         if (status & E1000_STATUS_FD) {
1680                 *duplex = FULL_DUPLEX;
1681                 DEBUGOUT("Full Duplex\n");
1682         } else {
1683                 *duplex = HALF_DUPLEX;
1684                 DEBUGOUT("Half Duplex\n");
1685         }
1686
1687         return E1000_SUCCESS;
1688 }
1689
1690 /**
1691  *  e1000_get_speed_and_duplex_fiber_generic - Retrieve current speed/duplex
1692  *  @hw: pointer to the HW structure
1693  *  @speed: stores the current speed
1694  *  @duplex: stores the current duplex
1695  *
1696  *  Sets the speed and duplex to gigabit full duplex (the only possible option)
1697  *  for fiber/serdes links.
1698  **/
1699 s32 e1000_get_speed_and_duplex_fiber_serdes_generic(struct e1000_hw E1000_UNUSEDARG *hw,
1700                                                     u16 *speed, u16 *duplex)
1701 {
1702         DEBUGFUNC("e1000_get_speed_and_duplex_fiber_serdes_generic");
1703
1704         *speed = SPEED_1000;
1705         *duplex = FULL_DUPLEX;
1706
1707         return E1000_SUCCESS;
1708 }
1709
1710 /**
1711  *  e1000_get_auto_rd_done_generic - Check for auto read completion
1712  *  @hw: pointer to the HW structure
1713  *
1714  *  Check EEPROM for Auto Read done bit.
1715  **/
1716 s32 e1000_get_auto_rd_done_generic(struct e1000_hw *hw)
1717 {
1718         s32 i = 0;
1719
1720         DEBUGFUNC("e1000_get_auto_rd_done_generic");
1721
1722         while (i < AUTO_READ_DONE_TIMEOUT) {
1723                 if (E1000_READ_REG(hw, E1000_EECD) & E1000_EECD_AUTO_RD)
1724                         break;
1725                 msec_delay(1);
1726                 i++;
1727         }
1728
1729         if (i == AUTO_READ_DONE_TIMEOUT) {
1730                 DEBUGOUT("Auto read by HW from NVM has not completed.\n");
1731                 return -E1000_ERR_RESET;
1732         }
1733
1734         return E1000_SUCCESS;
1735 }
1736
1737 /**
1738  *  e1000_valid_led_default_generic - Verify a valid default LED config
1739  *  @hw: pointer to the HW structure
1740  *  @data: pointer to the NVM (EEPROM)
1741  *
1742  *  Read the EEPROM for the current default LED configuration.  If the
1743  *  LED configuration is not valid, set to a valid LED configuration.
1744  **/
1745 s32 e1000_valid_led_default_generic(struct e1000_hw *hw, u16 *data)
1746 {
1747         s32 ret_val;
1748
1749         DEBUGFUNC("e1000_valid_led_default_generic");
1750
1751         ret_val = hw->nvm.ops.read(hw, NVM_ID_LED_SETTINGS, 1, data);
1752         if (ret_val) {
1753                 DEBUGOUT("NVM Read Error\n");
1754                 return ret_val;
1755         }
1756
1757         if (*data == ID_LED_RESERVED_0000 || *data == ID_LED_RESERVED_FFFF)
1758                 *data = ID_LED_DEFAULT;
1759
1760         return E1000_SUCCESS;
1761 }
1762
1763 /**
1764  *  e1000_id_led_init_generic -
1765  *  @hw: pointer to the HW structure
1766  *
1767  **/
1768 s32 e1000_id_led_init_generic(struct e1000_hw *hw)
1769 {
1770         struct e1000_mac_info *mac = &hw->mac;
1771         s32 ret_val;
1772         const u32 ledctl_mask = 0x000000FF;
1773         const u32 ledctl_on = E1000_LEDCTL_MODE_LED_ON;
1774         const u32 ledctl_off = E1000_LEDCTL_MODE_LED_OFF;
1775         u16 data, i, temp;
1776         const u16 led_mask = 0x0F;
1777
1778         DEBUGFUNC("e1000_id_led_init_generic");
1779
1780         ret_val = hw->nvm.ops.valid_led_default(hw, &data);
1781         if (ret_val)
1782                 return ret_val;
1783
1784         mac->ledctl_default = E1000_READ_REG(hw, E1000_LEDCTL);
1785         mac->ledctl_mode1 = mac->ledctl_default;
1786         mac->ledctl_mode2 = mac->ledctl_default;
1787
1788         for (i = 0; i < 4; i++) {
1789                 temp = (data >> (i << 2)) & led_mask;
1790                 switch (temp) {
1791                 case ID_LED_ON1_DEF2:
1792                 case ID_LED_ON1_ON2:
1793                 case ID_LED_ON1_OFF2:
1794                         mac->ledctl_mode1 &= ~(ledctl_mask << (i << 3));
1795                         mac->ledctl_mode1 |= ledctl_on << (i << 3);
1796                         break;
1797                 case ID_LED_OFF1_DEF2:
1798                 case ID_LED_OFF1_ON2:
1799                 case ID_LED_OFF1_OFF2:
1800                         mac->ledctl_mode1 &= ~(ledctl_mask << (i << 3));
1801                         mac->ledctl_mode1 |= ledctl_off << (i << 3);
1802                         break;
1803                 default:
1804                         /* Do nothing */
1805                         break;
1806                 }
1807                 switch (temp) {
1808                 case ID_LED_DEF1_ON2:
1809                 case ID_LED_ON1_ON2:
1810                 case ID_LED_OFF1_ON2:
1811                         mac->ledctl_mode2 &= ~(ledctl_mask << (i << 3));
1812                         mac->ledctl_mode2 |= ledctl_on << (i << 3);
1813                         break;
1814                 case ID_LED_DEF1_OFF2:
1815                 case ID_LED_ON1_OFF2:
1816                 case ID_LED_OFF1_OFF2:
1817                         mac->ledctl_mode2 &= ~(ledctl_mask << (i << 3));
1818                         mac->ledctl_mode2 |= ledctl_off << (i << 3);
1819                         break;
1820                 default:
1821                         /* Do nothing */
1822                         break;
1823                 }
1824         }
1825
1826         return E1000_SUCCESS;
1827 }
1828
1829 /**
1830  *  e1000_setup_led_generic - Configures SW controllable LED
1831  *  @hw: pointer to the HW structure
1832  *
1833  *  This prepares the SW controllable LED for use and saves the current state
1834  *  of the LED so it can be later restored.
1835  **/
1836 s32 e1000_setup_led_generic(struct e1000_hw *hw)
1837 {
1838         u32 ledctl;
1839
1840         DEBUGFUNC("e1000_setup_led_generic");
1841
1842         if (hw->mac.ops.setup_led != e1000_setup_led_generic)
1843                 return -E1000_ERR_CONFIG;
1844
1845         if (hw->phy.media_type == e1000_media_type_fiber) {
1846                 ledctl = E1000_READ_REG(hw, E1000_LEDCTL);
1847                 hw->mac.ledctl_default = ledctl;
1848                 /* Turn off LED0 */
1849                 ledctl &= ~(E1000_LEDCTL_LED0_IVRT | E1000_LEDCTL_LED0_BLINK |
1850                             E1000_LEDCTL_LED0_MODE_MASK);
1851                 ledctl |= (E1000_LEDCTL_MODE_LED_OFF <<
1852                            E1000_LEDCTL_LED0_MODE_SHIFT);
1853                 E1000_WRITE_REG(hw, E1000_LEDCTL, ledctl);
1854         } else if (hw->phy.media_type == e1000_media_type_copper) {
1855                 E1000_WRITE_REG(hw, E1000_LEDCTL, hw->mac.ledctl_mode1);
1856         }
1857
1858         return E1000_SUCCESS;
1859 }
1860
1861 /**
1862  *  e1000_cleanup_led_generic - Set LED config to default operation
1863  *  @hw: pointer to the HW structure
1864  *
1865  *  Remove the current LED configuration and set the LED configuration
1866  *  to the default value, saved from the EEPROM.
1867  **/
1868 s32 e1000_cleanup_led_generic(struct e1000_hw *hw)
1869 {
1870         DEBUGFUNC("e1000_cleanup_led_generic");
1871
1872         E1000_WRITE_REG(hw, E1000_LEDCTL, hw->mac.ledctl_default);
1873         return E1000_SUCCESS;
1874 }
1875
1876 /**
1877  *  e1000_blink_led_generic - Blink LED
1878  *  @hw: pointer to the HW structure
1879  *
1880  *  Blink the LEDs which are set to be on.
1881  **/
1882 s32 e1000_blink_led_generic(struct e1000_hw *hw)
1883 {
1884         u32 ledctl_blink = 0;
1885         u32 i;
1886
1887         DEBUGFUNC("e1000_blink_led_generic");
1888
1889         if (hw->phy.media_type == e1000_media_type_fiber) {
1890                 /* always blink LED0 for PCI-E fiber */
1891                 ledctl_blink = E1000_LEDCTL_LED0_BLINK |
1892                      (E1000_LEDCTL_MODE_LED_ON << E1000_LEDCTL_LED0_MODE_SHIFT);
1893         } else {
1894                 /* Set the blink bit for each LED that's "on" (0x0E)
1895                  * (or "off" if inverted) in ledctl_mode2.  The blink
1896                  * logic in hardware only works when mode is set to "on"
1897                  * so it must be changed accordingly when the mode is
1898                  * "off" and inverted.
1899                  */
1900                 ledctl_blink = hw->mac.ledctl_mode2;
1901                 for (i = 0; i < 32; i += 8) {
1902                         u32 mode = (hw->mac.ledctl_mode2 >> i) &
1903                             E1000_LEDCTL_LED0_MODE_MASK;
1904                         u32 led_default = hw->mac.ledctl_default >> i;
1905
1906                         if ((!(led_default & E1000_LEDCTL_LED0_IVRT) &&
1907                              (mode == E1000_LEDCTL_MODE_LED_ON)) ||
1908                             ((led_default & E1000_LEDCTL_LED0_IVRT) &&
1909                              (mode == E1000_LEDCTL_MODE_LED_OFF))) {
1910                                 ledctl_blink &=
1911                                     ~(E1000_LEDCTL_LED0_MODE_MASK << i);
1912                                 ledctl_blink |= (E1000_LEDCTL_LED0_BLINK |
1913                                                  E1000_LEDCTL_MODE_LED_ON) << i;
1914                         }
1915                 }
1916         }
1917
1918         E1000_WRITE_REG(hw, E1000_LEDCTL, ledctl_blink);
1919
1920         return E1000_SUCCESS;
1921 }
1922
1923 /**
1924  *  e1000_led_on_generic - Turn LED on
1925  *  @hw: pointer to the HW structure
1926  *
1927  *  Turn LED on.
1928  **/
1929 s32 e1000_led_on_generic(struct e1000_hw *hw)
1930 {
1931         u32 ctrl;
1932
1933         DEBUGFUNC("e1000_led_on_generic");
1934
1935         switch (hw->phy.media_type) {
1936         case e1000_media_type_fiber:
1937                 ctrl = E1000_READ_REG(hw, E1000_CTRL);
1938                 ctrl &= ~E1000_CTRL_SWDPIN0;
1939                 ctrl |= E1000_CTRL_SWDPIO0;
1940                 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1941                 break;
1942         case e1000_media_type_copper:
1943                 E1000_WRITE_REG(hw, E1000_LEDCTL, hw->mac.ledctl_mode2);
1944                 break;
1945         default:
1946                 break;
1947         }
1948
1949         return E1000_SUCCESS;
1950 }
1951
1952 /**
1953  *  e1000_led_off_generic - Turn LED off
1954  *  @hw: pointer to the HW structure
1955  *
1956  *  Turn LED off.
1957  **/
1958 s32 e1000_led_off_generic(struct e1000_hw *hw)
1959 {
1960         u32 ctrl;
1961
1962         DEBUGFUNC("e1000_led_off_generic");
1963
1964         switch (hw->phy.media_type) {
1965         case e1000_media_type_fiber:
1966                 ctrl = E1000_READ_REG(hw, E1000_CTRL);
1967                 ctrl |= E1000_CTRL_SWDPIN0;
1968                 ctrl |= E1000_CTRL_SWDPIO0;
1969                 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1970                 break;
1971         case e1000_media_type_copper:
1972                 E1000_WRITE_REG(hw, E1000_LEDCTL, hw->mac.ledctl_mode1);
1973                 break;
1974         default:
1975                 break;
1976         }
1977
1978         return E1000_SUCCESS;
1979 }
1980
1981 /**
1982  *  e1000_set_pcie_no_snoop_generic - Set PCI-express capabilities
1983  *  @hw: pointer to the HW structure
1984  *  @no_snoop: bitmap of snoop events
1985  *
1986  *  Set the PCI-express register to snoop for events enabled in 'no_snoop'.
1987  **/
1988 void e1000_set_pcie_no_snoop_generic(struct e1000_hw *hw, u32 no_snoop)
1989 {
1990         u32 gcr;
1991
1992         DEBUGFUNC("e1000_set_pcie_no_snoop_generic");
1993
1994         if (hw->bus.type != e1000_bus_type_pci_express)
1995                 return;
1996
1997         if (no_snoop) {
1998                 gcr = E1000_READ_REG(hw, E1000_GCR);
1999                 gcr &= ~(PCIE_NO_SNOOP_ALL);
2000                 gcr |= no_snoop;
2001                 E1000_WRITE_REG(hw, E1000_GCR, gcr);
2002         }
2003 }
2004
2005 /**
2006  *  e1000_disable_pcie_master_generic - Disables PCI-express master access
2007  *  @hw: pointer to the HW structure
2008  *
2009  *  Returns E1000_SUCCESS if successful, else returns -10
2010  *  (-E1000_ERR_MASTER_REQUESTS_PENDING) if master disable bit has not caused
2011  *  the master requests to be disabled.
2012  *
2013  *  Disables PCI-Express master access and verifies there are no pending
2014  *  requests.
2015  **/
2016 s32 e1000_disable_pcie_master_generic(struct e1000_hw *hw)
2017 {
2018         u32 ctrl;
2019         s32 timeout = MASTER_DISABLE_TIMEOUT;
2020
2021         DEBUGFUNC("e1000_disable_pcie_master_generic");
2022
2023         if (hw->bus.type != e1000_bus_type_pci_express)
2024                 return E1000_SUCCESS;
2025
2026         ctrl = E1000_READ_REG(hw, E1000_CTRL);
2027         ctrl |= E1000_CTRL_GIO_MASTER_DISABLE;
2028         E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
2029
2030         while (timeout) {
2031                 if (!(E1000_READ_REG(hw, E1000_STATUS) &
2032                       E1000_STATUS_GIO_MASTER_ENABLE) ||
2033                                 E1000_REMOVED(hw->hw_addr))
2034                         break;
2035                 usec_delay(100);
2036                 timeout--;
2037         }
2038
2039         if (!timeout) {
2040                 DEBUGOUT("Master requests are pending.\n");
2041                 return -E1000_ERR_MASTER_REQUESTS_PENDING;
2042         }
2043
2044         return E1000_SUCCESS;
2045 }
2046
2047 /**
2048  *  e1000_reset_adaptive_generic - Reset Adaptive Interframe Spacing
2049  *  @hw: pointer to the HW structure
2050  *
2051  *  Reset the Adaptive Interframe Spacing throttle to default values.
2052  **/
2053 void e1000_reset_adaptive_generic(struct e1000_hw *hw)
2054 {
2055         struct e1000_mac_info *mac = &hw->mac;
2056
2057         DEBUGFUNC("e1000_reset_adaptive_generic");
2058
2059         if (!mac->adaptive_ifs) {
2060                 DEBUGOUT("Not in Adaptive IFS mode!\n");
2061                 return;
2062         }
2063
2064         mac->current_ifs_val = 0;
2065         mac->ifs_min_val = IFS_MIN;
2066         mac->ifs_max_val = IFS_MAX;
2067         mac->ifs_step_size = IFS_STEP;
2068         mac->ifs_ratio = IFS_RATIO;
2069
2070         mac->in_ifs_mode = FALSE;
2071         E1000_WRITE_REG(hw, E1000_AIT, 0);
2072 }
2073
2074 /**
2075  *  e1000_update_adaptive_generic - Update Adaptive Interframe Spacing
2076  *  @hw: pointer to the HW structure
2077  *
2078  *  Update the Adaptive Interframe Spacing Throttle value based on the
2079  *  time between transmitted packets and time between collisions.
2080  **/
2081 void e1000_update_adaptive_generic(struct e1000_hw *hw)
2082 {
2083         struct e1000_mac_info *mac = &hw->mac;
2084
2085         DEBUGFUNC("e1000_update_adaptive_generic");
2086
2087         if (!mac->adaptive_ifs) {
2088                 DEBUGOUT("Not in Adaptive IFS mode!\n");
2089                 return;
2090         }
2091
2092         if ((mac->collision_delta * mac->ifs_ratio) > mac->tx_packet_delta) {
2093                 if (mac->tx_packet_delta > MIN_NUM_XMITS) {
2094                         mac->in_ifs_mode = TRUE;
2095                         if (mac->current_ifs_val < mac->ifs_max_val) {
2096                                 if (!mac->current_ifs_val)
2097                                         mac->current_ifs_val = mac->ifs_min_val;
2098                                 else
2099                                         mac->current_ifs_val +=
2100                                                 mac->ifs_step_size;
2101                                 E1000_WRITE_REG(hw, E1000_AIT,
2102                                                 mac->current_ifs_val);
2103                         }
2104                 }
2105         } else {
2106                 if (mac->in_ifs_mode &&
2107                     (mac->tx_packet_delta <= MIN_NUM_XMITS)) {
2108                         mac->current_ifs_val = 0;
2109                         mac->in_ifs_mode = FALSE;
2110                         E1000_WRITE_REG(hw, E1000_AIT, 0);
2111                 }
2112         }
2113 }
2114
2115 /**
2116  *  e1000_validate_mdi_setting_generic - Verify MDI/MDIx settings
2117  *  @hw: pointer to the HW structure
2118  *
2119  *  Verify that when not using auto-negotiation that MDI/MDIx is correctly
2120  *  set, which is forced to MDI mode only.
2121  **/
2122 static s32 e1000_validate_mdi_setting_generic(struct e1000_hw *hw)
2123 {
2124         DEBUGFUNC("e1000_validate_mdi_setting_generic");
2125
2126         if (!hw->mac.autoneg && (hw->phy.mdix == 0 || hw->phy.mdix == 3)) {
2127                 DEBUGOUT("Invalid MDI setting detected\n");
2128                 hw->phy.mdix = 1;
2129                 return -E1000_ERR_CONFIG;
2130         }
2131
2132         return E1000_SUCCESS;
2133 }
2134
2135 /**
2136  *  e1000_validate_mdi_setting_crossover_generic - Verify MDI/MDIx settings
2137  *  @hw: pointer to the HW structure
2138  *
2139  *  Validate the MDI/MDIx setting, allowing for auto-crossover during forced
2140  *  operation.
2141  **/
2142 s32 e1000_validate_mdi_setting_crossover_generic(struct e1000_hw E1000_UNUSEDARG *hw)
2143 {
2144         DEBUGFUNC("e1000_validate_mdi_setting_crossover_generic");
2145
2146         return E1000_SUCCESS;
2147 }
2148
2149 /**
2150  *  e1000_write_8bit_ctrl_reg_generic - Write a 8bit CTRL register
2151  *  @hw: pointer to the HW structure
2152  *  @reg: 32bit register offset such as E1000_SCTL
2153  *  @offset: register offset to write to
2154  *  @data: data to write at register offset
2155  *
2156  *  Writes an address/data control type register.  There are several of these
2157  *  and they all have the format address << 8 | data and bit 31 is polled for
2158  *  completion.
2159  **/
2160 s32 e1000_write_8bit_ctrl_reg_generic(struct e1000_hw *hw, u32 reg,
2161                                       u32 offset, u8 data)
2162 {
2163         u32 i, regvalue = 0;
2164
2165         DEBUGFUNC("e1000_write_8bit_ctrl_reg_generic");
2166
2167         /* Set up the address and data */
2168         regvalue = ((u32)data) | (offset << E1000_GEN_CTL_ADDRESS_SHIFT);
2169         E1000_WRITE_REG(hw, reg, regvalue);
2170
2171         /* Poll the ready bit to see if the MDI read completed */
2172         for (i = 0; i < E1000_GEN_POLL_TIMEOUT; i++) {
2173                 usec_delay(5);
2174                 regvalue = E1000_READ_REG(hw, reg);
2175                 if (regvalue & E1000_GEN_CTL_READY)
2176                         break;
2177         }
2178         if (!(regvalue & E1000_GEN_CTL_READY)) {
2179                 DEBUGOUT1("Reg %08x did not indicate ready\n", reg);
2180                 return -E1000_ERR_PHY;
2181         }
2182
2183         return E1000_SUCCESS;
2184 }
2185
2186 /**
2187  *  e1000_get_hw_semaphore - Acquire hardware semaphore
2188  *  @hw: pointer to the HW structure
2189  *
2190  *  Acquire the HW semaphore to access the PHY or NVM
2191  **/
2192 s32 e1000_get_hw_semaphore(struct e1000_hw *hw)
2193 {
2194         u32 swsm;
2195         s32 fw_timeout = hw->nvm.word_size + 1;
2196         s32 sw_timeout = hw->nvm.word_size + 1;
2197         s32 i = 0;
2198
2199         DEBUGFUNC("e1000_get_hw_semaphore");
2200
2201         /* _82571 */
2202         /* If we have timedout 3 times on trying to acquire
2203          * the inter-port SMBI semaphore, there is old code
2204          * operating on the other port, and it is not
2205          * releasing SMBI. Modify the number of times that
2206          * we try for the semaphore to interwork with this
2207          * older code.
2208          */
2209         if (hw->dev_spec._82571.smb_counter > 2)
2210                 sw_timeout = 1;
2211
2212
2213         /* Get the SW semaphore */
2214         while (i < sw_timeout) {
2215                 swsm = E1000_READ_REG(hw, E1000_SWSM);
2216                 if (!(swsm & E1000_SWSM_SMBI))
2217                         break;
2218
2219                 usec_delay(50);
2220                 i++;
2221         }
2222
2223         if (i == sw_timeout) {
2224                 DEBUGOUT("Driver can't access device - SMBI bit is set.\n");
2225                 hw->dev_spec._82571.smb_counter++;
2226         }
2227
2228         /* In rare circumstances, the SW semaphore may already be held
2229          * unintentionally. Clear the semaphore once before giving up.
2230          */
2231          if (hw->dev_spec._82575.clear_semaphore_once) {
2232                 hw->dev_spec._82575.clear_semaphore_once = FALSE;
2233                 e1000_put_hw_semaphore(hw);
2234                 for (i = 0; i < fw_timeout; i++) {
2235                         swsm = E1000_READ_REG(hw, E1000_SWSM);
2236                         if (!(swsm & E1000_SWSM_SMBI))
2237                                 break;
2238
2239                         usec_delay(50);
2240                 }
2241          }
2242
2243         /* Get the FW semaphore. */
2244         for (i = 0; i < fw_timeout; i++) {
2245                 swsm = E1000_READ_REG(hw, E1000_SWSM);
2246                 E1000_WRITE_REG(hw, E1000_SWSM, swsm | E1000_SWSM_SWESMBI);
2247
2248                 /* Semaphore acquired if bit latched */
2249                 if (E1000_READ_REG(hw, E1000_SWSM) & E1000_SWSM_SWESMBI)
2250                         break;
2251
2252                 usec_delay(50);
2253         }
2254
2255         if (i == fw_timeout) {
2256                 /* Release semaphores */
2257                 e1000_put_hw_semaphore(hw);
2258                 DEBUGOUT("Driver can't access the NVM\n");
2259                 return -E1000_ERR_NVM;
2260         }
2261
2262         return E1000_SUCCESS;
2263 }
2264
2265 /**
2266  *  e1000_put_hw_semaphore - Release hardware semaphore
2267  *  @hw: pointer to the HW structure
2268  *
2269  *  Release hardware semaphore used to access the PHY or NVM
2270  **/
2271 void e1000_put_hw_semaphore(struct e1000_hw *hw)
2272 {
2273         u32 swsm;
2274
2275         DEBUGFUNC("e1000_put_hw_semaphore");
2276
2277         swsm = E1000_READ_REG(hw, E1000_SWSM);
2278
2279         swsm &= ~(E1000_SWSM_SMBI | E1000_SWSM_SWESMBI);
2280
2281         E1000_WRITE_REG(hw, E1000_SWSM, swsm);
2282 }
2283
2284
2285 /**
2286  *  e1000_acquire_swfw_sync - Acquire SW/FW semaphore
2287  *  @hw: pointer to the HW structure
2288  *  @mask: specifies which semaphore to acquire
2289  *
2290  *  Acquire the SW/FW semaphore to access the PHY or NVM.  The mask
2291  *  will also specify which port we're acquiring the lock for.
2292  **/
2293 s32
2294 e1000_acquire_swfw_sync(struct e1000_hw *hw, u16 mask)
2295 {
2296         u32 swfw_sync;
2297         u32 swmask = mask;
2298         u32 fwmask = mask << 16;
2299         s32 ret_val = E1000_SUCCESS;
2300         s32 i = 0, timeout = 200;
2301
2302         DEBUGFUNC("e1000_acquire_swfw_sync");
2303         ASSERT_NO_LOCKS();
2304         while (i < timeout) {
2305                 if (e1000_get_hw_semaphore(hw)) {
2306                         ret_val = -E1000_ERR_SWFW_SYNC;
2307                         goto out;
2308                 }
2309
2310                 swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
2311                 if (!(swfw_sync & (fwmask | swmask)))
2312                         break;
2313
2314                 /*
2315                  * Firmware currently using resource (fwmask)
2316                  * or other software thread using resource (swmask)
2317                  */
2318                 e1000_put_hw_semaphore(hw);
2319                 msec_delay_irq(5);
2320                 i++;
2321         }
2322
2323         if (i == timeout) {
2324                 DEBUGOUT("Driver can't access resource, SW_FW_SYNC timeout.\n");
2325                 ret_val = -E1000_ERR_SWFW_SYNC;
2326                 goto out;
2327         }
2328
2329         swfw_sync |= swmask;
2330         E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
2331
2332         e1000_put_hw_semaphore(hw);
2333
2334 out:
2335         return ret_val;
2336 }
2337
2338 /**
2339  *  e1000_release_swfw_sync - Release SW/FW semaphore
2340  *  @hw: pointer to the HW structure
2341  *  @mask: specifies which semaphore to acquire
2342  *
2343  *  Release the SW/FW semaphore used to access the PHY or NVM.  The mask
2344  *  will also specify which port we're releasing the lock for.
2345  **/
2346 void
2347 e1000_release_swfw_sync(struct e1000_hw *hw, u16 mask)
2348 {
2349         u32 swfw_sync;
2350
2351         DEBUGFUNC("e1000_release_swfw_sync");
2352
2353         while (e1000_get_hw_semaphore(hw) != E1000_SUCCESS)
2354                 ; /* Empty */
2355
2356         swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
2357         swfw_sync &= ~mask;
2358         E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
2359
2360         e1000_put_hw_semaphore(hw);
2361 }
2362