e1000: Use hw, er32, and ew32
[sfrench/cifs-2.6.git] / drivers / net / e1000 / e1000_hw.c
1 /*******************************************************************************
2
3   Intel PRO/1000 Linux driver
4   Copyright(c) 1999 - 2006 Intel Corporation.
5
6   This program is free software; you can redistribute it and/or modify it
7   under the terms and conditions of the GNU General Public License,
8   version 2, as published by the Free Software Foundation.
9
10   This program is distributed in the hope it will be useful, but WITHOUT
11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13   more details.
14
15   You should have received a copy of the GNU General Public License along with
16   this program; if not, write to the Free Software Foundation, Inc.,
17   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18
19   The full GNU General Public License is included in this distribution in
20   the file called "COPYING".
21
22   Contact Information:
23   Linux NICS <linux.nics@intel.com>
24   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
25   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
26
27 *******************************************************************************/
28
29 /* e1000_hw.c
30  * Shared functions for accessing and configuring the MAC
31  */
32
33
34 #include "e1000_hw.h"
35
36 static s32 e1000_swfw_sync_acquire(struct e1000_hw *hw, u16 mask);
37 static void e1000_swfw_sync_release(struct e1000_hw *hw, u16 mask);
38 static s32 e1000_read_kmrn_reg(struct e1000_hw *hw, u32 reg_addr, u16 *data);
39 static s32 e1000_write_kmrn_reg(struct e1000_hw *hw, u32 reg_addr, u16 data);
40 static s32 e1000_get_software_semaphore(struct e1000_hw *hw);
41 static void e1000_release_software_semaphore(struct e1000_hw *hw);
42
43 static u8 e1000_arc_subsystem_valid(struct e1000_hw *hw);
44 static s32 e1000_check_downshift(struct e1000_hw *hw);
45 static s32 e1000_check_polarity(struct e1000_hw *hw,
46                                 e1000_rev_polarity *polarity);
47 static void e1000_clear_hw_cntrs(struct e1000_hw *hw);
48 static void e1000_clear_vfta(struct e1000_hw *hw);
49 static s32 e1000_commit_shadow_ram(struct e1000_hw *hw);
50 static s32 e1000_config_dsp_after_link_change(struct e1000_hw *hw,
51                                               bool link_up);
52 static s32 e1000_config_fc_after_link_up(struct e1000_hw *hw);
53 static s32 e1000_detect_gig_phy(struct e1000_hw *hw);
54 static s32 e1000_erase_ich8_4k_segment(struct e1000_hw *hw, u32 bank);
55 static s32 e1000_get_auto_rd_done(struct e1000_hw *hw);
56 static s32 e1000_get_cable_length(struct e1000_hw *hw, u16 *min_length,
57                                   u16 *max_length);
58 static s32 e1000_get_hw_eeprom_semaphore(struct e1000_hw *hw);
59 static s32 e1000_get_phy_cfg_done(struct e1000_hw *hw);
60 static s32 e1000_get_software_flag(struct e1000_hw *hw);
61 static s32 e1000_ich8_cycle_init(struct e1000_hw *hw);
62 static s32 e1000_ich8_flash_cycle(struct e1000_hw *hw, u32 timeout);
63 static s32 e1000_id_led_init(struct e1000_hw *hw);
64 static s32 e1000_init_lcd_from_nvm_config_region(struct e1000_hw *hw,
65                                                  u32 cnf_base_addr,
66                                                  u32 cnf_size);
67 static s32 e1000_init_lcd_from_nvm(struct e1000_hw *hw);
68 static void e1000_init_rx_addrs(struct e1000_hw *hw);
69 static void e1000_initialize_hardware_bits(struct e1000_hw *hw);
70 static bool e1000_is_onboard_nvm_eeprom(struct e1000_hw *hw);
71 static s32 e1000_kumeran_lock_loss_workaround(struct e1000_hw *hw);
72 static s32 e1000_mng_enable_host_if(struct e1000_hw *hw);
73 static s32 e1000_mng_host_if_write(struct e1000_hw *hw, u8 *buffer, u16 length,
74                                    u16 offset, u8 *sum);
75 static s32 e1000_mng_write_cmd_header(struct e1000_hw* hw,
76                                       struct e1000_host_mng_command_header
77                                       *hdr);
78 static s32 e1000_mng_write_commit(struct e1000_hw *hw);
79 static s32 e1000_phy_ife_get_info(struct e1000_hw *hw,
80                                   struct e1000_phy_info *phy_info);
81 static s32 e1000_phy_igp_get_info(struct e1000_hw *hw,
82                                   struct e1000_phy_info *phy_info);
83 static s32 e1000_read_eeprom_eerd(struct e1000_hw *hw, u16 offset, u16 words,
84                                   u16 *data);
85 static s32 e1000_write_eeprom_eewr(struct e1000_hw *hw, u16 offset, u16 words,
86                                    u16 *data);
87 static s32 e1000_poll_eerd_eewr_done(struct e1000_hw *hw, int eerd);
88 static s32 e1000_phy_m88_get_info(struct e1000_hw *hw,
89                                   struct e1000_phy_info *phy_info);
90 static void e1000_put_hw_eeprom_semaphore(struct e1000_hw *hw);
91 static s32 e1000_read_ich8_byte(struct e1000_hw *hw, u32 index, u8 *data);
92 static s32 e1000_verify_write_ich8_byte(struct e1000_hw *hw, u32 index,
93                                         u8 byte);
94 static s32 e1000_write_ich8_byte(struct e1000_hw *hw, u32 index, u8 byte);
95 static s32 e1000_read_ich8_word(struct e1000_hw *hw, u32 index, u16 *data);
96 static s32 e1000_read_ich8_data(struct e1000_hw *hw, u32 index, u32 size,
97                                 u16 *data);
98 static s32 e1000_write_ich8_data(struct e1000_hw *hw, u32 index, u32 size,
99                                  u16 data);
100 static s32 e1000_read_eeprom_ich8(struct e1000_hw *hw, u16 offset, u16 words,
101                                   u16 *data);
102 static s32 e1000_write_eeprom_ich8(struct e1000_hw *hw, u16 offset, u16 words,
103                                    u16 *data);
104 static void e1000_release_software_flag(struct e1000_hw *hw);
105 static s32 e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active);
106 static s32 e1000_set_d0_lplu_state(struct e1000_hw *hw, bool active);
107 static s32 e1000_set_pci_ex_no_snoop(struct e1000_hw *hw, u32 no_snoop);
108 static void e1000_set_pci_express_master_disable(struct e1000_hw *hw);
109 static s32 e1000_wait_autoneg(struct e1000_hw *hw);
110 static void e1000_write_reg_io(struct e1000_hw *hw, u32 offset, u32 value);
111 static s32 e1000_set_phy_type(struct e1000_hw *hw);
112 static void e1000_phy_init_script(struct e1000_hw *hw);
113 static s32 e1000_setup_copper_link(struct e1000_hw *hw);
114 static s32 e1000_setup_fiber_serdes_link(struct e1000_hw *hw);
115 static s32 e1000_adjust_serdes_amplitude(struct e1000_hw *hw);
116 static s32 e1000_phy_force_speed_duplex(struct e1000_hw *hw);
117 static s32 e1000_config_mac_to_phy(struct e1000_hw *hw);
118 static void e1000_raise_mdi_clk(struct e1000_hw *hw, u32 *ctrl);
119 static void e1000_lower_mdi_clk(struct e1000_hw *hw, u32 *ctrl);
120 static void e1000_shift_out_mdi_bits(struct e1000_hw *hw, u32 data,
121                                      u16 count);
122 static u16 e1000_shift_in_mdi_bits(struct e1000_hw *hw);
123 static s32 e1000_phy_reset_dsp(struct e1000_hw *hw);
124 static s32 e1000_write_eeprom_spi(struct e1000_hw *hw, u16 offset,
125                                       u16 words, u16 *data);
126 static s32 e1000_write_eeprom_microwire(struct e1000_hw *hw, u16 offset,
127                                         u16 words, u16 *data);
128 static s32 e1000_spi_eeprom_ready(struct e1000_hw *hw);
129 static void e1000_raise_ee_clk(struct e1000_hw *hw, u32 *eecd);
130 static void e1000_lower_ee_clk(struct e1000_hw *hw, u32 *eecd);
131 static void e1000_shift_out_ee_bits(struct e1000_hw *hw, u16 data, u16 count);
132 static s32 e1000_write_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
133                                   u16 phy_data);
134 static s32 e1000_read_phy_reg_ex(struct e1000_hw *hw,u32 reg_addr,
135                                  u16 *phy_data);
136 static u16 e1000_shift_in_ee_bits(struct e1000_hw *hw, u16 count);
137 static s32 e1000_acquire_eeprom(struct e1000_hw *hw);
138 static void e1000_release_eeprom(struct e1000_hw *hw);
139 static void e1000_standby_eeprom(struct e1000_hw *hw);
140 static s32 e1000_set_vco_speed(struct e1000_hw *hw);
141 static s32 e1000_polarity_reversal_workaround(struct e1000_hw *hw);
142 static s32 e1000_set_phy_mode(struct e1000_hw *hw);
143 static s32 e1000_host_if_read_cookie(struct e1000_hw *hw, u8 *buffer);
144 static u8 e1000_calculate_mng_checksum(char *buffer, u32 length);
145 static s32 e1000_configure_kmrn_for_10_100(struct e1000_hw *hw, u16 duplex);
146 static s32 e1000_configure_kmrn_for_1000(struct e1000_hw *hw);
147
148 /* IGP cable length table */
149 static const
150 u16 e1000_igp_cable_length_table[IGP01E1000_AGC_LENGTH_TABLE_SIZE] =
151     { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
152       5, 10, 10, 10, 10, 10, 10, 10, 20, 20, 20, 20, 20, 25, 25, 25,
153       25, 25, 25, 25, 30, 30, 30, 30, 40, 40, 40, 40, 40, 40, 40, 40,
154       40, 50, 50, 50, 50, 50, 50, 50, 60, 60, 60, 60, 60, 60, 60, 60,
155       60, 70, 70, 70, 70, 70, 70, 80, 80, 80, 80, 80, 80, 90, 90, 90,
156       90, 90, 90, 90, 90, 90, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
157       100, 100, 100, 100, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
158       110, 110, 110, 110, 110, 110, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120};
159
160 static const
161 u16 e1000_igp_2_cable_length_table[IGP02E1000_AGC_LENGTH_TABLE_SIZE] =
162     { 0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 8, 11, 13, 16, 18, 21,
163       0, 0, 0, 3, 6, 10, 13, 16, 19, 23, 26, 29, 32, 35, 38, 41,
164       6, 10, 14, 18, 22, 26, 30, 33, 37, 41, 44, 48, 51, 54, 58, 61,
165       21, 26, 31, 35, 40, 44, 49, 53, 57, 61, 65, 68, 72, 75, 79, 82,
166       40, 45, 51, 56, 61, 66, 70, 75, 79, 83, 87, 91, 94, 98, 101, 104,
167       60, 66, 72, 77, 82, 87, 92, 96, 100, 104, 108, 111, 114, 117, 119, 121,
168       83, 89, 95, 100, 105, 109, 113, 116, 119, 122, 124,
169       104, 109, 114, 118, 121, 124};
170
171 /******************************************************************************
172  * Set the phy type member in the hw struct.
173  *
174  * hw - Struct containing variables accessed by shared code
175  *****************************************************************************/
176 static s32 e1000_set_phy_type(struct e1000_hw *hw)
177 {
178     DEBUGFUNC("e1000_set_phy_type");
179
180     if (hw->mac_type == e1000_undefined)
181         return -E1000_ERR_PHY_TYPE;
182
183     switch (hw->phy_id) {
184     case M88E1000_E_PHY_ID:
185     case M88E1000_I_PHY_ID:
186     case M88E1011_I_PHY_ID:
187     case M88E1111_I_PHY_ID:
188         hw->phy_type = e1000_phy_m88;
189         break;
190     case IGP01E1000_I_PHY_ID:
191         if (hw->mac_type == e1000_82541 ||
192             hw->mac_type == e1000_82541_rev_2 ||
193             hw->mac_type == e1000_82547 ||
194             hw->mac_type == e1000_82547_rev_2) {
195             hw->phy_type = e1000_phy_igp;
196             break;
197         }
198     case IGP03E1000_E_PHY_ID:
199         hw->phy_type = e1000_phy_igp_3;
200         break;
201     case IFE_E_PHY_ID:
202     case IFE_PLUS_E_PHY_ID:
203     case IFE_C_E_PHY_ID:
204         hw->phy_type = e1000_phy_ife;
205         break;
206     case GG82563_E_PHY_ID:
207         if (hw->mac_type == e1000_80003es2lan) {
208             hw->phy_type = e1000_phy_gg82563;
209             break;
210         }
211         /* Fall Through */
212     default:
213         /* Should never have loaded on this device */
214         hw->phy_type = e1000_phy_undefined;
215         return -E1000_ERR_PHY_TYPE;
216     }
217
218     return E1000_SUCCESS;
219 }
220
221 /******************************************************************************
222  * IGP phy init script - initializes the GbE PHY
223  *
224  * hw - Struct containing variables accessed by shared code
225  *****************************************************************************/
226 static void e1000_phy_init_script(struct e1000_hw *hw)
227 {
228     u32 ret_val;
229     u16 phy_saved_data;
230
231     DEBUGFUNC("e1000_phy_init_script");
232
233     if (hw->phy_init_script) {
234         msleep(20);
235
236         /* Save off the current value of register 0x2F5B to be restored at
237          * the end of this routine. */
238         ret_val = e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data);
239
240         /* Disabled the PHY transmitter */
241         e1000_write_phy_reg(hw, 0x2F5B, 0x0003);
242
243         msleep(20);
244
245         e1000_write_phy_reg(hw,0x0000,0x0140);
246
247         msleep(5);
248
249         switch (hw->mac_type) {
250         case e1000_82541:
251         case e1000_82547:
252             e1000_write_phy_reg(hw, 0x1F95, 0x0001);
253
254             e1000_write_phy_reg(hw, 0x1F71, 0xBD21);
255
256             e1000_write_phy_reg(hw, 0x1F79, 0x0018);
257
258             e1000_write_phy_reg(hw, 0x1F30, 0x1600);
259
260             e1000_write_phy_reg(hw, 0x1F31, 0x0014);
261
262             e1000_write_phy_reg(hw, 0x1F32, 0x161C);
263
264             e1000_write_phy_reg(hw, 0x1F94, 0x0003);
265
266             e1000_write_phy_reg(hw, 0x1F96, 0x003F);
267
268             e1000_write_phy_reg(hw, 0x2010, 0x0008);
269             break;
270
271         case e1000_82541_rev_2:
272         case e1000_82547_rev_2:
273             e1000_write_phy_reg(hw, 0x1F73, 0x0099);
274             break;
275         default:
276             break;
277         }
278
279         e1000_write_phy_reg(hw, 0x0000, 0x3300);
280
281         msleep(20);
282
283         /* Now enable the transmitter */
284         e1000_write_phy_reg(hw, 0x2F5B, phy_saved_data);
285
286         if (hw->mac_type == e1000_82547) {
287             u16 fused, fine, coarse;
288
289             /* Move to analog registers page */
290             e1000_read_phy_reg(hw, IGP01E1000_ANALOG_SPARE_FUSE_STATUS, &fused);
291
292             if (!(fused & IGP01E1000_ANALOG_SPARE_FUSE_ENABLED)) {
293                 e1000_read_phy_reg(hw, IGP01E1000_ANALOG_FUSE_STATUS, &fused);
294
295                 fine = fused & IGP01E1000_ANALOG_FUSE_FINE_MASK;
296                 coarse = fused & IGP01E1000_ANALOG_FUSE_COARSE_MASK;
297
298                 if (coarse > IGP01E1000_ANALOG_FUSE_COARSE_THRESH) {
299                     coarse -= IGP01E1000_ANALOG_FUSE_COARSE_10;
300                     fine -= IGP01E1000_ANALOG_FUSE_FINE_1;
301                 } else if (coarse == IGP01E1000_ANALOG_FUSE_COARSE_THRESH)
302                     fine -= IGP01E1000_ANALOG_FUSE_FINE_10;
303
304                 fused = (fused & IGP01E1000_ANALOG_FUSE_POLY_MASK) |
305                         (fine & IGP01E1000_ANALOG_FUSE_FINE_MASK) |
306                         (coarse & IGP01E1000_ANALOG_FUSE_COARSE_MASK);
307
308                 e1000_write_phy_reg(hw, IGP01E1000_ANALOG_FUSE_CONTROL, fused);
309                 e1000_write_phy_reg(hw, IGP01E1000_ANALOG_FUSE_BYPASS,
310                                     IGP01E1000_ANALOG_FUSE_ENABLE_SW_CONTROL);
311             }
312         }
313     }
314 }
315
316 /******************************************************************************
317  * Set the mac type member in the hw struct.
318  *
319  * hw - Struct containing variables accessed by shared code
320  *****************************************************************************/
321 s32 e1000_set_mac_type(struct e1000_hw *hw)
322 {
323         DEBUGFUNC("e1000_set_mac_type");
324
325         switch (hw->device_id) {
326         case E1000_DEV_ID_82542:
327                 switch (hw->revision_id) {
328                 case E1000_82542_2_0_REV_ID:
329                         hw->mac_type = e1000_82542_rev2_0;
330                         break;
331                 case E1000_82542_2_1_REV_ID:
332                         hw->mac_type = e1000_82542_rev2_1;
333                         break;
334                 default:
335                         /* Invalid 82542 revision ID */
336                         return -E1000_ERR_MAC_TYPE;
337                 }
338                 break;
339         case E1000_DEV_ID_82543GC_FIBER:
340         case E1000_DEV_ID_82543GC_COPPER:
341                 hw->mac_type = e1000_82543;
342                 break;
343         case E1000_DEV_ID_82544EI_COPPER:
344         case E1000_DEV_ID_82544EI_FIBER:
345         case E1000_DEV_ID_82544GC_COPPER:
346         case E1000_DEV_ID_82544GC_LOM:
347                 hw->mac_type = e1000_82544;
348                 break;
349         case E1000_DEV_ID_82540EM:
350         case E1000_DEV_ID_82540EM_LOM:
351         case E1000_DEV_ID_82540EP:
352         case E1000_DEV_ID_82540EP_LOM:
353         case E1000_DEV_ID_82540EP_LP:
354                 hw->mac_type = e1000_82540;
355                 break;
356         case E1000_DEV_ID_82545EM_COPPER:
357         case E1000_DEV_ID_82545EM_FIBER:
358                 hw->mac_type = e1000_82545;
359                 break;
360         case E1000_DEV_ID_82545GM_COPPER:
361         case E1000_DEV_ID_82545GM_FIBER:
362         case E1000_DEV_ID_82545GM_SERDES:
363                 hw->mac_type = e1000_82545_rev_3;
364                 break;
365         case E1000_DEV_ID_82546EB_COPPER:
366         case E1000_DEV_ID_82546EB_FIBER:
367         case E1000_DEV_ID_82546EB_QUAD_COPPER:
368                 hw->mac_type = e1000_82546;
369                 break;
370         case E1000_DEV_ID_82546GB_COPPER:
371         case E1000_DEV_ID_82546GB_FIBER:
372         case E1000_DEV_ID_82546GB_SERDES:
373         case E1000_DEV_ID_82546GB_PCIE:
374         case E1000_DEV_ID_82546GB_QUAD_COPPER:
375         case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
376                 hw->mac_type = e1000_82546_rev_3;
377                 break;
378         case E1000_DEV_ID_82541EI:
379         case E1000_DEV_ID_82541EI_MOBILE:
380         case E1000_DEV_ID_82541ER_LOM:
381                 hw->mac_type = e1000_82541;
382                 break;
383         case E1000_DEV_ID_82541ER:
384         case E1000_DEV_ID_82541GI:
385         case E1000_DEV_ID_82541GI_LF:
386         case E1000_DEV_ID_82541GI_MOBILE:
387                 hw->mac_type = e1000_82541_rev_2;
388                 break;
389         case E1000_DEV_ID_82547EI:
390         case E1000_DEV_ID_82547EI_MOBILE:
391                 hw->mac_type = e1000_82547;
392                 break;
393         case E1000_DEV_ID_82547GI:
394                 hw->mac_type = e1000_82547_rev_2;
395                 break;
396         case E1000_DEV_ID_82571EB_COPPER:
397         case E1000_DEV_ID_82571EB_FIBER:
398         case E1000_DEV_ID_82571EB_SERDES:
399         case E1000_DEV_ID_82571EB_SERDES_DUAL:
400         case E1000_DEV_ID_82571EB_SERDES_QUAD:
401         case E1000_DEV_ID_82571EB_QUAD_COPPER:
402         case E1000_DEV_ID_82571PT_QUAD_COPPER:
403         case E1000_DEV_ID_82571EB_QUAD_FIBER:
404         case E1000_DEV_ID_82571EB_QUAD_COPPER_LOWPROFILE:
405                 hw->mac_type = e1000_82571;
406                 break;
407         case E1000_DEV_ID_82572EI_COPPER:
408         case E1000_DEV_ID_82572EI_FIBER:
409         case E1000_DEV_ID_82572EI_SERDES:
410         case E1000_DEV_ID_82572EI:
411                 hw->mac_type = e1000_82572;
412                 break;
413         case E1000_DEV_ID_82573E:
414         case E1000_DEV_ID_82573E_IAMT:
415         case E1000_DEV_ID_82573L:
416                 hw->mac_type = e1000_82573;
417                 break;
418         case E1000_DEV_ID_80003ES2LAN_COPPER_SPT:
419         case E1000_DEV_ID_80003ES2LAN_SERDES_SPT:
420         case E1000_DEV_ID_80003ES2LAN_COPPER_DPT:
421         case E1000_DEV_ID_80003ES2LAN_SERDES_DPT:
422                 hw->mac_type = e1000_80003es2lan;
423                 break;
424         case E1000_DEV_ID_ICH8_IGP_M_AMT:
425         case E1000_DEV_ID_ICH8_IGP_AMT:
426         case E1000_DEV_ID_ICH8_IGP_C:
427         case E1000_DEV_ID_ICH8_IFE:
428         case E1000_DEV_ID_ICH8_IFE_GT:
429         case E1000_DEV_ID_ICH8_IFE_G:
430         case E1000_DEV_ID_ICH8_IGP_M:
431                 hw->mac_type = e1000_ich8lan;
432                 break;
433         default:
434                 /* Should never have loaded on this device */
435                 return -E1000_ERR_MAC_TYPE;
436         }
437
438         switch (hw->mac_type) {
439         case e1000_ich8lan:
440                 hw->swfwhw_semaphore_present = true;
441                 hw->asf_firmware_present = true;
442                 break;
443         case e1000_80003es2lan:
444                 hw->swfw_sync_present = true;
445                 /* fall through */
446         case e1000_82571:
447         case e1000_82572:
448         case e1000_82573:
449                 hw->eeprom_semaphore_present = true;
450                 /* fall through */
451         case e1000_82541:
452         case e1000_82547:
453         case e1000_82541_rev_2:
454         case e1000_82547_rev_2:
455                 hw->asf_firmware_present = true;
456                 break;
457         default:
458                 break;
459         }
460
461         /* The 82543 chip does not count tx_carrier_errors properly in
462          * FD mode
463          */
464         if (hw->mac_type == e1000_82543)
465                 hw->bad_tx_carr_stats_fd = true;
466
467         /* capable of receiving management packets to the host */
468         if (hw->mac_type >= e1000_82571)
469                 hw->has_manc2h = true;
470
471         /* In rare occasions, ESB2 systems would end up started without
472          * the RX unit being turned on.
473          */
474         if (hw->mac_type == e1000_80003es2lan)
475                 hw->rx_needs_kicking = true;
476
477         if (hw->mac_type > e1000_82544)
478                 hw->has_smbus = true;
479
480         return E1000_SUCCESS;
481 }
482
483 /*****************************************************************************
484  * Set media type and TBI compatibility.
485  *
486  * hw - Struct containing variables accessed by shared code
487  * **************************************************************************/
488 void e1000_set_media_type(struct e1000_hw *hw)
489 {
490     u32 status;
491
492     DEBUGFUNC("e1000_set_media_type");
493
494     if (hw->mac_type != e1000_82543) {
495         /* tbi_compatibility is only valid on 82543 */
496         hw->tbi_compatibility_en = false;
497     }
498
499     switch (hw->device_id) {
500     case E1000_DEV_ID_82545GM_SERDES:
501     case E1000_DEV_ID_82546GB_SERDES:
502     case E1000_DEV_ID_82571EB_SERDES:
503     case E1000_DEV_ID_82571EB_SERDES_DUAL:
504     case E1000_DEV_ID_82571EB_SERDES_QUAD:
505     case E1000_DEV_ID_82572EI_SERDES:
506     case E1000_DEV_ID_80003ES2LAN_SERDES_DPT:
507         hw->media_type = e1000_media_type_internal_serdes;
508         break;
509     default:
510         switch (hw->mac_type) {
511         case e1000_82542_rev2_0:
512         case e1000_82542_rev2_1:
513             hw->media_type = e1000_media_type_fiber;
514             break;
515         case e1000_ich8lan:
516         case e1000_82573:
517             /* The STATUS_TBIMODE bit is reserved or reused for the this
518              * device.
519              */
520             hw->media_type = e1000_media_type_copper;
521             break;
522         default:
523             status = er32(STATUS);
524             if (status & E1000_STATUS_TBIMODE) {
525                 hw->media_type = e1000_media_type_fiber;
526                 /* tbi_compatibility not valid on fiber */
527                 hw->tbi_compatibility_en = false;
528             } else {
529                 hw->media_type = e1000_media_type_copper;
530             }
531             break;
532         }
533     }
534 }
535
536 /******************************************************************************
537  * Reset the transmit and receive units; mask and clear all interrupts.
538  *
539  * hw - Struct containing variables accessed by shared code
540  *****************************************************************************/
541 s32 e1000_reset_hw(struct e1000_hw *hw)
542 {
543     u32 ctrl;
544     u32 ctrl_ext;
545     u32 icr;
546     u32 manc;
547     u32 led_ctrl;
548     u32 timeout;
549     u32 extcnf_ctrl;
550     s32 ret_val;
551
552     DEBUGFUNC("e1000_reset_hw");
553
554     /* For 82542 (rev 2.0), disable MWI before issuing a device reset */
555     if (hw->mac_type == e1000_82542_rev2_0) {
556         DEBUGOUT("Disabling MWI on 82542 rev 2.0\n");
557         e1000_pci_clear_mwi(hw);
558     }
559
560     if (hw->bus_type == e1000_bus_type_pci_express) {
561         /* Prevent the PCI-E bus from sticking if there is no TLP connection
562          * on the last TLP read/write transaction when MAC is reset.
563          */
564         if (e1000_disable_pciex_master(hw) != E1000_SUCCESS) {
565             DEBUGOUT("PCI-E Master disable polling has failed.\n");
566         }
567     }
568
569     /* Clear interrupt mask to stop board from generating interrupts */
570     DEBUGOUT("Masking off all interrupts\n");
571     ew32(IMC, 0xffffffff);
572
573     /* Disable the Transmit and Receive units.  Then delay to allow
574      * any pending transactions to complete before we hit the MAC with
575      * the global reset.
576      */
577     ew32(RCTL, 0);
578     ew32(TCTL, E1000_TCTL_PSP);
579     E1000_WRITE_FLUSH();
580
581     /* The tbi_compatibility_on Flag must be cleared when Rctl is cleared. */
582     hw->tbi_compatibility_on = false;
583
584     /* Delay to allow any outstanding PCI transactions to complete before
585      * resetting the device
586      */
587     msleep(10);
588
589     ctrl = er32(CTRL);
590
591     /* Must reset the PHY before resetting the MAC */
592     if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
593         ew32(CTRL, (ctrl | E1000_CTRL_PHY_RST));
594         msleep(5);
595     }
596
597     /* Must acquire the MDIO ownership before MAC reset.
598      * Ownership defaults to firmware after a reset. */
599     if (hw->mac_type == e1000_82573) {
600         timeout = 10;
601
602         extcnf_ctrl = er32(EXTCNF_CTRL);
603         extcnf_ctrl |= E1000_EXTCNF_CTRL_MDIO_SW_OWNERSHIP;
604
605         do {
606             ew32(EXTCNF_CTRL, extcnf_ctrl);
607             extcnf_ctrl = er32(EXTCNF_CTRL);
608
609             if (extcnf_ctrl & E1000_EXTCNF_CTRL_MDIO_SW_OWNERSHIP)
610                 break;
611             else
612                 extcnf_ctrl |= E1000_EXTCNF_CTRL_MDIO_SW_OWNERSHIP;
613
614             msleep(2);
615             timeout--;
616         } while (timeout);
617     }
618
619     /* Workaround for ICH8 bit corruption issue in FIFO memory */
620     if (hw->mac_type == e1000_ich8lan) {
621         /* Set Tx and Rx buffer allocation to 8k apiece. */
622         ew32(PBA, E1000_PBA_8K);
623         /* Set Packet Buffer Size to 16k. */
624         ew32(PBS, E1000_PBS_16K);
625     }
626
627     /* Issue a global reset to the MAC.  This will reset the chip's
628      * transmit, receive, DMA, and link units.  It will not effect
629      * the current PCI configuration.  The global reset bit is self-
630      * clearing, and should clear within a microsecond.
631      */
632     DEBUGOUT("Issuing a global reset to MAC\n");
633
634     switch (hw->mac_type) {
635         case e1000_82544:
636         case e1000_82540:
637         case e1000_82545:
638         case e1000_82546:
639         case e1000_82541:
640         case e1000_82541_rev_2:
641             /* These controllers can't ack the 64-bit write when issuing the
642              * reset, so use IO-mapping as a workaround to issue the reset */
643             E1000_WRITE_REG_IO(hw, CTRL, (ctrl | E1000_CTRL_RST));
644             break;
645         case e1000_82545_rev_3:
646         case e1000_82546_rev_3:
647             /* Reset is performed on a shadow of the control register */
648             ew32(CTRL_DUP, (ctrl | E1000_CTRL_RST));
649             break;
650         case e1000_ich8lan:
651             if (!hw->phy_reset_disable &&
652                 e1000_check_phy_reset_block(hw) == E1000_SUCCESS) {
653                 /* e1000_ich8lan PHY HW reset requires MAC CORE reset
654                  * at the same time to make sure the interface between
655                  * MAC and the external PHY is reset.
656                  */
657                 ctrl |= E1000_CTRL_PHY_RST;
658             }
659
660             e1000_get_software_flag(hw);
661             ew32(CTRL, (ctrl | E1000_CTRL_RST));
662             msleep(5);
663             break;
664         default:
665             ew32(CTRL, (ctrl | E1000_CTRL_RST));
666             break;
667     }
668
669     /* After MAC reset, force reload of EEPROM to restore power-on settings to
670      * device.  Later controllers reload the EEPROM automatically, so just wait
671      * for reload to complete.
672      */
673     switch (hw->mac_type) {
674         case e1000_82542_rev2_0:
675         case e1000_82542_rev2_1:
676         case e1000_82543:
677         case e1000_82544:
678             /* Wait for reset to complete */
679             udelay(10);
680             ctrl_ext = er32(CTRL_EXT);
681             ctrl_ext |= E1000_CTRL_EXT_EE_RST;
682             ew32(CTRL_EXT, ctrl_ext);
683             E1000_WRITE_FLUSH();
684             /* Wait for EEPROM reload */
685             msleep(2);
686             break;
687         case e1000_82541:
688         case e1000_82541_rev_2:
689         case e1000_82547:
690         case e1000_82547_rev_2:
691             /* Wait for EEPROM reload */
692             msleep(20);
693             break;
694         case e1000_82573:
695             if (!e1000_is_onboard_nvm_eeprom(hw)) {
696                 udelay(10);
697                 ctrl_ext = er32(CTRL_EXT);
698                 ctrl_ext |= E1000_CTRL_EXT_EE_RST;
699                 ew32(CTRL_EXT, ctrl_ext);
700                 E1000_WRITE_FLUSH();
701             }
702             /* fall through */
703         default:
704             /* Auto read done will delay 5ms or poll based on mac type */
705             ret_val = e1000_get_auto_rd_done(hw);
706             if (ret_val)
707                 return ret_val;
708             break;
709     }
710
711     /* Disable HW ARPs on ASF enabled adapters */
712     if (hw->mac_type >= e1000_82540 && hw->mac_type <= e1000_82547_rev_2) {
713         manc = er32(MANC);
714         manc &= ~(E1000_MANC_ARP_EN);
715         ew32(MANC, manc);
716     }
717
718     if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
719         e1000_phy_init_script(hw);
720
721         /* Configure activity LED after PHY reset */
722         led_ctrl = er32(LEDCTL);
723         led_ctrl &= IGP_ACTIVITY_LED_MASK;
724         led_ctrl |= (IGP_ACTIVITY_LED_ENABLE | IGP_LED3_MODE);
725         ew32(LEDCTL, led_ctrl);
726     }
727
728     /* Clear interrupt mask to stop board from generating interrupts */
729     DEBUGOUT("Masking off all interrupts\n");
730     ew32(IMC, 0xffffffff);
731
732     /* Clear any pending interrupt events. */
733     icr = er32(ICR);
734
735     /* If MWI was previously enabled, reenable it. */
736     if (hw->mac_type == e1000_82542_rev2_0) {
737         if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE)
738             e1000_pci_set_mwi(hw);
739     }
740
741     if (hw->mac_type == e1000_ich8lan) {
742         u32 kab = er32(KABGTXD);
743         kab |= E1000_KABGTXD_BGSQLBIAS;
744         ew32(KABGTXD, kab);
745     }
746
747     return E1000_SUCCESS;
748 }
749
750 /******************************************************************************
751  *
752  * Initialize a number of hardware-dependent bits
753  *
754  * hw: Struct containing variables accessed by shared code
755  *
756  * This function contains hardware limitation workarounds for PCI-E adapters
757  *
758  *****************************************************************************/
759 static void e1000_initialize_hardware_bits(struct e1000_hw *hw)
760 {
761     if ((hw->mac_type >= e1000_82571) && (!hw->initialize_hw_bits_disable)) {
762         /* Settings common to all PCI-express silicon */
763         u32 reg_ctrl, reg_ctrl_ext;
764         u32 reg_tarc0, reg_tarc1;
765         u32 reg_tctl;
766         u32 reg_txdctl, reg_txdctl1;
767
768         /* link autonegotiation/sync workarounds */
769         reg_tarc0 = er32(TARC0);
770         reg_tarc0 &= ~((1 << 30)|(1 << 29)|(1 << 28)|(1 << 27));
771
772         /* Enable not-done TX descriptor counting */
773         reg_txdctl = er32(TXDCTL);
774         reg_txdctl |= E1000_TXDCTL_COUNT_DESC;
775         ew32(TXDCTL, reg_txdctl);
776         reg_txdctl1 = er32(TXDCTL1);
777         reg_txdctl1 |= E1000_TXDCTL_COUNT_DESC;
778         ew32(TXDCTL1, reg_txdctl1);
779
780         switch (hw->mac_type) {
781             case e1000_82571:
782             case e1000_82572:
783                 /* Clear PHY TX compatible mode bits */
784                 reg_tarc1 = er32(TARC1);
785                 reg_tarc1 &= ~((1 << 30)|(1 << 29));
786
787                 /* link autonegotiation/sync workarounds */
788                 reg_tarc0 |= ((1 << 26)|(1 << 25)|(1 << 24)|(1 << 23));
789
790                 /* TX ring control fixes */
791                 reg_tarc1 |= ((1 << 26)|(1 << 25)|(1 << 24));
792
793                 /* Multiple read bit is reversed polarity */
794                 reg_tctl = er32(TCTL);
795                 if (reg_tctl & E1000_TCTL_MULR)
796                     reg_tarc1 &= ~(1 << 28);
797                 else
798                     reg_tarc1 |= (1 << 28);
799
800                 ew32(TARC1, reg_tarc1);
801                 break;
802             case e1000_82573:
803                 reg_ctrl_ext = er32(CTRL_EXT);
804                 reg_ctrl_ext &= ~(1 << 23);
805                 reg_ctrl_ext |= (1 << 22);
806
807                 /* TX byte count fix */
808                 reg_ctrl = er32(CTRL);
809                 reg_ctrl &= ~(1 << 29);
810
811                 ew32(CTRL_EXT, reg_ctrl_ext);
812                 ew32(CTRL, reg_ctrl);
813                 break;
814             case e1000_80003es2lan:
815                 /* improve small packet performace for fiber/serdes */
816                 if ((hw->media_type == e1000_media_type_fiber) ||
817                     (hw->media_type == e1000_media_type_internal_serdes)) {
818                     reg_tarc0 &= ~(1 << 20);
819                 }
820
821                 /* Multiple read bit is reversed polarity */
822                 reg_tctl = er32(TCTL);
823                 reg_tarc1 = er32(TARC1);
824                 if (reg_tctl & E1000_TCTL_MULR)
825                     reg_tarc1 &= ~(1 << 28);
826                 else
827                     reg_tarc1 |= (1 << 28);
828
829                 ew32(TARC1, reg_tarc1);
830                 break;
831             case e1000_ich8lan:
832                 /* Reduce concurrent DMA requests to 3 from 4 */
833                 if ((hw->revision_id < 3) ||
834                     ((hw->device_id != E1000_DEV_ID_ICH8_IGP_M_AMT) &&
835                      (hw->device_id != E1000_DEV_ID_ICH8_IGP_M)))
836                     reg_tarc0 |= ((1 << 29)|(1 << 28));
837
838                 reg_ctrl_ext = er32(CTRL_EXT);
839                 reg_ctrl_ext |= (1 << 22);
840                 ew32(CTRL_EXT, reg_ctrl_ext);
841
842                 /* workaround TX hang with TSO=on */
843                 reg_tarc0 |= ((1 << 27)|(1 << 26)|(1 << 24)|(1 << 23));
844
845                 /* Multiple read bit is reversed polarity */
846                 reg_tctl = er32(TCTL);
847                 reg_tarc1 = er32(TARC1);
848                 if (reg_tctl & E1000_TCTL_MULR)
849                     reg_tarc1 &= ~(1 << 28);
850                 else
851                     reg_tarc1 |= (1 << 28);
852
853                 /* workaround TX hang with TSO=on */
854                 reg_tarc1 |= ((1 << 30)|(1 << 26)|(1 << 24));
855
856                 ew32(TARC1, reg_tarc1);
857                 break;
858             default:
859                 break;
860         }
861
862         ew32(TARC0, reg_tarc0);
863     }
864 }
865
866 /******************************************************************************
867  * Performs basic configuration of the adapter.
868  *
869  * hw - Struct containing variables accessed by shared code
870  *
871  * Assumes that the controller has previously been reset and is in a
872  * post-reset uninitialized state. Initializes the receive address registers,
873  * multicast table, and VLAN filter table. Calls routines to setup link
874  * configuration and flow control settings. Clears all on-chip counters. Leaves
875  * the transmit and receive units disabled and uninitialized.
876  *****************************************************************************/
877 s32 e1000_init_hw(struct e1000_hw *hw)
878 {
879     u32 ctrl;
880     u32 i;
881     s32 ret_val;
882     u32 mta_size;
883     u32 reg_data;
884     u32 ctrl_ext;
885
886     DEBUGFUNC("e1000_init_hw");
887
888     /* force full DMA clock frequency for 10/100 on ICH8 A0-B0 */
889     if ((hw->mac_type == e1000_ich8lan) &&
890         ((hw->revision_id < 3) ||
891          ((hw->device_id != E1000_DEV_ID_ICH8_IGP_M_AMT) &&
892           (hw->device_id != E1000_DEV_ID_ICH8_IGP_M)))) {
893             reg_data = er32(STATUS);
894             reg_data &= ~0x80000000;
895             ew32(STATUS, reg_data);
896     }
897
898     /* Initialize Identification LED */
899     ret_val = e1000_id_led_init(hw);
900     if (ret_val) {
901         DEBUGOUT("Error Initializing Identification LED\n");
902         return ret_val;
903     }
904
905     /* Set the media type and TBI compatibility */
906     e1000_set_media_type(hw);
907
908     /* Must be called after e1000_set_media_type because media_type is used */
909     e1000_initialize_hardware_bits(hw);
910
911     /* Disabling VLAN filtering. */
912     DEBUGOUT("Initializing the IEEE VLAN\n");
913     /* VET hardcoded to standard value and VFTA removed in ICH8 LAN */
914     if (hw->mac_type != e1000_ich8lan) {
915         if (hw->mac_type < e1000_82545_rev_3)
916             ew32(VET, 0);
917         e1000_clear_vfta(hw);
918     }
919
920     /* For 82542 (rev 2.0), disable MWI and put the receiver into reset */
921     if (hw->mac_type == e1000_82542_rev2_0) {
922         DEBUGOUT("Disabling MWI on 82542 rev 2.0\n");
923         e1000_pci_clear_mwi(hw);
924         ew32(RCTL, E1000_RCTL_RST);
925         E1000_WRITE_FLUSH();
926         msleep(5);
927     }
928
929     /* Setup the receive address. This involves initializing all of the Receive
930      * Address Registers (RARs 0 - 15).
931      */
932     e1000_init_rx_addrs(hw);
933
934     /* For 82542 (rev 2.0), take the receiver out of reset and enable MWI */
935     if (hw->mac_type == e1000_82542_rev2_0) {
936         ew32(RCTL, 0);
937         E1000_WRITE_FLUSH();
938         msleep(1);
939         if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE)
940             e1000_pci_set_mwi(hw);
941     }
942
943     /* Zero out the Multicast HASH table */
944     DEBUGOUT("Zeroing the MTA\n");
945     mta_size = E1000_MC_TBL_SIZE;
946     if (hw->mac_type == e1000_ich8lan)
947         mta_size = E1000_MC_TBL_SIZE_ICH8LAN;
948     for (i = 0; i < mta_size; i++) {
949         E1000_WRITE_REG_ARRAY(hw, MTA, i, 0);
950         /* use write flush to prevent Memory Write Block (MWB) from
951          * occuring when accessing our register space */
952         E1000_WRITE_FLUSH();
953     }
954
955     /* Set the PCI priority bit correctly in the CTRL register.  This
956      * determines if the adapter gives priority to receives, or if it
957      * gives equal priority to transmits and receives.  Valid only on
958      * 82542 and 82543 silicon.
959      */
960     if (hw->dma_fairness && hw->mac_type <= e1000_82543) {
961         ctrl = er32(CTRL);
962         ew32(CTRL, ctrl | E1000_CTRL_PRIOR);
963     }
964
965     switch (hw->mac_type) {
966     case e1000_82545_rev_3:
967     case e1000_82546_rev_3:
968         break;
969     default:
970         /* Workaround for PCI-X problem when BIOS sets MMRBC incorrectly. */
971         if (hw->bus_type == e1000_bus_type_pcix && e1000_pcix_get_mmrbc(hw) > 2048)
972                 e1000_pcix_set_mmrbc(hw, 2048);
973         break;
974     }
975
976     /* More time needed for PHY to initialize */
977     if (hw->mac_type == e1000_ich8lan)
978         msleep(15);
979
980     /* Call a subroutine to configure the link and setup flow control. */
981     ret_val = e1000_setup_link(hw);
982
983     /* Set the transmit descriptor write-back policy */
984     if (hw->mac_type > e1000_82544) {
985         ctrl = er32(TXDCTL);
986         ctrl = (ctrl & ~E1000_TXDCTL_WTHRESH) | E1000_TXDCTL_FULL_TX_DESC_WB;
987         ew32(TXDCTL, ctrl);
988     }
989
990     if (hw->mac_type == e1000_82573) {
991         e1000_enable_tx_pkt_filtering(hw);
992     }
993
994     switch (hw->mac_type) {
995     default:
996         break;
997     case e1000_80003es2lan:
998         /* Enable retransmit on late collisions */
999         reg_data = er32(TCTL);
1000         reg_data |= E1000_TCTL_RTLC;
1001         ew32(TCTL, reg_data);
1002
1003         /* Configure Gigabit Carry Extend Padding */
1004         reg_data = er32(TCTL_EXT);
1005         reg_data &= ~E1000_TCTL_EXT_GCEX_MASK;
1006         reg_data |= DEFAULT_80003ES2LAN_TCTL_EXT_GCEX;
1007         ew32(TCTL_EXT, reg_data);
1008
1009         /* Configure Transmit Inter-Packet Gap */
1010         reg_data = er32(TIPG);
1011         reg_data &= ~E1000_TIPG_IPGT_MASK;
1012         reg_data |= DEFAULT_80003ES2LAN_TIPG_IPGT_1000;
1013         ew32(TIPG, reg_data);
1014
1015         reg_data = E1000_READ_REG_ARRAY(hw, FFLT, 0x0001);
1016         reg_data &= ~0x00100000;
1017         E1000_WRITE_REG_ARRAY(hw, FFLT, 0x0001, reg_data);
1018         /* Fall through */
1019     case e1000_82571:
1020     case e1000_82572:
1021     case e1000_ich8lan:
1022         ctrl = er32(TXDCTL1);
1023         ctrl = (ctrl & ~E1000_TXDCTL_WTHRESH) | E1000_TXDCTL_FULL_TX_DESC_WB;
1024         ew32(TXDCTL1, ctrl);
1025         break;
1026     }
1027
1028
1029     if (hw->mac_type == e1000_82573) {
1030         u32 gcr = er32(GCR);
1031         gcr |= E1000_GCR_L1_ACT_WITHOUT_L0S_RX;
1032         ew32(GCR, gcr);
1033     }
1034
1035     /* Clear all of the statistics registers (clear on read).  It is
1036      * important that we do this after we have tried to establish link
1037      * because the symbol error count will increment wildly if there
1038      * is no link.
1039      */
1040     e1000_clear_hw_cntrs(hw);
1041
1042     /* ICH8 No-snoop bits are opposite polarity.
1043      * Set to snoop by default after reset. */
1044     if (hw->mac_type == e1000_ich8lan)
1045         e1000_set_pci_ex_no_snoop(hw, PCI_EX_82566_SNOOP_ALL);
1046
1047     if (hw->device_id == E1000_DEV_ID_82546GB_QUAD_COPPER ||
1048         hw->device_id == E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3) {
1049         ctrl_ext = er32(CTRL_EXT);
1050         /* Relaxed ordering must be disabled to avoid a parity
1051          * error crash in a PCI slot. */
1052         ctrl_ext |= E1000_CTRL_EXT_RO_DIS;
1053         ew32(CTRL_EXT, ctrl_ext);
1054     }
1055
1056     return ret_val;
1057 }
1058
1059 /******************************************************************************
1060  * Adjust SERDES output amplitude based on EEPROM setting.
1061  *
1062  * hw - Struct containing variables accessed by shared code.
1063  *****************************************************************************/
1064 static s32 e1000_adjust_serdes_amplitude(struct e1000_hw *hw)
1065 {
1066     u16 eeprom_data;
1067     s32  ret_val;
1068
1069     DEBUGFUNC("e1000_adjust_serdes_amplitude");
1070
1071     if (hw->media_type != e1000_media_type_internal_serdes)
1072         return E1000_SUCCESS;
1073
1074     switch (hw->mac_type) {
1075     case e1000_82545_rev_3:
1076     case e1000_82546_rev_3:
1077         break;
1078     default:
1079         return E1000_SUCCESS;
1080     }
1081
1082     ret_val = e1000_read_eeprom(hw, EEPROM_SERDES_AMPLITUDE, 1, &eeprom_data);
1083     if (ret_val) {
1084         return ret_val;
1085     }
1086
1087     if (eeprom_data != EEPROM_RESERVED_WORD) {
1088         /* Adjust SERDES output amplitude only. */
1089         eeprom_data &= EEPROM_SERDES_AMPLITUDE_MASK;
1090         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_EXT_CTRL, eeprom_data);
1091         if (ret_val)
1092             return ret_val;
1093     }
1094
1095     return E1000_SUCCESS;
1096 }
1097
1098 /******************************************************************************
1099  * Configures flow control and link settings.
1100  *
1101  * hw - Struct containing variables accessed by shared code
1102  *
1103  * Determines which flow control settings to use. Calls the apropriate media-
1104  * specific link configuration function. Configures the flow control settings.
1105  * Assuming the adapter has a valid link partner, a valid link should be
1106  * established. Assumes the hardware has previously been reset and the
1107  * transmitter and receiver are not enabled.
1108  *****************************************************************************/
1109 s32 e1000_setup_link(struct e1000_hw *hw)
1110 {
1111     u32 ctrl_ext;
1112     s32 ret_val;
1113     u16 eeprom_data;
1114
1115     DEBUGFUNC("e1000_setup_link");
1116
1117     /* In the case of the phy reset being blocked, we already have a link.
1118      * We do not have to set it up again. */
1119     if (e1000_check_phy_reset_block(hw))
1120         return E1000_SUCCESS;
1121
1122     /* Read and store word 0x0F of the EEPROM. This word contains bits
1123      * that determine the hardware's default PAUSE (flow control) mode,
1124      * a bit that determines whether the HW defaults to enabling or
1125      * disabling auto-negotiation, and the direction of the
1126      * SW defined pins. If there is no SW over-ride of the flow
1127      * control setting, then the variable hw->fc will
1128      * be initialized based on a value in the EEPROM.
1129      */
1130     if (hw->fc == E1000_FC_DEFAULT) {
1131         switch (hw->mac_type) {
1132         case e1000_ich8lan:
1133         case e1000_82573:
1134             hw->fc = E1000_FC_FULL;
1135             break;
1136         default:
1137             ret_val = e1000_read_eeprom(hw, EEPROM_INIT_CONTROL2_REG,
1138                                         1, &eeprom_data);
1139             if (ret_val) {
1140                 DEBUGOUT("EEPROM Read Error\n");
1141                 return -E1000_ERR_EEPROM;
1142             }
1143             if ((eeprom_data & EEPROM_WORD0F_PAUSE_MASK) == 0)
1144                 hw->fc = E1000_FC_NONE;
1145             else if ((eeprom_data & EEPROM_WORD0F_PAUSE_MASK) ==
1146                     EEPROM_WORD0F_ASM_DIR)
1147                 hw->fc = E1000_FC_TX_PAUSE;
1148             else
1149                 hw->fc = E1000_FC_FULL;
1150             break;
1151         }
1152     }
1153
1154     /* We want to save off the original Flow Control configuration just
1155      * in case we get disconnected and then reconnected into a different
1156      * hub or switch with different Flow Control capabilities.
1157      */
1158     if (hw->mac_type == e1000_82542_rev2_0)
1159         hw->fc &= (~E1000_FC_TX_PAUSE);
1160
1161     if ((hw->mac_type < e1000_82543) && (hw->report_tx_early == 1))
1162         hw->fc &= (~E1000_FC_RX_PAUSE);
1163
1164     hw->original_fc = hw->fc;
1165
1166     DEBUGOUT1("After fix-ups FlowControl is now = %x\n", hw->fc);
1167
1168     /* Take the 4 bits from EEPROM word 0x0F that determine the initial
1169      * polarity value for the SW controlled pins, and setup the
1170      * Extended Device Control reg with that info.
1171      * This is needed because one of the SW controlled pins is used for
1172      * signal detection.  So this should be done before e1000_setup_pcs_link()
1173      * or e1000_phy_setup() is called.
1174      */
1175     if (hw->mac_type == e1000_82543) {
1176         ret_val = e1000_read_eeprom(hw, EEPROM_INIT_CONTROL2_REG,
1177                                     1, &eeprom_data);
1178         if (ret_val) {
1179             DEBUGOUT("EEPROM Read Error\n");
1180             return -E1000_ERR_EEPROM;
1181         }
1182         ctrl_ext = ((eeprom_data & EEPROM_WORD0F_SWPDIO_EXT) <<
1183                     SWDPIO__EXT_SHIFT);
1184         ew32(CTRL_EXT, ctrl_ext);
1185     }
1186
1187     /* Call the necessary subroutine to configure the link. */
1188     ret_val = (hw->media_type == e1000_media_type_copper) ?
1189               e1000_setup_copper_link(hw) :
1190               e1000_setup_fiber_serdes_link(hw);
1191
1192     /* Initialize the flow control address, type, and PAUSE timer
1193      * registers to their default values.  This is done even if flow
1194      * control is disabled, because it does not hurt anything to
1195      * initialize these registers.
1196      */
1197     DEBUGOUT("Initializing the Flow Control address, type and timer regs\n");
1198
1199     /* FCAL/H and FCT are hardcoded to standard values in e1000_ich8lan. */
1200     if (hw->mac_type != e1000_ich8lan) {
1201         ew32(FCT, FLOW_CONTROL_TYPE);
1202         ew32(FCAH, FLOW_CONTROL_ADDRESS_HIGH);
1203         ew32(FCAL, FLOW_CONTROL_ADDRESS_LOW);
1204     }
1205
1206     ew32(FCTTV, hw->fc_pause_time);
1207
1208     /* Set the flow control receive threshold registers.  Normally,
1209      * these registers will be set to a default threshold that may be
1210      * adjusted later by the driver's runtime code.  However, if the
1211      * ability to transmit pause frames in not enabled, then these
1212      * registers will be set to 0.
1213      */
1214     if (!(hw->fc & E1000_FC_TX_PAUSE)) {
1215         ew32(FCRTL, 0);
1216         ew32(FCRTH, 0);
1217     } else {
1218         /* We need to set up the Receive Threshold high and low water marks
1219          * as well as (optionally) enabling the transmission of XON frames.
1220          */
1221         if (hw->fc_send_xon) {
1222             ew32(FCRTL, (hw->fc_low_water | E1000_FCRTL_XONE));
1223             ew32(FCRTH, hw->fc_high_water);
1224         } else {
1225             ew32(FCRTL, hw->fc_low_water);
1226             ew32(FCRTH, hw->fc_high_water);
1227         }
1228     }
1229     return ret_val;
1230 }
1231
1232 /******************************************************************************
1233  * Sets up link for a fiber based or serdes based adapter
1234  *
1235  * hw - Struct containing variables accessed by shared code
1236  *
1237  * Manipulates Physical Coding Sublayer functions in order to configure
1238  * link. Assumes the hardware has been previously reset and the transmitter
1239  * and receiver are not enabled.
1240  *****************************************************************************/
1241 static s32 e1000_setup_fiber_serdes_link(struct e1000_hw *hw)
1242 {
1243     u32 ctrl;
1244     u32 status;
1245     u32 txcw = 0;
1246     u32 i;
1247     u32 signal = 0;
1248     s32 ret_val;
1249
1250     DEBUGFUNC("e1000_setup_fiber_serdes_link");
1251
1252     /* On 82571 and 82572 Fiber connections, SerDes loopback mode persists
1253      * until explicitly turned off or a power cycle is performed.  A read to
1254      * the register does not indicate its status.  Therefore, we ensure
1255      * loopback mode is disabled during initialization.
1256      */
1257     if (hw->mac_type == e1000_82571 || hw->mac_type == e1000_82572)
1258         ew32(SCTL, E1000_DISABLE_SERDES_LOOPBACK);
1259
1260     /* On adapters with a MAC newer than 82544, SWDP 1 will be
1261      * set when the optics detect a signal. On older adapters, it will be
1262      * cleared when there is a signal.  This applies to fiber media only.
1263      * If we're on serdes media, adjust the output amplitude to value
1264      * set in the EEPROM.
1265      */
1266     ctrl = er32(CTRL);
1267     if (hw->media_type == e1000_media_type_fiber)
1268         signal = (hw->mac_type > e1000_82544) ? E1000_CTRL_SWDPIN1 : 0;
1269
1270     ret_val = e1000_adjust_serdes_amplitude(hw);
1271     if (ret_val)
1272         return ret_val;
1273
1274     /* Take the link out of reset */
1275     ctrl &= ~(E1000_CTRL_LRST);
1276
1277     /* Adjust VCO speed to improve BER performance */
1278     ret_val = e1000_set_vco_speed(hw);
1279     if (ret_val)
1280         return ret_val;
1281
1282     e1000_config_collision_dist(hw);
1283
1284     /* Check for a software override of the flow control settings, and setup
1285      * the device accordingly.  If auto-negotiation is enabled, then software
1286      * will have to set the "PAUSE" bits to the correct value in the Tranmsit
1287      * Config Word Register (TXCW) and re-start auto-negotiation.  However, if
1288      * auto-negotiation is disabled, then software will have to manually
1289      * configure the two flow control enable bits in the CTRL register.
1290      *
1291      * The possible values of the "fc" parameter are:
1292      *      0:  Flow control is completely disabled
1293      *      1:  Rx flow control is enabled (we can receive pause frames, but
1294      *          not send pause frames).
1295      *      2:  Tx flow control is enabled (we can send pause frames but we do
1296      *          not support receiving pause frames).
1297      *      3:  Both Rx and TX flow control (symmetric) are enabled.
1298      */
1299     switch (hw->fc) {
1300     case E1000_FC_NONE:
1301         /* Flow control is completely disabled by a software over-ride. */
1302         txcw = (E1000_TXCW_ANE | E1000_TXCW_FD);
1303         break;
1304     case E1000_FC_RX_PAUSE:
1305         /* RX Flow control is enabled and TX Flow control is disabled by a
1306          * software over-ride. Since there really isn't a way to advertise
1307          * that we are capable of RX Pause ONLY, we will advertise that we
1308          * support both symmetric and asymmetric RX PAUSE. Later, we will
1309          *  disable the adapter's ability to send PAUSE frames.
1310          */
1311         txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
1312         break;
1313     case E1000_FC_TX_PAUSE:
1314         /* TX Flow control is enabled, and RX Flow control is disabled, by a
1315          * software over-ride.
1316          */
1317         txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_ASM_DIR);
1318         break;
1319     case E1000_FC_FULL:
1320         /* Flow control (both RX and TX) is enabled by a software over-ride. */
1321         txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
1322         break;
1323     default:
1324         DEBUGOUT("Flow control param set incorrectly\n");
1325         return -E1000_ERR_CONFIG;
1326         break;
1327     }
1328
1329     /* Since auto-negotiation is enabled, take the link out of reset (the link
1330      * will be in reset, because we previously reset the chip). This will
1331      * restart auto-negotiation.  If auto-neogtiation is successful then the
1332      * link-up status bit will be set and the flow control enable bits (RFCE
1333      * and TFCE) will be set according to their negotiated value.
1334      */
1335     DEBUGOUT("Auto-negotiation enabled\n");
1336
1337     ew32(TXCW, txcw);
1338     ew32(CTRL, ctrl);
1339     E1000_WRITE_FLUSH();
1340
1341     hw->txcw = txcw;
1342     msleep(1);
1343
1344     /* If we have a signal (the cable is plugged in) then poll for a "Link-Up"
1345      * indication in the Device Status Register.  Time-out if a link isn't
1346      * seen in 500 milliseconds seconds (Auto-negotiation should complete in
1347      * less than 500 milliseconds even if the other end is doing it in SW).
1348      * For internal serdes, we just assume a signal is present, then poll.
1349      */
1350     if (hw->media_type == e1000_media_type_internal_serdes ||
1351        (er32(CTRL) & E1000_CTRL_SWDPIN1) == signal) {
1352         DEBUGOUT("Looking for Link\n");
1353         for (i = 0; i < (LINK_UP_TIMEOUT / 10); i++) {
1354             msleep(10);
1355             status = er32(STATUS);
1356             if (status & E1000_STATUS_LU) break;
1357         }
1358         if (i == (LINK_UP_TIMEOUT / 10)) {
1359             DEBUGOUT("Never got a valid link from auto-neg!!!\n");
1360             hw->autoneg_failed = 1;
1361             /* AutoNeg failed to achieve a link, so we'll call
1362              * e1000_check_for_link. This routine will force the link up if
1363              * we detect a signal. This will allow us to communicate with
1364              * non-autonegotiating link partners.
1365              */
1366             ret_val = e1000_check_for_link(hw);
1367             if (ret_val) {
1368                 DEBUGOUT("Error while checking for link\n");
1369                 return ret_val;
1370             }
1371             hw->autoneg_failed = 0;
1372         } else {
1373             hw->autoneg_failed = 0;
1374             DEBUGOUT("Valid Link Found\n");
1375         }
1376     } else {
1377         DEBUGOUT("No Signal Detected\n");
1378     }
1379     return E1000_SUCCESS;
1380 }
1381
1382 /******************************************************************************
1383 * Make sure we have a valid PHY and change PHY mode before link setup.
1384 *
1385 * hw - Struct containing variables accessed by shared code
1386 ******************************************************************************/
1387 static s32 e1000_copper_link_preconfig(struct e1000_hw *hw)
1388 {
1389     u32 ctrl;
1390     s32 ret_val;
1391     u16 phy_data;
1392
1393     DEBUGFUNC("e1000_copper_link_preconfig");
1394
1395     ctrl = er32(CTRL);
1396     /* With 82543, we need to force speed and duplex on the MAC equal to what
1397      * the PHY speed and duplex configuration is. In addition, we need to
1398      * perform a hardware reset on the PHY to take it out of reset.
1399      */
1400     if (hw->mac_type > e1000_82543) {
1401         ctrl |= E1000_CTRL_SLU;
1402         ctrl &= ~(E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1403         ew32(CTRL, ctrl);
1404     } else {
1405         ctrl |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX | E1000_CTRL_SLU);
1406         ew32(CTRL, ctrl);
1407         ret_val = e1000_phy_hw_reset(hw);
1408         if (ret_val)
1409             return ret_val;
1410     }
1411
1412     /* Make sure we have a valid PHY */
1413     ret_val = e1000_detect_gig_phy(hw);
1414     if (ret_val) {
1415         DEBUGOUT("Error, did not detect valid phy.\n");
1416         return ret_val;
1417     }
1418     DEBUGOUT1("Phy ID = %x \n", hw->phy_id);
1419
1420     /* Set PHY to class A mode (if necessary) */
1421     ret_val = e1000_set_phy_mode(hw);
1422     if (ret_val)
1423         return ret_val;
1424
1425     if ((hw->mac_type == e1000_82545_rev_3) ||
1426        (hw->mac_type == e1000_82546_rev_3)) {
1427         ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1428         phy_data |= 0x00000008;
1429         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1430     }
1431
1432     if (hw->mac_type <= e1000_82543 ||
1433         hw->mac_type == e1000_82541 || hw->mac_type == e1000_82547 ||
1434         hw->mac_type == e1000_82541_rev_2 || hw->mac_type == e1000_82547_rev_2)
1435         hw->phy_reset_disable = false;
1436
1437    return E1000_SUCCESS;
1438 }
1439
1440
1441 /********************************************************************
1442 * Copper link setup for e1000_phy_igp series.
1443 *
1444 * hw - Struct containing variables accessed by shared code
1445 *********************************************************************/
1446 static s32 e1000_copper_link_igp_setup(struct e1000_hw *hw)
1447 {
1448     u32 led_ctrl;
1449     s32 ret_val;
1450     u16 phy_data;
1451
1452     DEBUGFUNC("e1000_copper_link_igp_setup");
1453
1454     if (hw->phy_reset_disable)
1455         return E1000_SUCCESS;
1456
1457     ret_val = e1000_phy_reset(hw);
1458     if (ret_val) {
1459         DEBUGOUT("Error Resetting the PHY\n");
1460         return ret_val;
1461     }
1462
1463     /* Wait 15ms for MAC to configure PHY from eeprom settings */
1464     msleep(15);
1465     if (hw->mac_type != e1000_ich8lan) {
1466     /* Configure activity LED after PHY reset */
1467     led_ctrl = er32(LEDCTL);
1468     led_ctrl &= IGP_ACTIVITY_LED_MASK;
1469     led_ctrl |= (IGP_ACTIVITY_LED_ENABLE | IGP_LED3_MODE);
1470     ew32(LEDCTL, led_ctrl);
1471     }
1472
1473     /* The NVM settings will configure LPLU in D3 for IGP2 and IGP3 PHYs */
1474     if (hw->phy_type == e1000_phy_igp) {
1475         /* disable lplu d3 during driver init */
1476         ret_val = e1000_set_d3_lplu_state(hw, false);
1477         if (ret_val) {
1478             DEBUGOUT("Error Disabling LPLU D3\n");
1479             return ret_val;
1480         }
1481     }
1482
1483     /* disable lplu d0 during driver init */
1484     ret_val = e1000_set_d0_lplu_state(hw, false);
1485     if (ret_val) {
1486         DEBUGOUT("Error Disabling LPLU D0\n");
1487         return ret_val;
1488     }
1489     /* Configure mdi-mdix settings */
1490     ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, &phy_data);
1491     if (ret_val)
1492         return ret_val;
1493
1494     if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
1495         hw->dsp_config_state = e1000_dsp_config_disabled;
1496         /* Force MDI for earlier revs of the IGP PHY */
1497         phy_data &= ~(IGP01E1000_PSCR_AUTO_MDIX | IGP01E1000_PSCR_FORCE_MDI_MDIX);
1498         hw->mdix = 1;
1499
1500     } else {
1501         hw->dsp_config_state = e1000_dsp_config_enabled;
1502         phy_data &= ~IGP01E1000_PSCR_AUTO_MDIX;
1503
1504         switch (hw->mdix) {
1505         case 1:
1506             phy_data &= ~IGP01E1000_PSCR_FORCE_MDI_MDIX;
1507             break;
1508         case 2:
1509             phy_data |= IGP01E1000_PSCR_FORCE_MDI_MDIX;
1510             break;
1511         case 0:
1512         default:
1513             phy_data |= IGP01E1000_PSCR_AUTO_MDIX;
1514             break;
1515         }
1516     }
1517     ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, phy_data);
1518     if (ret_val)
1519         return ret_val;
1520
1521     /* set auto-master slave resolution settings */
1522     if (hw->autoneg) {
1523         e1000_ms_type phy_ms_setting = hw->master_slave;
1524
1525         if (hw->ffe_config_state == e1000_ffe_config_active)
1526             hw->ffe_config_state = e1000_ffe_config_enabled;
1527
1528         if (hw->dsp_config_state == e1000_dsp_config_activated)
1529             hw->dsp_config_state = e1000_dsp_config_enabled;
1530
1531         /* when autonegotiation advertisment is only 1000Mbps then we
1532           * should disable SmartSpeed and enable Auto MasterSlave
1533           * resolution as hardware default. */
1534         if (hw->autoneg_advertised == ADVERTISE_1000_FULL) {
1535             /* Disable SmartSpeed */
1536             ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
1537                                          &phy_data);
1538             if (ret_val)
1539                 return ret_val;
1540             phy_data &= ~IGP01E1000_PSCFR_SMART_SPEED;
1541             ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
1542                                           phy_data);
1543             if (ret_val)
1544                 return ret_val;
1545             /* Set auto Master/Slave resolution process */
1546             ret_val = e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_data);
1547             if (ret_val)
1548                 return ret_val;
1549             phy_data &= ~CR_1000T_MS_ENABLE;
1550             ret_val = e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_data);
1551             if (ret_val)
1552                 return ret_val;
1553         }
1554
1555         ret_val = e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_data);
1556         if (ret_val)
1557             return ret_val;
1558
1559         /* load defaults for future use */
1560         hw->original_master_slave = (phy_data & CR_1000T_MS_ENABLE) ?
1561                                         ((phy_data & CR_1000T_MS_VALUE) ?
1562                                          e1000_ms_force_master :
1563                                          e1000_ms_force_slave) :
1564                                          e1000_ms_auto;
1565
1566         switch (phy_ms_setting) {
1567         case e1000_ms_force_master:
1568             phy_data |= (CR_1000T_MS_ENABLE | CR_1000T_MS_VALUE);
1569             break;
1570         case e1000_ms_force_slave:
1571             phy_data |= CR_1000T_MS_ENABLE;
1572             phy_data &= ~(CR_1000T_MS_VALUE);
1573             break;
1574         case e1000_ms_auto:
1575             phy_data &= ~CR_1000T_MS_ENABLE;
1576             default:
1577             break;
1578         }
1579         ret_val = e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_data);
1580         if (ret_val)
1581             return ret_val;
1582     }
1583
1584     return E1000_SUCCESS;
1585 }
1586
1587 /********************************************************************
1588 * Copper link setup for e1000_phy_gg82563 series.
1589 *
1590 * hw - Struct containing variables accessed by shared code
1591 *********************************************************************/
1592 static s32 e1000_copper_link_ggp_setup(struct e1000_hw *hw)
1593 {
1594     s32 ret_val;
1595     u16 phy_data;
1596     u32 reg_data;
1597
1598     DEBUGFUNC("e1000_copper_link_ggp_setup");
1599
1600     if (!hw->phy_reset_disable) {
1601
1602         /* Enable CRS on TX for half-duplex operation. */
1603         ret_val = e1000_read_phy_reg(hw, GG82563_PHY_MAC_SPEC_CTRL,
1604                                      &phy_data);
1605         if (ret_val)
1606             return ret_val;
1607
1608         phy_data |= GG82563_MSCR_ASSERT_CRS_ON_TX;
1609         /* Use 25MHz for both link down and 1000BASE-T for Tx clock */
1610         phy_data |= GG82563_MSCR_TX_CLK_1000MBPS_25MHZ;
1611
1612         ret_val = e1000_write_phy_reg(hw, GG82563_PHY_MAC_SPEC_CTRL,
1613                                       phy_data);
1614         if (ret_val)
1615             return ret_val;
1616
1617         /* Options:
1618          *   MDI/MDI-X = 0 (default)
1619          *   0 - Auto for all speeds
1620          *   1 - MDI mode
1621          *   2 - MDI-X mode
1622          *   3 - Auto for 1000Base-T only (MDI-X for 10/100Base-T modes)
1623          */
1624         ret_val = e1000_read_phy_reg(hw, GG82563_PHY_SPEC_CTRL, &phy_data);
1625         if (ret_val)
1626             return ret_val;
1627
1628         phy_data &= ~GG82563_PSCR_CROSSOVER_MODE_MASK;
1629
1630         switch (hw->mdix) {
1631         case 1:
1632             phy_data |= GG82563_PSCR_CROSSOVER_MODE_MDI;
1633             break;
1634         case 2:
1635             phy_data |= GG82563_PSCR_CROSSOVER_MODE_MDIX;
1636             break;
1637         case 0:
1638         default:
1639             phy_data |= GG82563_PSCR_CROSSOVER_MODE_AUTO;
1640             break;
1641         }
1642
1643         /* Options:
1644          *   disable_polarity_correction = 0 (default)
1645          *       Automatic Correction for Reversed Cable Polarity
1646          *   0 - Disabled
1647          *   1 - Enabled
1648          */
1649         phy_data &= ~GG82563_PSCR_POLARITY_REVERSAL_DISABLE;
1650         if (hw->disable_polarity_correction == 1)
1651             phy_data |= GG82563_PSCR_POLARITY_REVERSAL_DISABLE;
1652         ret_val = e1000_write_phy_reg(hw, GG82563_PHY_SPEC_CTRL, phy_data);
1653
1654         if (ret_val)
1655             return ret_val;
1656
1657         /* SW Reset the PHY so all changes take effect */
1658         ret_val = e1000_phy_reset(hw);
1659         if (ret_val) {
1660             DEBUGOUT("Error Resetting the PHY\n");
1661             return ret_val;
1662         }
1663     } /* phy_reset_disable */
1664
1665     if (hw->mac_type == e1000_80003es2lan) {
1666         /* Bypass RX and TX FIFO's */
1667         ret_val = e1000_write_kmrn_reg(hw, E1000_KUMCTRLSTA_OFFSET_FIFO_CTRL,
1668                                        E1000_KUMCTRLSTA_FIFO_CTRL_RX_BYPASS |
1669                                        E1000_KUMCTRLSTA_FIFO_CTRL_TX_BYPASS);
1670         if (ret_val)
1671             return ret_val;
1672
1673         ret_val = e1000_read_phy_reg(hw, GG82563_PHY_SPEC_CTRL_2, &phy_data);
1674         if (ret_val)
1675             return ret_val;
1676
1677         phy_data &= ~GG82563_PSCR2_REVERSE_AUTO_NEG;
1678         ret_val = e1000_write_phy_reg(hw, GG82563_PHY_SPEC_CTRL_2, phy_data);
1679
1680         if (ret_val)
1681             return ret_val;
1682
1683         reg_data = er32(CTRL_EXT);
1684         reg_data &= ~(E1000_CTRL_EXT_LINK_MODE_MASK);
1685         ew32(CTRL_EXT, reg_data);
1686
1687         ret_val = e1000_read_phy_reg(hw, GG82563_PHY_PWR_MGMT_CTRL,
1688                                           &phy_data);
1689         if (ret_val)
1690             return ret_val;
1691
1692         /* Do not init these registers when the HW is in IAMT mode, since the
1693          * firmware will have already initialized them.  We only initialize
1694          * them if the HW is not in IAMT mode.
1695          */
1696         if (!e1000_check_mng_mode(hw)) {
1697             /* Enable Electrical Idle on the PHY */
1698             phy_data |= GG82563_PMCR_ENABLE_ELECTRICAL_IDLE;
1699             ret_val = e1000_write_phy_reg(hw, GG82563_PHY_PWR_MGMT_CTRL,
1700                                           phy_data);
1701             if (ret_val)
1702                 return ret_val;
1703
1704             ret_val = e1000_read_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL,
1705                                          &phy_data);
1706             if (ret_val)
1707                 return ret_val;
1708
1709             phy_data &= ~GG82563_KMCR_PASS_FALSE_CARRIER;
1710             ret_val = e1000_write_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL,
1711                                           phy_data);
1712
1713             if (ret_val)
1714                 return ret_val;
1715         }
1716
1717         /* Workaround: Disable padding in Kumeran interface in the MAC
1718          * and in the PHY to avoid CRC errors.
1719          */
1720         ret_val = e1000_read_phy_reg(hw, GG82563_PHY_INBAND_CTRL,
1721                                      &phy_data);
1722         if (ret_val)
1723             return ret_val;
1724         phy_data |= GG82563_ICR_DIS_PADDING;
1725         ret_val = e1000_write_phy_reg(hw, GG82563_PHY_INBAND_CTRL,
1726                                       phy_data);
1727         if (ret_val)
1728             return ret_val;
1729     }
1730
1731     return E1000_SUCCESS;
1732 }
1733
1734 /********************************************************************
1735 * Copper link setup for e1000_phy_m88 series.
1736 *
1737 * hw - Struct containing variables accessed by shared code
1738 *********************************************************************/
1739 static s32 e1000_copper_link_mgp_setup(struct e1000_hw *hw)
1740 {
1741     s32 ret_val;
1742     u16 phy_data;
1743
1744     DEBUGFUNC("e1000_copper_link_mgp_setup");
1745
1746     if (hw->phy_reset_disable)
1747         return E1000_SUCCESS;
1748
1749     /* Enable CRS on TX. This must be set for half-duplex operation. */
1750     ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
1751     if (ret_val)
1752         return ret_val;
1753
1754     phy_data |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
1755
1756     /* Options:
1757      *   MDI/MDI-X = 0 (default)
1758      *   0 - Auto for all speeds
1759      *   1 - MDI mode
1760      *   2 - MDI-X mode
1761      *   3 - Auto for 1000Base-T only (MDI-X for 10/100Base-T modes)
1762      */
1763     phy_data &= ~M88E1000_PSCR_AUTO_X_MODE;
1764
1765     switch (hw->mdix) {
1766     case 1:
1767         phy_data |= M88E1000_PSCR_MDI_MANUAL_MODE;
1768         break;
1769     case 2:
1770         phy_data |= M88E1000_PSCR_MDIX_MANUAL_MODE;
1771         break;
1772     case 3:
1773         phy_data |= M88E1000_PSCR_AUTO_X_1000T;
1774         break;
1775     case 0:
1776     default:
1777         phy_data |= M88E1000_PSCR_AUTO_X_MODE;
1778         break;
1779     }
1780
1781     /* Options:
1782      *   disable_polarity_correction = 0 (default)
1783      *       Automatic Correction for Reversed Cable Polarity
1784      *   0 - Disabled
1785      *   1 - Enabled
1786      */
1787     phy_data &= ~M88E1000_PSCR_POLARITY_REVERSAL;
1788     if (hw->disable_polarity_correction == 1)
1789         phy_data |= M88E1000_PSCR_POLARITY_REVERSAL;
1790     ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
1791     if (ret_val)
1792         return ret_val;
1793
1794     if (hw->phy_revision < M88E1011_I_REV_4) {
1795         /* Force TX_CLK in the Extended PHY Specific Control Register
1796          * to 25MHz clock.
1797          */
1798         ret_val = e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_data);
1799         if (ret_val)
1800             return ret_val;
1801
1802         phy_data |= M88E1000_EPSCR_TX_CLK_25;
1803
1804         if ((hw->phy_revision == E1000_REVISION_2) &&
1805             (hw->phy_id == M88E1111_I_PHY_ID)) {
1806             /* Vidalia Phy, set the downshift counter to 5x */
1807             phy_data &= ~(M88EC018_EPSCR_DOWNSHIFT_COUNTER_MASK);
1808             phy_data |= M88EC018_EPSCR_DOWNSHIFT_COUNTER_5X;
1809             ret_val = e1000_write_phy_reg(hw,
1810                                         M88E1000_EXT_PHY_SPEC_CTRL, phy_data);
1811             if (ret_val)
1812                 return ret_val;
1813         } else {
1814             /* Configure Master and Slave downshift values */
1815             phy_data &= ~(M88E1000_EPSCR_MASTER_DOWNSHIFT_MASK |
1816                               M88E1000_EPSCR_SLAVE_DOWNSHIFT_MASK);
1817             phy_data |= (M88E1000_EPSCR_MASTER_DOWNSHIFT_1X |
1818                              M88E1000_EPSCR_SLAVE_DOWNSHIFT_1X);
1819             ret_val = e1000_write_phy_reg(hw,
1820                                         M88E1000_EXT_PHY_SPEC_CTRL, phy_data);
1821             if (ret_val)
1822                return ret_val;
1823         }
1824     }
1825
1826     /* SW Reset the PHY so all changes take effect */
1827     ret_val = e1000_phy_reset(hw);
1828     if (ret_val) {
1829         DEBUGOUT("Error Resetting the PHY\n");
1830         return ret_val;
1831     }
1832
1833    return E1000_SUCCESS;
1834 }
1835
1836 /********************************************************************
1837 * Setup auto-negotiation and flow control advertisements,
1838 * and then perform auto-negotiation.
1839 *
1840 * hw - Struct containing variables accessed by shared code
1841 *********************************************************************/
1842 static s32 e1000_copper_link_autoneg(struct e1000_hw *hw)
1843 {
1844     s32 ret_val;
1845     u16 phy_data;
1846
1847     DEBUGFUNC("e1000_copper_link_autoneg");
1848
1849     /* Perform some bounds checking on the hw->autoneg_advertised
1850      * parameter.  If this variable is zero, then set it to the default.
1851      */
1852     hw->autoneg_advertised &= AUTONEG_ADVERTISE_SPEED_DEFAULT;
1853
1854     /* If autoneg_advertised is zero, we assume it was not defaulted
1855      * by the calling code so we set to advertise full capability.
1856      */
1857     if (hw->autoneg_advertised == 0)
1858         hw->autoneg_advertised = AUTONEG_ADVERTISE_SPEED_DEFAULT;
1859
1860     /* IFE phy only supports 10/100 */
1861     if (hw->phy_type == e1000_phy_ife)
1862         hw->autoneg_advertised &= AUTONEG_ADVERTISE_10_100_ALL;
1863
1864     DEBUGOUT("Reconfiguring auto-neg advertisement params\n");
1865     ret_val = e1000_phy_setup_autoneg(hw);
1866     if (ret_val) {
1867         DEBUGOUT("Error Setting up Auto-Negotiation\n");
1868         return ret_val;
1869     }
1870     DEBUGOUT("Restarting Auto-Neg\n");
1871
1872     /* Restart auto-negotiation by setting the Auto Neg Enable bit and
1873      * the Auto Neg Restart bit in the PHY control register.
1874      */
1875     ret_val = e1000_read_phy_reg(hw, PHY_CTRL, &phy_data);
1876     if (ret_val)
1877         return ret_val;
1878
1879     phy_data |= (MII_CR_AUTO_NEG_EN | MII_CR_RESTART_AUTO_NEG);
1880     ret_val = e1000_write_phy_reg(hw, PHY_CTRL, phy_data);
1881     if (ret_val)
1882         return ret_val;
1883
1884     /* Does the user want to wait for Auto-Neg to complete here, or
1885      * check at a later time (for example, callback routine).
1886      */
1887     if (hw->wait_autoneg_complete) {
1888         ret_val = e1000_wait_autoneg(hw);
1889         if (ret_val) {
1890             DEBUGOUT("Error while waiting for autoneg to complete\n");
1891             return ret_val;
1892         }
1893     }
1894
1895     hw->get_link_status = true;
1896
1897     return E1000_SUCCESS;
1898 }
1899
1900 /******************************************************************************
1901 * Config the MAC and the PHY after link is up.
1902 *   1) Set up the MAC to the current PHY speed/duplex
1903 *      if we are on 82543.  If we
1904 *      are on newer silicon, we only need to configure
1905 *      collision distance in the Transmit Control Register.
1906 *   2) Set up flow control on the MAC to that established with
1907 *      the link partner.
1908 *   3) Config DSP to improve Gigabit link quality for some PHY revisions.
1909 *
1910 * hw - Struct containing variables accessed by shared code
1911 ******************************************************************************/
1912 static s32 e1000_copper_link_postconfig(struct e1000_hw *hw)
1913 {
1914     s32 ret_val;
1915     DEBUGFUNC("e1000_copper_link_postconfig");
1916
1917     if (hw->mac_type >= e1000_82544) {
1918         e1000_config_collision_dist(hw);
1919     } else {
1920         ret_val = e1000_config_mac_to_phy(hw);
1921         if (ret_val) {
1922             DEBUGOUT("Error configuring MAC to PHY settings\n");
1923             return ret_val;
1924         }
1925     }
1926     ret_val = e1000_config_fc_after_link_up(hw);
1927     if (ret_val) {
1928         DEBUGOUT("Error Configuring Flow Control\n");
1929         return ret_val;
1930     }
1931
1932     /* Config DSP to improve Giga link quality */
1933     if (hw->phy_type == e1000_phy_igp) {
1934         ret_val = e1000_config_dsp_after_link_change(hw, true);
1935         if (ret_val) {
1936             DEBUGOUT("Error Configuring DSP after link up\n");
1937             return ret_val;
1938         }
1939     }
1940
1941     return E1000_SUCCESS;
1942 }
1943
1944 /******************************************************************************
1945 * Detects which PHY is present and setup the speed and duplex
1946 *
1947 * hw - Struct containing variables accessed by shared code
1948 ******************************************************************************/
1949 static s32 e1000_setup_copper_link(struct e1000_hw *hw)
1950 {
1951     s32 ret_val;
1952     u16 i;
1953     u16 phy_data;
1954     u16 reg_data;
1955
1956     DEBUGFUNC("e1000_setup_copper_link");
1957
1958     switch (hw->mac_type) {
1959     case e1000_80003es2lan:
1960     case e1000_ich8lan:
1961         /* Set the mac to wait the maximum time between each
1962          * iteration and increase the max iterations when
1963          * polling the phy; this fixes erroneous timeouts at 10Mbps. */
1964         ret_val = e1000_write_kmrn_reg(hw, GG82563_REG(0x34, 4), 0xFFFF);
1965         if (ret_val)
1966             return ret_val;
1967         ret_val = e1000_read_kmrn_reg(hw, GG82563_REG(0x34, 9), &reg_data);
1968         if (ret_val)
1969             return ret_val;
1970         reg_data |= 0x3F;
1971         ret_val = e1000_write_kmrn_reg(hw, GG82563_REG(0x34, 9), reg_data);
1972         if (ret_val)
1973             return ret_val;
1974     default:
1975         break;
1976     }
1977
1978     /* Check if it is a valid PHY and set PHY mode if necessary. */
1979     ret_val = e1000_copper_link_preconfig(hw);
1980     if (ret_val)
1981         return ret_val;
1982
1983     switch (hw->mac_type) {
1984     case e1000_80003es2lan:
1985         /* Kumeran registers are written-only */
1986         reg_data = E1000_KUMCTRLSTA_INB_CTRL_LINK_STATUS_TX_TIMEOUT_DEFAULT;
1987         reg_data |= E1000_KUMCTRLSTA_INB_CTRL_DIS_PADDING;
1988         ret_val = e1000_write_kmrn_reg(hw, E1000_KUMCTRLSTA_OFFSET_INB_CTRL,
1989                                        reg_data);
1990         if (ret_val)
1991             return ret_val;
1992         break;
1993     default:
1994         break;
1995     }
1996
1997     if (hw->phy_type == e1000_phy_igp ||
1998         hw->phy_type == e1000_phy_igp_3 ||
1999         hw->phy_type == e1000_phy_igp_2) {
2000         ret_val = e1000_copper_link_igp_setup(hw);
2001         if (ret_val)
2002             return ret_val;
2003     } else if (hw->phy_type == e1000_phy_m88) {
2004         ret_val = e1000_copper_link_mgp_setup(hw);
2005         if (ret_val)
2006             return ret_val;
2007     } else if (hw->phy_type == e1000_phy_gg82563) {
2008         ret_val = e1000_copper_link_ggp_setup(hw);
2009         if (ret_val)
2010             return ret_val;
2011     }
2012
2013     if (hw->autoneg) {
2014         /* Setup autoneg and flow control advertisement
2015           * and perform autonegotiation */
2016         ret_val = e1000_copper_link_autoneg(hw);
2017         if (ret_val)
2018             return ret_val;
2019     } else {
2020         /* PHY will be set to 10H, 10F, 100H,or 100F
2021           * depending on value from forced_speed_duplex. */
2022         DEBUGOUT("Forcing speed and duplex\n");
2023         ret_val = e1000_phy_force_speed_duplex(hw);
2024         if (ret_val) {
2025             DEBUGOUT("Error Forcing Speed and Duplex\n");
2026             return ret_val;
2027         }
2028     }
2029
2030     /* Check link status. Wait up to 100 microseconds for link to become
2031      * valid.
2032      */
2033     for (i = 0; i < 10; i++) {
2034         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2035         if (ret_val)
2036             return ret_val;
2037         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2038         if (ret_val)
2039             return ret_val;
2040
2041         if (phy_data & MII_SR_LINK_STATUS) {
2042             /* Config the MAC and PHY after link is up */
2043             ret_val = e1000_copper_link_postconfig(hw);
2044             if (ret_val)
2045                 return ret_val;
2046
2047             DEBUGOUT("Valid link established!!!\n");
2048             return E1000_SUCCESS;
2049         }
2050         udelay(10);
2051     }
2052
2053     DEBUGOUT("Unable to establish link!!!\n");
2054     return E1000_SUCCESS;
2055 }
2056
2057 /******************************************************************************
2058 * Configure the MAC-to-PHY interface for 10/100Mbps
2059 *
2060 * hw - Struct containing variables accessed by shared code
2061 ******************************************************************************/
2062 static s32 e1000_configure_kmrn_for_10_100(struct e1000_hw *hw, u16 duplex)
2063 {
2064     s32 ret_val = E1000_SUCCESS;
2065     u32 tipg;
2066     u16 reg_data;
2067
2068     DEBUGFUNC("e1000_configure_kmrn_for_10_100");
2069
2070     reg_data = E1000_KUMCTRLSTA_HD_CTRL_10_100_DEFAULT;
2071     ret_val = e1000_write_kmrn_reg(hw, E1000_KUMCTRLSTA_OFFSET_HD_CTRL,
2072                                    reg_data);
2073     if (ret_val)
2074         return ret_val;
2075
2076     /* Configure Transmit Inter-Packet Gap */
2077     tipg = er32(TIPG);
2078     tipg &= ~E1000_TIPG_IPGT_MASK;
2079     tipg |= DEFAULT_80003ES2LAN_TIPG_IPGT_10_100;
2080     ew32(TIPG, tipg);
2081
2082     ret_val = e1000_read_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL, &reg_data);
2083
2084     if (ret_val)
2085         return ret_val;
2086
2087     if (duplex == HALF_DUPLEX)
2088         reg_data |= GG82563_KMCR_PASS_FALSE_CARRIER;
2089     else
2090         reg_data &= ~GG82563_KMCR_PASS_FALSE_CARRIER;
2091
2092     ret_val = e1000_write_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL, reg_data);
2093
2094     return ret_val;
2095 }
2096
2097 static s32 e1000_configure_kmrn_for_1000(struct e1000_hw *hw)
2098 {
2099     s32 ret_val = E1000_SUCCESS;
2100     u16 reg_data;
2101     u32 tipg;
2102
2103     DEBUGFUNC("e1000_configure_kmrn_for_1000");
2104
2105     reg_data = E1000_KUMCTRLSTA_HD_CTRL_1000_DEFAULT;
2106     ret_val = e1000_write_kmrn_reg(hw, E1000_KUMCTRLSTA_OFFSET_HD_CTRL,
2107                                    reg_data);
2108     if (ret_val)
2109         return ret_val;
2110
2111     /* Configure Transmit Inter-Packet Gap */
2112     tipg = er32(TIPG);
2113     tipg &= ~E1000_TIPG_IPGT_MASK;
2114     tipg |= DEFAULT_80003ES2LAN_TIPG_IPGT_1000;
2115     ew32(TIPG, tipg);
2116
2117     ret_val = e1000_read_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL, &reg_data);
2118
2119     if (ret_val)
2120         return ret_val;
2121
2122     reg_data &= ~GG82563_KMCR_PASS_FALSE_CARRIER;
2123     ret_val = e1000_write_phy_reg(hw, GG82563_PHY_KMRN_MODE_CTRL, reg_data);
2124
2125     return ret_val;
2126 }
2127
2128 /******************************************************************************
2129 * Configures PHY autoneg and flow control advertisement settings
2130 *
2131 * hw - Struct containing variables accessed by shared code
2132 ******************************************************************************/
2133 s32 e1000_phy_setup_autoneg(struct e1000_hw *hw)
2134 {
2135     s32 ret_val;
2136     u16 mii_autoneg_adv_reg;
2137     u16 mii_1000t_ctrl_reg;
2138
2139     DEBUGFUNC("e1000_phy_setup_autoneg");
2140
2141     /* Read the MII Auto-Neg Advertisement Register (Address 4). */
2142     ret_val = e1000_read_phy_reg(hw, PHY_AUTONEG_ADV, &mii_autoneg_adv_reg);
2143     if (ret_val)
2144         return ret_val;
2145
2146     if (hw->phy_type != e1000_phy_ife) {
2147         /* Read the MII 1000Base-T Control Register (Address 9). */
2148         ret_val = e1000_read_phy_reg(hw, PHY_1000T_CTRL, &mii_1000t_ctrl_reg);
2149         if (ret_val)
2150             return ret_val;
2151     } else
2152         mii_1000t_ctrl_reg=0;
2153
2154     /* Need to parse both autoneg_advertised and fc and set up
2155      * the appropriate PHY registers.  First we will parse for
2156      * autoneg_advertised software override.  Since we can advertise
2157      * a plethora of combinations, we need to check each bit
2158      * individually.
2159      */
2160
2161     /* First we clear all the 10/100 mb speed bits in the Auto-Neg
2162      * Advertisement Register (Address 4) and the 1000 mb speed bits in
2163      * the  1000Base-T Control Register (Address 9).
2164      */
2165     mii_autoneg_adv_reg &= ~REG4_SPEED_MASK;
2166     mii_1000t_ctrl_reg &= ~REG9_SPEED_MASK;
2167
2168     DEBUGOUT1("autoneg_advertised %x\n", hw->autoneg_advertised);
2169
2170     /* Do we want to advertise 10 Mb Half Duplex? */
2171     if (hw->autoneg_advertised & ADVERTISE_10_HALF) {
2172         DEBUGOUT("Advertise 10mb Half duplex\n");
2173         mii_autoneg_adv_reg |= NWAY_AR_10T_HD_CAPS;
2174     }
2175
2176     /* Do we want to advertise 10 Mb Full Duplex? */
2177     if (hw->autoneg_advertised & ADVERTISE_10_FULL) {
2178         DEBUGOUT("Advertise 10mb Full duplex\n");
2179         mii_autoneg_adv_reg |= NWAY_AR_10T_FD_CAPS;
2180     }
2181
2182     /* Do we want to advertise 100 Mb Half Duplex? */
2183     if (hw->autoneg_advertised & ADVERTISE_100_HALF) {
2184         DEBUGOUT("Advertise 100mb Half duplex\n");
2185         mii_autoneg_adv_reg |= NWAY_AR_100TX_HD_CAPS;
2186     }
2187
2188     /* Do we want to advertise 100 Mb Full Duplex? */
2189     if (hw->autoneg_advertised & ADVERTISE_100_FULL) {
2190         DEBUGOUT("Advertise 100mb Full duplex\n");
2191         mii_autoneg_adv_reg |= NWAY_AR_100TX_FD_CAPS;
2192     }
2193
2194     /* We do not allow the Phy to advertise 1000 Mb Half Duplex */
2195     if (hw->autoneg_advertised & ADVERTISE_1000_HALF) {
2196         DEBUGOUT("Advertise 1000mb Half duplex requested, request denied!\n");
2197     }
2198
2199     /* Do we want to advertise 1000 Mb Full Duplex? */
2200     if (hw->autoneg_advertised & ADVERTISE_1000_FULL) {
2201         DEBUGOUT("Advertise 1000mb Full duplex\n");
2202         mii_1000t_ctrl_reg |= CR_1000T_FD_CAPS;
2203         if (hw->phy_type == e1000_phy_ife) {
2204             DEBUGOUT("e1000_phy_ife is a 10/100 PHY. Gigabit speed is not supported.\n");
2205         }
2206     }
2207
2208     /* Check for a software override of the flow control settings, and
2209      * setup the PHY advertisement registers accordingly.  If
2210      * auto-negotiation is enabled, then software will have to set the
2211      * "PAUSE" bits to the correct value in the Auto-Negotiation
2212      * Advertisement Register (PHY_AUTONEG_ADV) and re-start auto-negotiation.
2213      *
2214      * The possible values of the "fc" parameter are:
2215      *      0:  Flow control is completely disabled
2216      *      1:  Rx flow control is enabled (we can receive pause frames
2217      *          but not send pause frames).
2218      *      2:  Tx flow control is enabled (we can send pause frames
2219      *          but we do not support receiving pause frames).
2220      *      3:  Both Rx and TX flow control (symmetric) are enabled.
2221      *  other:  No software override.  The flow control configuration
2222      *          in the EEPROM is used.
2223      */
2224     switch (hw->fc) {
2225     case E1000_FC_NONE: /* 0 */
2226         /* Flow control (RX & TX) is completely disabled by a
2227          * software over-ride.
2228          */
2229         mii_autoneg_adv_reg &= ~(NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
2230         break;
2231     case E1000_FC_RX_PAUSE: /* 1 */
2232         /* RX Flow control is enabled, and TX Flow control is
2233          * disabled, by a software over-ride.
2234          */
2235         /* Since there really isn't a way to advertise that we are
2236          * capable of RX Pause ONLY, we will advertise that we
2237          * support both symmetric and asymmetric RX PAUSE.  Later
2238          * (in e1000_config_fc_after_link_up) we will disable the
2239          *hw's ability to send PAUSE frames.
2240          */
2241         mii_autoneg_adv_reg |= (NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
2242         break;
2243     case E1000_FC_TX_PAUSE: /* 2 */
2244         /* TX Flow control is enabled, and RX Flow control is
2245          * disabled, by a software over-ride.
2246          */
2247         mii_autoneg_adv_reg |= NWAY_AR_ASM_DIR;
2248         mii_autoneg_adv_reg &= ~NWAY_AR_PAUSE;
2249         break;
2250     case E1000_FC_FULL: /* 3 */
2251         /* Flow control (both RX and TX) is enabled by a software
2252          * over-ride.
2253          */
2254         mii_autoneg_adv_reg |= (NWAY_AR_ASM_DIR | NWAY_AR_PAUSE);
2255         break;
2256     default:
2257         DEBUGOUT("Flow control param set incorrectly\n");
2258         return -E1000_ERR_CONFIG;
2259     }
2260
2261     ret_val = e1000_write_phy_reg(hw, PHY_AUTONEG_ADV, mii_autoneg_adv_reg);
2262     if (ret_val)
2263         return ret_val;
2264
2265     DEBUGOUT1("Auto-Neg Advertising %x\n", mii_autoneg_adv_reg);
2266
2267     if (hw->phy_type != e1000_phy_ife) {
2268         ret_val = e1000_write_phy_reg(hw, PHY_1000T_CTRL, mii_1000t_ctrl_reg);
2269         if (ret_val)
2270             return ret_val;
2271     }
2272
2273     return E1000_SUCCESS;
2274 }
2275
2276 /******************************************************************************
2277 * Force PHY speed and duplex settings to hw->forced_speed_duplex
2278 *
2279 * hw - Struct containing variables accessed by shared code
2280 ******************************************************************************/
2281 static s32 e1000_phy_force_speed_duplex(struct e1000_hw *hw)
2282 {
2283     u32 ctrl;
2284     s32 ret_val;
2285     u16 mii_ctrl_reg;
2286     u16 mii_status_reg;
2287     u16 phy_data;
2288     u16 i;
2289
2290     DEBUGFUNC("e1000_phy_force_speed_duplex");
2291
2292     /* Turn off Flow control if we are forcing speed and duplex. */
2293     hw->fc = E1000_FC_NONE;
2294
2295     DEBUGOUT1("hw->fc = %d\n", hw->fc);
2296
2297     /* Read the Device Control Register. */
2298     ctrl = er32(CTRL);
2299
2300     /* Set the bits to Force Speed and Duplex in the Device Ctrl Reg. */
2301     ctrl |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
2302     ctrl &= ~(DEVICE_SPEED_MASK);
2303
2304     /* Clear the Auto Speed Detect Enable bit. */
2305     ctrl &= ~E1000_CTRL_ASDE;
2306
2307     /* Read the MII Control Register. */
2308     ret_val = e1000_read_phy_reg(hw, PHY_CTRL, &mii_ctrl_reg);
2309     if (ret_val)
2310         return ret_val;
2311
2312     /* We need to disable autoneg in order to force link and duplex. */
2313
2314     mii_ctrl_reg &= ~MII_CR_AUTO_NEG_EN;
2315
2316     /* Are we forcing Full or Half Duplex? */
2317     if (hw->forced_speed_duplex == e1000_100_full ||
2318         hw->forced_speed_duplex == e1000_10_full) {
2319         /* We want to force full duplex so we SET the full duplex bits in the
2320          * Device and MII Control Registers.
2321          */
2322         ctrl |= E1000_CTRL_FD;
2323         mii_ctrl_reg |= MII_CR_FULL_DUPLEX;
2324         DEBUGOUT("Full Duplex\n");
2325     } else {
2326         /* We want to force half duplex so we CLEAR the full duplex bits in
2327          * the Device and MII Control Registers.
2328          */
2329         ctrl &= ~E1000_CTRL_FD;
2330         mii_ctrl_reg &= ~MII_CR_FULL_DUPLEX;
2331         DEBUGOUT("Half Duplex\n");
2332     }
2333
2334     /* Are we forcing 100Mbps??? */
2335     if (hw->forced_speed_duplex == e1000_100_full ||
2336        hw->forced_speed_duplex == e1000_100_half) {
2337         /* Set the 100Mb bit and turn off the 1000Mb and 10Mb bits. */
2338         ctrl |= E1000_CTRL_SPD_100;
2339         mii_ctrl_reg |= MII_CR_SPEED_100;
2340         mii_ctrl_reg &= ~(MII_CR_SPEED_1000 | MII_CR_SPEED_10);
2341         DEBUGOUT("Forcing 100mb ");
2342     } else {
2343         /* Set the 10Mb bit and turn off the 1000Mb and 100Mb bits. */
2344         ctrl &= ~(E1000_CTRL_SPD_1000 | E1000_CTRL_SPD_100);
2345         mii_ctrl_reg |= MII_CR_SPEED_10;
2346         mii_ctrl_reg &= ~(MII_CR_SPEED_1000 | MII_CR_SPEED_100);
2347         DEBUGOUT("Forcing 10mb ");
2348     }
2349
2350     e1000_config_collision_dist(hw);
2351
2352     /* Write the configured values back to the Device Control Reg. */
2353     ew32(CTRL, ctrl);
2354
2355     if ((hw->phy_type == e1000_phy_m88) ||
2356         (hw->phy_type == e1000_phy_gg82563)) {
2357         ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
2358         if (ret_val)
2359             return ret_val;
2360
2361         /* Clear Auto-Crossover to force MDI manually. M88E1000 requires MDI
2362          * forced whenever speed are duplex are forced.
2363          */
2364         phy_data &= ~M88E1000_PSCR_AUTO_X_MODE;
2365         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
2366         if (ret_val)
2367             return ret_val;
2368
2369         DEBUGOUT1("M88E1000 PSCR: %x \n", phy_data);
2370
2371         /* Need to reset the PHY or these changes will be ignored */
2372         mii_ctrl_reg |= MII_CR_RESET;
2373
2374     /* Disable MDI-X support for 10/100 */
2375     } else if (hw->phy_type == e1000_phy_ife) {
2376         ret_val = e1000_read_phy_reg(hw, IFE_PHY_MDIX_CONTROL, &phy_data);
2377         if (ret_val)
2378             return ret_val;
2379
2380         phy_data &= ~IFE_PMC_AUTO_MDIX;
2381         phy_data &= ~IFE_PMC_FORCE_MDIX;
2382
2383         ret_val = e1000_write_phy_reg(hw, IFE_PHY_MDIX_CONTROL, phy_data);
2384         if (ret_val)
2385             return ret_val;
2386
2387     } else {
2388         /* Clear Auto-Crossover to force MDI manually.  IGP requires MDI
2389          * forced whenever speed or duplex are forced.
2390          */
2391         ret_val = e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, &phy_data);
2392         if (ret_val)
2393             return ret_val;
2394
2395         phy_data &= ~IGP01E1000_PSCR_AUTO_MDIX;
2396         phy_data &= ~IGP01E1000_PSCR_FORCE_MDI_MDIX;
2397
2398         ret_val = e1000_write_phy_reg(hw, IGP01E1000_PHY_PORT_CTRL, phy_data);
2399         if (ret_val)
2400             return ret_val;
2401     }
2402
2403     /* Write back the modified PHY MII control register. */
2404     ret_val = e1000_write_phy_reg(hw, PHY_CTRL, mii_ctrl_reg);
2405     if (ret_val)
2406         return ret_val;
2407
2408     udelay(1);
2409
2410     /* The wait_autoneg_complete flag may be a little misleading here.
2411      * Since we are forcing speed and duplex, Auto-Neg is not enabled.
2412      * But we do want to delay for a period while forcing only so we
2413      * don't generate false No Link messages.  So we will wait here
2414      * only if the user has set wait_autoneg_complete to 1, which is
2415      * the default.
2416      */
2417     if (hw->wait_autoneg_complete) {
2418         /* We will wait for autoneg to complete. */
2419         DEBUGOUT("Waiting for forced speed/duplex link.\n");
2420         mii_status_reg = 0;
2421
2422         /* We will wait for autoneg to complete or 4.5 seconds to expire. */
2423         for (i = PHY_FORCE_TIME; i > 0; i--) {
2424             /* Read the MII Status Register and wait for Auto-Neg Complete bit
2425              * to be set.
2426              */
2427             ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2428             if (ret_val)
2429                 return ret_val;
2430
2431             ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2432             if (ret_val)
2433                 return ret_val;
2434
2435             if (mii_status_reg & MII_SR_LINK_STATUS) break;
2436             msleep(100);
2437         }
2438         if ((i == 0) &&
2439            ((hw->phy_type == e1000_phy_m88) ||
2440             (hw->phy_type == e1000_phy_gg82563))) {
2441             /* We didn't get link.  Reset the DSP and wait again for link. */
2442             ret_val = e1000_phy_reset_dsp(hw);
2443             if (ret_val) {
2444                 DEBUGOUT("Error Resetting PHY DSP\n");
2445                 return ret_val;
2446             }
2447         }
2448         /* This loop will early-out if the link condition has been met.  */
2449         for (i = PHY_FORCE_TIME; i > 0; i--) {
2450             if (mii_status_reg & MII_SR_LINK_STATUS) break;
2451             msleep(100);
2452             /* Read the MII Status Register and wait for Auto-Neg Complete bit
2453              * to be set.
2454              */
2455             ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2456             if (ret_val)
2457                 return ret_val;
2458
2459             ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2460             if (ret_val)
2461                 return ret_val;
2462         }
2463     }
2464
2465     if (hw->phy_type == e1000_phy_m88) {
2466         /* Because we reset the PHY above, we need to re-force TX_CLK in the
2467          * Extended PHY Specific Control Register to 25MHz clock.  This value
2468          * defaults back to a 2.5MHz clock when the PHY is reset.
2469          */
2470         ret_val = e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_data);
2471         if (ret_val)
2472             return ret_val;
2473
2474         phy_data |= M88E1000_EPSCR_TX_CLK_25;
2475         ret_val = e1000_write_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, phy_data);
2476         if (ret_val)
2477             return ret_val;
2478
2479         /* In addition, because of the s/w reset above, we need to enable CRS on
2480          * TX.  This must be set for both full and half duplex operation.
2481          */
2482         ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
2483         if (ret_val)
2484             return ret_val;
2485
2486         phy_data |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
2487         ret_val = e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
2488         if (ret_val)
2489             return ret_val;
2490
2491         if ((hw->mac_type == e1000_82544 || hw->mac_type == e1000_82543) &&
2492             (!hw->autoneg) && (hw->forced_speed_duplex == e1000_10_full ||
2493              hw->forced_speed_duplex == e1000_10_half)) {
2494             ret_val = e1000_polarity_reversal_workaround(hw);
2495             if (ret_val)
2496                 return ret_val;
2497         }
2498     } else if (hw->phy_type == e1000_phy_gg82563) {
2499         /* The TX_CLK of the Extended PHY Specific Control Register defaults
2500          * to 2.5MHz on a reset.  We need to re-force it back to 25MHz, if
2501          * we're not in a forced 10/duplex configuration. */
2502         ret_val = e1000_read_phy_reg(hw, GG82563_PHY_MAC_SPEC_CTRL, &phy_data);
2503         if (ret_val)
2504             return ret_val;
2505
2506         phy_data &= ~GG82563_MSCR_TX_CLK_MASK;
2507         if ((hw->forced_speed_duplex == e1000_10_full) ||
2508             (hw->forced_speed_duplex == e1000_10_half))
2509             phy_data |= GG82563_MSCR_TX_CLK_10MBPS_2_5MHZ;
2510         else
2511             phy_data |= GG82563_MSCR_TX_CLK_100MBPS_25MHZ;
2512
2513         /* Also due to the reset, we need to enable CRS on Tx. */
2514         phy_data |= GG82563_MSCR_ASSERT_CRS_ON_TX;
2515
2516         ret_val = e1000_write_phy_reg(hw, GG82563_PHY_MAC_SPEC_CTRL, phy_data);
2517         if (ret_val)
2518             return ret_val;
2519     }
2520     return E1000_SUCCESS;
2521 }
2522
2523 /******************************************************************************
2524 * Sets the collision distance in the Transmit Control register
2525 *
2526 * hw - Struct containing variables accessed by shared code
2527 *
2528 * Link should have been established previously. Reads the speed and duplex
2529 * information from the Device Status register.
2530 ******************************************************************************/
2531 void e1000_config_collision_dist(struct e1000_hw *hw)
2532 {
2533     u32 tctl, coll_dist;
2534
2535     DEBUGFUNC("e1000_config_collision_dist");
2536
2537     if (hw->mac_type < e1000_82543)
2538         coll_dist = E1000_COLLISION_DISTANCE_82542;
2539     else
2540         coll_dist = E1000_COLLISION_DISTANCE;
2541
2542     tctl = er32(TCTL);
2543
2544     tctl &= ~E1000_TCTL_COLD;
2545     tctl |= coll_dist << E1000_COLD_SHIFT;
2546
2547     ew32(TCTL, tctl);
2548     E1000_WRITE_FLUSH();
2549 }
2550
2551 /******************************************************************************
2552 * Sets MAC speed and duplex settings to reflect the those in the PHY
2553 *
2554 * hw - Struct containing variables accessed by shared code
2555 * mii_reg - data to write to the MII control register
2556 *
2557 * The contents of the PHY register containing the needed information need to
2558 * be passed in.
2559 ******************************************************************************/
2560 static s32 e1000_config_mac_to_phy(struct e1000_hw *hw)
2561 {
2562     u32 ctrl;
2563     s32 ret_val;
2564     u16 phy_data;
2565
2566     DEBUGFUNC("e1000_config_mac_to_phy");
2567
2568     /* 82544 or newer MAC, Auto Speed Detection takes care of
2569     * MAC speed/duplex configuration.*/
2570     if (hw->mac_type >= e1000_82544)
2571         return E1000_SUCCESS;
2572
2573     /* Read the Device Control Register and set the bits to Force Speed
2574      * and Duplex.
2575      */
2576     ctrl = er32(CTRL);
2577     ctrl |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
2578     ctrl &= ~(E1000_CTRL_SPD_SEL | E1000_CTRL_ILOS);
2579
2580     /* Set up duplex in the Device Control and Transmit Control
2581      * registers depending on negotiated values.
2582      */
2583     ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
2584     if (ret_val)
2585         return ret_val;
2586
2587     if (phy_data & M88E1000_PSSR_DPLX)
2588         ctrl |= E1000_CTRL_FD;
2589     else
2590         ctrl &= ~E1000_CTRL_FD;
2591
2592     e1000_config_collision_dist(hw);
2593
2594     /* Set up speed in the Device Control register depending on
2595      * negotiated values.
2596      */
2597     if ((phy_data & M88E1000_PSSR_SPEED) == M88E1000_PSSR_1000MBS)
2598         ctrl |= E1000_CTRL_SPD_1000;
2599     else if ((phy_data & M88E1000_PSSR_SPEED) == M88E1000_PSSR_100MBS)
2600         ctrl |= E1000_CTRL_SPD_100;
2601
2602     /* Write the configured values back to the Device Control Reg. */
2603     ew32(CTRL, ctrl);
2604     return E1000_SUCCESS;
2605 }
2606
2607 /******************************************************************************
2608  * Forces the MAC's flow control settings.
2609  *
2610  * hw - Struct containing variables accessed by shared code
2611  *
2612  * Sets the TFCE and RFCE bits in the device control register to reflect
2613  * the adapter settings. TFCE and RFCE need to be explicitly set by
2614  * software when a Copper PHY is used because autonegotiation is managed
2615  * by the PHY rather than the MAC. Software must also configure these
2616  * bits when link is forced on a fiber connection.
2617  *****************************************************************************/
2618 s32 e1000_force_mac_fc(struct e1000_hw *hw)
2619 {
2620     u32 ctrl;
2621
2622     DEBUGFUNC("e1000_force_mac_fc");
2623
2624     /* Get the current configuration of the Device Control Register */
2625     ctrl = er32(CTRL);
2626
2627     /* Because we didn't get link via the internal auto-negotiation
2628      * mechanism (we either forced link or we got link via PHY
2629      * auto-neg), we have to manually enable/disable transmit an
2630      * receive flow control.
2631      *
2632      * The "Case" statement below enables/disable flow control
2633      * according to the "hw->fc" parameter.
2634      *
2635      * The possible values of the "fc" parameter are:
2636      *      0:  Flow control is completely disabled
2637      *      1:  Rx flow control is enabled (we can receive pause
2638      *          frames but not send pause frames).
2639      *      2:  Tx flow control is enabled (we can send pause frames
2640      *          frames but we do not receive pause frames).
2641      *      3:  Both Rx and TX flow control (symmetric) is enabled.
2642      *  other:  No other values should be possible at this point.
2643      */
2644
2645     switch (hw->fc) {
2646     case E1000_FC_NONE:
2647         ctrl &= (~(E1000_CTRL_TFCE | E1000_CTRL_RFCE));
2648         break;
2649     case E1000_FC_RX_PAUSE:
2650         ctrl &= (~E1000_CTRL_TFCE);
2651         ctrl |= E1000_CTRL_RFCE;
2652         break;
2653     case E1000_FC_TX_PAUSE:
2654         ctrl &= (~E1000_CTRL_RFCE);
2655         ctrl |= E1000_CTRL_TFCE;
2656         break;
2657     case E1000_FC_FULL:
2658         ctrl |= (E1000_CTRL_TFCE | E1000_CTRL_RFCE);
2659         break;
2660     default:
2661         DEBUGOUT("Flow control param set incorrectly\n");
2662         return -E1000_ERR_CONFIG;
2663     }
2664
2665     /* Disable TX Flow Control for 82542 (rev 2.0) */
2666     if (hw->mac_type == e1000_82542_rev2_0)
2667         ctrl &= (~E1000_CTRL_TFCE);
2668
2669     ew32(CTRL, ctrl);
2670     return E1000_SUCCESS;
2671 }
2672
2673 /******************************************************************************
2674  * Configures flow control settings after link is established
2675  *
2676  * hw - Struct containing variables accessed by shared code
2677  *
2678  * Should be called immediately after a valid link has been established.
2679  * Forces MAC flow control settings if link was forced. When in MII/GMII mode
2680  * and autonegotiation is enabled, the MAC flow control settings will be set
2681  * based on the flow control negotiated by the PHY. In TBI mode, the TFCE
2682  * and RFCE bits will be automaticaly set to the negotiated flow control mode.
2683  *****************************************************************************/
2684 static s32 e1000_config_fc_after_link_up(struct e1000_hw *hw)
2685 {
2686     s32 ret_val;
2687     u16 mii_status_reg;
2688     u16 mii_nway_adv_reg;
2689     u16 mii_nway_lp_ability_reg;
2690     u16 speed;
2691     u16 duplex;
2692
2693     DEBUGFUNC("e1000_config_fc_after_link_up");
2694
2695     /* Check for the case where we have fiber media and auto-neg failed
2696      * so we had to force link.  In this case, we need to force the
2697      * configuration of the MAC to match the "fc" parameter.
2698      */
2699     if (((hw->media_type == e1000_media_type_fiber) && (hw->autoneg_failed)) ||
2700         ((hw->media_type == e1000_media_type_internal_serdes) &&
2701          (hw->autoneg_failed)) ||
2702         ((hw->media_type == e1000_media_type_copper) && (!hw->autoneg))) {
2703         ret_val = e1000_force_mac_fc(hw);
2704         if (ret_val) {
2705             DEBUGOUT("Error forcing flow control settings\n");
2706             return ret_val;
2707         }
2708     }
2709
2710     /* Check for the case where we have copper media and auto-neg is
2711      * enabled.  In this case, we need to check and see if Auto-Neg
2712      * has completed, and if so, how the PHY and link partner has
2713      * flow control configured.
2714      */
2715     if ((hw->media_type == e1000_media_type_copper) && hw->autoneg) {
2716         /* Read the MII Status Register and check to see if AutoNeg
2717          * has completed.  We read this twice because this reg has
2718          * some "sticky" (latched) bits.
2719          */
2720         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2721         if (ret_val)
2722             return ret_val;
2723         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &mii_status_reg);
2724         if (ret_val)
2725             return ret_val;
2726
2727         if (mii_status_reg & MII_SR_AUTONEG_COMPLETE) {
2728             /* The AutoNeg process has completed, so we now need to
2729              * read both the Auto Negotiation Advertisement Register
2730              * (Address 4) and the Auto_Negotiation Base Page Ability
2731              * Register (Address 5) to determine how flow control was
2732              * negotiated.
2733              */
2734             ret_val = e1000_read_phy_reg(hw, PHY_AUTONEG_ADV,
2735                                          &mii_nway_adv_reg);
2736             if (ret_val)
2737                 return ret_val;
2738             ret_val = e1000_read_phy_reg(hw, PHY_LP_ABILITY,
2739                                          &mii_nway_lp_ability_reg);
2740             if (ret_val)
2741                 return ret_val;
2742
2743             /* Two bits in the Auto Negotiation Advertisement Register
2744              * (Address 4) and two bits in the Auto Negotiation Base
2745              * Page Ability Register (Address 5) determine flow control
2746              * for both the PHY and the link partner.  The following
2747              * table, taken out of the IEEE 802.3ab/D6.0 dated March 25,
2748              * 1999, describes these PAUSE resolution bits and how flow
2749              * control is determined based upon these settings.
2750              * NOTE:  DC = Don't Care
2751              *
2752              *   LOCAL DEVICE  |   LINK PARTNER
2753              * PAUSE | ASM_DIR | PAUSE | ASM_DIR | NIC Resolution
2754              *-------|---------|-------|---------|--------------------
2755              *   0   |    0    |  DC   |   DC    | E1000_FC_NONE
2756              *   0   |    1    |   0   |   DC    | E1000_FC_NONE
2757              *   0   |    1    |   1   |    0    | E1000_FC_NONE
2758              *   0   |    1    |   1   |    1    | E1000_FC_TX_PAUSE
2759              *   1   |    0    |   0   |   DC    | E1000_FC_NONE
2760              *   1   |   DC    |   1   |   DC    | E1000_FC_FULL
2761              *   1   |    1    |   0   |    0    | E1000_FC_NONE
2762              *   1   |    1    |   0   |    1    | E1000_FC_RX_PAUSE
2763              *
2764              */
2765             /* Are both PAUSE bits set to 1?  If so, this implies
2766              * Symmetric Flow Control is enabled at both ends.  The
2767              * ASM_DIR bits are irrelevant per the spec.
2768              *
2769              * For Symmetric Flow Control:
2770              *
2771              *   LOCAL DEVICE  |   LINK PARTNER
2772              * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
2773              *-------|---------|-------|---------|--------------------
2774              *   1   |   DC    |   1   |   DC    | E1000_FC_FULL
2775              *
2776              */
2777             if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
2778                 (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE)) {
2779                 /* Now we need to check if the user selected RX ONLY
2780                  * of pause frames.  In this case, we had to advertise
2781                  * FULL flow control because we could not advertise RX
2782                  * ONLY. Hence, we must now check to see if we need to
2783                  * turn OFF  the TRANSMISSION of PAUSE frames.
2784                  */
2785                 if (hw->original_fc == E1000_FC_FULL) {
2786                     hw->fc = E1000_FC_FULL;
2787                     DEBUGOUT("Flow Control = FULL.\n");
2788                 } else {
2789                     hw->fc = E1000_FC_RX_PAUSE;
2790                     DEBUGOUT("Flow Control = RX PAUSE frames only.\n");
2791                 }
2792             }
2793             /* For receiving PAUSE frames ONLY.
2794              *
2795              *   LOCAL DEVICE  |   LINK PARTNER
2796              * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
2797              *-------|---------|-------|---------|--------------------
2798              *   0   |    1    |   1   |    1    | E1000_FC_TX_PAUSE
2799              *
2800              */
2801             else if (!(mii_nway_adv_reg & NWAY_AR_PAUSE) &&
2802                      (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
2803                      (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
2804                      (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
2805                 hw->fc = E1000_FC_TX_PAUSE;
2806                 DEBUGOUT("Flow Control = TX PAUSE frames only.\n");
2807             }
2808             /* For transmitting PAUSE frames ONLY.
2809              *
2810              *   LOCAL DEVICE  |   LINK PARTNER
2811              * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
2812              *-------|---------|-------|---------|--------------------
2813              *   1   |    1    |   0   |    1    | E1000_FC_RX_PAUSE
2814              *
2815              */
2816             else if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
2817                      (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
2818                      !(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
2819                      (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
2820                 hw->fc = E1000_FC_RX_PAUSE;
2821                 DEBUGOUT("Flow Control = RX PAUSE frames only.\n");
2822             }
2823             /* Per the IEEE spec, at this point flow control should be
2824              * disabled.  However, we want to consider that we could
2825              * be connected to a legacy switch that doesn't advertise
2826              * desired flow control, but can be forced on the link
2827              * partner.  So if we advertised no flow control, that is
2828              * what we will resolve to.  If we advertised some kind of
2829              * receive capability (Rx Pause Only or Full Flow Control)
2830              * and the link partner advertised none, we will configure
2831              * ourselves to enable Rx Flow Control only.  We can do
2832              * this safely for two reasons:  If the link partner really
2833              * didn't want flow control enabled, and we enable Rx, no
2834              * harm done since we won't be receiving any PAUSE frames
2835              * anyway.  If the intent on the link partner was to have
2836              * flow control enabled, then by us enabling RX only, we
2837              * can at least receive pause frames and process them.
2838              * This is a good idea because in most cases, since we are
2839              * predominantly a server NIC, more times than not we will
2840              * be asked to delay transmission of packets than asking
2841              * our link partner to pause transmission of frames.
2842              */
2843             else if ((hw->original_fc == E1000_FC_NONE ||
2844                       hw->original_fc == E1000_FC_TX_PAUSE) ||
2845                       hw->fc_strict_ieee) {
2846                 hw->fc = E1000_FC_NONE;
2847                 DEBUGOUT("Flow Control = NONE.\n");
2848             } else {
2849                 hw->fc = E1000_FC_RX_PAUSE;
2850                 DEBUGOUT("Flow Control = RX PAUSE frames only.\n");
2851             }
2852
2853             /* Now we need to do one last check...  If we auto-
2854              * negotiated to HALF DUPLEX, flow control should not be
2855              * enabled per IEEE 802.3 spec.
2856              */
2857             ret_val = e1000_get_speed_and_duplex(hw, &speed, &duplex);
2858             if (ret_val) {
2859                 DEBUGOUT("Error getting link speed and duplex\n");
2860                 return ret_val;
2861             }
2862
2863             if (duplex == HALF_DUPLEX)
2864                 hw->fc = E1000_FC_NONE;
2865
2866             /* Now we call a subroutine to actually force the MAC
2867              * controller to use the correct flow control settings.
2868              */
2869             ret_val = e1000_force_mac_fc(hw);
2870             if (ret_val) {
2871                 DEBUGOUT("Error forcing flow control settings\n");
2872                 return ret_val;
2873             }
2874         } else {
2875             DEBUGOUT("Copper PHY and Auto Neg has not completed.\n");
2876         }
2877     }
2878     return E1000_SUCCESS;
2879 }
2880
2881 /******************************************************************************
2882  * Checks to see if the link status of the hardware has changed.
2883  *
2884  * hw - Struct containing variables accessed by shared code
2885  *
2886  * Called by any function that needs to check the link status of the adapter.
2887  *****************************************************************************/
2888 s32 e1000_check_for_link(struct e1000_hw *hw)
2889 {
2890     u32 rxcw = 0;
2891     u32 ctrl;
2892     u32 status;
2893     u32 rctl;
2894     u32 icr;
2895     u32 signal = 0;
2896     s32 ret_val;
2897     u16 phy_data;
2898
2899     DEBUGFUNC("e1000_check_for_link");
2900
2901     ctrl = er32(CTRL);
2902     status = er32(STATUS);
2903
2904     /* On adapters with a MAC newer than 82544, SW Defineable pin 1 will be
2905      * set when the optics detect a signal. On older adapters, it will be
2906      * cleared when there is a signal.  This applies to fiber media only.
2907      */
2908     if ((hw->media_type == e1000_media_type_fiber) ||
2909         (hw->media_type == e1000_media_type_internal_serdes)) {
2910         rxcw = er32(RXCW);
2911
2912         if (hw->media_type == e1000_media_type_fiber) {
2913             signal = (hw->mac_type > e1000_82544) ? E1000_CTRL_SWDPIN1 : 0;
2914             if (status & E1000_STATUS_LU)
2915                 hw->get_link_status = false;
2916         }
2917     }
2918
2919     /* If we have a copper PHY then we only want to go out to the PHY
2920      * registers to see if Auto-Neg has completed and/or if our link
2921      * status has changed.  The get_link_status flag will be set if we
2922      * receive a Link Status Change interrupt or we have Rx Sequence
2923      * Errors.
2924      */
2925     if ((hw->media_type == e1000_media_type_copper) && hw->get_link_status) {
2926         /* First we want to see if the MII Status Register reports
2927          * link.  If so, then we want to get the current speed/duplex
2928          * of the PHY.
2929          * Read the register twice since the link bit is sticky.
2930          */
2931         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2932         if (ret_val)
2933             return ret_val;
2934         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
2935         if (ret_val)
2936             return ret_val;
2937
2938         if (phy_data & MII_SR_LINK_STATUS) {
2939             hw->get_link_status = false;
2940             /* Check if there was DownShift, must be checked immediately after
2941              * link-up */
2942             e1000_check_downshift(hw);
2943
2944             /* If we are on 82544 or 82543 silicon and speed/duplex
2945              * are forced to 10H or 10F, then we will implement the polarity
2946              * reversal workaround.  We disable interrupts first, and upon
2947              * returning, place the devices interrupt state to its previous
2948              * value except for the link status change interrupt which will
2949              * happen due to the execution of this workaround.
2950              */
2951
2952             if ((hw->mac_type == e1000_82544 || hw->mac_type == e1000_82543) &&
2953                 (!hw->autoneg) &&
2954                 (hw->forced_speed_duplex == e1000_10_full ||
2955                  hw->forced_speed_duplex == e1000_10_half)) {
2956                 ew32(IMC, 0xffffffff);
2957                 ret_val = e1000_polarity_reversal_workaround(hw);
2958                 icr = er32(ICR);
2959                 ew32(ICS, (icr & ~E1000_ICS_LSC));
2960                 ew32(IMS, IMS_ENABLE_MASK);
2961             }
2962
2963         } else {
2964             /* No link detected */
2965             e1000_config_dsp_after_link_change(hw, false);
2966             return 0;
2967         }
2968
2969         /* If we are forcing speed/duplex, then we simply return since
2970          * we have already determined whether we have link or not.
2971          */
2972         if (!hw->autoneg) return -E1000_ERR_CONFIG;
2973
2974         /* optimize the dsp settings for the igp phy */
2975         e1000_config_dsp_after_link_change(hw, true);
2976
2977         /* We have a M88E1000 PHY and Auto-Neg is enabled.  If we
2978          * have Si on board that is 82544 or newer, Auto
2979          * Speed Detection takes care of MAC speed/duplex
2980          * configuration.  So we only need to configure Collision
2981          * Distance in the MAC.  Otherwise, we need to force
2982          * speed/duplex on the MAC to the current PHY speed/duplex
2983          * settings.
2984          */
2985         if (hw->mac_type >= e1000_82544)
2986             e1000_config_collision_dist(hw);
2987         else {
2988             ret_val = e1000_config_mac_to_phy(hw);
2989             if (ret_val) {
2990                 DEBUGOUT("Error configuring MAC to PHY settings\n");
2991                 return ret_val;
2992             }
2993         }
2994
2995         /* Configure Flow Control now that Auto-Neg has completed. First, we
2996          * need to restore the desired flow control settings because we may
2997          * have had to re-autoneg with a different link partner.
2998          */
2999         ret_val = e1000_config_fc_after_link_up(hw);
3000         if (ret_val) {
3001             DEBUGOUT("Error configuring flow control\n");
3002             return ret_val;
3003         }
3004
3005         /* At this point we know that we are on copper and we have
3006          * auto-negotiated link.  These are conditions for checking the link
3007          * partner capability register.  We use the link speed to determine if
3008          * TBI compatibility needs to be turned on or off.  If the link is not
3009          * at gigabit speed, then TBI compatibility is not needed.  If we are
3010          * at gigabit speed, we turn on TBI compatibility.
3011          */
3012         if (hw->tbi_compatibility_en) {
3013             u16 speed, duplex;
3014             ret_val = e1000_get_speed_and_duplex(hw, &speed, &duplex);
3015             if (ret_val) {
3016                 DEBUGOUT("Error getting link speed and duplex\n");
3017                 return ret_val;
3018             }
3019             if (speed != SPEED_1000) {
3020                 /* If link speed is not set to gigabit speed, we do not need
3021                  * to enable TBI compatibility.
3022                  */
3023                 if (hw->tbi_compatibility_on) {
3024                     /* If we previously were in the mode, turn it off. */
3025                     rctl = er32(RCTL);
3026                     rctl &= ~E1000_RCTL_SBP;
3027                     ew32(RCTL, rctl);
3028                     hw->tbi_compatibility_on = false;
3029                 }
3030             } else {
3031                 /* If TBI compatibility is was previously off, turn it on. For
3032                  * compatibility with a TBI link partner, we will store bad
3033                  * packets. Some frames have an additional byte on the end and
3034                  * will look like CRC errors to to the hardware.
3035                  */
3036                 if (!hw->tbi_compatibility_on) {
3037                     hw->tbi_compatibility_on = true;
3038                     rctl = er32(RCTL);
3039                     rctl |= E1000_RCTL_SBP;
3040                     ew32(RCTL, rctl);
3041                 }
3042             }
3043         }
3044     }
3045     /* If we don't have link (auto-negotiation failed or link partner cannot
3046      * auto-negotiate), the cable is plugged in (we have signal), and our
3047      * link partner is not trying to auto-negotiate with us (we are receiving
3048      * idles or data), we need to force link up. We also need to give
3049      * auto-negotiation time to complete, in case the cable was just plugged
3050      * in. The autoneg_failed flag does this.
3051      */
3052     else if ((((hw->media_type == e1000_media_type_fiber) &&
3053               ((ctrl & E1000_CTRL_SWDPIN1) == signal)) ||
3054               (hw->media_type == e1000_media_type_internal_serdes)) &&
3055               (!(status & E1000_STATUS_LU)) &&
3056               (!(rxcw & E1000_RXCW_C))) {
3057         if (hw->autoneg_failed == 0) {
3058             hw->autoneg_failed = 1;
3059             return 0;
3060         }
3061         DEBUGOUT("NOT RXing /C/, disable AutoNeg and force link.\n");
3062
3063         /* Disable auto-negotiation in the TXCW register */
3064         ew32(TXCW, (hw->txcw & ~E1000_TXCW_ANE));
3065
3066         /* Force link-up and also force full-duplex. */
3067         ctrl = er32(CTRL);
3068         ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FD);
3069         ew32(CTRL, ctrl);
3070
3071         /* Configure Flow Control after forcing link up. */
3072         ret_val = e1000_config_fc_after_link_up(hw);
3073         if (ret_val) {
3074             DEBUGOUT("Error configuring flow control\n");
3075             return ret_val;
3076         }
3077     }
3078     /* If we are forcing link and we are receiving /C/ ordered sets, re-enable
3079      * auto-negotiation in the TXCW register and disable forced link in the
3080      * Device Control register in an attempt to auto-negotiate with our link
3081      * partner.
3082      */
3083     else if (((hw->media_type == e1000_media_type_fiber) ||
3084               (hw->media_type == e1000_media_type_internal_serdes)) &&
3085               (ctrl & E1000_CTRL_SLU) && (rxcw & E1000_RXCW_C)) {
3086         DEBUGOUT("RXing /C/, enable AutoNeg and stop forcing link.\n");
3087         ew32(TXCW, hw->txcw);
3088         ew32(CTRL, (ctrl & ~E1000_CTRL_SLU));
3089
3090         hw->serdes_link_down = false;
3091     }
3092     /* If we force link for non-auto-negotiation switch, check link status
3093      * based on MAC synchronization for internal serdes media type.
3094      */
3095     else if ((hw->media_type == e1000_media_type_internal_serdes) &&
3096              !(E1000_TXCW_ANE & er32(TXCW))) {
3097         /* SYNCH bit and IV bit are sticky. */
3098         udelay(10);
3099         if (E1000_RXCW_SYNCH & er32(RXCW)) {
3100             if (!(rxcw & E1000_RXCW_IV)) {
3101                 hw->serdes_link_down = false;
3102                 DEBUGOUT("SERDES: Link is up.\n");
3103             }
3104         } else {
3105             hw->serdes_link_down = true;
3106             DEBUGOUT("SERDES: Link is down.\n");
3107         }
3108     }
3109     if ((hw->media_type == e1000_media_type_internal_serdes) &&
3110         (E1000_TXCW_ANE & er32(TXCW))) {
3111         hw->serdes_link_down = !(E1000_STATUS_LU & er32(STATUS));
3112     }
3113     return E1000_SUCCESS;
3114 }
3115
3116 /******************************************************************************
3117  * Detects the current speed and duplex settings of the hardware.
3118  *
3119  * hw - Struct containing variables accessed by shared code
3120  * speed - Speed of the connection
3121  * duplex - Duplex setting of the connection
3122  *****************************************************************************/
3123 s32 e1000_get_speed_and_duplex(struct e1000_hw *hw, u16 *speed, u16 *duplex)
3124 {
3125     u32 status;
3126     s32 ret_val;
3127     u16 phy_data;
3128
3129     DEBUGFUNC("e1000_get_speed_and_duplex");
3130
3131     if (hw->mac_type >= e1000_82543) {
3132         status = er32(STATUS);
3133         if (status & E1000_STATUS_SPEED_1000) {
3134             *speed = SPEED_1000;
3135             DEBUGOUT("1000 Mbs, ");
3136         } else if (status & E1000_STATUS_SPEED_100) {
3137             *speed = SPEED_100;
3138             DEBUGOUT("100 Mbs, ");
3139         } else {
3140             *speed = SPEED_10;
3141             DEBUGOUT("10 Mbs, ");
3142         }
3143
3144         if (status & E1000_STATUS_FD) {
3145             *duplex = FULL_DUPLEX;
3146             DEBUGOUT("Full Duplex\n");
3147         } else {
3148             *duplex = HALF_DUPLEX;
3149             DEBUGOUT(" Half Duplex\n");
3150         }
3151     } else {
3152         DEBUGOUT("1000 Mbs, Full Duplex\n");
3153         *speed = SPEED_1000;
3154         *duplex = FULL_DUPLEX;
3155     }
3156
3157     /* IGP01 PHY may advertise full duplex operation after speed downgrade even
3158      * if it is operating at half duplex.  Here we set the duplex settings to
3159      * match the duplex in the link partner's capabilities.
3160      */
3161     if (hw->phy_type == e1000_phy_igp && hw->speed_downgraded) {
3162         ret_val = e1000_read_phy_reg(hw, PHY_AUTONEG_EXP, &phy_data);
3163         if (ret_val)
3164             return ret_val;
3165
3166         if (!(phy_data & NWAY_ER_LP_NWAY_CAPS))
3167             *duplex = HALF_DUPLEX;
3168         else {
3169             ret_val = e1000_read_phy_reg(hw, PHY_LP_ABILITY, &phy_data);
3170             if (ret_val)
3171                 return ret_val;
3172             if ((*speed == SPEED_100 && !(phy_data & NWAY_LPAR_100TX_FD_CAPS)) ||
3173                (*speed == SPEED_10 && !(phy_data & NWAY_LPAR_10T_FD_CAPS)))
3174                 *duplex = HALF_DUPLEX;
3175         }
3176     }
3177
3178     if ((hw->mac_type == e1000_80003es2lan) &&
3179         (hw->media_type == e1000_media_type_copper)) {
3180         if (*speed == SPEED_1000)
3181             ret_val = e1000_configure_kmrn_for_1000(hw);
3182         else
3183             ret_val = e1000_configure_kmrn_for_10_100(hw, *duplex);
3184         if (ret_val)
3185             return ret_val;
3186     }
3187
3188     if ((hw->phy_type == e1000_phy_igp_3) && (*speed == SPEED_1000)) {
3189         ret_val = e1000_kumeran_lock_loss_workaround(hw);
3190         if (ret_val)
3191             return ret_val;
3192     }
3193
3194     return E1000_SUCCESS;
3195 }
3196
3197 /******************************************************************************
3198 * Blocks until autoneg completes or times out (~4.5 seconds)
3199 *
3200 * hw - Struct containing variables accessed by shared code
3201 ******************************************************************************/
3202 static s32 e1000_wait_autoneg(struct e1000_hw *hw)
3203 {
3204     s32 ret_val;
3205     u16 i;
3206     u16 phy_data;
3207
3208     DEBUGFUNC("e1000_wait_autoneg");
3209     DEBUGOUT("Waiting for Auto-Neg to complete.\n");
3210
3211     /* We will wait for autoneg to complete or 4.5 seconds to expire. */
3212     for (i = PHY_AUTO_NEG_TIME; i > 0; i--) {
3213         /* Read the MII Status Register and wait for Auto-Neg
3214          * Complete bit to be set.
3215          */
3216         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
3217         if (ret_val)
3218             return ret_val;
3219         ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
3220         if (ret_val)
3221             return ret_val;
3222         if (phy_data & MII_SR_AUTONEG_COMPLETE) {
3223             return E1000_SUCCESS;
3224         }
3225         msleep(100);
3226     }
3227     return E1000_SUCCESS;
3228 }
3229
3230 /******************************************************************************
3231 * Raises the Management Data Clock
3232 *
3233 * hw - Struct containing variables accessed by shared code
3234 * ctrl - Device control register's current value
3235 ******************************************************************************/
3236 static void e1000_raise_mdi_clk(struct e1000_hw *hw, u32 *ctrl)
3237 {
3238     /* Raise the clock input to the Management Data Clock (by setting the MDC
3239      * bit), and then delay 10 microseconds.
3240      */
3241     ew32(CTRL, (*ctrl | E1000_CTRL_MDC));
3242     E1000_WRITE_FLUSH();
3243     udelay(10);
3244 }
3245
3246 /******************************************************************************
3247 * Lowers the Management Data Clock
3248 *