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