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