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