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