drivers/net/ethernet/intel/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 #include "e1000.h"
  34
  35 static s32 e1000_check_downshift(struct e1000_hw *hw);
  36 static s32 e1000_check_polarity(struct e1000_hw *hw,
  37                                 e1000_rev_polarity *polarity);
  38 static void e1000_clear_hw_cntrs(struct e1000_hw *hw);
  39 static void e1000_clear_vfta(struct e1000_hw *hw);
  40 static s32 e1000_config_dsp_after_link_change(struct e1000_hw *hw,
  41                                               bool link_up);
  42 static s32 e1000_config_fc_after_link_up(struct e1000_hw *hw);
  43 static s32 e1000_detect_gig_phy(struct e1000_hw *hw);
  44 static s32 e1000_get_auto_rd_done(struct e1000_hw *hw);
  45 static s32 e1000_get_cable_length(struct e1000_hw *hw, u16 *min_length,
  46                                   u16 *max_length);
  47 static s32 e1000_get_phy_cfg_done(struct e1000_hw *hw);
  48 static s32 e1000_id_led_init(struct e1000_hw *hw);
  49 static void e1000_init_rx_addrs(struct e1000_hw *hw);
  50 static s32 e1000_phy_igp_get_info(struct e1000_hw *hw,
  51                                   struct e1000_phy_info *phy_info);
  52 static s32 e1000_phy_m88_get_info(struct e1000_hw *hw,
  53                                   struct e1000_phy_info *phy_info);
  54 static s32 e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active);
  55 static s32 e1000_wait_autoneg(struct e1000_hw *hw);
  56 static void e1000_write_reg_io(struct e1000_hw *hw, u32 offset, u32 value);
  57 static s32 e1000_set_phy_type(struct e1000_hw *hw);
  58 static void e1000_phy_init_script(struct e1000_hw *hw);
  59 static s32 e1000_setup_copper_link(struct e1000_hw *hw);
  60 static s32 e1000_setup_fiber_serdes_link(struct e1000_hw *hw);
  61 static s32 e1000_adjust_serdes_amplitude(struct e1000_hw *hw);
  62 static s32 e1000_phy_force_speed_duplex(struct e1000_hw *hw);
  63 static s32 e1000_config_mac_to_phy(struct e1000_hw *hw);
  64 static void e1000_raise_mdi_clk(struct e1000_hw *hw, u32 *ctrl);
  65 static void e1000_lower_mdi_clk(struct e1000_hw *hw, u32 *ctrl);
  66 static void e1000_shift_out_mdi_bits(struct e1000_hw *hw, u32 data, u16 count);
  67 static u16 e1000_shift_in_mdi_bits(struct e1000_hw *hw);
  68 static s32 e1000_phy_reset_dsp(struct e1000_hw *hw);
  69 static s32 e1000_write_eeprom_spi(struct e1000_hw *hw, u16 offset,
  70                                   u16 words, u16 *data);
  71 static s32 e1000_write_eeprom_microwire(struct e1000_hw *hw, u16 offset,
  72                                         u16 words, u16 *data);
  73 static s32 e1000_spi_eeprom_ready(struct e1000_hw *hw);
  74 static void e1000_raise_ee_clk(struct e1000_hw *hw, u32 *eecd);
  75 static void e1000_lower_ee_clk(struct e1000_hw *hw, u32 *eecd);
  76 static void e1000_shift_out_ee_bits(struct e1000_hw *hw, u16 data, u16 count);
  77 static s32 e1000_write_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
  78                                   u16 phy_data);
  79 static s32 e1000_read_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
  80                                  u16 *phy_data);
  81 static u16 e1000_shift_in_ee_bits(struct e1000_hw *hw, u16 count);
  82 static s32 e1000_acquire_eeprom(struct e1000_hw *hw);
  83 static void e1000_release_eeprom(struct e1000_hw *hw);
  84 static void e1000_standby_eeprom(struct e1000_hw *hw);
  85 static s32 e1000_set_vco_speed(struct e1000_hw *hw);
  86 static s32 e1000_polarity_reversal_workaround(struct e1000_hw *hw);
  87 static s32 e1000_set_phy_mode(struct e1000_hw *hw);
  88 static s32 e1000_do_read_eeprom(struct e1000_hw *hw, u16 offset, u16 words,
  89                                 u16 *data);
  90 static s32 e1000_do_write_eeprom(struct e1000_hw *hw, u16 offset, u16 words,
  91                                  u16 *data);
  92
  93 /* IGP cable length table */
  94 static const
  95 u16 e1000_igp_cable_length_table[IGP01E1000_AGC_LENGTH_TABLE_SIZE] = {
  96         5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  97         5, 10, 10, 10, 10, 10, 10, 10, 20, 20, 20, 20, 20, 25, 25, 25,
  98         25, 25, 25, 25, 30, 30, 30, 30, 40, 40, 40, 40, 40, 40, 40, 40,
  99         40, 50, 50, 50, 50, 50, 50, 50, 60, 60, 60, 60, 60, 60, 60, 60,
 100         60, 70, 70, 70, 70, 70, 70, 80, 80, 80, 80, 80, 80, 90, 90, 90,
 101         90, 90, 90, 90, 90, 90, 100, 100, 100, 100, 100, 100, 100, 100, 100,
 102             100,
 103         100, 100, 100, 100, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
 104             110, 110,
 105         110, 110, 110, 110, 110, 110, 120, 120, 120, 120, 120, 120, 120, 120,
 106             120, 120
 107 };
 108
 109 static DEFINE_SPINLOCK(e1000_eeprom_lock);
 110 static DEFINE_SPINLOCK(e1000_phy_lock);
 111
 112 /**
 113  * e1000_set_phy_type - Set the phy type member in the hw struct.
 114  * @hw: Struct containing variables accessed by shared code
 115  */
 116 static s32 e1000_set_phy_type(struct e1000_hw *hw)
 117 {
 118         e_dbg("e1000_set_phy_type");
 119
 120         if (hw->mac_type == e1000_undefined)
 121                 return -E1000_ERR_PHY_TYPE;
 122
 123         switch (hw->phy_id) {
 124         case M88E1000_E_PHY_ID:
 125         case M88E1000_I_PHY_ID:
 126         case M88E1011_I_PHY_ID:
 127         case M88E1111_I_PHY_ID:
 128         case M88E1118_E_PHY_ID:
 129                 hw->phy_type = e1000_phy_m88;
 130                 break;
 131         case IGP01E1000_I_PHY_ID:
 132                 if (hw->mac_type == e1000_82541 ||
 133                     hw->mac_type == e1000_82541_rev_2 ||
 134                     hw->mac_type == e1000_82547 ||
 135                     hw->mac_type == e1000_82547_rev_2)
 136                         hw->phy_type = e1000_phy_igp;
 137                 break;
 138         case RTL8211B_PHY_ID:
 139                 hw->phy_type = e1000_phy_8211;
 140                 break;
 141         case RTL8201N_PHY_ID:
 142                 hw->phy_type = e1000_phy_8201;
 143                 break;
 144         default:
 145                 /* Should never have loaded on this device */
 146                 hw->phy_type = e1000_phy_undefined;
 147                 return -E1000_ERR_PHY_TYPE;
 148         }
 149
 150         return E1000_SUCCESS;
 151 }
 152
 153 /**
 154  * e1000_phy_init_script - IGP phy init script - initializes the GbE PHY
 155  * @hw: Struct containing variables accessed by shared code
 156  */
 157 static void e1000_phy_init_script(struct e1000_hw *hw)
 158 {
 159         u32 ret_val;
 160         u16 phy_saved_data;
 161
 162         e_dbg("e1000_phy_init_script");
 163
 164         if (hw->phy_init_script) {
 165                 msleep(20);
 166
 167                 /* Save off the current value of register 0x2F5B to be restored
 168                  * at the end of this routine.
 169                  */
 170                 ret_val = e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data);
 171
 172                 /* Disabled the PHY transmitter */
 173                 e1000_write_phy_reg(hw, 0x2F5B, 0x0003);
 174                 msleep(20);
 175
 176                 e1000_write_phy_reg(hw, 0x0000, 0x0140);
 177                 msleep(5);
 178
 179                 switch (hw->mac_type) {
 180                 case e1000_82541:
 181                 case e1000_82547:
 182                         e1000_write_phy_reg(hw, 0x1F95, 0x0001);
 183                         e1000_write_phy_reg(hw, 0x1F71, 0xBD21);
 184                         e1000_write_phy_reg(hw, 0x1F79, 0x0018);
 185                         e1000_write_phy_reg(hw, 0x1F30, 0x1600);
 186                         e1000_write_phy_reg(hw, 0x1F31, 0x0014);
 187                         e1000_write_phy_reg(hw, 0x1F32, 0x161C);
 188                         e1000_write_phy_reg(hw, 0x1F94, 0x0003);
 189                         e1000_write_phy_reg(hw, 0x1F96, 0x003F);
 190                         e1000_write_phy_reg(hw, 0x2010, 0x0008);
 191                         break;
 192
 193                 case e1000_82541_rev_2:
 194                 case e1000_82547_rev_2:
 195                         e1000_write_phy_reg(hw, 0x1F73, 0x0099);
 196                         break;
 197                 default:
 198                         break;
 199                 }
 200
 201                 e1000_write_phy_reg(hw, 0x0000, 0x3300);
 202                 msleep(20);
 203
 204                 /* Now enable the transmitter */
 205                 e1000_write_phy_reg(hw, 0x2F5B, phy_saved_data);
 206
 207                 if (hw->mac_type == e1000_82547) {
 208                         u16 fused, fine, coarse;
 209
 210                         /* Move to analog registers page */
 211                         e1000_read_phy_reg(hw,
 212                                            IGP01E1000_ANALOG_SPARE_FUSE_STATUS,
 213                                            &fused);
 214
 215                         if (!(fused & IGP01E1000_ANALOG_SPARE_FUSE_ENABLED)) {
 216                                 e1000_read_phy_reg(hw,
 217                                                    IGP01E1000_ANALOG_FUSE_STATUS,
 218                                                    &fused);
 219
 220                                 fine = fused & IGP01E1000_ANALOG_FUSE_FINE_MASK;
 221                                 coarse =
 222                                     fused & IGP01E1000_ANALOG_FUSE_COARSE_MASK;
 223
 224                                 if (coarse >
 225                                     IGP01E1000_ANALOG_FUSE_COARSE_THRESH) {
 226                                         coarse -=
 227                                             IGP01E1000_ANALOG_FUSE_COARSE_10;
 228                                         fine -= IGP01E1000_ANALOG_FUSE_FINE_1;
 229                                 } else if (coarse ==
 230                                            IGP01E1000_ANALOG_FUSE_COARSE_THRESH)
 231                                         fine -= IGP01E1000_ANALOG_FUSE_FINE_10;
 232
 233                                 fused =
 234                                     (fused & IGP01E1000_ANALOG_FUSE_POLY_MASK) |
 235                                     (fine & IGP01E1000_ANALOG_FUSE_FINE_MASK) |
 236                                     (coarse &
 237                                      IGP01E1000_ANALOG_FUSE_COARSE_MASK);
 238
 239                                 e1000_write_phy_reg(hw,
 240                                                     IGP01E1000_ANALOG_FUSE_CONTROL,
 241                                                     fused);
 242                                 e1000_write_phy_reg(hw,
 243                                                     IGP01E1000_ANALOG_FUSE_BYPASS,
 244                                                     IGP01E1000_ANALOG_FUSE_ENABLE_SW_CONTROL);
 245                         }
 246                 }
 247         }
 248 }
 249
 250 /**
 251  * e1000_set_mac_type - Set the mac type member in the hw struct.
 252  * @hw: Struct containing variables accessed by shared code
 253  */
 254 s32 e1000_set_mac_type(struct e1000_hw *hw)
 255 {
 256         e_dbg("e1000_set_mac_type");
 257
 258         switch (hw->device_id) {
 259         case E1000_DEV_ID_82542:
 260                 switch (hw->revision_id) {
 261                 case E1000_82542_2_0_REV_ID:
 262                         hw->mac_type = e1000_82542_rev2_0;
 263                         break;
 264                 case E1000_82542_2_1_REV_ID:
 265                         hw->mac_type = e1000_82542_rev2_1;
 266                         break;
 267                 default:
 268                         /* Invalid 82542 revision ID */
 269                         return -E1000_ERR_MAC_TYPE;
 270                 }
 271                 break;
 272         case E1000_DEV_ID_82543GC_FIBER:
 273         case E1000_DEV_ID_82543GC_COPPER:
 274                 hw->mac_type = e1000_82543;
 275                 break;
 276         case E1000_DEV_ID_82544EI_COPPER:
 277         case E1000_DEV_ID_82544EI_FIBER:
 278         case E1000_DEV_ID_82544GC_COPPER:
 279         case E1000_DEV_ID_82544GC_LOM:
 280                 hw->mac_type = e1000_82544;
 281                 break;
 282         case E1000_DEV_ID_82540EM:
 283         case E1000_DEV_ID_82540EM_LOM:
 284         case E1000_DEV_ID_82540EP:
 285         case E1000_DEV_ID_82540EP_LOM:
 286         case E1000_DEV_ID_82540EP_LP:
 287                 hw->mac_type = e1000_82540;
 288                 break;
 289         case E1000_DEV_ID_82545EM_COPPER:
 290         case E1000_DEV_ID_82545EM_FIBER:
 291                 hw->mac_type = e1000_82545;
 292                 break;
 293         case E1000_DEV_ID_82545GM_COPPER:
 294         case E1000_DEV_ID_82545GM_FIBER:
 295         case E1000_DEV_ID_82545GM_SERDES:
 296                 hw->mac_type = e1000_82545_rev_3;
 297                 break;
 298         case E1000_DEV_ID_82546EB_COPPER:
 299         case E1000_DEV_ID_82546EB_FIBER:
 300         case E1000_DEV_ID_82546EB_QUAD_COPPER:
 301                 hw->mac_type = e1000_82546;
 302                 break;
 303         case E1000_DEV_ID_82546GB_COPPER:
 304         case E1000_DEV_ID_82546GB_FIBER:
 305         case E1000_DEV_ID_82546GB_SERDES:
 306         case E1000_DEV_ID_82546GB_PCIE:
 307         case E1000_DEV_ID_82546GB_QUAD_COPPER:
 308         case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
 309                 hw->mac_type = e1000_82546_rev_3;
 310                 break;
 311         case E1000_DEV_ID_82541EI:
 312         case E1000_DEV_ID_82541EI_MOBILE:
 313         case E1000_DEV_ID_82541ER_LOM:
 314                 hw->mac_type = e1000_82541;
 315                 break;
 316         case E1000_DEV_ID_82541ER:
 317         case E1000_DEV_ID_82541GI:
 318         case E1000_DEV_ID_82541GI_LF:
 319         case E1000_DEV_ID_82541GI_MOBILE:
 320                 hw->mac_type = e1000_82541_rev_2;
 321                 break;
 322         case E1000_DEV_ID_82547EI:
 323         case E1000_DEV_ID_82547EI_MOBILE:
 324                 hw->mac_type = e1000_82547;
 325                 break;
 326         case E1000_DEV_ID_82547GI:
 327                 hw->mac_type = e1000_82547_rev_2;
 328                 break;
 329         case E1000_DEV_ID_INTEL_CE4100_GBE:
 330                 hw->mac_type = e1000_ce4100;
 331                 break;
 332         default:
 333                 /* Should never have loaded on this device */
 334                 return -E1000_ERR_MAC_TYPE;
 335         }
 336
 337         switch (hw->mac_type) {
 338         case e1000_82541:
 339         case e1000_82547:
 340         case e1000_82541_rev_2:
 341         case e1000_82547_rev_2:
 342                 hw->asf_firmware_present = true;
 343                 break;
 344         default:
 345                 break;
 346         }
 347
 348         /* The 82543 chip does not count tx_carrier_errors properly in
 349          * FD mode
 350          */
 351         if (hw->mac_type == e1000_82543)
 352                 hw->bad_tx_carr_stats_fd = true;
 353
 354         if (hw->mac_type > e1000_82544)
 355                 hw->has_smbus = true;
 356
 357         return E1000_SUCCESS;
 358 }
 359
 360 /**
 361  * e1000_set_media_type - Set media type and TBI compatibility.
 362  * @hw: Struct containing variables accessed by shared code
 363  */
 364 void e1000_set_media_type(struct e1000_hw *hw)
 365 {
 366         u32 status;
 367
 368         e_dbg("e1000_set_media_type");
 369
 370         if (hw->mac_type != e1000_82543) {
 371                 /* tbi_compatibility is only valid on 82543 */
 372                 hw->tbi_compatibility_en = false;
 373         }
 374
 375         switch (hw->device_id) {
 376         case E1000_DEV_ID_82545GM_SERDES:
 377         case E1000_DEV_ID_82546GB_SERDES:
 378                 hw->media_type = e1000_media_type_internal_serdes;
 379                 break;
 380         default:
 381                 switch (hw->mac_type) {
 382                 case e1000_82542_rev2_0:
 383                 case e1000_82542_rev2_1:
 384                         hw->media_type = e1000_media_type_fiber;
 385                         break;
 386                 case e1000_ce4100:
 387                         hw->media_type = e1000_media_type_copper;
 388                         break;
 389                 default:
 390                         status = er32(STATUS);
 391                         if (status & E1000_STATUS_TBIMODE) {
 392                                 hw->media_type = e1000_media_type_fiber;
 393                                 /* tbi_compatibility not valid on fiber */
 394                                 hw->tbi_compatibility_en = false;
 395                         } else {
 396                                 hw->media_type = e1000_media_type_copper;
 397                         }
 398                         break;
 399                 }
 400         }
 401 }
 402
 403 /**
 404  * e1000_reset_hw - reset the hardware completely
 405  * @hw: Struct containing variables accessed by shared code
 406  *
 407  * Reset the transmit and receive units; mask and clear all interrupts.
 408  */
 409 s32 e1000_reset_hw(struct e1000_hw *hw)
 410 {
 411         u32 ctrl;
 412         u32 ctrl_ext;
 413         u32 icr;
 414         u32 manc;
 415         u32 led_ctrl;
 416         s32 ret_val;
 417
 418         e_dbg("e1000_reset_hw");
 419
 420         /* For 82542 (rev 2.0), disable MWI before issuing a device reset */
 421         if (hw->mac_type == e1000_82542_rev2_0) {
 422                 e_dbg("Disabling MWI on 82542 rev 2.0\n");
 423                 e1000_pci_clear_mwi(hw);
 424         }
 425
 426         /* Clear interrupt mask to stop board from generating interrupts */
 427         e_dbg("Masking off all interrupts\n");
 428         ew32(IMC, 0xffffffff);
 429
 430         /* Disable the Transmit and Receive units.  Then delay to allow
 431          * any pending transactions to complete before we hit the MAC with
 432          * the global reset.
 433          */
 434         ew32(RCTL, 0);
 435         ew32(TCTL, E1000_TCTL_PSP);
 436         E1000_WRITE_FLUSH();
 437
 438         /* The tbi_compatibility_on Flag must be cleared when Rctl is cleared. */
 439         hw->tbi_compatibility_on = false;
 440
 441         /* Delay to allow any outstanding PCI transactions to complete before
 442          * resetting the device
 443          */
 444         msleep(10);
 445
 446         ctrl = er32(CTRL);
 447
 448         /* Must reset the PHY before resetting the MAC */
 449         if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
 450                 ew32(CTRL, (ctrl | E1000_CTRL_PHY_RST));
 451                 E1000_WRITE_FLUSH();
 452                 msleep(5);
 453         }
 454
 455         /* Issue a global reset to the MAC.  This will reset the chip's
 456          * transmit, receive, DMA, and link units.  It will not effect
 457          * the current PCI configuration.  The global reset bit is self-
 458          * clearing, and should clear within a microsecond.
 459          */
 460         e_dbg("Issuing a global reset to MAC\n");
 461
 462         switch (hw->mac_type) {
 463         case e1000_82544:
 464         case e1000_82540:
 465         case e1000_82545:
 466         case e1000_82546:
 467         case e1000_82541:
 468         case e1000_82541_rev_2:
 469                 /* These controllers can't ack the 64-bit write when issuing the
 470                  * reset, so use IO-mapping as a workaround to issue the reset
 471                  */
 472                 E1000_WRITE_REG_IO(hw, CTRL, (ctrl | E1000_CTRL_RST));
 473                 break;
 474         case e1000_82545_rev_3:
 475         case e1000_82546_rev_3:
 476                 /* Reset is performed on a shadow of the control register */
 477                 ew32(CTRL_DUP, (ctrl | E1000_CTRL_RST));
 478                 break;
 479         case e1000_ce4100:
 480         default:
 481                 ew32(CTRL, (ctrl | E1000_CTRL_RST));
 482                 break;
 483         }
 484
 485         /* After MAC reset, force reload of EEPROM to restore power-on settings
 486          * to device.  Later controllers reload the EEPROM automatically, so
 487          * just wait for reload to complete.
 488          */
 489         switch (hw->mac_type) {
 490         case e1000_82542_rev2_0:
 491         case e1000_82542_rev2_1:
 492         case e1000_82543:
 493         case e1000_82544:
 494                 /* Wait for reset to complete */
 495                 udelay(10);
 496                 ctrl_ext = er32(CTRL_EXT);
 497                 ctrl_ext |= E1000_CTRL_EXT_EE_RST;
 498                 ew32(CTRL_EXT, ctrl_ext);
 499                 E1000_WRITE_FLUSH();
 500                 /* Wait for EEPROM reload */
 501                 msleep(2);
 502                 break;
 503         case e1000_82541:
 504         case e1000_82541_rev_2:
 505         case e1000_82547:
 506         case e1000_82547_rev_2:
 507                 /* Wait for EEPROM reload */
 508                 msleep(20);
 509                 break;
 510         default:
 511                 /* Auto read done will delay 5ms or poll based on mac type */
 512                 ret_val = e1000_get_auto_rd_done(hw);
 513                 if (ret_val)
 514                         return ret_val;
 515                 break;
 516         }
 517
 518         /* Disable HW ARPs on ASF enabled adapters */
 519         if (hw->mac_type >= e1000_82540) {
 520                 manc = er32(MANC);
 521                 manc &= ~(E1000_MANC_ARP_EN);
 522                 ew32(MANC, manc);
 523         }
 524
 525         if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
 526                 e1000_phy_init_script(hw);
 527
 528                 /* Configure activity LED after PHY reset */
 529                 led_ctrl = er32(LEDCTL);
 530                 led_ctrl &= IGP_ACTIVITY_LED_MASK;
 531                 led_ctrl |= (IGP_ACTIVITY_LED_ENABLE | IGP_LED3_MODE);
 532                 ew32(LEDCTL, led_ctrl);
 533         }
 534
 535         /* Clear interrupt mask to stop board from generating interrupts */
 536         e_dbg("Masking off all interrupts\n");
 537         ew32(IMC, 0xffffffff);
 538
 539         /* Clear any pending interrupt events. */
 540         icr = er32(ICR);
 541
 542         /* If MWI was previously enabled, reenable it. */
 543         if (hw->mac_type == e1000_82542_rev2_0) {
 544                 if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE)
 545                         e1000_pci_set_mwi(hw);
 546         }
 547
 548         return E1000_SUCCESS;
 549 }
 550
 551 /**
 552  * e1000_init_hw - Performs basic configuration of the adapter.
 553  * @hw: Struct containing variables accessed by shared code
 554  *
 555  * Assumes that the controller has previously been reset and is in a
 556  * post-reset uninitialized state. Initializes the receive address registers,
 557  * multicast table, and VLAN filter table. Calls routines to setup link
 558  * configuration and flow control settings. Clears all on-chip counters. Leaves
 559  * the transmit and receive units disabled and uninitialized.
 560  */
 561 s32 e1000_init_hw(struct e1000_hw *hw)
 562 {
 563         u32 ctrl;
 564         u32 i;
 565         s32 ret_val;
 566         u32 mta_size;
 567         u32 ctrl_ext;
 568
 569         e_dbg("e1000_init_hw");
 570
 571         /* Initialize Identification LED */
 572         ret_val = e1000_id_led_init(hw);
 573         if (ret_val) {
 574                 e_dbg("Error Initializing Identification LED\n");
 575                 return ret_val;
 576         }
 577
 578         /* Set the media type and TBI compatibility */
 579         e1000_set_media_type(hw);
 580
 581         /* Disabling VLAN filtering. */
 582         e_dbg("Initializing the IEEE VLAN\n");
 583         if (hw->mac_type < e1000_82545_rev_3)
 584                 ew32(VET, 0);
 585         e1000_clear_vfta(hw);
 586
 587         /* For 82542 (rev 2.0), disable MWI and put the receiver into reset */
 588         if (hw->mac_type == e1000_82542_rev2_0) {
 589                 e_dbg("Disabling MWI on 82542 rev 2.0\n");
 590                 e1000_pci_clear_mwi(hw);
 591                 ew32(RCTL, E1000_RCTL_RST);
 592                 E1000_WRITE_FLUSH();
 593                 msleep(5);
 594         }
 595
 596         /* Setup the receive address. This involves initializing all of the
 597          * Receive Address Registers (RARs 0 - 15).
 598          */
 599         e1000_init_rx_addrs(hw);
 600
 601         /* For 82542 (rev 2.0), take the receiver out of reset and enable MWI */
 602         if (hw->mac_type == e1000_82542_rev2_0) {
 603                 ew32(RCTL, 0);
 604                 E1000_WRITE_FLUSH();
 605                 msleep(1);
 606                 if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE)
 607                         e1000_pci_set_mwi(hw);
 608         }
 609
 610         /* Zero out the Multicast HASH table */
 611         e_dbg("Zeroing the MTA\n");
 612         mta_size = E1000_MC_TBL_SIZE;
 613         for (i = 0; i < mta_size; i++) {
 614                 E1000_WRITE_REG_ARRAY(hw, MTA, i, 0);
 615                 /* use write flush to prevent Memory Write Block (MWB) from
 616                  * occurring when accessing our register space
 617                  */
 618                 E1000_WRITE_FLUSH();
 619         }
 620
 621         /* Set the PCI priority bit correctly in the CTRL register.  This
 622          * determines if the adapter gives priority to receives, or if it
 623          * gives equal priority to transmits and receives.  Valid only on
 624          * 82542 and 82543 silicon.
 625          */
 626         if (hw->dma_fairness && hw->mac_type <= e1000_82543) {
 627                 ctrl = er32(CTRL);
 628                 ew32(CTRL, ctrl | E1000_CTRL_PRIOR);
 629         }
 630
 631         switch (hw->mac_type) {
 632         case e1000_82545_rev_3:
 633         case e1000_82546_rev_3:
 634                 break;
 635         default:
 636                 /* Workaround for PCI-X problem when BIOS sets MMRBC
 637                  * incorrectly.
 638                  */
 639                 if (hw->bus_type == e1000_bus_type_pcix
 640                     && e1000_pcix_get_mmrbc(hw) > 2048)
 641                         e1000_pcix_set_mmrbc(hw, 2048);
 642                 break;
 643         }
 644
 645         /* Call a subroutine to configure the link and setup flow control. */
 646         ret_val = e1000_setup_link(hw);
 647
 648         /* Set the transmit descriptor write-back policy */
 649         if (hw->mac_type > e1000_82544) {
 650                 ctrl = er32(TXDCTL);
 651                 ctrl =
 652                     (ctrl & ~E1000_TXDCTL_WTHRESH) |
 653                     E1000_TXDCTL_FULL_TX_DESC_WB;
 654                 ew32(TXDCTL, ctrl);
 655         }
 656
 657         /* Clear all of the statistics registers (clear on read).  It is
 658          * important that we do this after we have tried to establish link
 659          * because the symbol error count will increment wildly if there
 660          * is no link.
 661          */
 662         e1000_clear_hw_cntrs(hw);
 663
 664         if (hw->device_id == E1000_DEV_ID_82546GB_QUAD_COPPER ||
 665             hw->device_id == E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3) {
 666                 ctrl_ext = er32(CTRL_EXT);
 667                 /* Relaxed ordering must be disabled to avoid a parity
 668                  * error crash in a PCI slot.
 669                  */
 670                 ctrl_ext |= E1000_CTRL_EXT_RO_DIS;
 671                 ew32(CTRL_EXT, ctrl_ext);
 672         }
 673
 674         return ret_val;
 675 }
 676
 677 /**
 678  * e1000_adjust_serdes_amplitude - Adjust SERDES output amplitude based on EEPROM setting.
 679  * @hw: Struct containing variables accessed by shared code.
 680  */
 681 static s32 e1000_adjust_serdes_amplitude(struct e1000_hw *hw)
 682 {
 683         u16 eeprom_data;
 684         s32 ret_val;
 685
 686         e_dbg("e1000_adjust_serdes_amplitude");
 687
 688         if (hw->media_type != e1000_media_type_internal_serdes)
 689                 return E1000_SUCCESS;
 690
 691         switch (hw->mac_type) {
 692         case e1000_82545_rev_3:
 693         case e1000_82546_rev_3:
 694                 break;
 695         default:
 696                 return E1000_SUCCESS;
 697         }
 698
 699         ret_val = e1000_read_eeprom(hw, EEPROM_SERDES_AMPLITUDE, 1,
 700                                     &eeprom_data);
 701         if (ret_val) {
 702                 return ret_val;
 703         }
 704
 705         if (eeprom_data != EEPROM_RESERVED_WORD) {
 706                 /* Adjust SERDES output amplitude only. */
 707                 eeprom_data &= EEPROM_SERDES_AMPLITUDE_MASK;
 708                 ret_val =
 709                     e1000_write_phy_reg(hw, M88E1000_PHY_EXT_CTRL, eeprom_data);
 710                 if (ret_val)
 711                         return ret_val;
 712         }
 713
 714         return E1000_SUCCESS;
 715 }
 716
 717 /**
 718  * e1000_setup_link - Configures flow control and link settings.
 719  * @hw: Struct containing variables accessed by shared code
 720  *
 721  * Determines which flow control settings to use. Calls the appropriate media-
 722  * specific link configuration function. Configures the flow control settings.
 723  * Assuming the adapter has a valid link partner, a valid link should be
 724  * established. Assumes the hardware has previously been reset and the
 725  * transmitter and receiver are not enabled.
 726  */
 727 s32 e1000_setup_link(struct e1000_hw *hw)
 728 {
 729         u32 ctrl_ext;
 730         s32 ret_val;
 731         u16 eeprom_data;
 732
 733         e_dbg("e1000_setup_link");
 734
 735         /* Read and store word 0x0F of the EEPROM. This word contains bits
 736          * that determine the hardware's default PAUSE (flow control) mode,
 737          * a bit that determines whether the HW defaults to enabling or
 738          * disabling auto-negotiation, and the direction of the
 739          * SW defined pins. If there is no SW over-ride of the flow
 740          * control setting, then the variable hw->fc will
 741          * be initialized based on a value in the EEPROM.
 742          */
 743         if (hw->fc == E1000_FC_DEFAULT) {
 744                 ret_val = e1000_read_eeprom(hw, EEPROM_INIT_CONTROL2_REG,
 745                                             1, &eeprom_data);
 746                 if (ret_val) {
 747                         e_dbg("EEPROM Read Error\n");
 748                         return -E1000_ERR_EEPROM;
 749                 }
 750                 if ((eeprom_data & EEPROM_WORD0F_PAUSE_MASK) == 0)
 751                         hw->fc = E1000_FC_NONE;
 752                 else if ((eeprom_data & EEPROM_WORD0F_PAUSE_MASK) ==
 753                          EEPROM_WORD0F_ASM_DIR)
 754                         hw->fc = E1000_FC_TX_PAUSE;
 755                 else
 756                         hw->fc = E1000_FC_FULL;
 757         }
 758
 759         /* We want to save off the original Flow Control configuration just
 760          * in case we get disconnected and then reconnected into a different
 761          * hub or switch with different Flow Control capabilities.
 762          */
 763         if (hw->mac_type == e1000_82542_rev2_0)
 764                 hw->fc &= (~E1000_FC_TX_PAUSE);
 765
 766         if ((hw->mac_type < e1000_82543) && (hw->report_tx_early == 1))
 767                 hw->fc &= (~E1000_FC_RX_PAUSE);
 768
 769         hw->original_fc = hw->fc;
 770
 771         e_dbg("After fix-ups FlowControl is now = %x\n", hw->fc);
 772
 773         /* Take the 4 bits from EEPROM word 0x0F that determine the initial
 774          * polarity value for the SW controlled pins, and setup the
 775          * Extended Device Control reg with that info.
 776          * This is needed because one of the SW controlled pins is used for
 777          * signal detection.  So this should be done before e1000_setup_pcs_link()
 778          * or e1000_phy_setup() is called.
 779          */
 780         if (hw->mac_type == e1000_82543) {
 781                 ret_val = e1000_read_eeprom(hw, EEPROM_INIT_CONTROL2_REG,
 782                                             1, &eeprom_data);
 783                 if (ret_val) {
 784                         e_dbg("EEPROM Read Error\n");
 785                         return -E1000_ERR_EEPROM;
 786                 }
 787                 ctrl_ext = ((eeprom_data & EEPROM_WORD0F_SWPDIO_EXT) <<
 788                             SWDPIO__EXT_SHIFT);
 789                 ew32(CTRL_EXT, ctrl_ext);
 790         }
 791
 792         /* Call the necessary subroutine to configure the link. */
 793         ret_val = (hw->media_type == e1000_media_type_copper) ?
 794             e1000_setup_copper_link(hw) : e1000_setup_fiber_serdes_link(hw);
 795
 796         /* Initialize the flow control address, type, and PAUSE timer
 797          * registers to their default values.  This is done even if flow
 798          * control is disabled, because it does not hurt anything to
 799          * initialize these registers.
 800          */
 801         e_dbg("Initializing the Flow Control address, type and timer regs\n");
 802
 803         ew32(FCT, FLOW_CONTROL_TYPE);
 804         ew32(FCAH, FLOW_CONTROL_ADDRESS_HIGH);
 805         ew32(FCAL, FLOW_CONTROL_ADDRESS_LOW);
 806
 807         ew32(FCTTV, hw->fc_pause_time);
 808
 809         /* Set the flow control receive threshold registers.  Normally,
 810          * these registers will be set to a default threshold that may be
 811          * adjusted later by the driver's runtime code.  However, if the
 812          * ability to transmit pause frames in not enabled, then these
 813          * registers will be set to 0.
 814          */
 815         if (!(hw->fc & E1000_FC_TX_PAUSE)) {
 816                 ew32(FCRTL, 0);
 817                 ew32(FCRTH, 0);
 818         } else {
 819                 /* We need to set up the Receive Threshold high and low water
 820                  * marks as well as (optionally) enabling the transmission of
 821                  * XON frames.
 822                  */
 823                 if (hw->fc_send_xon) {
 824                         ew32(FCRTL, (hw->fc_low_water | E1000_FCRTL_XONE));
 825                         ew32(FCRTH, hw->fc_high_water);
 826                 } else {
 827                         ew32(FCRTL, hw->fc_low_water);
 828                         ew32(FCRTH, hw->fc_high_water);
 829                 }
 830         }
 831         return ret_val;
 832 }
 833
 834 /**
 835  * e1000_setup_fiber_serdes_link - prepare fiber or serdes link
 836  * @hw: Struct containing variables accessed by shared code
 837  *
 838  * Manipulates Physical Coding Sublayer functions in order to configure
 839  * link. Assumes the hardware has been previously reset and the transmitter
 840  * and receiver are not enabled.
 841  */
 842 static s32 e1000_setup_fiber_serdes_link(struct e1000_hw *hw)
 843 {
 844         u32 ctrl;
 845         u32 status;
 846         u32 txcw = 0;
 847         u32 i;
 848         u32 signal = 0;
 849         s32 ret_val;
 850
 851         e_dbg("e1000_setup_fiber_serdes_link");
 852
 853         /* On adapters with a MAC newer than 82544, SWDP 1 will be
 854          * set when the optics detect a signal. On older adapters, it will be
 855          * cleared when there is a signal.  This applies to fiber media only.
 856          * If we're on serdes media, adjust the output amplitude to value
 857          * set in the EEPROM.
 858          */
 859         ctrl = er32(CTRL);
 860         if (hw->media_type == e1000_media_type_fiber)
 861                 signal = (hw->mac_type > e1000_82544) ? E1000_CTRL_SWDPIN1 : 0;
 862
 863         ret_val = e1000_adjust_serdes_amplitude(hw);
 864         if (ret_val)
 865                 return ret_val;
 866
 867         /* Take the link out of reset */
 868         ctrl &= ~(E1000_CTRL_LRST);
 869
 870         /* Adjust VCO speed to improve BER performance */
 871         ret_val = e1000_set_vco_speed(hw);
 872         if (ret_val)
 873                 return ret_val;
 874
 875         e1000_config_collision_dist(hw);
 876
 877         /* Check for a software override of the flow control settings, and setup
 878          * the device accordingly.  If auto-negotiation is enabled, then
 879          * software will have to set the "PAUSE" bits to the correct value in
 880          * the Tranmsit Config Word Register (TXCW) and re-start
 881          * auto-negotiation.  However, if auto-negotiation is disabled, then
 882          * software will have to manually configure the two flow control enable
 883          * bits in the CTRL register.
 884          *
 885          * The possible values of the "fc" parameter are:
 886          *  0:  Flow control is completely disabled
 887          *  1:  Rx flow control is enabled (we can receive pause frames, but
 888          *      not send pause frames).
 889          *  2:  Tx flow control is enabled (we can send pause frames but we do
 890          *      not support receiving pause frames).
 891          *  3:  Both Rx and TX flow control (symmetric) are enabled.
 892          */
 893         switch (hw->fc) {
 894         case E1000_FC_NONE:
 895                 /* Flow ctrl is completely disabled by a software over-ride */
 896                 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD);
 897                 break;
 898         case E1000_FC_RX_PAUSE:
 899                 /* Rx Flow control is enabled and Tx Flow control is disabled by
 900                  * a software over-ride. Since there really isn't a way to
 901                  * advertise that we are capable of Rx Pause ONLY, we will
 902                  * advertise that we support both symmetric and asymmetric Rx
 903                  * PAUSE. Later, we will disable the adapter's ability to send
 904                  * PAUSE frames.
 905                  */
 906                 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
 907                 break;
 908         case E1000_FC_TX_PAUSE:
 909                 /* Tx Flow control is enabled, and Rx Flow control is disabled,
 910                  * by a software over-ride.
 911                  */
 912                 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_ASM_DIR);
 913                 break;
 914         case E1000_FC_FULL:
 915                 /* Flow control (both Rx and Tx) is enabled by a software
 916                  * over-ride.
 917                  */
 918                 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
 919                 break;
 920         default:
 921                 e_dbg("Flow control param set incorrectly\n");
 922                 return -E1000_ERR_CONFIG;
 923                 break;
 924         }
 925
 926         /* Since auto-negotiation is enabled, take the link out of reset (the
 927          * link will be in reset, because we previously reset the chip). This
 928          * will restart auto-negotiation.  If auto-negotiation is successful
 929          * then the link-up status bit will be set and the flow control enable
 930          * bits (RFCE and TFCE) will be set according to their negotiated value.
 931          */
 932         e_dbg("Auto-negotiation enabled\n");
 933
 934         ew32(TXCW, txcw);
 935         ew32(CTRL, ctrl);
 936         E1000_WRITE_FLUSH();
 937
 938         hw->txcw = txcw;
 939         msleep(1);
 940
 941         /* If we have a signal (the cable is plugged in) then poll for a
 942          * "Link-Up" indication in the Device Status Register.  Time-out if a
 943          * link isn't seen in 500 milliseconds seconds (Auto-negotiation should
 944          * complete in less than 500 milliseconds even if the other end is doing
 945          * it in SW). For internal serdes, we just assume a signal is present,
 946          * then poll.
 947          */
 948         if (hw->media_type == e1000_media_type_internal_serdes ||
 949             (er32(CTRL) & E1000_CTRL_SWDPIN1) == signal) {
 950                 e_dbg("Looking for Link\n");
 951                 for (i = 0; i < (LINK_UP_TIMEOUT / 10); i++) {
 952                         msleep(10);
 953                         status = er32(STATUS);
 954                         if (status & E1000_STATUS_LU)
 955                                 break;
 956                 }
 957                 if (i == (LINK_UP_TIMEOUT / 10)) {
 958                         e_dbg("Never got a valid link from auto-neg!!!\n");
 959                         hw->autoneg_failed = 1;
 960                         /* AutoNeg failed to achieve a link, so we'll call
 961                          * e1000_check_for_link. This routine will force the
 962                          * link up if we detect a signal. This will allow us to
 963                          * communicate with non-autonegotiating link partners.
 964                          */
 965                         ret_val = e1000_check_for_link(hw);
 966                         if (ret_val) {
 967                                 e_dbg("Error while checking for link\n");
 968                                 return ret_val;
 969                         }
 970                         hw->autoneg_failed = 0;
 971                 } else {
 972                         hw->autoneg_failed = 0;
 973                         e_dbg("Valid Link Found\n");
 974                 }
 975         } else {
 976                 e_dbg("No Signal Detected\n");
 977         }
 978         return E1000_SUCCESS;
 979 }
 980
 981 /**
 982  * e1000_copper_link_rtl_setup - Copper link setup for e1000_phy_rtl series.
 983  * @hw: Struct containing variables accessed by shared code
 984  *
 985  * Commits changes to PHY configuration by calling e1000_phy_reset().
 986  */
 987 static s32 e1000_copper_link_rtl_setup(struct e1000_hw *hw)
 988 {
 989         s32 ret_val;
 990
 991         /* SW reset the PHY so all changes take effect */
 992         ret_val = e1000_phy_reset(hw);
 993         if (ret_val) {
 994                 e_dbg("Error Resetting the PHY\n");
 995                 return ret_val;
 996         }
 997
 998         return E1000_SUCCESS;
 999 }
1000
1001 static s32 gbe_dhg_phy_setup(struct e1000_hw *hw)
1002 {
1003         s32 ret_val;
1004         u32 ctrl_aux;
1005
1006         switch (hw->phy_type) {
1007         case e1000_phy_8211:
1008                 ret_val = e1000_copper_link_rtl_setup(hw);
1009                 if (ret_val) {
1010                         e_dbg("e1000_copper_link_rtl_setup failed!\n");
1011                         return ret_val;
1012                 }
1013                 break;
1014         case e1000_phy_8201:
1015                 /* Set RMII mode */
1016                 ctrl_aux = er32(CTL_AUX);
1017                 ctrl_aux |= E1000_CTL_AUX_RMII;
1018                 ew32(CTL_AUX, ctrl_aux);
1019                 E1000_WRITE_FLUSH();
1020
1021                 /* Disable the J/K bits required for receive */
1022                 ctrl_aux = er32(CTL_AUX);
1023                 ctrl_aux |= 0x4;
1024                 ctrl_aux &= ~0x2;
1025                 ew32(CTL_AUX, ctrl_aux);
1026                 E1000_WRITE_FLUSH();
1027                 ret_val = e1000_copper_link_rtl_setup(hw);
1028
1029                 if (ret_val) {
1030                         e_dbg("e1000_copper_link_rtl_setup failed!\n");
1031                         return ret_val;
1032                 }
1033                 break;
1034         default:
1035                 e_dbg("Error Resetting the PHY\n");
1036                 return E1000_ERR_PHY_TYPE;
1037         }
1038
1039         return E1000_SUCCESS;
1040 }
1041
1042 /**
1043  * e1000_copper_link_preconfig - early configuration for copper
1044  * @hw: Struct containing variables accessed by shared code
1045  *
1046  * Make sure we have a valid PHY and change PHY mode before link setup.
1047  */
1048 static s32 e1000_copper_link_preconfig(struct e1000_hw *hw)
1049 {
1050         u32 ctrl;
1051         s32 ret_val;
1052         u16 phy_data;
1053
1054         e_dbg("e1000_copper_link_preconfig");
1055
1056         ctrl = er32(CTRL);
1057         /* With 82543, we need to force speed and duplex on the MAC equal to
1058          * what the PHY speed and duplex configuration is. In addition, we need
1059          * to perform a hardware reset on the PHY to take it out of reset.
1060          */
1061         if (hw->mac_type > e1000_82543) {
1062                 ctrl |= E1000_CTRL_SLU;
1063                 ctrl &= ~(E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1064                 ew32(CTRL, ctrl);
1065         } else {
1066                 ctrl |=
1067                     (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX | E1000_CTRL_SLU);
1068                 ew32(CTRL, ctrl);
1069                 ret_val = e1000_phy_hw_reset(hw);
1070                 if (ret_val)
1071                         return ret_val;
1072         }
1073
1074         /* Make sure we have a valid PHY */
1075         ret_val = e1000_detect_gig_phy(hw);
1076         if (ret_val) {
1077                 e_dbg("Error, did not detect valid phy.\n");
1078                 return ret_val;
1079         }
1080         e_dbg("Phy ID = %x\n", hw->phy_id);
1081
1082         /* Set PHY to class A mode (if necessary) */
1083         ret_val = e1000_set_phy_mode(hw);
1084         if (ret_val)
1085                 return ret_val;
1086
1087         if ((hw->mac_type == e1000_82545_rev_3) ||
1088             (hw->mac_type == e1000_82546_rev_3)) {
1089                 ret_val =
1090                     e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1091                 phy_data |= 0x00000008;
1092                 ret_val =
1093                     e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1094         }
1095
1096         if (hw->mac_type <= e1000_82543 ||
1097             hw->mac_type == e1000_82541 || hw->mac_type == e1000_82547 ||
1098             hw->mac_type == e1000_82541_rev_2
1099             || hw->mac_type == e1000_82547_rev_2)
1100                 hw->phy_reset_disable = false;
1101
1102         return E1000_SUCCESS;
1103 }
1104
1105 /**
1106  * e1000_copper_link_igp_setup - Copper link setup for e1000_phy_igp series.
1107  * @hw: Struct containing variables accessed by shared code
1108  */
1109 static s32 e1000_copper_link_igp_setup(struct e1000_hw *hw)
1110 {
1111         u32 led_ctrl;
1112         s32 ret_val;
1113         u16 phy_data;
1114
1115         e_dbg("e1000_copper_link_igp_setup");
1116
1117         if (hw->phy_reset_disable)
1118                 return E1000_SUCCESS;
1119
1120         ret_val = e1000_phy_reset(hw);
1121         if (ret_val) {
1122                 e_dbg("Error Resetting the PHY\n");
1123                 return ret_val;
1124         }
1125
1126         /* Wait 15ms for MAC to configure PHY from eeprom settings */
1127         msleep(15);
1128         /* Configure activity LED after PHY reset */
1129         led_ctrl = er32(LEDCTL);
1130         led_ctrl &= IGP_ACTIVITY_LED_MASK;
1131         led_ctrl |= (IGP_ACTIVITY_LED_ENABLE | IGP_LED3_MODE);
1132         ew32(LEDCTL, led_ctrl);
1133
1134         /* The NVM settings will configure LPLU in D3 for IGP2 and IGP3 PHYs */
1135         if (hw->phy_type == e1000_phy_igp) {
1136                 /* disable lplu d3 during driver init */
1137                 ret_val = e1000_set_d3_lplu_state(hw, false);
1138                 if (ret_val) {
1139                         e_dbg("Error Disabling LPLU D3\n");
1140                         return ret_val;
1141                 }
1142         }
1143
1144         /* Configure mdi-mdix settings */
1145         ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, &phy_data);
1146         if (ret_val)
1147                 return ret_val;
1148
1149         if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
1150                 hw->dsp_config_state = e1000_dsp_config_disabled;
1151                 /* Force MDI for earlier revs of the IGP PHY */
1152                 phy_data &=
1153                     ~(IGP01E1000_PSCR_AUTO_MDIX |
1154                       IGP01E1000_PSCR_FORCE_MDI_MDIX);
1155                 hw->mdix = 1;
1156
1157         } else {
1158                 hw->dsp_config_state = e1000_dsp_config_enabled;
1159                 phy_data &= ~IGP01E1000_PSCR_AUTO_MDIX;
1160
1161                 switch (hw->mdix) {
1162                 case 1:
1163                         phy_data &= ~IGP01E1000_PSCR_FORCE_MDI_MDIX;
1164                         break;
1165                 case 2:
1166                         phy_data |= IGP01E1000_PSCR_FORCE_MDI_MDIX;
1167                         break;
1168                 case 0:
1169                 default:
1170                         phy_data |= IGP01E1000_PSCR_AUTO_MDIX;
1171                         break;
1172                 }
1173         }
1174         ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, phy_data);
1175         if (ret_val)
1176                 return ret_val;
1177
1178         /* set auto-master slave resolution settings */
1179         if (hw->autoneg) {
1180                 e1000_ms_type phy_ms_setting = hw->master_slave;
1181
1182                 if (hw->ffe_config_state == e1000_ffe_config_active)
1183                         hw->ffe_config_state = e1000_ffe_config_enabled;
1184
1185                 if (hw->dsp_config_state == e1000_dsp_config_activated)
1186                         hw->dsp_config_state = e1000_dsp_config_enabled;
1187
1188                 /* when autonegotiation advertisement is only 1000Mbps then we
1189                  * should disable SmartSpeed and enable Auto MasterSlave
1190                  * resolution as hardware default.
1191                  */
1192                 if (hw->autoneg_advertised == ADVERTISE_1000_FULL) {
1193                         /* Disable SmartSpeed */
1194                         ret_val =
1195                             e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
1196                                                &phy_data);
1197                         if (ret_val)
1198                                 return ret_val;
1199                         phy_data &= ~IGP01E1000_PSCFR_SMART_SPEED;
1200                         ret_val =
1201                             e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
1202                                                 phy_data);
1203                         if (ret_val)
1204                                 return ret_val;
1205                         /* Set auto Master/Slave resolution process */
1206                         ret_val =
1207                             e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_data);
1208                         if (ret_val)
1209                                 return ret_val;
1210                         phy_data &= ~CR_1000T_MS_ENABLE;
1211                         ret_val =
1212                             e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_data);
1213                         if (ret_val)
1214                                 return ret_val;
1215                 }
1216
1217                 ret_val = e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_data);
1218                 if (ret_val)
1219                         return ret_val;
1220
1221                 /* load defaults for future use */
1222                 hw->original_master_slave = (phy_data & CR_1000T_MS_ENABLE) ?
1223                     ((phy_data & CR_1000T_MS_VALUE) ?
1224                      e1000_ms_force_master :
1225                      e1000_ms_force_slave) : e1000_ms_auto;
1226
1227                 switch (phy_ms_setting) {
1228                 case e1000_ms_force_master:
1229                         phy_data |= (CR_1000T_MS_ENABLE | CR_1000T_MS_VALUE);
1230                         break;
1231                 case e1000_ms_force_slave:
1232                         phy_data |= CR_1000T_MS_ENABLE;
1233                         phy_data &= ~(CR_1000T_MS_VALUE);
1234                         break;
1235                 case e1000_ms_auto:
1236                         phy_data &= ~CR_1000T_MS_ENABLE;
1237                 default:
1238                         break;
1239                 }
1240                 ret_val = e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_data);
1241                 if (ret_val)
1242                         return ret_val;
1243         }
1244
1245         return E1000_SUCCESS;
1246 }
1247
1248 /**
1249  * e1000_copper_link_mgp_setup - Copper link setup for e1000_phy_m88 series.
1250  * @hw: Struct containing variables accessed by shared code
1251  */
1252 static s32 e1000_copper_link_mgp_setup(struct e1000_hw *hw)
1253 {
1254         s32 ret_val;
1255         u16 phy_data;
1256
1257         e_dbg("e1000_copper_link_mgp_setup");
1258
1259         if (hw->phy_reset_disable)
1260                 return E1000_SUCCESS;
1261
1262         /* Enable CRS on TX. This must be set for half-duplex operation. */
1263         ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1264         if (ret_val)
1265                 return ret_val;
1266
1267         phy_data |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
1268
1269         /* Options:
1270          *   MDI/MDI-X = 0 (default)
1271          *   0 - Auto for all speeds
1272          *   1 - MDI mode
1273          *   2 - MDI-X mode
1274          *   3 - Auto for 1000Base-T only (MDI-X for 10/100Base-T modes)
1275          */
1276         phy_data &= ~M88E1000_PSCR_AUTO_X_MODE;
1277
1278         switch (hw->mdix) {
1279         case 1:
1280                 phy_data |= M88E1000_PSCR_MDI_MANUAL_MODE;
1281                 break;
1282         case 2:
1283                 phy_data |= M88E1000_PSCR_MDIX_MANUAL_MODE;
1284                 break;
1285         case 3:
1286                 phy_data |= M88E1000_PSCR_AUTO_X_1000T;
1287                 break;
1288         case 0:
1289         default:
1290                 phy_data |= M88E1000_PSCR_AUTO_X_MODE;
1291                 break;
1292         }
1293
1294         /* Options:
1295          *   disable_polarity_correction = 0 (default)
1296          *       Automatic Correction for Reversed Cable Polarity
1297          *   0 - Disabled
1298          *   1 - Enabled
1299          */
1300         phy_data &= ~M88E1000_PSCR_POLARITY_REVERSAL;
1301         if (hw->disable_polarity_correction == 1)
1302                 phy_data |= M88E1000_PSCR_POLARITY_REVERSAL;
1303         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1304         if (ret_val)
1305                 return ret_val;
1306
1307         if (hw->phy_revision < M88E1011_I_REV_4) {
1308                 /* Force TX_CLK in the Extended PHY Specific Control Register
1309                  * to 25MHz clock.
1310                  */
1311                 ret_val =
1312                     e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL,
1313                                        &phy_data);
1314                 if (ret_val)
1315                         return ret_val;
1316
1317                 phy_data |= M88E1000_EPSCR_TX_CLK_25;
1318
1319                 if ((hw->phy_revision == E1000_REVISION_2) &&
1320                     (hw->phy_id == M88E1111_I_PHY_ID)) {
1321                         /* Vidalia Phy, set the downshift counter to 5x */
1322                         phy_data &= ~(M88EC018_EPSCR_DOWNSHIFT_COUNTER_MASK);
1323                         phy_data |= M88EC018_EPSCR_DOWNSHIFT_COUNTER_5X;
1324                         ret_val = e1000_write_phy_reg(hw,
1325                                                       M88E1000_EXT_PHY_SPEC_CTRL,
1326                                                       phy_data);
1327                         if (ret_val)
1328                                 return ret_val;
1329                 } else {
1330                         /* Configure Master and Slave downshift values */
1331                         phy_data &= ~(M88E1000_EPSCR_MASTER_DOWNSHIFT_MASK |
1332                                       M88E1000_EPSCR_SLAVE_DOWNSHIFT_MASK);
1333                         phy_data |= (M88E1000_EPSCR_MASTER_DOWNSHIFT_1X |
1334                                      M88E1000_EPSCR_SLAVE_DOWNSHIFT_1X);
1335                         ret_val = e1000_write_phy_reg(hw,
1336                                                       M88E1000_EXT_PHY_SPEC_CTRL,
1337                                                       phy_data);
1338                         if (ret_val)
1339                                 return ret_val;
1340                 }
1341         }
1342
1343         /* SW Reset the PHY so all changes take effect */
1344         ret_val = e1000_phy_reset(hw);
1345         if (ret_val) {
1346                 e_dbg("Error Resetting the PHY\n");
1347                 return ret_val;
1348         }
1349
1350         return E1000_SUCCESS;
1351 }
1352
1353 /**
1354  * e1000_copper_link_autoneg - setup auto-neg
1355  * @hw: Struct containing variables accessed by shared code
1356  *
1357  * Setup auto-negotiation and flow control advertisements,
1358  * and then perform auto-negotiation.
1359  */
1360 static s32 e1000_copper_link_autoneg(struct e1000_hw *hw)
1361 {
1362         s32 ret_val;
1363         u16 phy_data;
1364
1365         e_dbg("e1000_copper_link_autoneg");
1366
1367         /* Perform some bounds checking on the hw->autoneg_advertised
1368          * parameter.  If this variable is zero, then set it to the default.
1369          */
1370         hw->autoneg_advertised &= AUTONEG_ADVERTISE_SPEED_DEFAULT;
1371
1372         /* If autoneg_advertised is zero, we assume it was not defaulted
1373          * by the calling code so we set to advertise full capability.
1374          */
1375         if (hw->autoneg_advertised == 0)
1376                 hw->autoneg_advertised = AUTONEG_ADVERTISE_SPEED_DEFAULT;
1377
1378         /* IFE/RTL8201N PHY only supports 10/100 */
1379         if (hw->phy_type == e1000_phy_8201)
1380                 hw->autoneg_advertised &= AUTONEG_ADVERTISE_10_100_ALL;
1381
1382         e_dbg("Reconfiguring auto-neg advertisement params\n");
1383         ret_val = e1000_phy_setup_autoneg(hw);
1384         if (ret_val) {
1385                 e_dbg("Error Setting up Auto-Negotiation\n");
1386                 return ret_val;
1387         }
1388         e_dbg("Restarting Auto-Neg\n");
1389
1390         /* Restart auto-negotiation by setting the Auto Neg Enable bit and
1391          * the Auto Neg Restart bit in the PHY control register.
1392          */
1393         ret_val = e1000_read_phy_reg(hw, PHY_CTRL, &phy_data);
1394         if (ret_val)
1395                 return ret_val;
1396
1397         phy_data |= (MII_CR_AUTO_NEG_EN | MII_CR_RESTART_AUTO_NEG);
1398         ret_val = e1000_write_phy_reg(hw, PHY_CTRL, phy_data);
1399         if (ret_val)
1400                 return ret_val;
1401
1402         /* Does the user want to wait for Auto-Neg to complete here, or
1403          * check at a later time (for example, callback routine).
1404          */
1405         if (hw->wait_autoneg_complete) {
1406                 ret_val = e1000_wait_autoneg(hw);
1407                 if (ret_val) {
1408                         e_dbg
1409                             ("Error while waiting for autoneg to complete\n");
1410                         return ret_val;
1411                 }
1412         }
1413
1414         hw->get_link_status = true;
1415
1416         return E1000_SUCCESS;
1417 }
1418
1419 /**
1420  * e1000_copper_link_postconfig - post link setup
1421  * @hw: Struct containing variables accessed by shared code
1422  *
1423  * Config the MAC and the PHY after link is up.
1424  *   1) Set up the MAC to the current PHY speed/duplex
1425  *      if we are on 82543.  If we
1426  *      are on newer silicon, we only need to configure
1427  *      collision distance in the Transmit Control Register.
1428  *   2) Set up flow control on the MAC to that established with
1429  *      the link partner.
1430  *   3) Config DSP to improve Gigabit link quality for some PHY revisions.
1431  */
1432 static s32 e1000_copper_link_postconfig(struct e1000_hw *hw)
1433 {
1434         s32 ret_val;
1435         e_dbg("e1000_copper_link_postconfig");
1436
1437         if ((hw->mac_type >= e1000_82544) && (hw->mac_type != e1000_ce4100)) {
1438                 e1000_config_collision_dist(hw);
1439         } else {
1440                 ret_val = e1000_config_mac_to_phy(hw);
1441                 if (ret_val) {
1442                         e_dbg("Error configuring MAC to PHY settings\n");
1443                         return ret_val;
1444                 }
1445         }
1446         ret_val = e1000_config_fc_after_link_up(hw);
1447         if (ret_val) {
1448                 e_dbg("Error Configuring Flow Control\n");
1449                 return ret_val;
1450         }
1451
1452         /* Config DSP to improve Giga link quality */
1453         if (hw->phy_type == e1000_phy_igp) {
1454                 ret_val = e1000_config_dsp_after_link_change(hw, true);
1455                 if (ret_val) {
1456                         e_dbg("Error Configuring DSP after link up\n");
1457                         return ret_val;
1458                 }
1459         }
1460
1461         return E1000_SUCCESS;
1462 }
1463
1464 /**
1465  * e1000_setup_copper_link - phy/speed/duplex setting
1466  * @hw: Struct containing variables accessed by shared code
1467  *
1468  * Detects which PHY is present and sets up the speed and duplex
1469  */
1470 static s32 e1000_setup_copper_link(struct e1000_hw *hw)
1471 {
1472         s32 ret_val;
1473         u16 i;
1474         u16 phy_data;
1475
1476         e_dbg("e1000_setup_copper_link");
1477
1478         /* Check if it is a valid PHY and set PHY mode if necessary. */
1479         ret_val = e1000_copper_link_preconfig(hw);
1480         if (ret_val)
1481                 return ret_val;
1482
1483         if (hw->phy_type == e1000_phy_igp) {
1484                 ret_val = e1000_copper_link_igp_setup(hw);
1485                 if (ret_val)
1486                         return ret_val;
1487         } else if (hw->phy_type == e1000_phy_m88) {
1488                 ret_val = e1000_copper_link_mgp_setup(hw);
1489                 if (ret_val)
1490                         return ret_val;
1491         } else {
1492                 ret_val = gbe_dhg_phy_setup(hw);
1493                 if (ret_val) {
1494                         e_dbg("gbe_dhg_phy_setup failed!\n");
1495                         return ret_val;
1496                 }
1497         }
1498
1499         if (hw->autoneg) {
1500                 /* Setup autoneg and flow control advertisement
1501                  * and perform autonegotiation
1502                  */
1503                 ret_val = e1000_copper_link_autoneg(hw);
1504                 if (ret_val)
1505                         return ret_val;
1506         } else {
1507                 /* PHY will be set to 10H, 10F, 100H,or 100F
1508                  * depending on value from forced_speed_duplex.
1509                  */
1510                 e_dbg("Forcing speed and duplex\n");
1511                 ret_val = e1000_phy_force_speed_duplex(hw);
1512                 if (ret_val) {
1513                         e_dbg("Error Forcing Speed and Duplex\n");
1514                         return ret_val;
1515                 }
1516         }
1517
1518         /* Check link status. Wait up to 100 microseconds for link to become
1519          * valid.
1520          */
1521         for (i = 0; i < 10; i++) {
1522                 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
1523                 if (ret_val)
1524                         return ret_val;
1525                 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
1526                 if (ret_val)
1527                         return ret_val;
1528
1529                 if (phy_data & MII_SR_LINK_STATUS) {
1530                         /* Config the MAC and PHY after link is up */
1531                         ret_val = e1000_copper_link_postconfig(hw);
1532                         if (ret_val)
1533                                 return ret_val;
1534
1535                         e_dbg("Valid link established!!!\n");
1536                         return E1000_SUCCESS;
1537                 }
1538                 udelay(10);
1539         }
1540
1541         e_dbg("Unable to establish link!!!\n");
1542         return E1000_SUCCESS;
1543 }
1544
1545 /**
1546  * e1000_phy_setup_autoneg - phy settings
1547  * @hw: Struct containing variables accessed by shared code
1548  *
1549  * Configures PHY autoneg and flow control advertisement settings
1550  */
1551 s32 e1000_phy_setup_autoneg(struct e1000_hw *hw)
1552 {
1553         s32 ret_val;
1554         u16 mii_autoneg_adv_reg;
1555         u16 mii_1000t_ctrl_reg;
1556
1557         e_dbg("e1000_phy_setup_autoneg");
1558
1559         /* Read the MII Auto-Neg Advertisement Register (Address 4). */
1560         ret_val = e1000_read_phy_reg(hw, PHY_AUTONEG_ADV, &mii_autoneg_adv_reg);
1561         if (ret_val)
1562                 return ret_val;
1563
1564         /* Read the MII 1000Base-T Control Register (Address 9). */
1565         ret_val = e1000_read_phy_reg(hw, PHY_1000T_CTRL, &mii_1000t_ctrl_reg);
1566         if (ret_val)
1567                 return ret_val;
1568         else if (hw->phy_type == e1000_phy_8201)
1569                 mii_1000t_ctrl_reg &= ~REG9_SPEED_MASK;
1570
1571         /* Need to parse both autoneg_advertised and fc and set up
1572          * the appropriate PHY registers.  First we will parse for
1573          * autoneg_advertised software override.  Since we can advertise
1574          * a plethora of combinations, we need to check each bit
1575          * individually.
1576          */
1577
1578         /* First we clear all the 10/100 mb speed bits in the Auto-Neg
1579          * Advertisement Register (Address 4) and the 1000 mb speed bits in
1580          * the  1000Base-T Control Register (Address 9).
1581          */
1582         mii_autoneg_adv_reg &= ~REG4_SPEED_MASK;
1583         mii_1000t_ctrl_reg &= ~REG9_SPEED_MASK;
1584
1585         e_dbg("autoneg_advertised %x\n", hw->autoneg_advertised);
1586
1587         /* Do we want to advertise 10 Mb Half Duplex? */
1588         if (hw->autoneg_advertised & ADVERTISE_10_HALF) {
1589                 e_dbg("Advertise 10mb Half duplex\n");
1590                 mii_autoneg_adv_reg |= NWAY_AR_10T_HD_CAPS;
1591         }
1592
1593         /* Do we want to advertise 10 Mb Full Duplex? */
1594         if (hw->autoneg_advertised & ADVERTISE_10_FULL) {
1595                 e_dbg("Advertise 10mb Full duplex\n");
1596                 mii_autoneg_adv_reg |= NWAY_AR_10T_FD_CAPS;
1597         }
1598
1599         /* Do we want to advertise 100 Mb Half Duplex? */
1600         if (hw->autoneg_advertised & ADVERTISE_100_HALF) {
1601                 e_dbg("Advertise 100mb Half duplex\n");
1602                 mii_autoneg_adv_reg |= NWAY_AR_100TX_HD_CAPS;
1603         }
1604
1605         /* Do we want to advertise 100 Mb Full Duplex? */
1606         if (hw->autoneg_advertised & ADVERTISE_100_FULL) {
1607                 e_dbg("Advertise 100mb Full duplex\n");
1608                 mii_autoneg_adv_reg |= NWAY_AR_100TX_FD_CAPS;
1609         }
1610
1611         /* We do not allow the Phy to advertise 1000 Mb Half Duplex */
1612         if (hw->autoneg_advertised & ADVERTISE_1000_HALF) {
1613                 e_dbg
1614                     ("Advertise 1000mb Half duplex requested, request denied!\n");
1615         }
1616
1617         /* Do we want to advertise 1000 Mb Full Duplex? */
1618         if (hw->autoneg_advertised & ADVERTISE_1000_FULL) {
1619                 e_dbg("Advertise 1000mb Full duplex\n");
1620                 mii_1000t_ctrl_reg |= CR_1000T_FD_CAPS;
1621         }
1622
1623         /* Check for a software override of the flow control settings, and
1624          * setup the PHY advertisement registers accordingly.  If
1625          * auto-negotiation is enabled, then software will have to set the
1626          * "PAUSE" bits to the correct value in the Auto-Negotiation
1627          * Advertisement Register (PHY_AUTONEG_ADV) and re-start
1628          * auto-negotiation.
1629          *
1630          * The possible values of the "fc" parameter are:
1631          *      0:  Flow control is completely disabled
1632          *      1:  Rx flow control is enabled (we can receive pause frames
1633          *          but not send pause frames).
1634          *      2:  Tx flow control is enabled (we can send pause frames
1635          *          but we do not support receiving pause frames).
1636          *      3:  Both Rx and TX flow control (symmetric) are enabled.
1637          *  other:  No software override.  The flow control configuration
1638          *          in the EEPROM is used.
1639          */
1640         switch (hw->fc) {
1641         case E1000_FC_NONE:     /* 0 */
1642                 /* Flow control (RX & TX) is completely disabled by a
1643                  * software over-ride.
1644                  */
1645                 mii_autoneg_adv_reg &= ~(NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
1646                 break;
1647         case E1000_FC_RX_PAUSE: /* 1 */
1648                 /* RX Flow control is enabled, and TX Flow control is
1649                  * disabled, by a software over-ride.
1650                  */
1651                 /* Since there really isn't a way to advertise that we are
1652                  * capable of RX Pause ONLY, we will advertise that we
1653                  * support both symmetric and asymmetric RX PAUSE.  Later
1654                  * (in e1000_config_fc_after_link_up) we will disable the
1655                  * hw's ability to send PAUSE frames.
1656                  */
1657                 mii_autoneg_adv_reg |= (NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
1658                 break;
1659         case E1000_FC_TX_PAUSE: /* 2 */
1660                 /* TX Flow control is enabled, and RX Flow control is
1661                  * disabled, by a software over-ride.
1662                  */
1663                 mii_autoneg_adv_reg |= NWAY_AR_ASM_DIR;
1664                 mii_autoneg_adv_reg &= ~NWAY_AR_PAUSE;
1665                 break;
1666         case E1000_FC_FULL:     /* 3 */
1667                 /* Flow control (both RX and TX) is enabled by a software
1668                  * over-ride.
1669                  */
1670                 mii_autoneg_adv_reg |= (NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
1671                 break;
1672         default:
1673                 e_dbg("Flow control param set incorrectly\n");
1674                 return -E1000_ERR_CONFIG;
1675         }
1676
1677         ret_val = e1000_write_phy_reg(hw, PHY_AUTONEG_ADV, mii_autoneg_adv_reg);
1678         if (ret_val)
1679                 return ret_val;
1680
1681         e_dbg("Auto-Neg Advertising %x\n", mii_autoneg_adv_reg);
1682
1683         if (hw->phy_type == e1000_phy_8201) {
1684                 mii_1000t_ctrl_reg = 0;
1685         } else {
1686                 ret_val = e1000_write_phy_reg(hw, PHY_1000T_CTRL,
1687                                               mii_1000t_ctrl_reg);
1688                 if (ret_val)
1689                         return ret_val;
1690         }
1691
1692         return E1000_SUCCESS;
1693 }
1694
1695 /**
1696  * e1000_phy_force_speed_duplex - force link settings
1697  * @hw: Struct containing variables accessed by shared code
1698  *
1699  * Force PHY speed and duplex settings to hw->forced_speed_duplex
1700  */
1701 static s32 e1000_phy_force_speed_duplex(struct e1000_hw *hw)
1702 {
1703         u32 ctrl;
1704         s32 ret_val;
1705         u16 mii_ctrl_reg;
1706         u16 mii_status_reg;
1707         u16 phy_data;
1708         u16 i;
1709
1710         e_dbg("e1000_phy_force_speed_duplex");
1711
1712         /* Turn off Flow control if we are forcing speed and duplex. */
1713         hw->fc = E1000_FC_NONE;
1714
1715         e_dbg("hw->fc = %d\n", hw->fc);
1716
1717         /* Read the Device Control Register. */
1718         ctrl = er32(CTRL);
1719
1720         /* Set the bits to Force Speed and Duplex in the Device Ctrl Reg. */
1721         ctrl |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1722         ctrl &= ~(DEVICE_SPEED_MASK);
1723
1724         /* Clear the Auto Speed Detect Enable bit. */
1725         ctrl &= ~E1000_CTRL_ASDE;
1726
1727         /* Read the MII Control Register. */
1728         ret_val = e1000_read_phy_reg(hw, PHY_CTRL, &mii_ctrl_reg);
1729         if (ret_val)
1730                 return ret_val;
1731
1732         /* We need to disable autoneg in order to force link and duplex. */
1733
1734         mii_ctrl_reg &= ~MII_CR_AUTO_NEG_EN;
1735
1736         /* Are we forcing Full or Half Duplex? */
1737         if (hw->forced_speed_duplex == e1000_100_full ||
1738             hw->forced_speed_duplex == e1000_10_full) {
1739                 /* We want to force full duplex so we SET the full duplex bits
1740                  * in the Device and MII Control Registers.
1741                  */
1742                 ctrl |= E1000_CTRL_FD;
1743                 mii_ctrl_reg |= MII_CR_FULL_DUPLEX;
1744                 e_dbg("Full Duplex\n");
1745         } else {
1746                 /* We want to force half duplex so we CLEAR the full duplex bits
1747                  * in the Device and MII Control Registers.
1748                  */
1749                 ctrl &= ~E1000_CTRL_FD;
1750                 mii_ctrl_reg &= ~MII_CR_FULL_DUPLEX;
1751                 e_dbg("Half Duplex\n");
1752         }
1753
1754         /* Are we forcing 100Mbps??? */
1755         if (hw->forced_speed_duplex == e1000_100_full ||
1756             hw->forced_speed_duplex == e1000_100_half) {
1757                 /* Set the 100Mb bit and turn off the 1000Mb and 10Mb bits. */
1758                 ctrl |= E1000_CTRL_SPD_100;
1759                 mii_ctrl_reg |= MII_CR_SPEED_100;
1760                 mii_ctrl_reg &= ~(MII_CR_SPEED_1000 | MII_CR_SPEED_10);
1761                 e_dbg("Forcing 100mb ");
1762         } else {
1763                 /* Set the 10Mb bit and turn off the 1000Mb and 100Mb bits. */
1764                 ctrl &= ~(E1000_CTRL_SPD_1000 | E1000_CTRL_SPD_100);
1765                 mii_ctrl_reg |= MII_CR_SPEED_10;
1766                 mii_ctrl_reg &= ~(MII_CR_SPEED_1000 | MII_CR_SPEED_100);
1767                 e_dbg("Forcing 10mb ");
1768         }
1769
1770         e1000_config_collision_dist(hw);
1771
1772         /* Write the configured values back to the Device Control Reg. */
1773         ew32(CTRL, ctrl);
1774
1775         if (hw->phy_type == e1000_phy_m88) {
1776                 ret_val =
1777                     e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1778                 if (ret_val)
1779                         return ret_val;
1780
1781                 /* Clear Auto-Crossover to force MDI manually. M88E1000 requires
1782                  * MDI forced whenever speed are duplex are forced.
1783                  */
1784                 phy_data &= ~M88E1000_PSCR_AUTO_X_MODE;
1785                 ret_val =
1786                     e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1787                 if (ret_val)
1788                         return ret_val;
1789
1790                 e_dbg("M88E1000 PSCR: %x\n", phy_data);
1791
1792                 /* Need to reset the PHY or these changes will be ignored */
1793                 mii_ctrl_reg |= MII_CR_RESET;
1794
1795                 /* Disable MDI-X support for 10/100 */
1796         } else {
1797                 /* Clear Auto-Crossover to force MDI manually.  IGP requires MDI
1798                  * forced whenever speed or duplex are forced.
1799                  */
1800                 ret_val =
1801                     e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, &phy_data);
1802                 if (ret_val)
1803                         return ret_val;
1804
1805                 phy_data &= ~IGP01E1000_PSCR_AUTO_MDIX;
1806                 phy_data &= ~IGP01E1000_PSCR_FORCE_MDI_MDIX;
1807
1808                 ret_val =
1809                     e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, phy_data);
1810                 if (ret_val)
1811                         return ret_val;
1812         }
1813
1814         /* Write back the modified PHY MII control register. */
1815         ret_val = e1000_write_phy_reg(hw, PHY_CTRL, mii_ctrl_reg);
1816         if (ret_val)
1817                 return ret_val;
1818
1819         udelay(1);
1820
1821         /* The wait_autoneg_complete flag may be a little misleading here.
1822          * Since we are forcing speed and duplex, Auto-Neg is not enabled.
1823          * But we do want to delay for a period while forcing only so we
1824          * don't generate false No Link messages.  So we will wait here
1825          * only if the user has set wait_autoneg_complete to 1, which is
1826          * the default.
1827          */
1828         if (hw->wait_autoneg_complete) {
1829                 /* We will wait for autoneg to complete. */
1830                 e_dbg("Waiting for forced speed/duplex link.\n");
1831                 mii_status_reg = 0;
1832
1833                 /* Wait for autoneg to complete or 4.5 seconds to expire */
1834                 for (i = PHY_FORCE_TIME; i > 0; i--) {
1835                         /* Read the MII Status Register and wait for Auto-Neg
1836                          * Complete bit to be set.
1837                          */
1838                         ret_val =
1839                             e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
1840                         if (ret_val)
1841                                 return ret_val;
1842
1843                         ret_val =
1844                             e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
1845                         if (ret_val)
1846                                 return ret_val;
1847
1848                         if (mii_status_reg & MII_SR_LINK_STATUS)
1849                                 break;
1850                         msleep(100);
1851                 }
1852                 if ((i == 0) && (hw->phy_type == e1000_phy_m88)) {
1853                         /* We didn't get link.  Reset the DSP and wait again
1854                          * for link.
1855                          */
1856                         ret_val = e1000_phy_reset_dsp(hw);
1857                         if (ret_val) {
1858                                 e_dbg("Error Resetting PHY DSP\n");
1859                                 return ret_val;
1860                         }
1861                 }
1862                 /* This loop will early-out if the link condition has been
1863                  * met
1864                  */
1865                 for (i = PHY_FORCE_TIME; i > 0; i--) {
1866                         if (mii_status_reg & MII_SR_LINK_STATUS)
1867                                 break;
1868                         msleep(100);
1869                         /* Read the MII Status Register and wait for Auto-Neg
1870                          * Complete bit to be set.
1871                          */
1872                         ret_val =
1873                             e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
1874                         if (ret_val)
1875                                 return ret_val;
1876
1877                         ret_val =
1878                             e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
1879                         if (ret_val)
1880                                 return ret_val;
1881                 }
1882         }
1883
1884         if (hw->phy_type == e1000_phy_m88) {
1885                 /* Because we reset the PHY above, we need to re-force TX_CLK in
1886                  * the Extended PHY Specific Control Register to 25MHz clock.
1887                  * This value defaults back to a 2.5MHz clock when the PHY is
1888                  * reset.
1889                  */
1890                 ret_val =
1891                     e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL,
1892                                        &phy_data);
1893                 if (ret_val)
1894                         return ret_val;
1895
1896                 phy_data |= M88E1000_EPSCR_TX_CLK_25;
1897                 ret_val =
1898                     e1000_write_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL,
1899                                         phy_data);
1900                 if (ret_val)
1901                         return ret_val;
1902
1903                 /* In addition, because of the s/w reset above, we need to
1904                  * enable CRS on Tx.  This must be set for both full and half
1905                  * duplex operation.
1906                  */
1907                 ret_val =
1908                     e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1909                 if (ret_val)
1910                         return ret_val;
1911
1912                 phy_data |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
1913                 ret_val =
1914                     e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1915                 if (ret_val)
1916                         return ret_val;
1917
1918                 if ((hw->mac_type == e1000_82544 || hw->mac_type == e1000_82543)
1919                     && (!hw->autoneg)
1920                     && (hw->forced_speed_duplex == e1000_10_full
1921                         || hw->forced_speed_duplex == e1000_10_half)) {
1922                         ret_val = e1000_polarity_reversal_workaround(hw);
1923                         if (ret_val)
1924                                 return ret_val;
1925                 }
1926         }
1927         return E1000_SUCCESS;
1928 }
1929
1930 /**
1931  * e1000_config_collision_dist - set collision distance register
1932  * @hw: Struct containing variables accessed by shared code
1933  *
1934  * Sets the collision distance in the Transmit Control register.
1935  * Link should have been established previously. Reads the speed and duplex
1936  * information from the Device Status register.
1937  */
1938 void e1000_config_collision_dist(struct e1000_hw *hw)
1939 {
1940         u32 tctl, coll_dist;
1941
1942         e_dbg("e1000_config_collision_dist");
1943
1944         if (hw->mac_type < e1000_82543)
1945                 coll_dist = E1000_COLLISION_DISTANCE_82542;
1946         else
1947                 coll_dist = E1000_COLLISION_DISTANCE;
1948
1949         tctl = er32(TCTL);
1950
1951         tctl &= ~E1000_TCTL_COLD;
1952         tctl |= coll_dist << E1000_COLD_SHIFT;
1953
1954         ew32(TCTL, tctl);
1955         E1000_WRITE_FLUSH();
1956 }
1957
1958 /**
1959  * e1000_config_mac_to_phy - sync phy and mac settings
1960  * @hw: Struct containing variables accessed by shared code
1961  * @mii_reg: data to write to the MII control register
1962  *
1963  * Sets MAC speed and duplex settings to reflect the those in the PHY
1964  * The contents of the PHY register containing the needed information need to
1965  * be passed in.
1966  */
1967 static s32 e1000_config_mac_to_phy(struct e1000_hw *hw)
1968 {
1969         u32 ctrl;
1970         s32 ret_val;
1971         u16 phy_data;
1972
1973         e_dbg("e1000_config_mac_to_phy");
1974
1975         /* 82544 or newer MAC, Auto Speed Detection takes care of
1976          * MAC speed/duplex configuration.
1977          */
1978         if ((hw->mac_type >= e1000_82544) && (hw->mac_type != e1000_ce4100))
1979                 return E1000_SUCCESS;
1980
1981         /* Read the Device Control Register and set the bits to Force Speed
1982          * and Duplex.
1983          */
1984         ctrl = er32(CTRL);
1985         ctrl |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1986         ctrl &= ~(E1000_CTRL_SPD_SEL | E1000_CTRL_ILOS);
1987
1988         switch (hw->phy_type) {
1989         case e1000_phy_8201:
1990                 ret_val = e1000_read_phy_reg(hw, PHY_CTRL, &phy_data);
1991                 if (ret_val)
1992                         return ret_val;
1993
1994                 if (phy_data & RTL_PHY_CTRL_FD)
1995                         ctrl |= E1000_CTRL_FD;
1996                 else
1997                         ctrl &= ~E1000_CTRL_FD;
1998
1999                 if (phy_data & RTL_PHY_CTRL_SPD_100)
2000                         ctrl |= E1000_CTRL_SPD_100;
2001                 else
2002                         ctrl |= E1000_CTRL_SPD_10;
2003
2004                 e1000_config_collision_dist(hw);
2005                 break;
2006         default:
2007                 /* Set up duplex in the Device Control and Transmit Control
2008                  * registers depending on negotiated values.
2009                  */
2010                 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS,
2011                                              &phy_data);
2012                 if (ret_val)
2013                         return ret_val;
2014
2015                 if (phy_data & M88E1000_PSSR_DPLX)
2016                         ctrl |= E1000_CTRL_FD;
2017                 else
2018                         ctrl &= ~E1000_CTRL_FD;
2019
2020                 e1000_config_collision_dist(hw);
2021
2022                 /* Set up speed in the Device Control register depending on
2023                  * negotiated values.
2024                  */
2025                 if ((phy_data & M88E1000_PSSR_SPEED) == M88E1000_PSSR_1000MBS)
2026                         ctrl |= E1000_CTRL_SPD_1000;
2027                 else if ((phy_data & M88E1000_PSSR_SPEED) ==
2028                          M88E1000_PSSR_100MBS)
2029                         ctrl |= E1000_CTRL_SPD_100;
2030         }
2031
2032         /* Write the configured values back to the Device Control Reg. */
2033         ew32(CTRL, ctrl);
2034         return E1000_SUCCESS;
2035 }
2036
2037 /**
2038  * e1000_force_mac_fc - force flow control settings
2039  * @hw: Struct containing variables accessed by shared code
2040  *
2041  * Forces the MAC's flow control settings.
2042  * Sets the TFCE and RFCE bits in the device control register to reflect
2043  * the adapter settings. TFCE and RFCE need to be explicitly set by
2044  * software when a Copper PHY is used because autonegotiation is managed
2045  * by the PHY rather than the MAC. Software must also configure these
2046  * bits when link is forced on a fiber connection.
2047  */
2048 s32 e1000_force_mac_fc(struct e1000_hw *hw)
2049 {
2050         u32 ctrl;
2051
2052         e_dbg("e1000_force_mac_fc");
2053
2054         /* Get the current configuration of the Device Control Register */
2055         ctrl = er32(CTRL);
2056
2057         /* Because we didn't get link via the internal auto-negotiation
2058          * mechanism (we either forced link or we got link via PHY
2059          * auto-neg), we have to manually enable/disable transmit an
2060          * receive flow control.
2061          *
2062          * The "Case" statement below enables/disable flow control
2063          * according to the "hw->fc" parameter.
2064          *
2065          * The possible values of the "fc" parameter are:
2066          *      0:  Flow control is completely disabled
2067          *      1:  Rx flow control is enabled (we can receive pause
2068          *          frames but not send pause frames).
2069          *      2:  Tx flow control is enabled (we can send pause frames
2070          *          frames but we do not receive pause frames).
2071          *      3:  Both Rx and TX flow control (symmetric) is enabled.
2072          *  other:  No other values should be possible at this point.
2073          */
2074
2075         switch (hw->fc) {
2076         case E1000_FC_NONE:
2077                 ctrl &= (~(E1000_CTRL_TFCE | E1000_CTRL_RFCE));
2078                 break;
2079         case E1000_FC_RX_PAUSE:
2080                 ctrl &= (~E1000_CTRL_TFCE);
2081                 ctrl |= E1000_CTRL_RFCE;
2082                 break;
2083         case E1000_FC_TX_PAUSE:
2084                 ctrl &= (~E1000_CTRL_RFCE);
2085                 ctrl |= E1000_CTRL_TFCE;
2086                 break;
2087         case E1000_FC_FULL:
2088                 ctrl |= (E1000_CTRL_TFCE | E1000_CTRL_RFCE);
2089                 break;
2090         default:
2091                 e_dbg("Flow control param set incorrectly\n");
2092                 return -E1000_ERR_CONFIG;
2093         }
2094
2095         /* Disable TX Flow Control for 82542 (rev 2.0) */
2096         if (hw->mac_type == e1000_82542_rev2_0)
2097                 ctrl &= (~E1000_CTRL_TFCE);
2098
2099         ew32(CTRL, ctrl);
2100         return E1000_SUCCESS;
2101 }
2102
2103 /**
2104  * e1000_config_fc_after_link_up - configure flow control after autoneg
2105  * @hw: Struct containing variables accessed by shared code
2106  *
2107  * Configures flow control settings after link is established
2108  * Should be called immediately after a valid link has been established.
2109  * Forces MAC flow control settings if link was forced. When in MII/GMII mode
2110  * and autonegotiation is enabled, the MAC flow control settings will be set
2111  * based on the flow control negotiated by the PHY. In TBI mode, the TFCE
2112  * and RFCE bits will be automatically set to the negotiated flow control mode.
2113  */
2114 static s32 e1000_config_fc_after_link_up(struct e1000_hw *hw)
2115 {
2116         s32 ret_val;
2117         u16 mii_status_reg;
2118         u16 mii_nway_adv_reg;
2119         u16 mii_nway_lp_ability_reg;
2120         u16 speed;
2121         u16 duplex;
2122
2123         e_dbg("e1000_config_fc_after_link_up");
2124
2125         /* Check for the case where we have fiber media and auto-neg failed
2126          * so we had to force link.  In this case, we need to force the
2127          * configuration of the MAC to match the "fc" parameter.
2128          */
2129         if (((hw->media_type == e1000_media_type_fiber) && (hw->autoneg_failed))
2130             || ((hw->media_type == e1000_media_type_internal_serdes)
2131                 && (hw->autoneg_failed))
2132             || ((hw->media_type == e1000_media_type_copper)
2133                 && (!hw->autoneg))) {
2134                 ret_val = e1000_force_mac_fc(hw);
2135                 if (ret_val) {
2136                         e_dbg("Error forcing flow control settings\n");
2137                         return ret_val;
2138                 }
2139         }
2140
2141         /* Check for the case where we have copper media and auto-neg is
2142          * enabled.  In this case, we need to check and see if Auto-Neg
2143          * has completed, and if so, how the PHY and link partner has
2144          * flow control configured.
2145          */
2146         if ((hw->media_type == e1000_media_type_copper) && hw->autoneg) {
2147                 /* Read the MII Status Register and check to see if AutoNeg
2148                  * has completed.  We read this twice because this reg has
2149                  * some "sticky" (latched) bits.
2150                  */
2151                 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2152                 if (ret_val)
2153                         return ret_val;
2154                 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2155                 if (ret_val)
2156                         return ret_val;
2157
2158                 if (mii_status_reg & MII_SR_AUTONEG_COMPLETE) {
2159                         /* The AutoNeg process has completed, so we now need to
2160                          * read both the Auto Negotiation Advertisement Register
2161                          * (Address 4) and the Auto_Negotiation Base Page
2162                          * Ability Register (Address 5) to determine how flow
2163                          * control was negotiated.
2164                          */
2165                         ret_val = e1000_read_phy_reg(hw, PHY_AUTONEG_ADV,
2166                                                      &mii_nway_adv_reg);
2167                         if (ret_val)
2168                                 return ret_val;
2169                         ret_val = e1000_read_phy_reg(hw, PHY_LP_ABILITY,
2170                                                      &mii_nway_lp_ability_reg);
2171                         if (ret_val)
2172                                 return ret_val;
2173
2174                         /* Two bits in the Auto Negotiation Advertisement
2175                          * Register (Address 4) and two bits in the Auto
2176                          * Negotiation Base Page Ability Register (Address 5)
2177                          * determine flow control for both the PHY and the link
2178                          * partner.  The following table, taken out of the IEEE
2179                          * 802.3ab/D6.0 dated March 25, 1999, describes these
2180                          * PAUSE resolution bits and how flow control is
2181                          * determined based upon these settings.
2182                          * NOTE:  DC = Don't Care
2183                          *
2184                          *   LOCAL DEVICE  |   LINK PARTNER
2185                          * PAUSE | ASM_DIR | PAUSE | ASM_DIR | NIC Resolution
2186                          *-------|---------|-------|---------|------------------
2187                          *   0   |    0    |  DC   |   DC    | E1000_FC_NONE
2188                          *   0   |    1    |   0   |   DC    | E1000_FC_NONE
2189                          *   0   |    1    |   1   |    0    | E1000_FC_NONE
2190                          *   0   |    1    |   1   |    1    | E1000_FC_TX_PAUSE
2191                          *   1   |    0    |   0   |   DC    | E1000_FC_NONE
2192                          *   1   |   DC    |   1   |   DC    | E1000_FC_FULL
2193                          *   1   |    1    |   0   |    0    | E1000_FC_NONE
2194                          *   1   |    1    |   0   |    1    | E1000_FC_RX_PAUSE
2195                          *
2196                          */
2197                         /* Are both PAUSE bits set to 1?  If so, this implies
2198                          * Symmetric Flow Control is enabled at both ends.  The
2199                          * ASM_DIR bits are irrelevant per the spec.
2200                          *
2201                          * For Symmetric Flow Control:
2202                          *
2203                          *   LOCAL DEVICE  |   LINK PARTNER
2204                          * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
2205                          *-------|---------|-------|---------|------------------
2206                          *   1   |   DC    |   1   |   DC    | E1000_FC_FULL
2207                          *
2208                          */
2209                         if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
2210                             (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE)) {
2211                                 /* Now we need to check if the user selected Rx
2212                                  * ONLY of pause frames.  In this case, we had
2213                                  * to advertise FULL flow control because we
2214                                  * could not advertise Rx ONLY. Hence, we must
2215                                  * now check to see if we need to turn OFF the
2216                                  * TRANSMISSION of PAUSE frames.
2217                                  */
2218                                 if (hw->original_fc == E1000_FC_FULL) {
2219                                         hw->fc = E1000_FC_FULL;
2220                                         e_dbg("Flow Control = FULL.\n");
2221                                 } else {
2222                                         hw->fc = E1000_FC_RX_PAUSE;
2223                                         e_dbg
2224                                             ("Flow Control = RX PAUSE frames only.\n");
2225                                 }
2226                         }
2227                         /* For receiving PAUSE frames ONLY.
2228                          *
2229                          *   LOCAL DEVICE  |   LINK PARTNER
2230                          * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
2231                          *-------|---------|-------|---------|------------------
2232                          *   0   |    1    |   1   |    1    | E1000_FC_TX_PAUSE
2233                          *
2234                          */
2235                         else if (!(mii_nway_adv_reg & NWAY_AR_PAUSE) &&
2236                                  (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
2237                                  (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
2238                                  (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR))
2239                         {
2240                                 hw->fc = E1000_FC_TX_PAUSE;
2241                                 e_dbg
2242                                     ("Flow Control = TX PAUSE frames only.\n");
2243                         }
2244                         /* For transmitting PAUSE frames ONLY.
2245                          *
2246                          *   LOCAL DEVICE  |   LINK PARTNER
2247                          * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
2248                          *-------|---------|-------|---------|------------------
2249                          *   1   |    1    |   0   |    1    | E1000_FC_RX_PAUSE
2250                          *
2251                          */
2252                         else if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
2253                                  (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
2254                                  !(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
2255                                  (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR))
2256                         {
2257                                 hw->fc = E1000_FC_RX_PAUSE;
2258                                 e_dbg
2259                                     ("Flow Control = RX PAUSE frames only.\n");
2260                         }
2261                         /* Per the IEEE spec, at this point flow control should
2262                          * be disabled.  However, we want to consider that we
2263                          * could be connected to a legacy switch that doesn't
2264                          * advertise desired flow control, but can be forced on
2265                          * the link partner.  So if we advertised no flow
2266                          * control, that is what we will resolve to.  If we
2267                          * advertised some kind of receive capability (Rx Pause
2268                          * Only or Full Flow Control) and the link partner
2269                          * advertised none, we will configure ourselves to
2270                          * enable Rx Flow Control only.  We can do this safely
2271                          * for two reasons:  If the link partner really
2272                          * didn't want flow control enabled, and we enable Rx,
2273                          * no harm done since we won't be receiving any PAUSE
2274                          * frames anyway.  If the intent on the link partner was
2275                          * to have flow control enabled, then by us enabling Rx
2276                          * only, we can at least receive pause frames and
2277                          * process them. This is a good idea because in most
2278                          * cases, since we are predominantly a server NIC, more
2279                          * times than not we will be asked to delay transmission
2280                          * of packets than asking our link partner to pause
2281                          * transmission of frames.
2282                          */
2283                         else if ((hw->original_fc == E1000_FC_NONE ||
2284                                   hw->original_fc == E1000_FC_TX_PAUSE) ||
2285                                  hw->fc_strict_ieee) {
2286                                 hw->fc = E1000_FC_NONE;
2287                                 e_dbg("Flow Control = NONE.\n");
2288                         } else {
2289                                 hw->fc = E1000_FC_RX_PAUSE;
2290                                 e_dbg
2291                                     ("Flow Control = RX PAUSE frames only.\n");
2292                         }
2293
2294                         /* Now we need to do one last check...  If we auto-
2295                          * negotiated to HALF DUPLEX, flow control should not be
2296                          * enabled per IEEE 802.3 spec.
2297                          */
2298                         ret_val =
2299                             e1000_get_speed_and_duplex(hw, &speed, &duplex);
2300                         if (ret_val) {
2301                                 e_dbg
2302                                     ("Error getting link speed and duplex\n");
2303                                 return ret_val;
2304                         }
2305
2306                         if (duplex == HALF_DUPLEX)
2307                                 hw->fc = E1000_FC_NONE;
2308
2309                         /* Now we call a subroutine to actually force the MAC
2310                          * controller to use the correct flow control settings.
2311                          */
2312                         ret_val = e1000_force_mac_fc(hw);
2313                         if (ret_val) {
2314                                 e_dbg
2315                                     ("Error forcing flow control settings\n");
2316                                 return ret_val;
2317                         }
2318                 } else {
2319                         e_dbg
2320                             ("Copper PHY and Auto Neg has not completed.\n");
2321                 }
2322         }
2323         return E1000_SUCCESS;
2324 }
2325
2326 /**
2327  * e1000_check_for_serdes_link_generic - Check for link (Serdes)
2328  * @hw: pointer to the HW structure
2329  *
2330  * Checks for link up on the hardware.  If link is not up and we have
2331  * a signal, then we need to force link up.
2332  */
2333 static s32 e1000_check_for_serdes_link_generic(struct e1000_hw *hw)
2334 {
2335         u32 rxcw;
2336         u32 ctrl;
2337         u32 status;
2338         s32 ret_val = E1000_SUCCESS;
2339
2340         e_dbg("e1000_check_for_serdes_link_generic");
2341
2342         ctrl = er32(CTRL);
2343         status = er32(STATUS);
2344         rxcw = er32(RXCW);
2345
2346         /* If we don't have link (auto-negotiation failed or link partner
2347          * cannot auto-negotiate), and our link partner is not trying to
2348          * auto-negotiate with us (we are receiving idles or data),
2349          * we need to force link up. We also need to give auto-negotiation
2350          * time to complete.
2351          */
2352         /* (ctrl & E1000_CTRL_SWDPIN1) == 1 == have signal */
2353         if ((!(status & E1000_STATUS_LU)) && (!(rxcw & E1000_RXCW_C))) {
2354                 if (hw->autoneg_failed == 0) {
2355                         hw->autoneg_failed = 1;
2356                         goto out;
2357                 }
2358                 e_dbg("NOT RXing /C/, disable AutoNeg and force link.\n");
2359
2360                 /* Disable auto-negotiation in the TXCW register */
2361                 ew32(TXCW, (hw->txcw & ~E1000_TXCW_ANE));
2362
2363                 /* Force link-up and also force full-duplex. */
2364                 ctrl = er32(CTRL);
2365                 ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FD);
2366                 ew32(CTRL, ctrl);
2367
2368                 /* Configure Flow Control after forcing link up. */
2369                 ret_val = e1000_config_fc_after_link_up(hw);
2370                 if (ret_val) {
2371                         e_dbg("Error configuring flow control\n");
2372                         goto out;
2373                 }
2374         } else if ((ctrl & E1000_CTRL_SLU) && (rxcw & E1000_RXCW_C)) {
2375                 /* If we are forcing link and we are receiving /C/ ordered
2376                  * sets, re-enable auto-negotiation in the TXCW register
2377                  * and disable forced link in the Device Control register
2378                  * in an attempt to auto-negotiate with our link partner.
2379                  */
2380                 e_dbg("RXing /C/, enable AutoNeg and stop forcing link.\n");
2381                 ew32(TXCW, hw->txcw);
2382                 ew32(CTRL, (ctrl & ~E1000_CTRL_SLU));
2383
2384                 hw->serdes_has_link = true;
2385         } else if (!(E1000_TXCW_ANE & er32(TXCW))) {
2386                 /* If we force link for non-auto-negotiation switch, check
2387                  * link status based on MAC synchronization for internal
2388                  * serdes media type.
2389                  */
2390                 /* SYNCH bit and IV bit are sticky. */
2391                 udelay(10);
2392                 rxcw = er32(RXCW);
2393                 if (rxcw & E1000_RXCW_SYNCH) {
2394                         if (!(rxcw & E1000_RXCW_IV)) {
2395                                 hw->serdes_has_link = true;
2396                                 e_dbg("SERDES: Link up - forced.\n");
2397                         }
2398                 } else {
2399                         hw->serdes_has_link = false;
2400                         e_dbg("SERDES: Link down - force failed.\n");
2401                 }
2402         }
2403
2404         if (E1000_TXCW_ANE & er32(TXCW)) {
2405                 status = er32(STATUS);
2406                 if (status & E1000_STATUS_LU) {
2407                         /* SYNCH bit and IV bit are sticky, so reread rxcw. */
2408                         udelay(10);
2409                         rxcw = er32(RXCW);
2410                         if (rxcw & E1000_RXCW_SYNCH) {
2411                                 if (!(rxcw & E1000_RXCW_IV)) {
2412                                         hw->serdes_has_link = true;
2413                                         e_dbg("SERDES: Link up - autoneg "
2414                                                  "completed successfully.\n");
2415                                 } else {
2416                                         hw->serdes_has_link = false;
2417                                         e_dbg("SERDES: Link down - invalid"
2418                                                  "codewords detected in autoneg.\n");
2419                                 }
2420                         } else {
2421                                 hw->serdes_has_link = false;
2422                                 e_dbg("SERDES: Link down - no sync.\n");
2423                         }
2424                 } else {
2425                         hw->serdes_has_link = false;
2426                         e_dbg("SERDES: Link down - autoneg failed\n");
2427                 }
2428         }
2429
2430       out:
2431         return ret_val;
2432 }
2433
2434 /**
2435  * e1000_check_for_link
2436  * @hw: Struct containing variables accessed by shared code
2437  *
2438  * Checks to see if the link status of the hardware has changed.
2439  * Called by any function that needs to check the link status of the adapter.
2440  */
2441 s32 e1000_check_for_link(struct e1000_hw *hw)
2442 {
2443         u32 rxcw = 0;
2444         u32 ctrl;
2445         u32 status;
2446         u32 rctl;
2447         u32 icr;
2448         u32 signal = 0;
2449         s32 ret_val;
2450         u16 phy_data;
2451
2452         e_dbg("e1000_check_for_link");
2453
2454         ctrl = er32(CTRL);
2455         status = er32(STATUS);
2456
2457         /* On adapters with a MAC newer than 82544, SW Definable pin 1 will be
2458          * set when the optics detect a signal. On older adapters, it will be
2459          * cleared when there is a signal.  This applies to fiber media only.
2460          */
2461         if ((hw->media_type == e1000_media_type_fiber) ||
2462             (hw->media_type == e1000_media_type_internal_serdes)) {
2463                 rxcw = er32(RXCW);
2464
2465                 if (hw->media_type == e1000_media_type_fiber) {
2466                         signal =
2467                             (hw->mac_type >
2468                              e1000_82544) ? E1000_CTRL_SWDPIN1 : 0;
2469                         if (status & E1000_STATUS_LU)
2470                                 hw->get_link_status = false;
2471                 }
2472         }
2473
2474         /* If we have a copper PHY then we only want to go out to the PHY
2475          * registers to see if Auto-Neg has completed and/or if our link
2476          * status has changed.  The get_link_status flag will be set if we
2477          * receive a Link Status Change interrupt or we have Rx Sequence
2478          * Errors.
2479          */
2480         if ((hw->media_type == e1000_media_type_copper) && hw->get_link_status) {
2481                 /* First we want to see if the MII Status Register reports
2482                  * link.  If so, then we want to get the current speed/duplex
2483                  * of the PHY.
2484                  * Read the register twice since the link bit is sticky.
2485                  */
2486                 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2487                 if (ret_val)
2488                         return ret_val;
2489                 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2490                 if (ret_val)
2491                         return ret_val;
2492
2493                 if (phy_data & MII_SR_LINK_STATUS) {
2494                         hw->get_link_status = false;
2495                         /* Check if there was DownShift, must be checked
2496                          * immediately after link-up
2497                          */
2498                         e1000_check_downshift(hw);
2499
2500                         /* If we are on 82544 or 82543 silicon and speed/duplex
2501                          * are forced to 10H or 10F, then we will implement the
2502                          * polarity reversal workaround.  We disable interrupts
2503                          * first, and upon returning, place the devices
2504                          * interrupt state to its previous value except for the
2505                          * link status change interrupt which will
2506                          * happen due to the execution of this workaround.
2507                          */
2508
2509                         if ((hw->mac_type == e1000_82544
2510                              || hw->mac_type == e1000_82543) && (!hw->autoneg)
2511                             && (hw->forced_speed_duplex == e1000_10_full
2512                                 || hw->forced_speed_duplex == e1000_10_half)) {
2513                                 ew32(IMC, 0xffffffff);
2514                                 ret_val =
2515                                     e1000_polarity_reversal_workaround(hw);
2516                                 icr = er32(ICR);
2517                                 ew32(ICS, (icr & ~E1000_ICS_LSC));
2518                                 ew32(IMS, IMS_ENABLE_MASK);
2519                         }
2520
2521                 } else {
2522                         /* No link detected */
2523                         e1000_config_dsp_after_link_change(hw, false);
2524                         return 0;
2525                 }
2526
2527                 /* If we are forcing speed/duplex, then we simply return since
2528                  * we have already determined whether we have link or not.
2529                  */
2530                 if (!hw->autoneg)
2531                         return -E1000_ERR_CONFIG;
2532
2533                 /* optimize the dsp settings for the igp phy */
2534                 e1000_config_dsp_after_link_change(hw, true);
2535
2536                 /* We have a M88E1000 PHY and Auto-Neg is enabled.  If we
2537                  * have Si on board that is 82544 or newer, Auto
2538                  * Speed Detection takes care of MAC speed/duplex
2539                  * configuration.  So we only need to configure Collision
2540                  * Distance in the MAC.  Otherwise, we need to force
2541                  * speed/duplex on the MAC to the current PHY speed/duplex
2542                  * settings.
2543                  */
2544                 if ((hw->mac_type >= e1000_82544) &&
2545                     (hw->mac_type != e1000_ce4100))
2546                         e1000_config_collision_dist(hw);
2547                 else {
2548                         ret_val = e1000_config_mac_to_phy(hw);
2549                         if (ret_val) {
2550                                 e_dbg
2551                                     ("Error configuring MAC to PHY settings\n");
2552                                 return ret_val;
2553                         }
2554                 }
2555
2556                 /* Configure Flow Control now that Auto-Neg has completed.
2557                  * First, we need to restore the desired flow control settings
2558                  * because we may have had to re-autoneg with a different link
2559                  * partner.
2560                  */
2561                 ret_val = e1000_config_fc_after_link_up(hw);
2562                 if (ret_val) {
2563                         e_dbg("Error configuring flow control\n");
2564                         return ret_val;
2565                 }
2566
2567                 /* At this point we know that we are on copper and we have
2568                  * auto-negotiated link.  These are conditions for checking the
2569                  * link partner capability register.  We use the link speed to
2570                  * determine if TBI compatibility needs to be turned on or off.
2571                  * If the link is not at gigabit speed, then TBI compatibility
2572                  * is not needed.  If we are at gigabit speed, we turn on TBI
2573                  * compatibility.
2574                  */
2575                 if (hw->tbi_compatibility_en) {
2576                         u16 speed, duplex;
2577                         ret_val =
2578                             e1000_get_speed_and_duplex(hw, &speed, &duplex);
2579                         if (ret_val) {
2580                                 e_dbg
2581                                     ("Error getting link speed and duplex\n");
2582                                 return ret_val;
2583                         }
2584                         if (speed != SPEED_1000) {
2585                                 /* If link speed is not set to gigabit speed, we
2586                                  * do not need to enable TBI compatibility.
2587                                  */
2588                                 if (hw->tbi_compatibility_on) {
2589                                         /* If we previously were in the mode,
2590                                          * turn it off.
2591                                          */
2592                                         rctl = er32(RCTL);
2593                                         rctl &= ~E1000_RCTL_SBP;
2594                                         ew32(RCTL, rctl);
2595                                         hw->tbi_compatibility_on = false;
2596                                 }
2597                         } else {
2598                                 /* If TBI compatibility is was previously off,
2599                                  * turn it on. For compatibility with a TBI link
2600                                  * partner, we will store bad packets. Some
2601                                  * frames have an additional byte on the end and
2602                                  * will look like CRC errors to to the hardware.
2603                                  */
2604                                 if (!hw->tbi_compatibility_on) {
2605                                         hw->tbi_compatibility_on = true;
2606                                         rctl = er32(RCTL);
2607                                         rctl |= E1000_RCTL_SBP;
2608                                         ew32(RCTL, rctl);
2609                                 }
2610                         }
2611                 }
2612         }
2613
2614         if ((hw->media_type == e1000_media_type_fiber) ||
2615             (hw->media_type == e1000_media_type_internal_serdes))
2616                 e1000_check_for_serdes_link_generic(hw);
2617
2618         return E1000_SUCCESS;
2619 }
2620
2621 /**
2622  * e1000_get_speed_and_duplex
2623  * @hw: Struct containing variables accessed by shared code
2624  * @speed: Speed of the connection
2625  * @duplex: Duplex setting of the connection
2626  *
2627  * Detects the current speed and duplex settings of the hardware.
2628  */
2629 s32 e1000_get_speed_and_duplex(struct e1000_hw *hw, u16 *speed, u16 *duplex)
2630 {
2631         u32 status;
2632         s32 ret_val;
2633         u16 phy_data;
2634
2635         e_dbg("e1000_get_speed_and_duplex");
2636
2637         if (hw->mac_type >= e1000_82543) {
2638                 status = er32(STATUS);
2639                 if (status & E1000_STATUS_SPEED_1000) {
2640                         *speed = SPEED_1000;
2641                         e_dbg("1000 Mbs, ");
2642                 } else if (status & E1000_STATUS_SPEED_100) {
2643                         *speed = SPEED_100;
2644                         e_dbg("100 Mbs, ");
2645                 } else {
2646                         *speed = SPEED_10;
2647                         e_dbg("10 Mbs, ");
2648                 }
2649
2650                 if (status & E1000_STATUS_FD) {
2651                         *duplex = FULL_DUPLEX;
2652                         e_dbg("Full Duplex\n");
2653                 } else {
2654                         *duplex = HALF_DUPLEX;
2655                         e_dbg(" Half Duplex\n");
2656                 }
2657         } else {
2658                 e_dbg("1000 Mbs, Full Duplex\n");
2659                 *speed = SPEED_1000;
2660                 *duplex = FULL_DUPLEX;
2661         }
2662
2663         /* IGP01 PHY may advertise full duplex operation after speed downgrade
2664          * even if it is operating at half duplex.  Here we set the duplex
2665          * settings to match the duplex in the link partner's capabilities.
2666          */
2667         if (hw->phy_type == e1000_phy_igp && hw->speed_downgraded) {
2668                 ret_val = e1000_read_phy_reg(hw, PHY_AUTONEG_EXP, &phy_data);
2669                 if (ret_val)
2670                         return ret_val;
2671
2672                 if (!(phy_data & NWAY_ER_LP_NWAY_CAPS))
2673                         *duplex = HALF_DUPLEX;
2674                 else {
2675                         ret_val =
2676                             e1000_read_phy_reg(hw, PHY_LP_ABILITY, &phy_data);
2677                         if (ret_val)
2678                                 return ret_val;
2679                         if ((*speed == SPEED_100
2680                              && !(phy_data & NWAY_LPAR_100TX_FD_CAPS))
2681                             || (*speed == SPEED_10
2682                                 && !(phy_data & NWAY_LPAR_10T_FD_CAPS)))
2683                                 *duplex = HALF_DUPLEX;
2684                 }
2685         }
2686
2687         return E1000_SUCCESS;
2688 }
2689
2690 /**
2691  * e1000_wait_autoneg
2692  * @hw: Struct containing variables accessed by shared code
2693  *
2694  * Blocks until autoneg completes or times out (~4.5 seconds)
2695  */
2696 static s32 e1000_wait_autoneg(struct e1000_hw *hw)
2697 {
2698         s32 ret_val;
2699         u16 i;
2700         u16 phy_data;
2701
2702         e_dbg("e1000_wait_autoneg");
2703         e_dbg("Waiting for Auto-Neg to complete.\n");
2704
2705         /* We will wait for autoneg to complete or 4.5 seconds to expire. */
2706         for (i = PHY_AUTO_NEG_TIME; i > 0; i--) {
2707                 /* Read the MII Status Register and wait for Auto-Neg
2708                  * Complete bit to be set.
2709                  */
2710                 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2711                 if (ret_val)
2712                         return ret_val;
2713                 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2714                 if (ret_val)
2715                         return ret_val;
2716                 if (phy_data & MII_SR_AUTONEG_COMPLETE) {
2717                         return E1000_SUCCESS;
2718                 }
2719                 msleep(100);
2720         }
2721         return E1000_SUCCESS;
2722 }
2723
2724 /**
2725  * e1000_raise_mdi_clk - Raises the Management Data Clock
2726  * @hw: Struct containing variables accessed by shared code
2727  * @ctrl: Device control register's current value
2728  */
2729 static void e1000_raise_mdi_clk(struct e1000_hw *hw, u32 *ctrl)
2730 {
2731         /* Raise the clock input to the Management Data Clock (by setting the
2732          * MDC bit), and then delay 10 microseconds.
2733          */
2734         ew32(CTRL, (*ctrl | E1000_CTRL_MDC));
2735         E1000_WRITE_FLUSH();
2736         udelay(10);
2737 }
2738
2739 /**
2740  * e1000_lower_mdi_clk - Lowers the Management Data Clock
2741  * @hw: Struct containing variables accessed by shared code
2742  * @ctrl: Device control register's current value
2743  */
2744 static void e1000_lower_mdi_clk(struct e1000_hw *hw, u32 *ctrl)
2745 {
2746         /* Lower the clock input to the Management Data Clock (by clearing the
2747          * MDC bit), and then delay 10 microseconds.
2748          */
2749         ew32(CTRL, (*ctrl & ~E1000_CTRL_MDC));
2750         E1000_WRITE_FLUSH();
2751         udelay(10);
2752 }
2753
2754 /**
2755  * e1000_shift_out_mdi_bits - Shifts data bits out to the PHY
2756  * @hw: Struct containing variables accessed by shared code
2757  * @data: Data to send out to the PHY
2758  * @count: Number of bits to shift out
2759  *
2760  * Bits are shifted out in MSB to LSB order.
2761  */
2762 static void e1000_shift_out_mdi_bits(struct e1000_hw *hw, u32 data, u16 count)
2763 {
2764         u32 ctrl;
2765         u32 mask;
2766
2767         /* We need to shift "count" number of bits out to the PHY. So, the value
2768          * in the "data" parameter will be shifted out to the PHY one bit at a
2769          * time. In order to do this, "data" must be broken down into bits.
2770          */
2771         mask = 0x01;
2772         mask <<= (count - 1);
2773
2774         ctrl = er32(CTRL);
2775
2776         /* Set MDIO_DIR and MDC_DIR direction bits to be used as output pins. */
2777         ctrl |= (E1000_CTRL_MDIO_DIR | E1000_CTRL_MDC_DIR);
2778
2779         while (mask) {
2780                 /* A "1" is shifted out to the PHY by setting the MDIO bit to
2781                  * "1" and then raising and lowering the Management Data Clock.
2782                  * A "0" is shifted out to the PHY by setting the MDIO bit to
2783                  * "0" and then raising and lowering the clock.
2784                  */
2785                 if (data & mask)
2786                         ctrl |= E1000_CTRL_MDIO;
2787                 else
2788                         ctrl &= ~E1000_CTRL_MDIO;
2789
2790                 ew32(CTRL, ctrl);
2791                 E1000_WRITE_FLUSH();
2792
2793                 udelay(10);
2794
2795                 e1000_raise_mdi_clk(hw, &ctrl);
2796                 e1000_lower_mdi_clk(hw, &ctrl);
2797
2798                 mask = mask >> 1;
2799         }
2800 }
2801
2802 /**
2803  * e1000_shift_in_mdi_bits - Shifts data bits in from the PHY
2804  * @hw: Struct containing variables accessed by shared code
2805  *
2806  * Bits are shifted in in MSB to LSB order.
2807  */
2808 static u16 e1000_shift_in_mdi_bits(struct e1000_hw *hw)
2809 {
2810         u32 ctrl;
2811         u16 data = 0;
2812         u8 i;
2813
2814         /* In order to read a register from the PHY, we need to shift in a total
2815          * of 18 bits from the PHY. The first two bit (turnaround) times are
2816          * used to avoid contention on the MDIO pin when a read operation is
2817          * performed. These two bits are ignored by us and thrown away. Bits are
2818          * "shifted in" by raising the input to the Management Data Clock
2819          * (setting the MDC bit), and then reading the value of the MDIO bit.
2820          */
2821         ctrl = er32(CTRL);
2822
2823         /* Clear MDIO_DIR (SWDPIO1) to indicate this bit is to be used as
2824          * input.
2825          */
2826         ctrl &= ~E1000_CTRL_MDIO_DIR;
2827         ctrl &= ~E1000_CTRL_MDIO;
2828
2829         ew32(CTRL, ctrl);
2830         E1000_WRITE_FLUSH();
2831
2832         /* Raise and Lower the clock before reading in the data. This accounts
2833          * for the turnaround bits. The first clock occurred when we clocked out
2834          * the last bit of the Register Address.
2835          */
2836         e1000_raise_mdi_clk(hw, &ctrl);
2837         e1000_lower_mdi_clk(hw, &ctrl);
2838
2839         for (data = 0, i = 0; i < 16; i++) {
2840                 data = data << 1;
2841                 e1000_raise_mdi_clk(hw, &ctrl);
2842                 ctrl = er32(CTRL);
2843                 /* Check to see if we shifted in a "1". */
2844                 if (ctrl & E1000_CTRL_MDIO)
2845                         data |= 1;
2846                 e1000_lower_mdi_clk(hw, &ctrl);
2847         }
2848
2849         e1000_raise_mdi_clk(hw, &ctrl);
2850         e1000_lower_mdi_clk(hw, &ctrl);
2851
2852         return data;
2853 }
2854
2855
2856 /**
2857  * e1000_read_phy_reg - read a phy register
2858  * @hw: Struct containing variables accessed by shared code
2859  * @reg_addr: address of the PHY register to read
2860  *
2861  * Reads the value from a PHY register, if the value is on a specific non zero
2862  * page, sets the page first.
2863  */
2864 s32 e1000_read_phy_reg(struct e1000_hw *hw, u32 reg_addr, u16 *phy_data)
2865 {
2866         u32 ret_val;
2867         unsigned long flags;
2868
2869         e_dbg("e1000_read_phy_reg");
2870
2871         spin_lock_irqsave(&e1000_phy_lock, flags);
2872
2873         if ((hw->phy_type == e1000_phy_igp) &&
2874             (reg_addr > MAX_PHY_MULTI_PAGE_REG)) {
2875                 ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT,
2876                                                  (u16) reg_addr);
2877                 if (ret_val) {
2878                         spin_unlock_irqrestore(&e1000_phy_lock, flags);
2879                         return ret_val;
2880                 }
2881         }
2882
2883         ret_val = e1000_read_phy_reg_ex(hw, MAX_PHY_REG_ADDRESS & reg_addr,
2884                                         phy_data);
2885         spin_unlock_irqrestore(&e1000_phy_lock, flags);
2886
2887         return ret_val;
2888 }
2889
2890 static s32 e1000_read_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
2891                                  u16 *phy_data)
2892 {
2893         u32 i;
2894         u32 mdic = 0;
2895         const u32 phy_addr = (hw->mac_type == e1000_ce4100) ? hw->phy_addr : 1;
2896
2897         e_dbg("e1000_read_phy_reg_ex");
2898
2899         if (reg_addr > MAX_PHY_REG_ADDRESS) {
2900                 e_dbg("PHY Address %d is out of range\n", reg_addr);
2901                 return -E1000_ERR_PARAM;
2902         }
2903
2904         if (hw->mac_type > e1000_82543) {
2905                 /* Set up Op-code, Phy Address, and register address in the MDI
2906                  * Control register.  The MAC will take care of interfacing with
2907                  * the PHY to retrieve the desired data.
2908                  */
2909                 if (hw->mac_type == e1000_ce4100) {
2910                         mdic = ((reg_addr << E1000_MDIC_REG_SHIFT) |
2911                                 (phy_addr << E1000_MDIC_PHY_SHIFT) |
2912                                 (INTEL_CE_GBE_MDIC_OP_READ) |
2913                                 (INTEL_CE_GBE_MDIC_GO));
2914
2915                         writel(mdic, E1000_MDIO_CMD);
2916
2917                         /* Poll the ready bit to see if the MDI read
2918                          * completed
2919                          */
2920                         for (i = 0; i < 64; i++) {
2921                                 udelay(50);
2922                                 mdic = readl(E1000_MDIO_CMD);
2923                                 if (!(mdic & INTEL_CE_GBE_MDIC_GO))
2924                                         break;
2925                         }
2926
2927                         if (mdic & INTEL_CE_GBE_MDIC_GO) {
2928                                 e_dbg("MDI Read did not complete\n");
2929                                 return -E1000_ERR_PHY;
2930                         }
2931
2932                         mdic = readl(E1000_MDIO_STS);
2933                         if (mdic & INTEL_CE_GBE_MDIC_READ_ERROR) {
2934                                 e_dbg("MDI Read Error\n");
2935                                 return -E1000_ERR_PHY;
2936                         }
2937                         *phy_data = (u16) mdic;
2938                 } else {
2939                         mdic = ((reg_addr << E1000_MDIC_REG_SHIFT) |
2940                                 (phy_addr << E1000_MDIC_PHY_SHIFT) |
2941                                 (E1000_MDIC_OP_READ));
2942
2943                         ew32(MDIC, mdic);
2944
2945                         /* Poll the ready bit to see if the MDI read
2946                          * completed
2947                          */
2948                         for (i = 0; i < 64; i++) {
2949                                 udelay(50);
2950                                 mdic = er32(MDIC);
2951                                 if (mdic & E1000_MDIC_READY)
2952                                         break;
2953                         }
2954                         if (!(mdic & E1000_MDIC_READY)) {
2955                                 e_dbg("MDI Read did not complete\n");
2956                                 return -E1000_ERR_PHY;
2957                         }
2958                         if (mdic & E1000_MDIC_ERROR) {
2959                                 e_dbg("MDI Error\n");
2960                                 return -E1000_ERR_PHY;
2961                         }
2962                         *phy_data = (u16) mdic;
2963                 }
2964         } else {
2965                 /* We must first send a preamble through the MDIO pin to signal
2966                  * the beginning of an MII instruction.  This is done by sending
2967                  * 32 consecutive "1" bits.
2968                  */
2969                 e1000_shift_out_mdi_bits(hw, PHY_PREAMBLE, PHY_PREAMBLE_SIZE);
2970
2971                 /* Now combine the next few fields that are required for a read
2972                  * operation.  We use this method instead of calling the
2973                  * e1000_shift_out_mdi_bits routine five different times. The
2974                  * format of a MII read instruction consists of a shift out of
2975                  * 14 bits and is defined as follows:
2976                  *    <Preamble><SOF><Op Code><Phy Addr><Reg Addr>
2977                  * followed by a shift in of 18 bits.  This first two bits
2978                  * shifted in are TurnAround bits used to avoid contention on
2979                  * the MDIO pin when a READ operation is performed.  These two
2980                  * bits are thrown away followed by a shift in of 16 bits which
2981                  * contains the desired data.
2982                  */
2983                 mdic = ((reg_addr) | (phy_addr << 5) |
2984                         (PHY_OP_READ << 10) | (PHY_SOF << 12));
2985
2986                 e1000_shift_out_mdi_bits(hw, mdic, 14);
2987
2988                 /* Now that we've shifted out the read command to the MII, we
2989                  * need to "shift in" the 16-bit value (18 total bits) of the
2990                  * requested PHY register address.
2991                  */
2992                 *phy_data = e1000_shift_in_mdi_bits(hw);
2993         }
2994         return E1000_SUCCESS;
2995 }
2996
2997 /**
2998  * e1000_write_phy_reg - write a phy register
2999  *
3000  * @hw: Struct containing variables accessed by shared code
3001  * @reg_addr: address of the PHY register to write
3002  * @data: data to write to the PHY
3003  *
3004  * Writes a value to a PHY register
3005  */
3006 s32 e1000_write_phy_reg(struct e1000_hw *hw, u32 reg_addr, u16 phy_data)
3007 {
3008         u32 ret_val;
3009         unsigned long flags;
3010
3011         e_dbg("e1000_write_phy_reg");
3012
3013         spin_lock_irqsave(&e1000_phy_lock, flags);
3014
3015         if ((hw->phy_type == e1000_phy_igp) &&
3016             (reg_addr > MAX_PHY_MULTI_PAGE_REG)) {
3017                 ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT,
3018                                                  (u16) reg_addr);
3019                 if (ret_val) {
3020                         spin_unlock_irqrestore(&e1000_phy_lock, flags);
3021                         return ret_val;
3022                 }
3023         }
3024
3025         ret_val = e1000_write_phy_reg_ex(hw, MAX_PHY_REG_ADDRESS & reg_addr,
3026                                          phy_data);
3027         spin_unlock_irqrestore(&e1000_phy_lock, flags);
3028
3029         return ret_val;
3030 }
3031
3032 static s32 e1000_write_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
3033                                   u16 phy_data)
3034 {
3035         u32 i;
3036         u32 mdic = 0;
3037         const u32 phy_addr = (hw->mac_type == e1000_ce4100) ? hw->phy_addr : 1;
3038
3039         e_dbg("e1000_write_phy_reg_ex");
3040
3041         if (reg_addr > MAX_PHY_REG_ADDRESS) {
3042                 e_dbg("PHY Address %d is out of range\n", reg_addr);
3043                 return -E1000_ERR_PARAM;
3044         }
3045
3046         if (hw->mac_type > e1000_82543) {
3047                 /* Set up Op-code, Phy Address, register address, and data
3048                  * intended for the PHY register in the MDI Control register.
3049                  * The MAC will take care of interfacing with the PHY to send
3050                  * the desired data.
3051                  */
3052                 if (hw->mac_type == e1000_ce4100) {
3053                         mdic = (((u32) phy_data) |
3054                                 (reg_addr << E1000_MDIC_REG_SHIFT) |
3055                                 (phy_addr << E1000_MDIC_PHY_SHIFT) |
3056                                 (INTEL_CE_GBE_MDIC_OP_WRITE) |
3057                                 (INTEL_CE_GBE_MDIC_GO));
3058
3059                         writel(mdic, E1000_MDIO_CMD);
3060
3061                         /* Poll the ready bit to see if the MDI read
3062                          * completed
3063                          */
3064                         for (i = 0; i < 640; i++) {
3065                                 udelay(5);
3066                                 mdic = readl(E1000_MDIO_CMD);
3067                                 if (!(mdic & INTEL_CE_GBE_MDIC_GO))
3068                                         break;
3069                         }
3070                         if (mdic & INTEL_CE_GBE_MDIC_GO) {
3071                                 e_dbg("MDI Write did not complete\n");
3072                                 return -E1000_ERR_PHY;
3073                         }
3074                 } else {
3075                         mdic = (((u32) phy_data) |
3076                                 (reg_addr << E1000_MDIC_REG_SHIFT) |
3077                                 (phy_addr << E1000_MDIC_PHY_SHIFT) |
3078                                 (E1000_MDIC_OP_WRITE));
3079
3080                         ew32(MDIC, mdic);
3081
3082                         /* Poll the ready bit to see if the MDI read
3083                          * completed
3084                          */
3085                         for (i = 0; i < 641; i++) {
3086                                 udelay(5);
3087                                 mdic = er32(MDIC);
3088                                 if (mdic & E1000_MDIC_READY)
3089                                         break;
3090                         }
3091                         if (!(mdic & E1000_MDIC_READY)) {
3092                                 e_dbg("MDI Write did not complete\n");
3093                                 return -E1000_ERR_PHY;
3094                         }
3095                 }
3096         } else {
3097                 /* We'll need to use the SW defined pins to shift the write
3098                  * command out to the PHY. We first send a preamble to the PHY
3099                  * to signal the beginning of the MII instruction.  This is done
3100                  * by sending 32 consecutive "1" bits.
3101                  */
3102                 e1000_shift_out_mdi_bits(hw, PHY_PREAMBLE, PHY_PREAMBLE_SIZE);
3103
3104                 /* Now combine the remaining required fields that will indicate
3105                  * a write operation. We use this method instead of calling the
3106                  * e1000_shift_out_mdi_bits routine for each field in the
3107                  * command. The format of a MII write instruction is as follows:
3108                  * <Preamble><SOF><OpCode><PhyAddr><RegAddr><Turnaround><Data>.
3109                  */
3110                 mdic = ((PHY_TURNAROUND) | (reg_addr << 2) | (phy_addr << 7) |
3111                         (PHY_OP_WRITE << 12) | (PHY_SOF << 14));
3112                 mdic <<= 16;
3113                 mdic |= (u32) phy_data;
3114
3115                 e1000_shift_out_mdi_bits(hw, mdic, 32);
3116         }
3117
3118         return E1000_SUCCESS;
3119 }
3120
3121 /**
3122  * e1000_phy_hw_reset - reset the phy, hardware style
3123  * @hw: Struct containing variables accessed by shared code
3124  *
3125  * Returns the PHY to the power-on reset state
3126  */
3127 s32 e1000_phy_hw_reset(struct e1000_hw *hw)
3128 {
3129         u32 ctrl, ctrl_ext;
3130         u32 led_ctrl;
3131
3132         e_dbg("e1000_phy_hw_reset");
3133
3134         e_dbg("Resetting Phy...\n");
3135
3136         if (hw->mac_type > e1000_82543) {
3137                 /* Read the device control register and assert the
3138                  * E1000_CTRL_PHY_RST bit. Then, take it out of reset.
3139                  * For e1000 hardware, we delay for 10ms between the assert
3140                  * and de-assert.
3141                  */
3142                 ctrl = er32(CTRL);
3143                 ew32(CTRL, ctrl | E1000_CTRL_PHY_RST);
3144                 E1000_WRITE_FLUSH();
3145
3146                 msleep(10);
3147
3148                 ew32(CTRL, ctrl);
3149                 E1000_WRITE_FLUSH();
3150
3151         } else {
3152                 /* Read the Extended Device Control Register, assert the
3153                  * PHY_RESET_DIR bit to put the PHY into reset. Then, take it
3154                  * out of reset.
3155                  */
3156                 ctrl_ext = er32(CTRL_EXT);
3157                 ctrl_ext |= E1000_CTRL_EXT_SDP4_DIR;
3158                 ctrl_ext &= ~E1000_CTRL_EXT_SDP4_DATA;
3159                 ew32(CTRL_EXT, ctrl_ext);
3160                 E1000_WRITE_FLUSH();
3161                 msleep(10);
3162                 ctrl_ext |= E1000_CTRL_EXT_SDP4_DATA;
3163                 ew32(CTRL_EXT, ctrl_ext);
3164                 E1000_WRITE_FLUSH();
3165         }
3166         udelay(150);
3167
3168         if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
3169                 /* Configure activity LED after PHY reset */
3170                 led_ctrl = er32(LEDCTL);
3171                 led_ctrl &= IGP_ACTIVITY_LED_MASK;
3172                 led_ctrl |= (IGP_ACTIVITY_LED_ENABLE | IGP_LED3_MODE);
3173                 ew32(LEDCTL, led_ctrl);
3174         }
3175
3176         /* Wait for FW to finish PHY configuration. */
3177         return e1000_get_phy_cfg_done(hw);
3178 }
3179
3180 /**
3181  * e1000_phy_reset - reset the phy to commit settings
3182  * @hw: Struct containing variables accessed by shared code
3183  *
3184  * Resets the PHY
3185  * Sets bit 15 of the MII Control register
3186  */
3187 s32 e1000_phy_reset(struct e1000_hw *hw)
3188 {
3189         s32 ret_val;
3190         u16 phy_data;
3191
3192         e_dbg("e1000_phy_reset");
3193
3194         switch (hw->phy_type) {
3195         case e1000_phy_igp:
3196                 ret_val = e1000_phy_hw_reset(hw);
3197                 if (ret_val)
3198                         return ret_val;
3199                 break;
3200         default:
3201                 ret_val = e1000_read_phy_reg(hw, PHY_CTRL, &phy_data);
3202                 if (ret_val)
3203                         return ret_val;
3204
3205                 phy_data |= MII_CR_RESET;
3206                 ret_val = e1000_write_phy_reg(hw, PHY_CTRL, phy_data);
3207                 if (ret_val)
3208                         return ret_val;
3209
3210                 udelay(1);
3211                 break;
3212         }
3213
3214         if (hw->phy_type == e1000_phy_igp)
3215                 e1000_phy_init_script(hw);
3216
3217         return E1000_SUCCESS;
3218 }
3219
3220 /**
3221  * e1000_detect_gig_phy - check the phy type
3222  * @hw: Struct containing variables accessed by shared code
3223  *
3224  * Probes the expected PHY address for known PHY IDs
3225  */
3226 static s32 e1000_detect_gig_phy(struct e1000_hw *hw)
3227 {
3228         s32 phy_init_status, ret_val;
3229         u16 phy_id_high, phy_id_low;
3230         bool match = false;
3231
3232         e_dbg("e1000_detect_gig_phy");
3233
3234         if (hw->phy_id != 0)
3235                 return E1000_SUCCESS;
3236
3237         /* Read the PHY ID Registers to identify which PHY is onboard. */
3238         ret_val = e1000_read_phy_reg(hw, PHY_ID1, &phy_id_high);
3239         if (ret_val)
3240                 return ret_val;
3241
3242         hw->phy_id = (u32) (phy_id_high << 16);
3243         udelay(20);
3244         ret_val = e1000_read_phy_reg(hw, PHY_ID2, &phy_id_low);
3245         if (ret_val)
3246                 return ret_val;
3247
3248         hw->phy_id |= (u32) (phy_id_low & PHY_REVISION_MASK);
3249         hw->phy_revision = (u32) phy_id_low & ~PHY_REVISION_MASK;
3250
3251         switch (hw->mac_type) {
3252         case e1000_82543:
3253                 if (hw->phy_id == M88E1000_E_PHY_ID)
3254                         match = true;
3255                 break;
3256         case e1000_82544:
3257                 if (hw->phy_id == M88E1000_I_PHY_ID)
3258                         match = true;
3259                 break;
3260         case e1000_82540:
3261         case e1000_82545:
3262         case e1000_82545_rev_3:
3263         case e1000_82546:
3264         case e1000_82546_rev_3:
3265                 if (hw->phy_id == M88E1011_I_PHY_ID)
3266                         match = true;
3267                 break;
3268         case e1000_ce4100:
3269                 if ((hw->phy_id == RTL8211B_PHY_ID) ||
3270                     (hw->phy_id == RTL8201N_PHY_ID) ||
3271                     (hw->phy_id == M88E1118_E_PHY_ID))
3272                         match = true;
3273                 break;
3274         case e1000_82541:
3275         case e1000_82541_rev_2:
3276         case e1000_82547:
3277         case e1000_82547_rev_2:
3278                 if (hw->phy_id == IGP01E1000_I_PHY_ID)
3279                         match = true;
3280                 break;
3281         default:
3282                 e_dbg("Invalid MAC type %d\n", hw->mac_type);
3283                 return -E1000_ERR_CONFIG;
3284         }
3285         phy_init_status = e1000_set_phy_type(hw);
3286
3287         if ((match) && (phy_init_status == E1000_SUCCESS)) {
3288                 e_dbg("PHY ID 0x%X detected\n", hw->phy_id);
3289                 return E1000_SUCCESS;
3290         }
3291         e_dbg("Invalid PHY ID 0x%X\n", hw->phy_id);
3292         return -E1000_ERR_PHY;
3293 }
3294
3295 /**
3296  * e1000_phy_reset_dsp - reset DSP
3297  * @hw: Struct containing variables accessed by shared code
3298  *
3299  * Resets the PHY's DSP
3300  */
3301 static s32 e1000_phy_reset_dsp(struct e1000_hw *hw)
3302 {
3303         s32 ret_val;
3304         e_dbg("e1000_phy_reset_dsp");
3305
3306         do {
3307                 ret_val = e1000_write_phy_reg(hw, 29, 0x001d);
3308                 if (ret_val)
3309                         break;
3310                 ret_val = e1000_write_phy_reg(hw, 30, 0x00c1);
3311                 if (ret_val)
3312                         break;
3313                 ret_val = e1000_write_phy_reg(hw, 30, 0x0000);
3314                 if (ret_val)
3315                         break;
3316                 ret_val = E1000_SUCCESS;
3317         } while (0);
3318
3319         return ret_val;
3320 }
3321
3322 /**
3323  * e1000_phy_igp_get_info - get igp specific registers
3324  * @hw: Struct containing variables accessed by shared code
3325  * @phy_info: PHY information structure
3326  *
3327  * Get PHY information from various PHY registers for igp PHY only.
3328  */
3329 static s32 e1000_phy_igp_get_info(struct e1000_hw *hw,
3330                                   struct e1000_phy_info *phy_info)
3331 {
3332         s32 ret_val;
3333         u16 phy_data, min_length, max_length, average;
3334         e1000_rev_polarity polarity;
3335
3336         e_dbg("e1000_phy_igp_get_info");
3337
3338         /* The downshift status is checked only once, after link is established,
3339          * and it stored in the hw->speed_downgraded parameter.
3340          */
3341         phy_info->downshift = (e1000_downshift) hw->speed_downgraded;
3342
3343         /* IGP01E1000 does not need to support it. */
3344         phy_info->extended_10bt_distance = e1000_10bt_ext_dist_enable_normal;
3345
3346         /* IGP01E1000 always correct polarity reversal */
3347         phy_info->polarity_correction = e1000_polarity_reversal_enabled;
3348
3349         /* Check polarity status */
3350         ret_val = e1000_check_polarity(hw, &polarity);
3351         if (ret_val)
3352                 return ret_val;
3353
3354         phy_info->cable_polarity = polarity;
3355
3356         ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_STATUS, &phy_data);
3357         if (ret_val)
3358                 return ret_val;
3359
3360         phy_info->mdix_mode =
3361             (e1000_auto_x_mode) ((phy_data & IGP01E1000_PSSR_MDIX) >>
3362                                  IGP01E1000_PSSR_MDIX_SHIFT);
3363
3364         if ((phy_data & IGP01E1000_PSSR_SPEED_MASK) ==
3365             IGP01E1000_PSSR_SPEED_1000MBPS) {
3366                 /* Local/Remote Receiver Information are only valid @ 1000
3367                  * Mbps
3368                  */
3369                 ret_val = e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_data);
3370                 if (ret_val)
3371                         return ret_val;
3372
3373                 phy_info->local_rx = ((phy_data & SR_1000T_LOCAL_RX_STATUS) >>
3374                                       SR_1000T_LOCAL_RX_STATUS_SHIFT) ?
3375                     e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok;
3376                 phy_info->remote_rx = ((phy_data & SR_1000T_REMOTE_RX_STATUS) >>
3377                                        SR_1000T_REMOTE_RX_STATUS_SHIFT) ?
3378                     e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok;
3379
3380                 /* Get cable length */
3381                 ret_val = e1000_get_cable_length(hw, &min_length, &max_length);
3382                 if (ret_val)
3383                         return ret_val;
3384
3385                 /* Translate to old method */
3386                 average = (max_length + min_length) / 2;
3387
3388                 if (average <= e1000_igp_cable_length_50)
3389                         phy_info->cable_length = e1000_cable_length_50;
3390                 else if (average <= e1000_igp_cable_length_80)
3391                         phy_info->cable_length = e1000_cable_length_50_80;
3392                 else if (average <= e1000_igp_cable_length_110)
3393                         phy_info->cable_length = e1000_cable_length_80_110;
3394                 else if (average <= e1000_igp_cable_length_140)
3395                         phy_info->cable_length = e1000_cable_length_110_140;
3396                 else
3397                         phy_info->cable_length = e1000_cable_length_140;
3398         }
3399
3400         return E1000_SUCCESS;
3401 }
3402
3403 /**
3404  * e1000_phy_m88_get_info - get m88 specific registers
3405  * @hw: Struct containing variables accessed by shared code
3406  * @phy_info: PHY information structure
3407  *
3408  * Get PHY information from various PHY registers for m88 PHY only.
3409  */
3410 static s32 e1000_phy_m88_get_info(struct e1000_hw *hw,
3411                                   struct e1000_phy_info *phy_info)
3412 {
3413         s32 ret_val;
3414         u16 phy_data;
3415         e1000_rev_polarity polarity;
3416
3417         e_dbg("e1000_phy_m88_get_info");
3418
3419         /* The downshift status is checked only once, after link is established,
3420          * and it stored in the hw->speed_downgraded parameter.
3421          */
3422         phy_info->downshift = (e1000_downshift) hw->speed_downgraded;
3423
3424         ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
3425         if (ret_val)
3426                 return ret_val;
3427
3428         phy_info->extended_10bt_distance =
3429             ((phy_data & M88E1000_PSCR_10BT_EXT_DIST_ENABLE) >>
3430              M88E1000_PSCR_10BT_EXT_DIST_ENABLE_SHIFT) ?
3431             e1000_10bt_ext_dist_enable_lower :
3432             e1000_10bt_ext_dist_enable_normal;
3433
3434         phy_info->polarity_correction =
3435             ((phy_data & M88E1000_PSCR_POLARITY_REVERSAL) >>
3436              M88E1000_PSCR_POLARITY_REVERSAL_SHIFT) ?
3437             e1000_polarity_reversal_disabled : e1000_polarity_reversal_enabled;
3438
3439         /* Check polarity status */
3440         ret_val = e1000_check_polarity(hw, &polarity);
3441         if (ret_val)
3442                 return ret_val;
3443         phy_info->cable_polarity = polarity;
3444
3445         ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
3446         if (ret_val)
3447                 return ret_val;
3448
3449         phy_info->mdix_mode =
3450             (e1000_auto_x_mode) ((phy_data & M88E1000_PSSR_MDIX) >>
3451                                  M88E1000_PSSR_MDIX_SHIFT);
3452
3453         if ((phy_data & M88E1000_PSSR_SPEED) == M88E1000_PSSR_1000MBS) {
3454                 /* Cable Length Estimation and Local/Remote Receiver Information
3455                  * are only valid at 1000 Mbps.
3456                  */
3457                 phy_info->cable_length =
3458                     (e1000_cable_length) ((phy_data &
3459                                            M88E1000_PSSR_CABLE_LENGTH) >>
3460                                           M88E1000_PSSR_CABLE_LENGTH_SHIFT);
3461
3462                 ret_val = e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_data);
3463                 if (ret_val)
3464                         return ret_val;
3465
3466                 phy_info->local_rx = ((phy_data & SR_1000T_LOCAL_RX_STATUS) >>
3467                                       SR_1000T_LOCAL_RX_STATUS_SHIFT) ?
3468                     e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok;
3469                 phy_info->remote_rx = ((phy_data & SR_1000T_REMOTE_RX_STATUS) >>
3470                                        SR_1000T_REMOTE_RX_STATUS_SHIFT) ?
3471                     e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok;
3472
3473         }
3474
3475         return E1000_SUCCESS;
3476 }
3477
3478 /**
3479  * e1000_phy_get_info - request phy info
3480  * @hw: Struct containing variables accessed by shared code
3481  * @phy_info: PHY information structure
3482  *
3483  * Get PHY information from various PHY registers
3484  */
3485 s32 e1000_phy_get_info(struct e1000_hw *hw, struct e1000_phy_info *phy_info)
3486 {
3487         s32 ret_val;
3488         u16 phy_data;
3489
3490         e_dbg("e1000_phy_get_info");
3491
3492         phy_info->cable_length = e1000_cable_length_undefined;
3493         phy_info->extended_10bt_distance = e1000_10bt_ext_dist_enable_undefined;
3494         phy_info->cable_polarity = e1000_rev_polarity_undefined;
3495         phy_info->downshift = e1000_downshift_undefined;
3496         phy_info->polarity_correction = e1000_polarity_reversal_undefined;
3497         phy_info->mdix_mode = e1000_auto_x_mode_undefined;
3498         phy_info->local_rx = e1000_1000t_rx_status_undefined;
3499         phy_info->remote_rx = e1000_1000t_rx_status_undefined;
3500
3501         if (hw->media_type != e1000_media_type_copper) {
3502                 e_dbg("PHY info is only valid for copper media\n");
3503                 return -E1000_ERR_CONFIG;
3504         }
3505
3506         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
3507         if (ret_val)
3508                 return ret_val;
3509
3510         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
3511         if (ret_val)
3512                 return ret_val;
3513
3514         if ((phy_data & MII_SR_LINK_STATUS) != MII_SR_LINK_STATUS) {
3515                 e_dbg("PHY info is only valid if link is up\n");
3516                 return -E1000_ERR_CONFIG;
3517         }
3518
3519         if (hw->phy_type == e1000_phy_igp)
3520                 return e1000_phy_igp_get_info(hw, phy_info);
3521         else if ((hw->phy_type == e1000_phy_8211) ||
3522                  (hw->phy_type == e1000_phy_8201))
3523                 return E1000_SUCCESS;
3524         else
3525                 return e1000_phy_m88_get_info(hw, phy_info);
3526 }
3527
3528 s32 e1000_validate_mdi_setting(struct e1000_hw *hw)
3529 {
3530         e_dbg("e1000_validate_mdi_settings");
3531
3532         if (!hw->autoneg && (hw->mdix == 0 || hw->mdix == 3)) {
3533                 e_dbg("Invalid MDI setting detected\n");
3534                 hw->mdix = 1;
3535                 return -E1000_ERR_CONFIG;
3536         }
3537         return E1000_SUCCESS;
3538 }
3539
3540 /**
3541  * e1000_init_eeprom_params - initialize sw eeprom vars
3542  * @hw: Struct containing variables accessed by shared code
3543  *
3544  * Sets up eeprom variables in the hw struct.  Must be called after mac_type
3545  * is configured.
3546  */
3547 s32 e1000_init_eeprom_params(struct e1000_hw *hw)
3548 {
3549         struct e1000_eeprom_info *eeprom = &hw->eeprom;
3550         u32 eecd = er32(EECD);
3551         s32 ret_val = E1000_SUCCESS;
3552         u16 eeprom_size;
3553
3554         e_dbg("e1000_init_eeprom_params");
3555
3556         switch (hw->mac_type) {
3557         case e1000_82542_rev2_0:
3558         case e1000_82542_rev2_1:
3559         case e1000_82543:
3560         case e1000_82544:
3561                 eeprom->type = e1000_eeprom_microwire;
3562                 eeprom->word_size = 64;
3563                 eeprom->opcode_bits = 3;
3564                 eeprom->address_bits = 6;
3565                 eeprom->delay_usec = 50;
3566                 break;
3567         case e1000_82540:
3568         case e1000_82545:
3569         case e1000_82545_rev_3:
3570         case e1000_82546:
3571         case e1000_82546_rev_3:
3572                 eeprom->type = e1000_eeprom_microwire;
3573                 eeprom->opcode_bits = 3;
3574                 eeprom->delay_usec = 50;
3575                 if (eecd & E1000_EECD_SIZE) {
3576                         eeprom->word_size = 256;
3577                         eeprom->address_bits = 8;
3578                 } else {
3579                         eeprom->word_size = 64;
3580                         eeprom->address_bits = 6;
3581                 }
3582                 break;
3583         case e1000_82541:
3584         case e1000_82541_rev_2:
3585         case e1000_82547:
3586         case e1000_82547_rev_2:
3587                 if (eecd & E1000_EECD_TYPE) {
3588                         eeprom->type = e1000_eeprom_spi;
3589                         eeprom->opcode_bits = 8;
3590                         eeprom->delay_usec = 1;
3591                         if (eecd & E1000_EECD_ADDR_BITS) {
3592                                 eeprom->page_size = 32;
3593                                 eeprom->address_bits = 16;
3594                         } else {
3595                                 eeprom->page_size = 8;
3596                                 eeprom->address_bits = 8;
3597                         }
3598                 } else {
3599                         eeprom->type = e1000_eeprom_microwire;
3600                         eeprom->opcode_bits = 3;
3601                         eeprom->delay_usec = 50;
3602                         if (eecd & E1000_EECD_ADDR_BITS) {
3603                                 eeprom->word_size = 256;
3604                                 eeprom->address_bits = 8;
3605                         } else {
3606                                 eeprom->word_size = 64;
3607                                 eeprom->address_bits = 6;
3608                         }
3609                 }
3610                 break;
3611         default:
3612                 break;
3613         }
3614
3615         if (eeprom->type == e1000_eeprom_spi) {
3616                 /* eeprom_size will be an enum [0..8] that maps to eeprom sizes
3617                  * 128B to 32KB (incremented by powers of 2).
3618                  */
3619                 /* Set to default value for initial eeprom read. */
3620                 eeprom->word_size = 64;
3621                 ret_val = e1000_read_eeprom(hw, EEPROM_CFG, 1, &eeprom_size);
3622                 if (ret_val)
3623                         return ret_val;
3624                 eeprom_size =
3625                     (eeprom_size & EEPROM_SIZE_MASK) >> EEPROM_SIZE_SHIFT;
3626                 /* 256B eeprom size was not supported in earlier hardware, so we
3627                  * bump eeprom_size up one to ensure that "1" (which maps to
3628                  * 256B) is never the result used in the shifting logic below.
3629                  */
3630                 if (eeprom_size)
3631                         eeprom_size++;
3632
3633                 eeprom->word_size = 1 << (eeprom_size + EEPROM_WORD_SIZE_SHIFT);
3634         }
3635         return ret_val;
3636 }
3637
3638 /**
3639  * e1000_raise_ee_clk - Raises the EEPROM's clock input.
3640  * @hw: Struct containing variables accessed by shared code
3641  * @eecd: EECD's current value
3642  */
3643 static void e1000_raise_ee_clk(struct e1000_hw *hw, u32 *eecd)
3644 {
3645         /* Raise the clock input to the EEPROM (by setting the SK bit), and then
3646          * wait <delay> microseconds.
3647          */
3648         *eecd = *eecd | E1000_EECD_SK;
3649         ew32(EECD, *eecd);
3650         E1000_WRITE_FLUSH();
3651         udelay(hw->eeprom.delay_usec);
3652 }
3653
3654 /**
3655  * e1000_lower_ee_clk - Lowers the EEPROM's clock input.
3656  * @hw: Struct containing variables accessed by shared code
3657  * @eecd: EECD's current value
3658  */
3659 static void e1000_lower_ee_clk(struct e1000_hw *hw, u32 *eecd)
3660 {
3661         /* Lower the clock input to the EEPROM (by clearing the SK bit), and
3662          * then wait 50 microseconds.
3663          */
3664         *eecd = *eecd & ~E1000_EECD_SK;
3665         ew32(EECD, *eecd);
3666         E1000_WRITE_FLUSH();
3667         udelay(hw->eeprom.delay_usec);
3668 }
3669
3670 /**
3671  * e1000_shift_out_ee_bits - Shift data bits out to the EEPROM.
3672  * @hw: Struct containing variables accessed by shared code
3673  * @data: data to send to the EEPROM
3674  * @count: number of bits to shift out
3675  */
3676 static void e1000_shift_out_ee_bits(struct e1000_hw *hw, u16 data, u16 count)
3677 {
3678         struct e1000_eeprom_info *eeprom = &hw->eeprom;
3679         u32 eecd;
3680         u32 mask;
3681
3682         /* We need to shift "count" bits out to the EEPROM. So, value in the
3683          * "data" parameter will be shifted out to the EEPROM one bit at a time.
3684          * In order to do this, "data" must be broken down into bits.
3685          */
3686         mask = 0x01 << (count - 1);
3687         eecd = er32(EECD);
3688         if (eeprom->type == e1000_eeprom_microwire) {
3689                 eecd &= ~E1000_EECD_DO;
3690         } else if (eeprom->type == e1000_eeprom_spi) {
3691                 eecd |= E1000_EECD_DO;
3692         }
3693         do {
3694                 /* A "1" is shifted out to the EEPROM by setting bit "DI" to a
3695                  * "1", and then raising and then lowering the clock (the SK bit
3696                  * controls the clock input to the EEPROM).  A "0" is shifted
3697                  * out to the EEPROM by setting "DI" to "0" and then raising and
3698                  * then lowering the clock.
3699                  */
3700                 eecd &= ~E1000_EECD_DI;
3701
3702                 if (data & mask)
3703                         eecd |= E1000_EECD_DI;
3704
3705                 ew32(EECD, eecd);
3706                 E1000_WRITE_FLUSH();
3707
3708                 udelay(eeprom->delay_usec);
3709
3710                 e1000_raise_ee_clk(hw, &eecd);
3711                 e1000_lower_ee_clk(hw, &eecd);
3712
3713                 mask = mask >> 1;
3714
3715         } while (mask);
3716
3717         /* We leave the "DI" bit set to "0" when we leave this routine. */
3718         eecd &= ~E1000_EECD_DI;
3719         ew32(EECD, eecd);
3720 }
3721
3722 /**
3723  * e1000_shift_in_ee_bits - Shift data bits in from the EEPROM
3724  * @hw: Struct containing variables accessed by shared code
3725  * @count: number of bits to shift in
3726  */
3727 static u16 e1000_shift_in_ee_bits(struct e1000_hw *hw, u16 count)
3728 {
3729         u32 eecd;
3730         u32 i;
3731         u16 data;
3732
3733         /* In order to read a register from the EEPROM, we need to shift 'count'
3734          * bits in from the EEPROM. Bits are "shifted in" by raising the clock
3735          * input to the EEPROM (setting the SK bit), and then reading the value
3736          * of the "DO" bit.  During this "shifting in" process the "DI" bit
3737          * should always be clear.
3738          */
3739
3740         eecd = er32(EECD);
3741
3742         eecd &= ~(E1000_EECD_DO | E1000_EECD_DI);
3743         data = 0;
3744
3745         for (i = 0; i < count; i++) {
3746                 data = data << 1;
3747                 e1000_raise_ee_clk(hw, &eecd);
3748
3749                 eecd = er32(EECD);
3750
3751                 eecd &= ~(E1000_EECD_DI);
3752                 if (eecd & E1000_EECD_DO)
3753                         data |= 1;
3754
3755                 e1000_lower_ee_clk(hw, &eecd);
3756         }
3757
3758         return data;
3759 }
3760
3761 /**
3762  * e1000_acquire_eeprom - Prepares EEPROM for access
3763  * @hw: Struct containing variables accessed by shared code
3764  *
3765  * Lowers EEPROM clock. Clears input pin. Sets the chip select pin. This
3766  * function should be called before issuing a command to the EEPROM.
3767  */
3768 static s32 e1000_acquire_eeprom(struct e1000_hw *hw)
3769 {
3770         struct e1000_eeprom_info *eeprom = &hw->eeprom;
3771         u32 eecd, i = 0;
3772
3773         e_dbg("e1000_acquire_eeprom");
3774
3775         eecd = er32(EECD);
3776
3777         /* Request EEPROM Access */
3778         if (hw->mac_type > e1000_82544) {
3779                 eecd |= E1000_EECD_REQ;
3780                 ew32(EECD, eecd);
3781                 eecd = er32(EECD);
3782                 while ((!(eecd & E1000_EECD_GNT)) &&
3783                        (i < E1000_EEPROM_GRANT_ATTEMPTS)) {
3784                         i++;
3785                         udelay(5);
3786                         eecd = er32(EECD);
3787                 }
3788                 if (!(eecd & E1000_EECD_GNT)) {
3789                         eecd &= ~E1000_EECD_REQ;
3790                         ew32(EECD, eecd);
3791                         e_dbg("Could not acquire EEPROM grant\n");
3792                         return -E1000_ERR_EEPROM;
3793                 }
3794         }
3795
3796         /* Setup EEPROM for Read/Write */
3797
3798         if (eeprom->type == e1000_eeprom_microwire) {
3799                 /* Clear SK and DI */
3800                 eecd &= ~(E1000_EECD_DI | E1000_EECD_SK);
3801                 ew32(EECD, eecd);
3802
3803                 /* Set CS */
3804                 eecd |= E1000_EECD_CS;
3805                 ew32(EECD, eecd);
3806         } else if (eeprom->type == e1000_eeprom_spi) {
3807                 /* Clear SK and CS */
3808                 eecd &= ~(E1000_EECD_CS | E1000_EECD_SK);
3809                 ew32(EECD, eecd);
3810                 E1000_WRITE_FLUSH();
3811                 udelay(1);
3812         }
3813
3814         return E1000_SUCCESS;
3815 }
3816
3817 /**
3818  * e1000_standby_eeprom - Returns EEPROM to a "standby" state
3819  * @hw: Struct containing variables accessed by shared code
3820  */
3821 static void e1000_standby_eeprom(struct e1000_hw *hw)
3822 {
3823         struct e1000_eeprom_info *eeprom = &hw->eeprom;
3824         u32 eecd;
3825
3826         eecd = er32(EECD);
3827
3828         if (eeprom->type == e1000_eeprom_microwire) {
3829                 eecd &= ~(E1000_EECD_CS | E1000_EECD_SK);
3830                 ew32(EECD, eecd);
3831                 E1000_WRITE_FLUSH();
3832                 udelay(eeprom->delay_usec);
3833
3834                 /* Clock high */
3835                 eecd |= E1000_EECD_SK;
3836                 ew32(EECD, eecd);
3837                 E1000_WRITE_FLUSH();
3838                 udelay(eeprom->delay_usec);
3839
3840                 /* Select EEPROM */
3841                 eecd |= E1000_EECD_CS;
3842                 ew32(EECD, eecd);
3843                 E1000_WRITE_FLUSH();
3844                 udelay(eeprom->delay_usec);
3845
3846                 /* Clock low */
3847                 eecd &= ~E1000_EECD_SK;
3848                 ew32(EECD, eecd);
3849                 E1000_WRITE_FLUSH();
3850                 udelay(eeprom->delay_usec);
3851         } else if (eeprom->type == e1000_eeprom_spi) {
3852                 /* Toggle CS to flush commands */
3853                 eecd |= E1000_EECD_CS;
3854                 ew32(EECD, eecd);
3855                 E1000_WRITE_FLUSH();
3856                 udelay(eeprom->delay_usec);
3857                 eecd &= ~E1000_EECD_CS;
3858                 ew32(EECD, eecd);
3859                 E1000_WRITE_FLUSH();
3860                 udelay(eeprom->delay_usec);
3861         }
3862 }
3863
3864 /**
3865  * e1000_release_eeprom - drop chip select
3866  * @hw: Struct containing variables accessed by shared code
3867  *
3868  * Terminates a command by inverting the EEPROM's chip select pin
3869  */
3870 static void e1000_release_eeprom(struct e1000_hw *hw)
3871 {
3872         u32 eecd;
3873
3874         e_dbg("e1000_release_eeprom");
3875
3876         eecd = er32(EECD);
3877
3878         if (hw->eeprom.type == e1000_eeprom_spi) {
3879                 eecd |= E1000_EECD_CS;  /* Pull CS high */
3880                 eecd &= ~E1000_EECD_SK; /* Lower SCK */
3881
3882                 ew32(EECD, eecd);
3883                 E1000_WRITE_FLUSH();
3884
3885                 udelay(hw->eeprom.delay_usec);
3886         } else if (hw->eeprom.type == e1000_eeprom_microwire) {
3887                 /* cleanup eeprom */
3888
3889                 /* CS on Microwire is active-high */
3890                 eecd &= ~(E1000_EECD_CS | E1000_EECD_DI);
3891
3892                 ew32(EECD, eecd);
3893
3894                 /* Rising edge of clock */
3895                 eecd |= E1000_EECD_SK;
3896                 ew32(EECD, eecd);
3897                 E1000_WRITE_FLUSH();
3898                 udelay(hw->eeprom.delay_usec);
3899
3900                 /* Falling edge of clock */
3901                 eecd &= ~E1000_EECD_SK;
3902                 ew32(EECD, eecd);
3903                 E1000_WRITE_FLUSH();
3904                 udelay(hw->eeprom.delay_usec);
3905         }
3906
3907         /* Stop requesting EEPROM access */
3908         if (hw->mac_type > e1000_82544) {
3909                 eecd &= ~E1000_EECD_REQ;
3910                 ew32(EECD, eecd);
3911         }
3912 }
3913
3914 /**
3915  * e1000_spi_eeprom_ready - Reads a 16 bit word from the EEPROM.
3916  * @hw: Struct containing variables accessed by shared code
3917  */
3918 static s32 e1000_spi_eeprom_ready(struct e1000_hw *hw)
3919 {
3920         u16 retry_count = 0;
3921         u8 spi_stat_reg;
3922
3923         e_dbg("e1000_spi_eeprom_ready");
3924
3925         /* Read "Status Register" repeatedly until the LSB is cleared.  The
3926          * EEPROM will signal that the command has been completed by clearing
3927          * bit 0 of the internal status register.  If it's not cleared within
3928          * 5 milliseconds, then error out.
3929          */
3930         retry_count = 0;
3931         do {
3932                 e1000_shift_out_ee_bits(hw, EEPROM_RDSR_OPCODE_SPI,
3933                                         hw->eeprom.opcode_bits);
3934                 spi_stat_reg = (u8) e1000_shift_in_ee_bits(hw, 8);
3935                 if (!(spi_stat_reg & EEPROM_STATUS_RDY_SPI))
3936                         break;
3937
3938                 udelay(5);
3939                 retry_count += 5;
3940
3941                 e1000_standby_eeprom(hw);
3942         } while (retry_count < EEPROM_MAX_RETRY_SPI);
3943
3944         /* ATMEL SPI write time could vary from 0-20mSec on 3.3V devices (and
3945          * only 0-5mSec on 5V devices)
3946          */
3947         if (retry_count >= EEPROM_MAX_RETRY_SPI) {
3948                 e_dbg("SPI EEPROM Status error\n");
3949                 return -E1000_ERR_EEPROM;
3950         }
3951
3952         return E1000_SUCCESS;
3953 }
3954
3955 /**
3956  * e1000_read_eeprom - Reads a 16 bit word from the EEPROM.
3957  * @hw: Struct containing variables accessed by shared code
3958  * @offset: offset of  word in the EEPROM to read
3959  * @data: word read from the EEPROM
3960  * @words: number of words to read
3961  */
3962 s32 e1000_read_eeprom(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
3963 {
3964         s32 ret;
3965         spin_lock(&e1000_eeprom_lock);
3966         ret = e1000_do_read_eeprom(hw, offset, words, data);
3967         spin_unlock(&e1000_eeprom_lock);
3968         return ret;
3969 }
3970
3971 static s32 e1000_do_read_eeprom(struct e1000_hw *hw, u16 offset, u16 words,
3972                                 u16 *data)
3973 {
3974         struct e1000_eeprom_info *eeprom = &hw->eeprom;
3975         u32 i = 0;
3976
3977         e_dbg("e1000_read_eeprom");
3978
3979         if (hw->mac_type == e1000_ce4100) {
3980                 GBE_CONFIG_FLASH_READ(GBE_CONFIG_BASE_VIRT, offset, words,
3981                                       data);
3982                 return E1000_SUCCESS;
3983         }
3984
3985         /* If eeprom is not yet detected, do so now */
3986         if (eeprom->word_size == 0)
3987                 e1000_init_eeprom_params(hw);
3988
3989         /* A check for invalid values:  offset too large, too many words, and
3990          * not enough words.
3991          */
3992         if ((offset >= eeprom->word_size)
3993             || (words > eeprom->word_size - offset) || (words == 0)) {
3994                 e_dbg("\"words\" parameter out of bounds. Words = %d,"
3995                       "size = %d\n", offset, eeprom->word_size);
3996                 return -E1000_ERR_EEPROM;
3997         }
3998
3999         /* EEPROM's that don't use EERD to read require us to bit-bang the SPI
4000          * directly. In this case, we need to acquire the EEPROM so that
4001          * FW or other port software does not interrupt.
4002          */
4003         /* Prepare the EEPROM for bit-bang reading */
4004         if (e1000_acquire_eeprom(hw) != E1000_SUCCESS)
4005                 return -E1000_ERR_EEPROM;
4006
4007         /* Set up the SPI or Microwire EEPROM for bit-bang reading.  We have
4008          * acquired the EEPROM at this point, so any returns should release it
4009          */
4010         if (eeprom->type == e1000_eeprom_spi) {
4011                 u16 word_in;
4012                 u8 read_opcode = EEPROM_READ_OPCODE_SPI;
4013
4014                 if (e1000_spi_eeprom_ready(hw)) {
4015                         e1000_release_eeprom(hw);
4016                         return -E1000_ERR_EEPROM;
4017                 }
4018
4019                 e1000_standby_eeprom(hw);
4020
4021                 /* Some SPI eeproms use the 8th address bit embedded in the
4022                  * opcode
4023                  */
4024                 if ((eeprom->address_bits == 8) && (offset >= 128))
4025                         read_opcode |= EEPROM_A8_OPCODE_SPI;
4026
4027                 /* Send the READ command (opcode + addr)  */
4028                 e1000_shift_out_ee_bits(hw, read_opcode, eeprom->opcode_bits);
4029                 e1000_shift_out_ee_bits(hw, (u16) (offset * 2),
4030                                         eeprom->address_bits);
4031
4032                 /* Read the data.  The address of the eeprom internally
4033                  * increments with each byte (spi) being read, saving on the
4034                  * overhead of eeprom setup and tear-down.  The address counter
4035                  * will roll over if reading beyond the size of the eeprom, thus
4036                  * allowing the entire memory to be read starting from any
4037                  * offset.
4038                  */
4039                 for (i = 0; i < words; i++) {
4040                         word_in = e1000_shift_in_ee_bits(hw, 16);
4041                         data[i] = (word_in >> 8) | (word_in << 8);
4042                 }
4043         } else if (eeprom->type == e1000_eeprom_microwire) {
4044                 for (i = 0; i < words; i++) {
4045                         /* Send the READ command (opcode + addr)  */
4046                         e1000_shift_out_ee_bits(hw,
4047                                                 EEPROM_READ_OPCODE_MICROWIRE,
4048                                                 eeprom->opcode_bits);
4049                         e1000_shift_out_ee_bits(hw, (u16) (offset + i),
4050                                                 eeprom->address_bits);
4051
4052                         /* Read the data.  For microwire, each word requires the
4053                          * overhead of eeprom setup and tear-down.
4054                          */
4055                         data[i] = e1000_shift_in_ee_bits(hw, 16);
4056                         e1000_standby_eeprom(hw);
4057                 }
4058         }
4059
4060         /* End this read operation */
4061         e1000_release_eeprom(hw);
4062
4063         return E1000_SUCCESS;
4064 }
4065
4066 /**
4067  * e1000_validate_eeprom_checksum - Verifies that the EEPROM has a valid checksum
4068  * @hw: Struct containing variables accessed by shared code
4069  *
4070  * Reads the first 64 16 bit words of the EEPROM and sums the values read.
4071  * If the the sum of the 64 16 bit words is 0xBABA, the EEPROM's checksum is
4072  * valid.
4073  */
4074 s32 e1000_validate_eeprom_checksum(struct e1000_hw *hw)
4075 {
4076         u16 checksum = 0;
4077         u16 i, eeprom_data;
4078
4079         e_dbg("e1000_validate_eeprom_checksum");
4080
4081         for (i = 0; i < (EEPROM_CHECKSUM_REG + 1); i++) {
4082                 if (e1000_read_eeprom(hw, i, 1, &eeprom_data) < 0) {
4083                         e_dbg("EEPROM Read Error\n");
4084                         return -E1000_ERR_EEPROM;
4085                 }
4086                 checksum += eeprom_data;
4087         }
4088
4089 #ifdef CONFIG_PARISC
4090         /* This is a signature and not a checksum on HP c8000 */
4091         if ((hw->subsystem_vendor_id == 0x103C) && (eeprom_data == 0x16d6))
4092                 return E1000_SUCCESS;
4093
4094 #endif
4095         if (checksum == (u16) EEPROM_SUM)
4096                 return E1000_SUCCESS;
4097         else {
4098                 e_dbg("EEPROM Checksum Invalid\n");
4099                 return -E1000_ERR_EEPROM;
4100         }
4101 }
4102
4103 /**
4104  * e1000_update_eeprom_checksum - Calculates/writes the EEPROM checksum
4105  * @hw: Struct containing variables accessed by shared code
4106  *
4107  * Sums the first 63 16 bit words of the EEPROM. Subtracts the sum from 0xBABA.
4108  * Writes the difference to word offset 63 of the EEPROM.
4109  */
4110 s32 e1000_update_eeprom_checksum(struct e1000_hw *hw)
4111 {
4112         u16 checksum = 0;
4113         u16 i, eeprom_data;
4114
4115         e_dbg("e1000_update_eeprom_checksum");
4116
4117         for (i = 0; i < EEPROM_CHECKSUM_REG; i++) {
4118                 if (e1000_read_eeprom(hw, i, 1, &eeprom_data) < 0) {
4119                         e_dbg("EEPROM Read Error\n");
4120                         return -E1000_ERR_EEPROM;
4121                 }
4122                 checksum += eeprom_data;
4123         }
4124         checksum = (u16) EEPROM_SUM - checksum;
4125         if (e1000_write_eeprom(hw, EEPROM_CHECKSUM_REG, 1, &checksum) < 0) {
4126                 e_dbg("EEPROM Write Error\n");
4127                 return -E1000_ERR_EEPROM;
4128         }
4129         return E1000_SUCCESS;
4130 }
4131
4132 /**
4133  * e1000_write_eeprom - write words to the different EEPROM types.
4134  * @hw: Struct containing variables accessed by shared code
4135  * @offset: offset within the EEPROM to be written to
4136  * @words: number of words to write
4137  * @data: 16 bit word to be written to the EEPROM
4138  *
4139  * If e1000_update_eeprom_checksum is not called after this function, the
4140  * EEPROM will most likely contain an invalid checksum.
4141  */
4142 s32 e1000_write_eeprom(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
4143 {
4144         s32 ret;
4145         spin_lock(&e1000_eeprom_lock);
4146         ret = e1000_do_write_eeprom(hw, offset, words, data);
4147         spin_unlock(&e1000_eeprom_lock);
4148         return ret;
4149 }
4150
4151 static s32 e1000_do_write_eeprom(struct e1000_hw *hw, u16 offset, u16 words,
4152                                  u16 *data)
4153 {
4154         struct e1000_eeprom_info *eeprom = &hw->eeprom;
4155         s32 status = 0;
4156
4157         e_dbg("e1000_write_eeprom");
4158
4159         if (hw->mac_type == e1000_ce4100) {
4160                 GBE_CONFIG_FLASH_WRITE(GBE_CONFIG_BASE_VIRT, offset, words,
4161                                        data);
4162                 return E1000_SUCCESS;
4163         }
4164
4165         /* If eeprom is not yet detected, do so now */
4166         if (eeprom->word_size == 0)
4167                 e1000_init_eeprom_params(hw);
4168
4169         /* A check for invalid values:  offset too large, too many words, and
4170          * not enough words.
4171          */
4172         if ((offset >= eeprom->word_size)
4173             || (words > eeprom->word_size - offset) || (words == 0)) {
4174                 e_dbg("\"words\" parameter out of bounds\n");
4175                 return -E1000_ERR_EEPROM;
4176         }
4177
4178         /* Prepare the EEPROM for writing  */
4179         if (e1000_acquire_eeprom(hw) != E1000_SUCCESS)
4180                 return -E1000_ERR_EEPROM;
4181
4182         if (eeprom->type == e1000_eeprom_microwire) {
4183                 status = e1000_write_eeprom_microwire(hw, offset, words, data);
4184         } else {
4185                 status = e1000_write_eeprom_spi(hw, offset, words, data);
4186                 msleep(10);
4187         }
4188
4189         /* Done with writing */
4190         e1000_release_eeprom(hw);
4191
4192         return status;
4193 }
4194
4195 /**
4196  * e1000_write_eeprom_spi - Writes a 16 bit word to a given offset in an SPI EEPROM.
4197  * @hw: Struct containing variables accessed by shared code
4198  * @offset: offset within the EEPROM to be written to
4199  * @words: number of words to write
4200  * @data: pointer to array of 8 bit words to be written to the EEPROM
4201  */
4202 static s32 e1000_write_eeprom_spi(struct e1000_hw *hw, u16 offset, u16 words,
4203                                   u16 *data)
4204 {
4205         struct e1000_eeprom_info *eeprom = &hw->eeprom;
4206         u16 widx = 0;
4207
4208         e_dbg("e1000_write_eeprom_spi");
4209
4210         while (widx < words) {
4211                 u8 write_opcode = EEPROM_WRITE_OPCODE_SPI;
4212
4213                 if (e1000_spi_eeprom_ready(hw))
4214                         return -E1000_ERR_EEPROM;
4215
4216                 e1000_standby_eeprom(hw);
4217
4218                 /*  Send the WRITE ENABLE command (8 bit opcode )  */
4219                 e1000_shift_out_ee_bits(hw, EEPROM_WREN_OPCODE_SPI,
4220                                         eeprom->opcode_bits);
4221
4222                 e1000_standby_eeprom(hw);
4223
4224                 /* Some SPI eeproms use the 8th address bit embedded in the
4225                  * opcode
4226                  */
4227                 if ((eeprom->address_bits == 8) && (offset >= 128))
4228                         write_opcode |= EEPROM_A8_OPCODE_SPI;
4229
4230                 /* Send the Write command (8-bit opcode + addr) */
4231                 e1000_shift_out_ee_bits(hw, write_opcode, eeprom->opcode_bits);
4232
4233                 e1000_shift_out_ee_bits(hw, (u16) ((offset + widx) * 2),
4234                                         eeprom->address_bits);
4235
4236                 /* Send the data */
4237
4238                 /* Loop to allow for up to whole page write (32 bytes) of
4239                  * eeprom
4240                  */
4241                 while (widx < words) {
4242                         u16 word_out = data[widx];
4243                         word_out = (word_out >> 8) | (word_out << 8);
4244                         e1000_shift_out_ee_bits(hw, word_out, 16);
4245                         widx++;
4246
4247                         /* Some larger eeprom sizes are capable of a 32-byte
4248                          * PAGE WRITE operation, while the smaller eeproms are
4249                          * capable of an 8-byte PAGE WRITE operation.  Break the
4250                          * inner loop to pass new address
4251                          */
4252                         if ((((offset + widx) * 2) % eeprom->page_size) == 0) {
4253                                 e1000_standby_eeprom(hw);
4254                                 break;
4255                         }
4256                 }
4257         }
4258
4259         return E1000_SUCCESS;
4260 }
4261
4262 /**
4263  * e1000_write_eeprom_microwire - Writes a 16 bit word to a given offset in a Microwire EEPROM.
4264  * @hw: Struct containing variables accessed by shared code
4265  * @offset: offset within the EEPROM to be written to
4266  * @words: number of words to write
4267  * @data: pointer to array of 8 bit words to be written to the EEPROM
4268  */
4269 static s32 e1000_write_eeprom_microwire(struct e1000_hw *hw, u16 offset,
4270                                         u16 words, u16 *data)
4271 {
4272         struct e1000_eeprom_info *eeprom = &hw->eeprom;
4273         u32 eecd;
4274         u16 words_written = 0;
4275         u16 i = 0;
4276
4277         e_dbg("e1000_write_eeprom_microwire");
4278
4279         /* Send the write enable command to the EEPROM (3-bit opcode plus
4280          * 6/8-bit dummy address beginning with 11).  It's less work to include
4281          * the 11 of the dummy address as part of the opcode than it is to shift
4282          * it over the correct number of bits for the address.  This puts the
4283          * EEPROM into write/erase mode.
4284          */
4285         e1000_shift_out_ee_bits(hw, EEPROM_EWEN_OPCODE_MICROWIRE,
4286                                 (u16) (eeprom->opcode_bits + 2));
4287
4288         e1000_shift_out_ee_bits(hw, 0, (u16) (eeprom->address_bits - 2));
4289
4290         /* Prepare the EEPROM */
4291         e1000_standby_eeprom(hw);
4292
4293         while (words_written < words) {
4294                 /* Send the Write command (3-bit opcode + addr) */
4295                 e1000_shift_out_ee_bits(hw, EEPROM_WRITE_OPCODE_MICROWIRE,
4296                                         eeprom->opcode_bits);
4297
4298                 e1000_shift_out_ee_bits(hw, (u16) (offset + words_written),
4299                                         eeprom->address_bits);
4300
4301                 /* Send the data */
4302                 e1000_shift_out_ee_bits(hw, data[words_written], 16);
4303
4304                 /* Toggle the CS line.  This in effect tells the EEPROM to
4305                  * execute the previous command.
4306                  */
4307                 e1000_standby_eeprom(hw);
4308
4309                 /* Read DO repeatedly until it is high (equal to '1').  The
4310                  * EEPROM will signal that the command has been completed by
4311                  * raising the DO signal. If DO does not go high in 10
4312                  * milliseconds, then error out.
4313                  */
4314                 for (i = 0; i < 200; i++) {
4315                         eecd = er32(EECD);
4316                         if (eecd & E1000_EECD_DO)
4317                                 break;
4318                         udelay(50);
4319                 }
4320                 if (i == 200) {
4321                         e_dbg("EEPROM Write did not complete\n");
4322                         return -E1000_ERR_EEPROM;
4323                 }
4324
4325                 /* Recover from write */
4326                 e1000_standby_eeprom(hw);
4327
4328                 words_written++;
4329         }
4330
4331         /* Send the write disable command to the EEPROM (3-bit opcode plus
4332          * 6/8-bit dummy address beginning with 10).  It's less work to include
4333          * the 10 of the dummy address as part of the opcode than it is to shift
4334          * it over the correct number of bits for the address.  This takes the
4335          * EEPROM out of write/erase mode.
4336          */
4337         e1000_shift_out_ee_bits(hw, EEPROM_EWDS_OPCODE_MICROWIRE,
4338                                 (u16) (eeprom->opcode_bits + 2));
4339
4340         e1000_shift_out_ee_bits(hw, 0, (u16) (eeprom->address_bits - 2));
4341
4342         return E1000_SUCCESS;
4343 }
4344
4345 /**
4346  * e1000_read_mac_addr - read the adapters MAC from eeprom
4347  * @hw: Struct containing variables accessed by shared code
4348  *
4349  * Reads the adapter's MAC address from the EEPROM and inverts the LSB for the
4350  * second function of dual function devices
4351  */
4352 s32 e1000_read_mac_addr(struct e1000_hw *hw)
4353 {
4354         u16 offset;
4355         u16 eeprom_data, i;
4356
4357         e_dbg("e1000_read_mac_addr");
4358
4359         for (i = 0; i < NODE_ADDRESS_SIZE; i += 2) {
4360                 offset = i >> 1;
4361                 if (e1000_read_eeprom(hw, offset, 1, &eeprom_data) < 0) {
4362                         e_dbg("EEPROM Read Error\n");
4363                         return -E1000_ERR_EEPROM;
4364                 }
4365                 hw->perm_mac_addr[i] = (u8) (eeprom_data & 0x00FF);
4366                 hw->perm_mac_addr[i + 1] = (u8) (eeprom_data >> 8);
4367         }
4368
4369         switch (hw->mac_type) {
4370         default:
4371                 break;
4372         case e1000_82546:
4373         case e1000_82546_rev_3:
4374                 if (er32(STATUS) & E1000_STATUS_FUNC_1)
4375                         hw->perm_mac_addr[5] ^= 0x01;
4376                 break;
4377         }
4378
4379         for (i = 0; i < NODE_ADDRESS_SIZE; i++)
4380                 hw->mac_addr[i] = hw->perm_mac_addr[i];
4381         return E1000_SUCCESS;
4382 }
4383
4384 /**
4385  * e1000_init_rx_addrs - Initializes receive address filters.
4386  * @hw: Struct containing variables accessed by shared code
4387  *
4388  * Places the MAC address in receive address register 0 and clears the rest
4389  * of the receive address registers. Clears the multicast table. Assumes
4390  * the receiver is in reset when the routine is called.
4391  */
4392 static void e1000_init_rx_addrs(struct e1000_hw *hw)
4393 {
4394         u32 i;
4395         u32 rar_num;
4396
4397         e_dbg("e1000_init_rx_addrs");
4398
4399         /* Setup the receive address. */
4400         e_dbg("Programming MAC Address into RAR[0]\n");
4401
4402         e1000_rar_set(hw, hw->mac_addr, 0);
4403
4404         rar_num = E1000_RAR_ENTRIES;
4405
4406         /* Zero out the other 15 receive addresses. */
4407         e_dbg("Clearing RAR[1-15]\n");
4408         for (i = 1; i < rar_num; i++) {
4409                 E1000_WRITE_REG_ARRAY(hw, RA, (i << 1), 0);
4410                 E1000_WRITE_FLUSH();
4411                 E1000_WRITE_REG_ARRAY(hw, RA, ((i << 1) + 1), 0);
4412                 E1000_WRITE_FLUSH();
4413         }
4414 }
4415
4416 /**
4417  * e1000_hash_mc_addr - Hashes an address to determine its location in the multicast table
4418  * @hw: Struct containing variables accessed by shared code
4419  * @mc_addr: the multicast address to hash
4420  */
4421 u32 e1000_hash_mc_addr(struct e1000_hw *hw, u8 *mc_addr)
4422 {
4423         u32 hash_value = 0;
4424
4425         /* The portion of the address that is used for the hash table is
4426          * determined by the mc_filter_type setting.
4427          */
4428         switch (hw->mc_filter_type) {
4429                 /* [0] [1] [2] [3] [4] [5]
4430                  * 01  AA  00  12  34  56
4431                  * LSB                 MSB
4432                  */
4433         case 0:
4434                 /* [47:36] i.e. 0x563 for above example address */
4435                 hash_value = ((mc_addr[4] >> 4) | (((u16) mc_addr[5]) << 4));
4436                 break;
4437         case 1:
4438                 /* [46:35] i.e. 0xAC6 for above example address */
4439                 hash_value = ((mc_addr[4] >> 3) | (((u16) mc_addr[5]) << 5));
4440                 break;
4441         case 2:
4442                 /* [45:34] i.e. 0x5D8 for above example address */
4443                 hash_value = ((mc_addr[4] >> 2) | (((u16) mc_addr[5]) << 6));
4444                 break;
4445         case 3:
4446                 /* [43:32] i.e. 0x634 for above example address */
4447                 hash_value = ((mc_addr[4]) | (((u16) mc_addr[5]) << 8));
4448                 break;
4449         }
4450
4451         hash_value &= 0xFFF;
4452         return hash_value;
4453 }
4454
4455 /**
4456  * e1000_rar_set - Puts an ethernet address into a receive address register.
4457  * @hw: Struct containing variables accessed by shared code
4458  * @addr: Address to put into receive address register
4459  * @index: Receive address register to write
4460  */
4461 void e1000_rar_set(struct e1000_hw *hw, u8 *addr, u32 index)
4462 {
4463         u32 rar_low, rar_high;
4464
4465         /* HW expects these in little endian so we reverse the byte order
4466          * from network order (big endian) to little endian
4467          */
4468         rar_low = ((u32) addr[0] | ((u32) addr[1] << 8) |
4469                    ((u32) addr[2] << 16) | ((u32) addr[3] << 24));
4470         rar_high = ((u32) addr[4] | ((u32) addr[5] << 8));
4471
4472         /* Disable Rx and flush all Rx frames before enabling RSS to avoid Rx
4473          * unit hang.
4474          *
4475          * Description:
4476          * If there are any Rx frames queued up or otherwise present in the HW
4477          * before RSS is enabled, and then we enable RSS, the HW Rx unit will
4478          * hang.  To work around this issue, we have to disable receives and
4479          * flush out all Rx frames before we enable RSS. To do so, we modify we
4480          * redirect all Rx traffic to manageability and then reset the HW.
4481          * This flushes away Rx frames, and (since the redirections to
4482          * manageability persists across resets) keeps new ones from coming in
4483          * while we work.  Then, we clear the Address Valid AV bit for all MAC
4484          * addresses and undo the re-direction to manageability.
4485          * Now, frames are coming in again, but the MAC won't accept them, so
4486          * far so good.  We now proceed to initialize RSS (if necessary) and
4487          * configure the Rx unit.  Last, we re-enable the AV bits and continue
4488          * on our merry way.
4489          */
4490         switch (hw->mac_type) {
4491         default:
4492                 /* Indicate to hardware the Address is Valid. */
4493                 rar_high |= E1000_RAH_AV;
4494                 break;
4495         }
4496
4497         E1000_WRITE_REG_ARRAY(hw, RA, (index << 1), rar_low);
4498         E1000_WRITE_FLUSH();
4499         E1000_WRITE_REG_ARRAY(hw, RA, ((index << 1) + 1), rar_high);
4500         E1000_WRITE_FLUSH();
4501 }
4502
4503 /**
4504  * e1000_write_vfta - Writes a value to the specified offset in the VLAN filter table.
4505  * @hw: Struct containing variables accessed by shared code
4506  * @offset: Offset in VLAN filer table to write
4507  * @value: Value to write into VLAN filter table
4508  */
4509 void e1000_write_vfta(struct e1000_hw *hw, u32 offset, u32 value)
4510 {
4511         u32 temp;
4512
4513         if ((hw->mac_type == e1000_82544) && ((offset & 0x1) == 1)) {
4514                 temp = E1000_READ_REG_ARRAY(hw, VFTA, (offset - 1));
4515                 E1000_WRITE_REG_ARRAY(hw, VFTA, offset, value);
4516                 E1000_WRITE_FLUSH();
4517                 E1000_WRITE_REG_ARRAY(hw, VFTA, (offset - 1), temp);
4518                 E1000_WRITE_FLUSH();
4519         } else {
4520                 E1000_WRITE_REG_ARRAY(hw, VFTA, offset, value);
4521                 E1000_WRITE_FLUSH();
4522         }
4523 }
4524
4525 /**
4526  * e1000_clear_vfta - Clears the VLAN filer table
4527  * @hw: Struct containing variables accessed by shared code
4528  */
4529 static void e1000_clear_vfta(struct e1000_hw *hw)
4530 {
4531         u32 offset;
4532         u32 vfta_value = 0;
4533         u32 vfta_offset = 0;
4534         u32 vfta_bit_in_reg = 0;
4535
4536         for (offset = 0; offset < E1000_VLAN_FILTER_TBL_SIZE; offset++) {
4537                 /* If the offset we want to clear is the same offset of the
4538                  * manageability VLAN ID, then clear all bits except that of the
4539                  * manageability unit
4540                  */
4541                 vfta_value = (offset == vfta_offset) ? vfta_bit_in_reg : 0;
4542                 E1000_WRITE_REG_ARRAY(hw, VFTA, offset, vfta_value);
4543                 E1000_WRITE_FLUSH();
4544         }
4545 }
4546
4547 static s32 e1000_id_led_init(struct e1000_hw *hw)
4548 {
4549         u32 ledctl;
4550         const u32 ledctl_mask = 0x000000FF;
4551         const u32 ledctl_on = E1000_LEDCTL_MODE_LED_ON;
4552         const u32 ledctl_off = E1000_LEDCTL_MODE_LED_OFF;
4553         u16 eeprom_data, i, temp;
4554         const u16 led_mask = 0x0F;
4555
4556         e_dbg("e1000_id_led_init");
4557
4558         if (hw->mac_type < e1000_82540) {
4559                 /* Nothing to do */
4560                 return E1000_SUCCESS;
4561         }
4562
4563         ledctl = er32(LEDCTL);
4564         hw->ledctl_default = ledctl;
4565         hw->ledctl_mode1 = hw->ledctl_default;
4566         hw->ledctl_mode2 = hw->ledctl_default;
4567
4568         if (e1000_read_eeprom(hw, EEPROM_ID_LED_SETTINGS, 1, &eeprom_data) < 0) {
4569                 e_dbg("EEPROM Read Error\n");
4570                 return -E1000_ERR_EEPROM;
4571         }
4572
4573         if ((eeprom_data == ID_LED_RESERVED_0000) ||
4574             (eeprom_data == ID_LED_RESERVED_FFFF)) {
4575                 eeprom_data = ID_LED_DEFAULT;
4576         }
4577
4578         for (i = 0; i < 4; i++) {
4579                 temp = (eeprom_data >> (i << 2)) & led_mask;
4580                 switch (temp) {
4581                 case ID_LED_ON1_DEF2:
4582                 case ID_LED_ON1_ON2:
4583                 case ID_LED_ON1_OFF2:
4584                         hw->ledctl_mode1 &= ~(ledctl_mask << (i << 3));
4585                         hw->ledctl_mode1 |= ledctl_on << (i << 3);
4586                         break;
4587                 case ID_LED_OFF1_DEF2:
4588                 case ID_LED_OFF1_ON2:
4589                 case ID_LED_OFF1_OFF2:
4590                         hw->ledctl_mode1 &= ~(ledctl_mask << (i << 3));
4591                         hw->ledctl_mode1 |= ledctl_off << (i << 3);
4592                         break;
4593                 default:
4594                         /* Do nothing */
4595                         break;
4596                 }
4597                 switch (temp) {
4598                 case ID_LED_DEF1_ON2:
4599                 case ID_LED_ON1_ON2:
4600                 case ID_LED_OFF1_ON2:
4601                         hw->ledctl_mode2 &= ~(ledctl_mask << (i << 3));
4602                         hw->ledctl_mode2 |= ledctl_on << (i << 3);
4603                         break;
4604                 case ID_LED_DEF1_OFF2:
4605                 case ID_LED_ON1_OFF2:
4606                 case ID_LED_OFF1_OFF2:
4607                         hw->ledctl_mode2 &= ~(ledctl_mask << (i << 3));
4608                         hw->ledctl_mode2 |= ledctl_off << (i << 3);
4609                         break;
4610                 default:
4611                         /* Do nothing */
4612                         break;
4613                 }
4614         }
4615         return E1000_SUCCESS;
4616 }
4617
4618 /**
4619  * e1000_setup_led
4620  * @hw: Struct containing variables accessed by shared code
4621  *
4622  * Prepares SW controlable LED for use and saves the current state of the LED.
4623  */
4624 s32 e1000_setup_led(struct e1000_hw *hw)
4625 {
4626         u32 ledctl;
4627         s32 ret_val = E1000_SUCCESS;
4628
4629         e_dbg("e1000_setup_led");
4630
4631         switch (hw->mac_type) {
4632         case e1000_82542_rev2_0:
4633         case e1000_82542_rev2_1:
4634         case e1000_82543:
4635         case e1000_82544:
4636                 /* No setup necessary */
4637                 break;
4638         case e1000_82541:
4639         case e1000_82547:
4640         case e1000_82541_rev_2:
4641         case e1000_82547_rev_2:
4642                 /* Turn off PHY Smart Power Down (if enabled) */
4643                 ret_val = e1000_read_phy_reg(hw, IGP01E1000_GMII_FIFO,
4644                                              &hw->phy_spd_default);
4645                 if (ret_val)
4646                         return ret_val;
4647                 ret_val = e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO,
4648                                               (u16) (hw->phy_spd_default &
4649                                                      ~IGP01E1000_GMII_SPD));
4650                 if (ret_val)
4651                         return ret_val;
4652                 /* Fall Through */
4653         default:
4654                 if (hw->media_type == e1000_media_type_fiber) {
4655                         ledctl = er32(LEDCTL);
4656                         /* Save current LEDCTL settings */
4657                         hw->ledctl_default = ledctl;
4658                         /* Turn off LED0 */
4659                         ledctl &= ~(E1000_LEDCTL_LED0_IVRT |
4660                                     E1000_LEDCTL_LED0_BLINK |
4661                                     E1000_LEDCTL_LED0_MODE_MASK);
4662                         ledctl |= (E1000_LEDCTL_MODE_LED_OFF <<
4663                                    E1000_LEDCTL_LED0_MODE_SHIFT);
4664                         ew32(LEDCTL, ledctl);
4665                 } else if (hw->media_type == e1000_media_type_copper)
4666                         ew32(LEDCTL, hw->ledctl_mode1);
4667                 break;
4668         }
4669
4670         return E1000_SUCCESS;
4671 }
4672
4673 /**
4674  * e1000_cleanup_led - Restores the saved state of the SW controlable LED.
4675  * @hw: Struct containing variables accessed by shared code
4676  */
4677 s32 e1000_cleanup_led(struct e1000_hw *hw)
4678 {
4679         s32 ret_val = E1000_SUCCESS;
4680
4681         e_dbg("e1000_cleanup_led");
4682
4683         switch (hw->mac_type) {
4684         case e1000_82542_rev2_0:
4685         case e1000_82542_rev2_1:
4686         case e1000_82543:
4687         case e1000_82544:
4688                 /* No cleanup necessary */
4689                 break;
4690         case e1000_82541:
4691         case e1000_82547:
4692         case e1000_82541_rev_2:
4693         case e1000_82547_rev_2:
4694                 /* Turn on PHY Smart Power Down (if previously enabled) */
4695                 ret_val = e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO,
4696                                               hw->phy_spd_default);
4697                 if (ret_val)
4698                         return ret_val;
4699                 /* Fall Through */
4700         default:
4701                 /* Restore LEDCTL settings */
4702                 ew32(LEDCTL, hw->ledctl_default);
4703                 break;
4704         }
4705
4706         return E1000_SUCCESS;
4707 }
4708
4709 /**
4710  * e1000_led_on - Turns on the software controllable LED
4711  * @hw: Struct containing variables accessed by shared code
4712  */
4713 s32 e1000_led_on(struct e1000_hw *hw)
4714 {
4715         u32 ctrl = er32(CTRL);
4716
4717         e_dbg("e1000_led_on");
4718
4719         switch (hw->mac_type) {
4720         case e1000_82542_rev2_0:
4721         case e1000_82542_rev2_1:
4722         case e1000_82543:
4723                 /* Set SW Defineable Pin 0 to turn on the LED */
4724                 ctrl |= E1000_CTRL_SWDPIN0;
4725                 ctrl |= E1000_CTRL_SWDPIO0;
4726                 break;
4727         case e1000_82544:
4728                 if (hw->media_type == e1000_media_type_fiber) {
4729                         /* Set SW Defineable Pin 0 to turn on the LED */
4730                         ctrl |= E1000_CTRL_SWDPIN0;
4731                         ctrl |= E1000_CTRL_SWDPIO0;
4732                 } else {
4733                         /* Clear SW Defineable Pin 0 to turn on the LED */
4734                         ctrl &= ~E1000_CTRL_SWDPIN0;
4735                         ctrl |= E1000_CTRL_SWDPIO0;
4736                 }
4737                 break;
4738         default:
4739                 if (hw->media_type == e1000_media_type_fiber) {
4740                         /* Clear SW Defineable Pin 0 to turn on the LED */
4741                         ctrl &= ~E1000_CTRL_SWDPIN0;
4742                         ctrl |= E1000_CTRL_SWDPIO0;
4743                 } else if (hw->media_type == e1000_media_type_copper) {
4744                         ew32(LEDCTL, hw->ledctl_mode2);
4745                         return E1000_SUCCESS;
4746                 }
4747                 break;
4748         }
4749
4750         ew32(CTRL, ctrl);
4751
4752         return E1000_SUCCESS;
4753 }
4754
4755 /**
4756  * e1000_led_off - Turns off the software controllable LED
4757  * @hw: Struct containing variables accessed by shared code
4758  */
4759 s32 e1000_led_off(struct e1000_hw *hw)
4760 {
4761         u32 ctrl = er32(CTRL);
4762
4763         e_dbg("e1000_led_off");
4764
4765         switch (hw->mac_type) {
4766         case e1000_82542_rev2_0:
4767         case e1000_82542_rev2_1:
4768         case e1000_82543:
4769                 /* Clear SW Defineable Pin 0 to turn off the LED */
4770                 ctrl &= ~E1000_CTRL_SWDPIN0;
4771                 ctrl |= E1000_CTRL_SWDPIO0;
4772                 break;
4773         case e1000_82544:
4774                 if (hw->media_type == e1000_media_type_fiber) {
4775                         /* Clear SW Defineable Pin 0 to turn off the LED */
4776                         ctrl &= ~E1000_CTRL_SWDPIN0;
4777                         ctrl |= E1000_CTRL_SWDPIO0;
4778                 } else {
4779                         /* Set SW Defineable Pin 0 to turn off the LED */
4780                         ctrl |= E1000_CTRL_SWDPIN0;
4781                         ctrl |= E1000_CTRL_SWDPIO0;
4782                 }
4783                 break;
4784         default:
4785                 if (hw->media_type == e1000_media_type_fiber) {
4786                         /* Set SW Defineable Pin 0 to turn off the LED */
4787                         ctrl |= E1000_CTRL_SWDPIN0;
4788                         ctrl |= E1000_CTRL_SWDPIO0;
4789                 } else if (hw->media_type == e1000_media_type_copper) {
4790                         ew32(LEDCTL, hw->ledctl_mode1);
4791                         return E1000_SUCCESS;
4792                 }
4793                 break;
4794         }
4795
4796         ew32(CTRL, ctrl);
4797
4798         return E1000_SUCCESS;
4799 }
4800
4801 /**
4802  * e1000_clear_hw_cntrs - Clears all hardware statistics counters.
4803  * @hw: Struct containing variables accessed by shared code
4804  */
4805 static void e1000_clear_hw_cntrs(struct e1000_hw *hw)
4806 {
4807         volatile u32 temp;
4808
4809         temp = er32(CRCERRS);
4810         temp = er32(SYMERRS);
4811         temp = er32(MPC);
4812         temp = er32(SCC);
4813         temp = er32(ECOL);
4814         temp = er32(MCC);
4815         temp = er32(LATECOL);
4816         temp = er32(COLC);
4817         temp = er32(DC);
4818         temp = er32(SEC);
4819         temp = er32(RLEC);
4820         temp = er32(XONRXC);
4821         temp = er32(XONTXC);
4822         temp = er32(XOFFRXC);
4823         temp = er32(XOFFTXC);
4824         temp = er32(FCRUC);
4825
4826         temp = er32(PRC64);
4827         temp = er32(PRC127);
4828         temp = er32(PRC255);
4829         temp = er32(PRC511);
4830         temp = er32(PRC1023);
4831         temp = er32(PRC1522);
4832
4833         temp = er32(GPRC);
4834         temp = er32(BPRC);
4835         temp = er32(MPRC);
4836         temp = er32(GPTC);
4837         temp = er32(GORCL);
4838         temp = er32(GORCH);
4839         temp = er32(GOTCL);
4840         temp = er32(GOTCH);
4841         temp = er32(RNBC);
4842         temp = er32(RUC);
4843         temp = er32(RFC);
4844         temp = er32(ROC);
4845         temp = er32(RJC);
4846         temp = er32(TORL);
4847         temp = er32(TORH);
4848         temp = er32(TOTL);
4849         temp = er32(TOTH);
4850         temp = er32(TPR);
4851         temp = er32(TPT);
4852
4853         temp = er32(PTC64);
4854         temp = er32(PTC127);
4855         temp = er32(PTC255);
4856         temp = er32(PTC511);
4857         temp = er32(PTC1023);
4858         temp = er32(PTC1522);
4859
4860         temp = er32(MPTC);
4861         temp = er32(BPTC);
4862
4863         if (hw->mac_type < e1000_82543)
4864                 return;
4865
4866         temp = er32(ALGNERRC);
4867         temp = er32(RXERRC);
4868         temp = er32(TNCRS);
4869         temp = er32(CEXTERR);
4870         temp = er32(TSCTC);
4871         temp = er32(TSCTFC);
4872
4873         if (hw->mac_type <= e1000_82544)
4874                 return;
4875
4876         temp = er32(MGTPRC);
4877         temp = er32(MGTPDC);
4878         temp = er32(MGTPTC);
4879 }
4880
4881 /**
4882  * e1000_reset_adaptive - Resets Adaptive IFS to its default state.
4883  * @hw: Struct containing variables accessed by shared code
4884  *
4885  * Call this after e1000_init_hw. You may override the IFS defaults by setting
4886  * hw->ifs_params_forced to true. However, you must initialize hw->
4887  * current_ifs_val, ifs_min_val, ifs_max_val, ifs_step_size, and ifs_ratio
4888  * before calling this function.
4889  */
4890 void e1000_reset_adaptive(struct e1000_hw *hw)
4891 {
4892         e_dbg("e1000_reset_adaptive");
4893
4894         if (hw->adaptive_ifs) {
4895                 if (!hw->ifs_params_forced) {
4896                         hw->current_ifs_val = 0;
4897                         hw->ifs_min_val = IFS_MIN;
4898                         hw->ifs_max_val = IFS_MAX;
4899                         hw->ifs_step_size = IFS_STEP;
4900                         hw->ifs_ratio = IFS_RATIO;
4901                 }
4902                 hw->in_ifs_mode = false;
4903                 ew32(AIT, 0);
4904         } else {
4905                 e_dbg("Not in Adaptive IFS mode!\n");
4906         }
4907 }
4908
4909 /**
4910  * e1000_update_adaptive - update adaptive IFS
4911  * @hw: Struct containing variables accessed by shared code
4912  * @tx_packets: Number of transmits since last callback
4913  * @total_collisions: Number of collisions since last callback
4914  *
4915  * Called during the callback/watchdog routine to update IFS value based on
4916  * the ratio of transmits to collisions.
4917  */
4918 void e1000_update_adaptive(struct e1000_hw *hw)
4919 {
4920         e_dbg("e1000_update_adaptive");
4921
4922         if (hw->adaptive_ifs) {
4923                 if ((hw->collision_delta *hw->ifs_ratio) > hw->tx_packet_delta) {
4924                         if (hw->tx_packet_delta > MIN_NUM_XMITS) {
4925                                 hw->in_ifs_mode = true;
4926                                 if (hw->current_ifs_val < hw->ifs_max_val) {
4927                                         if (hw->current_ifs_val == 0)
4928                                                 hw->current_ifs_val =
4929                                                     hw->ifs_min_val;
4930                                         else
4931                                                 hw->current_ifs_val +=
4932                                                     hw->ifs_step_size;
4933                                         ew32(AIT, hw->current_ifs_val);
4934                                 }
4935                         }
4936                 } else {
4937                         if (hw->in_ifs_mode
4938                             && (hw->tx_packet_delta <= MIN_NUM_XMITS)) {
4939                                 hw->current_ifs_val = 0;
4940                                 hw->in_ifs_mode = false;
4941                                 ew32(AIT, 0);
4942                         }
4943                 }
4944         } else {
4945                 e_dbg("Not in Adaptive IFS mode!\n");
4946         }
4947 }
4948
4949 /**
4950  * e1000_tbi_adjust_stats
4951  * @hw: Struct containing variables accessed by shared code
4952  * @frame_len: The length of the frame in question
4953  * @mac_addr: The Ethernet destination address of the frame in question
4954  *
4955  * Adjusts the statistic counters when a frame is accepted by TBI_ACCEPT
4956  */
4957 void e1000_tbi_adjust_stats(struct e1000_hw *hw, struct e1000_hw_stats *stats,
4958                             u32 frame_len, u8 *mac_addr)
4959 {
4960         u64 carry_bit;
4961
4962         /* First adjust the frame length. */
4963         frame_len--;
4964         /* We need to adjust the statistics counters, since the hardware
4965          * counters overcount this packet as a CRC error and undercount
4966          * the packet as a good packet
4967          */
4968         /* This packet should not be counted as a CRC error. */
4969         stats->crcerrs--;
4970         /* This packet does count as a Good Packet Received. */
4971         stats->gprc++;
4972
4973         /* Adjust the Good Octets received counters */
4974         carry_bit = 0x80000000 & stats->gorcl;
4975         stats->gorcl += frame_len;
4976         /* If the high bit of Gorcl (the low 32 bits of the Good Octets
4977          * Received Count) was one before the addition,
4978          * AND it is zero after, then we lost the carry out,
4979          * need to add one to Gorch (Good Octets Received Count High).
4980          * This could be simplified if all environments supported
4981          * 64-bit integers.
4982          */
4983         if (carry_bit && ((stats->gorcl & 0x80000000) == 0))
4984                 stats->gorch++;
4985         /* Is this a broadcast or multicast?  Check broadcast first,
4986          * since the test for a multicast frame will test positive on
4987          * a broadcast frame.
4988          */
4989         if ((mac_addr[0] == (u8) 0xff) && (mac_addr[1] == (u8) 0xff))
4990                 /* Broadcast packet */
4991                 stats->bprc++;
4992         else if (*mac_addr & 0x01)
4993                 /* Multicast packet */
4994                 stats->mprc++;
4995
4996         if (frame_len == hw->max_frame_size) {
4997                 /* In this case, the hardware has overcounted the number of
4998                  * oversize frames.
4999                  */
5000                 if (stats->roc > 0)
5001                         stats->roc--;
5002         }
5003
5004         /* Adjust the bin counters when the extra byte put the frame in the
5005          * wrong bin. Remember that the frame_len was adjusted above.
5006          */
5007         if (frame_len == 64) {
5008                 stats->prc64++;
5009                 stats->prc127--;
5010         } else if (frame_len == 127) {
5011                 stats->prc127++;
5012                 stats->prc255--;
5013         } else if (frame_len == 255) {
5014                 stats->prc255++;
5015                 stats->prc511--;
5016         } else if (frame_len == 511) {
5017                 stats->prc511++;
5018                 stats->prc1023--;
5019         } else if (frame_len == 1023) {
5020                 stats->prc1023++;
5021                 stats->prc1522--;
5022         } else if (frame_len == 1522) {
5023                 stats->prc1522++;
5024         }
5025 }
5026
5027 /**
5028  * e1000_get_bus_info
5029  * @hw: Struct containing variables accessed by shared code
5030  *
5031  * Gets the current PCI bus type, speed, and width of the hardware
5032  */
5033 void e1000_get_bus_info(struct e1000_hw *hw)
5034 {
5035         u32 status;
5036
5037         switch (hw->mac_type) {
5038         case e1000_82542_rev2_0:
5039         case e1000_82542_rev2_1:
5040                 hw->bus_type = e1000_bus_type_pci;
5041                 hw->bus_speed = e1000_bus_speed_unknown;
5042                 hw->bus_width = e1000_bus_width_unknown;
5043                 break;
5044         default:
5045                 status = er32(STATUS);
5046                 hw->bus_type = (status & E1000_STATUS_PCIX_MODE) ?
5047                     e1000_bus_type_pcix : e1000_bus_type_pci;
5048
5049                 if (hw->device_id == E1000_DEV_ID_82546EB_QUAD_COPPER) {
5050                         hw->bus_speed = (hw->bus_type == e1000_bus_type_pci) ?
5051                             e1000_bus_speed_66 : e1000_bus_speed_120;
5052                 } else if (hw->bus_type == e1000_bus_type_pci) {
5053                         hw->bus_speed = (status & E1000_STATUS_PCI66) ?
5054                             e1000_bus_speed_66 : e1000_bus_speed_33;
5055                 } else {
5056                         switch (status & E1000_STATUS_PCIX_SPEED) {
5057                         case E1000_STATUS_PCIX_SPEED_66:
5058                                 hw->bus_speed = e1000_bus_speed_66;
5059                                 break;
5060                         case E1000_STATUS_PCIX_SPEED_100:
5061                                 hw->bus_speed = e1000_bus_speed_100;
5062                                 break;
5063                         case E1000_STATUS_PCIX_SPEED_133:
5064                                 hw->bus_speed = e1000_bus_speed_133;
5065                                 break;
5066                         default:
5067                                 hw->bus_speed = e1000_bus_speed_reserved;
5068                                 break;
5069                         }
5070                 }
5071                 hw->bus_width = (status & E1000_STATUS_BUS64) ?
5072                     e1000_bus_width_64 : e1000_bus_width_32;
5073                 break;
5074         }
5075 }
5076
5077 /**
5078  * e1000_write_reg_io
5079  * @hw: Struct containing variables accessed by shared code
5080  * @offset: offset to write to
5081  * @value: value to write
5082  *
5083  * Writes a value to one of the devices registers using port I/O (as opposed to
5084  * memory mapped I/O). Only 82544 and newer devices support port I/O.
5085  */
5086 static void e1000_write_reg_io(struct e1000_hw *hw, u32 offset, u32 value)
5087 {
5088         unsigned long io_addr = hw->io_base;
5089         unsigned long io_data = hw->io_base + 4;
5090
5091         e1000_io_write(hw, io_addr, offset);
5092         e1000_io_write(hw, io_data, value);
5093 }
5094
5095 /**
5096  * e1000_get_cable_length - Estimates the cable length.
5097  * @hw: Struct containing variables accessed by shared code
5098  * @min_length: The estimated minimum length
5099  * @max_length: The estimated maximum length
5100  *
5101  * returns: - E1000_ERR_XXX
5102  *            E1000_SUCCESS
5103  *
5104  * This function always returns a ranged length (minimum & maximum).
5105  * So for M88 phy's, this function interprets the one value returned from the
5106  * register to the minimum and maximum range.
5107  * For IGP phy's, the function calculates the range by the AGC registers.
5108  */
5109 static s32 e1000_get_cable_length(struct e1000_hw *hw, u16 *min_length,
5110                                   u16 *max_length)
5111 {
5112         s32 ret_val;
5113         u16 agc_value = 0;
5114         u16 i, phy_data;
5115         u16 cable_length;
5116
5117         e_dbg("e1000_get_cable_length");
5118
5119         *min_length = *max_length = 0;
5120
5121         /* Use old method for Phy older than IGP */
5122         if (hw->phy_type == e1000_phy_m88) {
5123
5124                 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS,
5125                                              &phy_data);
5126                 if (ret_val)
5127                         return ret_val;
5128                 cable_length = (phy_data & M88E1000_PSSR_CABLE_LENGTH) >>
5129                     M88E1000_PSSR_CABLE_LENGTH_SHIFT;
5130
5131                 /* Convert the enum value to ranged values */
5132                 switch (cable_length) {
5133                 case e1000_cable_length_50:
5134                         *min_length = 0;
5135                         *max_length = e1000_igp_cable_length_50;
5136                         break;
5137                 case e1000_cable_length_50_80:
5138                         *min_length = e1000_igp_cable_length_50;
5139                         *max_length = e1000_igp_cable_length_80;
5140                         break;
5141                 case e1000_cable_length_80_110:
5142                         *min_length = e1000_igp_cable_length_80;
5143                         *max_length = e1000_igp_cable_length_110;
5144                         break;
5145                 case e1000_cable_length_110_140:
5146                         *min_length = e1000_igp_cable_length_110;
5147                         *max_length = e1000_igp_cable_length_140;
5148                         break;
5149                 case e1000_cable_length_140:
5150                         *min_length = e1000_igp_cable_length_140;
5151                         *max_length = e1000_igp_cable_length_170;
5152                         break;
5153                 default:
5154                         return -E1000_ERR_PHY;
5155                         break;
5156                 }
5157         } else if (hw->phy_type == e1000_phy_igp) {     /* For IGP PHY */
5158                 u16 cur_agc_value;
5159                 u16 min_agc_value = IGP01E1000_AGC_LENGTH_TABLE_SIZE;
5160                 static const u16 agc_reg_array[IGP01E1000_PHY_CHANNEL_NUM] = {
5161                        IGP01E1000_PHY_AGC_A,
5162                        IGP01E1000_PHY_AGC_B,
5163                        IGP01E1000_PHY_AGC_C,
5164                        IGP01E1000_PHY_AGC_D
5165                 };
5166                 /* Read the AGC registers for all channels */
5167                 for (i = 0; i < IGP01E1000_PHY_CHANNEL_NUM; i++) {
5168
5169                         ret_val =
5170                             e1000_read_phy_reg(hw, agc_reg_array[i], &phy_data);
5171                         if (ret_val)
5172                                 return ret_val;
5173
5174                         cur_agc_value = phy_data >> IGP01E1000_AGC_LENGTH_SHIFT;
5175
5176                         /* Value bound check. */
5177                         if ((cur_agc_value >=
5178                              IGP01E1000_AGC_LENGTH_TABLE_SIZE - 1)
5179                             || (cur_agc_value == 0))
5180                                 return -E1000_ERR_PHY;
5181
5182                         agc_value += cur_agc_value;
5183
5184                         /* Update minimal AGC value. */
5185                         if (min_agc_value > cur_agc_value)
5186                                 min_agc_value = cur_agc_value;
5187                 }
5188
5189                 /* Remove the minimal AGC result for length < 50m */
5190                 if (agc_value <
5191                     IGP01E1000_PHY_CHANNEL_NUM * e1000_igp_cable_length_50) {
5192                         agc_value -= min_agc_value;
5193
5194                         /* Get the average length of the remaining 3 channels */
5195                         agc_value /= (IGP01E1000_PHY_CHANNEL_NUM - 1);
5196                 } else {
5197                         /* Get the average length of all the 4 channels. */
5198                         agc_value /= IGP01E1000_PHY_CHANNEL_NUM;
5199                 }
5200
5201                 /* Set the range of the calculated length. */
5202                 *min_length = ((e1000_igp_cable_length_table[agc_value] -
5203                                 IGP01E1000_AGC_RANGE) > 0) ?
5204                     (e1000_igp_cable_length_table[agc_value] -
5205                      IGP01E1000_AGC_RANGE) : 0;
5206                 *max_length = e1000_igp_cable_length_table[agc_value] +
5207                     IGP01E1000_AGC_RANGE;
5208         }
5209
5210         return E1000_SUCCESS;
5211 }
5212
5213 /**
5214  * e1000_check_polarity - Check the cable polarity
5215  * @hw: Struct containing variables accessed by shared code
5216  * @polarity: output parameter : 0 - Polarity is not reversed
5217  *                               1 - Polarity is reversed.
5218  *
5219  * returns: - E1000_ERR_XXX
5220  *            E1000_SUCCESS
5221  *
5222  * For phy's older than IGP, this function simply reads the polarity bit in the
5223  * Phy Status register.  For IGP phy's, this bit is valid only if link speed is
5224  * 10 Mbps.  If the link speed is 100 Mbps there is no polarity so this bit will
5225  * return 0.  If the link speed is 1000 Mbps the polarity status is in the
5226  * IGP01E1000_PHY_PCS_INIT_REG.
5227  */
5228 static s32 e1000_check_polarity(struct e1000_hw *hw,
5229                                 e1000_rev_polarity *polarity)
5230 {
5231         s32 ret_val;
5232         u16 phy_data;
5233
5234         e_dbg("e1000_check_polarity");
5235
5236         if (hw->phy_type == e1000_phy_m88) {
5237                 /* return the Polarity bit in the Status register. */
5238                 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS,
5239                                              &phy_data);
5240                 if (ret_val)
5241                         return ret_val;
5242                 *polarity = ((phy_data & M88E1000_PSSR_REV_POLARITY) >>
5243                              M88E1000_PSSR_REV_POLARITY_SHIFT) ?
5244                     e1000_rev_polarity_reversed : e1000_rev_polarity_normal;
5245
5246         } else if (hw->phy_type == e1000_phy_igp) {
5247                 /* Read the Status register to check the speed */
5248                 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_STATUS,
5249                                              &phy_data);
5250                 if (ret_val)
5251                         return ret_val;
5252
5253                 /* If speed is 1000 Mbps, must read the
5254                  * IGP01E1000_PHY_PCS_INIT_REG to find the polarity status
5255                  */
5256                 if ((phy_data & IGP01E1000_PSSR_SPEED_MASK) ==
5257                     IGP01E1000_PSSR_SPEED_1000MBPS) {
5258
5259                         /* Read the GIG initialization PCS register (0x00B4) */
5260                         ret_val =
5261                             e1000_read_phy_reg(hw, IGP01E1000_PHY_PCS_INIT_REG,
5262                                                &phy_data);
5263                         if (ret_val)
5264                                 return ret_val;
5265
5266                         /* Check the polarity bits */
5267                         *polarity = (phy_data & IGP01E1000_PHY_POLARITY_MASK) ?
5268                             e1000_rev_polarity_reversed :
5269                             e1000_rev_polarity_normal;
5270                 } else {
5271                         /* For 10 Mbps, read the polarity bit in the status
5272                          * register. (for 100 Mbps this bit is always 0)
5273                          */
5274                         *polarity =
5275                             (phy_data & IGP01E1000_PSSR_POLARITY_REVERSED) ?
5276                             e1000_rev_polarity_reversed :
5277                             e1000_rev_polarity_normal;
5278                 }
5279         }
5280         return E1000_SUCCESS;
5281 }
5282
5283 /**
5284  * e1000_check_downshift - Check if Downshift occurred
5285  * @hw: Struct containing variables accessed by shared code
5286  * @downshift: output parameter : 0 - No Downshift occurred.
5287  *                                1 - Downshift occurred.
5288  *
5289  * returns: - E1000_ERR_XXX
5290  *            E1000_SUCCESS
5291  *
5292  * For phy's older than IGP, this function reads the Downshift bit in the Phy
5293  * Specific Status register.  For IGP phy's, it reads the Downgrade bit in the
5294  * Link Health register.  In IGP this bit is latched high, so the driver must
5295  * read it immediately after link is established.
5296  */
5297 static s32 e1000_check_downshift(struct e1000_hw *hw)
5298 {
5299         s32 ret_val;
5300         u16 phy_data;
5301
5302         e_dbg("e1000_check_downshift");
5303
5304         if (hw->phy_type == e1000_phy_igp) {
5305                 ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_LINK_HEALTH,
5306                                              &phy_data);
5307                 if (ret_val)
5308                         return ret_val;
5309
5310                 hw->speed_downgraded =
5311                     (phy_data & IGP01E1000_PLHR_SS_DOWNGRADE) ? 1 : 0;
5312         } else if (hw->phy_type == e1000_phy_m88) {
5313                 ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS,
5314                                              &phy_data);
5315                 if (ret_val)
5316                         return ret_val;
5317
5318                 hw->speed_downgraded = (phy_data & M88E1000_PSSR_DOWNSHIFT) >>
5319                     M88E1000_PSSR_DOWNSHIFT_SHIFT;
5320         }
5321
5322         return E1000_SUCCESS;
5323 }
5324
5325 static const u16 dsp_reg_array[IGP01E1000_PHY_CHANNEL_NUM] = {
5326         IGP01E1000_PHY_AGC_PARAM_A,
5327         IGP01E1000_PHY_AGC_PARAM_B,
5328         IGP01E1000_PHY_AGC_PARAM_C,
5329         IGP01E1000_PHY_AGC_PARAM_D
5330 };
5331
5332 static s32 e1000_1000Mb_check_cable_length(struct e1000_hw *hw)
5333 {
5334         u16 min_length, max_length;
5335         u16 phy_data, i;
5336         s32 ret_val;
5337
5338         ret_val = e1000_get_cable_length(hw, &min_length, &max_length);
5339         if (ret_val)
5340                 return ret_val;
5341
5342         if (hw->dsp_config_state != e1000_dsp_config_enabled)
5343                 return 0;
5344
5345         if (min_length >= e1000_igp_cable_length_50) {
5346                 for (i = 0; i < IGP01E1000_PHY_CHANNEL_NUM; i++) {
5347                         ret_val = e1000_read_phy_reg(hw, dsp_reg_array[i],
5348                                                      &phy_data);
5349                         if (ret_val)
5350                                 return ret_val;
5351
5352                         phy_data &= ~IGP01E1000_PHY_EDAC_MU_INDEX;
5353
5354                         ret_val = e1000_write_phy_reg(hw, dsp_reg_array[i],
5355                                                       phy_data);
5356                         if (ret_val)
5357                                 return ret_val;
5358                 }
5359                 hw->dsp_config_state = e1000_dsp_config_activated;
5360         } else {
5361                 u16 ffe_idle_err_timeout = FFE_IDLE_ERR_COUNT_TIMEOUT_20;
5362                 u32 idle_errs = 0;
5363
5364                 /* clear previous idle error counts */
5365                 ret_val = e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_data);
5366                 if (ret_val)
5367                         return ret_val;
5368
5369                 for (i = 0; i < ffe_idle_err_timeout; i++) {
5370                         udelay(1000);
5371                         ret_val = e1000_read_phy_reg(hw, PHY_1000T_STATUS,
5372                                                      &phy_data);
5373                         if (ret_val)
5374                                 return ret_val;
5375
5376                         idle_errs += (phy_data & SR_1000T_IDLE_ERROR_CNT);
5377                         if (idle_errs > SR_1000T_PHY_EXCESSIVE_IDLE_ERR_COUNT) {
5378                                 hw->ffe_config_state = e1000_ffe_config_active;
5379
5380                                 ret_val = e1000_write_phy_reg(hw,
5381                                               IGP01E1000_PHY_DSP_FFE,
5382                                               IGP01E1000_PHY_DSP_FFE_CM_CP);
5383                                 if (ret_val)
5384                                         return ret_val;
5385                                 break;
5386                         }
5387
5388                         if (idle_errs)
5389                                 ffe_idle_err_timeout =
5390                                             FFE_IDLE_ERR_COUNT_TIMEOUT_100;
5391                 }
5392         }
5393
5394         return 0;
5395 }
5396
5397 /**
5398  * e1000_config_dsp_after_link_change
5399  * @hw: Struct containing variables accessed by shared code
5400  * @link_up: was link up at the time this was called
5401  *
5402  * returns: - E1000_ERR_PHY if fail to read/write the PHY
5403  *            E1000_SUCCESS at any other case.
5404  *
5405  * 82541_rev_2 & 82547_rev_2 have the capability to configure the DSP when a
5406  * gigabit link is achieved to improve link quality.
5407  */
5408
5409 static s32 e1000_config_dsp_after_link_change(struct e1000_hw *hw, bool link_up)
5410 {
5411         s32 ret_val;
5412         u16 phy_data, phy_saved_data, speed, duplex, i;
5413
5414         e_dbg("e1000_config_dsp_after_link_change");
5415
5416         if (hw->phy_type != e1000_phy_igp)
5417                 return E1000_SUCCESS;
5418
5419         if (link_up) {
5420                 ret_val = e1000_get_speed_and_duplex(hw, &speed, &duplex);
5421                 if (ret_val) {
5422                         e_dbg("Error getting link speed and duplex\n");
5423                         return ret_val;
5424                 }
5425
5426                 if (speed == SPEED_1000) {
5427                         ret_val = e1000_1000Mb_check_cable_length(hw);
5428                         if (ret_val)
5429                                 return ret_val;
5430                 }
5431         } else {
5432                 if (hw->dsp_config_state == e1000_dsp_config_activated) {
5433                         /* Save off the current value of register 0x2F5B to be
5434                          * restored at the end of the routines.
5435                          */
5436                         ret_val =
5437                             e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data);
5438
5439                         if (ret_val)
5440                                 return ret_val;
5441
5442                         /* Disable the PHY transmitter */
5443                         ret_val = e1000_write_phy_reg(hw, 0x2F5B, 0x0003);
5444
5445                         if (ret_val)
5446                                 return ret_val;
5447
5448                         msleep(20);
5449
5450                         ret_val = e1000_write_phy_reg(hw, 0x0000,
5451                                                     IGP01E1000_IEEE_FORCE_GIGA);
5452                         if (ret_val)
5453                                 return ret_val;
5454                         for (i = 0; i < IGP01E1000_PHY_CHANNEL_NUM; i++) {
5455                                 ret_val =
5456                                     e1000_read_phy_reg(hw, dsp_reg_array[i],
5457                                                        &phy_data);
5458                                 if (ret_val)
5459                                         return ret_val;
5460
5461                                 phy_data &= ~IGP01E1000_PHY_EDAC_MU_INDEX;
5462                                 phy_data |= IGP01E1000_PHY_EDAC_SIGN_EXT_9_BITS;
5463
5464                                 ret_val =
5465                                     e1000_write_phy_reg(hw, dsp_reg_array[i],
5466                                                         phy_data);
5467                                 if (ret_val)
5468                                         return ret_val;
5469                         }
5470
5471                         ret_val = e1000_write_phy_reg(hw, 0x0000,
5472                                         IGP01E1000_IEEE_RESTART_AUTONEG);
5473                         if (ret_val)
5474                                 return ret_val;
5475
5476                         msleep(20);
5477
5478                         /* Now enable the transmitter */
5479                         ret_val =
5480                             e1000_write_phy_reg(hw, 0x2F5B, phy_saved_data);
5481
5482                         if (ret_val)
5483                                 return ret_val;
5484
5485                         hw->dsp_config_state = e1000_dsp_config_enabled;
5486                 }
5487
5488                 if (hw->ffe_config_state == e1000_ffe_config_active) {
5489                         /* Save off the current value of register 0x2F5B to be
5490                          * restored at the end of the routines.
5491                          */
5492                         ret_val =
5493                             e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data);
5494
5495                         if (ret_val)
5496                                 return ret_val;
5497
5498                         /* Disable the PHY transmitter */
5499                         ret_val = e1000_write_phy_reg(hw, 0x2F5B, 0x0003);
5500
5501                         if (ret_val)
5502                                 return ret_val;
5503
5504                         msleep(20);
5505
5506                         ret_val = e1000_write_phy_reg(hw, 0x0000,
5507                                                     IGP01E1000_IEEE_FORCE_GIGA);
5508                         if (ret_val)
5509                                 return ret_val;
5510                         ret_val =
5511                             e1000_write_phy_reg(hw, IGP01E1000_PHY_DSP_FFE,
5512                                                 IGP01E1000_PHY_DSP_FFE_DEFAULT);
5513                         if (ret_val)
5514                                 return ret_val;
5515
5516                         ret_val = e1000_write_phy_reg(hw, 0x0000,
5517                                         IGP01E1000_IEEE_RESTART_AUTONEG);
5518                         if (ret_val)
5519                                 return ret_val;
5520
5521                         msleep(20);
5522
5523                         /* Now enable the transmitter */
5524                         ret_val =
5525                             e1000_write_phy_reg(hw, 0x2F5B, phy_saved_data);
5526
5527                         if (ret_val)
5528                                 return ret_val;
5529
5530                         hw->ffe_config_state = e1000_ffe_config_enabled;
5531                 }
5532         }
5533         return E1000_SUCCESS;
5534 }
5535
5536 /**
5537  * e1000_set_phy_mode - Set PHY to class A mode
5538  * @hw: Struct containing variables accessed by shared code
5539  *
5540  * Assumes the following operations will follow to enable the new class mode.
5541  *  1. Do a PHY soft reset
5542  *  2. Restart auto-negotiation or force link.
5543  */
5544 static s32 e1000_set_phy_mode(struct e1000_hw *hw)
5545 {
5546         s32 ret_val;
5547         u16 eeprom_data;
5548
5549         e_dbg("e1000_set_phy_mode");
5550
5551         if ((hw->mac_type == e1000_82545_rev_3) &&
5552             (hw->media_type == e1000_media_type_copper)) {
5553                 ret_val =
5554                     e1000_read_eeprom(hw, EEPROM_PHY_CLASS_WORD, 1,
5555                                       &eeprom_data);
5556                 if (ret_val) {
5557                         return ret_val;
5558                 }
5559
5560                 if ((eeprom_data != EEPROM_RESERVED_WORD) &&
5561                     (eeprom_data & EEPROM_PHY_CLASS_A)) {
5562                         ret_val =
5563                             e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT,
5564                                                 0x000B);
5565                         if (ret_val)
5566                                 return ret_val;
5567                         ret_val =
5568                             e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL,
5569                                                 0x8104);
5570                         if (ret_val)
5571                                 return ret_val;
5572
5573                         hw->phy_reset_disable = false;
5574                 }
5575         }
5576
5577         return E1000_SUCCESS;
5578 }
5579
5580 /**
5581  * e1000_set_d3_lplu_state - set d3 link power state
5582  * @hw: Struct containing variables accessed by shared code
5583  * @active: true to enable lplu false to disable lplu.
5584  *
5585  * This function sets the lplu state according to the active flag.  When
5586  * activating lplu this function also disables smart speed and vise versa.
5587  * lplu will not be activated unless the device autonegotiation advertisement
5588  * meets standards of either 10 or 10/100 or 10/100/1000 at all duplexes.
5589  *
5590  * returns: - E1000_ERR_PHY if fail to read/write the PHY
5591  *            E1000_SUCCESS at any other case.
5592  */
5593 static s32 e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active)
5594 {
5595         s32 ret_val;
5596         u16 phy_data;
5597         e_dbg("e1000_set_d3_lplu_state");
5598
5599         if (hw->phy_type != e1000_phy_igp)
5600                 return E1000_SUCCESS;
5601
5602         /* During driver activity LPLU should not be used or it will attain link
5603          * from the lowest speeds starting from 10Mbps. The capability is used
5604          * for Dx transitions and states
5605          */
5606         if (hw->mac_type == e1000_82541_rev_2
5607             || hw->mac_type == e1000_82547_rev_2) {
5608                 ret_val =
5609                     e1000_read_phy_reg(hw, IGP01E1000_GMII_FIFO, &phy_data);
5610                 if (ret_val)
5611                         return ret_val;
5612         }
5613
5614         if (!active) {
5615                 if (hw->mac_type == e1000_82541_rev_2 ||
5616                     hw->mac_type == e1000_82547_rev_2) {
5617                         phy_data &= ~IGP01E1000_GMII_FLEX_SPD;
5618                         ret_val =
5619                             e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO,
5620                                                 phy_data);
5621                         if (ret_val)
5622                                 return ret_val;
5623                 }
5624
5625                 /* LPLU and SmartSpeed are mutually exclusive.  LPLU is used
5626                  * during Dx states where the power conservation is most
5627                  * important.  During driver activity we should enable
5628                  * SmartSpeed, so performance is maintained.
5629                  */
5630                 if (hw->smart_speed == e1000_smart_speed_on) {
5631                         ret_val =
5632                             e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
5633                                                &phy_data);
5634                         if (ret_val)
5635                                 return ret_val;
5636
5637                         phy_data |= IGP01E1000_PSCFR_SMART_SPEED;
5638                         ret_val =
5639                             e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
5640                                                 phy_data);
5641                         if (ret_val)
5642                                 return ret_val;
5643                 } else if (hw->smart_speed == e1000_smart_speed_off) {
5644                         ret_val =
5645                             e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
5646                                                &phy_data);
5647                         if (ret_val)
5648                                 return ret_val;
5649
5650                         phy_data &= ~IGP01E1000_PSCFR_SMART_SPEED;
5651                         ret_val =
5652                             e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
5653                                                 phy_data);
5654                         if (ret_val)
5655                                 return ret_val;
5656                 }
5657         } else if ((hw->autoneg_advertised == AUTONEG_ADVERTISE_SPEED_DEFAULT)
5658                    || (hw->autoneg_advertised == AUTONEG_ADVERTISE_10_ALL)
5659                    || (hw->autoneg_advertised ==
5660                        AUTONEG_ADVERTISE_10_100_ALL)) {
5661
5662                 if (hw->mac_type == e1000_82541_rev_2 ||
5663                     hw->mac_type == e1000_82547_rev_2) {
5664                         phy_data |= IGP01E1000_GMII_FLEX_SPD;
5665                         ret_val =
5666                             e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO,
5667                                                 phy_data);
5668                         if (ret_val)
5669                                 return ret_val;
5670                 }
5671
5672                 /* When LPLU is enabled we should disable SmartSpeed */
5673                 ret_val =
5674                     e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
5675                                        &phy_data);
5676                 if (ret_val)
5677                         return ret_val;
5678
5679                 phy_data &= ~IGP01E1000_PSCFR_SMART_SPEED;
5680                 ret_val =
5681                     e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
5682                                         phy_data);
5683                 if (ret_val)
5684                         return ret_val;
5685
5686         }
5687         return E1000_SUCCESS;
5688 }
5689
5690 /**
5691  * e1000_set_vco_speed
5692  * @hw: Struct containing variables accessed by shared code
5693  *
5694  * Change VCO speed register to improve Bit Error Rate performance of SERDES.
5695  */
5696 static s32 e1000_set_vco_speed(struct e1000_hw *hw)
5697 {
5698         s32 ret_val;
5699         u16 default_page = 0;
5700         u16 phy_data;
5701
5702         e_dbg("e1000_set_vco_speed");
5703
5704         switch (hw->mac_type) {
5705         case e1000_82545_rev_3:
5706         case e1000_82546_rev_3:
5707                 break;
5708         default:
5709                 return E1000_SUCCESS;
5710         }
5711
5712         /* Set PHY register 30, page 5, bit 8 to 0 */
5713
5714         ret_val =
5715             e1000_read_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, &default_page);
5716         if (ret_val)
5717                 return ret_val;
5718
5719         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0005);
5720         if (ret_val)
5721                 return ret_val;
5722
5723         ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, &phy_data);
5724         if (ret_val)
5725                 return ret_val;
5726
5727         phy_data &= ~M88E1000_PHY_VCO_REG_BIT8;
5728         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, phy_data);
5729         if (ret_val)
5730                 return ret_val;
5731
5732         /* Set PHY register 30, page 4, bit 11 to 1 */
5733
5734         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0004);
5735         if (ret_val)
5736                 return ret_val;
5737
5738         ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, &phy_data);
5739         if (ret_val)
5740                 return ret_val;
5741
5742         phy_data |= M88E1000_PHY_VCO_REG_BIT11;
5743         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, phy_data);
5744         if (ret_val)
5745                 return ret_val;
5746
5747         ret_val =
5748             e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, default_page);
5749         if (ret_val)
5750                 return ret_val;
5751
5752         return E1000_SUCCESS;
5753 }
5754
5755
5756 /**
5757  * e1000_enable_mng_pass_thru - check for bmc pass through
5758  * @hw: Struct containing variables accessed by shared code
5759  *
5760  * Verifies the hardware needs to allow ARPs to be processed by the host
5761  * returns: - true/false
5762  */
5763 u32 e1000_enable_mng_pass_thru(struct e1000_hw *hw)
5764 {
5765         u32 manc;
5766
5767         if (hw->asf_firmware_present) {
5768                 manc = er32(MANC);
5769
5770                 if (!(manc & E1000_MANC_RCV_TCO_EN) ||
5771                     !(manc & E1000_MANC_EN_MAC_ADDR_FILTER))
5772                         return false;
5773                 if ((manc & E1000_MANC_SMBUS_EN) && !(manc & E1000_MANC_ASF_EN))
5774                         return true;
5775         }
5776         return false;
5777 }
5778
5779 static s32 e1000_polarity_reversal_workaround(struct e1000_hw *hw)
5780 {
5781         s32 ret_val;
5782         u16 mii_status_reg;
5783         u16 i;
5784
5785         /* Polarity reversal workaround for forced 10F/10H links. */
5786
5787         /* Disable the transmitter on the PHY */
5788
5789         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0019);
5790         if (ret_val)
5791                 return ret_val;
5792         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0xFFFF);
5793         if (ret_val)
5794                 return ret_val;
5795
5796         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0000);
5797         if (ret_val)
5798                 return ret_val;
5799
5800         /* This loop will early-out if the NO link condition has been met. */
5801         for (i = PHY_FORCE_TIME; i > 0; i--) {
5802                 /* Read the MII Status Register and wait for Link Status bit
5803                  * to be clear.
5804                  */
5805
5806                 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
5807                 if (ret_val)
5808                         return ret_val;
5809
5810                 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
5811                 if (ret_val)
5812                         return ret_val;
5813
5814                 if ((mii_status_reg & ~MII_SR_LINK_STATUS) == 0)
5815                         break;
5816                 msleep(100);
5817         }
5818
5819         /* Recommended delay time after link has been lost */
5820         msleep(1000);
5821
5822         /* Now we will re-enable th transmitter on the PHY */
5823
5824         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0019);
5825         if (ret_val)
5826                 return ret_val;
5827         msleep(50);
5828         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0xFFF0);
5829         if (ret_val)
5830                 return ret_val;
5831         msleep(50);
5832         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0xFF00);
5833         if (ret_val)
5834                 return ret_val;
5835         msleep(50);
5836         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_GEN_CONTROL, 0x0000);
5837         if (ret_val)
5838                 return ret_val;
5839
5840         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0000);
5841         if (ret_val)
5842                 return ret_val;
5843
5844         /* This loop will early-out if the link condition has been met. */
5845         for (i = PHY_FORCE_TIME; i > 0; i--) {
5846                 /* Read the MII Status Register and wait for Link Status bit
5847                  * to be set.
5848                  */
5849
5850                 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
5851                 if (ret_val)
5852                         return ret_val;
5853
5854                 ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
5855                 if (ret_val)
5856                         return ret_val;
5857
5858                 if (mii_status_reg & MII_SR_LINK_STATUS)
5859                         break;
5860                 msleep(100);
5861         }
5862         return E1000_SUCCESS;
5863 }
5864
5865 /**
5866  * e1000_get_auto_rd_done
5867  * @hw: Struct containing variables accessed by shared code
5868  *
5869  * Check for EEPROM Auto Read bit done.
5870  * returns: - E1000_ERR_RESET if fail to reset MAC
5871  *            E1000_SUCCESS at any other case.
5872  */
5873 static s32 e1000_get_auto_rd_done(struct e1000_hw *hw)
5874 {
5875         e_dbg("e1000_get_auto_rd_done");
5876         msleep(5);
5877         return E1000_SUCCESS;
5878 }
5879
5880 /**
5881  * e1000_get_phy_cfg_done
5882  * @hw: Struct containing variables accessed by shared code
5883  *
5884  * Checks if the PHY configuration is done
5885  * returns: - E1000_ERR_RESET if fail to reset MAC
5886  *            E1000_SUCCESS at any other case.
5887  */
5888 static s32 e1000_get_phy_cfg_done(struct e1000_hw *hw)
5889 {
5890         e_dbg("e1000_get_phy_cfg_done");
5891         msleep(10);
5892         return E1000_SUCCESS;
5893 }