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