sys/dev/e1000/e1000_82575.c

   1 /******************************************************************************
   2
   3   Copyright (c) 2001-2010, 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 /*$FreeBSD$*/
  34
  35 /*
  36  * 82575EB Gigabit Network Connection
  37  * 82575EB Gigabit Backplane Connection
  38  * 82575GB Gigabit Network Connection
  39  * 82575GB Gigabit Network Connection
  40  * 82576 Gigabit Network Connection
  41  * 82576 Quad Port Gigabit Mezzanine Adapter
  42  */
  43
  44 #include "e1000_api.h"
  45
  46 static s32  e1000_init_phy_params_82575(struct e1000_hw *hw);
  47 static s32  e1000_init_nvm_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_get_cfg_done_82575(struct e1000_hw *hw);
  55 static s32  e1000_get_link_up_info_82575(struct e1000_hw *hw, u16 *speed,
  56                                          u16 *duplex);
  57 static s32  e1000_init_hw_82575(struct e1000_hw *hw);
  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_82575(struct e1000_hw *hw,
  68                                           bool active);
  69 static s32  e1000_setup_copper_link_82575(struct e1000_hw *hw);
  70 static s32  e1000_setup_serdes_link_82575(struct e1000_hw *hw);
  71 static s32  e1000_valid_led_default_82575(struct e1000_hw *hw, u16 *data);
  72 static s32  e1000_write_phy_reg_sgmii_82575(struct e1000_hw *hw,
  73                                             u32 offset, u16 data);
  74 static void e1000_clear_hw_cntrs_82575(struct e1000_hw *hw);
  75 static s32  e1000_acquire_swfw_sync_82575(struct e1000_hw *hw, u16 mask);
  76 static s32  e1000_get_pcs_speed_and_duplex_82575(struct e1000_hw *hw,
  77                                                  u16 *speed, u16 *duplex);
  78 static s32  e1000_get_phy_id_82575(struct e1000_hw *hw);
  79 static void e1000_release_swfw_sync_82575(struct e1000_hw *hw, u16 mask);
  80 static bool e1000_sgmii_active_82575(struct e1000_hw *hw);
  81 static s32  e1000_reset_init_script_82575(struct e1000_hw *hw);
  82 static s32  e1000_read_mac_addr_82575(struct e1000_hw *hw);
  83 static void e1000_config_collision_dist_82575(struct e1000_hw *hw);
  84 static void e1000_power_down_phy_copper_82575(struct e1000_hw *hw);
  85 static void e1000_shutdown_serdes_link_82575(struct e1000_hw *hw);
  86 static void e1000_power_up_serdes_link_82575(struct e1000_hw *hw);
  87 static s32 e1000_set_pcie_completion_timeout(struct e1000_hw *hw);
  88
  89 static const u16 e1000_82580_rxpbs_table[] =
  90         { 36, 72, 144, 1, 2, 4, 8, 16,
  91           35, 70, 140 };
  92 #define E1000_82580_RXPBS_TABLE_SIZE \
  93         (sizeof(e1000_82580_rxpbs_table)/sizeof(u16))
  94
  95 /**
  96  *  e1000_init_phy_params_82575 - Init PHY func ptrs.
  97  *  @hw: pointer to the HW structure
  98  **/
  99 static s32 e1000_init_phy_params_82575(struct e1000_hw *hw)
 100 {
 101         struct e1000_phy_info *phy = &hw->phy;
 102         s32 ret_val = E1000_SUCCESS;
 103
 104         DEBUGFUNC("e1000_init_phy_params_82575");
 105
 106         if (hw->phy.media_type != e1000_media_type_copper) {
 107                 phy->type = e1000_phy_none;
 108                 goto out;
 109         }
 110
 111         phy->ops.power_up   = e1000_power_up_phy_copper;
 112         phy->ops.power_down = e1000_power_down_phy_copper_82575;
 113
 114         phy->autoneg_mask           = AUTONEG_ADVERTISE_SPEED_DEFAULT;
 115         phy->reset_delay_us         = 100;
 116
 117         phy->ops.acquire            = e1000_acquire_phy_82575;
 118         phy->ops.check_reset_block  = e1000_check_reset_block_generic;
 119         phy->ops.commit             = e1000_phy_sw_reset_generic;
 120         phy->ops.get_cfg_done       = e1000_get_cfg_done_82575;
 121         phy->ops.release            = e1000_release_phy_82575;
 122
 123         if (e1000_sgmii_active_82575(hw)) {
 124                 phy->ops.reset      = e1000_phy_hw_reset_sgmii_82575;
 125                 phy->ops.read_reg   = e1000_read_phy_reg_sgmii_82575;
 126                 phy->ops.write_reg  = e1000_write_phy_reg_sgmii_82575;
 127         } else if (hw->mac.type >= e1000_82580) {
 128                 phy->ops.reset      = e1000_phy_hw_reset_generic;
 129                 phy->ops.read_reg   = e1000_read_phy_reg_82580;
 130                 phy->ops.write_reg  = e1000_write_phy_reg_82580;
 131         } else {
 132                 phy->ops.reset      = e1000_phy_hw_reset_generic;
 133                 phy->ops.read_reg   = e1000_read_phy_reg_igp;
 134                 phy->ops.write_reg  = e1000_write_phy_reg_igp;
 135         }
 136
 137         /* Set phy->phy_addr and phy->id. */
 138         ret_val = e1000_get_phy_id_82575(hw);
 139
 140         /* Verify phy id and set remaining function pointers */
 141         switch (phy->id) {
 142         case M88E1111_I_PHY_ID:
 143                 phy->type                   = e1000_phy_m88;
 144                 phy->ops.check_polarity     = e1000_check_polarity_m88;
 145                 phy->ops.get_info           = e1000_get_phy_info_m88;
 146                 phy->ops.get_cable_length   = e1000_get_cable_length_m88;
 147                 phy->ops.force_speed_duplex = e1000_phy_force_speed_duplex_m88;
 148                 break;
 149         case IGP03E1000_E_PHY_ID:
 150         case IGP04E1000_E_PHY_ID:
 151                 phy->type                   = e1000_phy_igp_3;
 152                 phy->ops.check_polarity     = e1000_check_polarity_igp;
 153                 phy->ops.get_info           = e1000_get_phy_info_igp;
 154                 phy->ops.get_cable_length   = e1000_get_cable_length_igp_2;
 155                 phy->ops.force_speed_duplex = e1000_phy_force_speed_duplex_igp;
 156                 phy->ops.set_d0_lplu_state  = e1000_set_d0_lplu_state_82575;
 157                 phy->ops.set_d3_lplu_state  = e1000_set_d3_lplu_state_generic;
 158                 break;
 159         case I82580_I_PHY_ID:
 160                 phy->type                   = e1000_phy_82580;
 161                 phy->ops.check_polarity     = e1000_check_polarity_82577;
 162                 phy->ops.force_speed_duplex = e1000_phy_force_speed_duplex_82577;
 163                 phy->ops.get_cable_length   = e1000_get_cable_length_82577;
 164                 phy->ops.get_info           = e1000_get_phy_info_82577;
 165                 break;
 166         default:
 167                 ret_val = -E1000_ERR_PHY;
 168                 goto out;
 169         }
 170
 171 out:
 172         return ret_val;
 173 }
 174
 175 /**
 176  *  e1000_init_nvm_params_82575 - Init NVM func ptrs.
 177  *  @hw: pointer to the HW structure
 178  **/
 179 static s32 e1000_init_nvm_params_82575(struct e1000_hw *hw)
 180 {
 181         struct e1000_nvm_info *nvm = &hw->nvm;
 182         u32 eecd = E1000_READ_REG(hw, E1000_EECD);
 183         u16 size;
 184
 185         DEBUGFUNC("e1000_init_nvm_params_82575");
 186
 187         nvm->opcode_bits        = 8;
 188         nvm->delay_usec         = 1;
 189         switch (nvm->override) {
 190         case e1000_nvm_override_spi_large:
 191                 nvm->page_size    = 32;
 192                 nvm->address_bits = 16;
 193                 break;
 194         case e1000_nvm_override_spi_small:
 195                 nvm->page_size    = 8;
 196                 nvm->address_bits = 8;
 197                 break;
 198         default:
 199                 nvm->page_size    = eecd & E1000_EECD_ADDR_BITS ? 32 : 8;
 200                 nvm->address_bits = eecd & E1000_EECD_ADDR_BITS ? 16 : 8;
 201                 break;
 202         }
 203
 204         nvm->type              = e1000_nvm_eeprom_spi;
 205
 206         size = (u16)((eecd & E1000_EECD_SIZE_EX_MASK) >>
 207                           E1000_EECD_SIZE_EX_SHIFT);
 208
 209         /*
 210          * Added to a constant, "size" becomes the left-shift value
 211          * for setting word_size.
 212          */
 213         size += NVM_WORD_SIZE_BASE_SHIFT;
 214
 215         /* EEPROM access above 16k is unsupported */
 216         if (size > 14)
 217                 size = 14;
 218         nvm->word_size = 1 << size;
 219
 220         /* Function Pointers */
 221         nvm->ops.acquire       = e1000_acquire_nvm_82575;
 222         nvm->ops.read          = e1000_read_nvm_eerd;
 223         nvm->ops.release       = e1000_release_nvm_82575;
 224         nvm->ops.update        = e1000_update_nvm_checksum_generic;
 225         nvm->ops.valid_led_default = e1000_valid_led_default_82575;
 226         nvm->ops.validate      = e1000_validate_nvm_checksum_generic;
 227         nvm->ops.write         = e1000_write_nvm_spi;
 228
 229         return E1000_SUCCESS;
 230 }
 231
 232 /**
 233  *  e1000_init_mac_params_82575 - Init MAC func ptrs.
 234  *  @hw: pointer to the HW structure
 235  **/
 236 static s32 e1000_init_mac_params_82575(struct e1000_hw *hw)
 237 {
 238         struct e1000_mac_info *mac = &hw->mac;
 239         struct e1000_dev_spec_82575 *dev_spec = &hw->dev_spec._82575;
 240         u32 ctrl_ext = 0;
 241
 242         DEBUGFUNC("e1000_init_mac_params_82575");
 243
 244         /* Set media type */
 245         /*
 246          * The 82575 uses bits 22:23 for link mode. The mode can be changed
 247          * based on the EEPROM. We cannot rely upon device ID. There
 248          * is no distinguishable difference between fiber and internal
 249          * SerDes mode on the 82575. There can be an external PHY attached
 250          * on the SGMII interface. For this, we'll set sgmii_active to TRUE.
 251          */
 252         hw->phy.media_type = e1000_media_type_copper;
 253         dev_spec->sgmii_active = FALSE;
 254
 255         ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
 256         switch (ctrl_ext & E1000_CTRL_EXT_LINK_MODE_MASK) {
 257         case E1000_CTRL_EXT_LINK_MODE_SGMII:
 258                 dev_spec->sgmii_active = TRUE;
 259                 ctrl_ext |= E1000_CTRL_I2C_ENA;
 260                 break;
 261         case E1000_CTRL_EXT_LINK_MODE_1000BASE_KX:
 262         case E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES:
 263                 hw->phy.media_type = e1000_media_type_internal_serdes;
 264                 ctrl_ext |= E1000_CTRL_I2C_ENA;
 265                 break;
 266         default:
 267                 ctrl_ext &= ~E1000_CTRL_I2C_ENA;
 268                 break;
 269         }
 270
 271         E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
 272
 273         /*
 274          * if using i2c make certain the MDICNFG register is cleared to prevent
 275          * communications from being misrouted to the mdic registers
 276          */
 277         if ((ctrl_ext & E1000_CTRL_I2C_ENA) && (hw->mac.type == e1000_82580))
 278                 E1000_WRITE_REG(hw, E1000_MDICNFG, 0);
 279
 280         /* Set mta register count */
 281         mac->mta_reg_count = 128;
 282         /* Set uta register count */
 283         mac->uta_reg_count = (hw->mac.type == e1000_82575) ? 0 : 128;
 284         /* Set rar entry count */
 285         mac->rar_entry_count = E1000_RAR_ENTRIES_82575;
 286         if (mac->type == e1000_82576)
 287                 mac->rar_entry_count = E1000_RAR_ENTRIES_82576;
 288         if (mac->type == e1000_82580)
 289                 mac->rar_entry_count = E1000_RAR_ENTRIES_82580;
 290         /* Set if part includes ASF firmware */
 291         mac->asf_firmware_present = TRUE;
 292         /* FWSM register */
 293         mac->has_fwsm = TRUE;
 294         /* ARC supported; valid only if manageability features are enabled. */
 295         mac->arc_subsystem_valid =
 296                 (E1000_READ_REG(hw, E1000_FWSM) & E1000_FWSM_MODE_MASK)
 297                         ? TRUE : FALSE;
 298
 299         /* Function pointers */
 300
 301         /* bus type/speed/width */
 302         mac->ops.get_bus_info = e1000_get_bus_info_pcie_generic;
 303         /* reset */
 304         if (mac->type >= e1000_82580)
 305                 mac->ops.reset_hw = e1000_reset_hw_82580;
 306         else
 307         mac->ops.reset_hw = e1000_reset_hw_82575;
 308         /* hw initialization */
 309         mac->ops.init_hw = e1000_init_hw_82575;
 310         /* link setup */
 311         mac->ops.setup_link = e1000_setup_link_generic;
 312         /* physical interface link setup */
 313         mac->ops.setup_physical_interface =
 314                 (hw->phy.media_type == e1000_media_type_copper)
 315                         ? e1000_setup_copper_link_82575
 316                         : e1000_setup_serdes_link_82575;
 317         /* physical interface shutdown */
 318         mac->ops.shutdown_serdes = e1000_shutdown_serdes_link_82575;
 319         /* physical interface power up */
 320         mac->ops.power_up_serdes = e1000_power_up_serdes_link_82575;
 321         /* check for link */
 322         mac->ops.check_for_link = e1000_check_for_link_82575;
 323         /* receive address register setting */
 324         mac->ops.rar_set = e1000_rar_set_generic;
 325         /* read mac address */
 326         mac->ops.read_mac_addr = e1000_read_mac_addr_82575;
 327         /* configure collision distance */
 328         mac->ops.config_collision_dist = e1000_config_collision_dist_82575;
 329         /* multicast address update */
 330         mac->ops.update_mc_addr_list = e1000_update_mc_addr_list_generic;
 331         /* writing VFTA */
 332         mac->ops.write_vfta = e1000_write_vfta_generic;
 333         /* clearing VFTA */
 334         mac->ops.clear_vfta = e1000_clear_vfta_generic;
 335         /* ID LED init */
 336         mac->ops.id_led_init = e1000_id_led_init_generic;
 337         /* blink LED */
 338         mac->ops.blink_led = e1000_blink_led_generic;
 339         /* setup LED */
 340         mac->ops.setup_led = e1000_setup_led_generic;
 341         /* cleanup LED */
 342         mac->ops.cleanup_led = e1000_cleanup_led_generic;
 343         /* turn on/off LED */
 344         mac->ops.led_on = e1000_led_on_generic;
 345         mac->ops.led_off = e1000_led_off_generic;
 346         /* clear hardware counters */
 347         mac->ops.clear_hw_cntrs = e1000_clear_hw_cntrs_82575;
 348         /* link info */
 349         mac->ops.get_link_up_info = e1000_get_link_up_info_82575;
 350
 351         /* set lan id for port to determine which phy lock to use */
 352         hw->mac.ops.set_lan_id(hw);
 353
 354         return E1000_SUCCESS;
 355 }
 356
 357 /**
 358  *  e1000_init_function_pointers_82575 - Init func ptrs.
 359  *  @hw: pointer to the HW structure
 360  *
 361  *  Called to initialize all function pointers and parameters.
 362  **/
 363 void e1000_init_function_pointers_82575(struct e1000_hw *hw)
 364 {
 365         DEBUGFUNC("e1000_init_function_pointers_82575");
 366
 367         hw->mac.ops.init_params = e1000_init_mac_params_82575;
 368         hw->nvm.ops.init_params = e1000_init_nvm_params_82575;
 369         hw->phy.ops.init_params = e1000_init_phy_params_82575;
 370 }
 371
 372 /**
 373  *  e1000_acquire_phy_82575 - Acquire rights to access PHY
 374  *  @hw: pointer to the HW structure
 375  *
 376  *  Acquire access rights to the correct PHY.
 377  **/
 378 static s32 e1000_acquire_phy_82575(struct e1000_hw *hw)
 379 {
 380         u16 mask = E1000_SWFW_PHY0_SM;
 381
 382         DEBUGFUNC("e1000_acquire_phy_82575");
 383
 384         if (hw->bus.func == E1000_FUNC_1)
 385                 mask = E1000_SWFW_PHY1_SM;
 386         else if (hw->bus.func == E1000_FUNC_2)
 387                 mask = E1000_SWFW_PHY2_SM;
 388         else if (hw->bus.func == E1000_FUNC_3)
 389                 mask = E1000_SWFW_PHY3_SM;
 390
 391         return e1000_acquire_swfw_sync_82575(hw, mask);
 392 }
 393
 394 /**
 395  *  e1000_release_phy_82575 - Release rights to access PHY
 396  *  @hw: pointer to the HW structure
 397  *
 398  *  A wrapper to release access rights to the correct PHY.
 399  **/
 400 static void e1000_release_phy_82575(struct e1000_hw *hw)
 401 {
 402         u16 mask = E1000_SWFW_PHY0_SM;
 403
 404         DEBUGFUNC("e1000_release_phy_82575");
 405
 406         if (hw->bus.func == E1000_FUNC_1)
 407                 mask = E1000_SWFW_PHY1_SM;
 408         else if (hw->bus.func == E1000_FUNC_2)
 409                 mask = E1000_SWFW_PHY2_SM;
 410         else if (hw->bus.func == E1000_FUNC_3)
 411                 mask = E1000_SWFW_PHY3_SM;
 412
 413         e1000_release_swfw_sync_82575(hw, mask);
 414 }
 415
 416 /**
 417  *  e1000_read_phy_reg_sgmii_82575 - Read PHY register using sgmii
 418  *  @hw: pointer to the HW structure
 419  *  @offset: register offset to be read
 420  *  @data: pointer to the read data
 421  *
 422  *  Reads the PHY register at offset using the serial gigabit media independent
 423  *  interface and stores the retrieved information in data.
 424  **/
 425 static s32 e1000_read_phy_reg_sgmii_82575(struct e1000_hw *hw, u32 offset,
 426                                           u16 *data)
 427 {
 428         s32 ret_val = -E1000_ERR_PARAM;
 429
 430         DEBUGFUNC("e1000_read_phy_reg_sgmii_82575");
 431
 432         if (offset > E1000_MAX_SGMII_PHY_REG_ADDR) {
 433                 DEBUGOUT1("PHY Address %u is out of range\n", offset);
 434                 goto out;
 435         }
 436
 437         ret_val = hw->phy.ops.acquire(hw);
 438         if (ret_val)
 439                 goto out;
 440
 441         ret_val = e1000_read_phy_reg_i2c(hw, offset, data);
 442
 443         hw->phy.ops.release(hw);
 444
 445 out:
 446         return ret_val;
 447 }
 448
 449 /**
 450  *  e1000_write_phy_reg_sgmii_82575 - Write PHY register using sgmii
 451  *  @hw: pointer to the HW structure
 452  *  @offset: register offset to write to
 453  *  @data: data to write at register offset
 454  *
 455  *  Writes the data to PHY register at the offset using the serial gigabit
 456  *  media independent interface.
 457  **/
 458 static s32 e1000_write_phy_reg_sgmii_82575(struct e1000_hw *hw, u32 offset,
 459                                            u16 data)
 460 {
 461         s32 ret_val = -E1000_ERR_PARAM;
 462
 463         DEBUGFUNC("e1000_write_phy_reg_sgmii_82575");
 464
 465         if (offset > E1000_MAX_SGMII_PHY_REG_ADDR) {
 466                 DEBUGOUT1("PHY Address %d is out of range\n", offset);
 467                 goto out;
 468         }
 469
 470         ret_val = hw->phy.ops.acquire(hw);
 471         if (ret_val)
 472                 goto out;
 473
 474         ret_val = e1000_write_phy_reg_i2c(hw, offset, data);
 475
 476         hw->phy.ops.release(hw);
 477
 478 out:
 479         return ret_val;
 480 }
 481
 482 /**
 483  *  e1000_get_phy_id_82575 - Retrieve PHY addr and id
 484  *  @hw: pointer to the HW structure
 485  *
 486  *  Retrieves the PHY address and ID for both PHY's which do and do not use
 487  *  sgmi interface.
 488  **/
 489 static s32 e1000_get_phy_id_82575(struct e1000_hw *hw)
 490 {
 491         struct e1000_phy_info *phy = &hw->phy;
 492         s32  ret_val = E1000_SUCCESS;
 493         u16 phy_id;
 494         u32 ctrl_ext;
 495
 496         DEBUGFUNC("e1000_get_phy_id_82575");
 497
 498         /*
 499          * For SGMII PHYs, we try the list of possible addresses until
 500          * we find one that works.  For non-SGMII PHYs
 501          * (e.g. integrated copper PHYs), an address of 1 should
 502          * work.  The result of this function should mean phy->phy_addr
 503          * and phy->id are set correctly.
 504          */
 505         if (!e1000_sgmii_active_82575(hw)) {
 506                 phy->addr = 1;
 507                 ret_val = e1000_get_phy_id(hw);
 508                 goto out;
 509         }
 510
 511         /* Power on sgmii phy if it is disabled */
 512         ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
 513         E1000_WRITE_REG(hw, E1000_CTRL_EXT,
 514                         ctrl_ext & ~E1000_CTRL_EXT_SDP3_DATA);
 515         E1000_WRITE_FLUSH(hw);
 516         msec_delay(300);
 517
 518         /*
 519          * The address field in the I2CCMD register is 3 bits and 0 is invalid.
 520          * Therefore, we need to test 1-7
 521          */
 522         for (phy->addr = 1; phy->addr < 8; phy->addr++) {
 523                 ret_val = e1000_read_phy_reg_sgmii_82575(hw, PHY_ID1, &phy_id);
 524                 if (ret_val == E1000_SUCCESS) {
 525                         DEBUGOUT2("Vendor ID 0x%08X read at address %u\n",
 526                                   phy_id,
 527                                   phy->addr);
 528                         /*
 529                          * At the time of this writing, The M88 part is
 530                          * the only supported SGMII PHY product.
 531                          */
 532                         if (phy_id == M88_VENDOR)
 533                                 break;
 534                 } else {
 535                         DEBUGOUT1("PHY address %u was unreadable\n",
 536                                   phy->addr);
 537                 }
 538         }
 539
 540         /* A valid PHY type couldn't be found. */
 541         if (phy->addr == 8) {
 542                 phy->addr = 0;
 543                 ret_val = -E1000_ERR_PHY;
 544         } else {
 545                 ret_val = e1000_get_phy_id(hw);
 546         }
 547
 548         /* restore previous sfp cage power state */
 549         E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
 550
 551 out:
 552         return ret_val;
 553 }
 554
 555 /**
 556  *  e1000_phy_hw_reset_sgmii_82575 - Performs a PHY reset
 557  *  @hw: pointer to the HW structure
 558  *
 559  *  Resets the PHY using the serial gigabit media independent interface.
 560  **/
 561 static s32 e1000_phy_hw_reset_sgmii_82575(struct e1000_hw *hw)
 562 {
 563         s32 ret_val = E1000_SUCCESS;
 564
 565         DEBUGFUNC("e1000_phy_hw_reset_sgmii_82575");
 566
 567         /*
 568          * This isn't a TRUE "hard" reset, but is the only reset
 569          * available to us at this time.
 570          */
 571
 572         DEBUGOUT("Soft resetting SGMII attached PHY...\n");
 573
 574         if (!(hw->phy.ops.write_reg))
 575                 goto out;
 576
 577         /*
 578          * SFP documentation requires the following to configure the SPF module
 579          * to work on SGMII.  No further documentation is given.
 580          */
 581         ret_val = hw->phy.ops.write_reg(hw, 0x1B, 0x8084);
 582         if (ret_val)
 583                 goto out;
 584
 585         ret_val = hw->phy.ops.commit(hw);
 586
 587 out:
 588         return ret_val;
 589 }
 590
 591 /**
 592  *  e1000_set_d0_lplu_state_82575 - Set Low Power Linkup D0 state
 593  *  @hw: pointer to the HW structure
 594  *  @active: TRUE to enable LPLU, FALSE to disable
 595  *
 596  *  Sets the LPLU D0 state according to the active flag.  When
 597  *  activating LPLU this function also disables smart speed
 598  *  and vice versa.  LPLU will not be activated unless the
 599  *  device autonegotiation advertisement meets standards of
 600  *  either 10 or 10/100 or 10/100/1000 at all duplexes.
 601  *  This is a function pointer entry point only called by
 602  *  PHY setup routines.
 603  **/
 604 static s32 e1000_set_d0_lplu_state_82575(struct e1000_hw *hw, bool active)
 605 {
 606         struct e1000_phy_info *phy = &hw->phy;
 607         s32 ret_val = E1000_SUCCESS;
 608         u16 data;
 609
 610         DEBUGFUNC("e1000_set_d0_lplu_state_82575");
 611
 612         if (!(hw->phy.ops.read_reg))
 613                 goto out;
 614
 615         ret_val = phy->ops.read_reg(hw, IGP02E1000_PHY_POWER_MGMT, &data);
 616         if (ret_val)
 617                 goto out;
 618
 619         if (active) {
 620                 data |= IGP02E1000_PM_D0_LPLU;
 621                 ret_val = phy->ops.write_reg(hw, IGP02E1000_PHY_POWER_MGMT,
 622                                              data);
 623                 if (ret_val)
 624                         goto out;
 625
 626                 /* When LPLU is enabled, we should disable SmartSpeed */
 627                 ret_val = phy->ops.read_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
 628                                             &data);
 629                 data &= ~IGP01E1000_PSCFR_SMART_SPEED;
 630                 ret_val = phy->ops.write_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
 631                                              data);
 632                 if (ret_val)
 633                         goto out;
 634         } else {
 635                 data &= ~IGP02E1000_PM_D0_LPLU;
 636                 ret_val = phy->ops.write_reg(hw, IGP02E1000_PHY_POWER_MGMT,
 637                                              data);
 638                 /*
 639                  * LPLU and SmartSpeed are mutually exclusive.  LPLU is used
 640                  * during Dx states where the power conservation is most
 641                  * important.  During driver activity we should enable
 642                  * SmartSpeed, so performance is maintained.
 643                  */
 644                 if (phy->smart_speed == e1000_smart_speed_on) {
 645                         ret_val = phy->ops.read_reg(hw,
 646                                                     IGP01E1000_PHY_PORT_CONFIG,
 647                                                     &data);
 648                         if (ret_val)
 649                                 goto out;
 650
 651                         data |= IGP01E1000_PSCFR_SMART_SPEED;
 652                         ret_val = phy->ops.write_reg(hw,
 653                                                      IGP01E1000_PHY_PORT_CONFIG,
 654                                                      data);
 655                         if (ret_val)
 656                                 goto out;
 657                 } else if (phy->smart_speed == e1000_smart_speed_off) {
 658                         ret_val = phy->ops.read_reg(hw,
 659                                                     IGP01E1000_PHY_PORT_CONFIG,
 660                                                     &data);
 661                         if (ret_val)
 662                                 goto out;
 663
 664                         data &= ~IGP01E1000_PSCFR_SMART_SPEED;
 665                         ret_val = phy->ops.write_reg(hw,
 666                                                      IGP01E1000_PHY_PORT_CONFIG,
 667                                                      data);
 668                         if (ret_val)
 669                                 goto out;
 670                 }
 671         }
 672
 673 out:
 674         return ret_val;
 675 }
 676
 677 /**
 678  *  e1000_acquire_nvm_82575 - Request for access to EEPROM
 679  *  @hw: pointer to the HW structure
 680  *
 681  *  Acquire the necessary semaphores for exclusive access to the EEPROM.
 682  *  Set the EEPROM access request bit and wait for EEPROM access grant bit.
 683  *  Return successful if access grant bit set, else clear the request for
 684  *  EEPROM access and return -E1000_ERR_NVM (-1).
 685  **/
 686 static s32 e1000_acquire_nvm_82575(struct e1000_hw *hw)
 687 {
 688         s32 ret_val;
 689
 690         DEBUGFUNC("e1000_acquire_nvm_82575");
 691
 692         ret_val = e1000_acquire_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
 693         if (ret_val)
 694                 goto out;
 695
 696         ret_val = e1000_acquire_nvm_generic(hw);
 697
 698         if (ret_val)
 699                 e1000_release_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
 700
 701 out:
 702         return ret_val;
 703 }
 704
 705 /**
 706  *  e1000_release_nvm_82575 - Release exclusive access to EEPROM
 707  *  @hw: pointer to the HW structure
 708  *
 709  *  Stop any current commands to the EEPROM and clear the EEPROM request bit,
 710  *  then release the semaphores acquired.
 711  **/
 712 static void e1000_release_nvm_82575(struct e1000_hw *hw)
 713 {
 714         DEBUGFUNC("e1000_release_nvm_82575");
 715
 716         e1000_release_nvm_generic(hw);
 717         e1000_release_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
 718 }
 719
 720 /**
 721  *  e1000_acquire_swfw_sync_82575 - Acquire SW/FW semaphore
 722  *  @hw: pointer to the HW structure
 723  *  @mask: specifies which semaphore to acquire
 724  *
 725  *  Acquire the SW/FW semaphore to access the PHY or NVM.  The mask
 726  *  will also specify which port we're acquiring the lock for.
 727  **/
 728 static s32 e1000_acquire_swfw_sync_82575(struct e1000_hw *hw, u16 mask)
 729 {
 730         u32 swfw_sync;
 731         u32 swmask = mask;
 732         u32 fwmask = mask << 16;
 733         s32 ret_val = E1000_SUCCESS;
 734         s32 i = 0, timeout = 200; /* FIXME: find real value to use here */
 735
 736         DEBUGFUNC("e1000_acquire_swfw_sync_82575");
 737
 738         while (i < timeout) {
 739                 if (e1000_get_hw_semaphore_generic(hw)) {
 740                         ret_val = -E1000_ERR_SWFW_SYNC;
 741                         goto out;
 742                 }
 743
 744                 swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
 745                 if (!(swfw_sync & (fwmask | swmask)))
 746                         break;
 747
 748                 /*
 749                  * Firmware currently using resource (fwmask)
 750                  * or other software thread using resource (swmask)
 751                  */
 752                 e1000_put_hw_semaphore_generic(hw);
 753                 msec_delay_irq(5);
 754                 i++;
 755         }
 756
 757         if (i == timeout) {
 758                 DEBUGOUT("Driver can't access resource, SW_FW_SYNC timeout.\n");
 759                 ret_val = -E1000_ERR_SWFW_SYNC;
 760                 goto out;
 761         }
 762
 763         swfw_sync |= swmask;
 764         E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
 765
 766         e1000_put_hw_semaphore_generic(hw);
 767
 768 out:
 769         return ret_val;
 770 }
 771
 772 /**
 773  *  e1000_release_swfw_sync_82575 - Release SW/FW semaphore
 774  *  @hw: pointer to the HW structure
 775  *  @mask: specifies which semaphore to acquire
 776  *
 777  *  Release the SW/FW semaphore used to access the PHY or NVM.  The mask
 778  *  will also specify which port we're releasing the lock for.
 779  **/
 780 static void e1000_release_swfw_sync_82575(struct e1000_hw *hw, u16 mask)
 781 {
 782         u32 swfw_sync;
 783
 784         DEBUGFUNC("e1000_release_swfw_sync_82575");
 785
 786         while (e1000_get_hw_semaphore_generic(hw) != E1000_SUCCESS);
 787         /* Empty */
 788
 789         swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
 790         swfw_sync &= ~mask;
 791         E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
 792
 793         e1000_put_hw_semaphore_generic(hw);
 794 }
 795
 796 /**
 797  *  e1000_get_cfg_done_82575 - Read config done bit
 798  *  @hw: pointer to the HW structure
 799  *
 800  *  Read the management control register for the config done bit for
 801  *  completion status.  NOTE: silicon which is EEPROM-less will fail trying
 802  *  to read the config done bit, so an error is *ONLY* logged and returns
 803  *  E1000_SUCCESS.  If we were to return with error, EEPROM-less silicon
 804  *  would not be able to be reset or change link.
 805  **/
 806 static s32 e1000_get_cfg_done_82575(struct e1000_hw *hw)
 807 {
 808         s32 timeout = PHY_CFG_TIMEOUT;
 809         s32 ret_val = E1000_SUCCESS;
 810         u32 mask = E1000_NVM_CFG_DONE_PORT_0;
 811
 812         DEBUGFUNC("e1000_get_cfg_done_82575");
 813
 814         if (hw->bus.func == E1000_FUNC_1)
 815                 mask = E1000_NVM_CFG_DONE_PORT_1;
 816         else if (hw->bus.func == E1000_FUNC_2)
 817                 mask = E1000_NVM_CFG_DONE_PORT_2;
 818         else if (hw->bus.func == E1000_FUNC_3)
 819                 mask = E1000_NVM_CFG_DONE_PORT_3;
 820         while (timeout) {
 821                 if (E1000_READ_REG(hw, E1000_EEMNGCTL) & mask)
 822                         break;
 823                 msec_delay(1);
 824                 timeout--;
 825         }
 826         if (!timeout)
 827                 DEBUGOUT("MNG configuration cycle has not completed.\n");
 828
 829         /* If EEPROM is not marked present, init the PHY manually */
 830         if (((E1000_READ_REG(hw, E1000_EECD) & E1000_EECD_PRES) == 0) &&
 831             (hw->phy.type == e1000_phy_igp_3))
 832                 e1000_phy_init_script_igp3(hw);
 833
 834         return ret_val;
 835 }
 836
 837 /**
 838  *  e1000_get_link_up_info_82575 - Get link speed/duplex info
 839  *  @hw: pointer to the HW structure
 840  *  @speed: stores the current speed
 841  *  @duplex: stores the current duplex
 842  *
 843  *  This is a wrapper function, if using the serial gigabit media independent
 844  *  interface, use PCS to retrieve the link speed and duplex information.
 845  *  Otherwise, use the generic function to get the link speed and duplex info.
 846  **/
 847 static s32 e1000_get_link_up_info_82575(struct e1000_hw *hw, u16 *speed,
 848                                         u16 *duplex)
 849 {
 850         s32 ret_val;
 851
 852         DEBUGFUNC("e1000_get_link_up_info_82575");
 853
 854         if (hw->phy.media_type != e1000_media_type_copper)
 855                 ret_val = e1000_get_pcs_speed_and_duplex_82575(hw, speed,
 856                                                                duplex);
 857         else
 858                 ret_val = e1000_get_speed_and_duplex_copper_generic(hw, speed,
 859                                                                     duplex);
 860
 861         return ret_val;
 862 }
 863
 864 /**
 865  *  e1000_check_for_link_82575 - Check for link
 866  *  @hw: pointer to the HW structure
 867  *
 868  *  If sgmii is enabled, then use the pcs register to determine link, otherwise
 869  *  use the generic interface for determining link.
 870  **/
 871 static s32 e1000_check_for_link_82575(struct e1000_hw *hw)
 872 {
 873         s32 ret_val;
 874         u16 speed, duplex;
 875
 876         DEBUGFUNC("e1000_check_for_link_82575");
 877
 878         if (hw->phy.media_type != e1000_media_type_copper) {
 879                 ret_val = e1000_get_pcs_speed_and_duplex_82575(hw, &speed,
 880                                                                &duplex);
 881                 /*
 882                  * Use this flag to determine if link needs to be checked or
 883                  * not.  If we have link clear the flag so that we do not
 884                  * continue to check for link.
 885                  */
 886                 hw->mac.get_link_status = !hw->mac.serdes_has_link;
 887         } else {
 888                 ret_val = e1000_check_for_copper_link_generic(hw);
 889         }
 890
 891         return ret_val;
 892 }
 893
 894 /**
 895  *  e1000_power_up_serdes_link_82575 - Power up the serdes link after shutdown
 896  *  @hw: pointer to the HW structure
 897  **/
 898 static void e1000_power_up_serdes_link_82575(struct e1000_hw *hw)
 899 {
 900         u32 reg;
 901
 902         DEBUGFUNC("e1000_power_up_serdes_link_82575");
 903
 904         if ((hw->phy.media_type != e1000_media_type_internal_serdes) &&
 905             !e1000_sgmii_active_82575(hw))
 906                 return;
 907
 908         /* Enable PCS to turn on link */
 909         reg = E1000_READ_REG(hw, E1000_PCS_CFG0);
 910         reg |= E1000_PCS_CFG_PCS_EN;
 911         E1000_WRITE_REG(hw, E1000_PCS_CFG0, reg);
 912
 913         /* Power up the laser */
 914         reg = E1000_READ_REG(hw, E1000_CTRL_EXT);
 915         reg &= ~E1000_CTRL_EXT_SDP3_DATA;
 916         E1000_WRITE_REG(hw, E1000_CTRL_EXT, reg);
 917
 918         /* flush the write to verify completion */
 919         E1000_WRITE_FLUSH(hw);
 920         msec_delay(1);
 921 }
 922
 923 /**
 924  *  e1000_get_pcs_speed_and_duplex_82575 - Retrieve current speed/duplex
 925  *  @hw: pointer to the HW structure
 926  *  @speed: stores the current speed
 927  *  @duplex: stores the current duplex
 928  *
 929  *  Using the physical coding sub-layer (PCS), retrieve the current speed and
 930  *  duplex, then store the values in the pointers provided.
 931  **/
 932 static s32 e1000_get_pcs_speed_and_duplex_82575(struct e1000_hw *hw,
 933                                                 u16 *speed, u16 *duplex)
 934 {
 935         struct e1000_mac_info *mac = &hw->mac;
 936         u32 pcs;
 937
 938         DEBUGFUNC("e1000_get_pcs_speed_and_duplex_82575");
 939
 940         /* Set up defaults for the return values of this function */
 941         mac->serdes_has_link = FALSE;
 942         *speed = 0;
 943         *duplex = 0;
 944
 945         /*
 946          * Read the PCS Status register for link state. For non-copper mode,
 947          * the status register is not accurate. The PCS status register is
 948          * used instead.
 949          */
 950         pcs = E1000_READ_REG(hw, E1000_PCS_LSTAT);
 951
 952         /*
 953          * The link up bit determines when link is up on autoneg. The sync ok
 954          * gets set once both sides sync up and agree upon link. Stable link
 955          * can be determined by checking for both link up and link sync ok
 956          */
 957         if ((pcs & E1000_PCS_LSTS_LINK_OK) && (pcs & E1000_PCS_LSTS_SYNK_OK)) {
 958                 mac->serdes_has_link = TRUE;
 959
 960                 /* Detect and store PCS speed */
 961                 if (pcs & E1000_PCS_LSTS_SPEED_1000) {
 962                         *speed = SPEED_1000;
 963                 } else if (pcs & E1000_PCS_LSTS_SPEED_100) {
 964                         *speed = SPEED_100;
 965                 } else {
 966                         *speed = SPEED_10;
 967                 }
 968
 969                 /* Detect and store PCS duplex */
 970                 if (pcs & E1000_PCS_LSTS_DUPLEX_FULL) {
 971                         *duplex = FULL_DUPLEX;
 972                 } else {
 973                         *duplex = HALF_DUPLEX;
 974                 }
 975         }
 976
 977         return E1000_SUCCESS;
 978 }
 979
 980 /**
 981  *  e1000_shutdown_serdes_link_82575 - Remove link during power down
 982  *  @hw: pointer to the HW structure
 983  *
 984  *  In the case of serdes shut down sfp and PCS on driver unload
 985  *  when management pass thru is not enabled.
 986  **/
 987 void e1000_shutdown_serdes_link_82575(struct e1000_hw *hw)
 988 {
 989         u32 reg;
 990
 991         DEBUGFUNC("e1000_shutdown_serdes_link_82575");
 992
 993         if ((hw->phy.media_type != e1000_media_type_internal_serdes) &&
 994             !e1000_sgmii_active_82575(hw))
 995                 return;
 996
 997         if (!e1000_enable_mng_pass_thru(hw)) {
 998                 /* Disable PCS to turn off link */
 999                 reg = E1000_READ_REG(hw, E1000_PCS_CFG0);
1000                 reg &= ~E1000_PCS_CFG_PCS_EN;
1001                 E1000_WRITE_REG(hw, E1000_PCS_CFG0, reg);
1002
1003                 /* shutdown the laser */
1004                 reg = E1000_READ_REG(hw, E1000_CTRL_EXT);
1005                 reg |= E1000_CTRL_EXT_SDP3_DATA;
1006                 E1000_WRITE_REG(hw, E1000_CTRL_EXT, reg);
1007
1008                 /* flush the write to verify completion */
1009                 E1000_WRITE_FLUSH(hw);
1010                 msec_delay(1);
1011         }
1012
1013         return;
1014 }
1015
1016 /**
1017  *  e1000_reset_hw_82575 - Reset hardware
1018  *  @hw: pointer to the HW structure
1019  *
1020  *  This resets the hardware into a known state.
1021  **/
1022 static s32 e1000_reset_hw_82575(struct e1000_hw *hw)
1023 {
1024         u32 ctrl, icr;
1025         s32 ret_val;
1026
1027         DEBUGFUNC("e1000_reset_hw_82575");
1028
1029         /*
1030          * Prevent the PCI-E bus from sticking if there is no TLP connection
1031          * on the last TLP read/write transaction when MAC is reset.
1032          */
1033         ret_val = e1000_disable_pcie_master_generic(hw);
1034         if (ret_val) {
1035                 DEBUGOUT("PCI-E Master disable polling has failed.\n");
1036         }
1037
1038         /* set the completion timeout for interface */
1039         ret_val = e1000_set_pcie_completion_timeout(hw);
1040         if (ret_val) {
1041                 DEBUGOUT("PCI-E Set completion timeout has failed.\n");
1042         }
1043
1044         DEBUGOUT("Masking off all interrupts\n");
1045         E1000_WRITE_REG(hw, E1000_IMC, 0xffffffff);
1046
1047         E1000_WRITE_REG(hw, E1000_RCTL, 0);
1048         E1000_WRITE_REG(hw, E1000_TCTL, E1000_TCTL_PSP);
1049         E1000_WRITE_FLUSH(hw);
1050
1051         msec_delay(10);
1052
1053         ctrl = E1000_READ_REG(hw, E1000_CTRL);
1054
1055         DEBUGOUT("Issuing a global reset to MAC\n");
1056         E1000_WRITE_REG(hw, E1000_CTRL, ctrl | E1000_CTRL_RST);
1057
1058         ret_val = e1000_get_auto_rd_done_generic(hw);
1059         if (ret_val) {
1060                 /*
1061                  * When auto config read does not complete, do not
1062                  * return with an error. This can happen in situations
1063                  * where there is no eeprom and prevents getting link.
1064                  */
1065                 DEBUGOUT("Auto Read Done did not complete\n");
1066         }
1067
1068         /* If EEPROM is not present, run manual init scripts */
1069         if ((E1000_READ_REG(hw, E1000_EECD) & E1000_EECD_PRES) == 0)
1070                 e1000_reset_init_script_82575(hw);
1071
1072         /* Clear any pending interrupt events. */
1073         E1000_WRITE_REG(hw, E1000_IMC, 0xffffffff);
1074         icr = E1000_READ_REG(hw, E1000_ICR);
1075
1076         /* Install any alternate MAC address into RAR0 */
1077         ret_val = e1000_check_alt_mac_addr_generic(hw);
1078
1079         return ret_val;
1080 }
1081
1082 /**
1083  *  e1000_init_hw_82575 - Initialize hardware
1084  *  @hw: pointer to the HW structure
1085  *
1086  *  This inits the hardware readying it for operation.
1087  **/
1088 static s32 e1000_init_hw_82575(struct e1000_hw *hw)
1089 {
1090         struct e1000_mac_info *mac = &hw->mac;
1091         s32 ret_val;
1092         u16 i, rar_count = mac->rar_entry_count;
1093
1094         DEBUGFUNC("e1000_init_hw_82575");
1095
1096         /* Initialize identification LED */
1097         ret_val = mac->ops.id_led_init(hw);
1098         if (ret_val) {
1099                 DEBUGOUT("Error initializing identification LED\n");
1100                 /* This is not fatal and we should not stop init due to this */
1101         }
1102
1103         /* Disabling VLAN filtering */
1104         DEBUGOUT("Initializing the IEEE VLAN\n");
1105         mac->ops.clear_vfta(hw);
1106
1107         /* Setup the receive address */
1108         e1000_init_rx_addrs_generic(hw, rar_count);
1109
1110         /* Zero out the Multicast HASH table */
1111         DEBUGOUT("Zeroing the MTA\n");
1112         for (i = 0; i < mac->mta_reg_count; i++)
1113                 E1000_WRITE_REG_ARRAY(hw, E1000_MTA, i, 0);
1114
1115         /* Zero out the Unicast HASH table */
1116         DEBUGOUT("Zeroing the UTA\n");
1117         for (i = 0; i < mac->uta_reg_count; i++)
1118                 E1000_WRITE_REG_ARRAY(hw, E1000_UTA, i, 0);
1119
1120         /* Setup link and flow control */
1121         ret_val = mac->ops.setup_link(hw);
1122
1123         /*
1124          * Clear all of the statistics registers (clear on read).  It is
1125          * important that we do this after we have tried to establish link
1126          * because the symbol error count will increment wildly if there
1127          * is no link.
1128          */
1129         e1000_clear_hw_cntrs_82575(hw);
1130
1131         return ret_val;
1132 }
1133
1134 /**
1135  *  e1000_setup_copper_link_82575 - Configure copper link settings
1136  *  @hw: pointer to the HW structure
1137  *
1138  *  Configures the link for auto-neg or forced speed and duplex.  Then we check
1139  *  for link, once link is established calls to configure collision distance
1140  *  and flow control are called.
1141  **/
1142 static s32 e1000_setup_copper_link_82575(struct e1000_hw *hw)
1143 {
1144         u32 ctrl;
1145         s32  ret_val;
1146
1147         DEBUGFUNC("e1000_setup_copper_link_82575");
1148
1149         ctrl = E1000_READ_REG(hw, E1000_CTRL);
1150         ctrl |= E1000_CTRL_SLU;
1151         ctrl &= ~(E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1152         E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1153
1154         ret_val = e1000_setup_serdes_link_82575(hw);
1155         if (ret_val)
1156                 goto out;
1157
1158         if (e1000_sgmii_active_82575(hw) && !hw->phy.reset_disable) {
1159                 /* allow time for SFP cage time to power up phy */
1160                 msec_delay(300);
1161
1162                 ret_val = hw->phy.ops.reset(hw);
1163                 if (ret_val) {
1164                         DEBUGOUT("Error resetting the PHY.\n");
1165                         goto out;
1166                 }
1167         }
1168         switch (hw->phy.type) {
1169         case e1000_phy_m88:
1170                 ret_val = e1000_copper_link_setup_m88(hw);
1171                 break;
1172         case e1000_phy_igp_3:
1173                 ret_val = e1000_copper_link_setup_igp(hw);
1174                 break;
1175         case e1000_phy_82580:
1176                 ret_val = e1000_copper_link_setup_82577(hw);
1177                 break;
1178         default:
1179                 ret_val = -E1000_ERR_PHY;
1180                 break;
1181         }
1182
1183         if (ret_val)
1184                 goto out;
1185
1186         ret_val = e1000_setup_copper_link_generic(hw);
1187 out:
1188         return ret_val;
1189 }
1190
1191 /**
1192  *  e1000_setup_serdes_link_82575 - Setup link for serdes
1193  *  @hw: pointer to the HW structure
1194  *
1195  *  Configure the physical coding sub-layer (PCS) link.  The PCS link is
1196  *  used on copper connections where the serialized gigabit media independent
1197  *  interface (sgmii), or serdes fiber is being used.  Configures the link
1198  *  for auto-negotiation or forces speed/duplex.
1199  **/
1200 static s32 e1000_setup_serdes_link_82575(struct e1000_hw *hw)
1201 {
1202         u32 ctrl_ext, ctrl_reg, reg;
1203         bool pcs_autoneg;
1204
1205         DEBUGFUNC("e1000_setup_serdes_link_82575");
1206
1207         if ((hw->phy.media_type != e1000_media_type_internal_serdes) &&
1208             !e1000_sgmii_active_82575(hw))
1209                 return E1000_SUCCESS;
1210
1211         /*
1212          * On the 82575, SerDes loopback mode persists until it is
1213          * explicitly turned off or a power cycle is performed.  A read to
1214          * the register does not indicate its status.  Therefore, we ensure
1215          * loopback mode is disabled during initialization.
1216          */
1217         E1000_WRITE_REG(hw, E1000_SCTL, E1000_SCTL_DISABLE_SERDES_LOOPBACK);
1218
1219         /* power on the sfp cage if present */
1220         ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
1221         ctrl_ext &= ~E1000_CTRL_EXT_SDP3_DATA;
1222         E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
1223
1224         ctrl_reg = E1000_READ_REG(hw, E1000_CTRL);
1225         ctrl_reg |= E1000_CTRL_SLU;
1226
1227         /* set both sw defined pins on 82575/82576*/
1228         if (hw->mac.type == e1000_82575 || hw->mac.type == e1000_82576)
1229                 ctrl_reg |= E1000_CTRL_SWDPIN0 | E1000_CTRL_SWDPIN1;
1230
1231         reg = E1000_READ_REG(hw, E1000_PCS_LCTL);
1232
1233         /* default pcs_autoneg to the same setting as mac autoneg */
1234         pcs_autoneg = hw->mac.autoneg;
1235
1236         switch (ctrl_ext & E1000_CTRL_EXT_LINK_MODE_MASK) {
1237         case E1000_CTRL_EXT_LINK_MODE_SGMII:
1238                 /* sgmii mode lets the phy handle forcing speed/duplex */
1239                 pcs_autoneg = TRUE;
1240                 /* autoneg time out should be disabled for SGMII mode */
1241                 reg &= ~(E1000_PCS_LCTL_AN_TIMEOUT);
1242                 break;
1243         case E1000_CTRL_EXT_LINK_MODE_1000BASE_KX:
1244                 /* disable PCS autoneg and support parallel detect only */
1245                 pcs_autoneg = FALSE;
1246         default:
1247                 /*
1248                  * non-SGMII modes only supports a speed of 1000/Full for the
1249                  * link so it is best to just force the MAC and let the pcs
1250                  * link either autoneg or be forced to 1000/Full
1251                  */
1252                 ctrl_reg |= E1000_CTRL_SPD_1000 | E1000_CTRL_FRCSPD |
1253                             E1000_CTRL_FD | E1000_CTRL_FRCDPX;
1254
1255                 /* set speed of 1000/Full if speed/duplex is forced */
1256                 reg |= E1000_PCS_LCTL_FSV_1000 | E1000_PCS_LCTL_FDV_FULL;
1257                 break;
1258         }
1259
1260         E1000_WRITE_REG(hw, E1000_CTRL, ctrl_reg);
1261
1262         /*
1263          * New SerDes mode allows for forcing speed or autonegotiating speed
1264          * at 1gb. Autoneg should be default set by most drivers. This is the
1265          * mode that will be compatible with older link partners and switches.
1266          * However, both are supported by the hardware and some drivers/tools.
1267          */
1268         reg &= ~(E1000_PCS_LCTL_AN_ENABLE | E1000_PCS_LCTL_FLV_LINK_UP |
1269                  E1000_PCS_LCTL_FSD | E1000_PCS_LCTL_FORCE_LINK);
1270
1271         /*
1272          * We force flow control to prevent the CTRL register values from being
1273          * overwritten by the autonegotiated flow control values
1274          */
1275         reg |= E1000_PCS_LCTL_FORCE_FCTRL;
1276
1277         if (pcs_autoneg) {
1278                 /* Set PCS register for autoneg */
1279                 reg |= E1000_PCS_LCTL_AN_ENABLE | /* Enable Autoneg */
1280                        E1000_PCS_LCTL_AN_RESTART; /* Restart autoneg */
1281                 DEBUGOUT1("Configuring Autoneg:PCS_LCTL=0x%08X\n", reg);
1282         } else {
1283                 /* Set PCS register for forced link */
1284                 reg |= E1000_PCS_LCTL_FSD;        /* Force Speed */
1285                 DEBUGOUT1("Configuring Forced Link:PCS_LCTL=0x%08X\n", reg);
1286         }
1287
1288         E1000_WRITE_REG(hw, E1000_PCS_LCTL, reg);
1289
1290         if (!e1000_sgmii_active_82575(hw))
1291                 e1000_force_mac_fc_generic(hw);
1292
1293         return E1000_SUCCESS;
1294 }
1295
1296 /**
1297  *  e1000_valid_led_default_82575 - Verify a valid default LED config
1298  *  @hw: pointer to the HW structure
1299  *  @data: pointer to the NVM (EEPROM)
1300  *
1301  *  Read the EEPROM for the current default LED configuration.  If the
1302  *  LED configuration is not valid, set to a valid LED configuration.
1303  **/
1304 static s32 e1000_valid_led_default_82575(struct e1000_hw *hw, u16 *data)
1305 {
1306         s32 ret_val;
1307
1308         DEBUGFUNC("e1000_valid_led_default_82575");
1309
1310         ret_val = hw->nvm.ops.read(hw, NVM_ID_LED_SETTINGS, 1, data);
1311         if (ret_val) {
1312                 DEBUGOUT("NVM Read Error\n");
1313                 goto out;
1314         }
1315
1316         if (*data == ID_LED_RESERVED_0000 || *data == ID_LED_RESERVED_FFFF) {
1317                 switch(hw->phy.media_type) {
1318                 case e1000_media_type_internal_serdes:
1319                         *data = ID_LED_DEFAULT_82575_SERDES;
1320                         break;
1321                 case e1000_media_type_copper:
1322                 default:
1323                         *data = ID_LED_DEFAULT;
1324                         break;
1325                 }
1326         }
1327 out:
1328         return ret_val;
1329 }
1330
1331 /**
1332  *  e1000_sgmii_active_82575 - Return sgmii state
1333  *  @hw: pointer to the HW structure
1334  *
1335  *  82575 silicon has a serialized gigabit media independent interface (sgmii)
1336  *  which can be enabled for use in the embedded applications.  Simply
1337  *  return the current state of the sgmii interface.
1338  **/
1339 static bool e1000_sgmii_active_82575(struct e1000_hw *hw)
1340 {
1341         struct e1000_dev_spec_82575 *dev_spec = &hw->dev_spec._82575;
1342         return dev_spec->sgmii_active;
1343 }
1344
1345 /**
1346  *  e1000_reset_init_script_82575 - Inits HW defaults after reset
1347  *  @hw: pointer to the HW structure
1348  *
1349  *  Inits recommended HW defaults after a reset when there is no EEPROM
1350  *  detected. This is only for the 82575.
1351  **/
1352 static s32 e1000_reset_init_script_82575(struct e1000_hw* hw)
1353 {
1354         DEBUGFUNC("e1000_reset_init_script_82575");
1355
1356         if (hw->mac.type == e1000_82575) {
1357                 DEBUGOUT("Running reset init script for 82575\n");
1358                 /* SerDes configuration via SERDESCTRL */
1359                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCTL, 0x00, 0x0C);
1360                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCTL, 0x01, 0x78);
1361                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCTL, 0x1B, 0x23);
1362                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCTL, 0x23, 0x15);
1363
1364                 /* CCM configuration via CCMCTL register */
1365                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_CCMCTL, 0x14, 0x00);
1366                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_CCMCTL, 0x10, 0x00);
1367
1368                 /* PCIe lanes configuration */
1369                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_GIOCTL, 0x00, 0xEC);
1370                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_GIOCTL, 0x61, 0xDF);
1371                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_GIOCTL, 0x34, 0x05);
1372                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_GIOCTL, 0x2F, 0x81);
1373
1374                 /* PCIe PLL Configuration */
1375                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCCTL, 0x02, 0x47);
1376                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCCTL, 0x14, 0x00);
1377                 e1000_write_8bit_ctrl_reg_generic(hw, E1000_SCCTL, 0x10, 0x00);
1378         }
1379
1380         return E1000_SUCCESS;
1381 }
1382
1383 /**
1384  *  e1000_read_mac_addr_82575 - Read device MAC address
1385  *  @hw: pointer to the HW structure
1386  **/
1387 static s32 e1000_read_mac_addr_82575(struct e1000_hw *hw)
1388 {
1389         s32 ret_val = E1000_SUCCESS;
1390
1391         DEBUGFUNC("e1000_read_mac_addr_82575");
1392
1393         /*
1394          * If there's an alternate MAC address place it in RAR0
1395          * so that it will override the Si installed default perm
1396          * address.
1397          */
1398         ret_val = e1000_check_alt_mac_addr_generic(hw);
1399         if (ret_val)
1400                 goto out;
1401
1402         ret_val = e1000_read_mac_addr_generic(hw);
1403
1404 out:
1405         return ret_val;
1406 }
1407
1408 /**
1409  *  e1000_config_collision_dist_82575 - Configure collision distance
1410  *  @hw: pointer to the HW structure
1411  *
1412  *  Configures the collision distance to the default value and is used
1413  *  during link setup.
1414  **/
1415 static void e1000_config_collision_dist_82575(struct e1000_hw *hw)
1416 {
1417         u32 tctl_ext;
1418
1419         DEBUGFUNC("e1000_config_collision_dist_82575");
1420
1421         tctl_ext = E1000_READ_REG(hw, E1000_TCTL_EXT);
1422
1423         tctl_ext &= ~E1000_TCTL_EXT_COLD;
1424         tctl_ext |= E1000_COLLISION_DISTANCE << E1000_TCTL_EXT_COLD_SHIFT;
1425
1426         E1000_WRITE_REG(hw, E1000_TCTL_EXT, tctl_ext);
1427         E1000_WRITE_FLUSH(hw);
1428 }
1429
1430 /**
1431  * e1000_power_down_phy_copper_82575 - Remove link during PHY power down
1432  * @hw: pointer to the HW structure
1433  *
1434  * In the case of a PHY power down to save power, or to turn off link during a
1435  * driver unload, or wake on lan is not enabled, remove the link.
1436  **/
1437 static void e1000_power_down_phy_copper_82575(struct e1000_hw *hw)
1438 {
1439         struct e1000_phy_info *phy = &hw->phy;
1440
1441         if (!(phy->ops.check_reset_block))
1442                 return;
1443
1444         /* If the management interface is not enabled, then power down */
1445         if (!(e1000_enable_mng_pass_thru(hw) || phy->ops.check_reset_block(hw)))
1446                 e1000_power_down_phy_copper(hw);
1447
1448         return;
1449 }
1450
1451 /**
1452  *  e1000_clear_hw_cntrs_82575 - Clear device specific hardware counters
1453  *  @hw: pointer to the HW structure
1454  *
1455  *  Clears the hardware counters by reading the counter registers.
1456  **/
1457 static void e1000_clear_hw_cntrs_82575(struct e1000_hw *hw)
1458 {
1459         DEBUGFUNC("e1000_clear_hw_cntrs_82575");
1460
1461         e1000_clear_hw_cntrs_base_generic(hw);
1462
1463         E1000_READ_REG(hw, E1000_PRC64);
1464         E1000_READ_REG(hw, E1000_PRC127);
1465         E1000_READ_REG(hw, E1000_PRC255);
1466         E1000_READ_REG(hw, E1000_PRC511);
1467         E1000_READ_REG(hw, E1000_PRC1023);
1468         E1000_READ_REG(hw, E1000_PRC1522);
1469         E1000_READ_REG(hw, E1000_PTC64);
1470         E1000_READ_REG(hw, E1000_PTC127);
1471         E1000_READ_REG(hw, E1000_PTC255);
1472         E1000_READ_REG(hw, E1000_PTC511);
1473         E1000_READ_REG(hw, E1000_PTC1023);
1474         E1000_READ_REG(hw, E1000_PTC1522);
1475
1476         E1000_READ_REG(hw, E1000_ALGNERRC);
1477         E1000_READ_REG(hw, E1000_RXERRC);
1478         E1000_READ_REG(hw, E1000_TNCRS);
1479         E1000_READ_REG(hw, E1000_CEXTERR);
1480         E1000_READ_REG(hw, E1000_TSCTC);
1481         E1000_READ_REG(hw, E1000_TSCTFC);
1482
1483         E1000_READ_REG(hw, E1000_MGTPRC);
1484         E1000_READ_REG(hw, E1000_MGTPDC);
1485         E1000_READ_REG(hw, E1000_MGTPTC);
1486
1487         E1000_READ_REG(hw, E1000_IAC);
1488         E1000_READ_REG(hw, E1000_ICRXOC);
1489
1490         E1000_READ_REG(hw, E1000_ICRXPTC);
1491         E1000_READ_REG(hw, E1000_ICRXATC);
1492         E1000_READ_REG(hw, E1000_ICTXPTC);
1493         E1000_READ_REG(hw, E1000_ICTXATC);
1494         E1000_READ_REG(hw, E1000_ICTXQEC);
1495         E1000_READ_REG(hw, E1000_ICTXQMTC);
1496         E1000_READ_REG(hw, E1000_ICRXDMTC);
1497
1498         E1000_READ_REG(hw, E1000_CBTMPC);
1499         E1000_READ_REG(hw, E1000_HTDPMC);
1500         E1000_READ_REG(hw, E1000_CBRMPC);
1501         E1000_READ_REG(hw, E1000_RPTHC);
1502         E1000_READ_REG(hw, E1000_HGPTC);
1503         E1000_READ_REG(hw, E1000_HTCBDPC);
1504         E1000_READ_REG(hw, E1000_HGORCL);
1505         E1000_READ_REG(hw, E1000_HGORCH);
1506         E1000_READ_REG(hw, E1000_HGOTCL);
1507         E1000_READ_REG(hw, E1000_HGOTCH);
1508         E1000_READ_REG(hw, E1000_LENERRS);
1509
1510         /* This register should not be read in copper configurations */
1511         if ((hw->phy.media_type == e1000_media_type_internal_serdes) ||
1512             e1000_sgmii_active_82575(hw))
1513                 E1000_READ_REG(hw, E1000_SCVPC);
1514 }
1515
1516 /**
1517  *  e1000_rx_fifo_flush_82575 - Clean rx fifo after RX enable
1518  *  @hw: pointer to the HW structure
1519  *
1520  *  After rx enable if managability is enabled then there is likely some
1521  *  bad data at the start of the fifo and possibly in the DMA fifo.  This
1522  *  function clears the fifos and flushes any packets that came in as rx was
1523  *  being enabled.
1524  **/
1525 void e1000_rx_fifo_flush_82575(struct e1000_hw *hw)
1526 {
1527         u32 rctl, rlpml, rxdctl[4], rfctl, temp_rctl, rx_enabled;
1528         int i, ms_wait;
1529
1530         DEBUGFUNC("e1000_rx_fifo_workaround_82575");
1531         if (hw->mac.type != e1000_82575 ||
1532             !(E1000_READ_REG(hw, E1000_MANC) & E1000_MANC_RCV_TCO_EN))
1533                 return;
1534
1535         /* Disable all RX queues */
1536         for (i = 0; i < 4; i++) {
1537                 rxdctl[i] = E1000_READ_REG(hw, E1000_RXDCTL(i));
1538                 E1000_WRITE_REG(hw, E1000_RXDCTL(i),
1539                                 rxdctl[i] & ~E1000_RXDCTL_QUEUE_ENABLE);
1540         }
1541         /* Poll all queues to verify they have shut down */
1542         for (ms_wait = 0; ms_wait < 10; ms_wait++) {
1543                 msec_delay(1);
1544                 rx_enabled = 0;
1545                 for (i = 0; i < 4; i++)
1546                         rx_enabled |= E1000_READ_REG(hw, E1000_RXDCTL(i));
1547                 if (!(rx_enabled & E1000_RXDCTL_QUEUE_ENABLE))
1548                         break;
1549         }
1550
1551         if (ms_wait == 10)
1552                 DEBUGOUT("Queue disable timed out after 10ms\n");
1553
1554         /* Clear RLPML, RCTL.SBP, RFCTL.LEF, and set RCTL.LPE so that all
1555          * incoming packets are rejected.  Set enable and wait 2ms so that
1556          * any packet that was coming in as RCTL.EN was set is flushed
1557          */
1558         rfctl = E1000_READ_REG(hw, E1000_RFCTL);
1559         E1000_WRITE_REG(hw, E1000_RFCTL, rfctl & ~E1000_RFCTL_LEF);
1560
1561         rlpml = E1000_READ_REG(hw, E1000_RLPML);
1562         E1000_WRITE_REG(hw, E1000_RLPML, 0);
1563
1564         rctl = E1000_READ_REG(hw, E1000_RCTL);
1565         temp_rctl = rctl & ~(E1000_RCTL_EN | E1000_RCTL_SBP);
1566         temp_rctl |= E1000_RCTL_LPE;
1567
1568         E1000_WRITE_REG(hw, E1000_RCTL, temp_rctl);
1569         E1000_WRITE_REG(hw, E1000_RCTL, temp_rctl | E1000_RCTL_EN);
1570         E1000_WRITE_FLUSH(hw);
1571         msec_delay(2);
1572
1573         /* Enable RX queues that were previously enabled and restore our
1574          * previous state
1575          */
1576         for (i = 0; i < 4; i++)
1577                 E1000_WRITE_REG(hw, E1000_RXDCTL(i), rxdctl[i]);
1578         E1000_WRITE_REG(hw, E1000_RCTL, rctl);
1579         E1000_WRITE_FLUSH(hw);
1580
1581         E1000_WRITE_REG(hw, E1000_RLPML, rlpml);
1582         E1000_WRITE_REG(hw, E1000_RFCTL, rfctl);
1583
1584         /* Flush receive errors generated by workaround */
1585         E1000_READ_REG(hw, E1000_ROC);
1586         E1000_READ_REG(hw, E1000_RNBC);
1587         E1000_READ_REG(hw, E1000_MPC);
1588 }
1589
1590 /**
1591  *  e1000_set_pcie_completion_timeout - set pci-e completion timeout
1592  *  @hw: pointer to the HW structure
1593  *
1594  *  The defaults for 82575 and 82576 should be in the range of 50us to 50ms,
1595  *  however the hardware default for these parts is 500us to 1ms which is less
1596  *  than the 10ms recommended by the pci-e spec.  To address this we need to
1597  *  increase the value to either 10ms to 200ms for capability version 1 config,
1598  *  or 16ms to 55ms for version 2.
1599  **/
1600 static s32 e1000_set_pcie_completion_timeout(struct e1000_hw *hw)
1601 {
1602         u32 gcr = E1000_READ_REG(hw, E1000_GCR);
1603         s32 ret_val = E1000_SUCCESS;
1604         u16 pcie_devctl2;
1605
1606         /* only take action if timeout value is defaulted to 0 */
1607         if (gcr & E1000_GCR_CMPL_TMOUT_MASK)
1608                 goto out;
1609
1610         /*
1611          * if capababilities version is type 1 we can write the
1612          * timeout of 10ms to 200ms through the GCR register
1613          */
1614         if (!(gcr & E1000_GCR_CAP_VER2)) {
1615                 gcr |= E1000_GCR_CMPL_TMOUT_10ms;
1616                 goto out;
1617         }
1618
1619         /*
1620          * for version 2 capabilities we need to write the config space
1621          * directly in order to set the completion timeout value for
1622          * 16ms to 55ms
1623          */
1624         ret_val = e1000_read_pcie_cap_reg(hw, PCIE_DEVICE_CONTROL2,
1625                                           &pcie_devctl2);
1626         if (ret_val)
1627                 goto out;
1628
1629         pcie_devctl2 |= PCIE_DEVICE_CONTROL2_16ms;
1630
1631         ret_val = e1000_write_pcie_cap_reg(hw, PCIE_DEVICE_CONTROL2,
1632                                            &pcie_devctl2);
1633 out:
1634         /* disable completion timeout resend */
1635         gcr &= ~E1000_GCR_CMPL_TMOUT_RESEND;
1636
1637         E1000_WRITE_REG(hw, E1000_GCR, gcr);
1638         return ret_val;
1639 }
1640
1641 /**
1642  *  e1000_vmdq_set_loopback_pf - enable or disable vmdq loopback
1643  *  @hw: pointer to the hardware struct
1644  *  @enable: state to enter, either enabled or disabled
1645  *
1646  *  enables/disables L2 switch loopback functionality.
1647  **/
1648 void e1000_vmdq_set_loopback_pf(struct e1000_hw *hw, bool enable)
1649 {
1650         u32 dtxswc;
1651
1652         switch (hw->mac.type) {
1653         case e1000_82576:
1654                 dtxswc = E1000_READ_REG(hw, E1000_DTXSWC);
1655                 if (enable)
1656                         dtxswc |= E1000_DTXSWC_VMDQ_LOOPBACK_EN;
1657                 else
1658                         dtxswc &= ~E1000_DTXSWC_VMDQ_LOOPBACK_EN;
1659                 E1000_WRITE_REG(hw, E1000_DTXSWC, dtxswc);
1660                 break;
1661         default:
1662                 /* Currently no other hardware supports loopback */
1663                 break;
1664         }
1665
1666
1667 }
1668
1669 /**
1670  *  e1000_vmdq_set_replication_pf - enable or disable vmdq replication
1671  *  @hw: pointer to the hardware struct
1672  *  @enable: state to enter, either enabled or disabled
1673  *
1674  *  enables/disables replication of packets across multiple pools.
1675  **/
1676 void e1000_vmdq_set_replication_pf(struct e1000_hw *hw, bool enable)
1677 {
1678         u32 vt_ctl = E1000_READ_REG(hw, E1000_VT_CTL);
1679
1680         if (enable)
1681                 vt_ctl |= E1000_VT_CTL_VM_REPL_EN;
1682         else
1683                 vt_ctl &= ~E1000_VT_CTL_VM_REPL_EN;
1684
1685         E1000_WRITE_REG(hw, E1000_VT_CTL, vt_ctl);
1686 }
1687
1688 /**
1689  *  e1000_read_phy_reg_82580 - Read 82580 MDI control register
1690  *  @hw: pointer to the HW structure
1691  *  @offset: register offset to be read
1692  *  @data: pointer to the read data
1693  *
1694  *  Reads the MDI control register in the PHY at offset and stores the
1695  *  information read to data.
1696  **/
1697 static s32 e1000_read_phy_reg_82580(struct e1000_hw *hw, u32 offset, u16 *data)
1698 {
1699         s32 ret_val;
1700
1701         DEBUGFUNC("e1000_read_phy_reg_82580");
1702
1703         ret_val = hw->phy.ops.acquire(hw);
1704         if (ret_val)
1705                 goto out;
1706
1707         ret_val = e1000_read_phy_reg_mdic(hw, offset, data);
1708
1709         hw->phy.ops.release(hw);
1710
1711 out:
1712         return ret_val;
1713 }
1714
1715 /**
1716  *  e1000_write_phy_reg_82580 - Write 82580 MDI control register
1717  *  @hw: pointer to the HW structure
1718  *  @offset: register offset to write to
1719  *  @data: data to write to register at offset
1720  *
1721  *  Writes data to MDI control register in the PHY at offset.
1722  **/
1723 static s32 e1000_write_phy_reg_82580(struct e1000_hw *hw, u32 offset, u16 data)
1724 {
1725         s32 ret_val;
1726
1727         DEBUGFUNC("e1000_write_phy_reg_82580");
1728
1729         ret_val = hw->phy.ops.acquire(hw);
1730         if (ret_val)
1731                 goto out;
1732
1733         ret_val = e1000_write_phy_reg_mdic(hw, offset, data);
1734
1735         hw->phy.ops.release(hw);
1736
1737 out:
1738         return ret_val;
1739 }
1740
1741 /**
1742  *  e1000_reset_hw_82580 - Reset hardware
1743  *  @hw: pointer to the HW structure
1744  *
1745  *  This resets function or entire device (all ports, etc.)
1746  *  to a known state.
1747  **/
1748 static s32 e1000_reset_hw_82580(struct e1000_hw *hw)
1749 {
1750         s32 ret_val = E1000_SUCCESS;
1751         /* BH SW mailbox bit in SW_FW_SYNC */
1752         u16 swmbsw_mask = E1000_SW_SYNCH_MB;
1753         u32 ctrl, icr;
1754         bool global_device_reset = hw->dev_spec._82575.global_device_reset;
1755
1756         DEBUGFUNC("e1000_reset_hw_82580");
1757
1758         hw->dev_spec._82575.global_device_reset = FALSE;
1759
1760         /* Get current control state. */
1761         ctrl = E1000_READ_REG(hw, E1000_CTRL);
1762
1763         /*
1764          * Prevent the PCI-E bus from sticking if there is no TLP connection
1765          * on the last TLP read/write transaction when MAC is reset.
1766          */
1767         ret_val = e1000_disable_pcie_master_generic(hw);
1768         if (ret_val)
1769                 DEBUGOUT("PCI-E Master disable polling has failed.\n");
1770
1771         DEBUGOUT("Masking off all interrupts\n");
1772         E1000_WRITE_REG(hw, E1000_IMC, 0xffffffff);
1773         E1000_WRITE_REG(hw, E1000_RCTL, 0);
1774         E1000_WRITE_REG(hw, E1000_TCTL, E1000_TCTL_PSP);
1775         E1000_WRITE_FLUSH(hw);
1776
1777         msec_delay(10);
1778
1779         /* Determine whether or not a global dev reset is requested */
1780         if (global_device_reset &&
1781                 e1000_acquire_swfw_sync_82575(hw, swmbsw_mask))
1782                         global_device_reset = FALSE;
1783
1784         if (global_device_reset &&
1785                 !(E1000_READ_REG(hw, E1000_STATUS) & E1000_STAT_DEV_RST_SET))
1786                 ctrl |= E1000_CTRL_DEV_RST;
1787         else
1788                 ctrl |= E1000_CTRL_RST;
1789
1790         E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1791
1792         /* Add delay to insure DEV_RST has time to complete */
1793         if (global_device_reset)
1794                 msec_delay(5);
1795
1796         ret_val = e1000_get_auto_rd_done_generic(hw);
1797         if (ret_val) {
1798                 /*
1799                  * When auto config read does not complete, do not
1800                  * return with an error. This can happen in situations
1801                  * where there is no eeprom and prevents getting link.
1802                  */
1803                 DEBUGOUT("Auto Read Done did not complete\n");
1804         }
1805
1806         /* If EEPROM is not present, run manual init scripts */
1807         if ((E1000_READ_REG(hw, E1000_EECD) & E1000_EECD_PRES) == 0)
1808                 e1000_reset_init_script_82575(hw);
1809
1810         /* clear global device reset status bit */
1811         E1000_WRITE_REG(hw, E1000_STATUS, E1000_STAT_DEV_RST_SET);
1812
1813         /* Clear any pending interrupt events. */
1814         E1000_WRITE_REG(hw, E1000_IMC, 0xffffffff);
1815         icr = E1000_READ_REG(hw, E1000_ICR);
1816
1817         /* Install any alternate MAC address into RAR0 */
1818         ret_val = e1000_check_alt_mac_addr_generic(hw);
1819
1820         /* Release semaphore */
1821         if (global_device_reset)
1822                 e1000_release_swfw_sync_82575(hw, swmbsw_mask);
1823
1824         return ret_val;
1825 }
1826
1827 /**
1828  *  e1000_rxpbs_adjust_82580 - adjust RXPBS value to reflect actual RX PBA size
1829  *  @data: data received by reading RXPBS register
1830  *
1831  *  The 82580 uses a table based approach for packet buffer allocation sizes.
1832  *  This function converts the retrieved value into the correct table value
1833  *     0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7
1834  *  0x0 36  72 144   1   2   4   8  16
1835  *  0x8 35  70 140 rsv rsv rsv rsv rsv
1836  */
1837 u16 e1000_rxpbs_adjust_82580(u32 data)
1838 {
1839         u16 ret_val = 0;
1840
1841         if (data < E1000_82580_RXPBS_TABLE_SIZE)
1842                 ret_val = e1000_82580_rxpbs_table[data];
1843
1844         return ret_val;
1845 }