drivers/net/e1000/base/e1000_82575.c

   1 /*******************************************************************************
   2
   3 Copyright (c) 2001-2015, Intel Corporation
   4 All rights reserved.
   5
   6 Redistribution and use in source and binary forms, with or without
   7 modification, are permitted provided that the following conditions are met:
   8
   9  1. Redistributions of source code must retain the above copyright notice,
  10     this list of conditions and the following disclaimer.
  11
  12  2. Redistributions in binary form must reproduce the above copyright
  13     notice, this list of conditions and the following disclaimer in the
  14     documentation and/or other materials provided with the distribution.
  15
  16  3. Neither the name of the Intel Corporation nor the names of its
  17     contributors may be used to endorse or promote products derived from
  18     this software without specific prior written permission.
  19
  20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30 POSSIBILITY OF SUCH DAMAGE.
  31
  32 ***************************************************************************/
  33
  34 /*
  35  * 82575EB Gigabit Network Connection
  36  * 82575EB Gigabit Backplane Connection
  37  * 82575GB Gigabit Network Connection
  38  * 82576 Gigabit Network Connection
  39  * 82576 Quad Port Gigabit Mezzanine Adapter
  40  * 82580 Gigabit Network Connection
  41  * I350 Gigabit Network Connection
  42  */
  43
  44 #include "e1000_api.h"
  45 #include "e1000_i210.h"
  46
  47 STATIC s32  e1000_init_phy_params_82575(struct e1000_hw *hw);
  48 STATIC s32  e1000_init_mac_params_82575(struct e1000_hw *hw);
  49 STATIC s32  e1000_acquire_phy_82575(struct e1000_hw *hw);
  50 STATIC void e1000_release_phy_82575(struct e1000_hw *hw);
  51 STATIC s32  e1000_acquire_nvm_82575(struct e1000_hw *hw);
  52 STATIC void e1000_release_nvm_82575(struct e1000_hw *hw);
  53 STATIC s32  e1000_check_for_link_82575(struct e1000_hw *hw);
  54 STATIC s32  e1000_check_for_link_media_swap(struct e1000_hw *hw);
  55 STATIC s32  e1000_get_cfg_done_82575(struct e1000_hw *hw);
  56 STATIC s32  e1000_get_link_up_info_82575(struct e1000_hw *hw, u16 *speed,
  57                                          u16 *duplex);
  58 STATIC s32  e1000_phy_hw_reset_sgmii_82575(struct e1000_hw *hw);
  59 STATIC s32  e1000_read_phy_reg_sgmii_82575(struct e1000_hw *hw, u32 offset,
  60                                            u16 *data);
  61 STATIC s32  e1000_reset_hw_82575(struct e1000_hw *hw);
  62 STATIC s32  e1000_reset_hw_82580(struct e1000_hw *hw);
  63 STATIC s32  e1000_read_phy_reg_82580(struct e1000_hw *hw,
  64                                      u32 offset, u16 *data);
  65 STATIC s32  e1000_write_phy_reg_82580(struct e1000_hw *hw,
  66                                       u32 offset, u16 data);
  67 STATIC s32  e1000_set_d0_lplu_state_82580(struct e1000_hw *hw,
  68                                           bool active);
  69 STATIC s32  e1000_set_d3_lplu_state_82580(struct e1000_hw *hw,
  70                                           bool active);
  71 STATIC s32  e1000_set_d0_lplu_state_82575(struct e1000_hw *hw,
  72                                           bool active);
  73 STATIC s32  e1000_setup_copper_link_82575(struct e1000_hw *hw);
  74 STATIC s32  e1000_setup_serdes_link_82575(struct e1000_hw *hw);
  75 STATIC s32  e1000_get_media_type_82575(struct e1000_hw *hw);
  76 STATIC s32  e1000_set_sfp_media_type_82575(struct e1000_hw *hw);
  77 STATIC s32  e1000_valid_led_default_82575(struct e1000_hw *hw, u16 *data);
  78 STATIC s32  e1000_write_phy_reg_sgmii_82575(struct e1000_hw *hw,
  79                                             u32 offset, u16 data);
  80 STATIC void e1000_clear_hw_cntrs_82575(struct e1000_hw *hw);
  81 STATIC s32  e1000_acquire_swfw_sync_82575(struct e1000_hw *hw, u16 mask);
  82 STATIC s32  e1000_get_pcs_speed_and_duplex_82575(struct e1000_hw *hw,
  83                                                  u16 *speed, u16 *duplex);
  84 STATIC s32  e1000_get_phy_id_82575(struct e1000_hw *hw);
  85 STATIC void e1000_release_swfw_sync_82575(struct e1000_hw *hw, u16 mask);
  86 STATIC bool e1000_sgmii_active_82575(struct e1000_hw *hw);
  87 STATIC s32  e1000_reset_init_script_82575(struct e1000_hw *hw);
  88 STATIC s32  e1000_read_mac_addr_82575(struct e1000_hw *hw);
  89 STATIC void e1000_config_collision_dist_82575(struct e1000_hw *hw);
  90 STATIC void e1000_power_down_phy_copper_82575(struct e1000_hw *hw);
  91 STATIC void e1000_shutdown_serdes_link_82575(struct e1000_hw *hw);
  92 STATIC void e1000_power_up_serdes_link_82575(struct e1000_hw *hw);
  93 STATIC s32 e1000_set_pcie_completion_timeout(struct e1000_hw *hw);
  94 STATIC s32 e1000_reset_mdicnfg_82580(struct e1000_hw *hw);
  95 STATIC s32 e1000_validate_nvm_checksum_82580(struct e1000_hw *hw);
  96 STATIC s32 e1000_update_nvm_checksum_82580(struct e1000_hw *hw);
  97 STATIC s32 e1000_update_nvm_checksum_with_offset(struct e1000_hw *hw,
  98                                                  u16 offset);
  99 STATIC s32 e1000_validate_nvm_checksum_with_offset(struct e1000_hw *hw,
 100                                                    u16 offset);
 101 STATIC s32 e1000_validate_nvm_checksum_i350(struct e1000_hw *hw);
 102 STATIC s32 e1000_update_nvm_checksum_i350(struct e1000_hw *hw);
 103 STATIC void e1000_write_vfta_i350(struct e1000_hw *hw, u32 offset, u32 value);
 104 STATIC void e1000_clear_vfta_i350(struct e1000_hw *hw);
 105
 106 STATIC void e1000_i2c_start(struct e1000_hw *hw);
 107 STATIC void e1000_i2c_stop(struct e1000_hw *hw);
 108 STATIC s32 e1000_clock_in_i2c_byte(struct e1000_hw *hw, u8 *data);
 109 STATIC s32 e1000_clock_out_i2c_byte(struct e1000_hw *hw, u8 data);
 110 STATIC s32 e1000_get_i2c_ack(struct e1000_hw *hw);
 111 STATIC s32 e1000_clock_in_i2c_bit(struct e1000_hw *hw, bool *data);
 112 STATIC s32 e1000_clock_out_i2c_bit(struct e1000_hw *hw, bool data);
 113 STATIC void e1000_raise_i2c_clk(struct e1000_hw *hw, u32 *i2cctl);
 114 STATIC void e1000_lower_i2c_clk(struct e1000_hw *hw, u32 *i2cctl);
 115 STATIC s32 e1000_set_i2c_data(struct e1000_hw *hw, u32 *i2cctl, bool data);
 116 STATIC bool e1000_get_i2c_data(u32 *i2cctl);
 117
 118 STATIC const u16 e1000_82580_rxpbs_table[] = {
 119         36, 72, 144, 1, 2, 4, 8, 16, 35, 70, 140 };
 120 #define E1000_82580_RXPBS_TABLE_SIZE \
 121         (sizeof(e1000_82580_rxpbs_table) / \
 122          sizeof(e1000_82580_rxpbs_table[0]))
 123
 124
 125 /**
 126  *  e1000_sgmii_uses_mdio_82575 - Determine if I2C pins are for external MDIO
 127  *  @hw: pointer to the HW structure
 128  *
 129  *  Called to determine if the I2C pins are being used for I2C or as an
 130  *  external MDIO interface since the two options are mutually exclusive.
 131  **/
 132 STATIC bool e1000_sgmii_uses_mdio_82575(struct e1000_hw *hw)
 133 {
 134         u32 reg = 0;
 135         bool ext_mdio = false;
 136
 137         DEBUGFUNC("e1000_sgmii_uses_mdio_82575");
 138
 139         switch (hw->mac.type) {
 140         case e1000_82575:
 141         case e1000_82576:
 142                 reg = E1000_READ_REG(hw, E1000_MDIC);
 143                 ext_mdio = !!(reg & E1000_MDIC_DEST);
 144                 break;
 145         case e1000_82580:
 146         case e1000_i350:
 147         case e1000_i354:
 148         case e1000_i210:
 149         case e1000_i211:
 150                 reg = E1000_READ_REG(hw, E1000_MDICNFG);
 151                 ext_mdio = !!(reg & E1000_MDICNFG_EXT_MDIO);
 152                 break;
 153         default:
 154                 break;
 155         }
 156         return ext_mdio;
 157 }
 158
 159 /**
 160  *  e1000_init_phy_params_82575 - Init PHY func ptrs.
 161  *  @hw: pointer to the HW structure
 162  **/
 163 STATIC s32 e1000_init_phy_params_82575(struct e1000_hw *hw)
 164 {
 165         struct e1000_phy_info *phy = &hw->phy;
 166         s32 ret_val = E1000_SUCCESS;
 167         u32 ctrl_ext;
 168
 169         DEBUGFUNC("e1000_init_phy_params_82575");
 170
 171         phy->ops.read_i2c_byte = e1000_read_i2c_byte_generic;
 172         phy->ops.write_i2c_byte = e1000_write_i2c_byte_generic;
 173
 174         if (hw->phy.media_type != e1000_media_type_copper) {
 175                 phy->type = e1000_phy_none;
 176                 goto out;
 177         }
 178
 179         phy->ops.power_up   = e1000_power_up_phy_copper;
 180         phy->ops.power_down = e1000_power_down_phy_copper_82575;
 181
 182         phy->autoneg_mask       = AUTONEG_ADVERTISE_SPEED_DEFAULT;
 183         phy->reset_delay_us     = 100;
 184
 185         phy->ops.acquire        = e1000_acquire_phy_82575;
 186         phy->ops.check_reset_block = e1000_check_reset_block_generic;
 187         phy->ops.commit         = e1000_phy_sw_reset_generic;
 188         phy->ops.get_cfg_done   = e1000_get_cfg_done_82575;
 189         phy->ops.release        = e1000_release_phy_82575;
 190
 191         ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
 192
 193         if (e1000_sgmii_active_82575(hw)) {
 194                 phy->ops.reset = e1000_phy_hw_reset_sgmii_82575;
 195                 ctrl_ext |= E1000_CTRL_I2C_ENA;
 196         } else {
 197                 phy->ops.reset = e1000_phy_hw_reset_generic;
 198                 ctrl_ext &= ~E1000_CTRL_I2C_ENA;
 199         }
 200
 201         E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
 202         e1000_reset_mdicnfg_82580(hw);
 203
 204         if (e1000_sgmii_active_82575(hw) && !e1000_sgmii_uses_mdio_82575(hw)) {
 205                 phy->ops.read_reg = e1000_read_phy_reg_sgmii_82575;
 206                 phy->ops.write_reg = e1000_write_phy_reg_sgmii_82575;
 207         } else {
 208                 switch (hw->mac.type) {
 209                 case e1000_82580:
 210                 case e1000_i350:
 211                 case e1000_i354:
 212                         phy->ops.read_reg = e1000_read_phy_reg_82580;
 213                         phy->ops.write_reg = e1000_write_phy_reg_82580;
 214                         break;
 215                 case e1000_i210:
 216                 case e1000_i211:
 217                         phy->ops.read_reg = e1000_read_phy_reg_gs40g;
 218                         phy->ops.write_reg = e1000_write_phy_reg_gs40g;
 219                         break;
 220                 default:
 221                         phy->ops.read_reg = e1000_read_phy_reg_igp;
 222                         phy->ops.write_reg = e1000_write_phy_reg_igp;
 223                 }
 224         }
 225
 226         /* Set phy->phy_addr and phy->id. */
 227         ret_val = e1000_get_phy_id_82575(hw);
 228
 229         /* Verify phy id and set remaining function pointers */
 230         switch (phy->id) {
 231         case M88E1543_E_PHY_ID:
 232         case M88E1512_E_PHY_ID:
 233         case I347AT4_E_PHY_ID:
 234         case M88E1112_E_PHY_ID:
 235         case M88E1340M_E_PHY_ID:
 236         case M88E1111_I_PHY_ID:
 237                 phy->type               = e1000_phy_m88;
 238                 phy->ops.check_polarity = e1000_check_polarity_m88;
 239                 phy->ops.get_info       = e1000_get_phy_info_m88;
 240                 if (phy->id == I347AT4_E_PHY_ID ||
 241                     phy->id == M88E1112_E_PHY_ID ||
 242                     phy->id == M88E1340M_E_PHY_ID)
 243                         phy->ops.get_cable_length =
 244                                          e1000_get_cable_length_m88_gen2;
 245                 else if (phy->id == M88E1543_E_PHY_ID ||
 246                          phy->id == M88E1512_E_PHY_ID)
 247                         phy->ops.get_cable_length =
 248                                          e1000_get_cable_length_m88_gen2;
 249                 else
 250                         phy->ops.get_cable_length = e1000_get_cable_length_m88;
 251                 phy->ops.force_speed_duplex = e1000_phy_force_speed_duplex_m88;
 252                 /* Check if this PHY is confgured for media swap. */
 253                 if (phy->id == M88E1112_E_PHY_ID) {
 254                         u16 data;
 255
 256                         ret_val = phy->ops.write_reg(hw,
 257                                                      E1000_M88E1112_PAGE_ADDR,
 258                                                      2);
 259                         if (ret_val)
 260                                 goto out;
 261
 262                         ret_val = phy->ops.read_reg(hw,
 263                                                     E1000_M88E1112_MAC_CTRL_1,
 264                                                     &data);
 265                         if (ret_val)
 266                                 goto out;
 267
 268                         data = (data & E1000_M88E1112_MAC_CTRL_1_MODE_MASK) >>
 269                                E1000_M88E1112_MAC_CTRL_1_MODE_SHIFT;
 270                         if (data == E1000_M88E1112_AUTO_COPPER_SGMII ||
 271                             data == E1000_M88E1112_AUTO_COPPER_BASEX)
 272                                 hw->mac.ops.check_for_link =
 273                                                 e1000_check_for_link_media_swap;
 274                 }
 275                 if (phy->id == M88E1512_E_PHY_ID) {
 276                         ret_val = e1000_initialize_M88E1512_phy(hw);
 277                         if (ret_val)
 278                                 goto out;
 279                 }
 280                 break;
 281         case IGP03E1000_E_PHY_ID:
 282         case IGP04E1000_E_PHY_ID:
 283                 phy->type = e1000_phy_igp_3;
 284                 phy->ops.check_polarity = e1000_check_polarity_igp;
 285                 phy->ops.get_info = e1000_get_phy_info_igp;
 286                 phy->ops.get_cable_length = e1000_get_cable_length_igp_2;
 287                 phy->ops.force_speed_duplex = e1000_phy_force_speed_duplex_igp;
 288                 phy->ops.set_d0_lplu_state = e1000_set_d0_lplu_state_82575;
 289                 phy->ops.set_d3_lplu_state = e1000_set_d3_lplu_state_generic;
 290                 break;
 291         case I82580_I_PHY_ID:
 292         case I350_I_PHY_ID:
 293                 phy->type = e1000_phy_82580;
 294                 phy->ops.check_polarity = e1000_check_polarity_82577;
 295                 phy->ops.force_speed_duplex =
 296                                          e1000_phy_force_speed_duplex_82577;
 297                 phy->ops.get_cable_length = e1000_get_cable_length_82577;
 298                 phy->ops.get_info = e1000_get_phy_info_82577;
 299                 phy->ops.set_d0_lplu_state = e1000_set_d0_lplu_state_82580;
 300                 phy->ops.set_d3_lplu_state = e1000_set_d3_lplu_state_82580;
 301                 break;
 302         case I210_I_PHY_ID:
 303                 phy->type               = e1000_phy_i210;
 304                 phy->ops.check_polarity = e1000_check_polarity_m88;
 305                 phy->ops.get_info       = e1000_get_phy_info_m88;
 306                 phy->ops.get_cable_length = e1000_get_cable_length_m88_gen2;
 307                 phy->ops.set_d0_lplu_state = e1000_set_d0_lplu_state_82580;
 308                 phy->ops.set_d3_lplu_state = e1000_set_d3_lplu_state_82580;
 309                 phy->ops.force_speed_duplex = e1000_phy_force_speed_duplex_m88;
 310                 break;
 311         default:
 312                 ret_val = -E1000_ERR_PHY;
 313                 goto out;
 314         }
 315
 316 out:
 317         return ret_val;
 318 }
 319
 320 /**
 321  *  e1000_init_nvm_params_82575 - Init NVM func ptrs.
 322  *  @hw: pointer to the HW structure
 323  **/
 324 s32 e1000_init_nvm_params_82575(struct e1000_hw *hw)
 325 {
 326         struct e1000_nvm_info *nvm = &hw->nvm;
 327         u32 eecd = E1000_READ_REG(hw, E1000_EECD);
 328         u16 size;
 329
 330         DEBUGFUNC("e1000_init_nvm_params_82575");
 331
 332         size = (u16)((eecd & E1000_EECD_SIZE_EX_MASK) >>
 333                      E1000_EECD_SIZE_EX_SHIFT);
 334         /*
 335          * Added to a constant, "size" becomes the left-shift value
 336          * for setting word_size.
 337          */
 338         size += NVM_WORD_SIZE_BASE_SHIFT;
 339
 340         /* Just in case size is out of range, cap it to the largest
 341          * EEPROM size supported
 342          */
 343         if (size > 15)
 344                 size = 15;
 345
 346         nvm->word_size = 1 << size;
 347         if (hw->mac.type < e1000_i210) {
 348                 nvm->opcode_bits = 8;
 349                 nvm->delay_usec = 1;
 350
 351                 switch (nvm->override) {
 352                 case e1000_nvm_override_spi_large:
 353                         nvm->page_size = 32;
 354                         nvm->address_bits = 16;
 355                         break;
 356                 case e1000_nvm_override_spi_small:
 357                         nvm->page_size = 8;
 358                         nvm->address_bits = 8;
 359                         break;
 360                 default:
 361                         nvm->page_size = eecd & E1000_EECD_ADDR_BITS ? 32 : 8;
 362                         nvm->address_bits = eecd & E1000_EECD_ADDR_BITS ?
 363                                             16 : 8;
 364                         break;
 365                 }
 366                 if (nvm->word_size == (1 << 15))
 367                         nvm->page_size = 128;
 368
 369                 nvm->type = e1000_nvm_eeprom_spi;
 370         } else {
 371                 nvm->type = e1000_nvm_flash_hw;
 372         }
 373
 374         /* Function Pointers */
 375         nvm->ops.acquire = e1000_acquire_nvm_82575;
 376         nvm->ops.release = e1000_release_nvm_82575;
 377         if (nvm->word_size < (1 << 15))
 378                 nvm->ops.read = e1000_read_nvm_eerd;
 379         else
 380                 nvm->ops.read = e1000_read_nvm_spi;
 381
 382         nvm->ops.write = e1000_write_nvm_spi;
 383         nvm->ops.validate = e1000_validate_nvm_checksum_generic;
 384         nvm->ops.update = e1000_update_nvm_checksum_generic;
 385         nvm->ops.valid_led_default = e1000_valid_led_default_82575;
 386
 387         /* override generic family function pointers for specific descendants */
 388         switch (hw->mac.type) {
 389         case e1000_82580:
 390                 nvm->ops.validate = e1000_validate_nvm_checksum_82580;
 391                 nvm->ops.update = e1000_update_nvm_checksum_82580;
 392                 break;
 393         case e1000_i350:
 394         case e1000_i354:
 395                 nvm->ops.validate = e1000_validate_nvm_checksum_i350;
 396                 nvm->ops.update = e1000_update_nvm_checksum_i350;
 397                 break;
 398         default:
 399                 break;
 400         }
 401
 402         return E1000_SUCCESS;
 403 }
 404
 405 /**
 406  *  e1000_init_mac_params_82575 - Init MAC func ptrs.
 407  *  @hw: pointer to the HW structure
 408  **/
 409 STATIC s32 e1000_init_mac_params_82575(struct e1000_hw *hw)
 410 {
 411         struct e1000_mac_info *mac = &hw->mac;
 412         struct e1000_dev_spec_82575 *dev_spec = &hw->dev_spec._82575;
 413
 414         DEBUGFUNC("e1000_init_mac_params_82575");
 415
 416         /* Derives media type */
 417         e1000_get_media_type_82575(hw);
 418         /* Set mta register count */
 419         mac->mta_reg_count = 128;
 420         /* Set uta register count */
 421         mac->uta_reg_count = (hw->mac.type == e1000_82575) ? 0 : 128;
 422         /* Set rar entry count */
 423         mac->rar_entry_count = E1000_RAR_ENTRIES_82575;
 424         if (mac->type == e1000_82576)
 425                 mac->rar_entry_count = E1000_RAR_ENTRIES_82576;
 426         if (mac->type == e1000_82580)
 427                 mac->rar_entry_count = E1000_RAR_ENTRIES_82580;
 428         if (mac->type == e1000_i350 || mac->type == e1000_i354)
 429                 mac->rar_entry_count = E1000_RAR_ENTRIES_I350;
 430
 431         /* Enable EEE default settings for EEE supported devices */
 432         if (mac->type >= e1000_i350)
 433                 dev_spec->eee_disable = false;
 434
 435         /* Allow a single clear of the SW semaphore on I210 and newer */
 436         if (mac->type >= e1000_i210)
 437                 dev_spec->clear_semaphore_once = true;
 438
 439         /* Set if part includes ASF firmware */
 440         mac->asf_firmware_present = true;
 441         /* FWSM register */
 442         mac->has_fwsm = true;
 443         /* ARC supported; valid only if manageability features are enabled. */
 444         mac->arc_subsystem_valid =
 445                 !!(E1000_READ_REG(hw, E1000_FWSM) & E1000_FWSM_MODE_MASK);
 446
 447         /* Function pointers */
 448
 449         /* bus type/speed/width */
 450         mac->ops.get_bus_info = e1000_get_bus_info_pcie_generic;
 451         /* reset */
 452         if (mac->type >= e1000_82580)
 453                 mac->ops.reset_hw = e1000_reset_hw_82580;
 454         else
 455         mac->ops.reset_hw = e1000_reset_hw_82575;
 456         /* hw initialization */
 457         if ((mac->type == e1000_i210) || (mac->type == e1000_i211))
 458                 mac->ops.init_hw = e1000_init_hw_i210;
 459         else
 460         mac->ops.init_hw = e1000_init_hw_82575;
 461         /* link setup */
 462         mac->ops.setup_link = e1000_setup_link_generic;
 463         /* physical interface link setup */
 464         mac->ops.setup_physical_interface =
 465                 (hw->phy.media_type == e1000_media_type_copper)
 466                 ? e1000_setup_copper_link_82575 : e1000_setup_serdes_link_82575;
 467         /* physical interface shutdown */
 468         mac->ops.shutdown_serdes = e1000_shutdown_serdes_link_82575;
 469         /* physical interface power up */
 470         mac->ops.power_up_serdes = e1000_power_up_serdes_link_82575;
 471         /* check for link */
 472         mac->ops.check_for_link = e1000_check_for_link_82575;
 473         /* read mac address */
 474         mac->ops.read_mac_addr = e1000_read_mac_addr_82575;
 475         /* configure collision distance */
 476         mac->ops.config_collision_dist = e1000_config_collision_dist_82575;
 477         /* multicast address update */
 478         mac->ops.update_mc_addr_list = e1000_update_mc_addr_list_generic;
 479         if (hw->mac.type == e1000_i350 || mac->type == e1000_i354) {
 480                 /* writing VFTA */
 481                 mac->ops.write_vfta = e1000_write_vfta_i350;
 482                 /* clearing VFTA */
 483                 mac->ops.clear_vfta = e1000_clear_vfta_i350;
 484         } else {
 485                 /* writing VFTA */
 486                 mac->ops.write_vfta = e1000_write_vfta_generic;
 487                 /* clearing VFTA */
 488                 mac->ops.clear_vfta = e1000_clear_vfta_generic;
 489         }
 490         if (hw->mac.type >= e1000_82580)
 491                 mac->ops.validate_mdi_setting =
 492                                 e1000_validate_mdi_setting_crossover_generic;
 493         /* ID LED init */
 494         mac->ops.id_led_init = e1000_id_led_init_generic;
 495         /* blink LED */
 496         mac->ops.blink_led = e1000_blink_led_generic;
 497         /* setup LED */
 498         mac->ops.setup_led = e1000_setup_led_generic;
 499         /* cleanup LED */
 500         mac->ops.cleanup_led = e1000_cleanup_led_generic;
 501         /* turn on/off LED */
 502         mac->ops.led_on = e1000_led_on_generic;
 503         mac->ops.led_off = e1000_led_off_generic;
 504         /* clear hardware counters */
 505         mac->ops.clear_hw_cntrs = e1000_clear_hw_cntrs_82575;
 506         /* link info */
 507         mac->ops.get_link_up_info = e1000_get_link_up_info_82575;
 508         /* acquire SW_FW sync */
 509         mac->ops.acquire_swfw_sync = e1000_acquire_swfw_sync_82575;
 510         mac->ops.release_swfw_sync = e1000_release_swfw_sync_82575;
 511         if (mac->type >= e1000_i210) {
 512                 mac->ops.acquire_swfw_sync = e1000_acquire_swfw_sync_i210;
 513                 mac->ops.release_swfw_sync = e1000_release_swfw_sync_i210;
 514         }
 515
 516         /* set lan id for port to determine which phy lock to use */
 517         hw->mac.ops.set_lan_id(hw);
 518
 519         return E1000_SUCCESS;
 520 }
 521
 522 /**
 523  *  e1000_init_function_pointers_82575 - Init func ptrs.
 524  *  @hw: pointer to the HW structure
 525  *
 526  *  Called to initialize all function pointers and parameters.
 527  **/
 528 void e1000_init_function_pointers_82575(struct e1000_hw *hw)
 529 {
 530         DEBUGFUNC("e1000_init_function_pointers_82575");
 531
 532         hw->mac.ops.init_params = e1000_init_mac_params_82575;
 533         hw->nvm.ops.init_params = e1000_init_nvm_params_82575;
 534         hw->phy.ops.init_params = e1000_init_phy_params_82575;
 535         hw->mbx.ops.init_params = e1000_init_mbx_params_pf;
 536 }
 537
 538 /**
 539  *  e1000_acquire_phy_82575 - Acquire rights to access PHY
 540  *  @hw: pointer to the HW structure
 541  *
 542  *  Acquire access rights to the correct PHY.
 543  **/
 544 STATIC s32 e1000_acquire_phy_82575(struct e1000_hw *hw)
 545 {
 546         u16 mask = E1000_SWFW_PHY0_SM;
 547
 548         DEBUGFUNC("e1000_acquire_phy_82575");
 549
 550         if (hw->bus.func == E1000_FUNC_1)
 551                 mask = E1000_SWFW_PHY1_SM;
 552         else if (hw->bus.func == E1000_FUNC_2)
 553                 mask = E1000_SWFW_PHY2_SM;
 554         else if (hw->bus.func == E1000_FUNC_3)
 555                 mask = E1000_SWFW_PHY3_SM;
 556
 557         return hw->mac.ops.acquire_swfw_sync(hw, mask);
 558 }
 559
 560 /**
 561  *  e1000_release_phy_82575 - Release rights to access PHY
 562  *  @hw: pointer to the HW structure
 563  *
 564  *  A wrapper to release access rights to the correct PHY.
 565  **/
 566 STATIC void e1000_release_phy_82575(struct e1000_hw *hw)
 567 {
 568         u16 mask = E1000_SWFW_PHY0_SM;
 569
 570         DEBUGFUNC("e1000_release_phy_82575");
 571
 572         if (hw->bus.func == E1000_FUNC_1)
 573                 mask = E1000_SWFW_PHY1_SM;
 574         else if (hw->bus.func == E1000_FUNC_2)
 575                 mask = E1000_SWFW_PHY2_SM;
 576         else if (hw->bus.func == E1000_FUNC_3)
 577                 mask = E1000_SWFW_PHY3_SM;
 578
 579         hw->mac.ops.release_swfw_sync(hw, mask);
 580 }
 581
 582 /**
 583  *  e1000_read_phy_reg_sgmii_82575 - Read PHY register using sgmii
 584  *  @hw: pointer to the HW structure
 585  *  @offset: register offset to be read
 586  *  @data: pointer to the read data
 587  *
 588  *  Reads the PHY register at offset using the serial gigabit media independent
 589  *  interface and stores the retrieved information in data.
 590  **/
 591 STATIC s32 e1000_read_phy_reg_sgmii_82575(struct e1000_hw *hw, u32 offset,
 592                                           u16 *data)
 593 {
 594         s32 ret_val = -E1000_ERR_PARAM;
 595
 596         DEBUGFUNC("e1000_read_phy_reg_sgmii_82575");
 597
 598         if (offset > E1000_MAX_SGMII_PHY_REG_ADDR) {
 599                 DEBUGOUT1("PHY Address %u is out of range\n", offset);
 600                 goto out;
 601         }
 602
 603         ret_val = hw->phy.ops.acquire(hw);
 604         if (ret_val)
 605                 goto out;
 606
 607         ret_val = e1000_read_phy_reg_i2c(hw, offset, data);
 608
 609         hw->phy.ops.release(hw);
 610
 611 out:
 612         return ret_val;
 613 }
 614
 615 /**
 616  *  e1000_write_phy_reg_sgmii_82575 - Write PHY register using sgmii
 617  *  @hw: pointer to the HW structure
 618  *  @offset: register offset to write to
 619  *  @data: data to write at register offset
 620  *
 621  *  Writes the data to PHY register at the offset using the serial gigabit
 622  *  media independent interface.
 623  **/
 624 STATIC s32 e1000_write_phy_reg_sgmii_82575(struct e1000_hw *hw, u32 offset,
 625                                            u16 data)
 626 {
 627         s32 ret_val = -E1000_ERR_PARAM;
 628
 629         DEBUGFUNC("e1000_write_phy_reg_sgmii_82575");
 630
 631         if (offset > E1000_MAX_SGMII_PHY_REG_ADDR) {
 632                 DEBUGOUT1("PHY Address %d is out of range\n", offset);
 633                 goto out;
 634         }
 635
 636         ret_val = hw->phy.ops.acquire(hw);
 637         if (ret_val)
 638                 goto out;
 639
 640         ret_val = e1000_write_phy_reg_i2c(hw, offset, data);
 641
 642         hw->phy.ops.release(hw);
 643
 644 out:
 645         return ret_val;
 646 }
 647
 648 /**
 649  *  e1000_get_phy_id_82575 - Retrieve PHY addr and id
 650  *  @hw: pointer to the HW structure
 651  *
 652  *  Retrieves the PHY address and ID for both PHY's which do and do not use
 653  *  sgmi interface.
 654  **/
 655 STATIC s32 e1000_get_phy_id_82575(struct e1000_hw *hw)
 656 {
 657         struct e1000_phy_info *phy = &hw->phy;
 658         s32  ret_val = E1000_SUCCESS;
 659         u16 phy_id;
 660         u32 ctrl_ext;
 661         u32 mdic;
 662
 663         DEBUGFUNC("e1000_get_phy_id_82575");
 664
 665         /* some i354 devices need an extra read for phy id */
 666         if (hw->mac.type == e1000_i354)
 667                 e1000_get_phy_id(hw);
 668
 669         /*
 670          * For SGMII PHYs, we try the list of possible addresses until
 671          * we find one that works.  For non-SGMII PHYs
 672          * (e.g. integrated copper PHYs), an address of 1 should
 673          * work.  The result of this function should mean phy->phy_addr
 674          * and phy->id are set correctly.
 675          */
 676         if (!e1000_sgmii_active_82575(hw)) {
 677                 phy->addr = 1;
 678                 ret_val = e1000_get_phy_id(hw);
 679                 goto out;
 680         }
 681
 682         if (e1000_sgmii_uses_mdio_82575(hw)) {
 683                 switch (hw->mac.type) {
 684                 case e1000_82575:
 685                 case e1000_82576:
 686                         mdic = E1000_READ_REG(hw, E1000_MDIC);
 687                         mdic &= E1000_MDIC_PHY_MASK;
 688                         phy->addr = mdic >> E1000_MDIC_PHY_SHIFT;
 689                         break;
 690                 case e1000_82580:
 691                 case e1000_i350:
 692                 case e1000_i354:
 693                 case e1000_i210:
 694                 case e1000_i211:
 695                         mdic = E1000_READ_REG(hw, E1000_MDICNFG);
 696                         mdic &= E1000_MDICNFG_PHY_MASK;
 697                         phy->addr = mdic >> E1000_MDICNFG_PHY_SHIFT;
 698                         break;
 699                 default:
 700                         ret_val = -E1000_ERR_PHY;
 701                         goto out;
 702                         break;
 703                 }
 704                 ret_val = e1000_get_phy_id(hw);
 705                 goto out;
 706         }
 707
 708         /* Power on sgmii phy if it is disabled */
 709         ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
 710         E1000_WRITE_REG(hw, E1000_CTRL_EXT,
 711                         ctrl_ext & ~E1000_CTRL_EXT_SDP3_DATA);
 712         E1000_WRITE_FLUSH(hw);
 713         msec_delay(300);
 714
 715         /*
 716          * The address field in the I2CCMD register is 3 bits and 0 is invalid.
 717          * Therefore, we need to test 1-7
 718          */
 719         for (phy->addr = 1; phy->addr < 8; phy->addr++) {
 720                 ret_val = e1000_read_phy_reg_sgmii_82575(hw, PHY_ID1, &phy_id);
 721                 if (ret_val == E1000_SUCCESS) {
 722                         DEBUGOUT2("Vendor ID 0x%08X read at address %u\n",
 723                                   phy_id, phy->addr);
 724                         /*
 725                          * At the time of this writing, The M88 part is
 726                          * the only supported SGMII PHY product.
 727                          */
 728                         if (phy_id == M88_VENDOR)
 729                                 break;
 730                 } else {
 731                         DEBUGOUT1("PHY address %u was unreadable\n",
 732                                   phy->addr);
 733                 }
 734         }
 735
 736         /* A valid PHY type couldn't be found. */
 737         if (phy->addr == 8) {
 738                 phy->addr = 0;
 739                 ret_val = -E1000_ERR_PHY;
 740         } else {
 741                 ret_val = e1000_get_phy_id(hw);
 742         }
 743
 744         /* restore previous sfp cage power state */
 745         E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
 746
 747 out:
 748         return ret_val;
 749 }
 750
 751 /**
 752  *  e1000_phy_hw_reset_sgmii_82575 - Performs a PHY reset
 753  *  @hw: pointer to the HW structure
 754  *
 755  *  Resets the PHY using the serial gigabit media independent interface.
 756  **/
 757 STATIC s32 e1000_phy_hw_reset_sgmii_82575(struct e1000_hw *hw)
 758 {
 759         s32 ret_val = E1000_SUCCESS;
 760         struct e1000_phy_info *phy = &hw->phy;
 761
 762         DEBUGFUNC("e1000_phy_hw_reset_sgmii_82575");
 763
 764         /*
 765          * This isn't a true "hard" reset, but is the only reset
 766          * available to us at this time.
 767          */
 768
 769         DEBUGOUT("Soft resetting SGMII attached PHY...\n");
 770
 771         if (!(hw->phy.ops.write_reg))
 772                 goto out;
 773
 774         /*
 775          * SFP documentation requires the following to configure the SPF module
 776          * to work on SGMII.  No further documentation is given.
 777          */
 778         ret_val = hw->phy.ops.write_reg(hw, 0x1B, 0x8084);
 779         if (ret_val)
 780                 goto out;
 781
 782         ret_val = hw->phy.ops.commit(hw);
 783         if (ret_val)
 784                 goto out;
 785
 786         if (phy->id == M88E1512_E_PHY_ID)
 787                 ret_val = e1000_initialize_M88E1512_phy(hw);
 788 out:
 789         return ret_val;
 790 }
 791
 792 /**
 793  *  e1000_set_d0_lplu_state_82575 - Set Low Power Linkup D0 state
 794  *  @hw: pointer to the HW structure
 795  *  @active: true to enable LPLU, false to disable
 796  *
 797  *  Sets the LPLU D0 state according to the active flag.  When
 798  *  activating LPLU this function also disables smart speed
 799  *  and vice versa.  LPLU will not be activated unless the
 800  *  device autonegotiation advertisement meets standards of
 801  *  either 10 or 10/100 or 10/100/1000 at all duplexes.
 802  *  This is a function pointer entry point only called by
 803  *  PHY setup routines.
 804  **/
 805 STATIC s32 e1000_set_d0_lplu_state_82575(struct e1000_hw *hw, bool active)
 806 {
 807         struct e1000_phy_info *phy = &hw->phy;
 808         s32 ret_val = E1000_SUCCESS;
 809         u16 data;
 810
 811         DEBUGFUNC("e1000_set_d0_lplu_state_82575");
 812
 813         if (!(hw->phy.ops.read_reg))
 814                 goto out;
 815
 816         ret_val = phy->ops.read_reg(hw, IGP02E1000_PHY_POWER_MGMT, &data);
 817         if (ret_val)
 818                 goto out;
 819
 820         if (active) {
 821                 data |= IGP02E1000_PM_D0_LPLU;
 822                 ret_val = phy->ops.write_reg(hw, IGP02E1000_PHY_POWER_MGMT,
 823                                              data);
 824                 if (ret_val)
 825                         goto out;
 826
 827                 /* When LPLU is enabled, we should disable SmartSpeed */
 828                 ret_val = phy->ops.read_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
 829                                             &data);
 830                 data &= ~IGP01E1000_PSCFR_SMART_SPEED;
 831                 ret_val = phy->ops.write_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
 832                                              data);
 833                 if (ret_val)
 834                         goto out;
 835         } else {
 836                 data &= ~IGP02E1000_PM_D0_LPLU;
 837                 ret_val = phy->ops.write_reg(hw, IGP02E1000_PHY_POWER_MGMT,
 838                                              data);
 839                 /*
 840                  * LPLU and SmartSpeed are mutually exclusive.  LPLU is used
 841                  * during Dx states where the power conservation is most
 842                  * important.  During driver activity we should enable
 843                  * SmartSpeed, so performance is maintained.
 844                  */
 845                 if (phy->smart_speed == e1000_smart_speed_on) {
 846                         ret_val = phy->ops.read_reg(hw,
 847                                                     IGP01E1000_PHY_PORT_CONFIG,
 848                                                     &data);
 849                         if (ret_val)
 850                                 goto out;
 851
 852                         data |= IGP01E1000_PSCFR_SMART_SPEED;
 853                         ret_val = phy->ops.write_reg(hw,
 854                                                      IGP01E1000_PHY_PORT_CONFIG,
 855                                                      data);
 856                         if (ret_val)
 857                                 goto out;
 858                 } else if (phy->smart_speed == e1000_smart_speed_off) {
 859                         ret_val = phy->ops.read_reg(hw,
 860                                                     IGP01E1000_PHY_PORT_CONFIG,
 861                                                     &data);
 862                         if (ret_val)
 863                                 goto out;
 864
 865                         data &= ~IGP01E1000_PSCFR_SMART_SPEED;
 866                         ret_val = phy->ops.write_reg(hw,
 867                                                      IGP01E1000_PHY_PORT_CONFIG,
 868                                                      data);
 869                         if (ret_val)
 870                                 goto out;
 871                 }
 872         }
 873
 874 out:
 875         return ret_val;
 876 }
 877
 878 /**
 879  *  e1000_set_d0_lplu_state_82580 - Set Low Power Linkup D0 state
 880  *  @hw: pointer to the HW structure
 881  *  @active: true to enable LPLU, false to disable
 882  *
 883  *  Sets the LPLU D0 state according to the active flag.  When
 884  *  activating LPLU this function also disables smart speed
 885  *  and vice versa.  LPLU will not be activated unless the
 886  *  device autonegotiation advertisement meets standards of
 887  *  either 10 or 10/100 or 10/100/1000 at all duplexes.
 888  *  This is a function pointer entry point only called by
 889  *  PHY setup routines.
 890  **/
 891 STATIC s32 e1000_set_d0_lplu_state_82580(struct e1000_hw *hw, bool active)
 892 {
 893         struct e1000_phy_info *phy = &hw->phy;
 894         u32 data;
 895
 896         DEBUGFUNC("e1000_set_d0_lplu_state_82580");
 897
 898         data = E1000_READ_REG(hw, E1000_82580_PHY_POWER_MGMT);
 899
 900         if (active) {
 901                 data |= E1000_82580_PM_D0_LPLU;
 902
 903                 /* When LPLU is enabled, we should disable SmartSpeed */
 904                 data &= ~E1000_82580_PM_SPD;
 905         } else {
 906                 data &= ~E1000_82580_PM_D0_LPLU;
 907
 908                 /*
 909                  * LPLU and SmartSpeed are mutually exclusive.  LPLU is used
 910                  * during Dx states where the power conservation is most
 911                  * important.  During driver activity we should enable
 912                  * SmartSpeed, so performance is maintained.
 913                  */
 914                 if (phy->smart_speed == e1000_smart_speed_on)
 915                         data |= E1000_82580_PM_SPD;
 916                 else if (phy->smart_speed == e1000_smart_speed_off)
 917                         data &= ~E1000_82580_PM_SPD;
 918         }
 919
 920         E1000_WRITE_REG(hw, E1000_82580_PHY_POWER_MGMT, data);
 921         return E1000_SUCCESS;
 922 }
 923
 924 /**
 925  *  e1000_set_d3_lplu_state_82580 - Sets low power link up state for D3
 926  *  @hw: pointer to the HW structure
 927  *  @active: boolean used to enable/disable lplu
 928  *
 929  *  Success returns 0, Failure returns 1
 930  *
 931  *  The low power link up (lplu) state is set to the power management level D3
 932  *  and SmartSpeed is disabled when active is true, else clear lplu for D3
 933  *  and enable Smartspeed.  LPLU and Smartspeed are mutually exclusive.  LPLU
 934  *  is used during Dx states where the power conservation is most important.
 935  *  During driver activity, SmartSpeed should be enabled so performance is
 936  *  maintained.
 937  **/
 938 s32 e1000_set_d3_lplu_state_82580(struct e1000_hw *hw, bool active)
 939 {
 940         struct e1000_phy_info *phy = &hw->phy;
 941         u32 data;
 942
 943         DEBUGFUNC("e1000_set_d3_lplu_state_82580");
 944
 945         data = E1000_READ_REG(hw, E1000_82580_PHY_POWER_MGMT);
 946
 947         if (!active) {
 948                 data &= ~E1000_82580_PM_D3_LPLU;
 949                 /*
 950                  * LPLU and SmartSpeed are mutually exclusive.  LPLU is used
 951                  * during Dx states where the power conservation is most
 952                  * important.  During driver activity we should enable
 953                  * SmartSpeed, so performance is maintained.
 954                  */
 955                 if (phy->smart_speed == e1000_smart_speed_on)
 956                         data |= E1000_82580_PM_SPD;
 957                 else if (phy->smart_speed == e1000_smart_speed_off)
 958                         data &= ~E1000_82580_PM_SPD;
 959         } else if ((phy->autoneg_advertised == E1000_ALL_SPEED_DUPLEX) ||
 960                    (phy->autoneg_advertised == E1000_ALL_NOT_GIG) ||
 961                    (phy->autoneg_advertised == E1000_ALL_10_SPEED)) {
 962                 data |= E1000_82580_PM_D3_LPLU;
 963                 /* When LPLU is enabled, we should disable SmartSpeed */
 964                 data &= ~E1000_82580_PM_SPD;
 965         }
 966
 967         E1000_WRITE_REG(hw, E1000_82580_PHY_POWER_MGMT, data);
 968         return E1000_SUCCESS;
 969 }
 970
 971 /**
 972  *  e1000_acquire_nvm_82575 - Request for access to EEPROM
 973  *  @hw: pointer to the HW structure
 974  *
 975  *  Acquire the necessary semaphores for exclusive access to the EEPROM.
 976  *  Set the EEPROM access request bit and wait for EEPROM access grant bit.
 977  *  Return successful if access grant bit set, else clear the request for
 978  *  EEPROM access and return -E1000_ERR_NVM (-1).
 979  **/
 980 STATIC s32 e1000_acquire_nvm_82575(struct e1000_hw *hw)
 981 {
 982         s32 ret_val = E1000_SUCCESS;
 983
 984         DEBUGFUNC("e1000_acquire_nvm_82575");
 985
 986         ret_val = e1000_acquire_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
 987         if (ret_val)
 988                 goto out;
 989
 990         /*
 991          * Check if there is some access
 992          * error this access may hook on
 993          */
 994         if (hw->mac.type == e1000_i350) {
 995                 u32 eecd = E1000_READ_REG(hw, E1000_EECD);
 996                 if (eecd & (E1000_EECD_BLOCKED | E1000_EECD_ABORT |
 997                     E1000_EECD_TIMEOUT)) {
 998                         /* Clear all access error flags */
 999                         E1000_WRITE_REG(hw, E1000_EECD, eecd |
1000                                         E1000_EECD_ERROR_CLR);
1001                         DEBUGOUT("Nvm bit banging access error detected and cleared.\n");
1002                 }
1003         }
1004
1005         if (hw->mac.type == e1000_82580) {
1006                 u32 eecd = E1000_READ_REG(hw, E1000_EECD);
1007                 if (eecd & E1000_EECD_BLOCKED) {
1008                         /* Clear access error flag */
1009                         E1000_WRITE_REG(hw, E1000_EECD, eecd |
1010                                         E1000_EECD_BLOCKED);
1011                         DEBUGOUT("Nvm bit banging access error detected and cleared.\n");
1012                 }
1013         }
1014
1015         ret_val = e1000_acquire_nvm_generic(hw);
1016         if (ret_val)
1017                 e1000_release_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
1018
1019 out:
1020         return ret_val;
1021 }
1022
1023 /**
1024  *  e1000_release_nvm_82575 - Release exclusive access to EEPROM
1025  *  @hw: pointer to the HW structure
1026  *
1027  *  Stop any current commands to the EEPROM and clear the EEPROM request bit,
1028  *  then release the semaphores acquired.
1029  **/
1030 STATIC void e1000_release_nvm_82575(struct e1000_hw *hw)
1031 {
1032         DEBUGFUNC("e1000_release_nvm_82575");
1033
1034         e1000_release_nvm_generic(hw);
1035
1036         e1000_release_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
1037 }
1038
1039 /**
1040  *  e1000_acquire_swfw_sync_82575 - Acquire SW/FW semaphore
1041  *  @hw: pointer to the HW structure
1042  *  @mask: specifies which semaphore to acquire
1043  *
1044  *  Acquire the SW/FW semaphore to access the PHY or NVM.  The mask
1045  *  will also specify which port we're acquiring the lock for.
1046  **/
1047 STATIC s32 e1000_acquire_swfw_sync_82575(struct e1000_hw *hw, u16 mask)
1048 {
1049         u32 swfw_sync;
1050         u32 swmask = mask;
1051         u32 fwmask = mask << 16;
1052         s32 ret_val = E1000_SUCCESS;
1053         s32 i = 0, timeout = 200;
1054
1055         DEBUGFUNC("e1000_acquire_swfw_sync_82575");
1056
1057         while (i < timeout) {
1058                 if (e1000_get_hw_semaphore_generic(hw)) {
1059                         ret_val = -E1000_ERR_SWFW_SYNC;
1060                         goto out;
1061                 }
1062
1063                 swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
1064                 if (!(swfw_sync & (fwmask | swmask)))
1065                         break;
1066
1067                 /*
1068                  * Firmware currently using resource (fwmask)
1069                  * or other software thread using resource (swmask)
1070                  */
1071                 e1000_put_hw_semaphore_generic(hw);
1072                 msec_delay_irq(5);
1073                 i++;
1074         }
1075
1076         if (i == timeout) {
1077                 DEBUGOUT("Driver can't access resource, SW_FW_SYNC timeout.\n");
1078                 ret_val = -E1000_ERR_SWFW_SYNC;
1079                 goto out;
1080         }
1081
1082         swfw_sync |= swmask;
1083         E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
1084
1085         e1000_put_hw_semaphore_generic(hw);
1086
1087 out:
1088         return ret_val;
1089 }
1090
1091 /**
1092  *  e1000_release_swfw_sync_82575 - Release SW/FW semaphore
1093  *  @hw: pointer to the HW structure
1094  *  @mask: specifies which semaphore to acquire
1095  *
1096  *  Release the SW/FW semaphore used to access the PHY or NVM.  The mask
1097  *  will also specify which port we're releasing the lock for.
1098  **/
1099 STATIC void e1000_release_swfw_sync_82575(struct e1000_hw *hw, u16 mask)
1100 {
1101         u32 swfw_sync;
1102
1103         DEBUGFUNC("e1000_release_swfw_sync_82575");
1104
1105         while (e1000_get_hw_semaphore_generic(hw) != E1000_SUCCESS)
1106                 ; /* Empty */
1107
1108         swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
1109         swfw_sync &= ~mask;
1110         E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
1111
1112         e1000_put_hw_semaphore_generic(hw);
1113 }
1114
1115 /**
1116  *  e1000_get_cfg_done_82575 - Read config done bit
1117  *  @hw: pointer to the HW structure
1118  *
1119  *  Read the management control register for the config done bit for
1120  *  completion status.  NOTE: silicon which is EEPROM-less will fail trying
1121  *  to read the config done bit, so an error is *ONLY* logged and returns
1122  *  E1000_SUCCESS.  If we were to return with error, EEPROM-less silicon
1123  *  would not be able to be reset or change link.
1124  **/
1125 STATIC s32 e1000_get_cfg_done_82575(struct e1000_hw *hw)
1126 {
1127         s32 timeout = PHY_CFG_TIMEOUT;
1128         u32 mask = E1000_NVM_CFG_DONE_PORT_0;
1129
1130         DEBUGFUNC("e1000_get_cfg_done_82575");
1131
1132         if (hw->bus.func == E1000_FUNC_1)
1133                 mask = E1000_NVM_CFG_DONE_PORT_1;
1134         else if (hw->bus.func == E1000_FUNC_2)
1135                 mask = E1000_NVM_CFG_DONE_PORT_2;
1136         else if (hw->bus.func == E1000_FUNC_3)
1137                 mask = E1000_NVM_CFG_DONE_PORT_3;
1138         while (timeout) {
1139                 if (E1000_READ_REG(hw, E1000_EEMNGCTL) & mask)
1140                         break;
1141                 msec_delay(1);
1142                 timeout--;
1143         }
1144         if (!timeout)
1145                 DEBUGOUT("MNG configuration cycle has not completed.\n");
1146
1147         /* If EEPROM is not marked present, init the PHY manually */
1148         if (!(E1000_READ_REG(hw, E1000_EECD) & E1000_EECD_PRES) &&
1149             (hw->phy.type == e1000_phy_igp_3))
1150                 e1000_phy_init_script_igp3(hw);
1151
1152         return E1000_SUCCESS;
1153 }
1154
1155 /**
1156  *  e1000_get_link_up_info_82575 - Get link speed/duplex info
1157  *  @hw: pointer to the HW structure
1158  *  @speed: stores the current speed
1159  *  @duplex: stores the current duplex
1160  *
1161  *  This is a wrapper function, if using the serial gigabit media independent
1162  *  interface, use PCS to retrieve the link speed and duplex information.
1163  *  Otherwise, use the generic function to get the link speed and duplex info.
1164  **/
1165 STATIC s32 e1000_get_link_up_info_82575(struct e1000_hw *hw, u16 *speed,
1166                                         u16 *duplex)
1167 {
1168         s32 ret_val;
1169
1170         DEBUGFUNC("e1000_get_link_up_info_82575");
1171
1172         if (hw->phy.media_type != e1000_media_type_copper)
1173                 ret_val = e1000_get_pcs_speed_and_duplex_82575(hw, speed,
1174                                                                duplex);
1175         else
1176                 ret_val = e1000_get_speed_and_duplex_copper_generic(hw, speed,
1177                                                                     duplex);
1178
1179         return ret_val;
1180 }
1181
1182 /**
1183  *  e1000_check_for_link_82575 - Check for link
1184  *  @hw: pointer to the HW structure
1185  *
1186  *  If sgmii is enabled, then use the pcs register to determine link, otherwise
1187  *  use the generic interface for determining link.
1188  **/
1189 STATIC s32 e1000_check_for_link_82575(struct e1000_hw *hw)
1190 {
1191         s32 ret_val;
1192         u16 speed, duplex;
1193
1194         DEBUGFUNC("e1000_check_for_link_82575");
1195
1196         if (hw->phy.media_type != e1000_media_type_copper) {
1197                 ret_val = e1000_get_pcs_speed_and_duplex_82575(hw, &speed,
1198                                                                &duplex);
1199                 /*
1200                  * Use this flag to determine if link needs to be checked or
1201                  * not.  If we have link clear the flag so that we do not
1202                  * continue to check for link.
1203                  */
1204                 hw->mac.get_link_status = !hw->mac.serdes_has_link;
1205
1206                 /*
1207                  * Configure Flow Control now that Auto-Neg has completed.
1208                  * First, we need to restore the desired flow control
1209                  * settings because we may have had to re-autoneg with a
1210                  * different link partner.
1211                  */
1212                 ret_val = e1000_config_fc_after_link_up_generic(hw);
1213                 if (ret_val)
1214                         DEBUGOUT("Error configuring flow control\n");
1215         } else {
1216                 ret_val = e1000_check_for_copper_link_generic(hw);
1217         }
1218
1219         return ret_val;
1220 }
1221
1222 /**
1223  *  e1000_check_for_link_media_swap - Check which M88E1112 interface linked
1224  *  @hw: pointer to the HW structure
1225  *
1226  *  Poll the M88E1112 interfaces to see which interface achieved link.
1227  */
1228 STATIC s32 e1000_check_for_link_media_swap(struct e1000_hw *hw)
1229 {
1230         struct e1000_phy_info *phy = &hw->phy;
1231         s32 ret_val;
1232         u16 data;
1233         u8 port = 0;
1234
1235         DEBUGFUNC("e1000_check_for_link_media_swap");
1236
1237         /* Check for copper. */
1238         ret_val = phy->ops.write_reg(hw, E1000_M88E1112_PAGE_ADDR, 0);
1239         if (ret_val)
1240                 return ret_val;
1241
1242         ret_val = phy->ops.read_reg(hw, E1000_M88E1112_STATUS, &data);
1243         if (ret_val)
1244                 return ret_val;
1245
1246         if (data & E1000_M88E1112_STATUS_LINK)
1247                 port = E1000_MEDIA_PORT_COPPER;
1248
1249         /* Check for other. */
1250         ret_val = phy->ops.write_reg(hw, E1000_M88E1112_PAGE_ADDR, 1);
1251         if (ret_val)
1252                 return ret_val;
1253
1254         ret_val = phy->ops.read_reg(hw, E1000_M88E1112_STATUS, &data);
1255         if (ret_val)
1256                 return ret_val;
1257
1258         if (data & E1000_M88E1112_STATUS_LINK)
1259                 port = E1000_MEDIA_PORT_OTHER;
1260
1261         /* Determine if a swap needs to happen. */
1262         if (port && (hw->dev_spec._82575.media_port != port)) {
1263                 hw->dev_spec._82575.media_port = port;
1264                 hw->dev_spec._82575.media_changed = true;
1265         }
1266
1267         if (port == E1000_MEDIA_PORT_COPPER) {
1268                 /* reset page to 0 */
1269                 ret_val = phy->ops.write_reg(hw, E1000_M88E1112_PAGE_ADDR, 0);
1270                 if (ret_val)
1271                         return ret_val;
1272                 e1000_check_for_link_82575(hw);
1273         } else {
1274                 e1000_check_for_link_82575(hw);
1275                 /* reset page to 0 */
1276                 ret_val = phy->ops.write_reg(hw, E1000_M88E1112_PAGE_ADDR, 0);
1277                 if (ret_val)
1278                         return ret_val;
1279         }
1280
1281         return E1000_SUCCESS;
1282 }
1283
1284 /**
1285  *  e1000_power_up_serdes_link_82575 - Power up the serdes link after shutdown
1286  *  @hw: pointer to the HW structure
1287  **/
1288 STATIC void e1000_power_up_serdes_link_82575(struct e1000_hw *hw)
1289 {
1290         u32 reg;
1291
1292         DEBUGFUNC("e1000_power_up_serdes_link_82575");
1293
1294         if ((hw->phy.media_type != e1000_media_type_internal_serdes) &&
1295             !e1000_sgmii_active_82575(hw))
1296                 return;
1297
1298         /* Enable PCS to turn on link */
1299         reg = E1000_READ_REG(hw, E1000_PCS_CFG0);
1300         reg |= E1000_PCS_CFG_PCS_EN;
1301         E1000_WRITE_REG(hw, E1000_PCS_CFG0, reg);
1302
1303         /* Power up the laser */
1304         reg = E1000_READ_REG(hw, E1000_CTRL_EXT);
1305         reg &= ~E1000_CTRL_EXT_SDP3_DATA;
1306         E1000_WRITE_REG(hw, E1000_CTRL_EXT, reg);
1307
1308         /* flush the write to verify completion */
1309         E1000_WRITE_FLUSH(hw);
1310         msec_delay(1);
1311 }
1312
1313 /**
1314  *  e1000_get_pcs_speed_and_duplex_82575 - Retrieve current speed/duplex
1315  *  @hw: pointer to the HW structure
1316  *  @speed: stores the current speed
1317  *  @duplex: stores the current duplex
1318  *
1319  *  Using the physical coding sub-layer (PCS), retrieve the current speed and
1320  *  duplex, then store the values in the pointers provided.
1321  **/
1322 STATIC s32 e1000_get_pcs_speed_and_duplex_82575(struct e1000_hw *hw,
1323                                                 u16 *speed, u16 *duplex)
1324 {
1325         struct e1000_mac_info *mac = &hw->mac;
1326         u32 pcs;
1327         u32 status;
1328
1329         DEBUGFUNC("e1000_get_pcs_speed_and_duplex_82575");
1330
1331         /*
1332          * Read the PCS Status register for link state. For non-copper mode,
1333          * the status register is not accurate. The PCS status register is
1334          * used instead.
1335          */
1336         pcs = E1000_READ_REG(hw, E1000_PCS_LSTAT);
1337
1338         /*
1339          * The link up bit determines when link is up on autoneg.
1340          */
1341         if (pcs & E1000_PCS_LSTS_LINK_OK) {
1342                 mac->serdes_has_link = true;
1343
1344                 /* Detect and store PCS speed */
1345                 if (pcs & E1000_PCS_LSTS_SPEED_1000)
1346                         *speed = SPEED_1000;
1347                 else if (pcs & E1000_PCS_LSTS_SPEED_100)
1348                         *speed = SPEED_100;
1349                 else
1350                         *speed = SPEED_10;
1351
1352                 /* Detect and store PCS duplex */
1353                 if (pcs & E1000_PCS_LSTS_DUPLEX_FULL)
1354                         *duplex = FULL_DUPLEX;
1355                 else
1356                         *duplex = HALF_DUPLEX;
1357
1358                 /* Check if it is an I354 2.5Gb backplane connection. */
1359                 if (mac->type == e1000_i354) {
1360                         status = E1000_READ_REG(hw, E1000_STATUS);
1361                         if ((status & E1000_STATUS_2P5_SKU) &&
1362                             !(status & E1000_STATUS_2P5_SKU_OVER)) {
1363                                 *speed = SPEED_2500;
1364                                 *duplex = FULL_DUPLEX;
1365                                 DEBUGOUT("2500 Mbs, ");
1366                                 DEBUGOUT("Full Duplex\n");
1367                         }
1368                 }
1369
1370         } else {
1371                 mac->serdes_has_link = false;
1372                 *speed = 0;
1373                 *duplex = 0;
1374         }
1375
1376         return E1000_SUCCESS;
1377 }
1378
1379 /**
1380  *  e1000_shutdown_serdes_link_82575 - Remove link during power down
1381  *  @hw: pointer to the HW structure
1382  *
1383  *  In the case of serdes shut down sfp and PCS on driver unload
1384  *  when management pass thru is not enabled.
1385  **/
1386 void e1000_shutdown_serdes_link_82575(struct e1000_hw *hw)
1387 {
1388         u32 reg;
1389
1390         DEBUGFUNC("e1000_shutdown_serdes_link_82575");
1391
1392         if ((hw->phy.media_type != e1000_media_type_internal_serdes) &&
1393             !e1000_sgmii_active_82575(hw))
1394                 return;
1395
1396         if (!e1000_enable_mng_pass_thru(hw)) {
1397                 /* Disable PCS to turn off link */
1398                 reg = E1000_READ_REG(hw, E1000_PCS_CFG0);
1399                 reg &= ~E1000_PCS_CFG_PCS_EN;
1400                 E1000_WRITE_REG(hw, E1000_PCS_CFG0, reg);
1401
1402                 /* shutdown the laser */
1403                 reg = E1000_READ_REG(hw, E1000_CTRL_EXT);
1404                 reg |= E1000_CTRL_EXT_SDP3_DATA;
1405                 E1000_WRITE_REG(hw, E1000_CTRL_EXT, reg);
1406
1407                 /* flush the write to verify completion */
1408                 E1000_WRITE_FLUSH(hw);
1409                 msec_delay(1);
1410         }
1411
1412         return;
1413 }
1414
1415 /**
1416  *  e1000_reset_hw_82575 - Reset hardware
1417  *  @hw: pointer to the HW structure
1418  *
1419  *  This resets the hardware into a known state.
1420  **/
1421 STATIC s32 e1000_reset_hw_82575(struct e1000_hw *hw)
1422 {
1423         u32 ctrl;
1424         s32 ret_val;
1425
1426         DEBUGFUNC("e1000_reset_hw_82575");
1427
1428         /*
1429          * Prevent the PCI-E bus from sticking if there is no TLP connection
1430          * on the last TLP read/write transaction when MAC is reset.
1431          */
1432         ret_val = e1000_disable_pcie_master_generic(hw);
1433         if (ret_val)
1434                 DEBUGOUT("PCI-E Master disable polling has failed.\n");
1435
1436         /* set the completion timeout for interface */
1437         ret_val = e1000_set_pcie_completion_timeout(hw);
1438         if (ret_val)
1439                 DEBUGOUT("PCI-E Set completion timeout has failed.\n");
1440
1441         DEBUGOUT("Masking off all interrupts\n");
1442         E1000_WRITE_REG(hw, E1000_IMC, 0xffffffff);
1443
1444         E1000_WRITE_REG(hw, E1000_RCTL, 0);
1445         E1000_WRITE_REG(hw, E1000_TCTL, E1000_TCTL_PSP);
1446         E1000_WRITE_FLUSH(hw);
1447
1448         msec_delay(10);
1449
1450         ctrl = E1000_READ_REG(hw, E1000_CTRL);
1451
1452         DEBUGOUT("Issuing a global reset to MAC\n");
1453         E1000_WRITE_REG(hw, E1000_CTRL, ctrl | E1000_CTRL_RST);
1454
1455         ret_val = e1000_get_auto_rd_done_generic(hw);
1456         if (ret_val) {
1457                 /*
1458                  * When auto config read does not complete, do not
1459                  * return with an error. This can happen in situations
1460                  * where there is no eeprom and prevents getting link.
1461                  */
1462                 DEBUGOUT("Auto Read Done did not complete\n");
1463         }
1464
1465         /* If EEPROM is not present, run manual init scripts */
1466         if (!(E1000_READ_REG(hw, E1000_EECD) & E1000_EECD_PRES))
1467                 e1000_reset_init_script_82575(hw);
1468
1469         /* Clear any pending interrupt events. */
1470         E1000_WRITE_REG(hw, E1000_IMC, 0xffffffff);
1471         E1000_READ_REG(hw, E1000_ICR);
1472
1473         /* Install any alternate MAC address into RAR0 */
1474         ret_val = e1000_check_alt_mac_addr_generic(hw);
1475
1476         return ret_val;
1477 }
1478
1479 /**
1480  *  e1000_init_hw_82575 - Initialize hardware
1481  *  @hw: pointer to the HW structure
1482  *
1483  *  This inits the hardware readying it for operation.
1484  **/
1485 s32 e1000_init_hw_82575(struct e1000_hw *hw)
1486 {
1487         struct e1000_mac_info *mac = &hw->mac;
1488         s32 ret_val;
1489         u16 i, rar_count = mac->rar_entry_count;
1490
1491         DEBUGFUNC("e1000_init_hw_82575");
1492
1493         /* Initialize identification LED */
1494         ret_val = mac->ops.id_led_init(hw);
1495         if (ret_val) {
1496                 DEBUGOUT("Error initializing identification LED\n");
1497                 /* This is not fatal and we should not stop init due to this */
1498         }
1499
1500         /* Disabling VLAN filtering */
1501         DEBUGOUT("Initializing the IEEE VLAN\n");
1502         mac->ops.clear_vfta(hw);
1503
1504         /* Setup the receive address */
1505         e1000_init_rx_addrs_generic(hw, rar_count);
1506
1507         /* Zero out the Multicast HASH table */
1508         DEBUGOUT("Zeroing the MTA\n");
1509         for (i = 0; i < mac->mta_reg_count; i++)
1510                 E1000_WRITE_REG_ARRAY(hw, E1000_MTA, i, 0);
1511
1512         /* Zero out the Unicast HASH table */
1513         DEBUGOUT("Zeroing the UTA\n");
1514         for (i = 0; i < mac->uta_reg_count; i++)
1515                 E1000_WRITE_REG_ARRAY(hw, E1000_UTA, i, 0);
1516
1517         /* Setup link and flow control */
1518         ret_val = mac->ops.setup_link(hw);
1519
1520         /* Set the default MTU size */
1521         hw->dev_spec._82575.mtu = 1500;
1522
1523         /*
1524          * Clear all of the statistics registers (clear on read).  It is
1525          * important that we do this after we have tried to establish link
1526          * because the symbol error count will increment wildly if there
1527          * is no link.
1528          */
1529         e1000_clear_hw_cntrs_82575(hw);
1530
1531         return ret_val;
1532 }
1533
1534 /**
1535  *  e1000_setup_copper_link_82575 - Configure copper link settings
1536  *  @hw: pointer to the HW structure
1537  *
1538  *  Configures the link for auto-neg or forced speed and duplex.  Then we check
1539  *  for link, once link is established calls to configure collision distance
1540  *  and flow control are called.
1541  **/
1542 STATIC s32 e1000_setup_copper_link_82575(struct e1000_hw *hw)
1543 {
1544         u32 ctrl;
1545         s32 ret_val;
1546         u32 phpm_reg;
1547
1548         DEBUGFUNC("e1000_setup_copper_link_82575");
1549
1550         ctrl = E1000_READ_REG(hw, E1000_CTRL);
1551         ctrl |= E1000_CTRL_SLU;
1552         ctrl &= ~(E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1553         E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1554
1555         /* Clear Go Link Disconnect bit on supported devices */
1556         switch (hw->mac.type) {
1557         case e1000_82580:
1558         case e1000_i350:
1559         case e1000_i210:
1560         case e1000_i211:
1561                 phpm_reg = E1000_READ_REG(hw, E1000_82580_PHY_POWER_MGMT);
1562                 phpm_reg &= ~E1000_82580_PM_GO_LINKD;
1563                 E1000_WRITE_REG(hw, E1000_82580_PHY_POWER_MGMT, phpm_reg);
1564                 break;
1565         default:
1566                 break;
1567         }
1568
1569         ret_val = e1000_setup_serdes_link_82575(hw);
1570         if (ret_val)
1571                 goto out;
1572
1573         if (e1000_sgmii_active_82575(hw)) {
1574                 /* allow time for SFP cage time to power up phy */
1575                 msec_delay(300);
1576
1577                 ret_val = hw->phy.ops.reset(hw);
1578                 if (ret_val) {
1579                         DEBUGOUT("Error resetting the PHY.\n");
1580                         goto out;
1581                 }
1582         }
1583         switch (hw->phy.type) {
1584         case e1000_phy_i210:
1585         case e1000_phy_m88:
1586                 switch (hw->phy.id) {
1587                 case I347AT4_E_PHY_ID:
1588                 case M88E1112_E_PHY_ID:
1589                 case M88E1340M_E_PHY_ID:
1590                 case M88E1543_E_PHY_ID:
1591                 case M88E1512_E_PHY_ID:
1592                 case I210_I_PHY_ID:
1593                         ret_val = e1000_copper_link_setup_m88_gen2(hw);
1594                         break;
1595                 default:
1596                         ret_val = e1000_copper_link_setup_m88(hw);
1597                         break;
1598                 }
1599                 break;
1600         case e1000_phy_igp_3:
1601                 ret_val = e1000_copper_link_setup_igp(hw);
1602                 break;
1603         case e1000_phy_82580:
1604                 ret_val = e1000_copper_link_setup_82577(hw);
1605                 break;
1606         default:
1607                 ret_val = -E1000_ERR_PHY;
1608                 break;
1609         }
1610
1611         if (ret_val)
1612                 goto out;
1613
1614         ret_val = e1000_setup_copper_link_generic(hw);
1615 out:
1616         return ret_val;
1617 }
1618
1619 /**
1620  *  e1000_setup_serdes_link_82575 - Setup link for serdes
1621  *  @hw: pointer to the HW structure
1622  *
1623  *  Configure the physical coding sub-layer (PCS) link.  The PCS link is
1624  *  used on copper connections where the serialized gigabit media independent
1625  *  interface (sgmii), or serdes fiber is being used.  Configures the link
1626  *  for auto-negotiation or forces speed/duplex.
1627  **/
1628 STATIC s32 e1000_setup_serdes_link_82575(struct e1000_hw *hw)
1629 {
1630         u32 ctrl_ext, ctrl_reg, reg, anadv_reg;
1631         bool pcs_autoneg;
1632         s32 ret_val = E1000_SUCCESS;
1633         u16 data;
1634
1635         DEBUGFUNC("e1000_setup_serdes_link_82575");
1636
1637         if ((hw->phy.media_type != e1000_media_type_internal_serdes) &&
1638             !e1000_sgmii_active_82575(hw))
1639                 return ret_val;
1640
1641         /*
1642          * On the 82575, SerDes loopback mode persists until it is
1643          * explicitly turned off or a power cycle is performed.  A read to
1644          * the register does not indicate its status.  Therefore, we ensure
1645          * loopback mode is disabled during initialization.
1646          */
1647         E1000_WRITE_REG(hw, E1000_SCTL, E1000_SCTL_DISABLE_SERDES_LOOPBACK);
1648
1649         /* power on the sfp cage if present */
1650         ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
1651         ctrl_ext &= ~E1000_CTRL_EXT_SDP3_DATA;
1652         E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
1653
1654         ctrl_reg = E1000_READ_REG(hw, E1000_CTRL);
1655         ctrl_reg |= E1000_CTRL_SLU;
1656
1657         /* set both sw defined pins on 82575/82576*/
1658         if (hw->mac.type == e1000_82575 || hw->mac.type == e1000_82576)
1659                 ctrl_reg |= E1000_CTRL_SWDPIN0 | E1000_CTRL_SWDPIN1;
1660
1661         reg = E1000_READ_REG(hw, E1000_PCS_LCTL);
1662
1663         /* default pcs_autoneg to the same setting as mac autoneg */
1664         pcs_autoneg = hw->mac.autoneg;
1665
1666         switch (ctrl_ext & E1000_CTRL_EXT_LINK_MODE_MASK) {
1667         case E1000_CTRL_EXT_LINK_MODE_SGMII:
1668                 /* sgmii mode lets the phy handle forcing speed/duplex */
1669                 pcs_autoneg = true;
1670                 /* autoneg time out should be disabled for SGMII mode */
1671                 reg &= ~(E1000_PCS_LCTL_AN_TIMEOUT);
1672                 break;
1673         case E1000_CTRL_EXT_LINK_MODE_1000BASE_KX:
1674                 /* disable PCS autoneg and support parallel detect only */
1675                 pcs_autoneg = false;
1676                 /* fall through to default case */
1677         default:
1678                 if (hw->mac.type == e1000_82575 ||
1679                     hw->mac.type == e1000_82576) {
1680                         ret_val = hw->nvm.ops.read(hw, NVM_COMPAT, 1, &data);
1681                         if (ret_val) {
1682                                 DEBUGOUT("NVM Read Error\n");
1683                                 return ret_val;
1684                         }
1685
1686                         if (data & E1000_EEPROM_PCS_AUTONEG_DISABLE_BIT)
1687                                 pcs_autoneg = false;
1688                 }
1689
1690                 /*
1691                  * non-SGMII modes only supports a speed of 1000/Full for the
1692                  * link so it is best to just force the MAC and let the pcs
1693                  * link either autoneg or be forced to 1000/Full
1694                  */
1695                 ctrl_reg |= E1000_CTRL_SPD_1000 | E1000_CTRL_FRCSPD |
1696                             E1000_CTRL_FD | E1000_CTRL_FRCDPX;
1697
1698                 /* set speed of 1000/Full if speed/duplex is forced */
1699                 reg |= E1000_PCS_LCTL_FSV_1000 | E1000_PCS_LCTL_FDV_FULL;
1700                 break;
1701         }
1702
1703         E1000_WRITE_REG(hw, E1000_CTRL, ctrl_reg);
1704
1705         /*
1706          * New SerDes mode allows for forcing speed or autonegotiating speed
1707          * at 1gb. Autoneg should be default set by most drivers. This is the
1708          * mode that will be compatible with older link partners and switches.
1709          * However, both are supported by the hardware and some drivers/tools.
1710          */
1711         reg &= ~(E1000_PCS_LCTL_AN_ENABLE | E1000_PCS_LCTL_FLV_LINK_UP |
1712                  E1000_PCS_LCTL_FSD | E1000_PCS_LCTL_FORCE_LINK);
1713
1714         if (pcs_autoneg) {
1715                 /* Set PCS register for autoneg */
1716                 reg |= E1000_PCS_LCTL_AN_ENABLE | /* Enable Autoneg */
1717                        E1000_PCS_LCTL_AN_RESTART; /* Restart autoneg */
1718
1719                 /* Disable force flow control for autoneg */
1720                 reg &= ~E1000_PCS_LCTL_FORCE_FCTRL;
1721
1722                 /* Configure flow control advertisement for autoneg */
1723                 anadv_reg = E1000_READ_REG(hw, E1000_PCS_ANADV);
1724                 anadv_reg &= ~(E1000_TXCW_ASM_DIR | E1000_TXCW_PAUSE);
1725
1726                 switch (hw->fc.requested_mode) {
1727                 case e1000_fc_full:
1728                 case e1000_fc_rx_pause:
1729                         anadv_reg |= E1000_TXCW_ASM_DIR;
1730                         anadv_reg |= E1000_TXCW_PAUSE;
1731                         break;
1732                 case e1000_fc_tx_pause:
1733                         anadv_reg |= E1000_TXCW_ASM_DIR;
1734                         break;
1735                 default:
1736                         break;
1737                 }
1738
1739                 E1000_WRITE_REG(hw, E1000_PCS_ANADV, anadv_reg);
1740
1741                 DEBUGOUT1("Configuring Autoneg:PCS_LCTL=0x%08X\n", reg);
1742         } else {
1743                 /* Set PCS register for forced link */
1744                 reg |= E1000_PCS_LCTL_FSD;      /* Force Speed */
1745
1746                 /* Force flow control for forced link */
1747                 reg |= E1000_PCS_LCTL_FORCE_FCTRL;
1748
1749                 DEBUGOUT1("Configuring Forced Link:PCS_LCTL=0x%08X\n", reg);
1750         }
1751
1752         E1000_WRITE_REG(hw, E1000_PCS_LCTL, reg);
1753
1754         if (!pcs_autoneg && !e1000_sgmii_active_82575(hw))
1755                 e1000_force_mac_fc_generic(hw);
1756
1757         return ret_val;
1758 }
1759
1760 /**
1761  *  e1000_get_media_type_82575 - derives current media type.
1762  *  @hw: pointer to the HW structure
1763  *
1764  *  The media type is chosen reflecting few settings.
1765  *  The following are taken into account:
1766  *  - link mode set in the current port Init Control Word #3
1767  *  - current link mode settings in CSR register
1768  *  - MDIO vs. I2C PHY control interface chosen
1769  *  - SFP module media type
1770  **/
1771 STATIC s32 e1000_get_media_type_82575(struct e1000_hw *hw)
1772 {
1773         struct e1000_dev_spec_82575 *dev_spec = &hw->dev_spec._82575;
1774         s32 ret_val = E1000_SUCCESS;
1775         u32 ctrl_ext = 0;
1776         u32 link_mode = 0;
1777
1778         /* Set internal phy as default */
1779         dev_spec->sgmii_active = false;
1780         dev_spec->module_plugged = false;
1781
1782         /* Get CSR setting */
1783         ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
1784
1785         /* extract link mode setting */
1786         link_mode = ctrl_ext & E1000_CTRL_EXT_LINK_MODE_MASK;
1787
1788         switch (link_mode) {
1789         case E1000_CTRL_EXT_LINK_MODE_1000BASE_KX:
1790                 hw->phy.media_type = e1000_media_type_internal_serdes;
1791                 break;
1792         case E1000_CTRL_EXT_LINK_MODE_GMII:
1793                 hw->phy.media_type = e1000_media_type_copper;
1794                 break;
1795         case E1000_CTRL_EXT_LINK_MODE_SGMII:
1796                 /* Get phy control interface type set (MDIO vs. I2C)*/
1797                 if (e1000_sgmii_uses_mdio_82575(hw)) {
1798                         hw->phy.media_type = e1000_media_type_copper;
1799                         dev_spec->sgmii_active = true;
1800                         break;
1801                 }
1802                 /* fall through for I2C based SGMII */
1803         case E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES:
1804                 /* read media type from SFP EEPROM */
1805                 ret_val = e1000_set_sfp_media_type_82575(hw);
1806                 if ((ret_val != E1000_SUCCESS) ||
1807                     (hw->phy.media_type == e1000_media_type_unknown)) {
1808                         /*
1809                          * If media type was not identified then return media
1810                          * type defined by the CTRL_EXT settings.
1811                          */
1812                         hw->phy.media_type = e1000_media_type_internal_serdes;
1813
1814                         if (link_mode == E1000_CTRL_EXT_LINK_MODE_SGMII) {
1815                                 hw->phy.media_type = e1000_media_type_copper;
1816                                 dev_spec->sgmii_active = true;
1817                         }
1818
1819                         break;
1820                 }
1821
1822                 /* do not change link mode for 100BaseFX */
1823                 if (dev_spec->eth_flags.e100_base_fx)
1824                         break;
1825
1826                 /* change current link mode setting */
1827                 ctrl_ext &= ~E1000_CTRL_EXT_LINK_MODE_MASK;
1828
1829                 if (hw->phy.media_type == e1000_media_type_copper)
1830                         ctrl_ext |= E1000_CTRL_EXT_LINK_MODE_SGMII;
1831                 else
1832                         ctrl_ext |= E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES;
1833
1834                 E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
1835
1836                 break;
1837         }
1838
1839         return ret_val;
1840 }
1841
1842 /**
1843  *  e1000_set_sfp_media_type_82575 - derives SFP module media type.
1844  *  @hw: pointer to the HW structure
1845  *
1846  *  The media type is chosen based on SFP module.
1847  *  compatibility flags retrieved from SFP ID EEPROM.
1848  **/
1849 STATIC s32 e1000_set_sfp_media_type_82575(struct e1000_hw *hw)
1850 {
1851         s32 ret_val = E1000_ERR_CONFIG;
1852         u32 ctrl_ext = 0;
1853         struct e1000_dev_spec_82575 *dev_spec = &hw->dev_spec._82575;
1854         struct sfp_e1000_flags *eth_flags = &dev_spec->eth_flags;
1855         u8 tranceiver_type = 0;
1856         s32 timeout = 3;
1857
1858         /* Turn I2C interface ON and power on sfp cage */
1859         ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
1860         ctrl_ext &= ~E1000_CTRL_EXT_SDP3_DATA;
1861         E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext | E1000_CTRL_I2C_ENA);
1862
1863         E1000_WRITE_FLUSH(hw);
1864
1865         /* Read SFP module data */
1866         while (timeout) {
1867                 ret_val = e1000_read_sfp_data_byte(hw,
1868                         E1000_I2CCMD_SFP_DATA_ADDR(E1000_SFF_IDENTIFIER_OFFSET),
1869                         &tranceiver_type);
1870                 if (ret_val == E1000_SUCCESS)
1871                         break;
1872                 msec_delay(100);
1873                 timeout--;
1874         }
1875         if (ret_val != E1000_SUCCESS)
1876                 goto out;
1877
1878         ret_val = e1000_read_sfp_data_byte(hw,
1879                         E1000_I2CCMD_SFP_DATA_ADDR(E1000_SFF_ETH_FLAGS_OFFSET),
1880                         (u8 *)eth_flags);
1881         if (ret_val != E1000_SUCCESS)
1882                 goto out;
1883
1884         /* Check if there is some SFP module plugged and powered */
1885         if ((tranceiver_type == E1000_SFF_IDENTIFIER_SFP) ||
1886             (tranceiver_type == E1000_SFF_IDENTIFIER_SFF)) {
1887                 dev_spec->module_plugged = true;
1888                 if (eth_flags->e1000_base_lx || eth_flags->e1000_base_sx) {
1889                         hw->phy.media_type = e1000_media_type_internal_serdes;
1890                 } else if (eth_flags->e100_base_fx) {
1891                         dev_spec->sgmii_active = true;
1892                         hw->phy.media_type = e1000_media_type_internal_serdes;
1893                 } else if (eth_flags->e1000_base_t) {
1894                         dev_spec->sgmii_active = true;
1895                         hw->phy.media_type = e1000_media_type_copper;
1896                 } else {
1897                         hw->phy.media_type = e1000_media_type_unknown;
1898                         DEBUGOUT("PHY module has not been recognized\n");
1899                         goto out;
1900                 }
1901         } else {
1902                 hw->phy.media_type = e1000_media_type_unknown;
1903         }
1904         ret_val = E1000_SUCCESS;
1905 out:
1906         /* Restore I2C interface setting */
1907         E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
1908         return ret_val;
1909 }
1910
1911 /**
1912  *  e1000_valid_led_default_82575 - Verify a valid default LED config
1913  *  @hw: pointer to the HW structure
1914  *  @data: pointer to the NVM (EEPROM)
1915  *
1916  *  Read the EEPROM for the current default LED configuration.  If the
1917  *  LED configuration is not valid, set to a valid LED configuration.
1918  **/
1919 STATIC s32 e1000_valid_led_default_82575(struct e1000_hw *hw, u16 *data)
1920 {
1921         s32 ret_val;
1922
1923         DEBUGFUNC("e1000_valid_led_default_82575");
1924
1925         ret_val = hw->nvm.ops.read(hw, NVM_ID_LED_SETTINGS, 1, data);
1926         if (ret_val) {
1927                 DEBUGOUT("NVM Read Error\n");
1928                 goto out;
1929         }
1930
1931         if (*data == ID_LED_RESERVED_0000 || *data == ID_LED_RESERVED_FFFF) {
1932                 switch (hw->phy.media_type) {
1933                 case e1000_media_type_internal_serdes:
1934                         *data = ID_LED_DEFAULT_82575_SERDES;
1935                         break;
1936                 case e1000_media_type_copper:
1937                 default:
1938                         *data = ID_LED_DEFAULT;
1939                         break;
1940                 }
1941         }
1942 out:
1943         return ret_val;
1944 }
1945
1946 /**
1947  *  e1000_sgmii_active_82575 - Return sgmii state
1948  *  @hw: pointer to the HW structure
1949  *
1950  *  82575 silicon has a serialized gigabit media independent interface (sgmii)
1951  *  which can be enabled for use in the embedded applications.  Simply
1952  *  return the current state of the sgmii interface.
1953  **/
1954 STATIC bool e1000_sgmii_active_82575(struct e1000_hw *hw)
1955 {
1956         struct e1000_dev_spec_82575 *dev_spec = &hw->dev_spec._82575;
1957         return dev_spec->sgmii_active;
1958 }
1959
1960 /**
1961  *  e1000_reset_init_script_82575 - Inits HW defaults after reset
1962  *  @hw: pointer to the HW structure
1963  *
1964  *  Inits recommended HW defaults after a reset when there is no EEPROM
1965  *  detected. This is only for the 82575.
1966  **/
1967 STATIC s32 e1000_reset_init_script_82575(struct e1000_hw *hw)
1968 {
1969         DEBUGFUNC("e1000_reset_init_script_82575");
1970
1971         if (hw->mac.type == e1000_82575) {
1972                 DEBUGOUT("Running reset init script for 82575\n");
1973                 /* SerDes configuration via SERDESCTRL */
1974                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCTL, 0x00, 0x0C);
1975                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCTL, 0x01, 0x78);
1976                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCTL, 0x1B, 0x23);
1977                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCTL, 0x23, 0x15);
1978
1979                 /* CCM configuration via CCMCTL register */
1980                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_CCMCTL, 0x14, 0x00);
1981                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_CCMCTL, 0x10, 0x00);
1982
1983                 /* PCIe lanes configuration */
1984                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_GIOCTL, 0x00, 0xEC);
1985                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_GIOCTL, 0x61, 0xDF);
1986                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_GIOCTL, 0x34, 0x05);
1987                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_GIOCTL, 0x2F, 0x81);
1988
1989                 /* PCIe PLL Configuration */
1990                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCCTL, 0x02, 0x47);
1991                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCCTL, 0x14, 0x00);
1992                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCCTL, 0x10, 0x00);
1993         }
1994
1995         return E1000_SUCCESS;
1996 }
1997
1998 /**
1999  *  e1000_read_mac_addr_82575 - Read device MAC address
2000  *  @hw: pointer to the HW structure
2001  **/
2002 STATIC s32 e1000_read_mac_addr_82575(struct e1000_hw *hw)
2003 {
2004         s32 ret_val;
2005
2006         DEBUGFUNC("e1000_read_mac_addr_82575");
2007
2008         /*
2009          * If there's an alternate MAC address place it in RAR0
2010          * so that it will override the Si installed default perm
2011          * address.
2012          */
2013         ret_val = e1000_check_alt_mac_addr_generic(hw);
2014         if (ret_val)
2015                 goto out;
2016
2017         ret_val = e1000_read_mac_addr_generic(hw);
2018
2019 out:
2020         return ret_val;
2021 }
2022
2023 /**
2024  *  e1000_config_collision_dist_82575 - Configure collision distance
2025  *  @hw: pointer to the HW structure
2026  *
2027  *  Configures the collision distance to the default value and is used
2028  *  during link setup.
2029  **/
2030 STATIC void e1000_config_collision_dist_82575(struct e1000_hw *hw)
2031 {
2032         u32 tctl_ext;
2033
2034         DEBUGFUNC("e1000_config_collision_dist_82575");
2035
2036         tctl_ext = E1000_READ_REG(hw, E1000_TCTL_EXT);
2037
2038         tctl_ext &= ~E1000_TCTL_EXT_COLD;
2039         tctl_ext |= E1000_COLLISION_DISTANCE << E1000_TCTL_EXT_COLD_SHIFT;
2040
2041         E1000_WRITE_REG(hw, E1000_TCTL_EXT, tctl_ext);
2042         E1000_WRITE_FLUSH(hw);
2043 }
2044
2045 /**
2046  * e1000_power_down_phy_copper_82575 - Remove link during PHY power down
2047  * @hw: pointer to the HW structure
2048  *
2049  * In the case of a PHY power down to save power, or to turn off link during a
2050  * driver unload, or wake on lan is not enabled, remove the link.
2051  **/
2052 STATIC void e1000_power_down_phy_copper_82575(struct e1000_hw *hw)
2053 {
2054         struct e1000_phy_info *phy = &hw->phy;
2055
2056         if (!(phy->ops.check_reset_block))
2057                 return;
2058
2059         /* If the management interface is not enabled, then power down */
2060         if (!(e1000_enable_mng_pass_thru(hw) || phy->ops.check_reset_block(hw)))
2061                 e1000_power_down_phy_copper(hw);
2062
2063         return;
2064 }
2065
2066 /**
2067  *  e1000_clear_hw_cntrs_82575 - Clear device specific hardware counters
2068  *  @hw: pointer to the HW structure
2069  *
2070  *  Clears the hardware counters by reading the counter registers.
2071  **/
2072 STATIC void e1000_clear_hw_cntrs_82575(struct e1000_hw *hw)
2073 {
2074         DEBUGFUNC("e1000_clear_hw_cntrs_82575");
2075
2076         e1000_clear_hw_cntrs_base_generic(hw);
2077
2078         E1000_READ_REG(hw, E1000_PRC64);
2079         E1000_READ_REG(hw, E1000_PRC127);
2080         E1000_READ_REG(hw, E1000_PRC255);
2081         E1000_READ_REG(hw, E1000_PRC511);
2082         E1000_READ_REG(hw, E1000_PRC1023);
2083         E1000_READ_REG(hw, E1000_PRC1522);
2084         E1000_READ_REG(hw, E1000_PTC64);
2085         E1000_READ_REG(hw, E1000_PTC127);
2086         E1000_READ_REG(hw, E1000_PTC255);
2087         E1000_READ_REG(hw, E1000_PTC511);
2088         E1000_READ_REG(hw, E1000_PTC1023);
2089         E1000_READ_REG(hw, E1000_PTC1522);
2090
2091         E1000_READ_REG(hw, E1000_ALGNERRC);
2092         E1000_READ_REG(hw, E1000_RXERRC);
2093         E1000_READ_REG(hw, E1000_TNCRS);
2094         E1000_READ_REG(hw, E1000_CEXTERR);
2095         E1000_READ_REG(hw, E1000_TSCTC);
2096         E1000_READ_REG(hw, E1000_TSCTFC);
2097
2098         E1000_READ_REG(hw, E1000_MGTPRC);
2099         E1000_READ_REG(hw, E1000_MGTPDC);
2100         E1000_READ_REG(hw, E1000_MGTPTC);
2101
2102         E1000_READ_REG(hw, E1000_IAC);
2103         E1000_READ_REG(hw, E1000_ICRXOC);
2104
2105         E1000_READ_REG(hw, E1000_ICRXPTC);
2106         E1000_READ_REG(hw, E1000_ICRXATC);
2107         E1000_READ_REG(hw, E1000_ICTXPTC);
2108         E1000_READ_REG(hw, E1000_ICTXATC);
2109         E1000_READ_REG(hw, E1000_ICTXQEC);
2110         E1000_READ_REG(hw, E1000_ICTXQMTC);
2111         E1000_READ_REG(hw, E1000_ICRXDMTC);
2112
2113         E1000_READ_REG(hw, E1000_CBTMPC);
2114         E1000_READ_REG(hw, E1000_HTDPMC);
2115         E1000_READ_REG(hw, E1000_CBRMPC);
2116         E1000_READ_REG(hw, E1000_RPTHC);
2117         E1000_READ_REG(hw, E1000_HGPTC);
2118         E1000_READ_REG(hw, E1000_HTCBDPC);
2119         E1000_READ_REG(hw, E1000_HGORCL);
2120         E1000_READ_REG(hw, E1000_HGORCH);
2121         E1000_READ_REG(hw, E1000_HGOTCL);
2122         E1000_READ_REG(hw, E1000_HGOTCH);
2123         E1000_READ_REG(hw, E1000_LENERRS);
2124
2125         /* This register should not be read in copper configurations */
2126         if ((hw->phy.media_type == e1000_media_type_internal_serdes) ||
2127             e1000_sgmii_active_82575(hw))
2128                 E1000_READ_REG(hw, E1000_SCVPC);
2129 }
2130
2131 /**
2132  *  e1000_rx_fifo_flush_82575 - Clean rx fifo after Rx enable
2133  *  @hw: pointer to the HW structure
2134  *
2135  *  After rx enable if managability is enabled then there is likely some
2136  *  bad data at the start of the fifo and possibly in the DMA fifo.  This
2137  *  function clears the fifos and flushes any packets that came in as rx was
2138  *  being enabled.
2139  **/
2140 void e1000_rx_fifo_flush_82575(struct e1000_hw *hw)
2141 {
2142         u32 rctl, rlpml, rxdctl[4], rfctl, temp_rctl, rx_enabled;
2143         int i, ms_wait;
2144
2145         DEBUGFUNC("e1000_rx_fifo_workaround_82575");
2146         if (hw->mac.type != e1000_82575 ||
2147             !(E1000_READ_REG(hw, E1000_MANC) & E1000_MANC_RCV_TCO_EN))
2148                 return;
2149
2150         /* Disable all Rx queues */
2151         for (i = 0; i < 4; i++) {
2152                 rxdctl[i] = E1000_READ_REG(hw, E1000_RXDCTL(i));
2153                 E1000_WRITE_REG(hw, E1000_RXDCTL(i),
2154                                 rxdctl[i] & ~E1000_RXDCTL_QUEUE_ENABLE);
2155         }
2156         /* Poll all queues to verify they have shut down */
2157         for (ms_wait = 0; ms_wait < 10; ms_wait++) {
2158                 msec_delay(1);
2159                 rx_enabled = 0;
2160                 for (i = 0; i < 4; i++)
2161                         rx_enabled |= E1000_READ_REG(hw, E1000_RXDCTL(i));
2162                 if (!(rx_enabled & E1000_RXDCTL_QUEUE_ENABLE))
2163                         break;
2164         }
2165
2166         if (ms_wait == 10)
2167                 DEBUGOUT("Queue disable timed out after 10ms\n");
2168
2169         /* Clear RLPML, RCTL.SBP, RFCTL.LEF, and set RCTL.LPE so that all
2170          * incoming packets are rejected.  Set enable and wait 2ms so that
2171          * any packet that was coming in as RCTL.EN was set is flushed
2172          */
2173         rfctl = E1000_READ_REG(hw, E1000_RFCTL);
2174         E1000_WRITE_REG(hw, E1000_RFCTL, rfctl & ~E1000_RFCTL_LEF);
2175
2176         rlpml = E1000_READ_REG(hw, E1000_RLPML);
2177         E1000_WRITE_REG(hw, E1000_RLPML, 0);
2178
2179         rctl = E1000_READ_REG(hw, E1000_RCTL);
2180         temp_rctl = rctl & ~(E1000_RCTL_EN | E1000_RCTL_SBP);
2181         temp_rctl |= E1000_RCTL_LPE;
2182
2183         E1000_WRITE_REG(hw, E1000_RCTL, temp_rctl);
2184         E1000_WRITE_REG(hw, E1000_RCTL, temp_rctl | E1000_RCTL_EN);
2185         E1000_WRITE_FLUSH(hw);
2186         msec_delay(2);
2187
2188         /* Enable Rx queues that were previously enabled and restore our
2189          * previous state
2190          */
2191         for (i = 0; i < 4; i++)
2192                 E1000_WRITE_REG(hw, E1000_RXDCTL(i), rxdctl[i]);
2193         E1000_WRITE_REG(hw, E1000_RCTL, rctl);
2194         E1000_WRITE_FLUSH(hw);
2195
2196         E1000_WRITE_REG(hw, E1000_RLPML, rlpml);
2197         E1000_WRITE_REG(hw, E1000_RFCTL, rfctl);
2198
2199         /* Flush receive errors generated by workaround */
2200         E1000_READ_REG(hw, E1000_ROC);
2201         E1000_READ_REG(hw, E1000_RNBC);
2202         E1000_READ_REG(hw, E1000_MPC);
2203 }
2204
2205 /**
2206  *  e1000_set_pcie_completion_timeout - set pci-e completion timeout
2207  *  @hw: pointer to the HW structure
2208  *
2209  *  The defaults for 82575 and 82576 should be in the range of 50us to 50ms,
2210  *  however the hardware default for these parts is 500us to 1ms which is less
2211  *  than the 10ms recommended by the pci-e spec.  To address this we need to
2212  *  increase the value to either 10ms to 200ms for capability version 1 config,
2213  *  or 16ms to 55ms for version 2.
2214  **/
2215 STATIC s32 e1000_set_pcie_completion_timeout(struct e1000_hw *hw)
2216 {
2217         u32 gcr = E1000_READ_REG(hw, E1000_GCR);
2218         s32 ret_val = E1000_SUCCESS;
2219         u16 pcie_devctl2;
2220
2221         /* only take action if timeout value is defaulted to 0 */
2222         if (gcr & E1000_GCR_CMPL_TMOUT_MASK)
2223                 goto out;
2224
2225         /*
2226          * if capababilities version is type 1 we can write the
2227          * timeout of 10ms to 200ms through the GCR register
2228          */
2229         if (!(gcr & E1000_GCR_CAP_VER2)) {
2230                 gcr |= E1000_GCR_CMPL_TMOUT_10ms;
2231                 goto out;
2232         }
2233
2234         /*
2235          * for version 2 capabilities we need to write the config space
2236          * directly in order to set the completion timeout value for
2237          * 16ms to 55ms
2238          */
2239         ret_val = e1000_read_pcie_cap_reg(hw, PCIE_DEVICE_CONTROL2,
2240                                           &pcie_devctl2);
2241         if (ret_val)
2242                 goto out;
2243
2244         pcie_devctl2 |= PCIE_DEVICE_CONTROL2_16ms;
2245
2246         ret_val = e1000_write_pcie_cap_reg(hw, PCIE_DEVICE_CONTROL2,
2247                                            &pcie_devctl2);
2248 out:
2249         /* disable completion timeout resend */
2250         gcr &= ~E1000_GCR_CMPL_TMOUT_RESEND;
2251
2252         E1000_WRITE_REG(hw, E1000_GCR, gcr);
2253         return ret_val;
2254 }
2255
2256 /**
2257  *  e1000_vmdq_set_anti_spoofing_pf - enable or disable anti-spoofing
2258  *  @hw: pointer to the hardware struct
2259  *  @enable: state to enter, either enabled or disabled
2260  *  @pf: Physical Function pool - do not set anti-spoofing for the PF
2261  *
2262  *  enables/disables L2 switch anti-spoofing functionality.
2263  **/
2264 void e1000_vmdq_set_anti_spoofing_pf(struct e1000_hw *hw, bool enable, int pf)
2265 {
2266         u32 reg_val, reg_offset;
2267
2268         switch (hw->mac.type) {
2269         case e1000_82576:
2270                 reg_offset = E1000_DTXSWC;
2271                 break;
2272         case e1000_i350:
2273         case e1000_i354:
2274                 reg_offset = E1000_TXSWC;
2275                 break;
2276         default:
2277                 return;
2278         }
2279
2280         reg_val = E1000_READ_REG(hw, reg_offset);
2281         if (enable) {
2282                 reg_val |= (E1000_DTXSWC_MAC_SPOOF_MASK |
2283                              E1000_DTXSWC_VLAN_SPOOF_MASK);
2284                 /* The PF can spoof - it has to in order to
2285                  * support emulation mode NICs
2286                  */
2287                 reg_val ^= (1 << pf | 1 << (pf + MAX_NUM_VFS));
2288         } else {
2289                 reg_val &= ~(E1000_DTXSWC_MAC_SPOOF_MASK |
2290                              E1000_DTXSWC_VLAN_SPOOF_MASK);
2291         }
2292         E1000_WRITE_REG(hw, reg_offset, reg_val);
2293 }
2294
2295 /**
2296  *  e1000_vmdq_set_loopback_pf - enable or disable vmdq loopback
2297  *  @hw: pointer to the hardware struct
2298  *  @enable: state to enter, either enabled or disabled
2299  *
2300  *  enables/disables L2 switch loopback functionality.
2301  **/
2302 void e1000_vmdq_set_loopback_pf(struct e1000_hw *hw, bool enable)
2303 {
2304         u32 dtxswc;
2305
2306         switch (hw->mac.type) {
2307         case e1000_82576:
2308                 dtxswc = E1000_READ_REG(hw, E1000_DTXSWC);
2309                 if (enable)
2310                         dtxswc |= E1000_DTXSWC_VMDQ_LOOPBACK_EN;
2311                 else
2312                         dtxswc &= ~E1000_DTXSWC_VMDQ_LOOPBACK_EN;
2313                 E1000_WRITE_REG(hw, E1000_DTXSWC, dtxswc);
2314                 break;
2315         case e1000_i350:
2316         case e1000_i354:
2317                 dtxswc = E1000_READ_REG(hw, E1000_TXSWC);
2318                 if (enable)
2319                         dtxswc |= E1000_DTXSWC_VMDQ_LOOPBACK_EN;
2320                 else
2321                         dtxswc &= ~E1000_DTXSWC_VMDQ_LOOPBACK_EN;
2322                 E1000_WRITE_REG(hw, E1000_TXSWC, dtxswc);
2323                 break;
2324         default:
2325                 /* Currently no other hardware supports loopback */
2326                 break;
2327         }
2328
2329
2330 }
2331
2332 /**
2333  *  e1000_vmdq_set_replication_pf - enable or disable vmdq replication
2334  *  @hw: pointer to the hardware struct
2335  *  @enable: state to enter, either enabled or disabled
2336  *
2337  *  enables/disables replication of packets across multiple pools.
2338  **/
2339 void e1000_vmdq_set_replication_pf(struct e1000_hw *hw, bool enable)
2340 {
2341         u32 vt_ctl = E1000_READ_REG(hw, E1000_VT_CTL);
2342
2343         if (enable)
2344                 vt_ctl |= E1000_VT_CTL_VM_REPL_EN;
2345         else
2346                 vt_ctl &= ~E1000_VT_CTL_VM_REPL_EN;
2347
2348         E1000_WRITE_REG(hw, E1000_VT_CTL, vt_ctl);
2349 }
2350
2351 /**
2352  *  e1000_read_phy_reg_82580 - Read 82580 MDI control register
2353  *  @hw: pointer to the HW structure
2354  *  @offset: register offset to be read
2355  *  @data: pointer to the read data
2356  *
2357  *  Reads the MDI control register in the PHY at offset and stores the
2358  *  information read to data.
2359  **/
2360 STATIC s32 e1000_read_phy_reg_82580(struct e1000_hw *hw, u32 offset, u16 *data)
2361 {
2362         s32 ret_val;
2363
2364         DEBUGFUNC("e1000_read_phy_reg_82580");
2365
2366         ret_val = hw->phy.ops.acquire(hw);
2367         if (ret_val)
2368                 goto out;
2369
2370         ret_val = e1000_read_phy_reg_mdic(hw, offset, data);
2371
2372         hw->phy.ops.release(hw);
2373
2374 out:
2375         return ret_val;
2376 }
2377
2378 /**
2379  *  e1000_write_phy_reg_82580 - Write 82580 MDI control register
2380  *  @hw: pointer to the HW structure
2381  *  @offset: register offset to write to
2382  *  @data: data to write to register at offset
2383  *
2384  *  Writes data to MDI control register in the PHY at offset.
2385  **/
2386 STATIC s32 e1000_write_phy_reg_82580(struct e1000_hw *hw, u32 offset, u16 data)
2387 {
2388         s32 ret_val;
2389
2390         DEBUGFUNC("e1000_write_phy_reg_82580");
2391
2392         ret_val = hw->phy.ops.acquire(hw);
2393         if (ret_val)
2394                 goto out;
2395
2396         ret_val = e1000_write_phy_reg_mdic(hw, offset, data);
2397
2398         hw->phy.ops.release(hw);
2399
2400 out:
2401         return ret_val;
2402 }
2403
2404 /**
2405  *  e1000_reset_mdicnfg_82580 - Reset MDICNFG destination and com_mdio bits
2406  *  @hw: pointer to the HW structure
2407  *
2408  *  This resets the the MDICNFG.Destination and MDICNFG.Com_MDIO bits based on
2409  *  the values found in the EEPROM.  This addresses an issue in which these
2410  *  bits are not restored from EEPROM after reset.
2411  **/
2412 STATIC s32 e1000_reset_mdicnfg_82580(struct e1000_hw *hw)
2413 {
2414         s32 ret_val = E1000_SUCCESS;
2415         u32 mdicnfg;
2416         u16 nvm_data = 0;
2417
2418         DEBUGFUNC("e1000_reset_mdicnfg_82580");
2419
2420         if (hw->mac.type != e1000_82580)
2421                 goto out;
2422         if (!e1000_sgmii_active_82575(hw))
2423                 goto out;
2424
2425         ret_val = hw->nvm.ops.read(hw, NVM_INIT_CONTROL3_PORT_A +
2426                                    NVM_82580_LAN_FUNC_OFFSET(hw->bus.func), 1,
2427                                    &nvm_data);
2428         if (ret_val) {
2429                 DEBUGOUT("NVM Read Error\n");
2430                 goto out;
2431         }
2432
2433         mdicnfg = E1000_READ_REG(hw, E1000_MDICNFG);
2434         if (nvm_data & NVM_WORD24_EXT_MDIO)
2435                 mdicnfg |= E1000_MDICNFG_EXT_MDIO;
2436         if (nvm_data & NVM_WORD24_COM_MDIO)
2437                 mdicnfg |= E1000_MDICNFG_COM_MDIO;
2438         E1000_WRITE_REG(hw, E1000_MDICNFG, mdicnfg);
2439 out:
2440         return ret_val;
2441 }
2442
2443 /**
2444  *  e1000_reset_hw_82580 - Reset hardware
2445  *  @hw: pointer to the HW structure
2446  *
2447  *  This resets function or entire device (all ports, etc.)
2448  *  to a known state.
2449  **/
2450 STATIC s32 e1000_reset_hw_82580(struct e1000_hw *hw)
2451 {
2452         s32 ret_val = E1000_SUCCESS;
2453         /* BH SW mailbox bit in SW_FW_SYNC */
2454         u16 swmbsw_mask = E1000_SW_SYNCH_MB;
2455         u32 ctrl;
2456         bool global_device_reset = hw->dev_spec._82575.global_device_reset;
2457
2458         DEBUGFUNC("e1000_reset_hw_82580");
2459
2460         hw->dev_spec._82575.global_device_reset = false;
2461
2462         /* 82580 does not reliably do global_device_reset due to hw errata */
2463         if (hw->mac.type == e1000_82580)
2464                 global_device_reset = false;
2465
2466         /* Get current control state. */
2467         ctrl = E1000_READ_REG(hw, E1000_CTRL);
2468
2469         /*
2470          * Prevent the PCI-E bus from sticking if there is no TLP connection
2471          * on the last TLP read/write transaction when MAC is reset.
2472          */
2473         ret_val = e1000_disable_pcie_master_generic(hw);
2474         if (ret_val)
2475                 DEBUGOUT("PCI-E Master disable polling has failed.\n");
2476
2477         DEBUGOUT("Masking off all interrupts\n");
2478         E1000_WRITE_REG(hw, E1000_IMC, 0xffffffff);
2479         E1000_WRITE_REG(hw, E1000_RCTL, 0);
2480         E1000_WRITE_REG(hw, E1000_TCTL, E1000_TCTL_PSP);
2481         E1000_WRITE_FLUSH(hw);
2482
2483         msec_delay(10);
2484
2485         /* Determine whether or not a global dev reset is requested */
2486         if (global_device_reset && hw->mac.ops.acquire_swfw_sync(hw,
2487             swmbsw_mask))
2488                         global_device_reset = false;
2489
2490         if (global_device_reset && !(E1000_READ_REG(hw, E1000_STATUS) &
2491             E1000_STAT_DEV_RST_SET))
2492                 ctrl |= E1000_CTRL_DEV_RST;
2493         else
2494                 ctrl |= E1000_CTRL_RST;
2495
2496         E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
2497
2498         switch (hw->device_id) {
2499         case E1000_DEV_ID_DH89XXCC_SGMII:
2500                 break;
2501         default:
2502                 E1000_WRITE_FLUSH(hw);
2503                 break;
2504         }
2505
2506         /* Add delay to insure DEV_RST or RST has time to complete */
2507         msec_delay(5);
2508
2509         ret_val = e1000_get_auto_rd_done_generic(hw);
2510         if (ret_val) {
2511                 /*
2512                  * When auto config read does not complete, do not
2513                  * return with an error. This can happen in situations
2514                  * where there is no eeprom and prevents getting link.
2515                  */
2516                 DEBUGOUT("Auto Read Done did not complete\n");
2517         }
2518
2519         /* clear global device reset status bit */
2520         E1000_WRITE_REG(hw, E1000_STATUS, E1000_STAT_DEV_RST_SET);
2521
2522         /* Clear any pending interrupt events. */
2523         E1000_WRITE_REG(hw, E1000_IMC, 0xffffffff);
2524         E1000_READ_REG(hw, E1000_ICR);
2525
2526         ret_val = e1000_reset_mdicnfg_82580(hw);
2527         if (ret_val)
2528                 DEBUGOUT("Could not reset MDICNFG based on EEPROM\n");
2529
2530         /* Install any alternate MAC address into RAR0 */
2531         ret_val = e1000_check_alt_mac_addr_generic(hw);
2532
2533         /* Release semaphore */
2534         if (global_device_reset)
2535                 hw->mac.ops.release_swfw_sync(hw, swmbsw_mask);
2536
2537         return ret_val;
2538 }
2539
2540 /**
2541  *  e1000_rxpbs_adjust_82580 - adjust RXPBS value to reflect actual Rx PBA size
2542  *  @data: data received by reading RXPBS register
2543  *
2544  *  The 82580 uses a table based approach for packet buffer allocation sizes.
2545  *  This function converts the retrieved value into the correct table value
2546  *     0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7
2547  *  0x0 36  72 144   1   2   4   8  16
2548  *  0x8 35  70 140 rsv rsv rsv rsv rsv
2549  */
2550 u16 e1000_rxpbs_adjust_82580(u32 data)
2551 {
2552         u16 ret_val = 0;
2553
2554         if (data < E1000_82580_RXPBS_TABLE_SIZE)
2555                 ret_val = e1000_82580_rxpbs_table[data];
2556
2557         return ret_val;
2558 }
2559
2560 /**
2561  *  e1000_validate_nvm_checksum_with_offset - Validate EEPROM
2562  *  checksum
2563  *  @hw: pointer to the HW structure
2564  *  @offset: offset in words of the checksum protected region
2565  *
2566  *  Calculates the EEPROM checksum by reading/adding each word of the EEPROM
2567  *  and then verifies that the sum of the EEPROM is equal to 0xBABA.
2568  **/
2569 s32 e1000_validate_nvm_checksum_with_offset(struct e1000_hw *hw, u16 offset)
2570 {
2571         s32 ret_val = E1000_SUCCESS;
2572         u16 checksum = 0;
2573         u16 i, nvm_data;
2574
2575         DEBUGFUNC("e1000_validate_nvm_checksum_with_offset");
2576
2577         for (i = offset; i < ((NVM_CHECKSUM_REG + offset) + 1); i++) {
2578                 ret_val = hw->nvm.ops.read(hw, i, 1, &nvm_data);
2579                 if (ret_val) {
2580                         DEBUGOUT("NVM Read Error\n");
2581                         goto out;
2582                 }
2583                 checksum += nvm_data;
2584         }
2585
2586         if (checksum != (u16) NVM_SUM) {
2587                 DEBUGOUT("NVM Checksum Invalid\n");
2588                 ret_val = -E1000_ERR_NVM;
2589                 goto out;
2590         }
2591
2592 out:
2593         return ret_val;
2594 }
2595
2596 /**
2597  *  e1000_update_nvm_checksum_with_offset - Update EEPROM
2598  *  checksum
2599  *  @hw: pointer to the HW structure
2600  *  @offset: offset in words of the checksum protected region
2601  *
2602  *  Updates the EEPROM checksum by reading/adding each word of the EEPROM
2603  *  up to the checksum.  Then calculates the EEPROM checksum and writes the
2604  *  value to the EEPROM.
2605  **/
2606 s32 e1000_update_nvm_checksum_with_offset(struct e1000_hw *hw, u16 offset)
2607 {
2608         s32 ret_val;
2609         u16 checksum = 0;
2610         u16 i, nvm_data;
2611
2612         DEBUGFUNC("e1000_update_nvm_checksum_with_offset");
2613
2614         for (i = offset; i < (NVM_CHECKSUM_REG + offset); i++) {
2615                 ret_val = hw->nvm.ops.read(hw, i, 1, &nvm_data);
2616                 if (ret_val) {
2617                         DEBUGOUT("NVM Read Error while updating checksum.\n");
2618                         goto out;
2619                 }
2620                 checksum += nvm_data;
2621         }
2622         checksum = (u16) NVM_SUM - checksum;
2623         ret_val = hw->nvm.ops.write(hw, (NVM_CHECKSUM_REG + offset), 1,
2624                                     &checksum);
2625         if (ret_val)
2626                 DEBUGOUT("NVM Write Error while updating checksum.\n");
2627
2628 out:
2629         return ret_val;
2630 }
2631
2632 /**
2633  *  e1000_validate_nvm_checksum_82580 - Validate EEPROM checksum
2634  *  @hw: pointer to the HW structure
2635  *
2636  *  Calculates the EEPROM section checksum by reading/adding each word of
2637  *  the EEPROM and then verifies that the sum of the EEPROM is
2638  *  equal to 0xBABA.
2639  **/
2640 STATIC s32 e1000_validate_nvm_checksum_82580(struct e1000_hw *hw)
2641 {
2642         s32 ret_val;
2643         u16 eeprom_regions_count = 1;
2644         u16 j, nvm_data;
2645         u16 nvm_offset;
2646
2647         DEBUGFUNC("e1000_validate_nvm_checksum_82580");
2648
2649         ret_val = hw->nvm.ops.read(hw, NVM_COMPATIBILITY_REG_3, 1, &nvm_data);
2650         if (ret_val) {
2651                 DEBUGOUT("NVM Read Error\n");
2652                 goto out;
2653         }
2654
2655         if (nvm_data & NVM_COMPATIBILITY_BIT_MASK) {
2656                 /* if chekcsums compatibility bit is set validate checksums
2657                  * for all 4 ports. */
2658                 eeprom_regions_count = 4;
2659         }
2660
2661         for (j = 0; j < eeprom_regions_count; j++) {
2662                 nvm_offset = NVM_82580_LAN_FUNC_OFFSET(j);
2663                 ret_val = e1000_validate_nvm_checksum_with_offset(hw,
2664                                                                   nvm_offset);
2665                 if (ret_val != E1000_SUCCESS)
2666                         goto out;
2667         }
2668
2669 out:
2670         return ret_val;
2671 }
2672
2673 /**
2674  *  e1000_update_nvm_checksum_82580 - Update EEPROM checksum
2675  *  @hw: pointer to the HW structure
2676  *
2677  *  Updates the EEPROM section checksums for all 4 ports by reading/adding
2678  *  each word of the EEPROM up to the checksum.  Then calculates the EEPROM
2679  *  checksum and writes the value to the EEPROM.
2680  **/
2681 STATIC s32 e1000_update_nvm_checksum_82580(struct e1000_hw *hw)
2682 {
2683         s32 ret_val;
2684         u16 j, nvm_data;
2685         u16 nvm_offset;
2686
2687         DEBUGFUNC("e1000_update_nvm_checksum_82580");
2688
2689         ret_val = hw->nvm.ops.read(hw, NVM_COMPATIBILITY_REG_3, 1, &nvm_data);
2690         if (ret_val) {
2691                 DEBUGOUT("NVM Read Error while updating checksum compatibility bit.\n");
2692                 goto out;
2693         }
2694
2695         if (!(nvm_data & NVM_COMPATIBILITY_BIT_MASK)) {
2696                 /* set compatibility bit to validate checksums appropriately */
2697                 nvm_data = nvm_data | NVM_COMPATIBILITY_BIT_MASK;
2698                 ret_val = hw->nvm.ops.write(hw, NVM_COMPATIBILITY_REG_3, 1,
2699                                             &nvm_data);
2700                 if (ret_val) {
2701                         DEBUGOUT("NVM Write Error while updating checksum compatibility bit.\n");
2702                         goto out;
2703                 }
2704         }
2705
2706         for (j = 0; j < 4; j++) {
2707                 nvm_offset = NVM_82580_LAN_FUNC_OFFSET(j);
2708                 ret_val = e1000_update_nvm_checksum_with_offset(hw, nvm_offset);
2709                 if (ret_val)
2710                         goto out;
2711         }
2712
2713 out:
2714         return ret_val;
2715 }
2716
2717 /**
2718  *  e1000_validate_nvm_checksum_i350 - Validate EEPROM checksum
2719  *  @hw: pointer to the HW structure
2720  *
2721  *  Calculates the EEPROM section checksum by reading/adding each word of
2722  *  the EEPROM and then verifies that the sum of the EEPROM is
2723  *  equal to 0xBABA.
2724  **/
2725 STATIC s32 e1000_validate_nvm_checksum_i350(struct e1000_hw *hw)
2726 {
2727         s32 ret_val = E1000_SUCCESS;
2728         u16 j;
2729         u16 nvm_offset;
2730
2731         DEBUGFUNC("e1000_validate_nvm_checksum_i350");
2732
2733         for (j = 0; j < 4; j++) {
2734                 nvm_offset = NVM_82580_LAN_FUNC_OFFSET(j);
2735                 ret_val = e1000_validate_nvm_checksum_with_offset(hw,
2736                                                                   nvm_offset);
2737                 if (ret_val != E1000_SUCCESS)
2738                         goto out;
2739         }
2740
2741 out:
2742         return ret_val;
2743 }
2744
2745 /**
2746  *  e1000_update_nvm_checksum_i350 - Update EEPROM checksum
2747  *  @hw: pointer to the HW structure
2748  *
2749  *  Updates the EEPROM section checksums for all 4 ports by reading/adding
2750  *  each word of the EEPROM up to the checksum.  Then calculates the EEPROM
2751  *  checksum and writes the value to the EEPROM.
2752  **/
2753 STATIC s32 e1000_update_nvm_checksum_i350(struct e1000_hw *hw)
2754 {
2755         s32 ret_val = E1000_SUCCESS;
2756         u16 j;
2757         u16 nvm_offset;
2758
2759         DEBUGFUNC("e1000_update_nvm_checksum_i350");
2760
2761         for (j = 0; j < 4; j++) {
2762                 nvm_offset = NVM_82580_LAN_FUNC_OFFSET(j);
2763                 ret_val = e1000_update_nvm_checksum_with_offset(hw, nvm_offset);
2764                 if (ret_val != E1000_SUCCESS)
2765                         goto out;
2766         }
2767
2768 out:
2769         return ret_val;
2770 }
2771
2772 /**
2773  *  __e1000_access_emi_reg - Read/write EMI register
2774  *  @hw: pointer to the HW structure
2775  *  @addr: EMI address to program
2776  *  @data: pointer to value to read/write from/to the EMI address
2777  *  @read: boolean flag to indicate read or write
2778  **/
2779 STATIC s32 __e1000_access_emi_reg(struct e1000_hw *hw, u16 address,
2780                                   u16 *data, bool read)
2781 {
2782         s32 ret_val;
2783
2784         DEBUGFUNC("__e1000_access_emi_reg");
2785
2786         ret_val = hw->phy.ops.write_reg(hw, E1000_EMIADD, address);
2787         if (ret_val)
2788                 return ret_val;
2789
2790         if (read)
2791                 ret_val = hw->phy.ops.read_reg(hw, E1000_EMIDATA, data);
2792         else
2793                 ret_val = hw->phy.ops.write_reg(hw, E1000_EMIDATA, *data);
2794
2795         return ret_val;
2796 }
2797
2798 /**
2799  *  e1000_read_emi_reg - Read Extended Management Interface register
2800  *  @hw: pointer to the HW structure
2801  *  @addr: EMI address to program
2802  *  @data: value to be read from the EMI address
2803  **/
2804 s32 e1000_read_emi_reg(struct e1000_hw *hw, u16 addr, u16 *data)
2805 {
2806         DEBUGFUNC("e1000_read_emi_reg");
2807
2808         return __e1000_access_emi_reg(hw, addr, data, true);
2809 }
2810
2811 /**
2812  *  e1000_initialize_M88E1512_phy - Initialize M88E1512 PHY
2813  *  @hw: pointer to the HW structure
2814  *
2815  *  Initialize Marverl 1512 to work correctly with Avoton.
2816  **/
2817 s32 e1000_initialize_M88E1512_phy(struct e1000_hw *hw)
2818 {
2819         struct e1000_phy_info *phy = &hw->phy;
2820         s32 ret_val = E1000_SUCCESS;
2821
2822         DEBUGFUNC("e1000_initialize_M88E1512_phy");
2823
2824         /* Check if this is correct PHY. */
2825         if (phy->id != M88E1512_E_PHY_ID)
2826                 goto out;
2827
2828         /* Switch to PHY page 0xFF. */
2829         ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0x00FF);
2830         if (ret_val)
2831                 goto out;
2832
2833         ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0x214B);
2834         if (ret_val)
2835                 goto out;
2836
2837         ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x2144);
2838         if (ret_val)
2839                 goto out;
2840
2841         ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0x0C28);
2842         if (ret_val)
2843                 goto out;
2844
2845         ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x2146);
2846         if (ret_val)
2847                 goto out;
2848
2849         ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0xB233);
2850         if (ret_val)
2851                 goto out;
2852
2853         ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x214D);
2854         if (ret_val)
2855                 goto out;
2856
2857         ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0xCC0C);
2858         if (ret_val)
2859                 goto out;
2860
2861         ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x2159);
2862         if (ret_val)
2863                 goto out;
2864
2865         /* Switch to PHY page 0xFB. */
2866         ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0x00FB);
2867         if (ret_val)
2868                 goto out;
2869
2870         ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_3, 0x000D);
2871         if (ret_val)
2872                 goto out;
2873
2874         /* Switch to PHY page 0x12. */
2875         ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0x12);
2876         if (ret_val)
2877                 goto out;
2878
2879         /* Change mode to SGMII-to-Copper */
2880         ret_val = phy->ops.write_reg(hw, E1000_M88E1512_MODE, 0x8001);
2881         if (ret_val)
2882                 goto out;
2883
2884         /* Return the PHY to page 0. */
2885         ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0);
2886         if (ret_val)
2887                 goto out;
2888
2889         ret_val = phy->ops.commit(hw);
2890         if (ret_val) {
2891                 DEBUGOUT("Error committing the PHY changes\n");
2892                 return ret_val;
2893         }
2894
2895         msec_delay(1000);
2896 out:
2897         return ret_val;
2898 }
2899
2900 /**
2901  *  e1000_set_eee_i350 - Enable/disable EEE support
2902  *  @hw: pointer to the HW structure
2903  *  @adv1g: boolean flag enabling 1G EEE advertisement
2904  *  @adv100m: boolean flag enabling 100M EEE advertisement
2905  *
2906  *  Enable/disable EEE based on setting in dev_spec structure.
2907  *
2908  **/
2909 s32 e1000_set_eee_i350(struct e1000_hw *hw, bool adv1G, bool adv100M)
2910 {
2911         u32 ipcnfg, eeer;
2912
2913         DEBUGFUNC("e1000_set_eee_i350");
2914
2915         if ((hw->mac.type < e1000_i350) ||
2916             (hw->phy.media_type != e1000_media_type_copper))
2917                 goto out;
2918         ipcnfg = E1000_READ_REG(hw, E1000_IPCNFG);
2919         eeer = E1000_READ_REG(hw, E1000_EEER);
2920
2921         /* enable or disable per user setting */
2922         if (!(hw->dev_spec._82575.eee_disable)) {
2923                 u32 eee_su = E1000_READ_REG(hw, E1000_EEE_SU);
2924
2925                 if (adv100M)
2926                         ipcnfg |= E1000_IPCNFG_EEE_100M_AN;
2927                 else
2928                         ipcnfg &= ~E1000_IPCNFG_EEE_100M_AN;
2929
2930                 if (adv1G)
2931                         ipcnfg |= E1000_IPCNFG_EEE_1G_AN;
2932                 else
2933                         ipcnfg &= ~E1000_IPCNFG_EEE_1G_AN;
2934
2935                 eeer |= (E1000_EEER_TX_LPI_EN | E1000_EEER_RX_LPI_EN |
2936                          E1000_EEER_LPI_FC);
2937
2938                 /* This bit should not be set in normal operation. */
2939                 if (eee_su & E1000_EEE_SU_LPI_CLK_STP)
2940                         DEBUGOUT("LPI Clock Stop Bit should not be set!\n");
2941         } else {
2942                 ipcnfg &= ~(E1000_IPCNFG_EEE_1G_AN | E1000_IPCNFG_EEE_100M_AN);
2943                 eeer &= ~(E1000_EEER_TX_LPI_EN | E1000_EEER_RX_LPI_EN |
2944                           E1000_EEER_LPI_FC);
2945         }
2946         E1000_WRITE_REG(hw, E1000_IPCNFG, ipcnfg);
2947         E1000_WRITE_REG(hw, E1000_EEER, eeer);
2948         E1000_READ_REG(hw, E1000_IPCNFG);
2949         E1000_READ_REG(hw, E1000_EEER);
2950 out:
2951
2952         return E1000_SUCCESS;
2953 }
2954
2955 /**
2956  *  e1000_set_eee_i354 - Enable/disable EEE support
2957  *  @hw: pointer to the HW structure
2958  *  @adv1g: boolean flag enabling 1G EEE advertisement
2959  *  @adv100m: boolean flag enabling 100M EEE advertisement
2960  *
2961  *  Enable/disable EEE legacy mode based on setting in dev_spec structure.
2962  *
2963  **/
2964 s32 e1000_set_eee_i354(struct e1000_hw *hw, bool adv1G, bool adv100M)
2965 {
2966         struct e1000_phy_info *phy = &hw->phy;
2967         s32 ret_val = E1000_SUCCESS;
2968         u16 phy_data;
2969
2970         DEBUGFUNC("e1000_set_eee_i354");
2971
2972         if ((hw->phy.media_type != e1000_media_type_copper) ||
2973             ((phy->id != M88E1543_E_PHY_ID) &&
2974             (phy->id != M88E1512_E_PHY_ID)))
2975                 goto out;
2976
2977         if (!hw->dev_spec._82575.eee_disable) {
2978                 /* Switch to PHY page 18. */
2979                 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 18);
2980                 if (ret_val)
2981                         goto out;
2982
2983                 ret_val = phy->ops.read_reg(hw, E1000_M88E1543_EEE_CTRL_1,
2984                                             &phy_data);
2985                 if (ret_val)
2986                         goto out;
2987
2988                 phy_data |= E1000_M88E1543_EEE_CTRL_1_MS;
2989                 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_EEE_CTRL_1,
2990                                              phy_data);
2991                 if (ret_val)
2992                         goto out;
2993
2994                 /* Return the PHY to page 0. */
2995                 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0);
2996                 if (ret_val)
2997                         goto out;
2998
2999                 /* Turn on EEE advertisement. */
3000                 ret_val = e1000_read_xmdio_reg(hw, E1000_EEE_ADV_ADDR_I354,
3001                                                E1000_EEE_ADV_DEV_I354,
3002                                                &phy_data);
3003                 if (ret_val)
3004                         goto out;
3005
3006                 if (adv100M)
3007                         phy_data |= E1000_EEE_ADV_100_SUPPORTED;
3008                 else
3009                         phy_data &= ~E1000_EEE_ADV_100_SUPPORTED;
3010
3011                 if (adv1G)
3012                         phy_data |= E1000_EEE_ADV_1000_SUPPORTED;
3013                 else
3014                         phy_data &= ~E1000_EEE_ADV_1000_SUPPORTED;
3015
3016                 ret_val = e1000_write_xmdio_reg(hw, E1000_EEE_ADV_ADDR_I354,
3017                                                 E1000_EEE_ADV_DEV_I354,
3018                                                 phy_data);
3019         } else {
3020                 /* Turn off EEE advertisement. */
3021                 ret_val = e1000_read_xmdio_reg(hw, E1000_EEE_ADV_ADDR_I354,
3022                                                E1000_EEE_ADV_DEV_I354,
3023                                                &phy_data);
3024                 if (ret_val)
3025                         goto out;
3026
3027                 phy_data &= ~(E1000_EEE_ADV_100_SUPPORTED |
3028                               E1000_EEE_ADV_1000_SUPPORTED);
3029                 ret_val = e1000_write_xmdio_reg(hw, E1000_EEE_ADV_ADDR_I354,
3030                                                 E1000_EEE_ADV_DEV_I354,
3031                                                 phy_data);
3032         }
3033
3034 out:
3035         return ret_val;
3036 }
3037
3038 /**
3039  *  e1000_get_eee_status_i354 - Get EEE status
3040  *  @hw: pointer to the HW structure
3041  *  @status: EEE status
3042  *
3043  *  Get EEE status by guessing based on whether Tx or Rx LPI indications have
3044  *  been received.
3045  **/
3046 s32 e1000_get_eee_status_i354(struct e1000_hw *hw, bool *status)
3047 {
3048         struct e1000_phy_info *phy = &hw->phy;
3049         s32 ret_val = E1000_SUCCESS;
3050         u16 phy_data;
3051
3052         DEBUGFUNC("e1000_get_eee_status_i354");
3053
3054         /* Check if EEE is supported on this device. */
3055         if ((hw->phy.media_type != e1000_media_type_copper) ||
3056             ((phy->id != M88E1543_E_PHY_ID) &&
3057             (phy->id != M88E1512_E_PHY_ID)))
3058                 goto out;
3059
3060         ret_val = e1000_read_xmdio_reg(hw, E1000_PCS_STATUS_ADDR_I354,
3061                                        E1000_PCS_STATUS_DEV_I354,
3062                                        &phy_data);
3063         if (ret_val)
3064                 goto out;
3065
3066         *status = phy_data & (E1000_PCS_STATUS_TX_LPI_RCVD |
3067                               E1000_PCS_STATUS_RX_LPI_RCVD) ? true : false;
3068
3069 out:
3070         return ret_val;
3071 }
3072
3073 /* Due to a hw errata, if the host tries to  configure the VFTA register
3074  * while performing queries from the BMC or DMA, then the VFTA in some
3075  * cases won't be written.
3076  */
3077
3078 /**
3079  *  e1000_clear_vfta_i350 - Clear VLAN filter table
3080  *  @hw: pointer to the HW structure
3081  *
3082  *  Clears the register array which contains the VLAN filter table by
3083  *  setting all the values to 0.
3084  **/
3085 void e1000_clear_vfta_i350(struct e1000_hw *hw)
3086 {
3087         u32 offset;
3088         int i;
3089
3090         DEBUGFUNC("e1000_clear_vfta_350");
3091
3092         for (offset = 0; offset < E1000_VLAN_FILTER_TBL_SIZE; offset++) {
3093                 for (i = 0; i < 10; i++)
3094                         E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, 0);
3095
3096                 E1000_WRITE_FLUSH(hw);
3097         }
3098 }
3099
3100 /**
3101  *  e1000_write_vfta_i350 - Write value to VLAN filter table
3102  *  @hw: pointer to the HW structure
3103  *  @offset: register offset in VLAN filter table
3104  *  @value: register value written to VLAN filter table
3105  *
3106  *  Writes value at the given offset in the register array which stores
3107  *  the VLAN filter table.
3108  **/
3109 void e1000_write_vfta_i350(struct e1000_hw *hw, u32 offset, u32 value)
3110 {
3111         int i;
3112
3113         DEBUGFUNC("e1000_write_vfta_350");
3114
3115         for (i = 0; i < 10; i++)
3116                 E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, value);
3117
3118         E1000_WRITE_FLUSH(hw);
3119 }
3120
3121
3122 /**
3123  *  e1000_set_i2c_bb - Enable I2C bit-bang
3124  *  @hw: pointer to the HW structure
3125  *
3126  *  Enable I2C bit-bang interface
3127  *
3128  **/
3129 s32 e1000_set_i2c_bb(struct e1000_hw *hw)
3130 {
3131         s32 ret_val = E1000_SUCCESS;
3132         u32 ctrl_ext, i2cparams;
3133
3134         DEBUGFUNC("e1000_set_i2c_bb");
3135
3136         ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
3137         ctrl_ext |= E1000_CTRL_I2C_ENA;
3138         E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
3139         E1000_WRITE_FLUSH(hw);
3140
3141         i2cparams = E1000_READ_REG(hw, E1000_I2CPARAMS);
3142         i2cparams |= E1000_I2CBB_EN;
3143         i2cparams |= E1000_I2C_DATA_OE_N;
3144         i2cparams |= E1000_I2C_CLK_OE_N;
3145         E1000_WRITE_REG(hw, E1000_I2CPARAMS, i2cparams);
3146         E1000_WRITE_FLUSH(hw);
3147
3148         return ret_val;
3149 }
3150
3151 /**
3152  *  e1000_read_i2c_byte_generic - Reads 8 bit word over I2C
3153  *  @hw: pointer to hardware structure
3154  *  @byte_offset: byte offset to read
3155  *  @dev_addr: device address
3156  *  @data: value read
3157  *
3158  *  Performs byte read operation over I2C interface at
3159  *  a specified device address.
3160  **/
3161 s32 e1000_read_i2c_byte_generic(struct e1000_hw *hw, u8 byte_offset,
3162                                 u8 dev_addr, u8 *data)
3163 {
3164         s32 status = E1000_SUCCESS;
3165         u32 max_retry = 10;
3166         u32 retry = 1;
3167         u16 swfw_mask = 0;
3168
3169         bool nack = true;
3170
3171         DEBUGFUNC("e1000_read_i2c_byte_generic");
3172
3173         swfw_mask = E1000_SWFW_PHY0_SM;
3174
3175         do {
3176                 if (hw->mac.ops.acquire_swfw_sync(hw, swfw_mask)
3177                     != E1000_SUCCESS) {
3178                         status = E1000_ERR_SWFW_SYNC;
3179                         goto read_byte_out;
3180                 }
3181
3182                 e1000_i2c_start(hw);
3183
3184                 /* Device Address and write indication */
3185                 status = e1000_clock_out_i2c_byte(hw, dev_addr);
3186                 if (status != E1000_SUCCESS)
3187                         goto fail;
3188
3189                 status = e1000_get_i2c_ack(hw);
3190                 if (status != E1000_SUCCESS)
3191                         goto fail;
3192
3193                 status = e1000_clock_out_i2c_byte(hw, byte_offset);
3194                 if (status != E1000_SUCCESS)
3195                         goto fail;
3196
3197                 status = e1000_get_i2c_ack(hw);
3198                 if (status != E1000_SUCCESS)
3199                         goto fail;
3200
3201                 e1000_i2c_start(hw);
3202
3203                 /* Device Address and read indication */
3204                 status = e1000_clock_out_i2c_byte(hw, (dev_addr | 0x1));
3205                 if (status != E1000_SUCCESS)
3206                         goto fail;
3207
3208                 status = e1000_get_i2c_ack(hw);
3209                 if (status != E1000_SUCCESS)
3210                         goto fail;
3211
3212                 status = e1000_clock_in_i2c_byte(hw, data);
3213                 if (status != E1000_SUCCESS)
3214                         goto fail;
3215
3216                 status = e1000_clock_out_i2c_bit(hw, nack);
3217                 if (status != E1000_SUCCESS)
3218                         goto fail;
3219
3220                 e1000_i2c_stop(hw);
3221                 break;
3222
3223 fail:
3224                 hw->mac.ops.release_swfw_sync(hw, swfw_mask);
3225                 msec_delay(100);
3226                 e1000_i2c_bus_clear(hw);
3227                 retry++;
3228                 if (retry < max_retry)
3229                         DEBUGOUT("I2C byte read error - Retrying.\n");
3230                 else
3231                         DEBUGOUT("I2C byte read error.\n");
3232
3233         } while (retry < max_retry);
3234
3235         hw->mac.ops.release_swfw_sync(hw, swfw_mask);
3236
3237 read_byte_out:
3238
3239         return status;
3240 }
3241
3242 /**
3243  *  e1000_write_i2c_byte_generic - Writes 8 bit word over I2C
3244  *  @hw: pointer to hardware structure
3245  *  @byte_offset: byte offset to write
3246  *  @dev_addr: device address
3247  *  @data: value to write
3248  *
3249  *  Performs byte write operation over I2C interface at
3250  *  a specified device address.
3251  **/
3252 s32 e1000_write_i2c_byte_generic(struct e1000_hw *hw, u8 byte_offset,
3253                                  u8 dev_addr, u8 data)
3254 {
3255         s32 status = E1000_SUCCESS;
3256         u32 max_retry = 1;
3257         u32 retry = 0;
3258         u16 swfw_mask = 0;
3259
3260         DEBUGFUNC("e1000_write_i2c_byte_generic");
3261
3262         swfw_mask = E1000_SWFW_PHY0_SM;
3263
3264         if (hw->mac.ops.acquire_swfw_sync(hw, swfw_mask) != E1000_SUCCESS) {
3265                 status = E1000_ERR_SWFW_SYNC;
3266                 goto write_byte_out;
3267         }
3268
3269         do {
3270                 e1000_i2c_start(hw);
3271
3272                 status = e1000_clock_out_i2c_byte(hw, dev_addr);
3273                 if (status != E1000_SUCCESS)
3274                         goto fail;
3275
3276                 status = e1000_get_i2c_ack(hw);
3277                 if (status != E1000_SUCCESS)
3278                         goto fail;
3279
3280                 status = e1000_clock_out_i2c_byte(hw, byte_offset);
3281                 if (status != E1000_SUCCESS)
3282                         goto fail;
3283
3284                 status = e1000_get_i2c_ack(hw);
3285                 if (status != E1000_SUCCESS)
3286                         goto fail;
3287
3288                 status = e1000_clock_out_i2c_byte(hw, data);
3289                 if (status != E1000_SUCCESS)
3290                         goto fail;
3291
3292                 status = e1000_get_i2c_ack(hw);
3293                 if (status != E1000_SUCCESS)
3294                         goto fail;
3295
3296                 e1000_i2c_stop(hw);
3297                 break;
3298
3299 fail:
3300                 e1000_i2c_bus_clear(hw);
3301                 retry++;
3302                 if (retry < max_retry)
3303                         DEBUGOUT("I2C byte write error - Retrying.\n");
3304                 else
3305                         DEBUGOUT("I2C byte write error.\n");
3306         } while (retry < max_retry);
3307
3308         hw->mac.ops.release_swfw_sync(hw, swfw_mask);
3309
3310 write_byte_out:
3311
3312         return status;
3313 }
3314
3315 /**
3316  *  e1000_i2c_start - Sets I2C start condition
3317  *  @hw: pointer to hardware structure
3318  *
3319  *  Sets I2C start condition (High -> Low on SDA while SCL is High)
3320  **/
3321 STATIC void e1000_i2c_start(struct e1000_hw *hw)
3322 {
3323         u32 i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3324
3325         DEBUGFUNC("e1000_i2c_start");
3326
3327         /* Start condition must begin with data and clock high */
3328         e1000_set_i2c_data(hw, &i2cctl, 1);
3329         e1000_raise_i2c_clk(hw, &i2cctl);
3330
3331         /* Setup time for start condition (4.7us) */
3332         usec_delay(E1000_I2C_T_SU_STA);
3333
3334         e1000_set_i2c_data(hw, &i2cctl, 0);
3335
3336         /* Hold time for start condition (4us) */
3337         usec_delay(E1000_I2C_T_HD_STA);
3338
3339         e1000_lower_i2c_clk(hw, &i2cctl);
3340
3341         /* Minimum low period of clock is 4.7 us */
3342         usec_delay(E1000_I2C_T_LOW);
3343
3344 }
3345
3346 /**
3347  *  e1000_i2c_stop - Sets I2C stop condition
3348  *  @hw: pointer to hardware structure
3349  *
3350  *  Sets I2C stop condition (Low -> High on SDA while SCL is High)
3351  **/
3352 STATIC void e1000_i2c_stop(struct e1000_hw *hw)
3353 {
3354         u32 i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3355
3356         DEBUGFUNC("e1000_i2c_stop");
3357
3358         /* Stop condition must begin with data low and clock high */
3359         e1000_set_i2c_data(hw, &i2cctl, 0);
3360         e1000_raise_i2c_clk(hw, &i2cctl);
3361
3362         /* Setup time for stop condition (4us) */
3363         usec_delay(E1000_I2C_T_SU_STO);
3364
3365         e1000_set_i2c_data(hw, &i2cctl, 1);
3366
3367         /* bus free time between stop and start (4.7us)*/
3368         usec_delay(E1000_I2C_T_BUF);
3369 }
3370
3371 /**
3372  *  e1000_clock_in_i2c_byte - Clocks in one byte via I2C
3373  *  @hw: pointer to hardware structure
3374  *  @data: data byte to clock in
3375  *
3376  *  Clocks in one byte data via I2C data/clock
3377  **/
3378 STATIC s32 e1000_clock_in_i2c_byte(struct e1000_hw *hw, u8 *data)
3379 {
3380         s32 i;
3381         bool bit = 0;
3382
3383         DEBUGFUNC("e1000_clock_in_i2c_byte");
3384
3385         *data = 0;
3386         for (i = 7; i >= 0; i--) {
3387                 e1000_clock_in_i2c_bit(hw, &bit);
3388                 *data |= bit << i;
3389         }
3390
3391         return E1000_SUCCESS;
3392 }
3393
3394 /**
3395  *  e1000_clock_out_i2c_byte - Clocks out one byte via I2C
3396  *  @hw: pointer to hardware structure
3397  *  @data: data byte clocked out
3398  *
3399  *  Clocks out one byte data via I2C data/clock
3400  **/
3401 STATIC s32 e1000_clock_out_i2c_byte(struct e1000_hw *hw, u8 data)
3402 {
3403         s32 status = E1000_SUCCESS;
3404         s32 i;
3405         u32 i2cctl;
3406         bool bit = 0;
3407
3408         DEBUGFUNC("e1000_clock_out_i2c_byte");
3409
3410         for (i = 7; i >= 0; i--) {
3411                 bit = (data >> i) & 0x1;
3412                 status = e1000_clock_out_i2c_bit(hw, bit);
3413
3414                 if (status != E1000_SUCCESS)
3415                         break;
3416         }
3417
3418         /* Release SDA line (set high) */
3419         i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3420
3421         i2cctl |= E1000_I2C_DATA_OE_N;
3422         E1000_WRITE_REG(hw, E1000_I2CPARAMS, i2cctl);
3423         E1000_WRITE_FLUSH(hw);
3424
3425         return status;
3426 }
3427
3428 /**
3429  *  e1000_get_i2c_ack - Polls for I2C ACK
3430  *  @hw: pointer to hardware structure
3431  *
3432  *  Clocks in/out one bit via I2C data/clock
3433  **/
3434 STATIC s32 e1000_get_i2c_ack(struct e1000_hw *hw)
3435 {
3436         s32 status = E1000_SUCCESS;
3437         u32 i = 0;
3438         u32 i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3439         u32 timeout = 10;
3440         bool ack = true;
3441
3442         DEBUGFUNC("e1000_get_i2c_ack");
3443
3444         e1000_raise_i2c_clk(hw, &i2cctl);
3445
3446         /* Minimum high period of clock is 4us */
3447         usec_delay(E1000_I2C_T_HIGH);
3448
3449         /* Wait until SCL returns high */
3450         for (i = 0; i < timeout; i++) {
3451                 usec_delay(1);
3452                 i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3453                 if (i2cctl & E1000_I2C_CLK_IN)
3454                         break;
3455         }
3456         if (!(i2cctl & E1000_I2C_CLK_IN))
3457                 return E1000_ERR_I2C;
3458
3459         ack = e1000_get_i2c_data(&i2cctl);
3460         if (ack) {
3461                 DEBUGOUT("I2C ack was not received.\n");
3462                 status = E1000_ERR_I2C;
3463         }
3464
3465         e1000_lower_i2c_clk(hw, &i2cctl);
3466
3467         /* Minimum low period of clock is 4.7 us */
3468         usec_delay(E1000_I2C_T_LOW);
3469
3470         return status;
3471 }
3472
3473 /**
3474  *  e1000_clock_in_i2c_bit - Clocks in one bit via I2C data/clock
3475  *  @hw: pointer to hardware structure
3476  *  @data: read data value
3477  *
3478  *  Clocks in one bit via I2C data/clock
3479  **/
3480 STATIC s32 e1000_clock_in_i2c_bit(struct e1000_hw *hw, bool *data)
3481 {
3482         u32 i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3483
3484         DEBUGFUNC("e1000_clock_in_i2c_bit");
3485
3486         e1000_raise_i2c_clk(hw, &i2cctl);
3487
3488         /* Minimum high period of clock is 4us */
3489         usec_delay(E1000_I2C_T_HIGH);
3490
3491         i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3492         *data = e1000_get_i2c_data(&i2cctl);
3493
3494         e1000_lower_i2c_clk(hw, &i2cctl);
3495
3496         /* Minimum low period of clock is 4.7 us */
3497         usec_delay(E1000_I2C_T_LOW);
3498
3499         return E1000_SUCCESS;
3500 }
3501
3502 /**
3503  *  e1000_clock_out_i2c_bit - Clocks in/out one bit via I2C data/clock
3504  *  @hw: pointer to hardware structure
3505  *  @data: data value to write
3506  *
3507  *  Clocks out one bit via I2C data/clock
3508  **/
3509 STATIC s32 e1000_clock_out_i2c_bit(struct e1000_hw *hw, bool data)
3510 {
3511         s32 status;
3512         u32 i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3513
3514         DEBUGFUNC("e1000_clock_out_i2c_bit");
3515
3516         status = e1000_set_i2c_data(hw, &i2cctl, data);
3517         if (status == E1000_SUCCESS) {
3518                 e1000_raise_i2c_clk(hw, &i2cctl);
3519
3520                 /* Minimum high period of clock is 4us */
3521                 usec_delay(E1000_I2C_T_HIGH);
3522
3523                 e1000_lower_i2c_clk(hw, &i2cctl);
3524
3525                 /* Minimum low period of clock is 4.7 us.
3526                  * This also takes care of the data hold time.
3527                  */
3528                 usec_delay(E1000_I2C_T_LOW);
3529         } else {
3530                 status = E1000_ERR_I2C;
3531                 DEBUGOUT1("I2C data was not set to %X\n", data);
3532         }
3533
3534         return status;
3535 }
3536 /**
3537  *  e1000_raise_i2c_clk - Raises the I2C SCL clock
3538  *  @hw: pointer to hardware structure
3539  *  @i2cctl: Current value of I2CCTL register
3540  *
3541  *  Raises the I2C clock line '0'->'1'
3542  **/
3543 STATIC void e1000_raise_i2c_clk(struct e1000_hw *hw, u32 *i2cctl)
3544 {
3545         DEBUGFUNC("e1000_raise_i2c_clk");
3546
3547         *i2cctl |= E1000_I2C_CLK_OUT;
3548         *i2cctl &= ~E1000_I2C_CLK_OE_N;
3549         E1000_WRITE_REG(hw, E1000_I2CPARAMS, *i2cctl);
3550         E1000_WRITE_FLUSH(hw);
3551
3552         /* SCL rise time (1000ns) */
3553         usec_delay(E1000_I2C_T_RISE);
3554 }
3555
3556 /**
3557  *  e1000_lower_i2c_clk - Lowers the I2C SCL clock
3558  *  @hw: pointer to hardware structure
3559  *  @i2cctl: Current value of I2CCTL register
3560  *
3561  *  Lowers the I2C clock line '1'->'0'
3562  **/
3563 STATIC void e1000_lower_i2c_clk(struct e1000_hw *hw, u32 *i2cctl)
3564 {
3565
3566         DEBUGFUNC("e1000_lower_i2c_clk");
3567
3568         *i2cctl &= ~E1000_I2C_CLK_OUT;
3569         *i2cctl &= ~E1000_I2C_CLK_OE_N;
3570         E1000_WRITE_REG(hw, E1000_I2CPARAMS, *i2cctl);
3571         E1000_WRITE_FLUSH(hw);
3572
3573         /* SCL fall time (300ns) */
3574         usec_delay(E1000_I2C_T_FALL);
3575 }
3576
3577 /**
3578  *  e1000_set_i2c_data - Sets the I2C data bit
3579  *  @hw: pointer to hardware structure
3580  *  @i2cctl: Current value of I2CCTL register
3581  *  @data: I2C data value (0 or 1) to set
3582  *
3583  *  Sets the I2C data bit
3584  **/
3585 STATIC s32 e1000_set_i2c_data(struct e1000_hw *hw, u32 *i2cctl, bool data)
3586 {
3587         s32 status = E1000_SUCCESS;
3588
3589         DEBUGFUNC("e1000_set_i2c_data");
3590
3591         if (data)
3592                 *i2cctl |= E1000_I2C_DATA_OUT;
3593         else
3594                 *i2cctl &= ~E1000_I2C_DATA_OUT;
3595
3596         *i2cctl &= ~E1000_I2C_DATA_OE_N;
3597         *i2cctl |= E1000_I2C_CLK_OE_N;
3598         E1000_WRITE_REG(hw, E1000_I2CPARAMS, *i2cctl);
3599         E1000_WRITE_FLUSH(hw);
3600
3601         /* Data rise/fall (1000ns/300ns) and set-up time (250ns) */
3602         usec_delay(E1000_I2C_T_RISE + E1000_I2C_T_FALL + E1000_I2C_T_SU_DATA);
3603
3604         *i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3605         if (data != e1000_get_i2c_data(i2cctl)) {
3606                 status = E1000_ERR_I2C;
3607                 DEBUGOUT1("Error - I2C data was not set to %X.\n", data);
3608         }
3609
3610         return status;
3611 }
3612
3613 /**
3614  *  e1000_get_i2c_data - Reads the I2C SDA data bit
3615  *  @hw: pointer to hardware structure
3616  *  @i2cctl: Current value of I2CCTL register
3617  *
3618  *  Returns the I2C data bit value
3619  **/
3620 STATIC bool e1000_get_i2c_data(u32 *i2cctl)
3621 {
3622         bool data;
3623
3624         DEBUGFUNC("e1000_get_i2c_data");
3625
3626         if (*i2cctl & E1000_I2C_DATA_IN)
3627                 data = 1;
3628         else
3629                 data = 0;
3630
3631         return data;
3632 }
3633
3634 /**
3635  *  e1000_i2c_bus_clear - Clears the I2C bus
3636  *  @hw: pointer to hardware structure
3637  *
3638  *  Clears the I2C bus by sending nine clock pulses.
3639  *  Used when data line is stuck low.
3640  **/
3641 void e1000_i2c_bus_clear(struct e1000_hw *hw)
3642 {
3643         u32 i2cctl = E1000_READ_REG(hw, E1000_I2CPARAMS);
3644         u32 i;
3645
3646         DEBUGFUNC("e1000_i2c_bus_clear");
3647
3648         e1000_i2c_start(hw);
3649
3650         e1000_set_i2c_data(hw, &i2cctl, 1);
3651
3652         for (i = 0; i < 9; i++) {
3653                 e1000_raise_i2c_clk(hw, &i2cctl);
3654
3655                 /* Min high period of clock is 4us */
3656                 usec_delay(E1000_I2C_T_HIGH);
3657
3658                 e1000_lower_i2c_clk(hw, &i2cctl);
3659
3660                 /* Min low period of clock is 4.7us*/
3661                 usec_delay(E1000_I2C_T_LOW);
3662         }
3663
3664         e1000_i2c_start(hw);
3665
3666         /* Put the i2c bus back to default state */
3667         e1000_i2c_stop(hw);
3668 }
3669