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