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