SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/e1000/e1000_hw.c

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