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