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