drivers/net/e1000/e1000_hw.c

   1 /*******************************************************************************
   2
   3   Intel PRO/1000 Linux driver
   4   Copyright(c) 1999 - 2006 Intel Corporation.
   5
   6   This program is free software; you can redistribute it and/or modify it
   7   under the terms and conditions of the GNU General Public License,
   8   version 2, as published by the Free Software Foundation.
   9
  10   This program is distributed in the hope it will be useful, but WITHOUT
  11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13   more details.
  14
  15   You should have received a copy of the GNU General Public License along with
  16   this program; if not, write to the Free Software Foundation, Inc.,
  17   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  18
  19   The full GNU General Public License is included in this distribution in
  20   the file called "COPYING".
  21
  22   Contact Information:
  23   Linux NICS <linux.nics@intel.com>
  24   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  25   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  26
  27 *******************************************************************************/
  28
  29 /* e1000_hw.c
  30  * Shared functions for accessing and configuring the MAC
  31  */
  32
  33
  34 #include "e1000_hw.h"
  35
  36 static s32 e1000_swfw_sync_acquire(struct e1000_hw *hw, u16 mask);
  37 static void e1000_swfw_sync_release(struct e1000_hw *hw, u16 mask);
  38 static s32 e1000_read_kmrn_reg(struct e1000_hw *hw, u32 reg_addr, u16 *data);
  39 static s32 e1000_write_kmrn_reg(struct e1000_hw *hw, u32 reg_addr, u16 data);
  40 static s32 e1000_get_software_semaphore(struct e1000_hw *hw);
  41 static void e1000_release_software_semaphore(struct e1000_hw *hw);
  42
  43 static u8 e1000_arc_subsystem_valid(struct e1000_hw *hw);
  44 static s32 e1000_check_downshift(struct e1000_hw *hw);
  45 static s32 e1000_check_polarity(struct e1000_hw *hw,
  46                                 e1000_rev_polarity *polarity);
  47 static void e1000_clear_hw_cntrs(struct e1000_hw *hw);
  48 static void e1000_clear_vfta(struct e1000_hw *hw);
  49 static s32 e1000_commit_shadow_ram(struct e1000_hw *hw);
  50 static s32 e1000_config_dsp_after_link_change(struct e1000_hw *hw,
  51                                               bool link_up);
  52 static s32 e1000_config_fc_after_link_up(struct e1000_hw *hw);
  53 static s32 e1000_detect_gig_phy(struct e1000_hw *hw);
  54 static s32 e1000_erase_ich8_4k_segment(struct e1000_hw *hw, u32 bank);
  55 static s32 e1000_get_auto_rd_done(struct e1000_hw *hw);
  56 static s32 e1000_get_cable_length(struct e1000_hw *hw, u16 *min_length,
  57                                   u16 *max_length);
  58 static s32 e1000_get_hw_eeprom_semaphore(struct e1000_hw *hw);
  59 static s32 e1000_get_phy_cfg_done(struct e1000_hw *hw);
  60 static s32 e1000_get_software_flag(struct e1000_hw *hw);
  61 static s32 e1000_ich8_cycle_init(struct e1000_hw *hw);
  62 static s32 e1000_ich8_flash_cycle(struct e1000_hw *hw, u32 timeout);
  63 static s32 e1000_id_led_init(struct e1000_hw *hw);
  64 static s32 e1000_init_lcd_from_nvm_config_region(struct e1000_hw *hw,
  65                                                  u32 cnf_base_addr,
  66                                                  u32 cnf_size);
  67 static s32 e1000_init_lcd_from_nvm(struct e1000_hw *hw);
  68 static void e1000_init_rx_addrs(struct e1000_hw *hw);
  69 static void e1000_initialize_hardware_bits(struct e1000_hw *hw);
  70 static bool e1000_is_onboard_nvm_eeprom(struct e1000_hw *hw);
  71 static s32 e1000_kumeran_lock_loss_workaround(struct e1000_hw *hw);
  72 static s32 e1000_mng_enable_host_if(struct e1000_hw *hw);
  73 static s32 e1000_mng_host_if_write(struct e1000_hw *hw, u8 *buffer, u16 length,
  74                                    u16 offset, u8 *sum);
  75 static s32 e1000_mng_write_cmd_header(struct e1000_hw* hw,
  76                                       struct e1000_host_mng_command_header
  77                                       *hdr);
  78 static s32 e1000_mng_write_commit(struct e1000_hw *hw);
  79 static s32 e1000_phy_ife_get_info(struct e1000_hw *hw,
  80                                   struct e1000_phy_info *phy_info);
  81 static s32 e1000_phy_igp_get_info(struct e1000_hw *hw,
  82                                   struct e1000_phy_info *phy_info);
  83 static s32 e1000_read_eeprom_eerd(struct e1000_hw *hw, u16 offset, u16 words,
  84                                   u16 *data);
  85 static s32 e1000_write_eeprom_eewr(struct e1000_hw *hw, u16 offset, u16 words,
  86                                    u16 *data);
  87 static s32 e1000_poll_eerd_eewr_done(struct e1000_hw *hw, int eerd);
  88 static s32 e1000_phy_m88_get_info(struct e1000_hw *hw,
  89                                   struct e1000_phy_info *phy_info);
  90 static void e1000_put_hw_eeprom_semaphore(struct e1000_hw *hw);
  91 static s32 e1000_read_ich8_byte(struct e1000_hw *hw, u32 index, u8 *data);
  92 static s32 e1000_verify_write_ich8_byte(struct e1000_hw *hw, u32 index,
  93                                         u8 byte);
  94 static s32 e1000_write_ich8_byte(struct e1000_hw *hw, u32 index, u8 byte);
  95 static s32 e1000_read_ich8_word(struct e1000_hw *hw, u32 index, u16 *data);
  96 static s32 e1000_read_ich8_data(struct e1000_hw *hw, u32 index, u32 size,
  97                                 u16 *data);
  98 static s32 e1000_write_ich8_data(struct e1000_hw *hw, u32 index, u32 size,
  99                                  u16 data);
 100 static s32 e1000_read_eeprom_ich8(struct e1000_hw *hw, u16 offset, u16 words,
 101                                   u16 *data);
 102 static s32 e1000_write_eeprom_ich8(struct e1000_hw *hw, u16 offset, u16 words,
 103                                    u16 *data);
 104 static void e1000_release_software_flag(struct e1000_hw *hw);
 105 static s32 e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active);
 106 static s32 e1000_set_d0_lplu_state(struct e1000_hw *hw, bool active);
 107 static s32 e1000_set_pci_ex_no_snoop(struct e1000_hw *hw, u32 no_snoop);
 108 static void e1000_set_pci_express_master_disable(struct e1000_hw *hw);
 109 static s32 e1000_wait_autoneg(struct e1000_hw *hw);
 110 static void e1000_write_reg_io(struct e1000_hw *hw, u32 offset, u32 value);
 111 static s32 e1000_set_phy_type(struct e1000_hw *hw);
 112 static void e1000_phy_init_script(struct e1000_hw *hw);
 113 static s32 e1000_setup_copper_link(struct e1000_hw *hw);
 114 static s32 e1000_setup_fiber_serdes_link(struct e1000_hw *hw);
 115 static s32 e1000_adjust_serdes_amplitude(struct e1000_hw *hw);
 116 static s32 e1000_phy_force_speed_duplex(struct e1000_hw *hw);
 117 static s32 e1000_config_mac_to_phy(struct e1000_hw *hw);
 118 static void e1000_raise_mdi_clk(struct e1000_hw *hw, u32 *ctrl);
 119 static void e1000_lower_mdi_clk(struct e1000_hw *hw, u32 *ctrl);
 120 static void e1000_shift_out_mdi_bits(struct e1000_hw *hw, u32 data,
 121                                      u16 count);
 122 static u16 e1000_shift_in_mdi_bits(struct e1000_hw *hw);
 123 static s32 e1000_phy_reset_dsp(struct e1000_hw *hw);
 124 static s32 e1000_write_eeprom_spi(struct e1000_hw *hw, u16 offset,
 125                                       u16 words, u16 *data);
 126 static s32 e1000_write_eeprom_microwire(struct e1000_hw *hw, u16 offset,
 127                                         u16 words, u16 *data);
 128 static s32 e1000_spi_eeprom_ready(struct e1000_hw *hw);
 129 static void e1000_raise_ee_clk(struct e1000_hw *hw, u32 *eecd);
 130 static void e1000_lower_ee_clk(struct e1000_hw *hw, u32 *eecd);
 131 static void e1000_shift_out_ee_bits(struct e1000_hw *hw, u16 data, u16 count);
 132 static s32 e1000_write_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
 133                                   u16 phy_data);
 134 static s32 e1000_read_phy_reg_ex(struct e1000_hw *hw,u32 reg_addr,
 135                                  u16 *phy_data);
 136 static u16 e1000_shift_in_ee_bits(struct e1000_hw *hw, u16 count);
 137 static s32 e1000_acquire_eeprom(struct e1000_hw *hw);
 138 static void e1000_release_eeprom(struct e1000_hw *hw);
 139 static void e1000_standby_eeprom(struct e1000_hw *hw);
 140 static s32 e1000_set_vco_speed(struct e1000_hw *hw);
 141 static s32 e1000_polarity_reversal_workaround(struct e1000_hw *hw);
 142 static s32 e1000_set_phy_mode(struct e1000_hw *hw);
 143 static s32 e1000_host_if_read_cookie(struct e1000_hw *hw, u8 *buffer);
 144 static u8 e1000_calculate_mng_checksum(char *buffer, u32 length);
 145 static s32 e1000_configure_kmrn_for_10_100(struct e1000_hw *hw, u16 duplex);
 146 static s32 e1000_configure_kmrn_for_1000(struct e1000_hw *hw);
 147
 148 /* IGP cable length table */
 149 static const
 150 u16 e1000_igp_cable_length_table[IGP01E1000_AGC_LENGTH_TABLE_SIZE] =
 151     { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 152       5, 10, 10, 10, 10, 10, 10, 10, 20, 20, 20, 20, 20, 25, 25, 25,
 153       25, 25, 25, 25, 30, 30, 30, 30, 40, 40, 40, 40, 40, 40, 40, 40,
 154       40, 50, 50, 50, 50, 50, 50, 50, 60, 60, 60, 60, 60, 60, 60, 60,
 155       60, 70, 70, 70, 70, 70, 70, 80, 80, 80, 80, 80, 80, 90, 90, 90,
 156       90, 90, 90, 90, 90, 90, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
 157       100, 100, 100, 100, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
 158       110, 110, 110, 110, 110, 110, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120};
 159
 160 static const
 161 u16 e1000_igp_2_cable_length_table[IGP02E1000_AGC_LENGTH_TABLE_SIZE] =
 162     { 0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 8, 11, 13, 16, 18, 21,
 163       0, 0, 0, 3, 6, 10, 13, 16, 19, 23, 26, 29, 32, 35, 38, 41,
 164       6, 10, 14, 18, 22, 26, 30, 33, 37, 41, 44, 48, 51, 54, 58, 61,
 165       21, 26, 31, 35, 40, 44, 49, 53, 57, 61, 65, 68, 72, 75, 79, 82,
 166       40, 45, 51, 56, 61, 66, 70, 75, 79, 83, 87, 91, 94, 98, 101, 104,
 167       60, 66, 72, 77, 82, 87, 92, 96, 100, 104, 108, 111, 114, 117, 119, 121,
 168       83, 89, 95, 100, 105, 109, 113, 116, 119, 122, 124,
 169       104, 109, 114, 118, 121, 124};
 170
 171 /******************************************************************************
 172  * Set the phy type member in the hw struct.
 173  *
 174  * hw - Struct containing variables accessed by shared code
 175  *****************************************************************************/
 176 static s32 e1000_set_phy_type(struct e1000_hw *hw)
 177 {
 178     DEBUGFUNC("e1000_set_phy_type");
 179
 180     if (hw->mac_type == e1000_undefined)
 181         return -E1000_ERR_PHY_TYPE;
 182
 183     switch (hw->phy_id) {
 184     case M88E1000_E_PHY_ID:
 185     case M88E1000_I_PHY_ID:
 186     case M88E1011_I_PHY_ID:
 187     case M88E1111_I_PHY_ID:
 188         hw->phy_type = e1000_phy_m88;
 189         break;
 190     case IGP01E1000_I_PHY_ID:
 191         if (hw->mac_type == e1000_82541 ||
 192             hw->mac_type == e1000_82541_rev_2 ||
 193             hw->mac_type == e1000_82547 ||
 194             hw->mac_type == e1000_82547_rev_2) {
 195             hw->phy_type = e1000_phy_igp;
 196             break;
 197         }
 198     case IGP03E1000_E_PHY_ID:
 199         hw->phy_type = e1000_phy_igp_3;
 200         break;
 201     case IFE_E_PHY_ID:
 202     case IFE_PLUS_E_PHY_ID:
 203     case IFE_C_E_PHY_ID:
 204         hw->phy_type = e1000_phy_ife;
 205         break;
 206     case GG82563_E_PHY_ID:
 207         if (hw->mac_type == e1000_80003es2lan) {
 208             hw->phy_type = e1000_phy_gg82563;
 209             break;
 210         }
 211         /* Fall Through */
 212     default:
 213         /* Should never have loaded on this device */
 214         hw->phy_type = e1000_phy_undefined;
 215         return -E1000_ERR_PHY_TYPE;
 216     }
 217
 218     return E1000_SUCCESS;
 219 }
 220
 221 /******************************************************************************
 222  * IGP phy init script - initializes the GbE PHY
 223  *
 224  * hw - Struct containing variables accessed by shared code
 225  *****************************************************************************/
 226 static void e1000_phy_init_script(struct e1000_hw *hw)
 227 {
 228     u32 ret_val;
 229     u16 phy_saved_data;
 230
 231     DEBUGFUNC("e1000_phy_init_script");
 232
 233     if (hw->phy_init_script) {
 234         msleep(20);
 235
 236         /* Save off the current value of register 0x2F5B to be restored at
 237          * the end of this routine. */
 238         ret_val = e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data);
 239
 240         /* Disabled the PHY transmitter */
 241         e1000_write_phy_reg(hw, 0x2F5B, 0x0003);
 242
 243         msleep(20);
 244
 245         e1000_write_phy_reg(hw,0x0000,0x0140);
 246
 247         msleep(5);
 248
 249         switch (hw->mac_type) {
 250         case e1000_82541:
 251         case e1000_82547:
 252             e1000_write_phy_reg(hw, 0x1F95, 0x0001);
 253
 254             e1000_write_phy_reg(hw, 0x1F71, 0xBD21);
 255
 256             e1000_write_phy_reg(hw, 0x1F79, 0x0018);
 257
 258             e1000_write_phy_reg(hw, 0x1F30, 0x1600);
 259
 260             e1000_write_phy_reg(hw, 0x1F31, 0x0014);
 261
 262             e1000_write_phy_reg(hw, 0x1F32, 0x161C);
 263
 264             e1000_write_phy_reg(hw, 0x1F94, 0x0003);
 265
 266             e1000_write_phy_reg(hw, 0x1F96, 0x003F);
 267
 268             e1000_write_phy_reg(hw, 0x2010, 0x0008);
 269             break;
 270
 271         case e1000_82541_rev_2:
 272         case e1000_82547_rev_2:
 273             e1000_write_phy_reg(hw, 0x1F73, 0x0099);
 274             break;
 275         default:
 276             break;
 277         }
 278
 279         e1000_write_phy_reg(hw, 0x0000, 0x3300);
 280
 281         msleep(20);
 282
 283         /* Now enable the transmitter */
 284         e1000_write_phy_reg(hw, 0x2F5B, phy_saved_data);
 285
 286         if (hw->mac_type == e1000_82547) {
 287             u16 fused, fine, coarse;
 288
 289             /* Move to analog registers page */
 290             e1000_read_phy_reg(hw, IGP01E1000_ANALOG_SPARE_FUSE_STATUS, &fused);
 291
 292             if (!(fused & IGP01E1000_ANALOG_SPARE_FUSE_ENABLED)) {
 293                 e1000_read_phy_reg(hw, IGP01E1000_ANALOG_FUSE_STATUS, &fused);
 294
 295                 fine = fused & IGP01E1000_ANALOG_FUSE_FINE_MASK;
 296                 coarse = fused & IGP01E1000_ANALOG_FUSE_COARSE_MASK;
 297
 298                 if (coarse > IGP01E1000_ANALOG_FUSE_COARSE_THRESH) {
 299                     coarse -= IGP01E1000_ANALOG_FUSE_COARSE_10;
 300                     fine -= IGP01E1000_ANALOG_FUSE_FINE_1;
 301                 } else if (coarse == IGP01E1000_ANALOG_FUSE_COARSE_THRESH)
 302                     fine -= IGP01E1000_ANALOG_FUSE_FINE_10;
 303
 304                 fused = (fused & IGP01E1000_ANALOG_FUSE_POLY_MASK) |
 305                         (fine & IGP01E1000_ANALOG_FUSE_FINE_MASK) |
 306                         (coarse & IGP01E1000_ANALOG_FUSE_COARSE_MASK);
 307
 308                 e1000_write_phy_reg(hw, IGP01E1000_ANALOG_FUSE_CONTROL, fused);
 309                 e1000_write_phy_reg(hw, IGP01E1000_ANALOG_FUSE_BYPASS,
 310                                     IGP01E1000_ANALOG_FUSE_ENABLE_SW_CONTROL);
 311             }
 312         }
 313     }
 314 }
 315
 316 /******************************************************************************
 317  * Set the mac type member in the hw struct.
 318  *
 319  * hw - Struct containing variables accessed by shared code
 320  *****************************************************************************/
 321 s32 e1000_set_mac_type(struct e1000_hw *hw)
 322 {
 323         DEBUGFUNC("e1000_set_mac_type");
 324
 325         switch (hw->device_id) {
 326         case E1000_DEV_ID_82542:
 327                 switch (hw->revision_id) {
 328                 case E1000_82542_2_0_REV_ID:
 329                         hw->mac_type = e1000_82542_rev2_0;
 330                         break;
 331                 case E1000_82542_2_1_REV_ID:
 332                         hw->mac_type = e1000_82542_rev2_1;
 333                         break;
 334                 default:
 335                         /* Invalid 82542 revision ID */
 336                         return -E1000_ERR_MAC_TYPE;
 337                 }
 338                 break;
 339         case E1000_DEV_ID_82543GC_FIBER:
 340         case E1000_DEV_ID_82543GC_COPPER:
 341                 hw->mac_type = e1000_82543;
 342                 break;
 343         case E1000_DEV_ID_82544EI_COPPER:
 344         case E1000_DEV_ID_82544EI_FIBER:
 345         case E1000_DEV_ID_82544GC_COPPER:
 346         case E1000_DEV_ID_82544GC_LOM:
 347                 hw->mac_type = e1000_82544;
 348                 break;
 349         case E1000_DEV_ID_82540EM:
 350         case E1000_DEV_ID_82540EM_LOM:
 351         case E1000_DEV_ID_82540EP:
 352         case E1000_DEV_ID_82540EP_LOM:
 353         case E1000_DEV_ID_82540EP_LP:
 354                 hw->mac_type = e1000_82540;
 355                 break;
 356         case E1000_DEV_ID_82545EM_COPPER:
 357         case E1000_DEV_ID_82545EM_FIBER:
 358                 hw->mac_type = e1000_82545;
 359                 break;
 360         case E1000_DEV_ID_82545GM_COPPER:
 361         case E1000_DEV_ID_82545GM_FIBER:
 362         case E1000_DEV_ID_82545GM_SERDES:
 363                 hw->mac_type = e1000_82545_rev_3;
 364                 break;
 365         case E1000_DEV_ID_82546EB_COPPER:
 366         case E1000_DEV_ID_82546EB_FIBER:
 367         case E1000_DEV_ID_82546EB_QUAD_COPPER:
 368                 hw->mac_type = e1000_82546;
 369                 break;
 370         case E1000_DEV_ID_82546GB_COPPER:
 371         case E1000_DEV_ID_82546GB_FIBER:
 372         case E1000_DEV_ID_82546GB_SERDES:
 373         case E1000_DEV_ID_82546GB_PCIE:
 374         case E1000_DEV_ID_82546GB_QUAD_COPPER:
 375         case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
 376                 hw->mac_type = e1000_82546_rev_3;
 377                 break;
 378         case E1000_DEV_ID_82541EI:
 379         case E1000_DEV_ID_82541EI_MOBILE:
 380         case E1000_DEV_ID_82541ER_LOM:
 381                 hw->mac_type = e1000_82541;
 382                 break;
 383         case E1000_DEV_ID_82541ER:
 384         case E1000_DEV_ID_82541GI:
 385         case E1000_DEV_ID_82541GI_LF:
 386         case E1000_DEV_ID_82541GI_MOBILE:
 387                 hw->mac_type = e1000_82541_rev_2;
 388                 break;
 389         case E1000_DEV_ID_82547EI:
 390         case E1000_DEV_ID_82547EI_MOBILE:
 391                 hw->mac_type = e1000_82547;
 392                 break;
 393         case E1000_DEV_ID_82547GI:
 394                 hw->mac_type = e1000_82547_rev_2;
 395                 break;
 396         case E1000_DEV_ID_82571EB_COPPER:
 397         case E1000_DEV_ID_82571EB_FIBER:
 398         case E1000_DEV_ID_82571EB_SERDES:
 399         case E1000_DEV_ID_82571EB_SERDES_DUAL:
 400         case E1000_DEV_ID_82571EB_SERDES_QUAD:
 401         case E1000_DEV_ID_82571EB_QUAD_COPPER:
 402         case E1000_DEV_ID_82571PT_QUAD_COPPER:
 403         case E1000_DEV_ID_82571EB_QUAD_FIBER:
 404         case E1000_DEV_ID_82571EB_QUAD_COPPER_LOWPROFILE:
 405                 hw->mac_type = e1000_82571;
 406                 break;
 407         case E1000_DEV_ID_82572EI_COPPER:
 408         case E1000_DEV_ID_82572EI_FIBER:
 409         case E1000_DEV_ID_82572EI_SERDES:
 410         case E1000_DEV_ID_82572EI:
 411                 hw->mac_type = e1000_82572;
 412                 break;
 413         case E1000_DEV_ID_82573E:
 414         case E1000_DEV_ID_82573E_IAMT:
 415         case E1000_DEV_ID_82573L:
 416                 hw->mac_type = e1000_82573;
 417                 break;
 418         case E1000_DEV_ID_80003ES2LAN_COPPER_SPT:
 419         case E1000_DEV_ID_80003ES2LAN_SERDES_SPT:
 420         case E1000_DEV_ID_80003ES2LAN_COPPER_DPT:
 421         case E1000_DEV_ID_80003ES2LAN_SERDES_DPT:
 422                 hw->mac_type = e1000_80003es2lan;
 423                 break;
 424         case E1000_DEV_ID_ICH8_IGP_M_AMT:
 425         case E1000_DEV_ID_ICH8_IGP_AMT:
 426         case E1000_DEV_ID_ICH8_IGP_C:
 427         case E1000_DEV_ID_ICH8_IFE:
 428         case E1000_DEV_ID_ICH8_IFE_GT:
 429         case E1000_DEV_ID_ICH8_IFE_G:
 430         case E1000_DEV_ID_ICH8_IGP_M:
 431                 hw->mac_type = e1000_ich8lan;
 432                 break;
 433         default:
 434                 /* Should never have loaded on this device */
 435                 return -E1000_ERR_MAC_TYPE;
 436         }
 437
 438         switch (hw->mac_type) {
 439         case e1000_ich8lan:
 440                 hw->swfwhw_semaphore_present = true;
 441                 hw->asf_firmware_present = true;
 442                 break;
 443         case e1000_80003es2lan:
 444                 hw->swfw_sync_present = true;
 445                 /* fall through */
 446         case e1000_82571:
 447         case e1000_82572:
 448         case e1000_82573:
 449                 hw->eeprom_semaphore_present = true;
 450                 /* fall through */
 451         case e1000_82541:
 452         case e1000_82547:
 453         case e1000_82541_rev_2:
 454         case e1000_82547_rev_2:
 455                 hw->asf_firmware_present = true;
 456                 break;
 457         default:
 458                 break;
 459         }
 460
 461         /* The 82543 chip does not count tx_carrier_errors properly in
 462          * FD mode
 463          */
 464         if (hw->mac_type == e1000_82543)
 465                 hw->bad_tx_carr_stats_fd = true;
 466
 467         /* capable of receiving management packets to the host */
 468         if (hw->mac_type >= e1000_82571)
 469                 hw->has_manc2h = true;
 470
 471         /* In rare occasions, ESB2 systems would end up started without
 472          * the RX unit being turned on.
 473          */
 474         if (hw->mac_type == e1000_80003es2lan)
 475                 hw->rx_needs_kicking = true;
 476
 477         if (hw->mac_type > e1000_82544)
 478                 hw->has_smbus = true;
 479
 480         return E1000_SUCCESS;
 481 }
 482
 483 /*****************************************************************************
 484  * Set media type and TBI compatibility.
 485  *
 486  * hw - Struct containing variables accessed by shared code
 487  * **************************************************************************/
 488 void e1000_set_media_type(struct e1000_hw *hw)
 489 {
 490     u32 status;
 491
 492     DEBUGFUNC("e1000_set_media_type");
 493
 494     if (hw->mac_type != e1000_82543) {
 495         /* tbi_compatibility is only valid on 82543 */
 496         hw->tbi_compatibility_en = false;
 497     }
 498
 499     switch (hw->device_id) {
 500     case E1000_DEV_ID_82545GM_SERDES:
 501     case E1000_DEV_ID_82546GB_SERDES:
 502     case E1000_DEV_ID_82571EB_SERDES:
 503     case E1000_DEV_ID_82571EB_SERDES_DUAL:
 504     case E1000_DEV_ID_82571EB_SERDES_QUAD:
 505     case E1000_DEV_ID_82572EI_SERDES:
 506     case E1000_DEV_ID_80003ES2LAN_SERDES_DPT:
 507         hw->media_type = e1000_media_type_internal_serdes;
 508         break;
 509     default:
 510         switch (hw->mac_type) {
 511         case e1000_82542_rev2_0:
 512         case e1000_82542_rev2_1:
 513             hw->media_type = e1000_media_type_fiber;
 514             break;
 515         case e1000_ich8lan:
 516         case e1000_82573:
 517             /* The STATUS_TBIMODE bit is reserved or reused for the this
 518              * device.
 519              */
 520             hw->media_type = e1000_media_type_copper;
 521             break;
 522         default:
 523             status = er32(STATUS);
 524             if (status & E1000_STATUS_TBIMODE) {
 525                 hw->media_type = e1000_media_type_fiber;
 526                 /* tbi_compatibility not valid on fiber */
 527                 hw->tbi_compatibility_en = false;
 528             } else {
 529                 hw->media_type = e1000_media_type_copper;
 530             }
 531             break;
 532         }
 533     }
 534 }
 535
 536 /******************************************************************************
 537  * Reset the transmit and receive units; mask and clear all interrupts.
 538  *
 539  * hw - Struct containing variables accessed by shared code
 540  *****************************************************************************/
 541 s32 e1000_reset_hw(struct e1000_hw *hw)
 542 {
 543     u32 ctrl;
 544     u32 ctrl_ext;
 545     u32 icr;
 546     u32 manc;
 547     u32 led_ctrl;
 548     u32 timeout;
 549     u32 extcnf_ctrl;
 550     s32 ret_val;
 551
 552     DEBUGFUNC("e1000_reset_hw");
 553
 554     /* For 82542 (rev 2.0), disable MWI before issuing a device reset */
 555     if (hw->mac_type == e1000_82542_rev2_0) {
 556         DEBUGOUT("Disabling MWI on 82542 rev 2.0\n");
 557         e1000_pci_clear_mwi(hw);
 558     }
 559
 560     if (hw->bus_type == e1000_bus_type_pci_express) {
 561         /* Prevent the PCI-E bus from sticking if there is no TLP connection
 562          * on the last TLP read/write transaction when MAC is reset.
 563          */
 564         if (e1000_disable_pciex_master(hw) != E1000_SUCCESS) {
 565             DEBUGOUT("PCI-E Master disable polling has failed.\n");
 566         }
 567     }
 568
 569     /* Clear interrupt mask to stop board from generating interrupts */
 570     DEBUGOUT("Masking off all interrupts\n");
 571     ew32(IMC, 0xffffffff);
 572
 573     /* Disable the Transmit and Receive units.  Then delay to allow
 574      * any pending transactions to complete before we hit the MAC with
 575      * the global reset.
 576      */
 577     ew32(RCTL, 0);
 578     ew32(TCTL, E1000_TCTL_PSP);
 579     E1000_WRITE_FLUSH();
 580
 581     /* The tbi_compatibility_on Flag must be cleared when Rctl is cleared. */
 582     hw->tbi_compatibility_on = false;
 583
 584     /* Delay to allow any outstanding PCI transactions to complete before
 585      * resetting the device
 586      */
 587     msleep(10);
 588
 589     ctrl = er32(CTRL);
 590
 591     /* Must reset the PHY before resetting the MAC */
 592     if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
 593         ew32(CTRL, (ctrl | E1000_CTRL_PHY_RST));
 594         msleep(5);
 595     }
 596
 597     /* Must acquire the MDIO ownership before MAC reset.
 598      * Ownership defaults to firmware after a reset. */
 599     if (hw->mac_type == e1000_82573) {
 600         timeout = 10;
 601
 602         extcnf_ctrl = er32(EXTCNF_CTRL);
 603         extcnf_ctrl |= E1000_EXTCNF_CTRL_MDIO_SW_OWNERSHIP;
 604
 605         do {
 606             ew32(EXTCNF_CTRL, extcnf_ctrl);
 607             extcnf_ctrl = er32(EXTCNF_CTRL);
 608
 609             if (extcnf_ctrl & E1000_EXTCNF_CTRL_MDIO_SW_OWNERSHIP)
 610                 break;
 611             else
 612                 extcnf_ctrl |= E1000_EXTCNF_CTRL_MDIO_SW_OWNERSHIP;
 613
 614             msleep(2);
 615             timeout--;
 616         } while (timeout);
 617     }
 618
 619     /* Workaround for ICH8 bit corruption issue in FIFO memory */
 620     if (hw->mac_type == e1000_ich8lan) {
 621         /* Set Tx and Rx buffer allocation to 8k apiece. */
 622         ew32(PBA, E1000_PBA_8K);
 623         /* Set Packet Buffer Size to 16k. */
 624         ew32(PBS, E1000_PBS_16K);
 625     }
 626
 627     /* Issue a global reset to the MAC.  This will reset the chip's
 628      * transmit, receive, DMA, and link units.  It will not effect
 629      * the current PCI configuration.  The global reset bit is self-
 630      * clearing, and should clear within a microsecond.
 631      */
 632     DEBUGOUT("Issuing a global reset to MAC\n");
 633
 634     switch (hw->mac_type) {
 635         case e1000_82544:
 636         case e1000_82540:
 637         case e1000_82545:
 638         case e1000_82546:
 639         case e1000_82541:
 640         case e1000_82541_rev_2:
 641             /* These controllers can't ack the 64-bit write when issuing the
 642              * reset, so use IO-mapping as a workaround to issue the reset */
 643             E1000_WRITE_REG_IO(hw, CTRL, (ctrl | E1000_CTRL_RST));
 644             break;
 645         case e1000_82545_rev_3:
 646         case e1000_82546_rev_3:
 647             /* Reset is performed on a shadow of the control register */
 648             ew32(CTRL_DUP, (ctrl | E1000_CTRL_RST));
 649             break;
 650         case e1000_ich8lan:
 651             if (!hw->phy_reset_disable &&
 652                 e1000_check_phy_reset_block(hw) == E1000_SUCCESS) {
 653                 /* e1000_ich8lan PHY HW reset requires MAC CORE reset
 654                  * at the same time to make sure the interface between
 655                  * MAC and the external PHY is reset.
 656                  */
 657                 ctrl |= E1000_CTRL_PHY_RST;
 658             }
 659
 660             e1000_get_software_flag(hw);
 661             ew32(CTRL, (ctrl | E1000_CTRL_RST));
 662             msleep(5);
 663             break;
 664         default:
 665             ew32(CTRL, (ctrl | E1000_CTRL_RST));
 666             break;
 667     }
 668
 669     /* After MAC reset, force reload of EEPROM to restore power-on settings to
 670      * device.  Later controllers reload the EEPROM automatically, so just wait
 671      * for reload to complete.
 672      */
 673     switch (hw->mac_type) {
 674         case e1000_82542_rev2_0:
 675         case e1000_82542_rev2_1:
 676         case e1000_82543:
 677         case e1000_82544:
 678             /* Wait for reset to complete */
 679             udelay(10);
 680             ctrl_ext = er32(CTRL_EXT);
 681             ctrl_ext |= E1000_CTRL_EXT_EE_RST;
 682             ew32(CTRL_EXT, ctrl_ext);
 683             E1000_WRITE_FLUSH();
 684             /* Wait for EEPROM reload */
 685             msleep(2);
 686             break;
 687         case e1000_82541:
 688         case e1000_82541_rev_2:
 689         case e1000_82547:
 690         case e1000_82547_rev_2:
 691             /* Wait for EEPROM reload */
 692             msleep(20);
 693             break;
 694         case e1000_82573:
 695             if (!e1000_is_onboard_nvm_eeprom(hw)) {
 696                 udelay(10);
 697                 ctrl_ext = er32(CTRL_EXT);
 698                 ctrl_ext |= E1000_CTRL_EXT_EE_RST;
 699                 ew32(CTRL_EXT, ctrl_ext);
 700                 E1000_WRITE_FLUSH();
 701             }
 702             /* fall through */
 703         default:
 704             /* Auto read done will delay 5ms or poll based on mac type */
 705             ret_val = e1000_get_auto_rd_done(hw);
 706             if (ret_val)
 707                 return ret_val;
 708             break;
 709     }
 710
 711     /* Disable HW ARPs on ASF enabled adapters */
 712     if (hw->mac_type >= e1000_82540 && hw->mac_type <= e1000_82547_rev_2) {
 713         manc = er32(MANC);
 714         manc &= ~(E1000_MANC_ARP_EN);
 715         ew32(MANC, manc);
 716     }
 717
 718     if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
 719         e1000_phy_init_script(hw);
 720
 721         /* Configure activity LED after PHY reset */
 722         led_ctrl = er32(LEDCTL);
 723         led_ctrl &= IGP_ACTIVITY_LED_MASK;
 724         led_ctrl |= (IGP_ACTIVITY_LED_ENABLE | IGP_LED3_MODE);
 725         ew32(LEDCTL, led_ctrl);
 726     }
 727
 728     /* Clear interrupt mask to stop board from generating interrupts */
 729     DEBUGOUT("Masking off all interrupts\n");
 730     ew32(IMC, 0xffffffff);
 731
 732     /* Clear any pending interrupt events. */
 733     icr = er32(ICR);
 734
 735     /* If MWI was previously enabled, reenable it. */
 736     if (hw->mac_type == e1000_82542_rev2_0) {
 737         if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE)
 738             e1000_pci_set_mwi(hw);
 739     }
 740
 741     if (hw->mac_type == e1000_ich8lan) {
 742         u32 kab = er32(KABGTXD);
 743         kab |= E1000_KABGTXD_BGSQLBIAS;
 744         ew32(KABGTXD, kab);
 745     }
 746
 747     return E1000_SUCCESS;
 748 }
 749
 750 /******************************************************************************
 751  *
 752  * Initialize a number of hardware-dependent bits
 753  *
 754  * hw: Struct containing variables accessed by shared code
 755  *
 756  * This function contains hardware limitation workarounds for PCI-E adapters
 757  *
 758  *****************************************************************************/
 759 static void e1000_initialize_hardware_bits(struct e1000_hw *hw)
 760 {
 761     if ((hw->mac_type >= e1000_82571) && (!hw->initialize_hw_bits_disable)) {
 762         /* Settings common to all PCI-express silicon */
 763         u32 reg_ctrl, reg_ctrl_ext;
 764         u32 reg_tarc0, reg_tarc1;
 765         u32 reg_tctl;
 766         u32 reg_txdctl, reg_txdctl1;
 767
 768         /* link autonegotiation/sync workarounds */
 769         reg_tarc0 = er32(TARC0);
 770         reg_tarc0 &= ~((1 << 30)|(1 << 29)|(1 << 28)|(1 << 27));
 771
 772         /* Enable not-done TX descriptor counting */
 773         reg_txdctl = er32(TXDCTL);
 774         reg_txdctl |= E1000_TXDCTL_COUNT_DESC;
 775         ew32(TXDCTL, reg_txdctl);
 776         reg_txdctl1 = er32(TXDCTL1);
 777         reg_txdctl1 |= E1000_TXDCTL_COUNT_DESC;
 778         ew32(TXDCTL1, reg_txdctl1);
 779
 780         switch (hw->mac_type) {
 781             case e1000_82571:
 782             case e1000_82572:
 783                 /* Clear PHY TX compatible mode bits */
 784                 reg_tarc1 = er32(TARC1);
 785                 reg_tarc1 &= ~((1 << 30)|(1 << 29));
 786
 787                 /* link autonegotiation/sync workarounds */
 788                 reg_tarc0 |= ((1 << 26)|(1 << 25)|(1 << 24)|(1 << 23));
 789
 790                 /* TX ring control fixes */
 791                 reg_tarc1 |= ((1 << 26)|(1 << 25)|(1 << 24));
 792
 793                 /* Multiple read bit is reversed polarity */
 794                 reg_tctl = er32(TCTL);
 795                 if (reg_tctl & E1000_TCTL_MULR)
 796                     reg_tarc1 &= ~(1 << 28);
 797                 else
 798                     reg_tarc1 |= (1 << 28);
 799
 800                 ew32(TARC1, reg_tarc1);
 801                 break;
 802             case e1000_82573:
 803                 reg_ctrl_ext = er32(CTRL_EXT);
 804                 reg_ctrl_ext &= ~(1 << 23);
 805                 reg_ctrl_ext |= (1 << 22);
 806
 807                 /* TX byte count fix */
 808                 reg_ctrl = er32(CTRL);
 809                 reg_ctrl &= ~(1 << 29);
 810
 811                 ew32(CTRL_EXT, reg_ctrl_ext);
 812                 ew32(CTRL, reg_ctrl);
 813                 break;
 814             case e1000_80003es2lan:
 815                 /* improve small packet performace for fiber/serdes */
 816                 if ((hw->media_type == e1000_media_type_fiber) ||
 817                     (hw->media_type == e1000_media_type_internal_serdes)) {
 818                     reg_tarc0 &= ~(1 << 20);
 819                 }
 820
 821                 /* Multiple read bit is reversed polarity */
 822                 reg_tctl = er32(TCTL);
 823                 reg_tarc1 = er32(TARC1);
 824                 if (reg_tctl & E1000_TCTL_MULR)
 825                     reg_tarc1 &= ~(1 << 28);
 826                 else
 827                     reg_tarc1 |= (1 << 28);
 828
 829                 ew32(TARC1, reg_tarc1);
 830                 break;
 831             case e1000_ich8lan:
 832                 /* Reduce concurrent DMA requests to 3 from 4 */
 833                 if ((hw->revision_id < 3) ||
 834                     ((hw->device_id != E1000_DEV_ID_ICH8_IGP_M_AMT) &&
 835                      (hw->device_id != E1000_DEV_ID_ICH8_IGP_M)))
 836                     reg_tarc0 |= ((1 << 29)|(1 << 28));
 837
 838                 reg_ctrl_ext = er32(CTRL_EXT);
 839                 reg_ctrl_ext |= (1 << 22);
 840                 ew32(CTRL_EXT, reg_ctrl_ext);
 841
 842                 /* workaround TX hang with TSO=on */
 843                 reg_tarc0 |= ((1 << 27)|(1 << 26)|(1 << 24)|(1 << 23));
 844
 845                 /* Multiple read bit is reversed polarity */
 846                 reg_tctl = er32(TCTL);
 847                 reg_tarc1 = er32(TARC1);
 848                 if (reg_tctl & E1000_TCTL_MULR)
 849                     reg_tarc1 &= ~(1 << 28);
 850                 else
 851                     reg_tarc1 |= (1 << 28);
 852
 853                 /* workaround TX hang with TSO=on */
 854                 reg_tarc1 |= ((1 << 30)|(1 << 26)|(1 << 24));
 855
 856                 ew32(TARC1, reg_tarc1);
 857                 break;
 858             default:
 859                 break;
 860         }
 861
 862         ew32(TARC0, reg_tarc0);
 863     }
 864 }
 865
 866 /******************************************************************************
 867  * Performs basic configuration of the adapter.
 868  *
 869  * hw - Struct containing variables accessed by shared code
 870  *
 871  * Assumes that the controller has previously been reset and is in a
 872  * post-reset uninitialized state. Initializes the receive address registers,
 873  * multicast table, and VLAN filter table. Calls routines to setup link
 874  * configuration and flow control settings. Clears all on-chip counters. Leaves
 875  * the transmit and receive units disabled and uninitialized.
 876  *****************************************************************************/
 877 s32 e1000_init_hw(struct e1000_hw *hw)
 878 {
 879     u32 ctrl;
 880     u32 i;
 881     s32 ret_val;
 882     u32 mta_size;
 883     u32 reg_data;
 884     u32 ctrl_ext;
 885
 886     DEBUGFUNC("e1000_init_hw");
 887
 888     /* force full DMA clock frequency for 10/100 on ICH8 A0-B0 */
 889     if ((hw->mac_type == e1000_ich8lan) &&
 890         ((hw->revision_id < 3) ||
 891          ((hw->device_id != E1000_DEV_ID_ICH8_IGP_M_AMT) &&
 892           (hw->device_id != E1000_DEV_ID_ICH8_IGP_M)))) {
 893             reg_data = er32(STATUS);
 894             reg_data &= ~0x80000000;
 895             ew32(STATUS, reg_data);
 896     }
 897
 898     /* Initialize Identification LED */
 899     ret_val = e1000_id_led_init(hw);
 900     if (ret_val) {
 901         DEBUGOUT("Error Initializing Identification LED\n");
 902         return ret_val;
 903     }
 904
 905     /* Set the media type and TBI compatibility */
 906     e1000_set_media_type(hw);
 907
 908     /* Must be called after e1000_set_media_type because media_type is used */
 909     e1000_initialize_hardware_bits(hw);
 910
 911     /* Disabling VLAN filtering. */
 912     DEBUGOUT("Initializing the IEEE VLAN\n");
 913     /* VET hardcoded to standard value and VFTA removed in ICH8 LAN */
 914     if (hw->mac_type != e1000_ich8lan) {
 915         if (hw->mac_type < e1000_82545_rev_3)
 916             ew32(VET, 0);
 917         e1000_clear_vfta(hw);
 918     }
 919
 920     /* For 82542 (rev 2.0), disable MWI and put the receiver into reset */
 921     if (hw->mac_type == e1000_82542_rev2_0) {
 922         DEBUGOUT("Disabling MWI on 82542 rev 2.0\n");
 923         e1000_pci_clear_mwi(hw);
 924         ew32(RCTL, E1000_RCTL_RST);
 925         E1000_WRITE_FLUSH();
 926         msleep(5);
 927     }
 928
 929     /* Setup the receive address. This involves initializing all of the Receive
 930      * Address Registers (RARs 0 - 15).
 931      */
 932     e1000_init_rx_addrs(hw);
 933
 934     /* For 82542 (rev 2.0), take the receiver out of reset and enable MWI */
 935     if (hw->mac_type == e1000_82542_rev2_0) {
 936         ew32(RCTL, 0);
 937         E1000_WRITE_FLUSH();
 938         msleep(1);
 939         if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE)
 940             e1000_pci_set_mwi(hw);
 941     }
 942
 943     /* Zero out the Multicast HASH table */
 944     DEBUGOUT("Zeroing the MTA\n");
 945     mta_size = E1000_MC_TBL_SIZE;
 946     if (hw->mac_type == e1000_ich8lan)
 947         mta_size = E1000_MC_TBL_SIZE_ICH8LAN;
 948     for (i = 0; i < mta_size; i++) {
 949         E1000_WRITE_REG_ARRAY(hw, MTA, i, 0);
 950         /* use write flush to prevent Memory Write Block (MWB) from
 951          * occuring when accessing our register space */
 952         E1000_WRITE_FLUSH();
 953     }
 954
 955     /* Set the PCI priority bit correctly in the CTRL register.  This
 956      * determines if the adapter gives priority to receives, or if it
 957      * gives equal priority to transmits and receives.  Valid only on
 958      * 82542 and 82543 silicon.
 959      */
 960     if (hw->dma_fairness && hw->mac_type <= e1000_82543) {
 961         ctrl = er32(CTRL);
 962         ew32(CTRL, ctrl | E1000_CTRL_PRIOR);
 963     }
 964
 965     switch (hw->mac_type) {
 966     case e1000_82545_rev_3:
 967     case e1000_82546_rev_3:
 968         break;
 969     default:
 970         /* Workaround for PCI-X problem when BIOS sets MMRBC incorrectly. */
 971         if (hw->bus_type == e1000_bus_type_pcix && e1000_pcix_get_mmrbc(hw) > 2048)
 972                 e1000_pcix_set_mmrbc(hw, 2048);
 973         break;
 974     }
 975
 976     /* More time needed for PHY to initialize */
 977     if (hw->mac_type == e1000_ich8lan)
 978         msleep(15);
 979
 980     /* Call a subroutine to configure the link and setup flow control. */
 981     ret_val = e1000_setup_link(hw);
 982
 983     /* Set the transmit descriptor write-back policy */
 984     if (hw->mac_type > e1000_82544) {
 985         ctrl = er32(TXDCTL);
 986         ctrl = (ctrl & ~E1000_TXDCTL_WTHRESH) | E1000_TXDCTL_FULL_TX_DESC_WB;
 987         ew32(TXDCTL, ctrl);
 988     }
 989
 990     if (hw->mac_type == e1000_82573) {
 991         e1000_enable_tx_pkt_filtering(hw);
 992     }
 993
 994     switch (hw->mac_type) {
 995     default:
 996         break;
 997     case e1000_80003es2lan:
 998         /* Enable retransmit on late collisions */
 999         reg_data = er32(TCTL);
1000         reg_data |= E1000_TCTL_RTLC;
1001         ew32(TCTL, reg_data);
1002
1003         /* Configure Gigabit Carry Extend Padding */
1004         reg_data = er32(TCTL_EXT);
1005         reg_data &= ~E1000_TCTL_EXT_GCEX_MASK;
1006         reg_data |= DEFAULT_80003ES2LAN_TCTL_EXT_GCEX;
1007         ew32(TCTL_EXT, reg_data);
1008
1009         /* Configure Transmit Inter-Packet Gap */
1010         reg_data = er32(TIPG);
1011         reg_data &= ~E1000_TIPG_IPGT_MASK;
1012         reg_data |= DEFAULT_80003ES2LAN_TIPG_IPGT_1000;
1013         ew32(TIPG, reg_data);
1014
1015         reg_data = E1000_READ_REG_ARRAY(hw, FFLT, 0x0001);
1016         reg_data &= ~0x00100000;
1017         E1000_WRITE_REG_ARRAY(hw, FFLT, 0x0001, reg_data);
1018         /* Fall through */
1019     case e1000_82571:
1020     case e1000_82572:
1021     case e1000_ich8lan:
1022         ctrl = er32(TXDCTL1);
1023         ctrl = (ctrl & ~E1000_TXDCTL_WTHRESH) | E1000_TXDCTL_FULL_TX_DESC_WB;
1024         ew32(TXDCTL1, ctrl);
1025         break;
1026     }
1027
1028
1029     if (hw->mac_type == e1000_82573) {
1030         u32 gcr = er32(GCR);
1031         gcr |= E1000_GCR_L1_ACT_WITHOUT_L0S_RX;
1032         ew32(GCR, gcr);
1033     }
1034
1035     /* Clear all of the statistics registers (clear on read).  It is
1036      * important that we do this after we have tried to establish link
1037      * because the symbol error count will increment wildly if there
1038      * is no link.
1039      */
1040     e1000_clear_hw_cntrs(hw);
1041
1042     /* ICH8 No-snoop bits are opposite polarity.
1043      * Set to snoop by default after reset. */
1044     if (hw->mac_type == e1000_ich8lan)
1045         e1000_set_pci_ex_no_snoop(hw, PCI_EX_82566_SNOOP_ALL);
1046
1047     if (hw->device_id == E1000_DEV_ID_82546GB_QUAD_COPPER ||
1048         hw->device_id == E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3) {
1049         ctrl_ext = er32(CTRL_EXT);
1050         /* Relaxed ordering must be disabled to avoid a parity
1051          * error crash in a PCI slot. */
1052         ctrl_ext |= E1000_CTRL_EXT_RO_DIS;
1053         ew32(CTRL_EXT, ctrl_ext);
1054     }
1055
1056     return ret_val;
1057 }
1058
1059 /******************************************************************************
1060  * Adjust SERDES output amplitude based on EEPROM setting.
1061  *
1062  * hw - Struct containing variables accessed by shared code.
1063  *****************************************************************************/
1064 static s32 e1000_adjust_serdes_amplitude(struct e1000_hw *hw)
1065 {
1066     u16 eeprom_data;
1067     s32  ret_val;
1068
1069     DEBUGFUNC("e1000_adjust_serdes_amplitude");
1070
1071     if (hw->media_type != e1000_media_type_internal_serdes)
1072         return E1000_SUCCESS;
1073
1074     switch (hw->mac_type) {
1075     case e1000_82545_rev_3:
1076     case e1000_82546_rev_3:
1077         break;
1078     default:
1079         return E1000_SUCCESS;
1080     }
1081
1082     ret_val = e1000_read_eeprom(hw, EEPROM_SERDES_AMPLITUDE, 1, &eeprom_data);
1083     if (ret_val) {
1084         return ret_val;
1085     }
1086
1087     if (eeprom_data != EEPROM_RESERVED_WORD) {
1088         /* Adjust SERDES output amplitude only. */
1089         eeprom_data &= EEPROM_SERDES_AMPLITUDE_MASK;
1090         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_EXT_CTRL, eeprom_data);
1091         if (ret_val)
1092             return ret_val;
1093     }
1094
1095     return E1000_SUCCESS;
1096 }
1097
1098 /******************************************************************************
1099  * Configures flow control and link settings.
1100  *
1101  * hw - Struct containing variables accessed by shared code
1102  *
1103  * Determines which flow control settings to use. Calls the apropriate media-
1104  * specific link configuration function. Configures the flow control settings.
1105  * Assuming the adapter has a valid link partner, a valid link should be
1106  * established. Assumes the hardware has previously been reset and the
1107  * transmitter and receiver are not enabled.
1108  *****************************************************************************/
1109 s32 e1000_setup_link(struct e1000_hw *hw)
1110 {
1111     u32 ctrl_ext;
1112     s32 ret_val;
1113     u16 eeprom_data;
1114
1115     DEBUGFUNC("e1000_setup_link");
1116
1117     /* In the case of the phy reset being blocked, we already have a link.
1118      * We do not have to set it up again. */
1119     if (e1000_check_phy_reset_block(hw))
1120         return E1000_SUCCESS;
1121
1122     /* Read and store word 0x0F of the EEPROM. This word contains bits
1123      * that determine the hardware's default PAUSE (flow control) mode,
1124      * a bit that determines whether the HW defaults to enabling or
1125      * disabling auto-negotiation, and the direction of the
1126      * SW defined pins. If there is no SW over-ride of the flow
1127      * control setting, then the variable hw->fc will
1128      * be initialized based on a value in the EEPROM.
1129      */
1130     if (hw->fc == E1000_FC_DEFAULT) {
1131         switch (hw->mac_type) {
1132         case e1000_ich8lan:
1133         case e1000_82573:
1134             hw->fc = E1000_FC_FULL;
1135             break;
1136         default:
1137             ret_val = e1000_read_eeprom(hw, EEPROM_INIT_CONTROL2_REG,
1138                                         1, &eeprom_data);
1139             if (ret_val) {
1140                 DEBUGOUT("EEPROM Read Error\n");
1141                 return -E1000_ERR_EEPROM;
1142             }
1143             if ((eeprom_data & EEPROM_WORD0F_PAUSE_MASK) == 0)
1144                 hw->fc = E1000_FC_NONE;
1145             else if ((eeprom_data & EEPROM_WORD0F_PAUSE_MASK) ==
1146                     EEPROM_WORD0F_ASM_DIR)
1147                 hw->fc = E1000_FC_TX_PAUSE;
1148             else
1149                 hw->fc = E1000_FC_FULL;
1150             break;
1151         }
1152     }
1153
1154     /* We want to save off the original Flow Control configuration just
1155      * in case we get disconnected and then reconnected into a different
1156      * hub or switch with different Flow Control capabilities.
1157      */
1158     if (hw->mac_type == e1000_82542_rev2_0)
1159         hw->fc &= (~E1000_FC_TX_PAUSE);
1160
1161     if ((hw->mac_type < e1000_82543) && (hw->report_tx_early == 1))
1162         hw->fc &= (~E1000_FC_RX_PAUSE);
1163
1164     hw->original_fc = hw->fc;
1165
1166     DEBUGOUT1("After fix-ups FlowControl is now = %x\n", hw->fc);
1167
1168     /* Take the 4 bits from EEPROM word 0x0F that determine the initial
1169      * polarity value for the SW controlled pins, and setup the
1170      * Extended Device Control reg with that info.
1171      * This is needed because one of the SW controlled pins is used for
1172      * signal detection.  So this should be done before e1000_setup_pcs_link()
1173      * or e1000_phy_setup() is called.
1174      */
1175     if (hw->mac_type == e1000_82543) {
1176         ret_val = e1000_read_eeprom(hw, EEPROM_INIT_CONTROL2_REG,
1177                                     1, &eeprom_data);
1178         if (ret_val) {
1179             DEBUGOUT("EEPROM Read Error\n");
1180             return -E1000_ERR_EEPROM;
1181         }
1182         ctrl_ext = ((eeprom_data & EEPROM_WORD0F_SWPDIO_EXT) <<
1183                     SWDPIO__EXT_SHIFT);
1184         ew32(CTRL_EXT, ctrl_ext);
1185     }
1186
1187     /* Call the necessary subroutine to configure the link. */
1188     ret_val = (hw->media_type == e1000_media_type_copper) ?
1189               e1000_setup_copper_link(hw) :
1190               e1000_setup_fiber_serdes_link(hw);
1191
1192     /* Initialize the flow control address, type, and PAUSE timer
1193      * registers to their default values.  This is done even if flow
1194      * control is disabled, because it does not hurt anything to
1195      * initialize these registers.
1196      */
1197     DEBUGOUT("Initializing the Flow Control address, type and timer regs\n");
1198
1199     /* FCAL/H and FCT are hardcoded to standard values in e1000_ich8lan. */
1200     if (hw->mac_type != e1000_ich8lan) {
1201         ew32(FCT, FLOW_CONTROL_TYPE);
1202         ew32(FCAH, FLOW_CONTROL_ADDRESS_HIGH);
1203         ew32(FCAL, FLOW_CONTROL_ADDRESS_LOW);
1204     }
1205
1206     ew32(FCTTV, hw->fc_pause_time);
1207
1208     /* Set the flow control receive threshold registers.  Normally,
1209      * these registers will be set to a default threshold that may be
1210      * adjusted later by the driver's runtime code.  However, if the
1211      * ability to transmit pause frames in not enabled, then these
1212      * registers will be set to 0.
1213      */
1214     if (!(hw->fc & E1000_FC_TX_PAUSE)) {
1215         ew32(FCRTL, 0);
1216         ew32(FCRTH, 0);
1217     } else {
1218         /* We need to set up the Receive Threshold high and low water marks
1219          * as well as (optionally) enabling the transmission of XON frames.
1220          */
1221         if (hw->fc_send_xon) {
1222             ew32(FCRTL, (hw->fc_low_water | E1000_FCRTL_XONE));
1223             ew32(FCRTH, hw->fc_high_water);
1224         } else {
1225             ew32(FCRTL, hw->fc_low_water);
1226             ew32(FCRTH, hw->fc_high_water);
1227         }
1228     }
1229     return ret_val;
1230 }
1231
1232 /******************************************************************************
1233  * Sets up link for a fiber based or serdes based adapter
1234  *
1235  * hw - Struct containing variables accessed by shared code
1236  *
1237  * Manipulates Physical Coding Sublayer functions in order to configure
1238  * link. Assumes the hardware has been previously reset and the transmitter
1239  * and receiver are not enabled.
1240  *****************************************************************************/
1241 static s32 e1000_setup_fiber_serdes_link(struct e1000_hw *hw)
1242 {
1243     u32 ctrl;
1244     u32 status;
1245     u32 txcw = 0;
1246     u32 i;
1247     u32 signal = 0;
1248     s32 ret_val;
1249
1250     DEBUGFUNC("e1000_setup_fiber_serdes_link");
1251
1252     /* On 82571 and 82572 Fiber connections, SerDes loopback mode persists
1253      * until explicitly turned off or a power cycle is performed.  A read to
1254      * the register does not indicate its status.  Therefore, we ensure
1255      * loopback mode is disabled during initialization.
1256      */
1257     if (hw->mac_type == e1000_82571 || hw->mac_type == e1000_82572)
1258         ew32(SCTL, E1000_DISABLE_SERDES_LOOPBACK);
1259
1260     /* On adapters with a MAC newer than 82544, SWDP 1 will be
1261      * set when the optics detect a signal. On older adapters, it will be
1262      * cleared when there is a signal.  This applies to fiber media only.
1263      * If we're on serdes media, adjust the output amplitude to value
1264      * set in the EEPROM.
1265      */
1266     ctrl = er32(CTRL);
1267     if (hw->media_type == e1000_media_type_fiber)
1268         signal = (hw->mac_type > e1000_82544) ? E1000_CTRL_SWDPIN1 : 0;
1269
1270     ret_val = e1000_adjust_serdes_amplitude(hw);
1271     if (ret_val)
1272         return ret_val;
1273
1274     /* Take the link out of reset */
1275     ctrl &= ~(E1000_CTRL_LRST);
1276
1277     /* Adjust VCO speed to improve BER performance */
1278     ret_val = e1000_set_vco_speed(hw);
1279     if (ret_val)
1280         return ret_val;
1281
1282     e1000_config_collision_dist(hw);
1283
1284     /* Check for a software override of the flow control settings, and setup
1285      * the device accordingly.  If auto-negotiation is enabled, then software
1286      * will have to set the "PAUSE" bits to the correct value in the Tranmsit
1287      * Config Word Register (TXCW) and re-start auto-negotiation.  However, if
1288      * auto-negotiation is disabled, then software will have to manually
1289      * configure the two flow control enable bits in the CTRL register.
1290      *
1291      * The possible values of the "fc" parameter are:
1292      *      0:  Flow control is completely disabled
1293      *      1:  Rx flow control is enabled (we can receive pause frames, but
1294      *          not send pause frames).
1295      *      2:  Tx flow control is enabled (we can send pause frames but we do
1296      *          not support receiving pause frames).
1297      *      3:  Both Rx and TX flow control (symmetric) are enabled.
1298      */
1299     switch (hw->fc) {
1300     case E1000_FC_NONE:
1301         /* Flow control is completely disabled by a software over-ride. */
1302         txcw = (E1000_TXCW_ANE | E1000_TXCW_FD);
1303         break;
1304     case E1000_FC_RX_PAUSE:
1305         /* RX Flow control is enabled and TX Flow control is disabled by a
1306          * software over-ride. Since there really isn't a way to advertise
1307          * that we are capable of RX Pause ONLY, we will advertise that we
1308          * support both symmetric and asymmetric RX PAUSE. Later, we will
1309          *  disable the adapter's ability to send PAUSE frames.
1310          */
1311         txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
1312         break;
1313     case E1000_FC_TX_PAUSE:
1314         /* TX Flow control is enabled, and RX Flow control is disabled, by a
1315          * software over-ride.
1316          */
1317         txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_ASM_DIR);
1318         break;
1319     case E1000_FC_FULL:
1320         /* Flow control (both RX and TX) is enabled by a software over-ride. */
1321         txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
1322         break;
1323     default:
1324         DEBUGOUT("Flow control param set incorrectly\n");
1325         return -E1000_ERR_CONFIG;
1326         break;
1327     }
1328
1329     /* Since auto-negotiation is enabled, take the link out of reset (the link
1330      * will be in reset, because we previously reset the chip). This will
1331      * restart auto-negotiation.  If auto-neogtiation is successful then the
1332      * link-up status bit will be set and the flow control enable bits (RFCE
1333      * and TFCE) will be set according to their negotiated value.
1334      */
1335     DEBUGOUT("Auto-negotiation enabled\n");
1336
1337     ew32(TXCW, txcw);
1338     ew32(CTRL, ctrl);
1339     E1000_WRITE_FLUSH();
1340
1341     hw->txcw = txcw;
1342     msleep(1);
1343
1344     /* If we have a signal (the cable is plugged in) then poll for a "Link-Up"
1345      * indication in the Device Status Register.  Time-out if a link isn't
1346      * seen in 500 milliseconds seconds (Auto-negotiation should complete in
1347      * less than 500 milliseconds even if the other end is doing it in SW).
1348      * For internal serdes, we just assume a signal is present, then poll.
1349      */
1350     if (hw->media_type == e1000_media_type_internal_serdes ||
1351        (er32(CTRL) & E1000_CTRL_SWDPIN1) == signal) {
1352         DEBUGOUT("Looking for Link\n");
1353         for (i = 0; i < (LINK_UP_TIMEOUT / 10); i++) {
1354             msleep(10);
1355             status = er32(STATUS);
1356             if (status & E1000_STATUS_LU) break;
1357         }
1358         if (i == (LINK_UP_TIMEOUT / 10)) {
1359             DEBUGOUT("Never got a valid link from auto-neg!!!\n");
1360             hw->autoneg_failed = 1;
1361             /* AutoNeg failed to achieve a link, so we'll call
1362              * e1000_check_for_link. This routine will force the link up if
1363              * we detect a signal. This will allow us to communicate with
1364              * non-autonegotiating link partners.
1365              */
1366             ret_val = e1000_check_for_link(hw);
1367             if (ret_val) {
1368                 DEBUGOUT("Error while checking for link\n");
1369                 return ret_val;
1370             }
1371             hw->autoneg_failed = 0;
1372         } else {
1373             hw->autoneg_failed = 0;
1374             DEBUGOUT("Valid Link Found\n");
1375         }
1376     } else {
1377         DEBUGOUT("No Signal Detected\n");
1378     }
1379     return E1000_SUCCESS;
1380 }
1381
1382 /******************************************************************************
1383 * Make sure we have a valid PHY and change PHY mode before link setup.
1384 *
1385 * hw - Struct containing variables accessed by shared code
1386 ******************************************************************************/
1387 static s32 e1000_copper_link_preconfig(struct e1000_hw *hw)
1388 {
1389     u32 ctrl;
1390     s32 ret_val;
1391     u16 phy_data;
1392
1393     DEBUGFUNC("e1000_copper_link_preconfig");
1394
1395     ctrl = er32(CTRL);
1396     /* With 82543, we need to force speed and duplex on the MAC equal to what
1397      * the PHY speed and duplex configuration is. In addition, we need to
1398      * perform a hardware reset on the PHY to take it out of reset.
1399      */
1400     if (hw->mac_type > e1000_82543) {
1401         ctrl |= E1000_CTRL_SLU;
1402         ctrl &= ~(E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1403         ew32(CTRL, ctrl);
1404     } else {
1405         ctrl |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX | E1000_CTRL_SLU);
1406         ew32(CTRL, ctrl);
1407         ret_val = e1000_phy_hw_reset(hw);
1408         if (ret_val)
1409             return ret_val;
1410     }
1411
1412     /* Make sure we have a valid PHY */
1413     ret_val = e1000_detect_gig_phy(hw);
1414     if (ret_val) {
1415         DEBUGOUT("Error, did not detect valid phy.\n");
1416         return ret_val;
1417     }
1418     DEBUGOUT1("Phy ID = %x \n", hw->phy_id);
1419
1420     /* Set PHY to class A mode (if necessary) */
1421     ret_val = e1000_set_phy_mode(hw);
1422     if (ret_val)
1423         return ret_val;
1424
1425     if ((hw->mac_type == e1000_82545_rev_3) ||
1426        (hw->mac_type == e1000_82546_rev_3)) {
1427         ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1428         phy_data |= 0x00000008;
1429         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1430     }
1431
1432     if (hw->mac_type <= e1000_82543 ||
1433         hw->mac_type == e1000_82541 || hw->mac_type == e1000_82547 ||
1434         hw->mac_type == e1000_82541_rev_2 || hw->mac_type == e1000_82547_rev_2)
1435         hw->phy_reset_disable = false;
1436
1437    return E1000_SUCCESS;
1438 }
1439
1440
1441 /********************************************************************
1442 * Copper link setup for e1000_phy_igp series.
1443 *
1444 * hw - Struct containing variables accessed by shared code
1445 *********************************************************************/
1446 static s32 e1000_copper_link_igp_setup(struct e1000_hw *hw)
1447 {
1448     u32 led_ctrl;
1449     s32 ret_val;
1450     u16 phy_data;
1451
1452     DEBUGFUNC("e1000_copper_link_igp_setup");
1453
1454     if (hw->phy_reset_disable)
1455         return E1000_SUCCESS;
1456
1457     ret_val = e1000_phy_reset(hw);
1458     if (ret_val) {
1459         DEBUGOUT("Error Resetting the PHY\n");
1460         return ret_val;
1461     }
1462
1463     /* Wait 15ms for MAC to configure PHY from eeprom settings */
1464     msleep(15);
1465     if (hw->mac_type != e1000_ich8lan) {
1466     /* Configure activity LED after PHY reset */
1467     led_ctrl = er32(LEDCTL);
1468     led_ctrl &= IGP_ACTIVITY_LED_MASK;
1469     led_ctrl |= (IGP_ACTIVITY_LED_ENABLE | IGP_LED3_MODE);
1470     ew32(LEDCTL, led_ctrl);
1471     }
1472
1473     /* The NVM settings will configure LPLU in D3 for IGP2 and IGP3 PHYs */
1474     if (hw->phy_type == e1000_phy_igp) {
1475         /* disable lplu d3 during driver init */
1476         ret_val = e1000_set_d3_lplu_state(hw, false);
1477         if (ret_val) {
1478             DEBUGOUT("Error Disabling LPLU D3\n");
1479             return ret_val;
1480         }
1481     }
1482
1483     /* disable lplu d0 during driver init */
1484     ret_val = e1000_set_d0_lplu_state(hw, false);
1485     if (ret_val) {
1486         DEBUGOUT("Error Disabling LPLU D0\n");
1487         return ret_val;
1488     }
1489     /* Configure mdi-mdix settings */
1490     ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, &phy_data);
1491     if (ret_val)
1492         return ret_val;
1493
1494     if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
1495         hw->dsp_config_state = e1000_dsp_config_disabled;
1496         /* Force MDI for earlier revs of the IGP PHY */
1497         phy_data &= ~(IGP01E1000_PSCR_AUTO_MDIX | IGP01E1000_PSCR_FORCE_MDI_MDIX);
1498         hw->mdix = 1;
1499
1500     } else {
1501         hw->dsp_config_state = e1000_dsp_config_enabled;
1502         phy_data &= ~IGP01E1000_PSCR_AUTO_MDIX;
1503
1504         switch (hw->mdix) {
1505         case 1:
1506             phy_data &= ~IGP01E1000_PSCR_FORCE_MDI_MDIX;
1507             break;
1508         case 2:
1509             phy_data |= IGP01E1000_PSCR_FORCE_MDI_MDIX;
1510             break;
1511         case 0:
1512         default:
1513             phy_data |= IGP01E1000_PSCR_AUTO_MDIX;
1514             break;
1515         }
1516     }
1517     ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, phy_data);
1518     if (ret_val)
1519         return ret_val;
1520
1521     /* set auto-master slave resolution settings */
1522     if (hw->autoneg) {
1523         e1000_ms_type phy_ms_setting = hw->master_slave;
1524
1525         if (hw->ffe_config_state == e1000_ffe_config_active)
1526             hw->ffe_config_state = e1000_ffe_config_enabled;
1527
1528         if (hw->dsp_config_state == e1000_dsp_config_activated)
1529             hw->dsp_config_state = e1000_dsp_config_enabled;
1530
1531         /* when autonegotiation advertisment is only 1000Mbps then we
1532           * should disable SmartSpeed and enable Auto MasterSlave
1533           * resolution as hardware default. */
1534         if (hw->autoneg_advertised == ADVERTISE_1000_FULL) {
1535             /* Disable SmartSpeed */
1536             ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
1537                                          &phy_data);
1538             if (ret_val)
1539                 return ret_val;
1540             phy_data &= ~IGP01E1000_PSCFR_SMART_SPEED;
1541             ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
1542                                           phy_data);
1543             if (ret_val)
1544                 return ret_val;
1545             /* Set auto Master/Slave resolution process */
1546             ret_val = e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_data);
1547             if (ret_val)
1548                 return ret_val;
1549             phy_data &= ~CR_1000T_MS_ENABLE;
1550             ret_val = e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_data);
1551             if (ret_val)
1552                 return ret_val;
1553         }
1554
1555         ret_val = e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_data);
1556         if (ret_val)
1557             return ret_val;
1558
1559         /* load defaults for future use */
1560         hw->original_master_slave = (phy_data & CR_1000T_MS_ENABLE) ?
1561                                         ((phy_data & CR_1000T_MS_VALUE) ?
1562                                          e1000_ms_force_master :
1563                                          e1000_ms_force_slave) :
1564                                          e1000_ms_auto;
1565
1566         switch (phy_ms_setting) {
1567         case e1000_ms_force_master:
1568             phy_data |= (CR_1000T_MS_ENABLE | CR_1000T_MS_VALUE);
1569             break;
1570         case e1000_ms_force_slave:
1571             phy_data |= CR_1000T_MS_ENABLE;
1572             phy_data &= ~(CR_1000T_MS_VALUE);
1573             break;
1574         case e1000_ms_auto:
1575             phy_data &= ~CR_1000T_MS_ENABLE;
1576             default:
1577             break;
1578         }
1579         ret_val = e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_data);
1580         if (ret_val)
1581             return ret_val;
1582     }
1583
1584     return E1000_SUCCESS;
1585 }
1586
1587 /********************************************************************
1588 * Copper link setup for e1000_phy_gg82563 series.
1589 *
1590 * hw - Struct containing variables accessed by shared code
1591 *********************************************************************/
1592 static s32 e1000_copper_link_ggp_setup(struct e1000_hw *hw)
1593 {
1594     s32 ret_val;
1595     u16 phy_data;
1596     u32 reg_data;
1597
1598     DEBUGFUNC("e1000_copper_link_ggp_setup");
1599
1600     if (!hw->phy_reset_disable) {
1601
1602         /* Enable CRS on TX for half-duplex operation. */
1603         ret_val = e1000_read_phy_reg(hw, GG82563_PHY_MAC_SPEC_CTRL,
1604                                      &phy_data);
1605         if (ret_val)
1606             return ret_val;
1607
1608         phy_data |= GG82563_MSCR_ASSERT_CRS_ON_TX;
1609         /* Use 25MHz for both link down and 1000BASE-T for Tx clock */
1610         phy_data |= GG82563_MSCR_TX_CLK_1000MBPS_25MHZ;
1611
1612         ret_val = e1000_write_phy_reg(hw, GG82563_PHY_MAC_SPEC_CTRL,
1613                                       phy_data);
1614         if (ret_val)
1615             return ret_val;
1616
1617         /* Options:
1618          *   MDI/MDI-X = 0 (default)
1619          *   0 - Auto for all speeds
1620          *   1 - MDI mode
1621          *   2 - MDI-X mode
1622          *   3 - Auto for 1000Base-T only (MDI-X for 10/100Base-T modes)
1623          */
1624         ret_val = e1000_read_phy_reg(hw, GG82563_PHY_SPEC_CTRL, &phy_data);
1625         if (ret_val)
1626             return ret_val;
1627
1628         phy_data &= ~GG82563_PSCR_CROSSOVER_MODE_MASK;
1629
1630         switch (hw->mdix) {
1631         case 1:
1632             phy_data |= GG82563_PSCR_CROSSOVER_MODE_MDI;
1633             break;
1634         case 2:
1635             phy_data |= GG82563_PSCR_CROSSOVER_MODE_MDIX;
1636             break;
1637         case 0:
1638         default:
1639             phy_data |= GG82563_PSCR_CROSSOVER_MODE_AUTO;
1640             break;
1641         }
1642
1643         /* Options:
1644          *   disable_polarity_correction = 0 (default)
1645          *       Automatic Correction for Reversed Cable Polarity
1646          *   0 - Disabled
1647          *   1 - Enabled
1648          */
1649         phy_data &= ~GG82563_PSCR_POLARITY_REVERSAL_DISABLE;
1650         if (hw->disable_polarity_correction == 1)
1651             phy_data |= GG82563_PSCR_POLARITY_REVERSAL_DISABLE;
1652         ret_val = e1000_write_phy_reg(hw, GG82563_PHY_SPEC_CTRL, phy_data);
1653
1654         if (ret_val)
1655             return ret_val;
1656
1657         /* SW Reset the PHY so all changes take effect */
1658         ret_val = e1000_phy_reset(hw);
1659         if (ret_val) {
1660             DEBUGOUT("Error Resetting the PHY\n");
1661             return ret_val;
1662         }
1663     } /* phy_reset_disable */
1664
1665     if (hw->mac_type == e1000_80003es2lan) {
1666         /* Bypass RX and TX FIFO's */
1667         ret_val = e1000_write_kmrn_reg(hw, E1000_KUMCTRLSTA_OFFSET_FIFO_CTRL,
1668                                        E1000_KUMCTRLSTA_FIFO_CTRL_RX_BYPASS |
1669                                        E1000_KUMCTRLSTA_FIFO_CTRL_TX_BYPASS);
1670         if (ret_val)
1671             return ret_val;
1672
1673         ret_val = e1000_read_phy_reg(hw, GG82563_PHY_SPEC_CTRL_2, &phy_data);
1674         if (ret_val)
1675             return ret_val;
1676
1677         phy_data &= ~GG82563_PSCR2_REVERSE_AUTO_NEG;
1678         ret_val = e1000_write_phy_reg(hw, GG82563_PHY_SPEC_CTRL_2, phy_data);
1679
1680         if (ret_val)
1681             return ret_val;
1682
1683         reg_data = er32(CTRL_EXT);
1684         reg_data &= ~(E1000_CTRL_EXT_LINK_MODE_MASK);
1685         ew32(CTRL_EXT, reg_data);
1686
1687         ret_val = e1000_read_phy_reg(hw, GG82563_PHY_PWR_MGMT_CTRL,
1688                                           &phy_data);
1689         if (ret_val)
1690             return ret_val;
1691
1692         /* Do not init these registers when the HW is in IAMT mode, since the
1693          * firmware will have already initialized them.  We only initialize
1694          * them if the HW is not in IAMT mode.
1695          */
1696         if (!e1000_check_mng_mode(hw)) {
1697             /* Enable Electrical Idle on the PHY */
1698             phy_data |= GG82563_PMCR_ENABLE_ELECTRICAL_IDLE;
1699             ret_val = e1000_write_phy_reg(hw, GG82563_PHY_PWR_MGMT_CTRL,
1700                                           phy_data);
1701             if (ret_val)
1702                 return ret_val;
1703
1704             ret_val = e1000_read_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL,
1705                                          &phy_data);
1706             if (ret_val)
1707                 return ret_val;
1708
1709             phy_data &= ~GG82563_KMCR_PASS_FALSE_CARRIER;
1710             ret_val = e1000_write_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL,
1711                                           phy_data);
1712
1713             if (ret_val)
1714                 return ret_val;
1715         }
1716
1717         /* Workaround: Disable padding in Kumeran interface in the MAC
1718          * and in the PHY to avoid CRC errors.
1719          */
1720         ret_val = e1000_read_phy_reg(hw, GG82563_PHY_INBAND_CTRL,
1721                                      &phy_data);
1722         if (ret_val)
1723             return ret_val;
1724         phy_data |= GG82563_ICR_DIS_PADDING;
1725         ret_val = e1000_write_phy_reg(hw, GG82563_PHY_INBAND_CTRL,
1726                                       phy_data);
1727         if (ret_val)
1728             return ret_val;
1729     }
1730
1731     return E1000_SUCCESS;
1732 }
1733
1734 /********************************************************************
1735 * Copper link setup for e1000_phy_m88 series.
1736 *
1737 * hw - Struct containing variables accessed by shared code
1738 *********************************************************************/
1739 static s32 e1000_copper_link_mgp_setup(struct e1000_hw *hw)
1740 {
1741     s32 ret_val;
1742     u16 phy_data;
1743
1744     DEBUGFUNC("e1000_copper_link_mgp_setup");
1745
1746     if (hw->phy_reset_disable)
1747         return E1000_SUCCESS;
1748
1749     /* Enable CRS on TX. This must be set for half-duplex operation. */
1750     ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1751     if (ret_val)
1752         return ret_val;
1753
1754     phy_data |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
1755
1756     /* Options:
1757      *   MDI/MDI-X = 0 (default)
1758      *   0 - Auto for all speeds
1759      *   1 - MDI mode
1760      *   2 - MDI-X mode
1761      *   3 - Auto for 1000Base-T only (MDI-X for 10/100Base-T modes)
1762      */
1763     phy_data &= ~M88E1000_PSCR_AUTO_X_MODE;
1764
1765     switch (hw->mdix) {
1766     case 1:
1767         phy_data |= M88E1000_PSCR_MDI_MANUAL_MODE;
1768         break;
1769     case 2:
1770         phy_data |= M88E1000_PSCR_MDIX_MANUAL_MODE;
1771         break;
1772     case 3:
1773         phy_data |= M88E1000_PSCR_AUTO_X_1000T;
1774         break;
1775     case 0:
1776     default:
1777         phy_data |= M88E1000_PSCR_AUTO_X_MODE;
1778         break;
1779     }
1780
1781     /* Options:
1782      *   disable_polarity_correction = 0 (default)
1783      *       Automatic Correction for Reversed Cable Polarity
1784      *   0 - Disabled
1785      *   1 - Enabled
1786      */
1787     phy_data &= ~M88E1000_PSCR_POLARITY_REVERSAL;
1788     if (hw->disable_polarity_correction == 1)
1789         phy_data |= M88E1000_PSCR_POLARITY_REVERSAL;
1790     ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1791     if (ret_val)
1792         return ret_val;
1793
1794     if (hw->phy_revision < M88E1011_I_REV_4) {
1795         /* Force TX_CLK in the Extended PHY Specific Control Register
1796          * to 25MHz clock.
1797          */
1798         ret_val = e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_data);
1799         if (ret_val)
1800             return ret_val;
1801
1802         phy_data |= M88E1000_EPSCR_TX_CLK_25;
1803
1804         if ((hw->phy_revision == E1000_REVISION_2) &&
1805             (hw->phy_id == M88E1111_I_PHY_ID)) {
1806             /* Vidalia Phy, set the downshift counter to 5x */
1807             phy_data &= ~(M88EC018_EPSCR_DOWNSHIFT_COUNTER_MASK);
1808             phy_data |= M88EC018_EPSCR_DOWNSHIFT_COUNTER_5X;
1809             ret_val = e1000_write_phy_reg(hw,
1810                                         M88E1000_EXT_PHY_SPEC_CTRL, phy_data);
1811             if (ret_val)
1812                 return ret_val;
1813         } else {
1814             /* Configure Master and Slave downshift values */
1815             phy_data &= ~(M88E1000_EPSCR_MASTER_DOWNSHIFT_MASK |
1816                               M88E1000_EPSCR_SLAVE_DOWNSHIFT_MASK);
1817             phy_data |= (M88E1000_EPSCR_MASTER_DOWNSHIFT_1X |
1818                              M88E1000_EPSCR_SLAVE_DOWNSHIFT_1X);
1819             ret_val = e1000_write_phy_reg(hw,
1820                                         M88E1000_EXT_PHY_SPEC_CTRL, phy_data);
1821             if (ret_val)
1822                return ret_val;
1823         }
1824     }
1825
1826     /* SW Reset the PHY so all changes take effect */
1827     ret_val = e1000_phy_reset(hw);
1828     if (ret_val) {
1829         DEBUGOUT("Error Resetting the PHY\n");
1830         return ret_val;
1831     }
1832
1833    return E1000_SUCCESS;
1834 }
1835
1836 /********************************************************************
1837 * Setup auto-negotiation and flow control advertisements,
1838 * and then perform auto-negotiation.
1839 *
1840 * hw - Struct containing variables accessed by shared code
1841 *********************************************************************/
1842 static s32 e1000_copper_link_autoneg(struct e1000_hw *hw)
1843 {
1844     s32 ret_val;
1845     u16 phy_data;
1846
1847     DEBUGFUNC("e1000_copper_link_autoneg");
1848
1849     /* Perform some bounds checking on the hw->autoneg_advertised
1850      * parameter.  If this variable is zero, then set it to the default.
1851      */
1852     hw->autoneg_advertised &= AUTONEG_ADVERTISE_SPEED_DEFAULT;
1853
1854     /* If autoneg_advertised is zero, we assume it was not defaulted
1855      * by the calling code so we set to advertise full capability.
1856      */
1857     if (hw->autoneg_advertised == 0)
1858         hw->autoneg_advertised = AUTONEG_ADVERTISE_SPEED_DEFAULT;
1859
1860     /* IFE phy only supports 10/100 */
1861     if (hw->phy_type == e1000_phy_ife)
1862         hw->autoneg_advertised &= AUTONEG_ADVERTISE_10_100_ALL;
1863
1864     DEBUGOUT("Reconfiguring auto-neg advertisement params\n");
1865     ret_val = e1000_phy_setup_autoneg(hw);
1866     if (ret_val) {
1867         DEBUGOUT("Error Setting up Auto-Negotiation\n");
1868         return ret_val;
1869     }
1870     DEBUGOUT("Restarting Auto-Neg\n");
1871
1872     /* Restart auto-negotiation by setting the Auto Neg Enable bit and
1873      * the Auto Neg Restart bit in the PHY control register.
1874      */
1875     ret_val = e1000_read_phy_reg(hw, PHY_CTRL, &phy_data);
1876     if (ret_val)
1877         return ret_val;
1878
1879     phy_data |= (MII_CR_AUTO_NEG_EN | MII_CR_RESTART_AUTO_NEG);
1880     ret_val = e1000_write_phy_reg(hw, PHY_CTRL, phy_data);
1881     if (ret_val)
1882         return ret_val;
1883
1884     /* Does the user want to wait for Auto-Neg to complete here, or
1885      * check at a later time (for example, callback routine).
1886      */
1887     if (hw->wait_autoneg_complete) {
1888         ret_val = e1000_wait_autoneg(hw);
1889         if (ret_val) {
1890             DEBUGOUT("Error while waiting for autoneg to complete\n");
1891             return ret_val;
1892         }
1893     }
1894
1895     hw->get_link_status = true;
1896
1897     return E1000_SUCCESS;
1898 }
1899
1900 /******************************************************************************
1901 * Config the MAC and the PHY after link is up.
1902 *   1) Set up the MAC to the current PHY speed/duplex
1903 *      if we are on 82543.  If we
1904 *      are on newer silicon, we only need to configure
1905 *      collision distance in the Transmit Control Register.
1906 *   2) Set up flow control on the MAC to that established with
1907 *      the link partner.
1908 *   3) Config DSP to improve Gigabit link quality for some PHY revisions.
1909 *
1910 * hw - Struct containing variables accessed by shared code
1911 ******************************************************************************/
1912 static s32 e1000_copper_link_postconfig(struct e1000_hw *hw)
1913 {
1914     s32 ret_val;
1915     DEBUGFUNC("e1000_copper_link_postconfig");
1916
1917     if (hw->mac_type >= e1000_82544) {
1918         e1000_config_collision_dist(hw);
1919     } else {
1920         ret_val = e1000_config_mac_to_phy(hw);
1921         if (ret_val) {
1922             DEBUGOUT("Error configuring MAC to PHY settings\n");
1923             return ret_val;
1924         }
1925     }
1926     ret_val = e1000_config_fc_after_link_up(hw);
1927     if (ret_val) {
1928         DEBUGOUT("Error Configuring Flow Control\n");
1929         return ret_val;
1930     }
1931
1932     /* Config DSP to improve Giga link quality */
1933     if (hw->phy_type == e1000_phy_igp) {
1934         ret_val = e1000_config_dsp_after_link_change(hw, true);
1935         if (ret_val) {
1936             DEBUGOUT("Error Configuring DSP after link up\n");
1937             return ret_val;
1938         }
1939     }
1940
1941     return E1000_SUCCESS;
1942 }
1943
1944 /******************************************************************************
1945 * Detects which PHY is present and setup the speed and duplex
1946 *
1947 * hw - Struct containing variables accessed by shared code
1948 ******************************************************************************/
1949 static s32 e1000_setup_copper_link(struct e1000_hw *hw)
1950 {
1951     s32 ret_val;
1952     u16 i;
1953     u16 phy_data;
1954     u16 reg_data;
1955
1956     DEBUGFUNC("e1000_setup_copper_link");
1957
1958     switch (hw->mac_type) {
1959     case e1000_80003es2lan:
1960     case e1000_ich8lan:
1961         /* Set the mac to wait the maximum time between each
1962          * iteration and increase the max iterations when
1963          * polling the phy; this fixes erroneous timeouts at 10Mbps. */
1964         ret_val = e1000_write_kmrn_reg(hw, GG82563_REG(0x34, 4), 0xFFFF);
1965         if (ret_val)
1966             return ret_val;
1967         ret_val = e1000_read_kmrn_reg(hw, GG82563_REG(0x34, 9), &reg_data);
1968         if (ret_val)
1969             return ret_val;
1970         reg_data |= 0x3F;
1971         ret_val = e1000_write_kmrn_reg(hw, GG82563_REG(0x34, 9), reg_data);
1972         if (ret_val)
1973             return ret_val;
1974     default:
1975         break;
1976     }
1977
1978     /* Check if it is a valid PHY and set PHY mode if necessary. */
1979     ret_val = e1000_copper_link_preconfig(hw);
1980     if (ret_val)
1981         return ret_val;
1982
1983     switch (hw->mac_type) {
1984     case e1000_80003es2lan:
1985         /* Kumeran registers are written-only */
1986         reg_data = E1000_KUMCTRLSTA_INB_CTRL_LINK_STATUS_TX_TIMEOUT_DEFAULT;
1987         reg_data |= E1000_KUMCTRLSTA_INB_CTRL_DIS_PADDING;
1988         ret_val = e1000_write_kmrn_reg(hw, E1000_KUMCTRLSTA_OFFSET_INB_CTRL,
1989                                        reg_data);
1990         if (ret_val)
1991             return ret_val;
1992         break;
1993     default:
1994         break;
1995     }
1996
1997     if (hw->phy_type == e1000_phy_igp ||
1998         hw->phy_type == e1000_phy_igp_3 ||
1999         hw->phy_type == e1000_phy_igp_2) {
2000         ret_val = e1000_copper_link_igp_setup(hw);
2001         if (ret_val)
2002             return ret_val;
2003     } else if (hw->phy_type == e1000_phy_m88) {
2004         ret_val = e1000_copper_link_mgp_setup(hw);
2005         if (ret_val)
2006             return ret_val;
2007     } else if (hw->phy_type == e1000_phy_gg82563) {
2008         ret_val = e1000_copper_link_ggp_setup(hw);
2009         if (ret_val)
2010             return ret_val;
2011     }
2012
2013     if (hw->autoneg) {
2014         /* Setup autoneg and flow control advertisement
2015           * and perform autonegotiation */
2016         ret_val = e1000_copper_link_autoneg(hw);
2017         if (ret_val)
2018             return ret_val;
2019     } else {
2020         /* PHY will be set to 10H, 10F, 100H,or 100F
2021           * depending on value from forced_speed_duplex. */
2022         DEBUGOUT("Forcing speed and duplex\n");
2023         ret_val = e1000_phy_force_speed_duplex(hw);
2024         if (ret_val) {
2025             DEBUGOUT("Error Forcing Speed and Duplex\n");
2026             return ret_val;
2027         }
2028     }
2029
2030     /* Check link status. Wait up to 100 microseconds for link to become
2031      * valid.
2032      */
2033     for (i = 0; i < 10; i++) {
2034         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2035         if (ret_val)
2036             return ret_val;
2037         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2038         if (ret_val)
2039             return ret_val;
2040
2041         if (phy_data & MII_SR_LINK_STATUS) {
2042             /* Config the MAC and PHY after link is up */
2043             ret_val = e1000_copper_link_postconfig(hw);
2044             if (ret_val)
2045                 return ret_val;
2046
2047             DEBUGOUT("Valid link established!!!\n");
2048             return E1000_SUCCESS;
2049         }
2050         udelay(10);
2051     }
2052
2053     DEBUGOUT("Unable to establish link!!!\n");
2054     return E1000_SUCCESS;
2055 }
2056
2057 /******************************************************************************
2058 * Configure the MAC-to-PHY interface for 10/100Mbps
2059 *
2060 * hw - Struct containing variables accessed by shared code
2061 ******************************************************************************/
2062 static s32 e1000_configure_kmrn_for_10_100(struct e1000_hw *hw, u16 duplex)
2063 {
2064     s32 ret_val = E1000_SUCCESS;
2065     u32 tipg;
2066     u16 reg_data;
2067
2068     DEBUGFUNC("e1000_configure_kmrn_for_10_100");
2069
2070     reg_data = E1000_KUMCTRLSTA_HD_CTRL_10_100_DEFAULT;
2071     ret_val = e1000_write_kmrn_reg(hw, E1000_KUMCTRLSTA_OFFSET_HD_CTRL,
2072                                    reg_data);
2073     if (ret_val)
2074         return ret_val;
2075
2076     /* Configure Transmit Inter-Packet Gap */
2077     tipg = er32(TIPG);
2078     tipg &= ~E1000_TIPG_IPGT_MASK;
2079     tipg |= DEFAULT_80003ES2LAN_TIPG_IPGT_10_100;
2080     ew32(TIPG, tipg);
2081
2082     ret_val = e1000_read_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL, &reg_data);
2083
2084     if (ret_val)
2085         return ret_val;
2086
2087     if (duplex == HALF_DUPLEX)
2088         reg_data |= GG82563_KMCR_PASS_FALSE_CARRIER;
2089     else
2090         reg_data &= ~GG82563_KMCR_PASS_FALSE_CARRIER;
2091
2092     ret_val = e1000_write_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL, reg_data);
2093
2094     return ret_val;
2095 }
2096
2097 static s32 e1000_configure_kmrn_for_1000(struct e1000_hw *hw)
2098 {
2099     s32 ret_val = E1000_SUCCESS;
2100     u16 reg_data;
2101     u32 tipg;
2102
2103     DEBUGFUNC("e1000_configure_kmrn_for_1000");
2104
2105     reg_data = E1000_KUMCTRLSTA_HD_CTRL_1000_DEFAULT;
2106     ret_val = e1000_write_kmrn_reg(hw, E1000_KUMCTRLSTA_OFFSET_HD_CTRL,
2107                                    reg_data);
2108     if (ret_val)
2109         return ret_val;
2110
2111     /* Configure Transmit Inter-Packet Gap */
2112     tipg = er32(TIPG);
2113     tipg &= ~E1000_TIPG_IPGT_MASK;
2114     tipg |= DEFAULT_80003ES2LAN_TIPG_IPGT_1000;
2115     ew32(TIPG, tipg);
2116
2117     ret_val = e1000_read_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL, &reg_data);
2118
2119     if (ret_val)
2120         return ret_val;
2121
2122     reg_data &= ~GG82563_KMCR_PASS_FALSE_CARRIER;
2123     ret_val = e1000_write_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL, reg_data);
2124
2125     return ret_val;
2126 }
2127
2128 /******************************************************************************
2129 * Configures PHY autoneg and flow control advertisement settings
2130 *
2131 * hw - Struct containing variables accessed by shared code
2132 ******************************************************************************/
2133 s32 e1000_phy_setup_autoneg(struct e1000_hw *hw)
2134 {
2135     s32 ret_val;
2136     u16 mii_autoneg_adv_reg;
2137     u16 mii_1000t_ctrl_reg;
2138
2139     DEBUGFUNC("e1000_phy_setup_autoneg");
2140
2141     /* Read the MII Auto-Neg Advertisement Register (Address 4). */
2142     ret_val = e1000_read_phy_reg(hw, PHY_AUTONEG_ADV, &mii_autoneg_adv_reg);
2143     if (ret_val)
2144         return ret_val;
2145
2146     if (hw->phy_type != e1000_phy_ife) {
2147         /* Read the MII 1000Base-T Control Register (Address 9). */
2148         ret_val = e1000_read_phy_reg(hw, PHY_1000T_CTRL, &mii_1000t_ctrl_reg);
2149         if (ret_val)
2150             return ret_val;
2151     } else
2152         mii_1000t_ctrl_reg=0;
2153
2154     /* Need to parse both autoneg_advertised and fc and set up
2155      * the appropriate PHY registers.  First we will parse for
2156      * autoneg_advertised software override.  Since we can advertise
2157      * a plethora of combinations, we need to check each bit
2158      * individually.
2159      */
2160
2161     /* First we clear all the 10/100 mb speed bits in the Auto-Neg
2162      * Advertisement Register (Address 4) and the 1000 mb speed bits in
2163      * the  1000Base-T Control Register (Address 9).
2164      */
2165     mii_autoneg_adv_reg &= ~REG4_SPEED_MASK;
2166     mii_1000t_ctrl_reg &= ~REG9_SPEED_MASK;
2167
2168     DEBUGOUT1("autoneg_advertised %x\n", hw->autoneg_advertised);
2169
2170     /* Do we want to advertise 10 Mb Half Duplex? */
2171     if (hw->autoneg_advertised & ADVERTISE_10_HALF) {
2172         DEBUGOUT("Advertise 10mb Half duplex\n");
2173         mii_autoneg_adv_reg |= NWAY_AR_10T_HD_CAPS;
2174     }
2175
2176     /* Do we want to advertise 10 Mb Full Duplex? */
2177     if (hw->autoneg_advertised & ADVERTISE_10_FULL) {
2178         DEBUGOUT("Advertise 10mb Full duplex\n");
2179         mii_autoneg_adv_reg |= NWAY_AR_10T_FD_CAPS;
2180     }
2181
2182     /* Do we want to advertise 100 Mb Half Duplex? */
2183     if (hw->autoneg_advertised & ADVERTISE_100_HALF) {
2184         DEBUGOUT("Advertise 100mb Half duplex\n");
2185         mii_autoneg_adv_reg |= NWAY_AR_100TX_HD_CAPS;
2186     }
2187
2188     /* Do we want to advertise 100 Mb Full Duplex? */
2189     if (hw->autoneg_advertised & ADVERTISE_100_FULL) {
2190         DEBUGOUT("Advertise 100mb Full duplex\n");
2191         mii_autoneg_adv_reg |= NWAY_AR_100TX_FD_CAPS;
2192     }
2193
2194     /* We do not allow the Phy to advertise 1000 Mb Half Duplex */
2195     if (hw->autoneg_advertised & ADVERTISE_1000_HALF) {
2196         DEBUGOUT("Advertise 1000mb Half duplex requested, request denied!\n");
2197     }
2198
2199     /* Do we want to advertise 1000 Mb Full Duplex? */
2200     if (hw->autoneg_advertised & ADVERTISE_1000_FULL) {
2201         DEBUGOUT("Advertise 1000mb Full duplex\n");
2202         mii_1000t_ctrl_reg |= CR_1000T_FD_CAPS;
2203         if (hw->phy_type == e1000_phy_ife) {
2204             DEBUGOUT("e1000_phy_ife is a 10/100 PHY. Gigabit speed is not supported.\n");
2205         }
2206     }
2207
2208     /* Check for a software override of the flow control settings, and
2209      * setup the PHY advertisement registers accordingly.  If
2210      * auto-negotiation is enabled, then software will have to set the
2211      * "PAUSE" bits to the correct value in the Auto-Negotiation
2212      * Advertisement Register (PHY_AUTONEG_ADV) and re-start auto-negotiation.
2213      *
2214      * The possible values of the "fc" parameter are:
2215      *      0:  Flow control is completely disabled
2216      *      1:  Rx flow control is enabled (we can receive pause frames
2217      *          but not send pause frames).
2218      *      2:  Tx flow control is enabled (we can send pause frames
2219      *          but we do not support receiving pause frames).
2220      *      3:  Both Rx and TX flow control (symmetric) are enabled.
2221      *  other:  No software override.  The flow control configuration
2222      *          in the EEPROM is used.
2223      */
2224     switch (hw->fc) {
2225     case E1000_FC_NONE: /* 0 */
2226         /* Flow control (RX & TX) is completely disabled by a
2227          * software over-ride.
2228          */
2229         mii_autoneg_adv_reg &= ~(NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
2230         break;
2231     case E1000_FC_RX_PAUSE: /* 1 */
2232         /* RX Flow control is enabled, and TX Flow control is
2233          * disabled, by a software over-ride.
2234          */
2235         /* Since there really isn't a way to advertise that we are
2236          * capable of RX Pause ONLY, we will advertise that we
2237          * support both symmetric and asymmetric RX PAUSE.  Later
2238          * (in e1000_config_fc_after_link_up) we will disable the
2239          *hw's ability to send PAUSE frames.
2240          */
2241         mii_autoneg_adv_reg |= (NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
2242         break;
2243     case E1000_FC_TX_PAUSE: /* 2 */
2244         /* TX Flow control is enabled, and RX Flow control is
2245          * disabled, by a software over-ride.
2246          */
2247         mii_autoneg_adv_reg |= NWAY_AR_ASM_DIR;
2248         mii_autoneg_adv_reg &= ~NWAY_AR_PAUSE;
2249         break;
2250     case E1000_FC_FULL: /* 3 */
2251         /* Flow control (both RX and TX) is enabled by a software
2252          * over-ride.
2253          */
2254         mii_autoneg_adv_reg |= (NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
2255         break;
2256     default:
2257         DEBUGOUT("Flow control param set incorrectly\n");
2258         return -E1000_ERR_CONFIG;
2259     }
2260
2261     ret_val = e1000_write_phy_reg(hw, PHY_AUTONEG_ADV, mii_autoneg_adv_reg);
2262     if (ret_val)
2263         return ret_val;
2264
2265     DEBUGOUT1("Auto-Neg Advertising %x\n", mii_autoneg_adv_reg);
2266
2267     if (hw->phy_type != e1000_phy_ife) {
2268         ret_val = e1000_write_phy_reg(hw, PHY_1000T_CTRL, mii_1000t_ctrl_reg);
2269         if (ret_val)
2270             return ret_val;
2271     }
2272
2273     return E1000_SUCCESS;
2274 }
2275
2276 /******************************************************************************
2277 * Force PHY speed and duplex settings to hw->forced_speed_duplex
2278 *
2279 * hw - Struct containing variables accessed by shared code
2280 ******************************************************************************/
2281 static s32 e1000_phy_force_speed_duplex(struct e1000_hw *hw)
2282 {
2283     u32 ctrl;
2284     s32 ret_val;
2285     u16 mii_ctrl_reg;
2286     u16 mii_status_reg;
2287     u16 phy_data;
2288     u16 i;
2289
2290     DEBUGFUNC("e1000_phy_force_speed_duplex");
2291
2292     /* Turn off Flow control if we are forcing speed and duplex. */
2293     hw->fc = E1000_FC_NONE;
2294
2295     DEBUGOUT1("hw->fc = %d\n", hw->fc);
2296
2297     /* Read the Device Control Register. */
2298     ctrl = er32(CTRL);
2299
2300     /* Set the bits to Force Speed and Duplex in the Device Ctrl Reg. */
2301     ctrl |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
2302     ctrl &= ~(DEVICE_SPEED_MASK);
2303
2304     /* Clear the Auto Speed Detect Enable bit. */
2305     ctrl &= ~E1000_CTRL_ASDE;
2306
2307     /* Read the MII Control Register. */
2308     ret_val = e1000_read_phy_reg(hw, PHY_CTRL, &mii_ctrl_reg);
2309     if (ret_val)
2310         return ret_val;
2311
2312     /* We need to disable autoneg in order to force link and duplex. */
2313
2314     mii_ctrl_reg &= ~MII_CR_AUTO_NEG_EN;
2315
2316     /* Are we forcing Full or Half Duplex? */
2317     if (hw->forced_speed_duplex == e1000_100_full ||
2318         hw->forced_speed_duplex == e1000_10_full) {
2319         /* We want to force full duplex so we SET the full duplex bits in the
2320          * Device and MII Control Registers.
2321          */
2322         ctrl |= E1000_CTRL_FD;
2323         mii_ctrl_reg |= MII_CR_FULL_DUPLEX;
2324         DEBUGOUT("Full Duplex\n");
2325     } else {
2326         /* We want to force half duplex so we CLEAR the full duplex bits in
2327          * the Device and MII Control Registers.
2328          */
2329         ctrl &= ~E1000_CTRL_FD;
2330         mii_ctrl_reg &= ~MII_CR_FULL_DUPLEX;
2331         DEBUGOUT("Half Duplex\n");
2332     }
2333
2334     /* Are we forcing 100Mbps??? */
2335     if (hw->forced_speed_duplex == e1000_100_full ||
2336        hw->forced_speed_duplex == e1000_100_half) {
2337         /* Set the 100Mb bit and turn off the 1000Mb and 10Mb bits. */
2338         ctrl |= E1000_CTRL_SPD_100;
2339         mii_ctrl_reg |= MII_CR_SPEED_100;
2340         mii_ctrl_reg &= ~(MII_CR_SPEED_1000 | MII_CR_SPEED_10);
2341         DEBUGOUT("Forcing 100mb ");
2342     } else {
2343         /* Set the 10Mb bit and turn off the 1000Mb and 100Mb bits. */
2344         ctrl &= ~(E1000_CTRL_SPD_1000 | E1000_CTRL_SPD_100);
2345         mii_ctrl_reg |= MII_CR_SPEED_10;
2346         mii_ctrl_reg &= ~(MII_CR_SPEED_1000 | MII_CR_SPEED_100);
2347         DEBUGOUT("Forcing 10mb ");
2348     }
2349
2350     e1000_config_collision_dist(hw);
2351
2352     /* Write the configured values back to the Device Control Reg. */
2353     ew32(CTRL, ctrl);
2354
2355     if ((hw->phy_type == e1000_phy_m88) ||
2356         (hw->phy_type == e1000_phy_gg82563)) {
2357         ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
2358         if (ret_val)
2359             return ret_val;
2360
2361         /* Clear Auto-Crossover to force MDI manually. M88E1000 requires MDI
2362          * forced whenever speed are duplex are forced.
2363          */
2364         phy_data &= ~M88E1000_PSCR_AUTO_X_MODE;
2365         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
2366         if (ret_val)
2367             return ret_val;
2368
2369         DEBUGOUT1("M88E1000 PSCR: %x \n", phy_data);
2370
2371         /* Need to reset the PHY or these changes will be ignored */
2372         mii_ctrl_reg |= MII_CR_RESET;
2373
2374     /* Disable MDI-X support for 10/100 */
2375     } else if (hw->phy_type == e1000_phy_ife) {
2376         ret_val = e1000_read_phy_reg(hw, IFE_PHY_MDIX_CONTROL, &phy_data);
2377         if (ret_val)
2378             return ret_val;
2379
2380         phy_data &= ~IFE_PMC_AUTO_MDIX;
2381         phy_data &= ~IFE_PMC_FORCE_MDIX;
2382
2383         ret_val = e1000_write_phy_reg(hw, IFE_PHY_MDIX_CONTROL, phy_data);
2384         if (ret_val)
2385             return ret_val;
2386
2387     } else {
2388         /* Clear Auto-Crossover to force MDI manually.  IGP requires MDI
2389          * forced whenever speed or duplex are forced.
2390          */
2391         ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, &phy_data);
2392         if (ret_val)
2393             return ret_val;
2394
2395         phy_data &= ~IGP01E1000_PSCR_AUTO_MDIX;
2396         phy_data &= ~IGP01E1000_PSCR_FORCE_MDI_MDIX;
2397
2398         ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, phy_data);
2399         if (ret_val)
2400             return ret_val;
2401     }
2402
2403     /* Write back the modified PHY MII control register. */
2404     ret_val = e1000_write_phy_reg(hw, PHY_CTRL, mii_ctrl_reg);
2405     if (ret_val)
2406         return ret_val;
2407
2408     udelay(1);
2409
2410     /* The wait_autoneg_complete flag may be a little misleading here.
2411      * Since we are forcing speed and duplex, Auto-Neg is not enabled.
2412      * But we do want to delay for a period while forcing only so we
2413      * don't generate false No Link messages.  So we will wait here
2414      * only if the user has set wait_autoneg_complete to 1, which is
2415      * the default.
2416      */
2417     if (hw->wait_autoneg_complete) {
2418         /* We will wait for autoneg to complete. */
2419         DEBUGOUT("Waiting for forced speed/duplex link.\n");
2420         mii_status_reg = 0;
2421
2422         /* We will wait for autoneg to complete or 4.5 seconds to expire. */
2423         for (i = PHY_FORCE_TIME; i > 0; i--) {
2424             /* Read the MII Status Register and wait for Auto-Neg Complete bit
2425              * to be set.
2426              */
2427             ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2428             if (ret_val)
2429                 return ret_val;
2430
2431             ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2432             if (ret_val)
2433                 return ret_val;
2434
2435             if (mii_status_reg & MII_SR_LINK_STATUS) break;
2436             msleep(100);
2437         }
2438         if ((i == 0) &&
2439            ((hw->phy_type == e1000_phy_m88) ||
2440             (hw->phy_type == e1000_phy_gg82563))) {
2441             /* We didn't get link.  Reset the DSP and wait again for link. */
2442             ret_val = e1000_phy_reset_dsp(hw);
2443             if (ret_val) {
2444                 DEBUGOUT("Error Resetting PHY DSP\n");
2445                 return ret_val;
2446             }
2447         }
2448         /* This loop will early-out if the link condition has been met.  */
2449         for (i = PHY_FORCE_TIME; i > 0; i--) {
2450             if (mii_status_reg & MII_SR_LINK_STATUS) break;
2451             msleep(100);
2452             /* Read the MII Status Register and wait for Auto-Neg Complete bit
2453              * to be set.
2454              */
2455             ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2456             if (ret_val)
2457                 return ret_val;
2458
2459             ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2460             if (ret_val)
2461                 return ret_val;
2462         }
2463     }
2464
2465     if (hw->phy_type == e1000_phy_m88) {
2466         /* Because we reset the PHY above, we need to re-force TX_CLK in the
2467          * Extended PHY Specific Control Register to 25MHz clock.  This value
2468          * defaults back to a 2.5MHz clock when the PHY is reset.
2469          */
2470         ret_val = e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_data);
2471         if (ret_val)
2472             return ret_val;
2473
2474         phy_data |= M88E1000_EPSCR_TX_CLK_25;
2475         ret_val = e1000_write_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, phy_data);
2476         if (ret_val)
2477             return ret_val;
2478
2479         /* In addition, because of the s/w reset above, we need to enable CRS on
2480          * TX.  This must be set for both full and half duplex operation.
2481          */
2482         ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
2483         if (ret_val)
2484             return ret_val;
2485
2486         phy_data |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
2487         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
2488         if (ret_val)
2489             return ret_val;
2490
2491         if ((hw->mac_type == e1000_82544 || hw->mac_type == e1000_82543) &&
2492             (!hw->autoneg) && (hw->forced_speed_duplex == e1000_10_full ||
2493              hw->forced_speed_duplex == e1000_10_half)) {
2494             ret_val = e1000_polarity_reversal_workaround(hw);
2495             if (ret_val)
2496                 return ret_val;
2497         }
2498     } else if (hw->phy_type == e1000_phy_gg82563) {
2499         /* The TX_CLK of the Extended PHY Specific Control Register defaults
2500          * to 2.5MHz on a reset.  We need to re-force it back to 25MHz, if
2501          * we're not in a forced 10/duplex configuration. */
2502         ret_val = e1000_read_phy_reg(hw, GG82563_PHY_MAC_SPEC_CTRL, &phy_data);
2503         if (ret_val)
2504             return ret_val;
2505
2506         phy_data &= ~GG82563_MSCR_TX_CLK_MASK;
2507         if ((hw->forced_speed_duplex == e1000_10_full) ||
2508             (hw->forced_speed_duplex == e1000_10_half))
2509             phy_data |= GG82563_MSCR_TX_CLK_10MBPS_2_5MHZ;
2510         else
2511             phy_data |= GG82563_MSCR_TX_CLK_100MBPS_25MHZ;
2512
2513         /* Also due to the reset, we need to enable CRS on Tx. */
2514         phy_data |= GG82563_MSCR_ASSERT_CRS_ON_TX;
2515
2516         ret_val = e1000_write_phy_reg(hw, GG82563_PHY_MAC_SPEC_CTRL, phy_data);
2517         if (ret_val)
2518             return ret_val;
2519     }
2520     return E1000_SUCCESS;
2521 }
2522
2523 /******************************************************************************
2524 * Sets the collision distance in the Transmit Control register
2525 *
2526 * hw - Struct containing variables accessed by shared code
2527 *
2528 * Link should have been established previously. Reads the speed and duplex
2529 * information from the Device Status register.
2530 ******************************************************************************/
2531 void e1000_config_collision_dist(struct e1000_hw *hw)
2532 {
2533     u32 tctl, coll_dist;
2534
2535     DEBUGFUNC("e1000_config_collision_dist");
2536
2537     if (hw->mac_type < e1000_82543)
2538         coll_dist = E1000_COLLISION_DISTANCE_82542;
2539     else
2540         coll_dist = E1000_COLLISION_DISTANCE;
2541
2542     tctl = er32(TCTL);
2543
2544     tctl &= ~E1000_TCTL_COLD;
2545     tctl |= coll_dist << E1000_COLD_SHIFT;
2546
2547     ew32(TCTL, tctl);
2548     E1000_WRITE_FLUSH();
2549 }
2550
2551 /******************************************************************************
2552 * Sets MAC speed and duplex settings to reflect the those in the PHY
2553 *
2554 * hw - Struct containing variables accessed by shared code
2555 * mii_reg - data to write to the MII control register
2556 *
2557 * The contents of the PHY register containing the needed information need to
2558 * be passed in.
2559 ******************************************************************************/
2560 static s32 e1000_config_mac_to_phy(struct e1000_hw *hw)
2561 {
2562     u32 ctrl;
2563     s32 ret_val;
2564     u16 phy_data;
2565
2566     DEBUGFUNC("e1000_config_mac_to_phy");
2567
2568     /* 82544 or newer MAC, Auto Speed Detection takes care of
2569     * MAC speed/duplex configuration.*/
2570     if (hw->mac_type >= e1000_82544)
2571         return E1000_SUCCESS;
2572
2573     /* Read the Device Control Register and set the bits to Force Speed
2574      * and Duplex.
2575      */
2576     ctrl = er32(CTRL);
2577     ctrl |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
2578     ctrl &= ~(E1000_CTRL_SPD_SEL | E1000_CTRL_ILOS);
2579
2580     /* Set up duplex in the Device Control and Transmit Control
2581      * registers depending on negotiated values.
2582      */
2583     ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
2584     if (ret_val)
2585         return ret_val;
2586
2587     if (phy_data & M88E1000_PSSR_DPLX)
2588         ctrl |= E1000_CTRL_FD;
2589     else
2590         ctrl &= ~E1000_CTRL_FD;
2591
2592     e1000_config_collision_dist(hw);
2593
2594     /* Set up speed in the Device Control register depending on
2595      * negotiated values.
2596      */
2597     if ((phy_data & M88E1000_PSSR_SPEED) == M88E1000_PSSR_1000MBS)
2598         ctrl |= E1000_CTRL_SPD_1000;
2599     else if ((phy_data & M88E1000_PSSR_SPEED) == M88E1000_PSSR_100MBS)
2600         ctrl |= E1000_CTRL_SPD_100;
2601
2602     /* Write the configured values back to the Device Control Reg. */
2603     ew32(CTRL, ctrl);
2604     return E1000_SUCCESS;
2605 }
2606
2607 /******************************************************************************
2608  * Forces the MAC's flow control settings.
2609  *
2610  * hw - Struct containing variables accessed by shared code
2611  *
2612  * Sets the TFCE and RFCE bits in the device control register to reflect
2613  * the adapter settings. TFCE and RFCE need to be explicitly set by
2614  * software when a Copper PHY is used because autonegotiation is managed
2615  * by the PHY rather than the MAC. Software must also configure these
2616  * bits when link is forced on a fiber connection.
2617  *****************************************************************************/
2618 s32 e1000_force_mac_fc(struct e1000_hw *hw)
2619 {
2620     u32 ctrl;
2621
2622     DEBUGFUNC("e1000_force_mac_fc");
2623
2624     /* Get the current configuration of the Device Control Register */
2625     ctrl = er32(CTRL);
2626
2627     /* Because we didn't get link via the internal auto-negotiation
2628      * mechanism (we either forced link or we got link via PHY
2629      * auto-neg), we have to manually enable/disable transmit an
2630      * receive flow control.
2631      *
2632      * The "Case" statement below enables/disable flow control
2633      * according to the "hw->fc" parameter.
2634      *
2635      * The possible values of the "fc" parameter are:
2636      *      0:  Flow control is completely disabled
2637      *      1:  Rx flow control is enabled (we can receive pause
2638      *          frames but not send pause frames).
2639      *      2:  Tx flow control is enabled (we can send pause frames
2640      *          frames but we do not receive pause frames).
2641      *      3:  Both Rx and TX flow control (symmetric) is enabled.
2642      *  other:  No other values should be possible at this point.
2643      */
2644
2645     switch (hw->fc) {
2646     case E1000_FC_NONE:
2647         ctrl &= (~(E1000_CTRL_TFCE | E1000_CTRL_RFCE));
2648         break;
2649     case E1000_FC_RX_PAUSE:
2650         ctrl &= (~E1000_CTRL_TFCE);
2651         ctrl |= E1000_CTRL_RFCE;
2652         break;
2653     case E1000_FC_TX_PAUSE:
2654         ctrl &= (~E1000_CTRL_RFCE);
2655         ctrl |= E1000_CTRL_TFCE;
2656         break;
2657     case E1000_FC_FULL:
2658         ctrl |= (E1000_CTRL_TFCE | E1000_CTRL_RFCE);
2659         break;
2660     default:
2661         DEBUGOUT("Flow control param set incorrectly\n");
2662         return -E1000_ERR_CONFIG;
2663     }
2664
2665     /* Disable TX Flow Control for 82542 (rev 2.0) */
2666     if (hw->mac_type == e1000_82542_rev2_0)
2667         ctrl &= (~E1000_CTRL_TFCE);
2668
2669     ew32(CTRL, ctrl);
2670     return E1000_SUCCESS;
2671 }
2672
2673 /******************************************************************************
2674  * Configures flow control settings after link is established
2675  *
2676  * hw - Struct containing variables accessed by shared code
2677  *
2678  * Should be called immediately after a valid link has been established.
2679  * Forces MAC flow control settings if link was forced. When in MII/GMII mode
2680  * and autonegotiation is enabled, the MAC flow control settings will be set
2681  * based on the flow control negotiated by the PHY. In TBI mode, the TFCE
2682  * and RFCE bits will be automaticaly set to the negotiated flow control mode.
2683  *****************************************************************************/
2684 static s32 e1000_config_fc_after_link_up(struct e1000_hw *hw)
2685 {
2686     s32 ret_val;
2687     u16 mii_status_reg;
2688     u16 mii_nway_adv_reg;
2689     u16 mii_nway_lp_ability_reg;
2690     u16 speed;
2691     u16 duplex;
2692
2693     DEBUGFUNC("e1000_config_fc_after_link_up");
2694
2695     /* Check for the case where we have fiber media and auto-neg failed
2696      * so we had to force link.  In this case, we need to force the
2697      * configuration of the MAC to match the "fc" parameter.
2698      */
2699     if (((hw->media_type == e1000_media_type_fiber) && (hw->autoneg_failed)) ||
2700         ((hw->media_type == e1000_media_type_internal_serdes) &&
2701          (hw->autoneg_failed)) ||
2702         ((hw->media_type == e1000_media_type_copper) && (!hw->autoneg))) {
2703         ret_val = e1000_force_mac_fc(hw);
2704         if (ret_val) {
2705             DEBUGOUT("Error forcing flow control settings\n");
2706             return ret_val;
2707         }
2708     }
2709
2710     /* Check for the case where we have copper media and auto-neg is
2711      * enabled.  In this case, we need to check and see if Auto-Neg
2712      * has completed, and if so, how the PHY and link partner has
2713      * flow control configured.
2714      */
2715     if ((hw->media_type == e1000_media_type_copper) && hw->autoneg) {
2716         /* Read the MII Status Register and check to see if AutoNeg
2717          * has completed.  We read this twice because this reg has
2718          * some "sticky" (latched) bits.
2719          */
2720         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2721         if (ret_val)
2722             return ret_val;
2723         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2724         if (ret_val)
2725             return ret_val;
2726
2727         if (mii_status_reg & MII_SR_AUTONEG_COMPLETE) {
2728             /* The AutoNeg process has completed, so we now need to
2729              * read both the Auto Negotiation Advertisement Register
2730              * (Address 4) and the Auto_Negotiation Base Page Ability
2731              * Register (Address 5) to determine how flow control was
2732              * negotiated.
2733              */
2734             ret_val = e1000_read_phy_reg(hw, PHY_AUTONEG_ADV,
2735                                          &mii_nway_adv_reg);
2736             if (ret_val)
2737                 return ret_val;
2738             ret_val = e1000_read_phy_reg(hw, PHY_LP_ABILITY,
2739                                          &mii_nway_lp_ability_reg);
2740             if (ret_val)
2741                 return ret_val;
2742
2743             /* Two bits in the Auto Negotiation Advertisement Register
2744              * (Address 4) and two bits in the Auto Negotiation Base
2745              * Page Ability Register (Address 5) determine flow control
2746              * for both the PHY and the link partner.  The following
2747              * table, taken out of the IEEE 802.3ab/D6.0 dated March 25,
2748              * 1999, describes these PAUSE resolution bits and how flow
2749              * control is determined based upon these settings.
2750              * NOTE:  DC = Don't Care
2751              *
2752              *   LOCAL DEVICE  |   LINK PARTNER
2753              * PAUSE | ASM_DIR | PAUSE | ASM_DIR | NIC Resolution
2754              *-------|---------|-------|---------|--------------------
2755              *   0   |    0    |  DC   |   DC    | E1000_FC_NONE
2756              *   0   |    1    |   0   |   DC    | E1000_FC_NONE
2757              *   0   |    1    |   1   |    0    | E1000_FC_NONE
2758              *   0   |    1    |   1   |    1    | E1000_FC_TX_PAUSE
2759              *   1   |    0    |   0   |   DC    | E1000_FC_NONE
2760              *   1   |   DC    |   1   |   DC    | E1000_FC_FULL
2761              *   1   |    1    |   0   |    0    | E1000_FC_NONE
2762              *   1   |    1    |   0   |    1    | E1000_FC_RX_PAUSE
2763              *
2764              */
2765             /* Are both PAUSE bits set to 1?  If so, this implies
2766              * Symmetric Flow Control is enabled at both ends.  The
2767              * ASM_DIR bits are irrelevant per the spec.
2768              *
2769              * For Symmetric Flow Control:
2770              *
2771              *   LOCAL DEVICE  |   LINK PARTNER
2772              * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
2773              *-------|---------|-------|---------|--------------------
2774              *   1   |   DC    |   1   |   DC    | E1000_FC_FULL
2775              *
2776              */
2777             if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
2778                 (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE)) {
2779                 /* Now we need to check if the user selected RX ONLY
2780                  * of pause frames.  In this case, we had to advertise
2781                  * FULL flow control because we could not advertise RX
2782                  * ONLY. Hence, we must now check to see if we need to
2783                  * turn OFF  the TRANSMISSION of PAUSE frames.
2784                  */
2785                 if (hw->original_fc == E1000_FC_FULL) {
2786                     hw->fc = E1000_FC_FULL;
2787                     DEBUGOUT("Flow Control = FULL.\n");
2788                 } else {
2789                     hw->fc = E1000_FC_RX_PAUSE;
2790                     DEBUGOUT("Flow Control = RX PAUSE frames only.\n");
2791                 }
2792             }
2793             /* For receiving PAUSE frames ONLY.
2794              *
2795              *   LOCAL DEVICE  |   LINK PARTNER
2796              * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
2797              *-------|---------|-------|---------|--------------------
2798              *   0   |    1    |   1   |    1    | E1000_FC_TX_PAUSE
2799              *
2800              */
2801             else if (!(mii_nway_adv_reg & NWAY_AR_PAUSE) &&
2802                      (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
2803                      (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
2804                      (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
2805                 hw->fc = E1000_FC_TX_PAUSE;
2806                 DEBUGOUT("Flow Control = TX PAUSE frames only.\n");
2807             }
2808             /* For transmitting PAUSE frames ONLY.
2809              *
2810              *   LOCAL DEVICE  |   LINK PARTNER
2811              * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
2812              *-------|---------|-------|---------|--------------------
2813              *   1   |    1    |   0   |    1    | E1000_FC_RX_PAUSE
2814              *
2815              */
2816             else if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
2817                      (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
2818                      !(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
2819                      (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
2820                 hw->fc = E1000_FC_RX_PAUSE;
2821                 DEBUGOUT("Flow Control = RX PAUSE frames only.\n");
2822             }
2823             /* Per the IEEE spec, at this point flow control should be
2824              * disabled.  However, we want to consider that we could
2825              * be connected to a legacy switch that doesn't advertise
2826              * desired flow control, but can be forced on the link
2827              * partner.  So if we advertised no flow control, that is
2828              * what we will resolve to.  If we advertised some kind of
2829              * receive capability (Rx Pause Only or Full Flow Control)
2830              * and the link partner advertised none, we will configure
2831              * ourselves to enable Rx Flow Control only.  We can do
2832              * this safely for two reasons:  If the link partner really
2833              * didn't want flow control enabled, and we enable Rx, no
2834              * harm done since we won't be receiving any PAUSE frames
2835              * anyway.  If the intent on the link partner was to have
2836              * flow control enabled, then by us enabling RX only, we
2837              * can at least receive pause frames and process them.
2838              * This is a good idea because in most cases, since we are
2839              * predominantly a server NIC, more times than not we will
2840              * be asked to delay transmission of packets than asking
2841              * our link partner to pause transmission of frames.
2842              */
2843             else if ((hw->original_fc == E1000_FC_NONE ||
2844                       hw->original_fc == E1000_FC_TX_PAUSE) ||
2845                       hw->fc_strict_ieee) {
2846                 hw->fc = E1000_FC_NONE;
2847                 DEBUGOUT("Flow Control = NONE.\n");
2848             } else {
2849                 hw->fc = E1000_FC_RX_PAUSE;
2850                 DEBUGOUT("Flow Control = RX PAUSE frames only.\n");
2851             }
2852
2853             /* Now we need to do one last check...  If we auto-
2854              * negotiated to HALF DUPLEX, flow control should not be
2855              * enabled per IEEE 802.3 spec.
2856              */
2857             ret_val = e1000_get_speed_and_duplex(hw, &speed, &duplex);
2858             if (ret_val) {
2859                 DEBUGOUT("Error getting link speed and duplex\n");
2860                 return ret_val;
2861             }
2862
2863             if (duplex == HALF_DUPLEX)
2864                 hw->fc = E1000_FC_NONE;
2865
2866             /* Now we call a subroutine to actually force the MAC
2867              * controller to use the correct flow control settings.
2868              */
2869             ret_val = e1000_force_mac_fc(hw);
2870             if (ret_val) {
2871                 DEBUGOUT("Error forcing flow control settings\n");
2872                 return ret_val;
2873             }
2874         } else {
2875             DEBUGOUT("Copper PHY and Auto Neg has not completed.\n");
2876         }
2877     }
2878     return E1000_SUCCESS;
2879 }
2880
2881 /******************************************************************************
2882  * Checks to see if the link status of the hardware has changed.
2883  *
2884  * hw - Struct containing variables accessed by shared code
2885  *
2886  * Called by any function that needs to check the link status of the adapter.
2887  *****************************************************************************/
2888 s32 e1000_check_for_link(struct e1000_hw *hw)
2889 {
2890     u32 rxcw = 0;
2891     u32 ctrl;
2892     u32 status;
2893     u32 rctl;
2894     u32 icr;
2895     u32 signal = 0;
2896     s32 ret_val;
2897     u16 phy_data;
2898
2899     DEBUGFUNC("e1000_check_for_link");
2900
2901     ctrl = er32(CTRL);
2902     status = er32(STATUS);
2903
2904     /* On adapters with a MAC newer than 82544, SW Defineable pin 1 will be
2905      * set when the optics detect a signal. On older adapters, it will be
2906      * cleared when there is a signal.  This applies to fiber media only.
2907      */
2908     if ((hw->media_type == e1000_media_type_fiber) ||
2909         (hw->media_type == e1000_media_type_internal_serdes)) {
2910         rxcw = er32(RXCW);
2911
2912         if (hw->media_type == e1000_media_type_fiber) {
2913             signal = (hw->mac_type > e1000_82544) ? E1000_CTRL_SWDPIN1 : 0;
2914             if (status & E1000_STATUS_LU)
2915                 hw->get_link_status = false;
2916         }
2917     }
2918
2919     /* If we have a copper PHY then we only want to go out to the PHY
2920      * registers to see if Auto-Neg has completed and/or if our link
2921      * status has changed.  The get_link_status flag will be set if we
2922      * receive a Link Status Change interrupt or we have Rx Sequence
2923      * Errors.
2924      */
2925     if ((hw->media_type == e1000_media_type_copper) && hw->get_link_status) {
2926         /* First we want to see if the MII Status Register reports
2927          * link.  If so, then we want to get the current speed/duplex
2928          * of the PHY.
2929          * Read the register twice since the link bit is sticky.
2930          */
2931         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2932         if (ret_val)
2933             return ret_val;
2934         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2935         if (ret_val)
2936             return ret_val;
2937
2938         if (phy_data & MII_SR_LINK_STATUS) {
2939             hw->get_link_status = false;
2940             /* Check if there was DownShift, must be checked immediately after
2941              * link-up */
2942             e1000_check_downshift(hw);
2943
2944             /* If we are on 82544 or 82543 silicon and speed/duplex
2945              * are forced to 10H or 10F, then we will implement the polarity
2946              * reversal workaround.  We disable interrupts first, and upon
2947              * returning, place the devices interrupt state to its previous
2948              * value except for the link status change interrupt which will
2949              * happen due to the execution of this workaround.
2950              */
2951
2952             if ((hw->mac_type == e1000_82544 || hw->mac_type == e1000_82543) &&
2953                 (!hw->autoneg) &&
2954                 (hw->forced_speed_duplex == e1000_10_full ||
2955                  hw->forced_speed_duplex == e1000_10_half)) {
2956                 ew32(IMC, 0xffffffff);
2957                 ret_val = e1000_polarity_reversal_workaround(hw);
2958                 icr = er32(ICR);
2959                 ew32(ICS, (icr & ~E1000_ICS_LSC));
2960                 ew32(IMS, IMS_ENABLE_MASK);
2961             }
2962
2963         } else {
2964             /* No link detected */
2965             e1000_config_dsp_after_link_change(hw, false);
2966             return 0;
2967         }
2968
2969         /* If we are forcing speed/duplex, then we simply return since
2970          * we have already determined whether we have link or not.
2971          */
2972         if (!hw->autoneg) return -E1000_ERR_CONFIG;
2973
2974         /* optimize the dsp settings for the igp phy */
2975         e1000_config_dsp_after_link_change(hw, true);
2976
2977         /* We have a M88E1000 PHY and Auto-Neg is enabled.  If we
2978          * have Si on board that is 82544 or newer, Auto
2979          * Speed Detection takes care of MAC speed/duplex
2980          * configuration.  So we only need to configure Collision
2981          * Distance in the MAC.  Otherwise, we need to force
2982          * speed/duplex on the MAC to the current PHY speed/duplex
2983          * settings.
2984          */
2985         if (hw->mac_type >= e1000_82544)
2986             e1000_config_collision_dist(hw);
2987         else {
2988             ret_val = e1000_config_mac_to_phy(hw);
2989             if (ret_val) {
2990                 DEBUGOUT("Error configuring MAC to PHY settings\n");
2991                 return ret_val;
2992             }
2993         }
2994
2995         /* Configure Flow Control now that Auto-Neg has completed. First, we
2996          * need to restore the desired flow control settings because we may
2997          * have had to re-autoneg with a different link partner.
2998          */
2999         ret_val = e1000_config_fc_after_link_up(hw);
3000         if (ret_val) {
3001             DEBUGOUT("Error configuring flow control\n");
3002             return ret_val;
3003         }
3004
3005         /* At this point we know that we are on copper and we have
3006          * auto-negotiated link.  These are conditions for checking the link
3007          * partner capability register.  We use the link speed to determine if
3008          * TBI compatibility needs to be turned on or off.  If the link is not
3009          * at gigabit speed, then TBI compatibility is not needed.  If we are
3010          * at gigabit speed, we turn on TBI compatibility.
3011          */
3012         if (hw->tbi_compatibility_en) {
3013             u16 speed, duplex;
3014             ret_val = e1000_get_speed_and_duplex(hw, &speed, &duplex);
3015             if (ret_val) {
3016                 DEBUGOUT("Error getting link speed and duplex\n");
3017                 return ret_val;
3018             }
3019             if (speed != SPEED_1000) {
3020                 /* If link speed is not set to gigabit speed, we do not need
3021                  * to enable TBI compatibility.
3022                  */
3023                 if (hw->tbi_compatibility_on) {
3024                     /* If we previously were in the mode, turn it off. */
3025                     rctl = er32(RCTL);
3026                     rctl &= ~E1000_RCTL_SBP;
3027                     ew32(RCTL, rctl);
3028                     hw->tbi_compatibility_on = false;
3029                 }
3030             } else {
3031                 /* If TBI compatibility is was previously off, turn it on. For
3032                  * compatibility with a TBI link partner, we will store bad
3033                  * packets. Some frames have an additional byte on the end and
3034                  * will look like CRC errors to to the hardware.
3035                  */
3036                 if (!hw->tbi_compatibility_on) {
3037                     hw->tbi_compatibility_on = true;
3038                     rctl = er32(RCTL);
3039                     rctl |= E1000_RCTL_SBP;
3040                     ew32(RCTL, rctl);
3041                 }
3042             }
3043         }
3044     }
3045     /* If we don't have link (auto-negotiation failed or link partner cannot
3046      * auto-negotiate), the cable is plugged in (we have signal), and our
3047      * link partner is not trying to auto-negotiate with us (we are receiving
3048      * idles or data), we need to force link up. We also need to give
3049      * auto-negotiation time to complete, in case the cable was just plugged
3050      * in. The autoneg_failed flag does this.
3051      */
3052     else if ((((hw->media_type == e1000_media_type_fiber) &&
3053               ((ctrl & E1000_CTRL_SWDPIN1) == signal)) ||
3054               (hw->media_type == e1000_media_type_internal_serdes)) &&
3055               (!(status & E1000_STATUS_LU)) &&
3056               (!(rxcw & E1000_RXCW_C))) {
3057         if (hw->autoneg_failed == 0) {
3058             hw->autoneg_failed = 1;
3059             return 0;
3060         }
3061         DEBUGOUT("NOT RXing /C/, disable AutoNeg and force link.\n");
3062
3063         /* Disable auto-negotiation in the TXCW register */
3064         ew32(TXCW, (hw->txcw & ~E1000_TXCW_ANE));
3065
3066         /* Force link-up and also force full-duplex. */
3067         ctrl = er32(CTRL);
3068         ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FD);
3069         ew32(CTRL, ctrl);
3070
3071         /* Configure Flow Control after forcing link up. */
3072         ret_val = e1000_config_fc_after_link_up(hw);
3073         if (ret_val) {
3074             DEBUGOUT("Error configuring flow control\n");
3075             return ret_val;
3076         }
3077     }
3078     /* If we are forcing link and we are receiving /C/ ordered sets, re-enable
3079      * auto-negotiation in the TXCW register and disable forced link in the
3080      * Device Control register in an attempt to auto-negotiate with our link
3081      * partner.
3082      */
3083     else if (((hw->media_type == e1000_media_type_fiber) ||
3084               (hw->media_type == e1000_media_type_internal_serdes)) &&
3085               (ctrl & E1000_CTRL_SLU) && (rxcw & E1000_RXCW_C)) {
3086         DEBUGOUT("RXing /C/, enable AutoNeg and stop forcing link.\n");
3087         ew32(TXCW, hw->txcw);
3088         ew32(CTRL, (ctrl & ~E1000_CTRL_SLU));
3089
3090         hw->serdes_link_down = false;
3091     }
3092     /* If we force link for non-auto-negotiation switch, check link status
3093      * based on MAC synchronization for internal serdes media type.
3094      */
3095     else if ((hw->media_type == e1000_media_type_internal_serdes) &&
3096              !(E1000_TXCW_ANE & er32(TXCW))) {
3097         /* SYNCH bit and IV bit are sticky. */
3098         udelay(10);
3099         if (E1000_RXCW_SYNCH & er32(RXCW)) {
3100             if (!(rxcw & E1000_RXCW_IV)) {
3101                 hw->serdes_link_down = false;
3102                 DEBUGOUT("SERDES: Link is up.\n");
3103             }
3104         } else {
3105             hw->serdes_link_down = true;
3106             DEBUGOUT("SERDES: Link is down.\n");
3107         }
3108     }
3109     if ((hw->media_type == e1000_media_type_internal_serdes) &&
3110         (E1000_TXCW_ANE & er32(TXCW))) {
3111         hw->serdes_link_down = !(E1000_STATUS_LU & er32(STATUS));
3112     }
3113     return E1000_SUCCESS;
3114 }
3115
3116 /******************************************************************************
3117  * Detects the current speed and duplex settings of the hardware.
3118  *
3119  * hw - Struct containing variables accessed by shared code
3120  * speed - Speed of the connection
3121  * duplex - Duplex setting of the connection
3122  *****************************************************************************/
3123 s32 e1000_get_speed_and_duplex(struct e1000_hw *hw, u16 *speed, u16 *duplex)
3124 {
3125     u32 status;
3126     s32 ret_val;
3127     u16 phy_data;
3128
3129     DEBUGFUNC("e1000_get_speed_and_duplex");
3130
3131     if (hw->mac_type >= e1000_82543) {
3132         status = er32(STATUS);
3133         if (status & E1000_STATUS_SPEED_1000) {
3134             *speed = SPEED_1000;
3135             DEBUGOUT("1000 Mbs, ");
3136         } else if (status & E1000_STATUS_SPEED_100) {
3137             *speed = SPEED_100;
3138             DEBUGOUT("100 Mbs, ");
3139         } else {
3140             *speed = SPEED_10;
3141             DEBUGOUT("10 Mbs, ");
3142         }
3143
3144         if (status & E1000_STATUS_FD) {
3145             *duplex = FULL_DUPLEX;
3146             DEBUGOUT("Full Duplex\n");
3147         } else {
3148             *duplex = HALF_DUPLEX;
3149             DEBUGOUT(" Half Duplex\n");
3150         }
3151     } else {
3152         DEBUGOUT("1000 Mbs, Full Duplex\n");
3153         *speed = SPEED_1000;
3154         *duplex = FULL_DUPLEX;
3155     }
3156
3157     /* IGP01 PHY may advertise full duplex operation after speed downgrade even
3158      * if it is operating at half duplex.  Here we set the duplex settings to
3159      * match the duplex in the link partner's capabilities.
3160      */
3161     if (hw->phy_type == e1000_phy_igp && hw->speed_downgraded) {
3162         ret_val = e1000_read_phy_reg(hw, PHY_AUTONEG_EXP, &phy_data);
3163         if (ret_val)
3164             return ret_val;
3165
3166         if (!(phy_data & NWAY_ER_LP_NWAY_CAPS))
3167             *duplex = HALF_DUPLEX;
3168         else {
3169             ret_val = e1000_read_phy_reg(hw, PHY_LP_ABILITY, &phy_data);
3170             if (ret_val)
3171                 return ret_val;
3172             if ((*speed == SPEED_100 && !(phy_data & NWAY_LPAR_100TX_FD_CAPS)) ||
3173                (*speed == SPEED_10 && !(phy_data & NWAY_LPAR_10T_FD_CAPS)))
3174                 *duplex = HALF_DUPLEX;
3175         }
3176     }
3177
3178     if ((hw->mac_type == e1000_80003es2lan) &&
3179         (hw->media_type == e1000_media_type_copper)) {
3180         if (*speed == SPEED_1000)
3181             ret_val = e1000_configure_kmrn_for_1000(hw);
3182         else
3183             ret_val = e1000_configure_kmrn_for_10_100(hw, *duplex);
3184         if (ret_val)
3185             return ret_val;
3186     }
3187
3188     if ((hw->phy_type == e1000_phy_igp_3) && (*speed == SPEED_1000)) {
3189         ret_val = e1000_kumeran_lock_loss_workaround(hw);
3190         if (ret_val)
3191             return ret_val;
3192     }
3193
3194     return E1000_SUCCESS;
3195 }
3196
3197 /******************************************************************************
3198 * Blocks until autoneg completes or times out (~4.5 seconds)
3199 *
3200 * hw - Struct containing variables accessed by shared code
3201 ******************************************************************************/
3202 static s32 e1000_wait_autoneg(struct e1000_hw *hw)
3203 {
3204     s32 ret_val;
3205     u16 i;
3206     u16 phy_data;
3207
3208     DEBUGFUNC("e1000_wait_autoneg");
3209     DEBUGOUT("Waiting for Auto-Neg to complete.\n");
3210
3211     /* We will wait for autoneg to complete or 4.5 seconds to expire. */
3212     for (i = PHY_AUTO_NEG_TIME; i > 0; i--) {
3213         /* Read the MII Status Register and wait for Auto-Neg
3214          * Complete bit to be set.
3215          */
3216         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
3217         if (ret_val)
3218             return ret_val;
3219         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
3220         if (ret_val)
3221             return ret_val;
3222         if (phy_data & MII_SR_AUTONEG_COMPLETE) {
3223             return E1000_SUCCESS;
3224         }
3225         msleep(100);
3226     }
3227     return E1000_SUCCESS;
3228 }
3229
3230 /******************************************************************************
3231 * Raises the Management Data Clock
3232 *
3233 * hw - Struct containing variables accessed by shared code
3234 * ctrl - Device control register's current value
3235 ******************************************************************************/
3236 static void e1000_raise_mdi_clk(struct e1000_hw *hw, u32 *ctrl)
3237 {
3238     /* Raise the clock input to the Management Data Clock (by setting the MDC
3239      * bit), and then delay 10 microseconds.
3240      */
3241     ew32(CTRL, (*ctrl | E1000_CTRL_MDC));
3242     E1000_WRITE_FLUSH();
3243     udelay(10);
3244 }
3245
3246 /******************************************************************************
3247 * Lowers the Management Data Clock
3248 *
3249 * hw - Struct containing variables accessed by shared code
3250 * ctrl - Device control register's current value
3251 ******************************************************************************/
3252 static void e1000_lower_mdi_clk(struct e1000_hw *hw, u32 *ctrl)
3253 {
3254     /* Lower the clock input to the Management Data Clock (by clearing the MDC
3255      * bit), and then delay 10 microseconds.
3256      */
3257     ew32(CTRL, (*ctrl & ~E1000_CTRL_MDC));
3258     E1000_WRITE_FLUSH();
3259     udelay(10);
3260 }
3261
3262 /******************************************************************************
3263 * Shifts data bits out to the PHY
3264 *
3265 * hw - Struct containing variables accessed by shared code
3266 * data - Data to send out to the PHY
3267 * count - Number of bits to shift out
3268 *
3269 * Bits are shifted out in MSB to LSB order.
3270 ******************************************************************************/
3271 static void e1000_shift_out_mdi_bits(struct e1000_hw *hw, u32 data, u16 count)
3272 {
3273     u32 ctrl;
3274     u32 mask;
3275
3276     /* We need to shift "count" number of bits out to the PHY. So, the value
3277      * in the "data" parameter will be shifted out to the PHY one bit at a
3278      * time. In order to do this, "data" must be broken down into bits.
3279      */
3280     mask = 0x01;
3281     mask <<= (count - 1);
3282
3283     ctrl = er32(CTRL);
3284
3285     /* Set MDIO_DIR and MDC_DIR direction bits to be used as output pins. */
3286     ctrl |= (E1000_CTRL_MDIO_DIR | E1000_CTRL_MDC_DIR);
3287
3288     while (mask) {
3289         /* A "1" is shifted out to the PHY by setting the MDIO bit to "1" and
3290          * then raising and lowering the Management Data Clock. A "0" is
3291          * shifted out to the PHY by setting the MDIO bit to "0" and then
3292          * raising and lowering the clock.
3293          */
3294         if (data & mask)
3295             ctrl |= E1000_CTRL_MDIO;
3296         else
3297             ctrl &= ~E1000_CTRL_MDIO;
3298
3299         ew32(CTRL, ctrl);
3300         E1000_WRITE_FLUSH();
3301
3302         udelay(10);
3303
3304         e1000_raise_mdi_clk(hw, &ctrl);
3305         e1000_lower_mdi_clk(hw, &ctrl);
3306
3307         mask = mask >> 1;
3308     }
3309 }
3310
3311 /******************************************************************************
3312 * Shifts data bits in from the PHY
3313 *
3314 * hw - Struct containing variables accessed by shared code
3315 *
3316 * Bits are shifted in in MSB to LSB order.
3317 ******************************************************************************/
3318 static u16 e1000_shift_in_mdi_bits(struct e1000_hw *hw)
3319 {
3320     u32 ctrl;
3321     u16 data = 0;
3322     u8 i;
3323
3324     /* In order to read a register from the PHY, we need to shift in a total
3325      * of 18 bits from the PHY. The first two bit (turnaround) times are used
3326      * to avoid contention on the MDIO pin when a read operation is performed.
3327      * These two bits are ignored by us and thrown away. Bits are "shifted in"
3328      * by raising the input to the Management Data Clock (setting the MDC bit),
3329      * and then reading the value of the MDIO bit.
3330      */
3331     ctrl = er32(CTRL);
3332
3333     /* Clear MDIO_DIR (SWDPIO1) to indicate this bit is to be used as input. */
3334     ctrl &= ~E1000_CTRL_MDIO_DIR;
3335     ctrl &= ~E1000_CTRL_MDIO;
3336
3337     ew32(CTRL, ctrl);
3338     E1000_WRITE_FLUSH();
3339
3340     /* Raise and Lower the clock before reading in the data. This accounts for
3341      * the turnaround bits. The first clock occurred when we clocked out the
3342      * last bit of the Register Address.
3343      */
3344     e1000_raise_mdi_clk(hw, &ctrl);
3345     e1000_lower_mdi_clk(hw, &ctrl);
3346
3347     for (data = 0, i = 0; i < 16; i++) {
3348         data = data << 1;
3349         e1000_raise_mdi_clk(hw, &ctrl);
3350         ctrl = er32(CTRL);
3351         /* Check to see if we shifted in a "1". */
3352         if (ctrl & E1000_CTRL_MDIO)
3353             data |= 1;
3354         e1000_lower_mdi_clk(hw, &ctrl);
3355     }
3356
3357     e1000_raise_mdi_clk(hw, &ctrl);
3358     e1000_lower_mdi_clk(hw, &ctrl);
3359
3360     return data;
3361 }
3362
3363 static s32 e1000_swfw_sync_acquire(struct e1000_hw *hw, u16 mask)
3364 {
3365     u32 swfw_sync = 0;
3366     u32 swmask = mask;
3367     u32 fwmask = mask << 16;
3368     s32 timeout = 200;
3369
3370     DEBUGFUNC("e1000_swfw_sync_acquire");
3371
3372     if (hw->swfwhw_semaphore_present)
3373         return e1000_get_software_flag(hw);
3374
3375     if (!hw->swfw_sync_present)
3376         return e1000_get_hw_eeprom_semaphore(hw);
3377
3378     while (timeout) {
3379             if (e1000_get_hw_eeprom_semaphore(hw))
3380                 return -E1000_ERR_SWFW_SYNC;
3381
3382             swfw_sync = er32(SW_FW_SYNC);
3383             if (!(swfw_sync & (fwmask | swmask))) {
3384                 break;
3385             }
3386
3387             /* firmware currently using resource (fwmask) */
3388             /* or other software thread currently using resource (swmask) */
3389             e1000_put_hw_eeprom_semaphore(hw);
3390             mdelay(5);
3391             timeout--;
3392     }
3393
3394     if (!timeout) {
3395         DEBUGOUT("Driver can't access resource, SW_FW_SYNC timeout.\n");
3396         return -E1000_ERR_SWFW_SYNC;
3397     }
3398
3399     swfw_sync |= swmask;
3400     ew32(SW_FW_SYNC, swfw_sync);
3401
3402     e1000_put_hw_eeprom_semaphore(hw);
3403     return E1000_SUCCESS;
3404 }
3405
3406 static void e1000_swfw_sync_release(struct e1000_hw *hw, u16 mask)
3407 {
3408     u32 swfw_sync;
3409     u32 swmask = mask;
3410
3411     DEBUGFUNC("e1000_swfw_sync_release");
3412
3413     if (hw->swfwhw_semaphore_present) {
3414         e1000_release_software_flag(hw);
3415         return;
3416     }
3417
3418     if (!hw->swfw_sync_present) {
3419         e1000_put_hw_eeprom_semaphore(hw);
3420         return;
3421     }
3422
3423     /* if (e1000_get_hw_eeprom_semaphore(hw))
3424      *    return -E1000_ERR_SWFW_SYNC; */
3425     while (e1000_get_hw_eeprom_semaphore(hw) != E1000_SUCCESS);
3426         /* empty */
3427
3428     swfw_sync = er32(SW_FW_SYNC);
3429     swfw_sync &= ~swmask;
3430     ew32(SW_FW_SYNC, swfw_sync);
3431
3432     e1000_put_hw_eeprom_semaphore(hw);
3433 }
3434
3435 /*****************************************************************************
3436 * Reads the value from a PHY register, if the value is on a specific non zero
3437 * page, sets the page first.
3438 * hw - Struct containing variables accessed by shared code
3439 * reg_addr - address of the PHY register to read
3440 ******************************************************************************/
3441 s32 e1000_read_phy_reg(struct e1000_hw *hw, u32 reg_addr, u16 *phy_data)
3442 {
3443     u32 ret_val;
3444     u16 swfw;
3445
3446     DEBUGFUNC("e1000_read_phy_reg");
3447
3448     if ((hw->mac_type == e1000_80003es2lan) &&
3449         (er32(STATUS) & E1000_STATUS_FUNC_1)) {
3450         swfw = E1000_SWFW_PHY1_SM;
3451     } else {
3452         swfw = E1000_SWFW_PHY0_SM;
3453     }
3454     if (e1000_swfw_sync_acquire(hw, swfw))
3455         return -E1000_ERR_SWFW_SYNC;
3456
3457     if ((hw->phy_type == e1000_phy_igp ||
3458         hw->phy_type == e1000_phy_igp_3 ||
3459         hw->phy_type == e1000_phy_igp_2) &&
3460        (reg_addr > MAX_PHY_MULTI_PAGE_REG)) {
3461         ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT,
3462                                          (u16)reg_addr);
3463         if (ret_val) {
3464             e1000_swfw_sync_release(hw, swfw);
3465             return ret_val;
3466         }
3467     } else if (hw->phy_type == e1000_phy_gg82563) {
3468         if (((reg_addr & MAX_PHY_REG_ADDRESS) > MAX_PHY_MULTI_PAGE_REG) ||
3469             (hw->mac_type == e1000_80003es2lan)) {
3470             /* Select Configuration Page */
3471             if ((reg_addr & MAX_PHY_REG_ADDRESS) < GG82563_MIN_ALT_REG) {
3472                 ret_val = e1000_write_phy_reg_ex(hw, GG82563_PHY_PAGE_SELECT,
3473                           (u16)((u16)reg_addr >> GG82563_PAGE_SHIFT));
3474             } else {
3475                 /* Use Alternative Page Select register to access
3476                  * registers 30 and 31
3477                  */
3478                 ret_val = e1000_write_phy_reg_ex(hw,
3479                                                  GG82563_PHY_PAGE_SELECT_ALT,
3480                           (u16)((u16)reg_addr >> GG82563_PAGE_SHIFT));
3481             }
3482
3483             if (ret_val) {
3484                 e1000_swfw_sync_release(hw, swfw);
3485                 return ret_val;
3486             }
3487         }
3488     }
3489
3490     ret_val = e1000_read_phy_reg_ex(hw, MAX_PHY_REG_ADDRESS & reg_addr,
3491                                     phy_data);
3492
3493     e1000_swfw_sync_release(hw, swfw);
3494     return ret_val;
3495 }
3496
3497 static s32 e1000_read_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
3498                                  u16 *phy_data)
3499 {
3500     u32 i;
3501     u32 mdic = 0;
3502     const u32 phy_addr = 1;
3503
3504     DEBUGFUNC("e1000_read_phy_reg_ex");
3505
3506     if (reg_addr > MAX_PHY_REG_ADDRESS) {
3507         DEBUGOUT1("PHY Address %d is out of range\n", reg_addr);
3508         return -E1000_ERR_PARAM;
3509     }
3510
3511     if (hw->mac_type > e1000_82543) {
3512         /* Set up Op-code, Phy Address, and register address in the MDI
3513          * Control register.  The MAC will take care of interfacing with the
3514          * PHY to retrieve the desired data.
3515          */
3516         mdic = ((reg_addr << E1000_MDIC_REG_SHIFT) |
3517                 (phy_addr << E1000_MDIC_PHY_SHIFT) |
3518                 (E1000_MDIC_OP_READ));
3519
3520         ew32(MDIC, mdic);
3521
3522         /* Poll the ready bit to see if the MDI read completed */
3523         for (i = 0; i < 64; i++) {
3524             udelay(50);
3525             mdic = er32(MDIC);
3526             if (mdic & E1000_MDIC_READY) break;
3527         }
3528         if (!(mdic & E1000_MDIC_READY)) {
3529             DEBUGOUT("MDI Read did not complete\n");
3530             return -E1000_ERR_PHY;
3531         }
3532         if (mdic & E1000_MDIC_ERROR) {
3533             DEBUGOUT("MDI Error\n");
3534             return -E1000_ERR_PHY;
3535         }
3536         *phy_data = (u16)mdic;
3537     } else {
3538         /* We must first send a preamble through the MDIO pin to signal the
3539          * beginning of an MII instruction.  This is done by sending 32
3540          * consecutive "1" bits.
3541          */
3542         e1000_shift_out_mdi_bits(hw, PHY_PREAMBLE, PHY_PREAMBLE_SIZE);
3543
3544         /* Now combine the next few fields that are required for a read
3545          * operation.  We use this method instead of calling the
3546          * e1000_shift_out_mdi_bits routine five different times. The format of
3547          * a MII read instruction consists of a shift out of 14 bits and is
3548          * defined as follows:
3549          *    <Preamble><SOF><Op Code><Phy Addr><Reg Addr>
3550          * followed by a shift in of 18 bits.  This first two bits shifted in
3551          * are TurnAround bits used to avoid contention on the MDIO pin when a
3552          * READ operation is performed.  These two bits are thrown away
3553          * followed by a shift in of 16 bits which contains the desired data.
3554          */
3555         mdic = ((reg_addr) | (phy_addr << 5) |
3556                 (PHY_OP_READ << 10) | (PHY_SOF << 12));
3557
3558         e1000_shift_out_mdi_bits(hw, mdic, 14);
3559
3560         /* Now that we've shifted out the read command to the MII, we need to
3561          * "shift in" the 16-bit value (18 total bits) of the requested PHY
3562          * register address.
3563          */
3564         *phy_data = e1000_shift_in_mdi_bits(hw);
3565     }
3566     return E1000_SUCCESS;
3567 }
3568
3569 /******************************************************************************
3570 * Writes a value to a PHY register
3571 *
3572 * hw - Struct containing variables accessed by shared code
3573 * reg_addr - address of the PHY register to write
3574 * data - data to write to the PHY
3575 ******************************************************************************/
3576 s32 e1000_write_phy_reg(struct e1000_hw *hw, u32 reg_addr, u16 phy_data)
3577 {
3578     u32 ret_val;
3579     u16 swfw;
3580
3581     DEBUGFUNC("e1000_write_phy_reg");
3582
3583     if ((hw->mac_type == e1000_80003es2lan) &&
3584         (er32(STATUS) & E1000_STATUS_FUNC_1)) {
3585         swfw = E1000_SWFW_PHY1_SM;
3586     } else {
3587         swfw = E1000_SWFW_PHY0_SM;
3588     }
3589     if (e1000_swfw_sync_acquire(hw, swfw))
3590         return -E1000_ERR_SWFW_SYNC;
3591
3592     if ((hw->phy_type == e1000_phy_igp ||
3593         hw->phy_type == e1000_phy_igp_3 ||
3594         hw->phy_type == e1000_phy_igp_2) &&
3595        (reg_addr > MAX_PHY_MULTI_PAGE_REG)) {
3596         ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT,
3597                                          (u16)reg_addr);
3598         if (ret_val) {
3599             e1000_swfw_sync_release(hw, swfw);
3600             return ret_val;
3601         }
3602     } else if (hw->phy_type == e1000_phy_gg82563) {
3603         if (((reg_addr & MAX_PHY_REG_ADDRESS) > MAX_PHY_MULTI_PAGE_REG) ||
3604             (hw->mac_type == e1000_80003es2lan)) {
3605             /* Select Configuration Page */
3606             if ((reg_addr & MAX_PHY_REG_ADDRESS) < GG82563_MIN_ALT_REG) {
3607                 ret_val = e1000_write_phy_reg_ex(hw, GG82563_PHY_PAGE_SELECT,
3608                           (u16)((u16)reg_addr >> GG82563_PAGE_SHIFT));
3609             } else {
3610                 /* Use Alternative Page Select register to access
3611                  * registers 30 and 31
3612                  */
3613                 ret_val = e1000_write_phy_reg_ex(hw,
3614                                                  GG82563_PHY_PAGE_SELECT_ALT,
3615                           (u16)((u16)reg_addr >> GG82563_PAGE_SHIFT));
3616             }
3617
3618             if (ret_val) {
3619                 e1000_swfw_sync_release(hw, swfw);
3620                 return ret_val;
3621             }
3622         }
3623     }
3624
3625     ret_val = e1000_write_phy_reg_ex(hw, MAX_PHY_REG_ADDRESS & reg_addr,
3626                                      phy_data);
3627
3628     e1000_swfw_sync_release(hw, swfw);
3629     return ret_val;
3630 }
3631
3632 static s32 e1000_write_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
3633                                   u16 phy_data)
3634 {
3635     u32 i;
3636     u32 mdic = 0;
3637     const u32 phy_addr = 1;
3638
3639     DEBUGFUNC("e1000_write_phy_reg_ex");
3640
3641     if (reg_addr > MAX_PHY_REG_ADDRESS) {
3642         DEBUGOUT1("PHY Address %d is out of range\n", reg_addr);
3643         return -E1000_ERR_PARAM;
3644     }
3645
3646     if (hw->mac_type > e1000_82543) {
3647         /* Set up Op-code, Phy Address, register address, and data intended
3648          * for the PHY register in the MDI Control register.  The MAC will take
3649          * care of interfacing with the PHY to send the desired data.
3650          */
3651         mdic = (((u32)phy_data) |
3652                 (reg_addr << E1000_MDIC_REG_SHIFT) |
3653                 (phy_addr << E1000_MDIC_PHY_SHIFT) |
3654                 (E1000_MDIC_OP_WRITE));
3655
3656         ew32(MDIC, mdic);
3657
3658         /* Poll the ready bit to see if the MDI read completed */
3659         for (i = 0; i < 641; i++) {
3660             udelay(5);
3661             mdic = er32(MDIC);
3662             if (mdic & E1000_MDIC_READY) break;
3663         }
3664         if (!(mdic & E1000_MDIC_READY)) {
3665             DEBUGOUT("MDI Write did not complete\n");
3666             return -E1000_ERR_PHY;
3667         }
3668     } else {
3669         /* We'll need to use the SW defined pins to shift the write command
3670          * out to the PHY. We first send a preamble to the PHY to signal the
3671          * beginning of the MII instruction.  This is done by sending 32
3672          * consecutive "1" bits.
3673          */
3674         e1000_shift_out_mdi_bits(hw, PHY_PREAMBLE, PHY_PREAMBLE_SIZE);
3675
3676         /* Now combine the remaining required fields that will indicate a
3677          * write operation. We use this method instead of calling the
3678          * e1000_shift_out_mdi_bits routine for each field in the command. The
3679          * format of a MII write instruction is as follows:
3680          * <Preamble><SOF><Op Code><Phy Addr><Reg Addr><Turnaround><Data>.
3681          */
3682         mdic = ((PHY_TURNAROUND) | (reg_addr << 2) | (phy_addr << 7) |
3683                 (PHY_OP_WRITE << 12) | (PHY_SOF << 14));
3684         mdic <<= 16;
3685         mdic |= (u32)phy_data;
3686
3687         e1000_shift_out_mdi_bits(hw, mdic, 32);
3688     }
3689
3690     return E1000_SUCCESS;
3691 }
3692
3693 static s32 e1000_read_kmrn_reg(struct e1000_hw *hw, u32 reg_addr, u16 *data)
3694 {
3695     u32 reg_val;
3696     u16 swfw;
3697     DEBUGFUNC("e1000_read_kmrn_reg");
3698
3699     if ((hw->mac_type == e1000_80003es2lan) &&
3700         (er32(STATUS) & E1000_STATUS_FUNC_1)) {
3701         swfw = E1000_SWFW_PHY1_SM;
3702     } else {
3703         swfw = E1000_SWFW_PHY0_SM;
3704     }
3705     if (e1000_swfw_sync_acquire(hw, swfw))
3706         return -E1000_ERR_SWFW_SYNC;
3707
3708     /* Write register address */
3709     reg_val = ((reg_addr << E1000_KUMCTRLSTA_OFFSET_SHIFT) &
3710               E1000_KUMCTRLSTA_OFFSET) |
3711               E1000_KUMCTRLSTA_REN;
3712     ew32(KUMCTRLSTA, reg_val);
3713     udelay(2);
3714
3715     /* Read the data returned */
3716     reg_val = er32(KUMCTRLSTA);
3717     *data = (u16)reg_val;
3718
3719     e1000_swfw_sync_release(hw, swfw);
3720     return E1000_SUCCESS;
3721 }
3722
3723 static s32 e1000_write_kmrn_reg(struct e1000_hw *hw, u32 reg_addr, u16 data)
3724 {
3725     u32 reg_val;
3726     u16 swfw;
3727     DEBUGFUNC("e1000_write_kmrn_reg");
3728
3729     if ((hw->mac_type == e1000_80003es2lan) &&
3730         (er32(STATUS) & E1000_STATUS_FUNC_1)) {
3731         swfw = E1000_SWFW_PHY1_SM;
3732     } else {
3733         swfw = E1000_SWFW_PHY0_SM;
3734     }
3735     if (e1000_swfw_sync_acquire(hw, swfw))
3736         return -E1000_ERR_SWFW_SYNC;
3737
3738     reg_val = ((reg_addr << E1000_KUMCTRLSTA_OFFSET_SHIFT) &
3739               E1000_KUMCTRLSTA_OFFSET) | data;
3740     ew32(KUMCTRLSTA, reg_val);
3741     udelay(2);
3742
3743     e1000_swfw_sync_release(hw, swfw);
3744     return E1000_SUCCESS;
3745 }
3746
3747 /******************************************************************************
3748 * Returns the PHY to the power-on reset state
3749 *
3750 * hw - Struct containing variables accessed by shared code
3751 ******************************************************************************/
3752 s32 e1000_phy_hw_reset(struct e1000_hw *hw)
3753 {
3754     u32 ctrl, ctrl_ext;
3755     u32 led_ctrl;
3756     s32 ret_val;
3757     u16 swfw;
3758
3759     DEBUGFUNC("e1000_phy_hw_reset");
3760
3761     /* In the case of the phy reset being blocked, it's not an error, we
3762      * simply return success without performing the reset. */
3763     ret_val = e1000_check_phy_reset_block(hw);
3764     if (ret_val)
3765         return E1000_SUCCESS;
3766
3767     DEBUGOUT("Resetting Phy...\n");
3768
3769     if (hw->mac_type > e1000_82543) {
3770         if ((hw->mac_type == e1000_80003es2lan) &&
3771             (er32(STATUS) & E1000_STATUS_FUNC_1)) {
3772             swfw = E1000_SWFW_PHY1_SM;
3773         } else {
3774             swfw = E1000_SWFW_PHY0_SM;
3775         }
3776         if (e1000_swfw_sync_acquire(hw, swfw)) {
3777             DEBUGOUT("Unable to acquire swfw sync\n");
3778             return -E1000_ERR_SWFW_SYNC;
3779         }
3780         /* Read the device control register and assert the E1000_CTRL_PHY_RST
3781          * bit. Then, take it out of reset.
3782          * For pre-e1000_82571 hardware, we delay for 10ms between the assert
3783          * and deassert.  For e1000_82571 hardware and later, we instead delay
3784          * for 50us between and 10ms after the deassertion.
3785          */
3786         ctrl = er32(CTRL);
3787         ew32(CTRL, ctrl | E1000_CTRL_PHY_RST);
3788         E1000_WRITE_FLUSH();
3789
3790         if (hw->mac_type < e1000_82571)
3791             msleep(10);
3792         else
3793             udelay(100);
3794
3795         ew32(CTRL, ctrl);
3796         E1000_WRITE_FLUSH();
3797
3798         if (hw->mac_type >= e1000_82571)
3799             mdelay(10);
3800
3801         e1000_swfw_sync_release(hw, swfw);
3802     } else {
3803         /* Read the Extended Device Control Register, assert the PHY_RESET_DIR
3804          * bit to put the PHY into reset. Then, take it out of reset.
3805          */
3806         ctrl_ext = er32(CTRL_EXT);
3807         ctrl_ext |= E1000_CTRL_EXT_SDP4_DIR;
3808         ctrl_ext &= ~E1000_CTRL_EXT_SDP4_DATA;
3809         ew32(CTRL_EXT, ctrl_ext);
3810         E1000_WRITE_FLUSH();
3811         msleep(10);
3812         ctrl_ext |= E1000_CTRL_EXT_SDP4_DATA;
3813         ew32(CTRL_EXT, ctrl_ext);
3814         E1000_WRITE_FLUSH();
3815     }
3816     udelay(150);
3817
3818     if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
3819         /* Configure activity LED after PHY reset */
3820         led_ctrl = er32(LEDCTL);
3821         led_ctrl &= IGP_ACTIVITY_LED_MASK;
3822         led_ctrl |= (IGP_ACTIVITY_LED_ENABLE | IGP_LED3_MODE);
3823         ew32(LEDCTL, led_ctrl);
3824     }
3825
3826     /* Wait for FW to finish PHY configuration. */
3827     ret_val = e1000_get_phy_cfg_done(hw);
3828     if (ret_val != E1000_SUCCESS)
3829         return ret_val;
3830     e1000_release_software_semaphore(hw);
3831
3832     if ((hw->mac_type == e1000_ich8lan) && (hw->phy_type == e1000_phy_igp_3))
3833         ret_val = e1000_init_lcd_from_nvm(hw);
3834
3835     return ret_val;
3836 }
3837
3838 /******************************************************************************
3839 * Resets the PHY
3840 *
3841 * hw - Struct containing variables accessed by shared code
3842 *
3843 * Sets bit 15 of the MII Control register
3844 ******************************************************************************/
3845 s32 e1000_phy_reset(struct e1000_hw *hw)
3846 {
3847     s32 ret_val;
3848     u16 phy_data;
3849
3850     DEBUGFUNC("e1000_phy_reset");
3851
3852     /* In the case of the phy reset being blocked, it's not an error, we
3853      * simply return success without performing the reset. */
3854     ret_val = e1000_check_phy_reset_block(hw);
3855     if (ret_val)
3856         return E1000_SUCCESS;
3857
3858     switch (hw->phy_type) {
3859     case e1000_phy_igp:
3860     case e1000_phy_igp_2:
3861     case e1000_phy_igp_3:
3862     case e1000_phy_ife:
3863         ret_val = e1000_phy_hw_reset(hw);
3864         if (ret_val)
3865             return ret_val;
3866         break;
3867     default:
3868         ret_val = e1000_read_phy_reg(hw, PHY_CTRL, &phy_data);
3869         if (ret_val)
3870             return ret_val;
3871
3872         phy_data |= MII_CR_RESET;
3873         ret_val = e1000_write_phy_reg(hw, PHY_CTRL, phy_data);
3874         if (ret_val)
3875             return ret_val;
3876
3877         udelay(1);
3878         break;
3879     }
3880
3881     if (hw->phy_type == e1000_phy_igp || hw->phy_type == e1000_phy_igp_2)
3882         e1000_phy_init_script(hw);
3883
3884     return E1000_SUCCESS;
3885 }
3886
3887 /******************************************************************************
3888 * Work-around for 82566 power-down: on D3 entry-
3889 * 1) disable gigabit link
3890 * 2) write VR power-down enable
3891 * 3) read it back
3892 * if successful continue, else issue LCD reset and repeat
3893 *
3894 * hw - struct containing variables accessed by shared code
3895 ******************************************************************************/
3896 void e1000_phy_powerdown_workaround(struct e1000_hw *hw)
3897 {
3898     s32 reg;
3899     u16 phy_data;
3900     s32 retry = 0;
3901
3902     DEBUGFUNC("e1000_phy_powerdown_workaround");
3903
3904     if (hw->phy_type != e1000_phy_igp_3)
3905         return;
3906
3907     do {
3908         /* Disable link */
3909         reg = er32(PHY_CTRL);
3910         ew32(PHY_CTRL, reg | E1000_PHY_CTRL_GBE_DISABLE |
3911                         E1000_PHY_CTRL_NOND0A_GBE_DISABLE);
3912
3913         /* Write VR power-down enable - bits 9:8 should be 10b */
3914         e1000_read_phy_reg(hw, IGP3_VR_CTRL, &phy_data);
3915         phy_data |= (1 << 9);
3916         phy_data &= ~(1 << 8);
3917         e1000_write_phy_reg(hw, IGP3_VR_CTRL, phy_data);
3918
3919         /* Read it back and test */
3920         e1000_read_phy_reg(hw, IGP3_VR_CTRL, &phy_data);
3921         if (((phy_data & IGP3_VR_CTRL_MODE_MASK) == IGP3_VR_CTRL_MODE_SHUT) || retry)
3922             break;
3923
3924         /* Issue PHY reset and repeat at most one more time */
3925         reg = er32(CTRL);
3926         ew32(CTRL, reg | E1000_CTRL_PHY_RST);
3927         retry++;
3928     } while (retry);
3929
3930     return;
3931
3932 }
3933
3934 /******************************************************************************
3935 * Work-around for 82566 Kumeran PCS lock loss:
3936 * On link status change (i.e. PCI reset, speed change) and link is up and
3937 * speed is gigabit-
3938 * 0) if workaround is optionally disabled do nothing
3939 * 1) wait 1ms for Kumeran link to come up
3940 * 2) check Kumeran Diagnostic register PCS lock loss bit
3941 * 3) if not set the link is locked (all is good), otherwise...
3942 * 4) reset the PHY
3943 * 5) repeat up to 10 times
3944 * Note: this is only called for IGP3 copper when speed is 1gb.
3945 *
3946 * hw - struct containing variables accessed by shared code
3947 ******************************************************************************/
3948 static s32 e1000_kumeran_lock_loss_workaround(struct e1000_hw *hw)
3949 {
3950     s32 ret_val;
3951     s32 reg;
3952     s32 cnt;
3953     u16 phy_data;
3954
3955     if (hw->kmrn_lock_loss_workaround_disabled)
3956         return E1000_SUCCESS;
3957
3958     /* Make sure link is up before proceeding.  If not just return.
3959      * Attempting this while link is negotiating fouled up link
3960      * stability */
3961     ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
3962     ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
3963
3964     if (phy_data & MII_SR_LINK_STATUS) {
3965         for (cnt = 0; cnt < 10; cnt++) {
3966             /* read once to clear */
3967             ret_val = e1000_read_phy_reg(hw, IGP3_KMRN_DIAG, &phy_data);
3968             if (ret_val)
3969                 return ret_val;
3970             /* and again to get new status */
3971             ret_val = e1000_read_phy_reg(hw, IGP3_KMRN_DIAG, &phy_data);
3972             if (ret_val)
3973                 return ret_val;
3974
3975             /* check for PCS lock */
3976             if (!(phy_data & IGP3_KMRN_DIAG_PCS_LOCK_LOSS))
3977                 return E1000_SUCCESS;
3978
3979             /* Issue PHY reset */
3980             e1000_phy_hw_reset(hw);
3981             mdelay(5);
3982         }
3983         /* Disable GigE link negotiation */
3984         reg = er32(PHY_CTRL);
3985         ew32(PHY_CTRL, reg | E1000_PHY_CTRL_GBE_DISABLE |
3986                         E1000_PHY_CTRL_NOND0A_GBE_DISABLE);
3987
3988         /* unable to acquire PCS lock */
3989         return E1000_ERR_PHY;
3990     }
3991
3992     return E1000_SUCCESS;
3993 }
3994
3995 /******************************************************************************
3996 * Probes the expected PHY address for known PHY IDs
3997 *
3998 * hw - Struct containing variables accessed by shared code
3999 ******************************************************************************/
4000 static s32 e1000_detect_gig_phy(struct e1000_hw *hw)
4001 {
4002     s32 phy_init_status, ret_val;
4003     u16 phy_id_high, phy_id_low;
4004     bool match = false;
4005
4006     DEBUGFUNC("e1000_detect_gig_phy");
4007
4008     if (hw->phy_id != 0)
4009         return E1000_SUCCESS;
4010
4011     /* The 82571 firmware may still be configuring the PHY.  In this
4012      * case, we cannot access the PHY until the configuration is done.  So
4013      * we explicitly set the PHY values. */
4014     if (hw->mac_type == e1000_82571 ||
4015         hw->mac_type == e1000_82572) {
4016         hw->phy_id = IGP01E1000_I_PHY_ID;
4017         hw->phy_type = e1000_phy_igp_2;
4018         return E1000_SUCCESS;
4019     }
4020
4021     /* ESB-2 PHY reads require e1000_phy_gg82563 to be set because of a work-
4022      * around that forces PHY page 0 to be set or the reads fail.  The rest of
4023      * the code in this routine uses e1000_read_phy_reg to read the PHY ID.
4024      * So for ESB-2 we need to have this set so our reads won't fail.  If the
4025      * attached PHY is not a e1000_phy_gg82563, the routines below will figure
4026      * this out as well. */
4027     if (hw->mac_type == e1000_80003es2lan)
4028         hw->phy_type = e1000_phy_gg82563;
4029
4030     /* Read the PHY ID Registers to identify which PHY is onboard. */
4031     ret_val = e1000_read_phy_reg(hw, PHY_ID1, &phy_id_high);
4032     if (ret_val)
4033         return ret_val;
4034
4035     hw->phy_id = (u32)(phy_id_high << 16);
4036     udelay(20);
4037     ret_val = e1000_read_phy_reg(hw, PHY_ID2, &phy_id_low);
4038     if (ret_val)
4039         return ret_val;
4040
4041     hw->phy_id |= (u32)(phy_id_low & PHY_REVISION_MASK);
4042     hw->phy_revision = (u32)phy_id_low & ~PHY_REVISION_MASK;
4043
4044     switch (hw->mac_type) {
4045     case e1000_82543:
4046         if (hw->phy_id == M88E1000_E_PHY_ID) match = true;
4047         break;
4048     case e1000_82544:
4049         if (hw->phy_id == M88E1000_I_PHY_ID) match = true;
4050         break;
4051     case e1000_82540:
4052     case e1000_82545:
4053     case e1000_82545_rev_3:
4054     case e1000_82546:
4055     case e1000_82546_rev_3:
4056         if (hw->phy_id == M88E1011_I_PHY_ID) match = true;
4057         break;
4058     case e1000_82541:
4059     case e1000_82541_rev_2:
4060     case e1000_82547:
4061     case e1000_82547_rev_2:
4062         if (hw->phy_id == IGP01E1000_I_PHY_ID) match = true;
4063         break;
4064     case e1000_82573:
4065         if (hw->phy_id == M88E1111_I_PHY_ID) match = true;
4066         break;
4067     case e1000_80003es2lan:
4068         if (hw->phy_id == GG82563_E_PHY_ID) match = true;
4069         break;
4070     case e1000_ich8lan:
4071         if (hw->phy_id == IGP03E1000_E_PHY_ID) match = true;
4072         if (hw->phy_id == IFE_E_PHY_ID) match = true;
4073         if (hw->phy_id == IFE_PLUS_E_PHY_ID) match = true;
4074         if (hw->phy_id == IFE_C_E_PHY_ID) match = true;
4075         break;
4076     default:
4077         DEBUGOUT1("Invalid MAC type %d\n", hw->mac_type);
4078         return -E1000_ERR_CONFIG;
4079     }
4080     phy_init_status = e1000_set_phy_type(hw);
4081
4082     if ((match) && (phy_init_status == E1000_SUCCESS)) {
4083         DEBUGOUT1("PHY ID 0x%X detected\n", hw->phy_id);
4084         return E1000_SUCCESS;
4085     }
4086     DEBUGOUT1("Invalid PHY ID 0x%X\n", hw->phy_id);
4087     return -E1000_ERR_PHY;
4088 }
4089
4090 /******************************************************************************
4091 * Resets the PHY's DSP
4092 *
4093 * hw - Struct containing variables accessed by shared code
4094 ******************************************************************************/
4095 static s32 e1000_phy_reset_dsp(struct e1000_hw *hw)
4096 {
4097     s32 ret_val;
4098     DEBUGFUNC("e1000_phy_reset_dsp");
4099
4100     do {
4101         if (hw->phy_type != e1000_phy_gg82563) {
4102             ret_val = e1000_write_phy_reg(hw, 29, 0x001d);
4103             if (ret_val) break;
4104         }
4105         ret_val = e1000_write_phy_reg(hw, 30, 0x00c1);
4106         if (ret_val) break;
4107         ret_val = e1000_write_phy_reg(hw, 30, 0x0000);
4108         if (ret_val) break;
4109         ret_val = E1000_SUCCESS;
4110     } while (0);
4111
4112     return ret_val;
4113 }
4114
4115 /******************************************************************************
4116 * Get PHY information from various PHY registers for igp PHY only.
4117 *
4118 * hw - Struct containing variables accessed by shared code
4119 * phy_info - PHY information structure
4120 ******************************************************************************/
4121 static s32 e1000_phy_igp_get_info(struct e1000_hw *hw,
4122                                   struct e1000_phy_info *phy_info)
4123 {
4124     s32 ret_val;
4125     u16 phy_data, min_length, max_length, average;
4126     e1000_rev_polarity polarity;
4127
4128     DEBUGFUNC("e1000_phy_igp_get_info");
4129
4130     /* The downshift status is checked only once, after link is established,
4131      * and it stored in the hw->speed_downgraded parameter. */
4132     phy_info->downshift = (e1000_downshift)hw->speed_downgraded;
4133
4134     /* IGP01E1000 does not need to support it. */
4135     phy_info->extended_10bt_distance = e1000_10bt_ext_dist_enable_normal;
4136
4137     /* IGP01E1000 always correct polarity reversal */
4138     phy_info->polarity_correction = e1000_polarity_reversal_enabled;
4139
4140     /* Check polarity status */
4141     ret_val = e1000_check_polarity(hw, &polarity);
4142     if (ret_val)
4143         return ret_val;
4144
4145     phy_info->cable_polarity = polarity;
4146
4147     ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_STATUS, &phy_data);
4148     if (ret_val)
4149         return ret_val;
4150
4151     phy_info->mdix_mode = (e1000_auto_x_mode)((phy_data & IGP01E1000_PSSR_MDIX) >>
4152                           IGP01E1000_PSSR_MDIX_SHIFT);
4153
4154     if ((phy_data & IGP01E1000_PSSR_SPEED_MASK) ==
4155        IGP01E1000_PSSR_SPEED_1000MBPS) {
4156         /* Local/Remote Receiver Information are only valid at 1000 Mbps */
4157         ret_val = e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_data);
4158         if (ret_val)
4159             return ret_val;
4160
4161         phy_info->local_rx = ((phy_data & SR_1000T_LOCAL_RX_STATUS) >>
4162                              SR_1000T_LOCAL_RX_STATUS_SHIFT) ?
4163                              e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok;
4164         phy_info->remote_rx = ((phy_data & SR_1000T_REMOTE_RX_STATUS) >>
4165                               SR_1000T_REMOTE_RX_STATUS_SHIFT) ?
4166                               e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok;
4167
4168         /* Get cable length */
4169         ret_val = e1000_get_cable_length(hw, &min_length, &max_length);
4170         if (ret_val)
4171             return ret_val;
4172
4173         /* Translate to old method */
4174         average = (max_length + min_length) / 2;
4175
4176         if (average <= e1000_igp_cable_length_50)
4177             phy_info->cable_length = e1000_cable_length_50;
4178         else if (average <= e1000_igp_cable_length_80)
4179             phy_info->cable_length = e1000_cable_length_50_80;
4180         else if (average <= e1000_igp_cable_length_110)
4181             phy_info->cable_length = e1000_cable_length_80_110;
4182         else if (average <= e1000_igp_cable_length_140)
4183             phy_info->cable_length = e1000_cable_length_110_140;
4184         else
4185             phy_info->cable_length = e1000_cable_length_140;
4186     }
4187
4188     return E1000_SUCCESS;
4189 }
4190
4191 /******************************************************************************
4192 * Get PHY information from various PHY registers for ife PHY only.
4193 *
4194 * hw - Struct containing variables accessed by shared code
4195 * phy_info - PHY information structure
4196 ******************************************************************************/
4197 static s32 e1000_phy_ife_get_info(struct e1000_hw *hw,
4198                                   struct e1000_phy_info *phy_info)
4199 {
4200     s32 ret_val;
4201     u16 phy_data;
4202     e1000_rev_polarity polarity;
4203
4204     DEBUGFUNC("e1000_phy_ife_get_info");
4205
4206     phy_info->downshift = (e1000_downshift)hw->speed_downgraded;
4207     phy_info->extended_10bt_distance = e1000_10bt_ext_dist_enable_normal;
4208
4209     ret_val = e1000_read_phy_reg(hw, IFE_PHY_SPECIAL_CONTROL, &phy_data);
4210     if (ret_val)
4211         return ret_val;
4212     phy_info->polarity_correction =
4213                         ((phy_data & IFE_PSC_AUTO_POLARITY_DISABLE) >>
4214                         IFE_PSC_AUTO_POLARITY_DISABLE_SHIFT) ?
4215                         e1000_polarity_reversal_disabled : e1000_polarity_reversal_enabled;
4216
4217     if (phy_info->polarity_correction == e1000_polarity_reversal_enabled) {
4218         ret_val = e1000_check_polarity(hw, &polarity);
4219         if (ret_val)
4220             return ret_val;
4221     } else {
4222         /* Polarity is forced. */
4223         polarity = ((phy_data & IFE_PSC_FORCE_POLARITY) >>
4224                      IFE_PSC_FORCE_POLARITY_SHIFT) ?
4225                      e1000_rev_polarity_reversed : e1000_rev_polarity_normal;
4226     }
4227     phy_info->cable_polarity = polarity;
4228
4229     ret_val = e1000_read_phy_reg(hw, IFE_PHY_MDIX_CONTROL, &phy_data);
4230     if (ret_val)
4231         return ret_val;
4232
4233     phy_info->mdix_mode = (e1000_auto_x_mode)
4234                      ((phy_data & (IFE_PMC_AUTO_MDIX | IFE_PMC_FORCE_MDIX)) >>
4235                      IFE_PMC_MDIX_MODE_SHIFT);
4236
4237     return E1000_SUCCESS;
4238 }
4239
4240 /******************************************************************************
4241 * Get PHY information from various PHY registers fot m88 PHY only.
4242 *
4243 * hw - Struct containing variables accessed by shared code
4244 * phy_info - PHY information structure
4245 ******************************************************************************/
4246 static s32 e1000_phy_m88_get_info(struct e1000_hw *hw,
4247                                   struct e1000_phy_info *phy_info)
4248 {
4249     s32 ret_val;
4250     u16 phy_data;
4251     e1000_rev_polarity polarity;
4252
4253     DEBUGFUNC("e1000_phy_m88_get_info");
4254
4255     /* The downshift status is checked only once, after link is established,
4256      * and it stored in the hw->speed_downgraded parameter. */
4257     phy_info->downshift = (e1000_downshift)hw->speed_downgraded;
4258
4259     ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
4260     if (ret_val)
4261         return ret_val;
4262
4263     phy_info->extended_10bt_distance =
4264         ((phy_data & M88E1000_PSCR_10BT_EXT_DIST_ENABLE) >>
4265         M88E1000_PSCR_10BT_EXT_DIST_ENABLE_SHIFT) ?
4266         e1000_10bt_ext_dist_enable_lower : e1000_10bt_ext_dist_enable_normal;
4267
4268     phy_info->polarity_correction =
4269         ((phy_data & M88E1000_PSCR_POLARITY_REVERSAL) >>
4270         M88E1000_PSCR_POLARITY_REVERSAL_SHIFT) ?
4271         e1000_polarity_reversal_disabled : e1000_polarity_reversal_enabled;
4272
4273     /* Check polarity status */
4274     ret_val = e1000_check_polarity(hw, &polarity);
4275     if (ret_val)
4276         return ret_val;
4277     phy_info->cable_polarity = polarity;
4278
4279     ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
4280     if (ret_val)
4281         return ret_val;
4282
4283     phy_info->mdix_mode = (e1000_auto_x_mode)((phy_data & M88E1000_PSSR_MDIX) >>
4284                           M88E1000_PSSR_MDIX_SHIFT);
4285
4286     if ((phy_data & M88E1000_PSSR_SPEED) == M88E1000_PSSR_1000MBS) {
4287         /* Cable Length Estimation and Local/Remote Receiver Information
4288          * are only valid at 1000 Mbps.
4289          */
4290         if (hw->phy_type != e1000_phy_gg82563) {
4291             phy_info->cable_length = (e1000_cable_length)((phy_data & M88E1000_PSSR_CABLE_LENGTH) >>
4292                                       M88E1000_PSSR_CABLE_LENGTH_SHIFT);
4293         } else {
4294             ret_val = e1000_read_phy_reg(hw, GG82563_PHY_DSP_DISTANCE,
4295                                          &phy_data);
4296             if (ret_val)
4297                 return ret_val;
4298
4299             phy_info->cable_length = (e1000_cable_length)(phy_data & GG82563_DSPD_CABLE_LENGTH);
4300         }
4301
4302         ret_val = e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_data);
4303         if (ret_val)
4304             return ret_val;
4305
4306         phy_info->local_rx = ((phy_data & SR_1000T_LOCAL_RX_STATUS) >>
4307                              SR_1000T_LOCAL_RX_STATUS_SHIFT) ?
4308                              e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok;
4309         phy_info->remote_rx = ((phy_data & SR_1000T_REMOTE_RX_STATUS) >>
4310                               SR_1000T_REMOTE_RX_STATUS_SHIFT) ?
4311                               e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok;
4312
4313     }
4314
4315     return E1000_SUCCESS;
4316 }
4317
4318 /******************************************************************************
4319 * Get PHY information from various PHY registers
4320 *
4321 * hw - Struct containing variables accessed by shared code
4322 * phy_info - PHY information structure
4323 ******************************************************************************/
4324 s32 e1000_phy_get_info(struct e1000_hw *hw, struct e1000_phy_info *phy_info)
4325 {
4326     s32 ret_val;
4327     u16 phy_data;
4328
4329     DEBUGFUNC("e1000_phy_get_info");
4330
4331     phy_info->cable_length = e1000_cable_length_undefined;
4332     phy_info->extended_10bt_distance = e1000_10bt_ext_dist_enable_undefined;
4333     phy_info->cable_polarity = e1000_rev_polarity_undefined;
4334     phy_info->downshift = e1000_downshift_undefined;
4335     phy_info->polarity_correction = e1000_polarity_reversal_undefined;
4336     phy_info->mdix_mode = e1000_auto_x_mode_undefined;
4337     phy_info->local_rx = e1000_1000t_rx_status_undefined;
4338     phy_info->remote_rx = e1000_1000t_rx_status_undefined;
4339
4340     if (hw->media_type != e1000_media_type_copper) {
4341         DEBUGOUT("PHY info is only valid for copper media\n");
4342         return -E1000_ERR_CONFIG;
4343     }
4344
4345     ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
4346     if (ret_val)
4347         return ret_val;
4348
4349     ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
4350     if (ret_val)
4351         return ret_val;
4352
4353     if ((phy_data & MII_SR_LINK_STATUS) != MII_SR_LINK_STATUS) {
4354         DEBUGOUT("PHY info is only valid if link is up\n");
4355         return -E1000_ERR_CONFIG;
4356     }
4357
4358     if (hw->phy_type == e1000_phy_igp ||
4359         hw->phy_type == e1000_phy_igp_3 ||
4360         hw->phy_type == e1000_phy_igp_2)
4361         return e1000_phy_igp_get_info(hw, phy_info);
4362     else if (hw->phy_type == e1000_phy_ife)
4363         return e1000_phy_ife_get_info(hw, phy_info);
4364     else
4365         return e1000_phy_m88_get_info(hw, phy_info);
4366 }
4367
4368 s32 e1000_validate_mdi_setting(struct e1000_hw *hw)
4369 {
4370     DEBUGFUNC("e1000_validate_mdi_settings");
4371
4372     if (!hw->autoneg && (hw->mdix == 0 || hw->mdix == 3)) {
4373         DEBUGOUT("Invalid MDI setting detected\n");
4374         hw->mdix = 1;
4375         return -E1000_ERR_CONFIG;
4376     }
4377     return E1000_SUCCESS;
4378 }
4379
4380
4381 /******************************************************************************
4382  * Sets up eeprom variables in the hw struct.  Must be called after mac_type
4383  * is configured.  Additionally, if this is ICH8, the flash controller GbE
4384  * registers must be mapped, or this will crash.
4385  *
4386  * hw - Struct containing variables accessed by shared code
4387  *****************************************************************************/
4388 s32 e1000_init_eeprom_params(struct e1000_hw *hw)
4389 {
4390     struct e1000_eeprom_info *eeprom = &hw->eeprom;
4391     u32 eecd = er32(EECD);
4392     s32 ret_val = E1000_SUCCESS;
4393     u16 eeprom_size;
4394
4395     DEBUGFUNC("e1000_init_eeprom_params");
4396
4397     switch (hw->mac_type) {
4398     case e1000_82542_rev2_0:
4399     case e1000_82542_rev2_1:
4400     case e1000_82543:
4401     case e1000_82544:
4402         eeprom->type = e1000_eeprom_microwire;
4403         eeprom->word_size = 64;
4404         eeprom->opcode_bits = 3;
4405         eeprom->address_bits = 6;
4406         eeprom->delay_usec = 50;
4407         eeprom->use_eerd = false;
4408         eeprom->use_eewr = false;
4409         break;
4410     case e1000_82540:
4411     case e1000_82545:
4412     case e1000_82545_rev_3:
4413     case e1000_82546:
4414     case e1000_82546_rev_3:
4415         eeprom->type = e1000_eeprom_microwire;
4416         eeprom->opcode_bits = 3;
4417         eeprom->delay_usec = 50;
4418         if (eecd & E1000_EECD_SIZE) {
4419             eeprom->word_size = 256;
4420             eeprom->address_bits = 8;
4421         } else {
4422             eeprom->word_size = 64;
4423             eeprom->address_bits = 6;
4424         }
4425         eeprom->use_eerd = false;
4426         eeprom->use_eewr = false;
4427         break;
4428     case e1000_82541:
4429     case e1000_82541_rev_2:
4430     case e1000_82547:
4431     case e1000_82547_rev_2:
4432         if (eecd & E1000_EECD_TYPE) {
4433             eeprom->type = e1000_eeprom_spi;
4434             eeprom->opcode_bits = 8;
4435             eeprom->delay_usec = 1;
4436             if (eecd & E1000_EECD_ADDR_BITS) {
4437                 eeprom->page_size = 32;
4438                 eeprom->address_bits = 16;
4439             } else {
4440                 eeprom->page_size = 8;
4441                 eeprom->address_bits = 8;
4442             }
4443         } else {
4444             eeprom->type = e1000_eeprom_microwire;
4445             eeprom->opcode_bits = 3;
4446             eeprom->delay_usec = 50;
4447             if (eecd & E1000_EECD_ADDR_BITS) {
4448                 eeprom->word_size = 256;
4449                 eeprom->address_bits = 8;
4450             } else {
4451                 eeprom->word_size = 64;
4452                 eeprom->address_bits = 6;
4453             }
4454         }
4455         eeprom->use_eerd = false;
4456         eeprom->use_eewr = false;
4457         break;
4458     case e1000_82571:
4459     case e1000_82572:
4460         eeprom->type = e1000_eeprom_spi;
4461         eeprom->opcode_bits = 8;
4462         eeprom->delay_usec = 1;
4463         if (eecd & E1000_EECD_ADDR_BITS) {
4464             eeprom->page_size = 32;
4465             eeprom->address_bits = 16;
4466         } else {
4467             eeprom->page_size = 8;
4468             eeprom->address_bits = 8;
4469         }
4470         eeprom->use_eerd = false;
4471         eeprom->use_eewr = false;
4472         break;
4473     case e1000_82573:
4474         eeprom->type = e1000_eeprom_spi;
4475         eeprom->opcode_bits = 8;
4476         eeprom->delay_usec = 1;
4477         if (eecd & E1000_EECD_ADDR_BITS) {
4478             eeprom->page_size = 32;
4479             eeprom->address_bits = 16;
4480         } else {
4481             eeprom->page_size = 8;
4482             eeprom->address_bits = 8;
4483         }
4484         eeprom->use_eerd = true;
4485         eeprom->use_eewr = true;
4486         if (!e1000_is_onboard_nvm_eeprom(hw)) {
4487             eeprom->type = e1000_eeprom_flash;
4488             eeprom->word_size = 2048;
4489
4490             /* Ensure that the Autonomous FLASH update bit is cleared due to
4491              * Flash update issue on parts which use a FLASH for NVM. */
4492             eecd &= ~E1000_EECD_AUPDEN;
4493             ew32(EECD, eecd);
4494         }
4495         break;
4496     case e1000_80003es2lan:
4497         eeprom->type = e1000_eeprom_spi;
4498         eeprom->opcode_bits = 8;
4499         eeprom->delay_usec = 1;
4500         if (eecd & E1000_EECD_ADDR_BITS) {
4501             eeprom->page_size = 32;
4502             eeprom->address_bits = 16;
4503         } else {
4504             eeprom->page_size = 8;
4505             eeprom->address_bits = 8;
4506         }
4507         eeprom->use_eerd = true;
4508         eeprom->use_eewr = false;
4509         break;
4510     case e1000_ich8lan:
4511         {
4512         s32  i = 0;
4513         u32 flash_size = E1000_READ_ICH_FLASH_REG(hw, ICH_FLASH_GFPREG);
4514
4515         eeprom->type = e1000_eeprom_ich8;
4516         eeprom->use_eerd = false;
4517         eeprom->use_eewr = false;
4518         eeprom->word_size = E1000_SHADOW_RAM_WORDS;
4519
4520         /* Zero the shadow RAM structure. But don't load it from NVM
4521          * so as to save time for driver init */
4522         if (hw->eeprom_shadow_ram != NULL) {
4523             for (i = 0; i < E1000_SHADOW_RAM_WORDS; i++) {
4524                 hw->eeprom_shadow_ram[i].modified = false;
4525                 hw->eeprom_shadow_ram[i].eeprom_word = 0xFFFF;
4526             }
4527         }
4528
4529         hw->flash_base_addr = (flash_size & ICH_GFPREG_BASE_MASK) *
4530                               ICH_FLASH_SECTOR_SIZE;
4531
4532         hw->flash_bank_size = ((flash_size >> 16) & ICH_GFPREG_BASE_MASK) + 1;
4533         hw->flash_bank_size -= (flash_size & ICH_GFPREG_BASE_MASK);
4534
4535         hw->flash_bank_size *= ICH_FLASH_SECTOR_SIZE;
4536
4537         hw->flash_bank_size /= 2 * sizeof(u16);
4538
4539         break;
4540         }
4541     default:
4542         break;
4543     }
4544
4545     if (eeprom->type == e1000_eeprom_spi) {
4546         /* eeprom_size will be an enum [0..8] that maps to eeprom sizes 128B to
4547          * 32KB (incremented by powers of 2).
4548          */
4549         if (hw->mac_type <= e1000_82547_rev_2) {
4550             /* Set to default value for initial eeprom read. */
4551             eeprom->word_size = 64;
4552             ret_val = e1000_read_eeprom(hw, EEPROM_CFG, 1, &eeprom_size);
4553             if (ret_val)
4554                 return ret_val;
4555             eeprom_size = (eeprom_size & EEPROM_SIZE_MASK) >> EEPROM_SIZE_SHIFT;
4556             /* 256B eeprom size was not supported in earlier hardware, so we
4557              * bump eeprom_size up one to ensure that "1" (which maps to 256B)
4558              * is never the result used in the shifting logic below. */
4559             if (eeprom_size)
4560                 eeprom_size++;
4561         } else {
4562             eeprom_size = (u16)((eecd & E1000_EECD_SIZE_EX_MASK) >>
4563                           E1000_EECD_SIZE_EX_SHIFT);
4564         }
4565
4566         eeprom->word_size = 1 << (eeprom_size + EEPROM_WORD_SIZE_SHIFT);
4567     }
4568     return ret_val;
4569 }
4570
4571 /******************************************************************************
4572  * Raises the EEPROM's clock input.
4573  *
4574  * hw - Struct containing variables accessed by shared code
4575  * eecd - EECD's current value
4576  *****************************************************************************/
4577 static void e1000_raise_ee_clk(struct e1000_hw *hw, u32 *eecd)
4578 {
4579     /* Raise the clock input to the EEPROM (by setting the SK bit), and then
4580      * wait <delay> microseconds.
4581      */
4582     *eecd = *eecd | E1000_EECD_SK;
4583     ew32(EECD, *eecd);
4584     E1000_WRITE_FLUSH();
4585     udelay(hw->eeprom.delay_usec);
4586 }
4587
4588 /******************************************************************************
4589  * Lowers the EEPROM's clock input.
4590  *
4591  * hw - Struct containing variables accessed by shared code
4592  * eecd - EECD's current value
4593  *****************************************************************************/
4594 static void e1000_lower_ee_clk(struct e1000_hw *hw, u32 *eecd)
4595 {
4596     /* Lower the clock input to the EEPROM (by clearing the SK bit), and then
4597      * wait 50 microseconds.
4598      */
4599     *eecd = *eecd & ~E1000_EECD_SK;
4600     ew32(EECD, *eecd);
4601     E1000_WRITE_FLUSH();
4602     udelay(hw->eeprom.delay_usec);
4603 }
4604
4605 /******************************************************************************
4606  * Shift data bits out to the EEPROM.
4607  *
4608  * hw - Struct containing variables accessed by shared code
4609  * data - data to send to the EEPROM
4610  * count - number of bits to shift out
4611  *****************************************************************************/
4612 static void e1000_shift_out_ee_bits(struct e1000_hw *hw, u16 data, u16 count)
4613 {
4614     struct e1000_eeprom_info *eeprom = &hw->eeprom;
4615     u32 eecd;
4616     u32 mask;
4617
4618     /* We need to shift "count" bits out to the EEPROM. So, value in the
4619      * "data" parameter will be shifted out to the EEPROM one bit at a time.
4620      * In order to do this, "data" must be broken down into bits.
4621      */
4622     mask = 0x01 << (count - 1);
4623     eecd = er32(EECD);
4624     if (eeprom->type == e1000_eeprom_microwire) {
4625         eecd &= ~E1000_EECD_DO;
4626     } else if (eeprom->type == e1000_eeprom_spi) {
4627         eecd |= E1000_EECD_DO;
4628     }
4629     do {
4630         /* A "1" is shifted out to the EEPROM by setting bit "DI" to a "1",
4631          * and then raising and then lowering the clock (the SK bit controls
4632          * the clock input to the EEPROM).  A "0" is shifted out to the EEPROM
4633          * by setting "DI" to "0" and then raising and then lowering the clock.
4634          */
4635         eecd &= ~E1000_EECD_DI;
4636
4637         if (data & mask)
4638             eecd |= E1000_EECD_DI;
4639
4640         ew32(EECD, eecd);
4641         E1000_WRITE_FLUSH();
4642
4643         udelay(eeprom->delay_usec);
4644
4645         e1000_raise_ee_clk(hw, &eecd);
4646         e1000_lower_ee_clk(hw, &eecd);
4647
4648         mask = mask >> 1;
4649
4650     } while (mask);
4651
4652     /* We leave the "DI" bit set to "0" when we leave this routine. */
4653     eecd &= ~E1000_EECD_DI;
4654     ew32(EECD, eecd);
4655 }
4656
4657 /******************************************************************************
4658  * Shift data bits in from the EEPROM
4659  *
4660  * hw - Struct containing variables accessed by shared code
4661  *****************************************************************************/
4662 static u16 e1000_shift_in_ee_bits(struct e1000_hw *hw, u16 count)
4663 {
4664     u32 eecd;
4665     u32 i;
4666     u16 data;
4667
4668     /* In order to read a register from the EEPROM, we need to shift 'count'
4669      * bits in from the EEPROM. Bits are "shifted in" by raising the clock
4670      * input to the EEPROM (setting the SK bit), and then reading the value of
4671      * the "DO" bit.  During this "shifting in" process the "DI" bit should
4672      * always be clear.
4673      */
4674
4675     eecd = er32(EECD);
4676
4677     eecd &= ~(E1000_EECD_DO | E1000_EECD_DI);
4678     data = 0;
4679
4680     for (i = 0; i < count; i++) {
4681         data = data << 1;
4682         e1000_raise_ee_clk(hw, &eecd);
4683
4684         eecd = er32(EECD);
4685
4686         eecd &= ~(E1000_EECD_DI);
4687         if (eecd & E1000_EECD_DO)
4688             data |= 1;
4689
4690         e1000_lower_ee_clk(hw, &eecd);
4691     }
4692
4693     return data;
4694 }
4695
4696 /******************************************************************************
4697  * Prepares EEPROM for access
4698  *
4699  * hw - Struct containing variables accessed by shared code
4700  *
4701  * Lowers EEPROM clock. Clears input pin. Sets the chip select pin. This
4702  * function should be called before issuing a command to the EEPROM.
4703  *****************************************************************************/
4704 static s32 e1000_acquire_eeprom(struct e1000_hw *hw)
4705 {
4706     struct e1000_eeprom_info *eeprom = &hw->eeprom;
4707     u32 eecd, i=0;
4708
4709     DEBUGFUNC("e1000_acquire_eeprom");
4710
4711     if (e1000_swfw_sync_acquire(hw, E1000_SWFW_EEP_SM))
4712         return -E1000_ERR_SWFW_SYNC;
4713     eecd = er32(EECD);
4714
4715     if (hw->mac_type != e1000_82573) {
4716         /* Request EEPROM Access */
4717         if (hw->mac_type > e1000_82544) {
4718             eecd |= E1000_EECD_REQ;
4719             ew32(EECD, eecd);
4720             eecd = er32(EECD);
4721             while ((!(eecd & E1000_EECD_GNT)) &&
4722                   (i < E1000_EEPROM_GRANT_ATTEMPTS)) {
4723                 i++;
4724                 udelay(5);
4725                 eecd = er32(EECD);
4726             }
4727             if (!(eecd & E1000_EECD_GNT)) {
4728                 eecd &= ~E1000_EECD_REQ;
4729                 ew32(EECD, eecd);
4730                 DEBUGOUT("Could not acquire EEPROM grant\n");
4731                 e1000_swfw_sync_release(hw, E1000_SWFW_EEP_SM);
4732                 return -E1000_ERR_EEPROM;
4733             }
4734         }
4735     }
4736
4737     /* Setup EEPROM for Read/Write */
4738
4739     if (eeprom->type == e1000_eeprom_microwire) {
4740         /* Clear SK and DI */
4741         eecd &= ~(E1000_EECD_DI | E1000_EECD_SK);
4742         ew32(EECD, eecd);
4743
4744         /* Set CS */
4745         eecd |= E1000_EECD_CS;
4746         ew32(EECD, eecd);
4747     } else if (eeprom->type == e1000_eeprom_spi) {
4748         /* Clear SK and CS */
4749         eecd &= ~(E1000_EECD_CS | E1000_EECD_SK);
4750         ew32(EECD, eecd);
4751         udelay(1);
4752     }
4753
4754     return E1000_SUCCESS;
4755 }
4756
4757 /******************************************************************************
4758  * Returns EEPROM to a "standby" state
4759  *
4760  * hw - Struct containing variables accessed by shared code
4761  *****************************************************************************/
4762 static void e1000_standby_eeprom(struct e1000_hw *hw)
4763 {
4764     struct e1000_eeprom_info *eeprom = &hw->eeprom;
4765     u32 eecd;
4766
4767     eecd = er32(EECD);
4768
4769     if (eeprom->type == e1000_eeprom_microwire) {
4770         eecd &= ~(E1000_EECD_CS | E1000_EECD_SK);
4771         ew32(EECD, eecd);
4772         E1000_WRITE_FLUSH();
4773         udelay(eeprom->delay_usec);
4774
4775         /* Clock high */
4776         eecd |= E1000_EECD_SK;
4777         ew32(EECD, eecd);
4778         E1000_WRITE_FLUSH();
4779         udelay(eeprom->delay_usec);
4780
4781         /* Select EEPROM */
4782         eecd |= E1000_EECD_CS;
4783         ew32(EECD, eecd);
4784         E1000_WRITE_FLUSH();
4785         udelay(eeprom->delay_usec);
4786
4787         /* Clock low */
4788         eecd &= ~E1000_EECD_SK;
4789         ew32(EECD, eecd);
4790         E1000_WRITE_FLUSH();
4791         udelay(eeprom->delay_usec);
4792     } else if (eeprom->type == e1000_eeprom_spi) {
4793         /* Toggle CS to flush commands */
4794         eecd |= E1000_EECD_CS;
4795         ew32(EECD, eecd);
4796         E1000_WRITE_FLUSH();
4797         udelay(eeprom->delay_usec);
4798         eecd &= ~E1000_EECD_CS;
4799         ew32(EECD, eecd);
4800         E1000_WRITE_FLUSH();
4801         udelay(eeprom->delay_usec);
4802     }
4803 }
4804
4805 /******************************************************************************
4806  * Terminates a command by inverting the EEPROM's chip select pin
4807  *
4808  * hw - Struct containing variables accessed by shared code
4809  *****************************************************************************/
4810 static void e1000_release_eeprom(struct e1000_hw *hw)
4811 {
4812     u32 eecd;
4813
4814     DEBUGFUNC("e1000_release_eeprom");
4815
4816     eecd = er32(EECD);
4817
4818     if (hw->eeprom.type == e1000_eeprom_spi) {
4819         eecd |= E1000_EECD_CS;  /* Pull CS high */
4820         eecd &= ~E1000_EECD_SK; /* Lower SCK */
4821
4822         ew32(EECD, eecd);
4823
4824         udelay(hw->eeprom.delay_usec);
4825     } else if (hw->eeprom.type == e1000_eeprom_microwire) {
4826         /* cleanup eeprom */
4827
4828         /* CS on Microwire is active-high */
4829         eecd &= ~(E1000_EECD_CS | E1000_EECD_DI);
4830
4831         ew32(EECD, eecd);
4832
4833         /* Rising edge of clock */
4834         eecd |= E1000_EECD_SK;
4835         ew32(EECD, eecd);
4836         E1000_WRITE_FLUSH();
4837         udelay(hw->eeprom.delay_usec);
4838
4839         /* Falling edge of clock */
4840         eecd &= ~E1000_EECD_SK;
4841         ew32(EECD, eecd);
4842         E1000_WRITE_FLUSH();
4843         udelay(hw->eeprom.delay_usec);
4844     }
4845
4846     /* Stop requesting EEPROM access */
4847     if (hw->mac_type > e1000_82544) {
4848         eecd &= ~E1000_EECD_REQ;
4849         ew32(EECD, eecd);
4850     }
4851
4852     e1000_swfw_sync_release(hw, E1000_SWFW_EEP_SM);
4853 }
4854
4855 /******************************************************************************
4856  * Reads a 16 bit word from the EEPROM.
4857  *
4858  * hw - Struct containing variables accessed by shared code
4859  *****************************************************************************/
4860 static s32 e1000_spi_eeprom_ready(struct e1000_hw *hw)
4861 {
4862     u16 retry_count = 0;
4863     u8 spi_stat_reg;
4864
4865     DEBUGFUNC("e1000_spi_eeprom_ready");
4866
4867     /* Read "Status Register" repeatedly until the LSB is cleared.  The
4868      * EEPROM will signal that the command has been completed by clearing
4869      * bit 0 of the internal status register.  If it's not cleared within
4870      * 5 milliseconds, then error out.
4871      */
4872     retry_count = 0;
4873     do {
4874         e1000_shift_out_ee_bits(hw, EEPROM_RDSR_OPCODE_SPI,
4875                                 hw->eeprom.opcode_bits);
4876         spi_stat_reg = (u8)e1000_shift_in_ee_bits(hw, 8);
4877         if (!(spi_stat_reg & EEPROM_STATUS_RDY_SPI))
4878             break;
4879
4880         udelay(5);
4881         retry_count += 5;
4882
4883         e1000_standby_eeprom(hw);
4884     } while (retry_count < EEPROM_MAX_RETRY_SPI);
4885
4886     /* ATMEL SPI write time could vary from 0-20mSec on 3.3V devices (and
4887      * only 0-5mSec on 5V devices)
4888      */
4889     if (retry_count >= EEPROM_MAX_RETRY_SPI) {
4890         DEBUGOUT("SPI EEPROM Status error\n");
4891         return -E1000_ERR_EEPROM;
4892     }
4893
4894     return E1000_SUCCESS;
4895 }
4896
4897 /******************************************************************************
4898  * Reads a 16 bit word from the EEPROM.
4899  *
4900  * hw - Struct containing variables accessed by shared code
4901  * offset - offset of  word in the EEPROM to read
4902  * data - word read from the EEPROM
4903  * words - number of words to read
4904  *****************************************************************************/
4905 s32 e1000_read_eeprom(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
4906 {
4907     struct e1000_eeprom_info *eeprom = &hw->eeprom;
4908     u32 i = 0;
4909
4910     DEBUGFUNC("e1000_read_eeprom");
4911
4912     /* If eeprom is not yet detected, do so now */
4913     if (eeprom->word_size == 0)
4914         e1000_init_eeprom_params(hw);
4915
4916     /* A check for invalid values:  offset too large, too many words, and not
4917      * enough words.
4918      */
4919     if ((offset >= eeprom->word_size) || (words > eeprom->word_size - offset) ||
4920        (words == 0)) {
4921         DEBUGOUT2("\"words\" parameter out of bounds. Words = %d, size = %d\n", offset, eeprom->word_size);
4922         return -E1000_ERR_EEPROM;
4923     }
4924
4925     /* EEPROM's that don't use EERD to read require us to bit-bang the SPI
4926      * directly. In this case, we need to acquire the EEPROM so that
4927      * FW or other port software does not interrupt.
4928      */
4929     if (e1000_is_onboard_nvm_eeprom(hw) && !hw->eeprom.use_eerd) {
4930         /* Prepare the EEPROM for bit-bang reading */
4931         if (e1000_acquire_eeprom(hw) != E1000_SUCCESS)
4932             return -E1000_ERR_EEPROM;
4933     }
4934
4935     /* Eerd register EEPROM access requires no eeprom aquire/release */
4936     if (eeprom->use_eerd)
4937         return e1000_read_eeprom_eerd(hw, offset, words, data);
4938
4939     /* ICH EEPROM access is done via the ICH flash controller */
4940     if (eeprom->type == e1000_eeprom_ich8)
4941         return e1000_read_eeprom_ich8(hw, offset, words, data);
4942
4943     /* Set up the SPI or Microwire EEPROM for bit-bang reading.  We have
4944      * acquired the EEPROM at this point, so any returns should relase it */
4945     if (eeprom->type == e1000_eeprom_spi) {
4946         u16 word_in;
4947         u8 read_opcode = EEPROM_READ_OPCODE_SPI;
4948
4949         if (e1000_spi_eeprom_ready(hw)) {
4950             e1000_release_eeprom(hw);
4951             return -E1000_ERR_EEPROM;
4952         }
4953
4954         e1000_standby_eeprom(hw);
4955
4956         /* Some SPI eeproms use the 8th address bit embedded in the opcode */
4957         if ((eeprom->address_bits == 8) && (offset >= 128))
4958             read_opcode |= EEPROM_A8_OPCODE_SPI;
4959
4960         /* Send the READ command (opcode + addr)  */
4961         e1000_shift_out_ee_bits(hw, read_opcode, eeprom->opcode_bits);
4962         e1000_shift_out_ee_bits(hw, (u16)(offset*2), eeprom->address_bits);
4963
4964         /* Read the data.  The address of the eeprom internally increments with
4965          * each byte (spi) being read, saving on the overhead of eeprom setup
4966          * and tear-down.  The address counter will roll over if reading beyond
4967          * the size of the eeprom, thus allowing the entire memory to be read
4968          * starting from any offset. */
4969         for (i = 0; i < words; i++) {
4970             word_in = e1000_shift_in_ee_bits(hw, 16);
4971             data[i] = (word_in >> 8) | (word_in << 8);
4972         }
4973     } else if (eeprom->type == e1000_eeprom_microwire) {
4974         for (i = 0; i < words; i++) {
4975             /* Send the READ command (opcode + addr)  */
4976             e1000_shift_out_ee_bits(hw, EEPROM_READ_OPCODE_MICROWIRE,
4977                                     eeprom->opcode_bits);
4978             e1000_shift_out_ee_bits(hw, (u16)(offset + i),
4979                                     eeprom->address_bits);
4980
4981             /* Read the data.  For microwire, each word requires the overhead
4982              * of eeprom setup and tear-down. */
4983             data[i] = e1000_shift_in_ee_bits(hw, 16);
4984             e1000_standby_eeprom(hw);
4985         }
4986     }
4987
4988     /* End this read operation */
4989     e1000_release_eeprom(hw);
4990
4991     return E1000_SUCCESS;
4992 }
4993
4994 /******************************************************************************
4995  * Reads a 16 bit word from the EEPROM using the EERD register.
4996  *
4997  * hw - Struct containing variables accessed by shared code
4998  * offset - offset of  word in the EEPROM to read
4999  * data - word read from the EEPROM
5000  * words - number of words to read
5001  *****************************************************************************/
5002 static s32 e1000_read_eeprom_eerd(struct e1000_hw *hw, u16 offset, u16 words,
5003                                   u16 *data)
5004 {
5005     u32 i, eerd = 0;
5006     s32 error = 0;
5007
5008     for (i = 0; i < words; i++) {
5009         eerd = ((offset+i) << E1000_EEPROM_RW_ADDR_SHIFT) +
5010                          E1000_EEPROM_RW_REG_START;
5011
5012         ew32(EERD, eerd);
5013         error = e1000_poll_eerd_eewr_done(hw, E1000_EEPROM_POLL_READ);
5014
5015         if (error) {
5016             break;
5017         }
5018         data[i] = (er32(EERD) >> E1000_EEPROM_RW_REG_DATA);
5019
5020     }
5021
5022     return error;
5023 }
5024
5025 /******************************************************************************
5026  * Writes a 16 bit word from the EEPROM using the EEWR register.
5027  *
5028  * hw - Struct containing variables accessed by shared code
5029  * offset - offset of  word in the EEPROM to read
5030  * data - word read from the EEPROM
5031  * words - number of words to read
5032  *****************************************************************************/
5033 static s32 e1000_write_eeprom_eewr(struct e1000_hw *hw, u16 offset, u16 words,
5034                                    u16 *data)
5035 {
5036     u32    register_value = 0;
5037     u32    i              = 0;
5038     s32     error          = 0;
5039
5040     if (e1000_swfw_sync_acquire(hw, E1000_SWFW_EEP_SM))
5041         return -E1000_ERR_SWFW_SYNC;
5042
5043     for (i = 0; i < words; i++) {
5044         register_value = (data[i] << E1000_EEPROM_RW_REG_DATA) |
5045                          ((offset+i) << E1000_EEPROM_RW_ADDR_SHIFT) |
5046                          E1000_EEPROM_RW_REG_START;
5047
5048         error = e1000_poll_eerd_eewr_done(hw, E1000_EEPROM_POLL_WRITE);
5049         if (error) {
5050             break;
5051         }
5052
5053         ew32(EEWR, register_value);
5054
5055         error = e1000_poll_eerd_eewr_done(hw, E1000_EEPROM_POLL_WRITE);
5056
5057         if (error) {
5058             break;
5059         }
5060     }
5061
5062     e1000_swfw_sync_release(hw, E1000_SWFW_EEP_SM);
5063     return error;
5064 }
5065
5066 /******************************************************************************
5067  * Polls the status bit (bit 1) of the EERD to determine when the read is done.
5068  *
5069  * hw - Struct containing variables accessed by shared code
5070  *****************************************************************************/
5071 static s32 e1000_poll_eerd_eewr_done(struct e1000_hw *hw, int eerd)
5072 {
5073     u32 attempts = 100000;
5074     u32 i, reg = 0;
5075     s32 done = E1000_ERR_EEPROM;
5076
5077     for (i = 0; i < attempts; i++) {
5078         if (eerd == E1000_EEPROM_POLL_READ)
5079             reg = er32(EERD);
5080         else
5081             reg = er32(EEWR);
5082
5083         if (reg & E1000_EEPROM_RW_REG_DONE) {
5084             done = E1000_SUCCESS;
5085             break;
5086         }
5087         udelay(5);
5088     }
5089
5090     return done;
5091 }
5092
5093 /***************************************************************************
5094 * Description:     Determines if the onboard NVM is FLASH or EEPROM.
5095 *
5096 * hw - Struct containing variables accessed by shared code
5097 ****************************************************************************/
5098 static bool e1000_is_onboard_nvm_eeprom(struct e1000_hw *hw)
5099 {
5100     u32 eecd = 0;
5101
5102     DEBUGFUNC("e1000_is_onboard_nvm_eeprom");
5103
5104     if (hw->mac_type == e1000_ich8lan)
5105         return false;
5106
5107     if (hw->mac_type == e1000_82573) {
5108         eecd = er32(EECD);
5109
5110         /* Isolate bits 15 & 16 */
5111         eecd = ((eecd >> 15) & 0x03);
5112
5113         /* If both bits are set, device is Flash type */
5114         if (eecd == 0x03) {
5115             return false;
5116         }
5117     }
5118     return true;
5119 }
5120
5121 /******************************************************************************
5122  * Verifies that the EEPROM has a valid checksum
5123  *
5124  * hw - Struct containing variables accessed by shared code
5125  *
5126  * Reads the first 64 16 bit words of the EEPROM and sums the values read.
5127  * If the the sum of the 64 16 bit words is 0xBABA, the EEPROM's checksum is
5128  * valid.
5129  *****************************************************************************/
5130 s32 e1000_validate_eeprom_checksum(struct e1000_hw *hw)
5131 {
5132     u16 checksum = 0;
5133     u16 i, eeprom_data;
5134
5135     DEBUGFUNC("e1000_validate_eeprom_checksum");
5136
5137     if ((hw->mac_type == e1000_82573) && !e1000_is_onboard_nvm_eeprom(hw)) {
5138         /* Check bit 4 of word 10h.  If it is 0, firmware is done updating
5139          * 10h-12h.  Checksum may need to be fixed. */
5140         e1000_read_eeprom(hw, 0x10, 1, &eeprom_data);
5141         if ((eeprom_data & 0x10) == 0) {
5142             /* Read 0x23 and check bit 15.  This bit is a 1 when the checksum
5143              * has already been fixed.  If the checksum is still wrong and this
5144              * bit is a 1, we need to return bad checksum.  Otherwise, we need
5145              * to set this bit to a 1 and update the checksum. */
5146             e1000_read_eeprom(hw, 0x23, 1, &eeprom_data);
5147             if ((eeprom_data & 0x8000) == 0) {
5148                 eeprom_data |= 0x8000;
5149                 e1000_write_eeprom(hw, 0x23, 1, &eeprom_data);
5150                 e1000_update_eeprom_checksum(hw);
5151             }
5152         }
5153     }
5154
5155     if (hw->mac_type == e1000_ich8lan) {
5156         /* Drivers must allocate the shadow ram structure for the
5157          * EEPROM checksum to be updated.  Otherwise, this bit as well
5158          * as the checksum must both be set correctly for this
5159          * validation to pass.
5160          */
5161         e1000_read_eeprom(hw, 0x19, 1, &eeprom_data);
5162         if ((eeprom_data & 0x40) == 0) {
5163             eeprom_data |= 0x40;
5164             e1000_write_eeprom(hw, 0x19, 1, &eeprom_data);
5165             e1000_update_eeprom_checksum(hw);
5166         }
5167     }
5168
5169     for (i = 0; i < (EEPROM_CHECKSUM_REG + 1); i++) {
5170         if (e1000_read_eeprom(hw, i, 1, &eeprom_data) < 0) {
5171             DEBUGOUT("EEPROM Read Error\n");
5172             return -E1000_ERR_EEPROM;
5173         }
5174         checksum += eeprom_data;
5175     }
5176
5177     if (checksum == (u16)EEPROM_SUM)
5178         return E1000_SUCCESS;
5179     else {
5180         DEBUGOUT("EEPROM Checksum Invalid\n");
5181         return -E1000_ERR_EEPROM;
5182     }
5183 }
5184
5185 /******************************************************************************
5186  * Calculates the EEPROM checksum and writes it to the EEPROM
5187  *
5188  * hw - Struct containing variables accessed by shared code
5189  *
5190  * Sums the first 63 16 bit words of the EEPROM. Subtracts the sum from 0xBABA.
5191  * Writes the difference to word offset 63 of the EEPROM.
5192  *****************************************************************************/
5193 s32 e1000_update_eeprom_checksum(struct e1000_hw *hw)
5194 {
5195     u32 ctrl_ext;
5196     u16 checksum = 0;
5197     u16 i, eeprom_data;
5198
5199     DEBUGFUNC("e1000_update_eeprom_checksum");
5200
5201     for (i = 0; i < EEPROM_CHECKSUM_REG; i++) {
5202         if (e1000_read_eeprom(hw, i, 1, &eeprom_data) < 0) {
5203             DEBUGOUT("EEPROM Read Error\n");
5204             return -E1000_ERR_EEPROM;
5205         }
5206         checksum += eeprom_data;
5207     }
5208     checksum = (u16)EEPROM_SUM - checksum;
5209     if (e1000_write_eeprom(hw, EEPROM_CHECKSUM_REG, 1, &checksum) < 0) {
5210         DEBUGOUT("EEPROM Write Error\n");
5211         return -E1000_ERR_EEPROM;
5212     } else if (hw->eeprom.type == e1000_eeprom_flash) {
5213         e1000_commit_shadow_ram(hw);
5214     } else if (hw->eeprom.type == e1000_eeprom_ich8) {
5215         e1000_commit_shadow_ram(hw);
5216         /* Reload the EEPROM, or else modifications will not appear
5217          * until after next adapter reset. */
5218         ctrl_ext = er32(CTRL_EXT);
5219         ctrl_ext |= E1000_CTRL_EXT_EE_RST;
5220         ew32(CTRL_EXT, ctrl_ext);
5221         msleep(10);
5222     }
5223     return E1000_SUCCESS;
5224 }
5225
5226 /******************************************************************************
5227  * Parent function for writing words to the different EEPROM types.
5228  *
5229  * hw - Struct containing variables accessed by shared code
5230  * offset - offset within the EEPROM to be written to
5231  * words - number of words to write
5232  * data - 16 bit word to be written to the EEPROM
5233  *
5234  * If e1000_update_eeprom_checksum is not called after this function, the
5235  * EEPROM will most likely contain an invalid checksum.
5236  *****************************************************************************/
5237 s32 e1000_write_eeprom(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
5238 {
5239     struct e1000_eeprom_info *eeprom = &hw->eeprom;
5240     s32 status = 0;
5241
5242     DEBUGFUNC("e1000_write_eeprom");
5243
5244     /* If eeprom is not yet detected, do so now */
5245     if (eeprom->word_size == 0)
5246         e1000_init_eeprom_params(hw);
5247
5248     /* A check for invalid values:  offset too large, too many words, and not
5249      * enough words.
5250      */
5251     if ((offset >= eeprom->word_size) || (words > eeprom->word_size - offset) ||
5252        (words == 0)) {
5253         DEBUGOUT("\"words\" parameter out of bounds\n");
5254         return -E1000_ERR_EEPROM;
5255     }
5256
5257     /* 82573 writes only through eewr */
5258     if (eeprom->use_eewr)
5259         return e1000_write_eeprom_eewr(hw, offset, words, data);
5260
5261     if (eeprom->type == e1000_eeprom_ich8)
5262         return e1000_write_eeprom_ich8(hw, offset, words, data);
5263
5264     /* Prepare the EEPROM for writing  */
5265     if (e1000_acquire_eeprom(hw) != E1000_SUCCESS)
5266         return -E1000_ERR_EEPROM;
5267
5268     if (eeprom->type == e1000_eeprom_microwire) {
5269         status = e1000_write_eeprom_microwire(hw, offset, words, data);
5270     } else {
5271         status = e1000_write_eeprom_spi(hw, offset, words, data);
5272         msleep(10);
5273     }
5274
5275     /* Done with writing */
5276     e1000_release_eeprom(hw);
5277
5278     return status;
5279 }
5280
5281 /******************************************************************************
5282  * Writes a 16 bit word to a given offset in an SPI EEPROM.
5283  *
5284  * hw - Struct containing variables accessed by shared code
5285  * offset - offset within the EEPROM to be written to
5286  * words - number of words to write
5287  * data - pointer to array of 8 bit words to be written to the EEPROM
5288  *
5289  *****************************************************************************/
5290 static s32 e1000_write_eeprom_spi(struct e1000_hw *hw, u16 offset, u16 words,
5291                                   u16 *data)
5292 {
5293     struct e1000_eeprom_info *eeprom = &hw->eeprom;
5294     u16 widx = 0;
5295
5296     DEBUGFUNC("e1000_write_eeprom_spi");
5297
5298     while (widx < words) {
5299         u8 write_opcode = EEPROM_WRITE_OPCODE_SPI;
5300
5301         if (e1000_spi_eeprom_ready(hw)) return -E1000_ERR_EEPROM;
5302
5303         e1000_standby_eeprom(hw);
5304
5305         /*  Send the WRITE ENABLE command (8 bit opcode )  */
5306         e1000_shift_out_ee_bits(hw, EEPROM_WREN_OPCODE_SPI,
5307                                     eeprom->opcode_bits);
5308
5309         e1000_standby_eeprom(hw);
5310
5311         /* Some SPI eeproms use the 8th address bit embedded in the opcode */
5312         if ((eeprom->address_bits == 8) && (offset >= 128))
5313             write_opcode |= EEPROM_A8_OPCODE_SPI;
5314
5315         /* Send the Write command (8-bit opcode + addr) */
5316         e1000_shift_out_ee_bits(hw, write_opcode, eeprom->opcode_bits);
5317
5318         e1000_shift_out_ee_bits(hw, (u16)((offset + widx)*2),
5319                                 eeprom->address_bits);
5320
5321         /* Send the data */
5322
5323         /* Loop to allow for up to whole page write (32 bytes) of eeprom */
5324         while (widx < words) {
5325             u16 word_out = data[widx];
5326             word_out = (word_out >> 8) | (word_out << 8);
5327             e1000_shift_out_ee_bits(hw, word_out, 16);
5328             widx++;
5329
5330             /* Some larger eeprom sizes are capable of a 32-byte PAGE WRITE
5331              * operation, while the smaller eeproms are capable of an 8-byte
5332              * PAGE WRITE operation.  Break the inner loop to pass new address
5333              */
5334             if ((((offset + widx)*2) % eeprom->page_size) == 0) {
5335                 e1000_standby_eeprom(hw);
5336                 break;
5337             }
5338         }
5339     }
5340
5341     return E1000_SUCCESS;
5342 }
5343
5344 /******************************************************************************
5345  * Writes a 16 bit word to a given offset in a Microwire EEPROM.
5346  *
5347  * hw - Struct containing variables accessed by shared code
5348  * offset - offset within the EEPROM to be written to
5349  * words - number of words to write
5350  * data - pointer to array of 16 bit words to be written to the EEPROM
5351  *
5352  *****************************************************************************/
5353 static s32 e1000_write_eeprom_microwire(struct e1000_hw *hw, u16 offset,
5354                                         u16 words, u16 *data)
5355 {
5356     struct e1000_eeprom_info *eeprom = &hw->eeprom;
5357     u32 eecd;
5358     u16 words_written = 0;
5359     u16 i = 0;
5360
5361     DEBUGFUNC("e1000_write_eeprom_microwire");
5362
5363     /* Send the write enable command to the EEPROM (3-bit opcode plus
5364      * 6/8-bit dummy address beginning with 11).  It's less work to include
5365      * the 11 of the dummy address as part of the opcode than it is to shift
5366      * it over the correct number of bits for the address.  This puts the
5367      * EEPROM into write/erase mode.
5368      */
5369     e1000_shift_out_ee_bits(hw, EEPROM_EWEN_OPCODE_MICROWIRE,
5370                             (u16)(eeprom->opcode_bits + 2));
5371
5372     e1000_shift_out_ee_bits(hw, 0, (u16)(eeprom->address_bits - 2));
5373
5374     /* Prepare the EEPROM */
5375     e1000_standby_eeprom(hw);
5376
5377     while (words_written < words) {
5378         /* Send the Write command (3-bit opcode + addr) */
5379         e1000_shift_out_ee_bits(hw, EEPROM_WRITE_OPCODE_MICROWIRE,
5380                                 eeprom->opcode_bits);
5381
5382         e1000_shift_out_ee_bits(hw, (u16)(offset + words_written),
5383                                 eeprom->address_bits);
5384
5385         /* Send the data */
5386         e1000_shift_out_ee_bits(hw, data[words_written], 16);
5387
5388         /* Toggle the CS line.  This in effect tells the EEPROM to execute
5389          * the previous command.
5390          */
5391         e1000_standby_eeprom(hw);
5392
5393         /* Read DO repeatedly until it is high (equal to '1').  The EEPROM will
5394          * signal that the command has been completed by raising the DO signal.
5395          * If DO does not go high in 10 milliseconds, then error out.
5396          */
5397         for (i = 0; i < 200; i++) {
5398             eecd = er32(EECD);
5399             if (eecd & E1000_EECD_DO) break;
5400             udelay(50);
5401         }
5402         if (i == 200) {
5403             DEBUGOUT("EEPROM Write did not complete\n");
5404             return -E1000_ERR_EEPROM;
5405         }
5406
5407         /* Recover from write */
5408         e1000_standby_eeprom(hw);
5409
5410         words_written++;
5411     }
5412
5413     /* Send the write disable command to the EEPROM (3-bit opcode plus
5414      * 6/8-bit dummy address beginning with 10).  It's less work to include
5415      * the 10 of the dummy address as part of the opcode than it is to shift
5416      * it over the correct number of bits for the address.  This takes the
5417      * EEPROM out of write/erase mode.
5418      */
5419     e1000_shift_out_ee_bits(hw, EEPROM_EWDS_OPCODE_MICROWIRE,
5420                             (u16)(eeprom->opcode_bits + 2));
5421
5422     e1000_shift_out_ee_bits(hw, 0, (u16)(eeprom->address_bits - 2));
5423
5424     return E1000_SUCCESS;
5425 }
5426
5427 /******************************************************************************
5428  * Flushes the cached eeprom to NVM. This is done by saving the modified values
5429  * in the eeprom cache and the non modified values in the currently active bank
5430  * to the new bank.
5431  *
5432  * hw - Struct containing variables accessed by shared code
5433  * offset - offset of  word in the EEPROM to read
5434  * data - word read from the EEPROM
5435  * words - number of words to read
5436  *****************************************************************************/
5437 static s32 e1000_commit_shadow_ram(struct e1000_hw *hw)
5438 {
5439     u32 attempts = 100000;
5440     u32 eecd = 0;
5441     u32 flop = 0;
5442     u32 i = 0;
5443     s32 error = E1000_SUCCESS;
5444     u32 old_bank_offset = 0;
5445     u32 new_bank_offset = 0;
5446     u8 low_byte = 0;
5447     u8 high_byte = 0;
5448     bool sector_write_failed = false;
5449
5450     if (hw->mac_type == e1000_82573) {
5451         /* The flop register will be used to determine if flash type is STM */
5452         flop = er32(FLOP);
5453         for (i=0; i < attempts; i++) {
5454             eecd = er32(EECD);
5455             if ((eecd & E1000_EECD_FLUPD) == 0) {
5456                 break;
5457             }
5458             udelay(5);
5459         }
5460
5461         if (i == attempts) {
5462             return -E1000_ERR_EEPROM;
5463         }
5464
5465         /* If STM opcode located in bits 15:8 of flop, reset firmware */
5466         if ((flop & 0xFF00) == E1000_STM_OPCODE) {
5467             ew32(HICR, E1000_HICR_FW_RESET);
5468         }
5469
5470         /* Perform the flash update */
5471         ew32(EECD, eecd | E1000_EECD_FLUPD);
5472
5473         for (i=0; i < attempts; i++) {
5474             eecd = er32(EECD);
5475             if ((eecd & E1000_EECD_FLUPD) == 0) {
5476                 break;
5477             }
5478             udelay(5);
5479         }
5480
5481         if (i == attempts) {
5482             return -E1000_ERR_EEPROM;
5483         }
5484     }
5485
5486     if (hw->mac_type == e1000_ich8lan && hw->eeprom_shadow_ram != NULL) {
5487         /* We're writing to the opposite bank so if we're on bank 1,
5488          * write to bank 0 etc.  We also need to erase the segment that
5489          * is going to be written */
5490         if (!(er32(EECD) & E1000_EECD_SEC1VAL)) {
5491             new_bank_offset = hw->flash_bank_size * 2;
5492             old_bank_offset = 0;
5493             e1000_erase_ich8_4k_segment(hw, 1);
5494         } else {
5495             old_bank_offset = hw->flash_bank_size * 2;
5496             new_bank_offset = 0;
5497             e1000_erase_ich8_4k_segment(hw, 0);
5498         }
5499
5500         sector_write_failed = false;
5501         /* Loop for every byte in the shadow RAM,
5502          * which is in units of words. */
5503         for (i = 0; i < E1000_SHADOW_RAM_WORDS; i++) {
5504             /* Determine whether to write the value stored
5505              * in the other NVM bank or a modified value stored
5506              * in the shadow RAM */
5507             if (hw->eeprom_shadow_ram[i].modified) {
5508                 low_byte = (u8)hw->eeprom_shadow_ram[i].eeprom_word;
5509                 udelay(100);
5510                 error = e1000_verify_write_ich8_byte(hw,
5511                             (i << 1) + new_bank_offset, low_byte);
5512
5513                 if (error != E1000_SUCCESS)
5514                     sector_write_failed = true;
5515                 else {
5516                     high_byte =
5517                         (u8)(hw->eeprom_shadow_ram[i].eeprom_word >> 8);
5518                     udelay(100);
5519                 }
5520             } else {
5521                 e1000_read_ich8_byte(hw, (i << 1) + old_bank_offset,
5522                                      &low_byte);
5523                 udelay(100);
5524                 error = e1000_verify_write_ich8_byte(hw,
5525                             (i << 1) + new_bank_offset, low_byte);
5526
5527                 if (error != E1000_SUCCESS)
5528                     sector_write_failed = true;
5529                 else {
5530                     e1000_read_ich8_byte(hw, (i << 1) + old_bank_offset + 1,
5531                                          &high_byte);
5532                     udelay(100);
5533                 }
5534             }
5535
5536             /* If the write of the low byte was successful, go ahead and
5537              * write the high byte while checking to make sure that if it
5538              * is the signature byte, then it is handled properly */
5539             if (!sector_write_failed) {
5540                 /* If the word is 0x13, then make sure the signature bits
5541                  * (15:14) are 11b until the commit has completed.
5542                  * This will allow us to write 10b which indicates the
5543                  * signature is valid.  We want to do this after the write
5544                  * has completed so that we don't mark the segment valid
5545                  * while the write is still in progress */
5546                 if (i == E1000_ICH_NVM_SIG_WORD)
5547                     high_byte = E1000_ICH_NVM_SIG_MASK | high_byte;
5548
5549                 error = e1000_verify_write_ich8_byte(hw,
5550                             (i << 1) + new_bank_offset + 1, high_byte);
5551                 if (error != E1000_SUCCESS)
5552                     sector_write_failed = true;
5553
5554             } else {
5555                 /* If the write failed then break from the loop and
5556                  * return an error */
5557                 break;
5558             }
5559         }
5560
5561         /* Don't bother writing the segment valid bits if sector
5562          * programming failed. */
5563         if (!sector_write_failed) {
5564             /* Finally validate the new segment by setting bit 15:14
5565              * to 10b in word 0x13 , this can be done without an
5566              * erase as well since these bits are 11 to start with
5567              * and we need to change bit 14 to 0b */
5568             e1000_read_ich8_byte(hw,
5569                                  E1000_ICH_NVM_SIG_WORD * 2 + 1 + new_bank_offset,
5570                                  &high_byte);
5571             high_byte &= 0xBF;
5572             error = e1000_verify_write_ich8_byte(hw,
5573                         E1000_ICH_NVM_SIG_WORD * 2 + 1 + new_bank_offset, high_byte);
5574             /* And invalidate the previously valid segment by setting
5575              * its signature word (0x13) high_byte to 0b. This can be
5576              * done without an erase because flash erase sets all bits
5577              * to 1's. We can write 1's to 0's without an erase */
5578             if (error == E1000_SUCCESS) {
5579                 error = e1000_verify_write_ich8_byte(hw,
5580                             E1000_ICH_NVM_SIG_WORD * 2 + 1 + old_bank_offset, 0);
5581             }
5582
5583             /* Clear the now not used entry in the cache */
5584             for (i = 0; i < E1000_SHADOW_RAM_WORDS; i++) {
5585                 hw->eeprom_shadow_ram[i].modified = false;
5586                 hw->eeprom_shadow_ram[i].eeprom_word = 0xFFFF;
5587             }
5588         }
5589     }
5590
5591     return error;
5592 }
5593
5594 /******************************************************************************
5595  * Reads the adapter's MAC address from the EEPROM and inverts the LSB for the
5596  * second function of dual function devices
5597  *
5598  * hw - Struct containing variables accessed by shared code
5599  *****************************************************************************/
5600 s32 e1000_read_mac_addr(struct e1000_hw *hw)
5601 {
5602     u16 offset;
5603     u16 eeprom_data, i;
5604
5605     DEBUGFUNC("e1000_read_mac_addr");
5606
5607     for (i = 0; i < NODE_ADDRESS_SIZE; i += 2) {
5608         offset = i >> 1;
5609         if (e1000_read_eeprom(hw, offset, 1, &eeprom_data) < 0) {
5610             DEBUGOUT("EEPROM Read Error\n");
5611             return -E1000_ERR_EEPROM;
5612         }
5613         hw->perm_mac_addr[i] = (u8)(eeprom_data & 0x00FF);
5614         hw->perm_mac_addr[i+1] = (u8)(eeprom_data >> 8);
5615     }
5616
5617     switch (hw->mac_type) {
5618     default:
5619         break;
5620     case e1000_82546:
5621     case e1000_82546_rev_3:
5622     case e1000_82571:
5623     case e1000_80003es2lan:
5624         if (er32(STATUS) & E1000_STATUS_FUNC_1)
5625             hw->perm_mac_addr[5] ^= 0x01;
5626         break;
5627     }
5628
5629     for (i = 0; i < NODE_ADDRESS_SIZE; i++)
5630         hw->mac_addr[i] = hw->perm_mac_addr[i];
5631     return E1000_SUCCESS;
5632 }
5633
5634 /******************************************************************************
5635  * Initializes receive address filters.
5636  *
5637  * hw - Struct containing variables accessed by shared code
5638  *
5639  * Places the MAC address in receive address register 0 and clears the rest
5640  * of the receive addresss registers. Clears the multicast table. Assumes
5641  * the receiver is in reset when the routine is called.
5642  *****************************************************************************/
5643 static void e1000_init_rx_addrs(struct e1000_hw *hw)
5644 {
5645     u32 i;
5646     u32 rar_num;
5647
5648     DEBUGFUNC("e1000_init_rx_addrs");
5649
5650     /* Setup the receive address. */
5651     DEBUGOUT("Programming MAC Address into RAR[0]\n");
5652
5653     e1000_rar_set(hw, hw->mac_addr, 0);
5654
5655     rar_num = E1000_RAR_ENTRIES;
5656
5657     /* Reserve a spot for the Locally Administered Address to work around
5658      * an 82571 issue in which a reset on one port will reload the MAC on
5659      * the other port. */
5660     if ((hw->mac_type == e1000_82571) && (hw->laa_is_present))
5661         rar_num -= 1;
5662     if (hw->mac_type == e1000_ich8lan)
5663         rar_num = E1000_RAR_ENTRIES_ICH8LAN;
5664
5665     /* Zero out the other 15 receive addresses. */
5666     DEBUGOUT("Clearing RAR[1-15]\n");
5667     for (i = 1; i < rar_num; i++) {
5668         E1000_WRITE_REG_ARRAY(hw, RA, (i << 1), 0);
5669         E1000_WRITE_FLUSH();
5670         E1000_WRITE_REG_ARRAY(hw, RA, ((i << 1) + 1), 0);
5671         E1000_WRITE_FLUSH();
5672     }
5673 }
5674
5675 /******************************************************************************
5676  * Hashes an address to determine its location in the multicast table
5677  *
5678  * hw - Struct containing variables accessed by shared code
5679  * mc_addr - the multicast address to hash
5680  *****************************************************************************/
5681 u32 e1000_hash_mc_addr(struct e1000_hw *hw, u8 *mc_addr)
5682 {
5683     u32 hash_value = 0;
5684
5685     /* The portion of the address that is used for the hash table is
5686      * determined by the mc_filter_type setting.
5687      */
5688     switch (hw->mc_filter_type) {
5689     /* [0] [1] [2] [3] [4] [5]
5690      * 01  AA  00  12  34  56
5691      * LSB                 MSB
5692      */
5693     case 0:
5694         if (hw->mac_type == e1000_ich8lan) {
5695             /* [47:38] i.e. 0x158 for above example address */
5696             hash_value = ((mc_addr[4] >> 6) | (((u16)mc_addr[5]) << 2));
5697         } else {
5698             /* [47:36] i.e. 0x563 for above example address */
5699             hash_value = ((mc_addr[4] >> 4) | (((u16)mc_addr[5]) << 4));
5700         }
5701         break;
5702     case 1:
5703         if (hw->mac_type == e1000_ich8lan) {
5704             /* [46:37] i.e. 0x2B1 for above example address */
5705             hash_value = ((mc_addr[4] >> 5) | (((u16)mc_addr[5]) << 3));
5706         } else {
5707             /* [46:35] i.e. 0xAC6 for above example address */
5708             hash_value = ((mc_addr[4] >> 3) | (((u16)mc_addr[5]) << 5));
5709         }
5710         break;
5711     case 2:
5712         if (hw->mac_type == e1000_ich8lan) {
5713             /*[45:36] i.e. 0x163 for above example address */
5714             hash_value = ((mc_addr[4] >> 4) | (((u16)mc_addr[5]) << 4));
5715         } else {
5716             /* [45:34] i.e. 0x5D8 for above example address */
5717             hash_value = ((mc_addr[4] >> 2) | (((u16)mc_addr[5]) << 6));
5718         }
5719         break;
5720     case 3:
5721         if (hw->mac_type == e1000_ich8lan) {
5722             /* [43:34] i.e. 0x18D for above example address */
5723             hash_value = ((mc_addr[4] >> 2) | (((u16)mc_addr[5]) << 6));
5724         } else {
5725             /* [43:32] i.e. 0x634 for above example address */
5726             hash_value = ((mc_addr[4]) | (((u16)mc_addr[5]) << 8));
5727         }
5728         break;
5729     }
5730
5731     hash_value &= 0xFFF;
5732     if (hw->mac_type == e1000_ich8lan)
5733         hash_value &= 0x3FF;
5734
5735     return hash_value;
5736 }
5737
5738 /******************************************************************************
5739  * Sets the bit in the multicast table corresponding to the hash value.
5740  *
5741  * hw - Struct containing variables accessed by shared code
5742  * hash_value - Multicast address hash value
5743  *****************************************************************************/
5744 void e1000_mta_set(struct e1000_hw *hw, u32 hash_value)
5745 {
5746     u32 hash_bit, hash_reg;
5747     u32 mta;
5748     u32 temp;
5749
5750     /* The MTA is a register array of 128 32-bit registers.
5751      * It is treated like an array of 4096 bits.  We want to set
5752      * bit BitArray[hash_value]. So we figure out what register
5753      * the bit is in, read it, OR in the new bit, then write
5754      * back the new value.  The register is determined by the
5755      * upper 7 bits of the hash value and the bit within that
5756      * register are determined by the lower 5 bits of the value.
5757      */
5758     hash_reg = (hash_value >> 5) & 0x7F;
5759     if (hw->mac_type == e1000_ich8lan)
5760         hash_reg &= 0x1F;
5761
5762     hash_bit = hash_value & 0x1F;
5763
5764     mta = E1000_READ_REG_ARRAY(hw, MTA, hash_reg);
5765
5766     mta |= (1 << hash_bit);
5767
5768     /* If we are on an 82544 and we are trying to write an odd offset
5769      * in the MTA, save off the previous entry before writing and
5770      * restore the old value after writing.
5771      */
5772     if ((hw->mac_type == e1000_82544) && ((hash_reg & 0x1) == 1)) {
5773         temp = E1000_READ_REG_ARRAY(hw, MTA, (hash_reg - 1));
5774         E1000_WRITE_REG_ARRAY(hw, MTA, hash_reg, mta);
5775         E1000_WRITE_FLUSH();
5776         E1000_WRITE_REG_ARRAY(hw, MTA, (hash_reg - 1), temp);
5777         E1000_WRITE_FLUSH();
5778     } else {
5779         E1000_WRITE_REG_ARRAY(hw, MTA, hash_reg, mta);
5780         E1000_WRITE_FLUSH();
5781     }
5782 }
5783
5784 /******************************************************************************
5785  * Puts an ethernet address into a receive address register.
5786  *
5787  * hw - Struct containing variables accessed by shared code
5788  * addr - Address to put into receive address register
5789  * index - Receive address register to write
5790  *****************************************************************************/
5791 void e1000_rar_set(struct e1000_hw *hw, u8 *addr, u32 index)
5792 {
5793     u32 rar_low, rar_high;
5794
5795     /* HW expects these in little endian so we reverse the byte order
5796      * from network order (big endian) to little endian
5797      */
5798     rar_low = ((u32)addr[0] | ((u32)addr[1] << 8) |
5799                ((u32)addr[2] << 16) | ((u32)addr[3] << 24));
5800     rar_high = ((u32)addr[4] | ((u32)addr[5] << 8));
5801
5802     /* Disable Rx and flush all Rx frames before enabling RSS to avoid Rx
5803      * unit hang.
5804      *
5805      * Description:
5806      * If there are any Rx frames queued up or otherwise present in the HW
5807      * before RSS is enabled, and then we enable RSS, the HW Rx unit will
5808      * hang.  To work around this issue, we have to disable receives and
5809      * flush out all Rx frames before we enable RSS. To do so, we modify we
5810      * redirect all Rx traffic to manageability and then reset the HW.
5811      * This flushes away Rx frames, and (since the redirections to
5812      * manageability persists across resets) keeps new ones from coming in
5813      * while we work.  Then, we clear the Address Valid AV bit for all MAC
5814      * addresses and undo the re-direction to manageability.
5815      * Now, frames are coming in again, but the MAC won't accept them, so
5816      * far so good.  We now proceed to initialize RSS (if necessary) and
5817      * configure the Rx unit.  Last, we re-enable the AV bits and continue
5818      * on our merry way.
5819      */
5820     switch (hw->mac_type) {
5821     case e1000_82571:
5822     case e1000_82572:
5823     case e1000_80003es2lan:
5824         if (hw->leave_av_bit_off)
5825             break;
5826     default:
5827         /* Indicate to hardware the Address is Valid. */
5828         rar_high |= E1000_RAH_AV;
5829         break;
5830     }
5831
5832     E1000_WRITE_REG_ARRAY(hw, RA, (index << 1), rar_low);
5833     E1000_WRITE_FLUSH();
5834     E1000_WRITE_REG_ARRAY(hw, RA, ((index << 1) + 1), rar_high);
5835     E1000_WRITE_FLUSH();
5836 }
5837
5838 /******************************************************************************
5839  * Writes a value to the specified offset in the VLAN filter table.
5840  *
5841  * hw - Struct containing variables accessed by shared code
5842  * offset - Offset in VLAN filer table to write
5843  * value - Value to write into VLAN filter table
5844  *****************************************************************************/
5845 void e1000_write_vfta(struct e1000_hw *hw, u32 offset, u32 value)
5846 {
5847     u32 temp;
5848
5849     if (hw->mac_type == e1000_ich8lan)
5850         return;
5851
5852     if ((hw->mac_type == e1000_82544) && ((offset & 0x1) == 1)) {
5853         temp = E1000_READ_REG_ARRAY(hw, VFTA, (offset - 1));
5854         E1000_WRITE_REG_ARRAY(hw, VFTA, offset, value);
5855         E1000_WRITE_FLUSH();
5856         E1000_WRITE_REG_ARRAY(hw, VFTA, (offset - 1), temp);
5857         E1000_WRITE_FLUSH();
5858     } else {
5859         E1000_WRITE_REG_ARRAY(hw, VFTA, offset, value);
5860         E1000_WRITE_FLUSH();
5861     }
5862 }
5863
5864 /******************************************************************************
5865  * Clears the VLAN filer table
5866  *
5867  * hw - Struct containing variables accessed by shared code
5868  *****************************************************************************/
5869 static void e1000_clear_vfta(struct e1000_hw *hw)
5870 {
5871     u32 offset;
5872     u32 vfta_value = 0;
5873     u32 vfta_offset = 0;
5874     u32 vfta_bit_in_reg = 0;
5875
5876     if (hw->mac_type == e1000_ich8lan)
5877         return;
5878
5879     if (hw->mac_type == e1000_82573) {
5880         if (hw->mng_cookie.vlan_id != 0) {
5881             /* The VFTA is a 4096b bit-field, each identifying a single VLAN
5882              * ID.  The following operations determine which 32b entry
5883              * (i.e. offset) into the array we want to set the VLAN ID
5884              * (i.e. bit) of the manageability unit. */
5885             vfta_offset = (hw->mng_cookie.vlan_id >>
5886                            E1000_VFTA_ENTRY_SHIFT) &
5887                           E1000_VFTA_ENTRY_MASK;
5888             vfta_bit_in_reg = 1 << (hw->mng_cookie.vlan_id &
5889                                     E1000_VFTA_ENTRY_BIT_SHIFT_MASK);
5890         }
5891     }
5892     for (offset = 0; offset < E1000_VLAN_FILTER_TBL_SIZE; offset++) {
5893         /* If the offset we want to clear is the same offset of the
5894          * manageability VLAN ID, then clear all bits except that of the
5895          * manageability unit */
5896         vfta_value = (offset == vfta_offset) ? vfta_bit_in_reg : 0;
5897         E1000_WRITE_REG_ARRAY(hw, VFTA, offset, vfta_value);
5898         E1000_WRITE_FLUSH();
5899     }
5900 }
5901
5902 static s32 e1000_id_led_init(struct e1000_hw *hw)
5903 {
5904     u32 ledctl;
5905     const u32 ledctl_mask = 0x000000FF;
5906     const u32 ledctl_on = E1000_LEDCTL_MODE_LED_ON;
5907     const u32 ledctl_off = E1000_LEDCTL_MODE_LED_OFF;
5908     u16 eeprom_data, i, temp;
5909     const u16 led_mask = 0x0F;
5910
5911     DEBUGFUNC("e1000_id_led_init");
5912
5913     if (hw->mac_type < e1000_82540) {
5914         /* Nothing to do */
5915         return E1000_SUCCESS;
5916     }
5917
5918     ledctl = er32(LEDCTL);
5919     hw->ledctl_default = ledctl;
5920     hw->ledctl_mode1 = hw->ledctl_default;
5921     hw->ledctl_mode2 = hw->ledctl_default;
5922
5923     if (e1000_read_eeprom(hw, EEPROM_ID_LED_SETTINGS, 1, &eeprom_data) < 0) {
5924         DEBUGOUT("EEPROM Read Error\n");
5925         return -E1000_ERR_EEPROM;
5926     }
5927
5928     if ((hw->mac_type == e1000_82573) &&
5929         (eeprom_data == ID_LED_RESERVED_82573))
5930         eeprom_data = ID_LED_DEFAULT_82573;
5931     else if ((eeprom_data == ID_LED_RESERVED_0000) ||
5932             (eeprom_data == ID_LED_RESERVED_FFFF)) {
5933         if (hw->mac_type == e1000_ich8lan)
5934             eeprom_data = ID_LED_DEFAULT_ICH8LAN;
5935         else
5936             eeprom_data = ID_LED_DEFAULT;
5937     }
5938
5939     for (i = 0; i < 4; i++) {
5940         temp = (eeprom_data >> (i << 2)) & led_mask;
5941         switch (temp) {
5942         case ID_LED_ON1_DEF2:
5943         case ID_LED_ON1_ON2:
5944         case ID_LED_ON1_OFF2:
5945             hw->ledctl_mode1 &= ~(ledctl_mask << (i << 3));
5946             hw->ledctl_mode1 |= ledctl_on << (i << 3);
5947             break;
5948         case ID_LED_OFF1_DEF2:
5949         case ID_LED_OFF1_ON2:
5950         case ID_LED_OFF1_OFF2:
5951             hw->ledctl_mode1 &= ~(ledctl_mask << (i << 3));
5952             hw->ledctl_mode1 |= ledctl_off << (i << 3);
5953             break;
5954         default:
5955             /* Do nothing */
5956             break;
5957         }
5958         switch (temp) {
5959         case ID_LED_DEF1_ON2:
5960         case ID_LED_ON1_ON2:
5961         case ID_LED_OFF1_ON2:
5962             hw->ledctl_mode2 &= ~(ledctl_mask << (i << 3));
5963             hw->ledctl_mode2 |= ledctl_on << (i << 3);
5964             break;
5965         case ID_LED_DEF1_OFF2:
5966         case ID_LED_ON1_OFF2:
5967         case ID_LED_OFF1_OFF2:
5968             hw->ledctl_mode2 &= ~(ledctl_mask << (i << 3));
5969             hw->ledctl_mode2 |= ledctl_off << (i << 3);
5970             break;
5971         default:
5972             /* Do nothing */
5973             break;
5974         }
5975     }
5976     return E1000_SUCCESS;
5977 }
5978
5979 /******************************************************************************
5980  * Prepares SW controlable LED for use and saves the current state of the LED.
5981  *
5982  * hw - Struct containing variables accessed by shared code
5983  *****************************************************************************/
5984 s32 e1000_setup_led(struct e1000_hw *hw)
5985 {
5986     u32 ledctl;
5987     s32 ret_val = E1000_SUCCESS;
5988
5989     DEBUGFUNC("e1000_setup_led");
5990
5991     switch (hw->mac_type) {
5992     case e1000_82542_rev2_0:
5993     case e1000_82542_rev2_1:
5994     case e1000_82543:
5995     case e1000_82544:
5996         /* No setup necessary */
5997         break;
5998     case e1000_82541:
5999     case e1000_82547:
6000     case e1000_82541_rev_2:
6001     case e1000_82547_rev_2:
6002         /* Turn off PHY Smart Power Down (if enabled) */
6003         ret_val = e1000_read_phy_reg(hw, IGP01E1000_GMII_FIFO,
6004                                      &hw->phy_spd_default);
6005         if (ret_val)
6006             return ret_val;
6007         ret_val = e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO,
6008                                       (u16)(hw->phy_spd_default &
6009                                       ~IGP01E1000_GMII_SPD));
6010         if (ret_val)
6011             return ret_val;
6012         /* Fall Through */
6013     default:
6014         if (hw->media_type == e1000_media_type_fiber) {
6015             ledctl = er32(LEDCTL);
6016             /* Save current LEDCTL settings */
6017             hw->ledctl_default = ledctl;
6018             /* Turn off LED0 */
6019             ledctl &= ~(E1000_LEDCTL_LED0_IVRT |
6020                         E1000_LEDCTL_LED0_BLINK |
6021                         E1000_LEDCTL_LED0_MODE_MASK);
6022             ledctl |= (E1000_LEDCTL_MODE_LED_OFF <<
6023                        E1000_LEDCTL_LED0_MODE_SHIFT);
6024             ew32(LEDCTL, ledctl);
6025         } else if (hw->media_type == e1000_media_type_copper)
6026             ew32(LEDCTL, hw->ledctl_mode1);
6027         break;
6028     }
6029
6030     return E1000_SUCCESS;
6031 }
6032
6033
6034 /******************************************************************************
6035  * Used on 82571 and later Si that has LED blink bits.
6036  * Callers must use their own timer and should have already called
6037  * e1000_id_led_init()
6038  * Call e1000_cleanup led() to stop blinking
6039  *
6040  * hw - Struct containing variables accessed by shared code
6041  *****************************************************************************/
6042 s32 e1000_blink_led_start(struct e1000_hw *hw)
6043 {
6044     s16  i;
6045     u32 ledctl_blink = 0;
6046
6047     DEBUGFUNC("e1000_id_led_blink_on");
6048
6049     if (hw->mac_type < e1000_82571) {
6050         /* Nothing to do */
6051         return E1000_SUCCESS;
6052     }
6053     if (hw->media_type == e1000_media_type_fiber) {
6054         /* always blink LED0 for PCI-E fiber */
6055         ledctl_blink = E1000_LEDCTL_LED0_BLINK |
6056                      (E1000_LEDCTL_MODE_LED_ON << E1000_LEDCTL_LED0_MODE_SHIFT);
6057     } else {
6058         /* set the blink bit for each LED that's "on" (0x0E) in ledctl_mode2 */
6059         ledctl_blink = hw->ledctl_mode2;
6060         for (i=0; i < 4; i++)
6061             if (((hw->ledctl_mode2 >> (i * 8)) & 0xFF) ==
6062                 E1000_LEDCTL_MODE_LED_ON)
6063                 ledctl_blink |= (E1000_LEDCTL_LED0_BLINK << (i * 8));
6064     }
6065
6066     ew32(LEDCTL, ledctl_blink);
6067
6068     return E1000_SUCCESS;
6069 }
6070
6071 /******************************************************************************
6072  * Restores the saved state of the SW controlable LED.
6073  *
6074  * hw - Struct containing variables accessed by shared code
6075  *****************************************************************************/
6076 s32 e1000_cleanup_led(struct e1000_hw *hw)
6077 {
6078     s32 ret_val = E1000_SUCCESS;
6079
6080     DEBUGFUNC("e1000_cleanup_led");
6081
6082     switch (hw->mac_type) {
6083     case e1000_82542_rev2_0:
6084     case e1000_82542_rev2_1:
6085     case e1000_82543:
6086     case e1000_82544:
6087         /* No cleanup necessary */
6088         break;
6089     case e1000_82541:
6090     case e1000_82547:
6091     case e1000_82541_rev_2:
6092     case e1000_82547_rev_2:
6093         /* Turn on PHY Smart Power Down (if previously enabled) */
6094         ret_val = e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO,
6095                                       hw->phy_spd_default);
6096         if (ret_val)
6097             return ret_val;
6098         /* Fall Through */
6099     default:
6100         if (hw->phy_type == e1000_phy_ife) {
6101             e1000_write_phy_reg(hw, IFE_PHY_SPECIAL_CONTROL_LED, 0);
6102             break;
6103         }
6104         /* Restore LEDCTL settings */
6105         ew32(LEDCTL, hw->ledctl_default);
6106         break;
6107     }
6108
6109     return E1000_SUCCESS;
6110 }
6111
6112 /******************************************************************************
6113  * Turns on the software controllable LED
6114  *
6115  * hw - Struct containing variables accessed by shared code
6116  *****************************************************************************/
6117 s32 e1000_led_on(struct e1000_hw *hw)
6118 {
6119     u32 ctrl = er32(CTRL);
6120
6121     DEBUGFUNC("e1000_led_on");
6122
6123     switch (hw->mac_type) {
6124     case e1000_82542_rev2_0:
6125     case e1000_82542_rev2_1:
6126     case e1000_82543:
6127         /* Set SW Defineable Pin 0 to turn on the LED */
6128         ctrl |= E1000_CTRL_SWDPIN0;
6129         ctrl |= E1000_CTRL_SWDPIO0;
6130         break;
6131     case e1000_82544:
6132         if (hw->media_type == e1000_media_type_fiber) {
6133             /* Set SW Defineable Pin 0 to turn on the LED */
6134             ctrl |= E1000_CTRL_SWDPIN0;
6135             ctrl |= E1000_CTRL_SWDPIO0;
6136         } else {
6137             /* Clear SW Defineable Pin 0 to turn on the LED */
6138             ctrl &= ~E1000_CTRL_SWDPIN0;
6139             ctrl |= E1000_CTRL_SWDPIO0;
6140         }
6141         break;
6142     default:
6143         if (hw->media_type == e1000_media_type_fiber) {
6144             /* Clear SW Defineable Pin 0 to turn on the LED */
6145             ctrl &= ~E1000_CTRL_SWDPIN0;
6146             ctrl |= E1000_CTRL_SWDPIO0;
6147         } else if (hw->phy_type == e1000_phy_ife) {
6148             e1000_write_phy_reg(hw, IFE_PHY_SPECIAL_CONTROL_LED,
6149                  (IFE_PSCL_PROBE_MODE | IFE_PSCL_PROBE_LEDS_ON));
6150         } else if (hw->media_type == e1000_media_type_copper) {
6151             ew32(LEDCTL, hw->ledctl_mode2);
6152             return E1000_SUCCESS;
6153         }
6154         break;
6155     }
6156
6157     ew32(CTRL, ctrl);
6158
6159     return E1000_SUCCESS;
6160 }
6161
6162 /******************************************************************************
6163  * Turns off the software controllable LED
6164  *
6165  * hw - Struct containing variables accessed by shared code
6166  *****************************************************************************/
6167 s32 e1000_led_off(struct e1000_hw *hw)
6168 {
6169     u32 ctrl = er32(CTRL);
6170
6171     DEBUGFUNC("e1000_led_off");
6172
6173     switch (hw->mac_type) {
6174     case e1000_82542_rev2_0:
6175     case e1000_82542_rev2_1:
6176     case e1000_82543:
6177         /* Clear SW Defineable Pin 0 to turn off the LED */
6178         ctrl &= ~E1000_CTRL_SWDPIN0;
6179         ctrl |= E1000_CTRL_SWDPIO0;
6180         break;
6181     case e1000_82544:
6182         if (hw->media_type == e1000_media_type_fiber) {
6183             /* Clear SW Defineable Pin 0 to turn off the LED */
6184             ctrl &= ~E1000_CTRL_SWDPIN0;
6185             ctrl |= E1000_CTRL_SWDPIO0;
6186         } else {
6187             /* Set SW Defineable Pin 0 to turn off the LED */
6188             ctrl |= E1000_CTRL_SWDPIN0;
6189             ctrl |= E1000_CTRL_SWDPIO0;
6190         }
6191         break;
6192     default:
6193         if (hw->media_type == e1000_media_type_fiber) {
6194             /* Set SW Defineable Pin 0 to turn off the LED */
6195             ctrl |= E1000_CTRL_SWDPIN0;
6196             ctrl |= E1000_CTRL_SWDPIO0;
6197         } else if (hw->phy_type == e1000_phy_ife) {
6198             e1000_write_phy_reg(hw, IFE_PHY_SPECIAL_CONTROL_LED,
6199                  (IFE_PSCL_PROBE_MODE | IFE_PSCL_PROBE_LEDS_OFF));
6200         } else if (hw->media_type == e1000_media_type_copper) {
6201             ew32(LEDCTL, hw->ledctl_mode1);
6202             return E1000_SUCCESS;
6203         }
6204         break;
6205     }
6206
6207     ew32(CTRL, ctrl);
6208
6209     return E1000_SUCCESS;
6210 }
6211
6212 /******************************************************************************
6213  * Clears all hardware statistics counters.
6214  *
6215  * hw - Struct containing variables accessed by shared code
6216  *****************************************************************************/
6217 static void e1000_clear_hw_cntrs(struct e1000_hw *hw)
6218 {
6219     volatile u32 temp;
6220
6221     temp = er32(CRCERRS);
6222     temp = er32(SYMERRS);
6223     temp = er32(MPC);
6224     temp = er32(SCC);
6225     temp = er32(ECOL);
6226     temp = er32(MCC);
6227     temp = er32(LATECOL);
6228     temp = er32(COLC);
6229     temp = er32(DC);
6230     temp = er32(SEC);
6231     temp = er32(RLEC);
6232     temp = er32(XONRXC);
6233     temp = er32(XONTXC);
6234     temp = er32(XOFFRXC);
6235     temp = er32(XOFFTXC);
6236     temp = er32(FCRUC);
6237
6238     if (hw->mac_type != e1000_ich8lan) {
6239     temp = er32(PRC64);
6240     temp = er32(PRC127);
6241     temp = er32(PRC255);
6242     temp = er32(PRC511);
6243     temp = er32(PRC1023);
6244     temp = er32(PRC1522);
6245     }
6246
6247     temp = er32(GPRC);
6248     temp = er32(BPRC);
6249     temp = er32(MPRC);
6250     temp = er32(GPTC);
6251     temp = er32(GORCL);
6252     temp = er32(GORCH);
6253     temp = er32(GOTCL);
6254     temp = er32(GOTCH);
6255     temp = er32(RNBC);
6256     temp = er32(RUC);
6257     temp = er32(RFC);
6258     temp = er32(ROC);
6259     temp = er32(RJC);
6260     temp = er32(TORL);
6261     temp = er32(TORH);
6262     temp = er32(TOTL);
6263     temp = er32(TOTH);
6264     temp = er32(TPR);
6265     temp = er32(TPT);
6266
6267     if (hw->mac_type != e1000_ich8lan) {
6268     temp = er32(PTC64);
6269     temp = er32(PTC127);
6270     temp = er32(PTC255);
6271     temp = er32(PTC511);
6272     temp = er32(PTC1023);
6273     temp = er32(PTC1522);
6274     }
6275
6276     temp = er32(MPTC);
6277     temp = er32(BPTC);
6278
6279     if (hw->mac_type < e1000_82543) return;
6280
6281     temp = er32(ALGNERRC);
6282     temp = er32(RXERRC);
6283     temp = er32(TNCRS);
6284     temp = er32(CEXTERR);
6285     temp = er32(TSCTC);
6286     temp = er32(TSCTFC);
6287
6288     if (hw->mac_type <= e1000_82544) return;
6289
6290     temp = er32(MGTPRC);
6291     temp = er32(MGTPDC);
6292     temp = er32(MGTPTC);
6293
6294     if (hw->mac_type <= e1000_82547_rev_2) return;
6295
6296     temp = er32(IAC);
6297     temp = er32(ICRXOC);
6298
6299     if (hw->mac_type == e1000_ich8lan) return;
6300
6301     temp = er32(ICRXPTC);
6302     temp = er32(ICRXATC);
6303     temp = er32(ICTXPTC);
6304     temp = er32(ICTXATC);
6305     temp = er32(ICTXQEC);
6306     temp = er32(ICTXQMTC);
6307     temp = er32(ICRXDMTC);
6308 }
6309
6310 /******************************************************************************
6311  * Resets Adaptive IFS to its default state.
6312  *
6313  * hw - Struct containing variables accessed by shared code
6314  *
6315  * Call this after e1000_init_hw. You may override the IFS defaults by setting
6316  * hw->ifs_params_forced to true. However, you must initialize hw->
6317  * current_ifs_val, ifs_min_val, ifs_max_val, ifs_step_size, and ifs_ratio
6318  * before calling this function.
6319  *****************************************************************************/
6320 void e1000_reset_adaptive(struct e1000_hw *hw)
6321 {
6322     DEBUGFUNC("e1000_reset_adaptive");
6323
6324     if (hw->adaptive_ifs) {
6325         if (!hw->ifs_params_forced) {
6326             hw->current_ifs_val = 0;
6327             hw->ifs_min_val = IFS_MIN;
6328             hw->ifs_max_val = IFS_MAX;
6329             hw->ifs_step_size = IFS_STEP;
6330             hw->ifs_ratio = IFS_RATIO;
6331         }
6332         hw->in_ifs_mode = false;
6333         ew32(AIT, 0);
6334     } else {
6335         DEBUGOUT("Not in Adaptive IFS mode!\n");
6336     }
6337 }
6338
6339 /******************************************************************************
6340  * Called during the callback/watchdog routine to update IFS value based on
6341  * the ratio of transmits to collisions.
6342  *
6343  * hw - Struct containing variables accessed by shared code
6344  * tx_packets - Number of transmits since last callback
6345  * total_collisions - Number of collisions since last callback
6346  *****************************************************************************/
6347 void e1000_update_adaptive(struct e1000_hw *hw)
6348 {
6349     DEBUGFUNC("e1000_update_adaptive");
6350
6351     if (hw->adaptive_ifs) {
6352         if ((hw->collision_delta * hw->ifs_ratio) > hw->tx_packet_delta) {
6353             if (hw->tx_packet_delta > MIN_NUM_XMITS) {
6354                 hw->in_ifs_mode = true;
6355                 if (hw->current_ifs_val < hw->ifs_max_val) {
6356                     if (hw->current_ifs_val == 0)
6357                         hw->current_ifs_val = hw->ifs_min_val;
6358                     else
6359                         hw->current_ifs_val += hw->ifs_step_size;
6360                     ew32(AIT, hw->current_ifs_val);
6361                 }
6362             }
6363         } else {
6364             if (hw->in_ifs_mode && (hw->tx_packet_delta <= MIN_NUM_XMITS)) {
6365                 hw->current_ifs_val = 0;
6366                 hw->in_ifs_mode = false;
6367                 ew32(AIT, 0);
6368             }
6369         }
6370     } else {
6371         DEBUGOUT("Not in Adaptive IFS mode!\n");
6372     }
6373 }
6374
6375 /******************************************************************************
6376  * Adjusts the statistic counters when a frame is accepted by TBI_ACCEPT
6377  *
6378  * hw - Struct containing variables accessed by shared code
6379  * frame_len - The length of the frame in question
6380  * mac_addr - The Ethernet destination address of the frame in question
6381  *****************************************************************************/
6382 void e1000_tbi_adjust_stats(struct e1000_hw *hw, struct e1000_hw_stats *stats,
6383                             u32 frame_len, u8 *mac_addr)
6384 {
6385     u64 carry_bit;
6386
6387     /* First adjust the frame length. */
6388     frame_len--;
6389     /* We need to adjust the statistics counters, since the hardware
6390      * counters overcount this packet as a CRC error and undercount
6391      * the packet as a good packet
6392      */
6393     /* This packet should not be counted as a CRC error.    */
6394     stats->crcerrs--;
6395     /* This packet does count as a Good Packet Received.    */
6396     stats->gprc++;
6397
6398     /* Adjust the Good Octets received counters             */
6399     carry_bit = 0x80000000 & stats->gorcl;
6400     stats->gorcl += frame_len;
6401     /* If the high bit of Gorcl (the low 32 bits of the Good Octets
6402      * Received Count) was one before the addition,
6403      * AND it is zero after, then we lost the carry out,
6404      * need to add one to Gorch (Good Octets Received Count High).
6405      * This could be simplified if all environments supported
6406      * 64-bit integers.
6407      */
6408     if (carry_bit && ((stats->gorcl & 0x80000000) == 0))
6409         stats->gorch++;
6410     /* Is this a broadcast or multicast?  Check broadcast first,
6411      * since the test for a multicast frame will test positive on
6412      * a broadcast frame.
6413      */
6414     if ((mac_addr[0] == (u8)0xff) && (mac_addr[1] == (u8)0xff))
6415         /* Broadcast packet */
6416         stats->bprc++;
6417     else if (*mac_addr & 0x01)
6418         /* Multicast packet */
6419         stats->mprc++;
6420
6421     if (frame_len == hw->max_frame_size) {
6422         /* In this case, the hardware has overcounted the number of
6423          * oversize frames.
6424          */
6425         if (stats->roc > 0)
6426             stats->roc--;
6427     }
6428
6429     /* Adjust the bin counters when the extra byte put the frame in the
6430      * wrong bin. Remember that the frame_len was adjusted above.
6431      */
6432     if (frame_len == 64) {
6433         stats->prc64++;
6434         stats->prc127--;
6435     } else if (frame_len == 127) {
6436         stats->prc127++;
6437         stats->prc255--;
6438     } else if (frame_len == 255) {
6439         stats->prc255++;
6440         stats->prc511--;
6441     } else if (frame_len == 511) {
6442         stats->prc511++;
6443         stats->prc1023--;
6444     } else if (frame_len == 1023) {
6445         stats->prc1023++;
6446         stats->prc1522--;
6447     } else if (frame_len == 1522) {
6448         stats->prc1522++;
6449     }
6450 }
6451
6452 /******************************************************************************
6453  * Gets the current PCI bus type, speed, and width of the hardware
6454  *
6455  * hw - Struct containing variables accessed by shared code
6456  *****************************************************************************/
6457 void e1000_get_bus_info(struct e1000_hw *hw)
6458 {
6459     s32 ret_val;
6460     u16 pci_ex_link_status;
6461     u32 status;
6462
6463     switch (hw->mac_type) {
6464     case e1000_82542_rev2_0:
6465     case e1000_82542_rev2_1:
6466         hw->bus_type = e1000_bus_type_pci;
6467         hw->bus_speed = e1000_bus_speed_unknown;
6468         hw->bus_width = e1000_bus_width_unknown;
6469         break;
6470     case e1000_82571:
6471     case e1000_82572:
6472     case e1000_82573:
6473     case e1000_80003es2lan:
6474         hw->bus_type = e1000_bus_type_pci_express;
6475         hw->bus_speed = e1000_bus_speed_2500;
6476         ret_val = e1000_read_pcie_cap_reg(hw,
6477                                       PCI_EX_LINK_STATUS,
6478                                       &pci_ex_link_status);
6479         if (ret_val)
6480             hw->bus_width = e1000_bus_width_unknown;
6481         else
6482             hw->bus_width = (pci_ex_link_status & PCI_EX_LINK_WIDTH_MASK) >>
6483                           PCI_EX_LINK_WIDTH_SHIFT;
6484         break;
6485     case e1000_ich8lan:
6486         hw->bus_type = e1000_bus_type_pci_express;
6487         hw->bus_speed = e1000_bus_speed_2500;
6488         hw->bus_width = e1000_bus_width_pciex_1;
6489         break;
6490     default:
6491         status = er32(STATUS);
6492         hw->bus_type = (status & E1000_STATUS_PCIX_MODE) ?
6493                        e1000_bus_type_pcix : e1000_bus_type_pci;
6494
6495         if (hw->device_id == E1000_DEV_ID_82546EB_QUAD_COPPER) {
6496             hw->bus_speed = (hw->bus_type == e1000_bus_type_pci) ?
6497                             e1000_bus_speed_66 : e1000_bus_speed_120;
6498         } else if (hw->bus_type == e1000_bus_type_pci) {
6499             hw->bus_speed = (status & E1000_STATUS_PCI66) ?
6500                             e1000_bus_speed_66 : e1000_bus_speed_33;
6501         } else {
6502             switch (status & E1000_STATUS_PCIX_SPEED) {
6503             case E1000_STATUS_PCIX_SPEED_66:
6504                 hw->bus_speed = e1000_bus_speed_66;
6505                 break;
6506             case E1000_STATUS_PCIX_SPEED_100:
6507                 hw->bus_speed = e1000_bus_speed_100;
6508                 break;
6509             case E1000_STATUS_PCIX_SPEED_133:
6510                 hw->bus_speed = e1000_bus_speed_133;
6511                 break;
6512             default:
6513                 hw->bus_speed = e1000_bus_speed_reserved;
6514                 break;
6515             }
6516         }
6517         hw->bus_width = (status & E1000_STATUS_BUS64) ?
6518                         e1000_bus_width_64 : e1000_bus_width_32;
6519         break;
6520     }
6521 }
6522
6523 /******************************************************************************
6524  * Writes a value to one of the devices registers using port I/O (as opposed to
6525  * memory mapped I/O). Only 82544 and newer devices support port I/O.
6526  *
6527  * hw - Struct containing variables accessed by shared code
6528  * offset - offset to write to
6529  * value - value to write
6530  *****************************************************************************/
6531 static void e1000_write_reg_io(struct e1000_hw *hw, u32 offset, u32 value)
6532 {
6533     unsigned long io_addr = hw->io_base;
6534     unsigned long io_data = hw->io_base + 4;
6535
6536     e1000_io_write(hw, io_addr, offset);
6537     e1000_io_write(hw, io_data, value);
6538 }
6539
6540 /******************************************************************************
6541  * Estimates the cable length.
6542  *
6543  * hw - Struct containing variables accessed by shared code
6544  * min_length - The estimated minimum length
6545  * max_length - The estimated maximum length
6546  *
6547  * returns: - E1000_ERR_XXX
6548  *            E1000_SUCCESS
6549  *
6550  * This function always returns a ranged length (minimum & maximum).
6551  * So for M88 phy's, this function interprets the one value returned from the
6552  * register to the minimum and maximum range.
6553  * For IGP phy's, the function calculates the range by the AGC registers.
6554  *****************************************************************************/
6555 static s32 e1000_get_cable_length(struct e1000_hw *hw, u16 *min_length,
6556                                   u16 *max_length)
6557 {
6558     s32 ret_val;
6559     u16 agc_value = 0;
6560     u16 i, phy_data;
6561     u16 cable_length;
6562
6563     DEBUGFUNC("e1000_get_cable_length");
6564
6565     *min_length = *max_length = 0;
6566
6567     /* Use old method for Phy older than IGP */
6568     if (hw->phy_type == e1000_phy_m88) {
6569
6570         ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS,
6571                                      &phy_data);
6572         if (ret_val)
6573             return ret_val;
6574         cable_length = (phy_data & M88E1000_PSSR_CABLE_LENGTH) >>
6575                        M88E1000_PSSR_CABLE_LENGTH_SHIFT;
6576
6577         /* Convert the enum value to ranged values */
6578         switch (cable_length) {
6579         case e1000_cable_length_50:
6580             *min_length = 0;
6581             *max_length = e1000_igp_cable_length_50;
6582             break;
6583         case e1000_cable_length_50_80:
6584             *min_length = e1000_igp_cable_length_50;
6585             *max_length = e1000_igp_cable_length_80;
6586             break;
6587         case e1000_cable_length_80_110:
6588             *min_length = e1000_igp_cable_length_80;
6589             *max_length = e1000_igp_cable_length_110;
6590             break;
6591         case e1000_cable_length_110_140:
6592             *min_length = e1000_igp_cable_length_110;
6593             *max_length = e1000_igp_cable_length_140;
6594             break;
6595         case e1000_cable_length_140:
6596             *min_length = e1000_igp_cable_length_140;
6597             *max_length = e1000_igp_cable_length_170;
6598             break;
6599         default:
6600             return -E1000_ERR_PHY;
6601             break;
6602         }
6603     } else if (hw->phy_type == e1000_phy_gg82563) {
6604         ret_val = e1000_read_phy_reg(hw, GG82563_PHY_DSP_DISTANCE,
6605                                      &phy_data);
6606         if (ret_val)
6607             return ret_val;
6608         cable_length = phy_data & GG82563_DSPD_CABLE_LENGTH;
6609
6610         switch (cable_length) {
6611         case e1000_gg_cable_length_60:
6612             *min_length = 0;
6613             *max_length = e1000_igp_cable_length_60;
6614             break;
6615         case e1000_gg_cable_length_60_115:
6616             *min_length = e1000_igp_cable_length_60;
6617             *max_length = e1000_igp_cable_length_115;
6618             break;
6619         case e1000_gg_cable_length_115_150:
6620             *min_length = e1000_igp_cable_length_115;
6621             *max_length = e1000_igp_cable_length_150;
6622             break;
6623         case e1000_gg_cable_length_150:
6624             *min_length = e1000_igp_cable_length_150;
6625             *max_length = e1000_igp_cable_length_180;
6626             break;
6627         default:
6628             return -E1000_ERR_PHY;
6629             break;
6630         }
6631     } else if (hw->phy_type == e1000_phy_igp) { /* For IGP PHY */
6632         u16 cur_agc_value;
6633         u16 min_agc_value = IGP01E1000_AGC_LENGTH_TABLE_SIZE;
6634         u16 agc_reg_array[IGP01E1000_PHY_CHANNEL_NUM] =
6635                                                          {IGP01E1000_PHY_AGC_A,
6636                                                           IGP01E1000_PHY_AGC_B,
6637                                                           IGP01E1000_PHY_AGC_C,
6638                                                           IGP01E1000_PHY_AGC_D};
6639         /* Read the AGC registers for all channels */
6640         for (i = 0; i < IGP01E1000_PHY_CHANNEL_NUM; i++) {
6641
6642             ret_val = e1000_read_phy_reg(hw, agc_reg_array[i], &phy_data);
6643             if (ret_val)
6644                 return ret_val;
6645
6646             cur_agc_value = phy_data >> IGP01E1000_AGC_LENGTH_SHIFT;
6647
6648             /* Value bound check. */
6649             if ((cur_agc_value >= IGP01E1000_AGC_LENGTH_TABLE_SIZE - 1) ||
6650                 (cur_agc_value == 0))
6651                 return -E1000_ERR_PHY;
6652
6653             agc_value += cur_agc_value;
6654
6655             /* Update minimal AGC value. */
6656             if (min_agc_value > cur_agc_value)
6657                 min_agc_value = cur_agc_value;
6658         }
6659
6660         /* Remove the minimal AGC result for length < 50m */
6661         if (agc_value < IGP01E1000_PHY_CHANNEL_NUM * e1000_igp_cable_length_50) {
6662             agc_value -= min_agc_value;
6663
6664             /* Get the average length of the remaining 3 channels */
6665             agc_value /= (IGP01E1000_PHY_CHANNEL_NUM - 1);
6666         } else {
6667             /* Get the average length of all the 4 channels. */
6668             agc_value /= IGP01E1000_PHY_CHANNEL_NUM;
6669         }
6670
6671         /* Set the range of the calculated length. */
6672         *min_length = ((e1000_igp_cable_length_table[agc_value] -
6673                        IGP01E1000_AGC_RANGE) > 0) ?
6674                        (e1000_igp_cable_length_table[agc_value] -
6675                        IGP01E1000_AGC_RANGE) : 0;
6676         *max_length = e1000_igp_cable_length_table[agc_value] +
6677                       IGP01E1000_AGC_RANGE;
6678     } else if (hw->phy_type == e1000_phy_igp_2 ||
6679                hw->phy_type == e1000_phy_igp_3) {
6680         u16 cur_agc_index, max_agc_index = 0;
6681         u16 min_agc_index = IGP02E1000_AGC_LENGTH_TABLE_SIZE - 1;
6682         u16 agc_reg_array[IGP02E1000_PHY_CHANNEL_NUM] =
6683                                                          {IGP02E1000_PHY_AGC_A,
6684                                                           IGP02E1000_PHY_AGC_B,
6685                                                           IGP02E1000_PHY_AGC_C,
6686                                                           IGP02E1000_PHY_AGC_D};
6687         /* Read the AGC registers for all channels */
6688         for (i = 0; i < IGP02E1000_PHY_CHANNEL_NUM; i++) {
6689             ret_val = e1000_read_phy_reg(hw, agc_reg_array[i], &phy_data);
6690             if (ret_val)
6691                 return ret_val;
6692
6693             /* Getting bits 15:9, which represent the combination of course and
6694              * fine gain values.  The result is a number that can be put into
6695              * the lookup table to obtain the approximate cable length. */
6696             cur_agc_index = (phy_data >> IGP02E1000_AGC_LENGTH_SHIFT) &
6697                             IGP02E1000_AGC_LENGTH_MASK;
6698
6699             /* Array index bound check. */
6700             if ((cur_agc_index >= IGP02E1000_AGC_LENGTH_TABLE_SIZE) ||
6701                 (cur_agc_index == 0))
6702                 return -E1000_ERR_PHY;
6703
6704             /* Remove min & max AGC values from calculation. */
6705             if (e1000_igp_2_cable_length_table[min_agc_index] >
6706                 e1000_igp_2_cable_length_table[cur_agc_index])
6707                 min_agc_index = cur_agc_index;
6708             if (e1000_igp_2_cable_length_table[max_agc_index] <
6709                 e1000_igp_2_cable_length_table[cur_agc_index])
6710                 max_agc_index = cur_agc_index;
6711
6712             agc_value += e1000_igp_2_cable_length_table[cur_agc_index];
6713         }
6714
6715         agc_value -= (e1000_igp_2_cable_length_table[min_agc_index] +
6716                       e1000_igp_2_cable_length_table[max_agc_index]);
6717         agc_value /= (IGP02E1000_PHY_CHANNEL_NUM - 2);
6718
6719         /* Calculate cable length with the error range of +/- 10 meters. */
6720         *min_length = ((agc_value - IGP02E1000_AGC_RANGE) > 0) ?
6721                        (agc_value - IGP02E1000_AGC_RANGE) : 0;
6722         *max_length = agc_value + IGP02E1000_AGC_RANGE;
6723     }
6724
6725     return E1000_SUCCESS;
6726 }
6727
6728 /******************************************************************************
6729  * Check the cable polarity
6730  *
6731  * hw - Struct containing variables accessed by shared code
6732  * polarity - output parameter : 0 - Polarity is not reversed
6733  *                               1 - Polarity is reversed.
6734  *
6735  * returns: - E1000_ERR_XXX
6736  *            E1000_SUCCESS
6737  *
6738  * For phy's older then IGP, this function simply reads the polarity bit in the
6739  * Phy Status register.  For IGP phy's, this bit is valid only if link speed is
6740  * 10 Mbps.  If the link speed is 100 Mbps there is no polarity so this bit will
6741  * return 0.  If the link speed is 1000 Mbps the polarity status is in the
6742  * IGP01E1000_PHY_PCS_INIT_REG.
6743  *****************************************************************************/
6744 static s32 e1000_check_polarity(struct e1000_hw *hw,
6745                                 e1000_rev_polarity *polarity)
6746 {
6747     s32 ret_val;
6748     u16 phy_data;
6749
6750     DEBUGFUNC("e1000_check_polarity");
6751
6752     if ((hw->phy_type == e1000_phy_m88) ||
6753         (hw->phy_type == e1000_phy_gg82563)) {
6754         /* return the Polarity bit in the Status register. */
6755         ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS,
6756                                      &phy_data);
6757         if (ret_val)
6758             return ret_val;
6759         *polarity = ((phy_data & M88E1000_PSSR_REV_POLARITY) >>
6760                      M88E1000_PSSR_REV_POLARITY_SHIFT) ?
6761                      e1000_rev_polarity_reversed : e1000_rev_polarity_normal;
6762
6763     } else if (hw->phy_type == e1000_phy_igp ||
6764               hw->phy_type == e1000_phy_igp_3 ||
6765               hw->phy_type == e1000_phy_igp_2) {
6766         /* Read the Status register to check the speed */
6767         ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_STATUS,
6768                                      &phy_data);
6769         if (ret_val)
6770             return ret_val;
6771
6772         /* If speed is 1000 Mbps, must read the IGP01E1000_PHY_PCS_INIT_REG to
6773          * find the polarity status */
6774         if ((phy_data & IGP01E1000_PSSR_SPEED_MASK) ==
6775            IGP01E1000_PSSR_SPEED_1000MBPS) {
6776
6777             /* Read the GIG initialization PCS register (0x00B4) */
6778             ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PCS_INIT_REG,
6779                                          &phy_data);
6780             if (ret_val)
6781                 return ret_val;
6782
6783             /* Check the polarity bits */
6784             *polarity = (phy_data & IGP01E1000_PHY_POLARITY_MASK) ?
6785                          e1000_rev_polarity_reversed : e1000_rev_polarity_normal;
6786         } else {
6787             /* For 10 Mbps, read the polarity bit in the status register. (for
6788              * 100 Mbps this bit is always 0) */
6789             *polarity = (phy_data & IGP01E1000_PSSR_POLARITY_REVERSED) ?
6790                          e1000_rev_polarity_reversed : e1000_rev_polarity_normal;
6791         }
6792     } else if (hw->phy_type == e1000_phy_ife) {
6793         ret_val = e1000_read_phy_reg(hw, IFE_PHY_EXTENDED_STATUS_CONTROL,
6794                                      &phy_data);
6795         if (ret_val)
6796             return ret_val;
6797         *polarity = ((phy_data & IFE_PESC_POLARITY_REVERSED) >>
6798                      IFE_PESC_POLARITY_REVERSED_SHIFT) ?
6799                      e1000_rev_polarity_reversed : e1000_rev_polarity_normal;
6800     }
6801     return E1000_SUCCESS;
6802 }
6803
6804 /******************************************************************************
6805  * Check if Downshift occured
6806  *
6807  * hw - Struct containing variables accessed by shared code
6808  * downshift - output parameter : 0 - No Downshift ocured.
6809  *                                1 - Downshift ocured.
6810  *
6811  * returns: - E1000_ERR_XXX
6812  *            E1000_SUCCESS
6813  *
6814  * For phy's older then IGP, this function reads the Downshift bit in the Phy
6815  * Specific Status register.  For IGP phy's, it reads the Downgrade bit in the
6816  * Link Health register.  In IGP this bit is latched high, so the driver must
6817  * read it immediately after link is established.
6818  *****************************************************************************/
6819 static s32 e1000_check_downshift(struct e1000_hw *hw)
6820 {
6821     s32 ret_val;
6822     u16 phy_data;
6823
6824     DEBUGFUNC("e1000_check_downshift");
6825
6826     if (hw->phy_type == e1000_phy_igp ||
6827         hw->phy_type == e1000_phy_igp_3 ||
6828         hw->phy_type == e1000_phy_igp_2) {
6829         ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_LINK_HEALTH,
6830                                      &phy_data);
6831         if (ret_val)
6832             return ret_val;
6833
6834         hw->speed_downgraded = (phy_data & IGP01E1000_PLHR_SS_DOWNGRADE) ? 1 : 0;
6835     } else if ((hw->phy_type == e1000_phy_m88) ||
6836                (hw->phy_type == e1000_phy_gg82563)) {
6837         ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS,
6838                                      &phy_data);
6839         if (ret_val)
6840             return ret_val;
6841
6842         hw->speed_downgraded = (phy_data & M88E1000_PSSR_DOWNSHIFT) >>
6843                                M88E1000_PSSR_DOWNSHIFT_SHIFT;
6844     } else if (hw->phy_type == e1000_phy_ife) {
6845         /* e1000_phy_ife supports 10/100 speed only */
6846         hw->speed_downgraded = false;
6847     }
6848
6849     return E1000_SUCCESS;
6850 }
6851
6852 /*****************************************************************************
6853  *
6854  * 82541_rev_2 & 82547_rev_2 have the capability to configure the DSP when a
6855  * gigabit link is achieved to improve link quality.
6856  *
6857  * hw: Struct containing variables accessed by shared code
6858  *
6859  * returns: - E1000_ERR_PHY if fail to read/write the PHY
6860  *            E1000_SUCCESS at any other case.
6861  *
6862  ****************************************************************************/
6863
6864 static s32 e1000_config_dsp_after_link_change(struct e1000_hw *hw, bool link_up)
6865 {
6866     s32 ret_val;
6867     u16 phy_data, phy_saved_data, speed, duplex, i;
6868     u16 dsp_reg_array[IGP01E1000_PHY_CHANNEL_NUM] =
6869                                         {IGP01E1000_PHY_AGC_PARAM_A,
6870                                         IGP01E1000_PHY_AGC_PARAM_B,
6871                                         IGP01E1000_PHY_AGC_PARAM_C,
6872                                         IGP01E1000_PHY_AGC_PARAM_D};
6873     u16 min_length, max_length;
6874
6875     DEBUGFUNC("e1000_config_dsp_after_link_change");
6876
6877     if (hw->phy_type != e1000_phy_igp)
6878         return E1000_SUCCESS;
6879
6880     if (link_up) {
6881         ret_val = e1000_get_speed_and_duplex(hw, &speed, &duplex);
6882         if (ret_val) {
6883             DEBUGOUT("Error getting link speed and duplex\n");
6884             return ret_val;
6885         }
6886
6887         if (speed == SPEED_1000) {
6888
6889             ret_val = e1000_get_cable_length(hw, &min_length, &max_length);
6890             if (ret_val)
6891                 return ret_val;
6892
6893             if ((hw->dsp_config_state == e1000_dsp_config_enabled) &&
6894                 min_length >= e1000_igp_cable_length_50) {
6895
6896                 for (i = 0; i < IGP01E1000_PHY_CHANNEL_NUM; i++) {
6897                     ret_val = e1000_read_phy_reg(hw, dsp_reg_array[i],
6898                                                  &phy_data);
6899                     if (ret_val)
6900                         return ret_val;
6901
6902                     phy_data &= ~IGP01E1000_PHY_EDAC_MU_INDEX;
6903
6904                     ret_val = e1000_write_phy_reg(hw, dsp_reg_array[i],
6905                                                   phy_data);
6906                     if (ret_val)
6907                         return ret_val;
6908                 }
6909                 hw->dsp_config_state = e1000_dsp_config_activated;
6910             }
6911
6912             if ((hw->ffe_config_state == e1000_ffe_config_enabled) &&
6913                (min_length < e1000_igp_cable_length_50)) {
6914
6915                 u16 ffe_idle_err_timeout = FFE_IDLE_ERR_COUNT_TIMEOUT_20;
6916                 u32 idle_errs = 0;
6917
6918                 /* clear previous idle error counts */
6919                 ret_val = e1000_read_phy_reg(hw, PHY_1000T_STATUS,
6920                                              &phy_data);
6921                 if (ret_val)
6922                     return ret_val;
6923
6924                 for (i = 0; i < ffe_idle_err_timeout; i++) {
6925                     udelay(1000);
6926                     ret_val = e1000_read_phy_reg(hw, PHY_1000T_STATUS,
6927                                                  &phy_data);
6928                     if (ret_val)
6929                         return ret_val;
6930
6931                     idle_errs += (phy_data & SR_1000T_IDLE_ERROR_CNT);
6932                     if (idle_errs > SR_1000T_PHY_EXCESSIVE_IDLE_ERR_COUNT) {
6933                         hw->ffe_config_state = e1000_ffe_config_active;
6934
6935                         ret_val = e1000_write_phy_reg(hw,
6936                                     IGP01E1000_PHY_DSP_FFE,
6937                                     IGP01E1000_PHY_DSP_FFE_CM_CP);
6938                         if (ret_val)
6939                             return ret_val;
6940                         break;
6941                     }
6942
6943                     if (idle_errs)
6944                         ffe_idle_err_timeout = FFE_IDLE_ERR_COUNT_TIMEOUT_100;
6945                 }
6946             }
6947         }
6948     } else {
6949         if (hw->dsp_config_state == e1000_dsp_config_activated) {
6950             /* Save off the current value of register 0x2F5B to be restored at
6951              * the end of the routines. */
6952             ret_val = e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data);
6953
6954             if (ret_val)
6955                 return ret_val;
6956
6957             /* Disable the PHY transmitter */
6958             ret_val = e1000_write_phy_reg(hw, 0x2F5B, 0x0003);
6959
6960             if (ret_val)
6961                 return ret_val;
6962
6963             mdelay(20);
6964
6965             ret_val = e1000_write_phy_reg(hw, 0x0000,
6966                                           IGP01E1000_IEEE_FORCE_GIGA);
6967             if (ret_val)
6968                 return ret_val;
6969             for (i = 0; i < IGP01E1000_PHY_CHANNEL_NUM; i++) {
6970                 ret_val = e1000_read_phy_reg(hw, dsp_reg_array[i], &phy_data);
6971                 if (ret_val)
6972                     return ret_val;
6973
6974                 phy_data &= ~IGP01E1000_PHY_EDAC_MU_INDEX;
6975                 phy_data |=  IGP01E1000_PHY_EDAC_SIGN_EXT_9_BITS;
6976
6977                 ret_val = e1000_write_phy_reg(hw,dsp_reg_array[i], phy_data);
6978                 if (ret_val)
6979                     return ret_val;
6980             }
6981
6982             ret_val = e1000_write_phy_reg(hw, 0x0000,
6983                                           IGP01E1000_IEEE_RESTART_AUTONEG);
6984             if (ret_val)
6985                 return ret_val;
6986
6987             mdelay(20);
6988
6989             /* Now enable the transmitter */
6990             ret_val = e1000_write_phy_reg(hw, 0x2F5B, phy_saved_data);
6991
6992             if (ret_val)
6993                 return ret_val;
6994
6995             hw->dsp_config_state = e1000_dsp_config_enabled;
6996         }
6997
6998         if (hw->ffe_config_state == e1000_ffe_config_active) {
6999             /* Save off the current value of register 0x2F5B to be restored at
7000              * the end of the routines. */
7001             ret_val = e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data);
7002
7003             if (ret_val)
7004                 return ret_val;
7005
7006             /* Disable the PHY transmitter */
7007             ret_val = e1000_write_phy_reg(hw, 0x2F5B, 0x0003);
7008
7009             if (ret_val)
7010                 return ret_val;
7011
7012             mdelay(20);
7013
7014             ret_val = e1000_write_phy_reg(hw, 0x0000,
7015                                           IGP01E1000_IEEE_FORCE_GIGA);
7016             if (ret_val)
7017                 return ret_val;
7018             ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_DSP_FFE,
7019                                           IGP01E1000_PHY_DSP_FFE_DEFAULT);
7020             if (ret_val)
7021                 return ret_val;
7022
7023             ret_val = e1000_write_phy_reg(hw, 0x0000,
7024                                           IGP01E1000_IEEE_RESTART_AUTONEG);
7025             if (ret_val)
7026                 return ret_val;
7027
7028             mdelay(20);
7029
7030             /* Now enable the transmitter */
7031             ret_val = e1000_write_phy_reg(hw, 0x2F5B, phy_saved_data);
7032
7033             if (ret_val)
7034                 return ret_val;
7035
7036             hw->ffe_config_state = e1000_ffe_config_enabled;
7037         }
7038     }
7039     return E1000_SUCCESS;
7040 }
7041
7042 /*****************************************************************************
7043  * Set PHY to class A mode
7044  * Assumes the following operations will follow to enable the new class mode.
7045  *  1. Do a PHY soft reset
7046  *  2. Restart auto-negotiation or force link.
7047  *
7048  * hw - Struct containing variables accessed by shared code
7049  ****************************************************************************/
7050 static s32 e1000_set_phy_mode(struct e1000_hw *hw)
7051 {
7052     s32 ret_val;
7053     u16 eeprom_data;
7054
7055     DEBUGFUNC("e1000_set_phy_mode");
7056
7057     if ((hw->mac_type == e1000_82545_rev_3) &&
7058         (hw->media_type == e1000_media_type_copper)) {
7059         ret_val = e1000_read_eeprom(hw, EEPROM_PHY_CLASS_WORD, 1, &eeprom_data);
7060         if (ret_val) {
7061             return ret_val;
7062         }
7063
7064         if ((eeprom_data != EEPROM_RESERVED_WORD) &&
7065             (eeprom_data & EEPROM_PHY_CLASS_A)) {
7066             ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x000B);
7067             if (ret_val)
7068                 return ret_val;
7069             ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0x8104);
7070             if (ret_val)
7071                 return ret_val;
7072
7073             hw->phy_reset_disable = false;
7074         }
7075     }
7076
7077     return E1000_SUCCESS;
7078 }
7079
7080 /*****************************************************************************
7081  *
7082  * This function sets the lplu state according to the active flag.  When
7083  * activating lplu this function also disables smart speed and vise versa.
7084  * lplu will not be activated unless the device autonegotiation advertisment
7085  * meets standards of either 10 or 10/100 or 10/100/1000 at all duplexes.
7086  * hw: Struct containing variables accessed by shared code
7087  * active - true to enable lplu false to disable lplu.
7088  *
7089  * returns: - E1000_ERR_PHY if fail to read/write the PHY
7090  *            E1000_SUCCESS at any other case.
7091  *
7092  ****************************************************************************/
7093
7094 static s32 e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active)
7095 {
7096     u32 phy_ctrl = 0;
7097     s32 ret_val;
7098     u16 phy_data;
7099     DEBUGFUNC("e1000_set_d3_lplu_state");
7100
7101     if (hw->phy_type != e1000_phy_igp && hw->phy_type != e1000_phy_igp_2
7102         && hw->phy_type != e1000_phy_igp_3)
7103         return E1000_SUCCESS;
7104
7105     /* During driver activity LPLU should not be used or it will attain link
7106      * from the lowest speeds starting from 10Mbps. The capability is used for
7107      * Dx transitions and states */
7108     if (hw->mac_type == e1000_82541_rev_2 || hw->mac_type == e1000_82547_rev_2) {
7109         ret_val = e1000_read_phy_reg(hw, IGP01E1000_GMII_FIFO, &phy_data);
7110         if (ret_val)
7111             return ret_val;
7112     } else if (hw->mac_type == e1000_ich8lan) {
7113         /* MAC writes into PHY register based on the state transition
7114          * and start auto-negotiation. SW driver can overwrite the settings
7115          * in CSR PHY power control E1000_PHY_CTRL register. */
7116         phy_ctrl = er32(PHY_CTRL);
7117     } else {
7118         ret_val = e1000_read_phy_reg(hw, IGP02E1000_PHY_POWER_MGMT, &phy_data);
7119         if (ret_val)
7120             return ret_val;
7121     }
7122
7123     if (!active) {
7124         if (hw->mac_type == e1000_82541_rev_2 ||
7125             hw->mac_type == e1000_82547_rev_2) {
7126             phy_data &= ~IGP01E1000_GMII_FLEX_SPD;
7127             ret_val = e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO, phy_data);
7128             if (ret_val)
7129                 return ret_val;
7130         } else {
7131             if (hw->mac_type == e1000_ich8lan) {
7132                 phy_ctrl &= ~E1000_PHY_CTRL_NOND0A_LPLU;
7133                 ew32(PHY_CTRL, phy_ctrl);
7134             } else {
7135                 phy_data &= ~IGP02E1000_PM_D3_LPLU;
7136                 ret_val = e1000_write_phy_reg(hw, IGP02E1000_PHY_POWER_MGMT,
7137                                               phy_data);
7138                 if (ret_val)
7139                     return ret_val;
7140             }
7141         }
7142
7143         /* LPLU and SmartSpeed are mutually exclusive.  LPLU is used during
7144          * Dx states where the power conservation is most important.  During
7145          * driver activity we should enable SmartSpeed, so performance is
7146          * maintained. */
7147         if (hw->smart_speed == e1000_smart_speed_on) {
7148             ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
7149                                          &phy_data);
7150             if (ret_val)
7151                 return ret_val;
7152
7153             phy_data |= IGP01E1000_PSCFR_SMART_SPEED;
7154             ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
7155                                           phy_data);
7156             if (ret_val)
7157                 return ret_val;
7158         } else if (hw->smart_speed == e1000_smart_speed_off) {
7159             ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
7160                                          &phy_data);
7161             if (ret_val)
7162                 return ret_val;
7163
7164             phy_data &= ~IGP01E1000_PSCFR_SMART_SPEED;
7165             ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
7166                                           phy_data);
7167             if (ret_val)
7168                 return ret_val;
7169         }
7170
7171     } else if ((hw->autoneg_advertised == AUTONEG_ADVERTISE_SPEED_DEFAULT) ||
7172                (hw->autoneg_advertised == AUTONEG_ADVERTISE_10_ALL ) ||
7173                (hw->autoneg_advertised == AUTONEG_ADVERTISE_10_100_ALL)) {
7174
7175         if (hw->mac_type == e1000_82541_rev_2 ||
7176             hw->mac_type == e1000_82547_rev_2) {
7177             phy_data |= IGP01E1000_GMII_FLEX_SPD;
7178             ret_val = e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO, phy_data);
7179             if (ret_val)
7180                 return ret_val;
7181         } else {
7182             if (hw->mac_type == e1000_ich8lan) {
7183                 phy_ctrl |= E1000_PHY_CTRL_NOND0A_LPLU;
7184                 ew32(PHY_CTRL, phy_ctrl);
7185             } else {
7186                 phy_data |= IGP02E1000_PM_D3_LPLU;
7187                 ret_val = e1000_write_phy_reg(hw, IGP02E1000_PHY_POWER_MGMT,
7188                                               phy_data);
7189                 if (ret_val)
7190                     return ret_val;
7191             }
7192         }
7193
7194         /* When LPLU is enabled we should disable SmartSpeed */
7195         ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG, &phy_data);
7196         if (ret_val)
7197             return ret_val;
7198
7199         phy_data &= ~IGP01E1000_PSCFR_SMART_SPEED;
7200         ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG, phy_data);
7201         if (ret_val)
7202             return ret_val;
7203
7204     }
7205     return E1000_SUCCESS;
7206 }
7207
7208 /*****************************************************************************
7209  *
7210  * This function sets the lplu d0 state according to the active flag.  When
7211  * activating lplu this function also disables smart speed and vise versa.
7212  * lplu will not be activated unless the device autonegotiation advertisment
7213  * meets standards of either 10 or 10/100 or 10/100/1000 at all duplexes.
7214  * hw: Struct containing variables accessed by shared code
7215  * active - true to enable lplu false to disable lplu.
7216  *
7217  * returns: - E1000_ERR_PHY if fail to read/write the PHY
7218  *            E1000_SUCCESS at any other case.
7219  *
7220  ****************************************************************************/
7221
7222 static s32 e1000_set_d0_lplu_state(struct e1000_hw *hw, bool active)
7223 {
7224     u32 phy_ctrl = 0;
7225     s32 ret_val;
7226     u16 phy_data;
7227     DEBUGFUNC("e1000_set_d0_lplu_state");
7228
7229     if (hw->mac_type <= e1000_82547_rev_2)
7230         return E1000_SUCCESS;
7231
7232     if (hw->mac_type == e1000_ich8lan) {
7233         phy_ctrl = er32(PHY_CTRL);
7234     } else {
7235         ret_val = e1000_read_phy_reg(hw, IGP02E1000_PHY_POWER_MGMT, &phy_data);
7236         if (ret_val)
7237             return ret_val;
7238     }
7239
7240     if (!active) {
7241         if (hw->mac_type == e1000_ich8lan) {
7242             phy_ctrl &= ~E1000_PHY_CTRL_D0A_LPLU;
7243             ew32(PHY_CTRL, phy_ctrl);
7244         } else {
7245             phy_data &= ~IGP02E1000_PM_D0_LPLU;
7246             ret_val = e1000_write_phy_reg(hw, IGP02E1000_PHY_POWER_MGMT, phy_data);
7247             if (ret_val)
7248                 return ret_val;
7249         }
7250
7251         /* LPLU and SmartSpeed are mutually exclusive.  LPLU is used during
7252          * Dx states where the power conservation is most important.  During
7253          * driver activity we should enable SmartSpeed, so performance is
7254          * maintained. */
7255         if (hw->smart_speed == e1000_smart_speed_on) {
7256             ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
7257                                          &phy_data);
7258             if (ret_val)
7259                 return ret_val;
7260
7261             phy_data |= IGP01E1000_PSCFR_SMART_SPEED;
7262             ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
7263                                           phy_data);
7264             if (ret_val)
7265                 return ret_val;
7266         } else if (hw->smart_speed == e1000_smart_speed_off) {
7267             ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
7268                                          &phy_data);
7269             if (ret_val)
7270                 return ret_val;
7271
7272             phy_data &= ~IGP01E1000_PSCFR_SMART_SPEED;
7273             ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
7274                                           phy_data);
7275             if (ret_val)
7276                 return ret_val;
7277         }
7278
7279
7280     } else {
7281
7282         if (hw->mac_type == e1000_ich8lan) {
7283             phy_ctrl |= E1000_PHY_CTRL_D0A_LPLU;
7284             ew32(PHY_CTRL, phy_ctrl);
7285         } else {
7286             phy_data |= IGP02E1000_PM_D0_LPLU;
7287             ret_val = e1000_write_phy_reg(hw, IGP02E1000_PHY_POWER_MGMT, phy_data);
7288             if (ret_val)
7289                 return ret_val;
7290         }
7291
7292         /* When LPLU is enabled we should disable SmartSpeed */
7293         ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG, &phy_data);
7294         if (ret_val)
7295             return ret_val;
7296
7297         phy_data &= ~IGP01E1000_PSCFR_SMART_SPEED;
7298         ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG, phy_data);
7299         if (ret_val)
7300             return ret_val;
7301
7302     }
7303     return E1000_SUCCESS;
7304 }
7305
7306 /******************************************************************************
7307  * Change VCO speed register to improve Bit Error Rate performance of SERDES.
7308  *
7309  * hw - Struct containing variables accessed by shared code
7310  *****************************************************************************/
7311 static s32 e1000_set_vco_speed(struct e1000_hw *hw)
7312 {
7313     s32  ret_val;
7314     u16 default_page = 0;
7315     u16 phy_data;
7316
7317     DEBUGFUNC("e1000_set_vco_speed");
7318
7319     switch (hw->mac_type) {
7320     case e1000_82545_rev_3:
7321     case e1000_82546_rev_3:
7322        break;
7323     default:
7324         return E1000_SUCCESS;
7325     }
7326
7327     /* Set PHY register 30, page 5, bit 8 to 0 */
7328
7329     ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, &default_page);
7330     if (ret_val)
7331         return ret_val;
7332
7333     ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0005);
7334     if (ret_val)
7335         return ret_val;
7336
7337     ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, &phy_data);
7338     if (ret_val)
7339         return ret_val;
7340
7341     phy_data &= ~M88E1000_PHY_VCO_REG_BIT8;
7342     ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, phy_data);
7343     if (ret_val)
7344         return ret_val;
7345
7346     /* Set PHY register 30, page 4, bit 11 to 1 */
7347
7348     ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0004);
7349     if (ret_val)
7350         return ret_val;
7351
7352     ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, &phy_data);
7353     if (ret_val)
7354         return ret_val;
7355
7356     phy_data |= M88E1000_PHY_VCO_REG_BIT11;
7357     ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, phy_data);
7358     if (ret_val)
7359         return ret_val;
7360
7361     ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, default_page);
7362     if (ret_val)
7363         return ret_val;
7364
7365     return E1000_SUCCESS;
7366 }
7367
7368
7369 /*****************************************************************************
7370  * This function reads the cookie from ARC ram.
7371  *
7372  * returns: - E1000_SUCCESS .
7373  ****************************************************************************/
7374 static s32 e1000_host_if_read_cookie(struct e1000_hw *hw, u8 *buffer)
7375 {
7376     u8 i;
7377     u32 offset = E1000_MNG_DHCP_COOKIE_OFFSET;
7378     u8 length = E1000_MNG_DHCP_COOKIE_LENGTH;
7379
7380     length = (length >> 2);
7381     offset = (offset >> 2);
7382
7383     for (i = 0; i < length; i++) {
7384         *((u32 *)buffer + i) =
7385             E1000_READ_REG_ARRAY_DWORD(hw, HOST_IF, offset + i);
7386     }
7387     return E1000_SUCCESS;
7388 }
7389
7390
7391 /*****************************************************************************
7392  * This function checks whether the HOST IF is enabled for command operaton
7393  * and also checks whether the previous command is completed.
7394  * It busy waits in case of previous command is not completed.
7395  *
7396  * returns: - E1000_ERR_HOST_INTERFACE_COMMAND in case if is not ready or
7397  *            timeout
7398  *          - E1000_SUCCESS for success.
7399  ****************************************************************************/
7400 static s32 e1000_mng_enable_host_if(struct e1000_hw *hw)
7401 {
7402     u32 hicr;
7403     u8 i;
7404
7405     /* Check that the host interface is enabled. */
7406     hicr = er32(HICR);
7407     if ((hicr & E1000_HICR_EN) == 0) {
7408         DEBUGOUT("E1000_HOST_EN bit disabled.\n");
7409         return -E1000_ERR_HOST_INTERFACE_COMMAND;
7410     }
7411     /* check the previous command is completed */
7412     for (i = 0; i < E1000_MNG_DHCP_COMMAND_TIMEOUT; i++) {
7413         hicr = er32(HICR);
7414         if (!(hicr & E1000_HICR_C))
7415             break;
7416         mdelay(1);
7417     }
7418
7419     if (i == E1000_MNG_DHCP_COMMAND_TIMEOUT) {
7420         DEBUGOUT("Previous command timeout failed .\n");
7421         return -E1000_ERR_HOST_INTERFACE_COMMAND;
7422     }
7423     return E1000_SUCCESS;
7424 }
7425
7426 /*****************************************************************************
7427  * This function writes the buffer content at the offset given on the host if.
7428  * It also does alignment considerations to do the writes in most efficient way.
7429  * Also fills up the sum of the buffer in *buffer parameter.
7430  *
7431  * returns  - E1000_SUCCESS for success.
7432  ****************************************************************************/
7433 static s32 e1000_mng_host_if_write(struct e1000_hw *hw, u8 *buffer, u16 length,
7434                                    u16 offset, u8 *sum)
7435 {
7436     u8 *tmp;
7437     u8 *bufptr = buffer;
7438     u32 data = 0;
7439     u16 remaining, i, j, prev_bytes;
7440
7441     /* sum = only sum of the data and it is not checksum */
7442
7443     if (length == 0 || offset + length > E1000_HI_MAX_MNG_DATA_LENGTH) {
7444         return -E1000_ERR_PARAM;
7445     }
7446
7447     tmp = (u8 *)&data;
7448     prev_bytes = offset & 0x3;
7449     offset &= 0xFFFC;
7450     offset >>= 2;
7451
7452     if (prev_bytes) {
7453         data = E1000_READ_REG_ARRAY_DWORD(hw, HOST_IF, offset);
7454         for (j = prev_bytes; j < sizeof(u32); j++) {
7455             *(tmp + j) = *bufptr++;
7456             *sum += *(tmp + j);
7457         }
7458         E1000_WRITE_REG_ARRAY_DWORD(hw, HOST_IF, offset, data);
7459         length -= j - prev_bytes;
7460         offset++;
7461     }
7462
7463     remaining = length & 0x3;
7464     length -= remaining;
7465
7466     /* Calculate length in DWORDs */
7467     length >>= 2;
7468
7469     /* The device driver writes the relevant command block into the
7470      * ram area. */
7471     for (i = 0; i < length; i++) {
7472         for (j = 0; j < sizeof(u32); j++) {
7473             *(tmp + j) = *bufptr++;
7474             *sum += *(tmp + j);
7475         }
7476
7477         E1000_WRITE_REG_ARRAY_DWORD(hw, HOST_IF, offset + i, data);
7478     }
7479     if (remaining) {
7480         for (j = 0; j < sizeof(u32); j++) {
7481             if (j < remaining)
7482                 *(tmp + j) = *bufptr++;
7483             else
7484                 *(tmp + j) = 0;
7485
7486             *sum += *(tmp + j);
7487         }
7488         E1000_WRITE_REG_ARRAY_DWORD(hw, HOST_IF, offset + i, data);
7489     }
7490
7491     return E1000_SUCCESS;
7492 }
7493
7494
7495 /*****************************************************************************
7496  * This function writes the command header after does the checksum calculation.
7497  *
7498  * returns  - E1000_SUCCESS for success.
7499  ****************************************************************************/
7500 static s32 e1000_mng_write_cmd_header(struct e1000_hw *hw,
7501                                       struct e1000_host_mng_command_header *hdr)
7502 {
7503     u16 i;
7504     u8 sum;
7505     u8 *buffer;
7506
7507     /* Write the whole command header structure which includes sum of
7508      * the buffer */
7509
7510     u16 length = sizeof(struct e1000_host_mng_command_header);
7511
7512     sum = hdr->checksum;
7513     hdr->checksum = 0;
7514
7515     buffer = (u8 *)hdr;
7516     i = length;
7517     while (i--)
7518         sum += buffer[i];
7519
7520     hdr->checksum = 0 - sum;
7521
7522     length >>= 2;
7523     /* The device driver writes the relevant command block into the ram area. */
7524     for (i = 0; i < length; i++) {
7525         E1000_WRITE_REG_ARRAY_DWORD(hw, HOST_IF, i, *((u32 *)hdr + i));
7526         E1000_WRITE_FLUSH();
7527     }
7528
7529     return E1000_SUCCESS;
7530 }
7531
7532
7533 /*****************************************************************************
7534  * This function indicates to ARC that a new command is pending which completes
7535  * one write operation by the driver.
7536  *
7537  * returns  - E1000_SUCCESS for success.
7538  ****************************************************************************/
7539 static s32 e1000_mng_write_commit(struct e1000_hw *hw)
7540 {
7541     u32 hicr;
7542
7543     hicr = er32(HICR);
7544     /* Setting this bit tells the ARC that a new command is pending. */
7545     ew32(HICR, hicr | E1000_HICR_C);
7546
7547     return E1000_SUCCESS;
7548 }
7549
7550
7551 /*****************************************************************************
7552  * This function checks the mode of the firmware.
7553  *
7554  * returns  - true when the mode is IAMT or false.
7555  ****************************************************************************/
7556 bool e1000_check_mng_mode(struct e1000_hw *hw)
7557 {
7558     u32 fwsm;
7559
7560     fwsm = er32(FWSM);
7561
7562     if (hw->mac_type == e1000_ich8lan) {
7563         if ((fwsm & E1000_FWSM_MODE_MASK) ==
7564             (E1000_MNG_ICH_IAMT_MODE << E1000_FWSM_MODE_SHIFT))
7565             return true;
7566     } else if ((fwsm & E1000_FWSM_MODE_MASK) ==
7567                (E1000_MNG_IAMT_MODE << E1000_FWSM_MODE_SHIFT))
7568         return true;
7569
7570     return false;
7571 }
7572
7573
7574 /*****************************************************************************
7575  * This function writes the dhcp info .
7576  ****************************************************************************/
7577 s32 e1000_mng_write_dhcp_info(struct e1000_hw *hw, u8 *buffer, u16 length)
7578 {
7579     s32 ret_val;
7580     struct e1000_host_mng_command_header hdr;
7581
7582     hdr.command_id = E1000_MNG_DHCP_TX_PAYLOAD_CMD;
7583     hdr.command_length = length;
7584     hdr.reserved1 = 0;
7585     hdr.reserved2 = 0;
7586     hdr.checksum = 0;
7587
7588     ret_val = e1000_mng_enable_host_if(hw);
7589     if (ret_val == E1000_SUCCESS) {
7590         ret_val = e1000_mng_host_if_write(hw, buffer, length, sizeof(hdr),
7591                                           &(hdr.checksum));
7592         if (ret_val == E1000_SUCCESS) {
7593             ret_val = e1000_mng_write_cmd_header(hw, &hdr);
7594             if (ret_val == E1000_SUCCESS)
7595                 ret_val = e1000_mng_write_commit(hw);
7596         }
7597     }
7598     return ret_val;
7599 }
7600
7601
7602 /*****************************************************************************
7603  * This function calculates the checksum.
7604  *
7605  * returns  - checksum of buffer contents.
7606  ****************************************************************************/
7607 static u8 e1000_calculate_mng_checksum(char *buffer, u32 length)
7608 {
7609     u8 sum = 0;
7610     u32 i;
7611
7612     if (!buffer)
7613         return 0;
7614
7615     for (i=0; i < length; i++)
7616         sum += buffer[i];
7617
7618     return (u8)(0 - sum);
7619 }
7620
7621 /*****************************************************************************
7622  * This function checks whether tx pkt filtering needs to be enabled or not.
7623  *
7624  * returns  - true for packet filtering or false.
7625  ****************************************************************************/
7626 bool e1000_enable_tx_pkt_filtering(struct e1000_hw *hw)
7627 {
7628     /* called in init as well as watchdog timer functions */
7629
7630     s32 ret_val, checksum;
7631     bool tx_filter = false;
7632     struct e1000_host_mng_dhcp_cookie *hdr = &(hw->mng_cookie);
7633     u8 *buffer = (u8 *) &(hw->mng_cookie);
7634
7635     if (e1000_check_mng_mode(hw)) {
7636         ret_val = e1000_mng_enable_host_if(hw);
7637         if (ret_val == E1000_SUCCESS) {
7638             ret_val = e1000_host_if_read_cookie(hw, buffer);
7639             if (ret_val == E1000_SUCCESS) {
7640                 checksum = hdr->checksum;
7641                 hdr->checksum = 0;
7642                 if ((hdr->signature == E1000_IAMT_SIGNATURE) &&
7643                     checksum == e1000_calculate_mng_checksum((char *)buffer,
7644                                                E1000_MNG_DHCP_COOKIE_LENGTH)) {
7645                     if (hdr->status &
7646                         E1000_MNG_DHCP_COOKIE_STATUS_PARSING_SUPPORT)
7647                         tx_filter = true;
7648                 } else
7649                     tx_filter = true;
7650             } else
7651                 tx_filter = true;
7652         }
7653     }
7654
7655     hw->tx_pkt_filtering = tx_filter;
7656     return tx_filter;
7657 }
7658
7659 /******************************************************************************
7660  * Verifies the hardware needs to allow ARPs to be processed by the host
7661  *
7662  * hw - Struct containing variables accessed by shared code
7663  *
7664  * returns: - true/false
7665  *
7666  *****************************************************************************/
7667 u32 e1000_enable_mng_pass_thru(struct e1000_hw *hw)
7668 {
7669     u32 manc;
7670     u32 fwsm, factps;
7671
7672     if (hw->asf_firmware_present) {
7673         manc = er32(MANC);
7674
7675         if (!(manc & E1000_MANC_RCV_TCO_EN) ||
7676             !(manc & E1000_MANC_EN_MAC_ADDR_FILTER))
7677             return false;
7678         if (e1000_arc_subsystem_valid(hw)) {
7679             fwsm = er32(FWSM);
7680             factps = er32(FACTPS);
7681
7682             if ((((fwsm & E1000_FWSM_MODE_MASK) >> E1000_FWSM_MODE_SHIFT) ==
7683                    e1000_mng_mode_pt) && !(factps & E1000_FACTPS_MNGCG))
7684                 return true;
7685         } else
7686             if ((manc & E1000_MANC_SMBUS_EN) && !(manc & E1000_MANC_ASF_EN))
7687                 return true;
7688     }
7689     return false;
7690 }
7691
7692 static s32 e1000_polarity_reversal_workaround(struct e1000_hw *hw)
7693 {
7694     s32 ret_val;
7695     u16 mii_status_reg;
7696     u16 i;
7697
7698     /* Polarity reversal workaround for forced 10F/10H links. */
7699
7700     /* Disable the transmitter on the PHY */
7701
7702     ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0019);
7703     if (ret_val)
7704         return ret_val;
7705     ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0xFFFF);
7706     if (ret_val)
7707         return ret_val;
7708
7709     ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0000);
7710     if (ret_val)
7711         return ret_val;
7712
7713     /* This loop will early-out if the NO link condition has been met. */
7714     for (i = PHY_FORCE_TIME; i > 0; i--) {
7715         /* Read the MII Status Register and wait for Link Status bit
7716          * to be clear.
7717          */
7718
7719         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
7720         if (ret_val)
7721             return ret_val;
7722
7723         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
7724         if (ret_val)
7725             return ret_val;
7726
7727         if ((mii_status_reg & ~MII_SR_LINK_STATUS) == 0) break;
7728         mdelay(100);
7729     }
7730
7731     /* Recommended delay time after link has been lost */
7732     mdelay(1000);
7733
7734     /* Now we will re-enable th transmitter on the PHY */
7735
7736     ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0019);
7737     if (ret_val)
7738         return ret_val;
7739     mdelay(50);
7740     ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0xFFF0);
7741     if (ret_val)
7742         return ret_val;
7743     mdelay(50);
7744     ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0xFF00);
7745     if (ret_val)
7746         return ret_val;
7747     mdelay(50);
7748     ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0x0000);
7749     if (ret_val)
7750         return ret_val;
7751
7752     ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0000);
7753     if (ret_val)
7754         return ret_val;
7755
7756     /* This loop will early-out if the link condition has been met. */
7757     for (i = PHY_FORCE_TIME; i > 0; i--) {
7758         /* Read the MII Status Register and wait for Link Status bit
7759          * to be set.
7760          */
7761
7762         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
7763         if (ret_val)
7764             return ret_val;
7765
7766         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
7767         if (ret_val)
7768             return ret_val;
7769
7770         if (mii_status_reg & MII_SR_LINK_STATUS) break;
7771         mdelay(100);
7772     }
7773     return E1000_SUCCESS;
7774 }
7775
7776 /***************************************************************************
7777  *
7778  * Disables PCI-Express master access.
7779  *
7780  * hw: Struct containing variables accessed by shared code
7781  *
7782  * returns: - none.
7783  *
7784  ***************************************************************************/
7785 static void e1000_set_pci_express_master_disable(struct e1000_hw *hw)
7786 {
7787     u32 ctrl;
7788
7789     DEBUGFUNC("e1000_set_pci_express_master_disable");
7790
7791     if (hw->bus_type != e1000_bus_type_pci_express)
7792         return;
7793
7794     ctrl = er32(CTRL);
7795     ctrl |= E1000_CTRL_GIO_MASTER_DISABLE;
7796     ew32(CTRL, ctrl);
7797 }
7798
7799 /*******************************************************************************
7800  *
7801  * Disables PCI-Express master access and verifies there are no pending requests
7802  *
7803  * hw: Struct containing variables accessed by shared code
7804  *
7805  * returns: - E1000_ERR_MASTER_REQUESTS_PENDING if master disable bit hasn't
7806  *            caused the master requests to be disabled.
7807  *            E1000_SUCCESS master requests disabled.
7808  *
7809  ******************************************************************************/
7810 s32 e1000_disable_pciex_master(struct e1000_hw *hw)
7811 {
7812     s32 timeout = MASTER_DISABLE_TIMEOUT;   /* 80ms */
7813
7814     DEBUGFUNC("e1000_disable_pciex_master");
7815
7816     if (hw->bus_type != e1000_bus_type_pci_express)
7817         return E1000_SUCCESS;
7818
7819     e1000_set_pci_express_master_disable(hw);
7820
7821     while (timeout) {
7822         if (!(er32(STATUS) & E1000_STATUS_GIO_MASTER_ENABLE))
7823             break;
7824         else
7825             udelay(100);
7826         timeout--;
7827     }
7828
7829     if (!timeout) {
7830         DEBUGOUT("Master requests are pending.\n");
7831         return -E1000_ERR_MASTER_REQUESTS_PENDING;
7832     }
7833
7834     return E1000_SUCCESS;
7835 }
7836
7837 /*******************************************************************************
7838  *
7839  * Check for EEPROM Auto Read bit done.
7840  *
7841  * hw: Struct containing variables accessed by shared code
7842  *
7843  * returns: - E1000_ERR_RESET if fail to reset MAC
7844  *            E1000_SUCCESS at any other case.
7845  *
7846  ******************************************************************************/
7847 static s32 e1000_get_auto_rd_done(struct e1000_hw *hw)
7848 {
7849     s32 timeout = AUTO_READ_DONE_TIMEOUT;
7850
7851     DEBUGFUNC("e1000_get_auto_rd_done");
7852
7853     switch (hw->mac_type) {
7854     default:
7855         msleep(5);
7856         break;
7857     case e1000_82571:
7858     case e1000_82572:
7859     case e1000_82573:
7860     case e1000_80003es2lan:
7861     case e1000_ich8lan:
7862         while (timeout) {
7863             if (er32(EECD) & E1000_EECD_AUTO_RD)
7864                 break;
7865             else msleep(1);
7866             timeout--;
7867         }
7868
7869         if (!timeout) {
7870             DEBUGOUT("Auto read by HW from EEPROM has not completed.\n");
7871             return -E1000_ERR_RESET;
7872         }
7873         break;
7874     }
7875
7876     /* PHY configuration from NVM just starts after EECD_AUTO_RD sets to high.
7877      * Need to wait for PHY configuration completion before accessing NVM
7878      * and PHY. */
7879     if (hw->mac_type == e1000_82573)
7880         msleep(25);
7881
7882     return E1000_SUCCESS;
7883 }
7884
7885 /***************************************************************************
7886  * Checks if the PHY configuration is done
7887  *
7888  * hw: Struct containing variables accessed by shared code
7889  *
7890  * returns: - E1000_ERR_RESET if fail to reset MAC
7891  *            E1000_SUCCESS at any other case.
7892  *
7893  ***************************************************************************/
7894 static s32 e1000_get_phy_cfg_done(struct e1000_hw *hw)
7895 {
7896     s32 timeout = PHY_CFG_TIMEOUT;
7897     u32 cfg_mask = E1000_EEPROM_CFG_DONE;
7898
7899     DEBUGFUNC("e1000_get_phy_cfg_done");
7900
7901     switch (hw->mac_type) {
7902     default:
7903         mdelay(10);
7904         break;
7905     case e1000_80003es2lan:
7906         /* Separate *_CFG_DONE_* bit for each port */
7907         if (er32(STATUS) & E1000_STATUS_FUNC_1)
7908             cfg_mask = E1000_EEPROM_CFG_DONE_PORT_1;
7909         /* Fall Through */
7910     case e1000_82571:
7911     case e1000_82572:
7912         while (timeout) {
7913             if (er32(EEMNGCTL) & cfg_mask)
7914                 break;
7915             else
7916                 msleep(1);
7917             timeout--;
7918         }
7919         if (!timeout) {
7920             DEBUGOUT("MNG configuration cycle has not completed.\n");
7921             return -E1000_ERR_RESET;
7922         }
7923         break;
7924     }
7925
7926     return E1000_SUCCESS;
7927 }
7928
7929 /***************************************************************************
7930  *
7931  * Using the combination of SMBI and SWESMBI semaphore bits when resetting
7932  * adapter or Eeprom access.
7933  *
7934  * hw: Struct containing variables accessed by shared code
7935  *
7936  * returns: - E1000_ERR_EEPROM if fail to access EEPROM.
7937  *            E1000_SUCCESS at any other case.
7938  *
7939  ***************************************************************************/
7940 static s32 e1000_get_hw_eeprom_semaphore(struct e1000_hw *hw)
7941 {
7942     s32 timeout;
7943     u32 swsm;
7944
7945     DEBUGFUNC("e1000_get_hw_eeprom_semaphore");
7946
7947     if (!hw->eeprom_semaphore_present)
7948         return E1000_SUCCESS;
7949
7950     if (hw->mac_type == e1000_80003es2lan) {
7951         /* Get the SW semaphore. */
7952         if (e1000_get_software_semaphore(hw) != E1000_SUCCESS)
7953             return -E1000_ERR_EEPROM;
7954     }
7955
7956     /* Get the FW semaphore. */
7957     timeout = hw->eeprom.word_size + 1;
7958     while (timeout) {
7959         swsm = er32(SWSM);
7960         swsm |= E1000_SWSM_SWESMBI;
7961         ew32(SWSM, swsm);
7962         /* if we managed to set the bit we got the semaphore. */
7963         swsm = er32(SWSM);
7964         if (swsm & E1000_SWSM_SWESMBI)
7965             break;
7966
7967         udelay(50);
7968         timeout--;
7969     }
7970
7971     if (!timeout) {
7972         /* Release semaphores */
7973         e1000_put_hw_eeprom_semaphore(hw);
7974         DEBUGOUT("Driver can't access the Eeprom - SWESMBI bit is set.\n");
7975         return -E1000_ERR_EEPROM;
7976     }
7977
7978     return E1000_SUCCESS;
7979 }
7980
7981 /***************************************************************************
7982  * This function clears HW semaphore bits.
7983  *
7984  * hw: Struct containing variables accessed by shared code
7985  *
7986  * returns: - None.
7987  *
7988  ***************************************************************************/
7989 static void e1000_put_hw_eeprom_semaphore(struct e1000_hw *hw)
7990 {
7991     u32 swsm;
7992
7993     DEBUGFUNC("e1000_put_hw_eeprom_semaphore");
7994
7995     if (!hw->eeprom_semaphore_present)
7996         return;
7997
7998     swsm = er32(SWSM);
7999     if (hw->mac_type == e1000_80003es2lan) {
8000         /* Release both semaphores. */
8001         swsm &= ~(E1000_SWSM_SMBI | E1000_SWSM_SWESMBI);
8002     } else
8003         swsm &= ~(E1000_SWSM_SWESMBI);
8004     ew32(SWSM, swsm);
8005 }
8006
8007 /***************************************************************************
8008  *
8009  * Obtaining software semaphore bit (SMBI) before resetting PHY.
8010  *
8011  * hw: Struct containing variables accessed by shared code
8012  *
8013  * returns: - E1000_ERR_RESET if fail to obtain semaphore.
8014  *            E1000_SUCCESS at any other case.
8015  *
8016  ***************************************************************************/
8017 static s32 e1000_get_software_semaphore(struct e1000_hw *hw)
8018 {
8019     s32 timeout = hw->eeprom.word_size + 1;
8020     u32 swsm;
8021
8022     DEBUGFUNC("e1000_get_software_semaphore");
8023
8024     if (hw->mac_type != e1000_80003es2lan) {
8025         return E1000_SUCCESS;
8026     }
8027
8028     while (timeout) {
8029         swsm = er32(SWSM);
8030         /* If SMBI bit cleared, it is now set and we hold the semaphore */
8031         if (!(swsm & E1000_SWSM_SMBI))
8032             break;
8033         mdelay(1);
8034         timeout--;
8035     }
8036
8037     if (!timeout) {
8038         DEBUGOUT("Driver can't access device - SMBI bit is set.\n");
8039         return -E1000_ERR_RESET;
8040     }
8041
8042     return E1000_SUCCESS;
8043 }
8044
8045 /***************************************************************************
8046  *
8047  * Release semaphore bit (SMBI).
8048  *
8049  * hw: Struct containing variables accessed by shared code
8050  *
8051  ***************************************************************************/
8052 static void e1000_release_software_semaphore(struct e1000_hw *hw)
8053 {
8054     u32 swsm;
8055
8056     DEBUGFUNC("e1000_release_software_semaphore");
8057
8058     if (hw->mac_type != e1000_80003es2lan) {
8059         return;
8060     }
8061
8062     swsm = er32(SWSM);
8063     /* Release the SW semaphores.*/
8064     swsm &= ~E1000_SWSM_SMBI;
8065     ew32(SWSM, swsm);
8066 }
8067
8068 /******************************************************************************
8069  * Checks if PHY reset is blocked due to SOL/IDER session, for example.
8070  * Returning E1000_BLK_PHY_RESET isn't necessarily an error.  But it's up to
8071  * the caller to figure out how to deal with it.
8072  *
8073  * hw - Struct containing variables accessed by shared code
8074  *
8075  * returns: - E1000_BLK_PHY_RESET
8076  *            E1000_SUCCESS
8077  *
8078  *****************************************************************************/
8079 s32 e1000_check_phy_reset_block(struct e1000_hw *hw)
8080 {
8081     u32 manc = 0;
8082     u32 fwsm = 0;
8083
8084     if (hw->mac_type == e1000_ich8lan) {
8085         fwsm = er32(FWSM);
8086         return (fwsm & E1000_FWSM_RSPCIPHY) ? E1000_SUCCESS
8087                                             : E1000_BLK_PHY_RESET;
8088     }
8089
8090     if (hw->mac_type > e1000_82547_rev_2)
8091         manc = er32(MANC);
8092     return (manc & E1000_MANC_BLK_PHY_RST_ON_IDE) ?
8093         E1000_BLK_PHY_RESET : E1000_SUCCESS;
8094 }
8095
8096 static u8 e1000_arc_subsystem_valid(struct e1000_hw *hw)
8097 {
8098     u32 fwsm;
8099
8100     /* On 8257x silicon, registers in the range of 0x8800 - 0x8FFC
8101      * may not be provided a DMA clock when no manageability features are
8102      * enabled.  We do not want to perform any reads/writes to these registers
8103      * if this is the case.  We read FWSM to determine the manageability mode.
8104      */
8105     switch (hw->mac_type) {
8106     case e1000_82571:
8107     case e1000_82572:
8108     case e1000_82573:
8109     case e1000_80003es2lan:
8110         fwsm = er32(FWSM);
8111         if ((fwsm & E1000_FWSM_MODE_MASK) != 0)
8112             return true;
8113         break;
8114     case e1000_ich8lan:
8115         return true;
8116     default:
8117         break;
8118     }
8119     return false;
8120 }
8121
8122
8123 /******************************************************************************
8124  * Configure PCI-Ex no-snoop
8125  *
8126  * hw - Struct containing variables accessed by shared code.
8127  * no_snoop - Bitmap of no-snoop events.
8128  *
8129  * returns: E1000_SUCCESS
8130  *
8131  *****************************************************************************/
8132 static s32 e1000_set_pci_ex_no_snoop(struct e1000_hw *hw, u32 no_snoop)
8133 {
8134     u32 gcr_reg = 0;
8135
8136     DEBUGFUNC("e1000_set_pci_ex_no_snoop");
8137
8138     if (hw->bus_type == e1000_bus_type_unknown)
8139         e1000_get_bus_info(hw);
8140
8141     if (hw->bus_type != e1000_bus_type_pci_express)
8142         return E1000_SUCCESS;
8143
8144     if (no_snoop) {
8145         gcr_reg = er32(GCR);
8146         gcr_reg &= ~(PCI_EX_NO_SNOOP_ALL);
8147         gcr_reg |= no_snoop;
8148         ew32(GCR, gcr_reg);
8149     }
8150     if (hw->mac_type == e1000_ich8lan) {
8151         u32 ctrl_ext;
8152
8153         ew32(GCR, PCI_EX_82566_SNOOP_ALL);
8154
8155         ctrl_ext = er32(CTRL_EXT);
8156         ctrl_ext |= E1000_CTRL_EXT_RO_DIS;
8157         ew32(CTRL_EXT, ctrl_ext);
8158     }
8159
8160     return E1000_SUCCESS;
8161 }
8162
8163 /***************************************************************************
8164  *
8165  * Get software semaphore FLAG bit (SWFLAG).
8166  * SWFLAG is used to synchronize the access to all shared resource between
8167  * SW, FW and HW.
8168  *
8169  * hw: Struct containing variables accessed by shared code
8170  *
8171  ***************************************************************************/
8172 static s32 e1000_get_software_flag(struct e1000_hw *hw)
8173 {
8174     s32 timeout = PHY_CFG_TIMEOUT;
8175     u32 extcnf_ctrl;
8176
8177     DEBUGFUNC("e1000_get_software_flag");
8178
8179     if (hw->mac_type == e1000_ich8lan) {
8180         while (timeout) {
8181             extcnf_ctrl = er32(EXTCNF_CTRL);
8182             extcnf_ctrl |= E1000_EXTCNF_CTRL_SWFLAG;
8183             ew32(EXTCNF_CTRL, extcnf_ctrl);
8184
8185             extcnf_ctrl = er32(EXTCNF_CTRL);
8186             if (extcnf_ctrl & E1000_EXTCNF_CTRL_SWFLAG)
8187                 break;
8188             mdelay(1);
8189             timeout--;
8190         }
8191
8192         if (!timeout) {
8193             DEBUGOUT("FW or HW locks the resource too long.\n");
8194             return -E1000_ERR_CONFIG;
8195         }
8196     }
8197
8198     return E1000_SUCCESS;
8199 }
8200
8201 /***************************************************************************
8202  *
8203  * Release software semaphore FLAG bit (SWFLAG).
8204  * SWFLAG is used to synchronize the access to all shared resource between
8205  * SW, FW and HW.
8206  *
8207  * hw: Struct containing variables accessed by shared code
8208  *
8209  ***************************************************************************/
8210 static void e1000_release_software_flag(struct e1000_hw *hw)
8211 {
8212     u32 extcnf_ctrl;
8213
8214     DEBUGFUNC("e1000_release_software_flag");
8215
8216     if (hw->mac_type == e1000_ich8lan) {
8217         extcnf_ctrl= er32(EXTCNF_CTRL);
8218         extcnf_ctrl &= ~E1000_EXTCNF_CTRL_SWFLAG;
8219         ew32(EXTCNF_CTRL, extcnf_ctrl);
8220     }
8221
8222     return;
8223 }
8224
8225 /******************************************************************************
8226  * Reads a 16 bit word or words from the EEPROM using the ICH8's flash access
8227  * register.
8228  *
8229  * hw - Struct containing variables accessed by shared code
8230  * offset - offset of word in the EEPROM to read
8231  * data - word read from the EEPROM
8232  * words - number of words to read
8233  *****************************************************************************/
8234 static s32 e1000_read_eeprom_ich8(struct e1000_hw *hw, u16 offset, u16 words,
8235                                   u16 *data)
8236 {
8237     s32  error = E1000_SUCCESS;
8238     u32 flash_bank = 0;
8239     u32 act_offset = 0;
8240     u32 bank_offset = 0;
8241     u16 word = 0;
8242     u16 i = 0;
8243
8244     /* We need to know which is the valid flash bank.  In the event
8245      * that we didn't allocate eeprom_shadow_ram, we may not be
8246      * managing flash_bank.  So it cannot be trusted and needs
8247      * to be updated with each read.
8248      */
8249     /* Value of bit 22 corresponds to the flash bank we're on. */
8250     flash_bank = (er32(EECD) & E1000_EECD_SEC1VAL) ? 1 : 0;
8251
8252     /* Adjust offset appropriately if we're on bank 1 - adjust for word size */
8253     bank_offset = flash_bank * (hw->flash_bank_size * 2);
8254
8255     error = e1000_get_software_flag(hw);
8256     if (error != E1000_SUCCESS)
8257         return error;
8258
8259     for (i = 0; i < words; i++) {
8260         if (hw->eeprom_shadow_ram != NULL &&
8261             hw->eeprom_shadow_ram[offset+i].modified) {
8262             data[i] = hw->eeprom_shadow_ram[offset+i].eeprom_word;
8263         } else {
8264             /* The NVM part needs a byte offset, hence * 2 */
8265             act_offset = bank_offset + ((offset + i) * 2);
8266             error = e1000_read_ich8_word(hw, act_offset, &word);
8267             if (error != E1000_SUCCESS)
8268                 break;
8269             data[i] = word;
8270         }
8271     }
8272
8273     e1000_release_software_flag(hw);
8274
8275     return error;
8276 }
8277
8278 /******************************************************************************
8279  * Writes a 16 bit word or words to the EEPROM using the ICH8's flash access
8280  * register.  Actually, writes are written to the shadow ram cache in the hw
8281  * structure hw->e1000_shadow_ram.  e1000_commit_shadow_ram flushes this to
8282  * the NVM, which occurs when the NVM checksum is updated.
8283  *
8284  * hw - Struct containing variables accessed by shared code
8285  * offset - offset of word in the EEPROM to write
8286  * words - number of words to write
8287  * data - words to write to the EEPROM
8288  *****************************************************************************/
8289 static s32 e1000_write_eeprom_ich8(struct e1000_hw *hw, u16 offset, u16 words,
8290                                    u16 *data)
8291 {
8292     u32 i = 0;
8293     s32 error = E1000_SUCCESS;
8294
8295     error = e1000_get_software_flag(hw);
8296     if (error != E1000_SUCCESS)
8297         return error;
8298
8299     /* A driver can write to the NVM only if it has eeprom_shadow_ram
8300      * allocated.  Subsequent reads to the modified words are read from
8301      * this cached structure as well.  Writes will only go into this
8302      * cached structure unless it's followed by a call to
8303      * e1000_update_eeprom_checksum() where it will commit the changes
8304      * and clear the "modified" field.
8305      */
8306     if (hw->eeprom_shadow_ram != NULL) {
8307         for (i = 0; i < words; i++) {
8308             if ((offset + i) < E1000_SHADOW_RAM_WORDS) {
8309                 hw->eeprom_shadow_ram[offset+i].modified = true;
8310                 hw->eeprom_shadow_ram[offset+i].eeprom_word = data[i];
8311             } else {
8312                 error = -E1000_ERR_EEPROM;
8313                 break;
8314             }
8315         }
8316     } else {
8317         /* Drivers have the option to not allocate eeprom_shadow_ram as long
8318          * as they don't perform any NVM writes.  An attempt in doing so
8319          * will result in this error.
8320          */
8321         error = -E1000_ERR_EEPROM;
8322     }
8323
8324     e1000_release_software_flag(hw);
8325
8326     return error;
8327 }
8328
8329 /******************************************************************************
8330  * This function does initial flash setup so that a new read/write/erase cycle
8331  * can be started.
8332  *
8333  * hw - The pointer to the hw structure
8334  ****************************************************************************/
8335 static s32 e1000_ich8_cycle_init(struct e1000_hw *hw)
8336 {
8337     union ich8_hws_flash_status hsfsts;
8338     s32 error = E1000_ERR_EEPROM;
8339     s32 i     = 0;
8340
8341     DEBUGFUNC("e1000_ich8_cycle_init");
8342
8343     hsfsts.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS);
8344
8345     /* May be check the Flash Des Valid bit in Hw status */
8346     if (hsfsts.hsf_status.fldesvalid == 0) {
8347         DEBUGOUT("Flash descriptor invalid.  SW Sequencing must be used.");
8348         return error;
8349     }
8350
8351     /* Clear FCERR in Hw status by writing 1 */
8352     /* Clear DAEL in Hw status by writing a 1 */
8353     hsfsts.hsf_status.flcerr = 1;
8354     hsfsts.hsf_status.dael = 1;
8355
8356     E1000_WRITE_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS, hsfsts.regval);
8357
8358     /* Either we should have a hardware SPI cycle in progress bit to check
8359      * against, in order to start a new cycle or FDONE bit should be changed
8360      * in the hardware so that it is 1 after harware reset, which can then be
8361      * used as an indication whether a cycle is in progress or has been
8362      * completed .. we should also have some software semaphore mechanism to
8363      * guard FDONE or the cycle in progress bit so that two threads access to
8364      * those bits can be sequentiallized or a way so that 2 threads dont
8365      * start the cycle at the same time */
8366
8367     if (hsfsts.hsf_status.flcinprog == 0) {
8368         /* There is no cycle running at present, so we can start a cycle */
8369         /* Begin by setting Flash Cycle Done. */
8370         hsfsts.hsf_status.flcdone = 1;
8371         E1000_WRITE_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS, hsfsts.regval);
8372         error = E1000_SUCCESS;
8373     } else {
8374         /* otherwise poll for sometime so the current cycle has a chance
8375          * to end before giving up. */
8376         for (i = 0; i < ICH_FLASH_COMMAND_TIMEOUT; i++) {
8377             hsfsts.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS);
8378             if (hsfsts.hsf_status.flcinprog == 0) {
8379                 error = E1000_SUCCESS;
8380                 break;
8381             }
8382             udelay(1);
8383         }
8384         if (error == E1000_SUCCESS) {
8385             /* Successful in waiting for previous cycle to timeout,
8386              * now set the Flash Cycle Done. */
8387             hsfsts.hsf_status.flcdone = 1;
8388             E1000_WRITE_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS, hsfsts.regval);
8389         } else {
8390             DEBUGOUT("Flash controller busy, cannot get access");
8391         }
8392     }
8393     return error;
8394 }
8395
8396 /******************************************************************************
8397  * This function starts a flash cycle and waits for its completion
8398  *
8399  * hw - The pointer to the hw structure
8400  ****************************************************************************/
8401 static s32 e1000_ich8_flash_cycle(struct e1000_hw *hw, u32 timeout)
8402 {
8403     union ich8_hws_flash_ctrl hsflctl;
8404     union ich8_hws_flash_status hsfsts;
8405     s32 error = E1000_ERR_EEPROM;
8406     u32 i = 0;
8407
8408     /* Start a cycle by writing 1 in Flash Cycle Go in Hw Flash Control */
8409     hsflctl.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFCTL);
8410     hsflctl.hsf_ctrl.flcgo = 1;
8411     E1000_WRITE_ICH_FLASH_REG16(hw, ICH_FLASH_HSFCTL, hsflctl.regval);
8412
8413     /* wait till FDONE bit is set to 1 */
8414     do {
8415         hsfsts.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS);
8416         if (hsfsts.hsf_status.flcdone == 1)
8417             break;
8418         udelay(1);
8419         i++;
8420     } while (i < timeout);
8421     if (hsfsts.hsf_status.flcdone == 1 && hsfsts.hsf_status.flcerr == 0) {
8422         error = E1000_SUCCESS;
8423     }
8424     return error;
8425 }
8426
8427 /******************************************************************************
8428  * Reads a byte or word from the NVM using the ICH8 flash access registers.
8429  *
8430  * hw - The pointer to the hw structure
8431  * index - The index of the byte or word to read.
8432  * size - Size of data to read, 1=byte 2=word
8433  * data - Pointer to the word to store the value read.
8434  *****************************************************************************/
8435 static s32 e1000_read_ich8_data(struct e1000_hw *hw, u32 index, u32 size,
8436                                 u16 *data)
8437 {
8438     union ich8_hws_flash_status hsfsts;
8439     union ich8_hws_flash_ctrl hsflctl;
8440     u32 flash_linear_address;
8441     u32 flash_data = 0;
8442     s32 error = -E1000_ERR_EEPROM;
8443     s32 count = 0;
8444
8445     DEBUGFUNC("e1000_read_ich8_data");
8446
8447     if (size < 1  || size > 2 || data == NULL ||
8448         index > ICH_FLASH_LINEAR_ADDR_MASK)
8449         return error;
8450
8451     flash_linear_address = (ICH_FLASH_LINEAR_ADDR_MASK & index) +
8452                            hw->flash_base_addr;
8453
8454     do {
8455         udelay(1);
8456         /* Steps */
8457         error = e1000_ich8_cycle_init(hw);
8458         if (error != E1000_SUCCESS)
8459             break;
8460
8461         hsflctl.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFCTL);
8462         /* 0b/1b corresponds to 1 or 2 byte size, respectively. */
8463         hsflctl.hsf_ctrl.fldbcount = size - 1;
8464         hsflctl.hsf_ctrl.flcycle = ICH_CYCLE_READ;
8465         E1000_WRITE_ICH_FLASH_REG16(hw, ICH_FLASH_HSFCTL, hsflctl.regval);
8466
8467         /* Write the last 24 bits of index into Flash Linear address field in
8468          * Flash Address */
8469         /* TODO: TBD maybe check the index against the size of flash */
8470
8471         E1000_WRITE_ICH_FLASH_REG(hw, ICH_FLASH_FADDR, flash_linear_address);
8472
8473         error = e1000_ich8_flash_cycle(hw, ICH_FLASH_COMMAND_TIMEOUT);
8474
8475         /* Check if FCERR is set to 1, if set to 1, clear it and try the whole
8476          * sequence a few more times, else read in (shift in) the Flash Data0,
8477          * the order is least significant byte first msb to lsb */
8478         if (error == E1000_SUCCESS) {
8479             flash_data = E1000_READ_ICH_FLASH_REG(hw, ICH_FLASH_FDATA0);
8480             if (size == 1) {
8481                 *data = (u8)(flash_data & 0x000000FF);
8482             } else if (size == 2) {
8483                 *data = (u16)(flash_data & 0x0000FFFF);
8484             }
8485             break;
8486         } else {
8487             /* If we've gotten here, then things are probably completely hosed,
8488              * but if the error condition is detected, it won't hurt to give
8489              * it another try...ICH_FLASH_CYCLE_REPEAT_COUNT times.
8490              */
8491             hsfsts.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS);
8492             if (hsfsts.hsf_status.flcerr == 1) {
8493                 /* Repeat for some time before giving up. */
8494                 continue;
8495             } else if (hsfsts.hsf_status.flcdone == 0) {
8496                 DEBUGOUT("Timeout error - flash cycle did not complete.");
8497                 break;
8498             }
8499         }
8500     } while (count++ < ICH_FLASH_CYCLE_REPEAT_COUNT);
8501
8502     return error;
8503 }
8504
8505 /******************************************************************************
8506  * Writes One /two bytes to the NVM using the ICH8 flash access registers.
8507  *
8508  * hw - The pointer to the hw structure
8509  * index - The index of the byte/word to read.
8510  * size - Size of data to read, 1=byte 2=word
8511  * data - The byte(s) to write to the NVM.
8512  *****************************************************************************/
8513 static s32 e1000_write_ich8_data(struct e1000_hw *hw, u32 index, u32 size,
8514                                  u16 data)
8515 {
8516     union ich8_hws_flash_status hsfsts;
8517     union ich8_hws_flash_ctrl hsflctl;
8518     u32 flash_linear_address;
8519     u32 flash_data = 0;
8520     s32 error = -E1000_ERR_EEPROM;
8521     s32 count = 0;
8522
8523     DEBUGFUNC("e1000_write_ich8_data");
8524
8525     if (size < 1  || size > 2 || data > size * 0xff ||
8526         index > ICH_FLASH_LINEAR_ADDR_MASK)
8527         return error;
8528
8529     flash_linear_address = (ICH_FLASH_LINEAR_ADDR_MASK & index) +
8530                            hw->flash_base_addr;
8531
8532     do {
8533         udelay(1);
8534         /* Steps */
8535         error = e1000_ich8_cycle_init(hw);
8536         if (error != E1000_SUCCESS)
8537             break;
8538
8539         hsflctl.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFCTL);
8540         /* 0b/1b corresponds to 1 or 2 byte size, respectively. */
8541         hsflctl.hsf_ctrl.fldbcount = size -1;
8542         hsflctl.hsf_ctrl.flcycle = ICH_CYCLE_WRITE;
8543         E1000_WRITE_ICH_FLASH_REG16(hw, ICH_FLASH_HSFCTL, hsflctl.regval);
8544
8545         /* Write the last 24 bits of index into Flash Linear address field in
8546          * Flash Address */
8547         E1000_WRITE_ICH_FLASH_REG(hw, ICH_FLASH_FADDR, flash_linear_address);
8548
8549         if (size == 1)
8550             flash_data = (u32)data & 0x00FF;
8551         else
8552             flash_data = (u32)data;
8553
8554         E1000_WRITE_ICH_FLASH_REG(hw, ICH_FLASH_FDATA0, flash_data);
8555
8556         /* check if FCERR is set to 1 , if set to 1, clear it and try the whole
8557          * sequence a few more times else done */
8558         error = e1000_ich8_flash_cycle(hw, ICH_FLASH_COMMAND_TIMEOUT);
8559         if (error == E1000_SUCCESS) {
8560             break;
8561         } else {
8562             /* If we're here, then things are most likely completely hosed,
8563              * but if the error condition is detected, it won't hurt to give
8564              * it another try...ICH_FLASH_CYCLE_REPEAT_COUNT times.
8565              */
8566             hsfsts.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS);
8567             if (hsfsts.hsf_status.flcerr == 1) {
8568                 /* Repeat for some time before giving up. */
8569                 continue;
8570             } else if (hsfsts.hsf_status.flcdone == 0) {
8571                 DEBUGOUT("Timeout error - flash cycle did not complete.");
8572                 break;
8573             }
8574         }
8575     } while (count++ < ICH_FLASH_CYCLE_REPEAT_COUNT);
8576
8577     return error;
8578 }
8579
8580 /******************************************************************************
8581  * Reads a single byte from the NVM using the ICH8 flash access registers.
8582  *
8583  * hw - pointer to e1000_hw structure
8584  * index - The index of the byte to read.
8585  * data - Pointer to a byte to store the value read.
8586  *****************************************************************************/
8587 static s32 e1000_read_ich8_byte(struct e1000_hw *hw, u32 index, u8 *data)
8588 {
8589     s32 status = E1000_SUCCESS;
8590     u16 word = 0;
8591
8592     status = e1000_read_ich8_data(hw, index, 1, &word);
8593     if (status == E1000_SUCCESS) {
8594         *data = (u8)word;
8595     }
8596
8597     return status;
8598 }
8599
8600 /******************************************************************************
8601  * Writes a single byte to the NVM using the ICH8 flash access registers.
8602  * Performs verification by reading back the value and then going through
8603  * a retry algorithm before giving up.
8604  *
8605  * hw - pointer to e1000_hw structure
8606  * index - The index of the byte to write.
8607  * byte - The byte to write to the NVM.
8608  *****************************************************************************/
8609 static s32 e1000_verify_write_ich8_byte(struct e1000_hw *hw, u32 index, u8 byte)
8610 {
8611     s32 error = E1000_SUCCESS;
8612     s32 program_retries = 0;
8613
8614     DEBUGOUT2("Byte := %2.2X Offset := %d\n", byte, index);
8615
8616     error = e1000_write_ich8_byte(hw, index, byte);
8617
8618     if (error != E1000_SUCCESS) {
8619         for (program_retries = 0; program_retries < 100; program_retries++) {
8620             DEBUGOUT2("Retrying \t Byte := %2.2X Offset := %d\n", byte, index);
8621             error = e1000_write_ich8_byte(hw, index, byte);
8622             udelay(100);
8623             if (error == E1000_SUCCESS)
8624                 break;
8625         }
8626     }
8627
8628     if (program_retries == 100)
8629         error = E1000_ERR_EEPROM;
8630
8631     return error;
8632 }
8633
8634 /******************************************************************************
8635  * Writes a single byte to the NVM using the ICH8 flash access registers.
8636  *
8637  * hw - pointer to e1000_hw structure
8638  * index - The index of the byte to read.
8639  * data - The byte to write to the NVM.
8640  *****************************************************************************/
8641 static s32 e1000_write_ich8_byte(struct e1000_hw *hw, u32 index, u8 data)
8642 {
8643     s32 status = E1000_SUCCESS;
8644     u16 word = (u16)data;
8645
8646     status = e1000_write_ich8_data(hw, index, 1, word);
8647
8648     return status;
8649 }
8650
8651 /******************************************************************************
8652  * Reads a word from the NVM using the ICH8 flash access registers.
8653  *
8654  * hw - pointer to e1000_hw structure
8655  * index - The starting byte index of the word to read.
8656  * data - Pointer to a word to store the value read.
8657  *****************************************************************************/
8658 static s32 e1000_read_ich8_word(struct e1000_hw *hw, u32 index, u16 *data)
8659 {
8660     s32 status = E1000_SUCCESS;
8661     status = e1000_read_ich8_data(hw, index, 2, data);
8662     return status;
8663 }
8664
8665 /******************************************************************************
8666  * Erases the bank specified. Each bank may be a 4, 8 or 64k block. Banks are 0
8667  * based.
8668  *
8669  * hw - pointer to e1000_hw structure
8670  * bank - 0 for first bank, 1 for second bank
8671  *
8672  * Note that this function may actually erase as much as 8 or 64 KBytes.  The
8673  * amount of NVM used in each bank is a *minimum* of 4 KBytes, but in fact the
8674  * bank size may be 4, 8 or 64 KBytes
8675  *****************************************************************************/
8676 static s32 e1000_erase_ich8_4k_segment(struct e1000_hw *hw, u32 bank)
8677 {
8678     union ich8_hws_flash_status hsfsts;
8679     union ich8_hws_flash_ctrl hsflctl;
8680     u32 flash_linear_address;
8681     s32  count = 0;
8682     s32  error = E1000_ERR_EEPROM;
8683     s32  iteration;
8684     s32  sub_sector_size = 0;
8685     s32  bank_size;
8686     s32  j = 0;
8687     s32  error_flag = 0;
8688
8689     hsfsts.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS);
8690
8691     /* Determine HW Sector size: Read BERASE bits of Hw flash Status register */
8692     /* 00: The Hw sector is 256 bytes, hence we need to erase 16
8693      *     consecutive sectors.  The start index for the nth Hw sector can be
8694      *     calculated as bank * 4096 + n * 256
8695      * 01: The Hw sector is 4K bytes, hence we need to erase 1 sector.
8696      *     The start index for the nth Hw sector can be calculated
8697      *     as bank * 4096
8698      * 10: The HW sector is 8K bytes
8699      * 11: The Hw sector size is 64K bytes */
8700     if (hsfsts.hsf_status.berasesz == 0x0) {
8701         /* Hw sector size 256 */
8702         sub_sector_size = ICH_FLASH_SEG_SIZE_256;
8703         bank_size = ICH_FLASH_SECTOR_SIZE;
8704         iteration = ICH_FLASH_SECTOR_SIZE / ICH_FLASH_SEG_SIZE_256;
8705     } else if (hsfsts.hsf_status.berasesz == 0x1) {
8706         bank_size = ICH_FLASH_SEG_SIZE_4K;
8707         iteration = 1;
8708     } else if (hsfsts.hsf_status.berasesz == 0x3) {
8709         bank_size = ICH_FLASH_SEG_SIZE_64K;
8710         iteration = 1;
8711     } else {
8712         return error;
8713     }
8714
8715     for (j = 0; j < iteration ; j++) {
8716         do {
8717             count++;
8718             /* Steps */
8719             error = e1000_ich8_cycle_init(hw);
8720             if (error != E1000_SUCCESS) {
8721                 error_flag = 1;
8722                 break;
8723             }
8724
8725             /* Write a value 11 (block Erase) in Flash Cycle field in Hw flash
8726              * Control */
8727             hsflctl.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFCTL);
8728             hsflctl.hsf_ctrl.flcycle = ICH_CYCLE_ERASE;
8729             E1000_WRITE_ICH_FLASH_REG16(hw, ICH_FLASH_HSFCTL, hsflctl.regval);
8730
8731             /* Write the last 24 bits of an index within the block into Flash
8732              * Linear address field in Flash Address.  This probably needs to
8733              * be calculated here based off the on-chip erase sector size and
8734              * the software bank size (4, 8 or 64 KBytes) */
8735             flash_linear_address = bank * bank_size + j * sub_sector_size;
8736             flash_linear_address += hw->flash_base_addr;
8737             flash_linear_address &= ICH_FLASH_LINEAR_ADDR_MASK;
8738
8739             E1000_WRITE_ICH_FLASH_REG(hw, ICH_FLASH_FADDR, flash_linear_address);
8740
8741             error = e1000_ich8_flash_cycle(hw, ICH_FLASH_ERASE_TIMEOUT);
8742             /* Check if FCERR is set to 1.  If 1, clear it and try the whole
8743              * sequence a few more times else Done */
8744             if (error == E1000_SUCCESS) {
8745                 break;
8746             } else {
8747                 hsfsts.regval = E1000_READ_ICH_FLASH_REG16(hw, ICH_FLASH_HSFSTS);
8748                 if (hsfsts.hsf_status.flcerr == 1) {
8749                     /* repeat for some time before giving up */
8750                     continue;
8751                 } else if (hsfsts.hsf_status.flcdone == 0) {
8752                     error_flag = 1;
8753                     break;
8754                 }
8755             }
8756         } while ((count < ICH_FLASH_CYCLE_REPEAT_COUNT) && !error_flag);
8757         if (error_flag == 1)
8758             break;
8759     }
8760     if (error_flag != 1)
8761         error = E1000_SUCCESS;
8762     return error;
8763 }
8764
8765 static s32 e1000_init_lcd_from_nvm_config_region(struct e1000_hw *hw,
8766                                                  u32 cnf_base_addr,
8767                                                  u32 cnf_size)
8768 {
8769     u32 ret_val = E1000_SUCCESS;
8770     u16 word_addr, reg_data, reg_addr;
8771     u16 i;
8772
8773     /* cnf_base_addr is in DWORD */
8774     word_addr = (u16)(cnf_base_addr << 1);
8775
8776     /* cnf_size is returned in size of dwords */
8777     for (i = 0; i < cnf_size; i++) {
8778         ret_val = e1000_read_eeprom(hw, (word_addr + i*2), 1, &reg_data);
8779         if (ret_val)
8780             return ret_val;
8781
8782         ret_val = e1000_read_eeprom(hw, (word_addr + i*2 + 1), 1, &reg_addr);
8783         if (ret_val)
8784             return ret_val;
8785
8786         ret_val = e1000_get_software_flag(hw);
8787         if (ret_val != E1000_SUCCESS)
8788             return ret_val;
8789
8790         ret_val = e1000_write_phy_reg_ex(hw, (u32)reg_addr, reg_data);
8791
8792         e1000_release_software_flag(hw);
8793     }
8794
8795     return ret_val;
8796 }
8797
8798
8799 /******************************************************************************
8800  * This function initializes the PHY from the NVM on ICH8 platforms. This
8801  * is needed due to an issue where the NVM configuration is not properly
8802  * autoloaded after power transitions. Therefore, after each PHY reset, we
8803  * will load the configuration data out of the NVM manually.
8804  *
8805  * hw: Struct containing variables accessed by shared code
8806  *****************************************************************************/
8807 static s32 e1000_init_lcd_from_nvm(struct e1000_hw *hw)
8808 {
8809     u32 reg_data, cnf_base_addr, cnf_size, ret_val, loop;
8810
8811     if (hw->phy_type != e1000_phy_igp_3)
8812           return E1000_SUCCESS;
8813
8814     /* Check if SW needs configure the PHY */
8815     reg_data = er32(FEXTNVM);
8816     if (!(reg_data & FEXTNVM_SW_CONFIG))
8817         return E1000_SUCCESS;
8818
8819     /* Wait for basic configuration completes before proceeding*/
8820     loop = 0;
8821     do {
8822         reg_data = er32(STATUS) & E1000_STATUS_LAN_INIT_DONE;
8823         udelay(100);
8824         loop++;
8825     } while ((!reg_data) && (loop < 50));
8826
8827     /* Clear the Init Done bit for the next init event */
8828     reg_data = er32(STATUS);
8829     reg_data &= ~E1000_STATUS_LAN_INIT_DONE;
8830     ew32(STATUS, reg_data);
8831
8832     /* Make sure HW does not configure LCD from PHY extended configuration
8833        before SW configuration */
8834     reg_data = er32(EXTCNF_CTRL);
8835     if ((reg_data & E1000_EXTCNF_CTRL_LCD_WRITE_ENABLE) == 0x0000) {
8836         reg_data = er32(EXTCNF_SIZE);
8837         cnf_size = reg_data & E1000_EXTCNF_SIZE_EXT_PCIE_LENGTH;
8838         cnf_size >>= 16;
8839         if (cnf_size) {
8840             reg_data = er32(EXTCNF_CTRL);
8841             cnf_base_addr = reg_data & E1000_EXTCNF_CTRL_EXT_CNF_POINTER;
8842             /* cnf_base_addr is in DWORD */
8843             cnf_base_addr >>= 16;
8844
8845             /* Configure LCD from extended configuration region. */
8846             ret_val = e1000_init_lcd_from_nvm_config_region(hw, cnf_base_addr,
8847                                                             cnf_size);
8848             if (ret_val)
8849                 return ret_val;
8850         }
8851     }
8852
8853     return E1000_SUCCESS;
8854 }
8855