BNX2X: usability fixups
[akaros.git] / kern / drivers / net / e1000 / e1000_82543.c
1 /*******************************************************************************
2
3   Intel PRO/1000 Linux driver
4   Copyright(c) 1999 - 2008 Intel Corporation.
5
6   This program is free software; you can redistribute it and/or modify it
7   under the terms and conditions of the GNU General Public License,
8   version 2, as published by the Free Software Foundation.
9
10   This program is distributed in the hope it will be useful, but WITHOUT
11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13   more details.
14
15   You should have received a copy of the GNU General Public License along with
16   this program; if not, write to the Free Software Foundation, Inc.,
17   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18
19   The full GNU General Public License is included in this distribution in
20   the file called "COPYING".
21
22   Contact Information:
23   Linux NICS <linux.nics@intel.com>
24   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
25   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
26
27 *******************************************************************************/
28
29 FILE_LICENCE(GPL2_OR_LATER);
30
31 /*
32  * 82543GC Gigabit Ethernet Controller (Fiber)
33  * 82543GC Gigabit Ethernet Controller (Copper)
34  * 82544EI Gigabit Ethernet Controller (Copper)
35  * 82544EI Gigabit Ethernet Controller (Fiber)
36  * 82544GC Gigabit Ethernet Controller (Copper)
37  * 82544GC Gigabit Ethernet Controller (LOM)
38  */
39
40 #include "e1000_api.h"
41
42 static s32 e1000_init_phy_params_82543(struct e1000_hw *hw);
43 static s32 e1000_init_nvm_params_82543(struct e1000_hw *hw);
44 static s32 e1000_init_mac_params_82543(struct e1000_hw *hw);
45 static s32 e1000_read_phy_reg_82543(struct e1000_hw *hw, u32 offset,
46                                                                         u16 * data);
47 static s32 e1000_write_phy_reg_82543(struct e1000_hw *hw, u32 offset, u16 data);
48 #if 0
49 static s32 e1000_phy_force_speed_duplex_82543(struct e1000_hw *hw);
50 #endif
51 static s32 e1000_phy_hw_reset_82543(struct e1000_hw *hw);
52 static s32 e1000_reset_hw_82543(struct e1000_hw *hw);
53 static s32 e1000_init_hw_82543(struct e1000_hw *hw);
54 static s32 e1000_setup_link_82543(struct e1000_hw *hw);
55 static s32 e1000_setup_copper_link_82543(struct e1000_hw *hw);
56 static s32 e1000_setup_fiber_link_82543(struct e1000_hw *hw);
57 static s32 e1000_check_for_copper_link_82543(struct e1000_hw *hw);
58 static s32 e1000_check_for_fiber_link_82543(struct e1000_hw *hw);
59 static s32 e1000_led_on_82543(struct e1000_hw *hw);
60 static s32 e1000_led_off_82543(struct e1000_hw *hw);
61 static void e1000_write_vfta_82543(struct e1000_hw *hw, u32 offset, u32 value);
62 static void e1000_mta_set_82543(struct e1000_hw *hw, u32 hash_value);
63 static void e1000_clear_hw_cntrs_82543(struct e1000_hw *hw);
64 static s32 e1000_config_mac_to_phy_82543(struct e1000_hw *hw);
65 static bool e1000_init_phy_disabled_82543(struct e1000_hw *hw);
66 static void e1000_lower_mdi_clk_82543(struct e1000_hw *hw, u32 * ctrl);
67 static s32 e1000_polarity_reversal_workaround_82543(struct e1000_hw *hw);
68 static void e1000_raise_mdi_clk_82543(struct e1000_hw *hw, u32 * ctrl);
69 static u16 e1000_shift_in_mdi_bits_82543(struct e1000_hw *hw);
70 static void e1000_shift_out_mdi_bits_82543(struct e1000_hw *hw, u32 data,
71                                                                                    u16 count);
72 static bool e1000_tbi_compatibility_enabled_82543(struct e1000_hw *hw);
73 static void e1000_set_tbi_compatibility_82543(struct e1000_hw *hw, bool state);
74 static void e1000_set_tbi_sbp_82543(struct e1000_hw *hw, bool state);
75
76 /**
77  *  e1000_init_phy_params_82543 - Init PHY func ptrs.
78  *  @hw: pointer to the HW structure
79  **/
80 static s32 e1000_init_phy_params_82543(struct e1000_hw *hw)
81 {
82         struct e1000_phy_info *phy = &hw->phy;
83         s32 ret_val = E1000_SUCCESS;
84
85         DEBUGFUNC("e1000_init_phy_params_82543");
86
87         if (hw->phy.media_type != e1000_media_type_copper) {
88                 phy->type = e1000_phy_none;
89                 goto out;
90         } else {
91                 phy->ops.power_up = e1000_power_up_phy_copper;
92                 phy->ops.power_down = e1000_power_down_phy_copper;
93         }
94
95         phy->addr = 1;
96         phy->autoneg_mask = AUTONEG_ADVERTISE_SPEED_DEFAULT;
97         phy->reset_delay_us = 10000;
98         phy->type = e1000_phy_m88;
99
100         /* Function Pointers */
101         phy->ops.check_polarity = e1000_check_polarity_m88;
102         phy->ops.commit = e1000_phy_sw_reset_generic;
103 #if 0
104         phy->ops.force_speed_duplex = e1000_phy_force_speed_duplex_82543;
105 #endif
106 #if 0
107         phy->ops.get_cable_length = e1000_get_cable_length_m88;
108 #endif
109         phy->ops.get_cfg_done = e1000_get_cfg_done_generic;
110         phy->ops.read_reg = (hw->mac.type == e1000_82543)
111                 ? e1000_read_phy_reg_82543 : e1000_read_phy_reg_m88;
112         phy->ops.reset = (hw->mac.type == e1000_82543)
113                 ? e1000_phy_hw_reset_82543 : e1000_phy_hw_reset_generic;
114         phy->ops.write_reg = (hw->mac.type == e1000_82543)
115                 ? e1000_write_phy_reg_82543 : e1000_write_phy_reg_m88;
116         phy->ops.get_info = e1000_get_phy_info_m88;
117
118         /*
119          * The external PHY of the 82543 can be in a funky state.
120          * Resetting helps us read the PHY registers for acquiring
121          * the PHY ID.
122          */
123         if (!e1000_init_phy_disabled_82543(hw)) {
124                 ret_val = phy->ops.reset(hw);
125                 if (ret_val) {
126                         DEBUGOUT("Resetting PHY during init failed.\n");
127                         goto out;
128                 }
129                 msec_delay(20);
130         }
131
132         ret_val = e1000_get_phy_id(hw);
133         if (ret_val)
134                 goto out;
135
136         /* Verify phy id */
137         switch (hw->mac.type) {
138                 case e1000_82543:
139                         if (phy->id != M88E1000_E_PHY_ID) {
140                                 ret_val = -E1000_ERR_PHY;
141                                 goto out;
142                         }
143                         break;
144                 case e1000_82544:
145                         if (phy->id != M88E1000_I_PHY_ID) {
146                                 ret_val = -E1000_ERR_PHY;
147                                 goto out;
148                         }
149                         break;
150                 default:
151                         ret_val = -E1000_ERR_PHY;
152                         goto out;
153                         break;
154         }
155
156 out:
157         return ret_val;
158 }
159
160 /**
161  *  e1000_init_nvm_params_82543 - Init NVM func ptrs.
162  *  @hw: pointer to the HW structure
163  **/
164 static s32 e1000_init_nvm_params_82543(struct e1000_hw *hw)
165 {
166         struct e1000_nvm_info *nvm = &hw->nvm;
167
168         DEBUGFUNC("e1000_init_nvm_params_82543");
169
170         nvm->type = e1000_nvm_eeprom_microwire;
171         nvm->word_size = 64;
172         nvm->delay_usec = 50;
173         nvm->address_bits = 6;
174         nvm->opcode_bits = 3;
175
176         /* Function Pointers */
177         nvm->ops.read = e1000_read_nvm_microwire;
178         nvm->ops.update = e1000_update_nvm_checksum_generic;
179         nvm->ops.valid_led_default = e1000_valid_led_default_generic;
180         nvm->ops.validate = e1000_validate_nvm_checksum_generic;
181         nvm->ops.write = e1000_write_nvm_microwire;
182
183         return E1000_SUCCESS;
184 }
185
186 /**
187  *  e1000_init_mac_params_82543 - Init MAC func ptrs.
188  *  @hw: pointer to the HW structure
189  **/
190 static s32 e1000_init_mac_params_82543(struct e1000_hw *hw)
191 {
192         struct e1000_mac_info *mac = &hw->mac;
193
194         DEBUGFUNC("e1000_init_mac_params_82543");
195
196         /* Set media type */
197         switch (hw->device_id) {
198                 case E1000_DEV_ID_82543GC_FIBER:
199                 case E1000_DEV_ID_82544EI_FIBER:
200                         hw->phy.media_type = e1000_media_type_fiber;
201                         break;
202                 default:
203                         hw->phy.media_type = e1000_media_type_copper;
204                         break;
205         }
206
207         /* Set mta register count */
208         mac->mta_reg_count = 128;
209         /* Set rar entry count */
210         mac->rar_entry_count = E1000_RAR_ENTRIES;
211
212         /* Function pointers */
213
214         /* bus type/speed/width */
215         mac->ops.get_bus_info = e1000_get_bus_info_pci_generic;
216         /* function id */
217         mac->ops.set_lan_id = e1000_set_lan_id_multi_port_pci;
218         /* reset */
219         mac->ops.reset_hw = e1000_reset_hw_82543;
220         /* hw initialization */
221         mac->ops.init_hw = e1000_init_hw_82543;
222         /* link setup */
223         mac->ops.setup_link = e1000_setup_link_82543;
224         /* physical interface setup */
225         mac->ops.setup_physical_interface =
226                 (hw->phy.media_type == e1000_media_type_copper)
227                 ? e1000_setup_copper_link_82543 : e1000_setup_fiber_link_82543;
228         /* check for link */
229         mac->ops.check_for_link = (hw->phy.media_type == e1000_media_type_copper)
230                 ? e1000_check_for_copper_link_82543 : e1000_check_for_fiber_link_82543;
231         /* link info */
232         mac->ops.get_link_up_info = (hw->phy.media_type == e1000_media_type_copper)
233                 ? e1000_get_speed_and_duplex_copper_generic
234                 : e1000_get_speed_and_duplex_fiber_serdes_generic;
235         /* multicast address update */
236         mac->ops.update_mc_addr_list = e1000_update_mc_addr_list_generic;
237         /* writing VFTA */
238         mac->ops.write_vfta = e1000_write_vfta_82543;
239         /* clearing VFTA */
240         mac->ops.clear_vfta = e1000_clear_vfta_generic;
241         /* setting MTA */
242         mac->ops.mta_set = e1000_mta_set_82543;
243         /* turn on/off LED */
244         mac->ops.led_on = e1000_led_on_82543;
245         mac->ops.led_off = e1000_led_off_82543;
246         /* clear hardware counters */
247         mac->ops.clear_hw_cntrs = e1000_clear_hw_cntrs_82543;
248
249         /* Set tbi compatibility */
250         if ((hw->mac.type != e1000_82543) ||
251                 (hw->phy.media_type == e1000_media_type_fiber))
252                 e1000_set_tbi_compatibility_82543(hw, false);
253
254         return E1000_SUCCESS;
255 }
256
257 /**
258  *  e1000_init_function_pointers_82543 - Init func ptrs.
259  *  @hw: pointer to the HW structure
260  *
261  *  Called to initialize all function pointers and parameters.
262  **/
263 void e1000_init_function_pointers_82543(struct e1000_hw *hw)
264 {
265         DEBUGFUNC("e1000_init_function_pointers_82543");
266
267         hw->mac.ops.init_params = e1000_init_mac_params_82543;
268         hw->nvm.ops.init_params = e1000_init_nvm_params_82543;
269         hw->phy.ops.init_params = e1000_init_phy_params_82543;
270 }
271
272 /**
273  *  e1000_tbi_compatibility_enabled_82543 - Returns TBI compat status
274  *  @hw: pointer to the HW structure
275  *
276  *  Returns the current status of 10-bit Interface (TBI) compatibility
277  *  (enabled/disabled).
278  **/
279 static bool e1000_tbi_compatibility_enabled_82543(struct e1000_hw *hw)
280 {
281         struct e1000_dev_spec_82543 *dev_spec = &hw->dev_spec._82543;
282         bool state = false;
283
284         DEBUGFUNC("e1000_tbi_compatibility_enabled_82543");
285
286         if (hw->mac.type != e1000_82543) {
287                 DEBUGOUT("TBI compatibility workaround for 82543 only.\n");
288                 goto out;
289         }
290
291         state = (dev_spec->tbi_compatibility & TBI_COMPAT_ENABLED)
292                 ? true : false;
293
294 out:
295         return state;
296 }
297
298 /**
299  *  e1000_set_tbi_compatibility_82543 - Set TBI compatibility
300  *  @hw: pointer to the HW structure
301  *  @state: enable/disable TBI compatibility
302  *
303  *  Enables or disabled 10-bit Interface (TBI) compatibility.
304  **/
305 static void e1000_set_tbi_compatibility_82543(struct e1000_hw *hw, bool state)
306 {
307         struct e1000_dev_spec_82543 *dev_spec = &hw->dev_spec._82543;
308
309         DEBUGFUNC("e1000_set_tbi_compatibility_82543");
310
311         if (hw->mac.type != e1000_82543) {
312                 DEBUGOUT("TBI compatibility workaround for 82543 only.\n");
313                 goto out;
314         }
315
316         if (state)
317                 dev_spec->tbi_compatibility |= TBI_COMPAT_ENABLED;
318         else
319                 dev_spec->tbi_compatibility &= ~TBI_COMPAT_ENABLED;
320
321 out:
322         return;
323 }
324
325 /**
326  *  e1000_tbi_sbp_enabled_82543 - Returns TBI SBP status
327  *  @hw: pointer to the HW structure
328  *
329  *  Returns the current status of 10-bit Interface (TBI) store bad packet (SBP)
330  *  (enabled/disabled).
331  **/
332 bool e1000_tbi_sbp_enabled_82543(struct e1000_hw * hw)
333 {
334         struct e1000_dev_spec_82543 *dev_spec = &hw->dev_spec._82543;
335         bool state = false;
336
337         DEBUGFUNC("e1000_tbi_sbp_enabled_82543");
338
339         if (hw->mac.type != e1000_82543) {
340                 DEBUGOUT("TBI compatibility workaround for 82543 only.\n");
341                 goto out;
342         }
343
344         state = (dev_spec->tbi_compatibility & TBI_SBP_ENABLED)
345                 ? true : false;
346
347 out:
348         return state;
349 }
350
351 /**
352  *  e1000_set_tbi_sbp_82543 - Set TBI SBP
353  *  @hw: pointer to the HW structure
354  *  @state: enable/disable TBI store bad packet
355  *
356  *  Enables or disabled 10-bit Interface (TBI) store bad packet (SBP).
357  **/
358 static void e1000_set_tbi_sbp_82543(struct e1000_hw *hw, bool state)
359 {
360         struct e1000_dev_spec_82543 *dev_spec = &hw->dev_spec._82543;
361
362         DEBUGFUNC("e1000_set_tbi_sbp_82543");
363
364         if (state && e1000_tbi_compatibility_enabled_82543(hw))
365                 dev_spec->tbi_compatibility |= TBI_SBP_ENABLED;
366         else
367                 dev_spec->tbi_compatibility &= ~TBI_SBP_ENABLED;
368
369         return;
370 }
371
372 /**
373  *  e1000_init_phy_disabled_82543 - Returns init PHY status
374  *  @hw: pointer to the HW structure
375  *
376  *  Returns the current status of whether PHY initialization is disabled.
377  *  True if PHY initialization is disabled else false.
378  **/
379 static bool e1000_init_phy_disabled_82543(struct e1000_hw *hw)
380 {
381         struct e1000_dev_spec_82543 *dev_spec = &hw->dev_spec._82543;
382         bool ret_val;
383
384         DEBUGFUNC("e1000_init_phy_disabled_82543");
385
386         if (hw->mac.type != e1000_82543) {
387                 ret_val = false;
388                 goto out;
389         }
390
391         ret_val = dev_spec->init_phy_disabled;
392
393 out:
394         return ret_val;
395 }
396
397 #if 0
398 /**
399  *  e1000_tbi_adjust_stats_82543 - Adjust stats when TBI enabled
400  *  @hw: pointer to the HW structure
401  *  @stats: Struct containing statistic register values
402  *  @frame_len: The length of the frame in question
403  *  @mac_addr: The Ethernet destination address of the frame in question
404  *  @max_frame_size: The maximum frame size
405  *
406  *  Adjusts the statistic counters when a frame is accepted by TBI_ACCEPT
407  **/
408 void e1000_tbi_adjust_stats_82543(struct e1000_hw *hw,
409                                                                   struct e1000_hw_stats *stats, u32 frame_len,
410                                                                   u8 * mac_addr, u32 max_frame_size)
411 {
412         if (!(e1000_tbi_sbp_enabled_82543(hw)))
413                 goto out;
414
415         /* First adjust the frame length. */
416         frame_len--;
417         /*
418          * We need to adjust the statistics counters, since the hardware
419          * counters overcount this packet as a CRC error and undercount
420          * the packet as a good packet
421          */
422         /* This packet should not be counted as a CRC error.    */
423         stats->crcerrs--;
424         /* This packet does count as a Good Packet Received.    */
425         stats->gprc++;
426
427         /* Adjust the Good Octets received counters             */
428         stats->gorc += frame_len;
429
430         /*
431          * Is this a broadcast or multicast?  Check broadcast first,
432          * since the test for a multicast frame will test positive on
433          * a broadcast frame.
434          */
435         if ((mac_addr[0] == 0xff) && (mac_addr[1] == 0xff))
436                 /* Broadcast packet */
437                 stats->bprc++;
438         else if (*mac_addr & 0x01)
439                 /* Multicast packet */
440                 stats->mprc++;
441
442         /*
443          * In this case, the hardware has overcounted the number of
444          * oversize frames.
445          */
446         if ((frame_len == max_frame_size) && (stats->roc > 0))
447                 stats->roc--;
448
449         /*
450          * Adjust the bin counters when the extra byte put the frame in the
451          * wrong bin. Remember that the frame_len was adjusted above.
452          */
453         if (frame_len == 64) {
454                 stats->prc64++;
455                 stats->prc127--;
456         } else if (frame_len == 127) {
457                 stats->prc127++;
458                 stats->prc255--;
459         } else if (frame_len == 255) {
460                 stats->prc255++;
461                 stats->prc511--;
462         } else if (frame_len == 511) {
463                 stats->prc511++;
464                 stats->prc1023--;
465         } else if (frame_len == 1023) {
466                 stats->prc1023++;
467                 stats->prc1522--;
468         } else if (frame_len == 1522) {
469                 stats->prc1522++;
470         }
471
472 out:
473         return;
474 }
475 #endif
476
477 /**
478  *  e1000_read_phy_reg_82543 - Read PHY register
479  *  @hw: pointer to the HW structure
480  *  @offset: register offset to be read
481  *  @data: pointer to the read data
482  *
483  *  Reads the PHY at offset and stores the information read to data.
484  **/
485 static s32 e1000_read_phy_reg_82543(struct e1000_hw *hw, u32 offset, u16 * data)
486 {
487         u32 mdic;
488         s32 ret_val = E1000_SUCCESS;
489
490         DEBUGFUNC("e1000_read_phy_reg_82543");
491
492         if (offset > MAX_PHY_REG_ADDRESS) {
493                 DEBUGOUT1("PHY Address %d is out of range\n", offset);
494                 ret_val = -E1000_ERR_PARAM;
495                 goto out;
496         }
497
498         /*
499          * We must first send a preamble through the MDIO pin to signal the
500          * beginning of an MII instruction.  This is done by sending 32
501          * consecutive "1" bits.
502          */
503         e1000_shift_out_mdi_bits_82543(hw, PHY_PREAMBLE, PHY_PREAMBLE_SIZE);
504
505         /*
506          * Now combine the next few fields that are required for a read
507          * operation.  We use this method instead of calling the
508          * e1000_shift_out_mdi_bits routine five different times.  The format
509          * of an MII read instruction consists of a shift out of 14 bits and
510          * is defined as follows:
511          *  <Preamble><SOF><Op Code><Phy Addr><Offset>
512          * followed by a shift in of 18 bits.  This first two bits shifted in
513          * are TurnAround bits used to avoid contention on the MDIO pin when a
514          * READ operation is performed.  These two bits are thrown away
515          * followed by a shift in of 16 bits which contains the desired data.
516          */
517         mdic = (offset | (hw->phy.addr << 5) |
518                         (PHY_OP_READ << 10) | (PHY_SOF << 12));
519
520         e1000_shift_out_mdi_bits_82543(hw, mdic, 14);
521
522         /*
523          * Now that we've shifted out the read command to the MII, we need to
524          * "shift in" the 16-bit value (18 total bits) of the requested PHY
525          * register address.
526          */
527         *data = e1000_shift_in_mdi_bits_82543(hw);
528
529 out:
530         return ret_val;
531 }
532
533 /**
534  *  e1000_write_phy_reg_82543 - Write PHY register
535  *  @hw: pointer to the HW structure
536  *  @offset: register offset to be written
537  *  @data: pointer to the data to be written at offset
538  *
539  *  Writes data to the PHY at offset.
540  **/
541 static s32 e1000_write_phy_reg_82543(struct e1000_hw *hw, u32 offset, u16 data)
542 {
543         u32 mdic;
544         s32 ret_val = E1000_SUCCESS;
545
546         DEBUGFUNC("e1000_write_phy_reg_82543");
547
548         if (offset > MAX_PHY_REG_ADDRESS) {
549                 DEBUGOUT1("PHY Address %d is out of range\n", offset);
550                 ret_val = -E1000_ERR_PARAM;
551                 goto out;
552         }
553
554         /*
555          * We'll need to use the SW defined pins to shift the write command
556          * out to the PHY. We first send a preamble to the PHY to signal the
557          * beginning of the MII instruction.  This is done by sending 32
558          * consecutive "1" bits.
559          */
560         e1000_shift_out_mdi_bits_82543(hw, PHY_PREAMBLE, PHY_PREAMBLE_SIZE);
561
562         /*
563          * Now combine the remaining required fields that will indicate a
564          * write operation. We use this method instead of calling the
565          * e1000_shift_out_mdi_bits routine for each field in the command. The
566          * format of a MII write instruction is as follows:
567          * <Preamble><SOF><Op Code><Phy Addr><Reg Addr><Turnaround><Data>.
568          */
569         mdic = ((PHY_TURNAROUND) | (offset << 2) | (hw->phy.addr << 7) |
570                         (PHY_OP_WRITE << 12) | (PHY_SOF << 14));
571         mdic <<= 16;
572         mdic |= (u32) data;
573
574         e1000_shift_out_mdi_bits_82543(hw, mdic, 32);
575
576 out:
577         return ret_val;
578 }
579
580 /**
581  *  e1000_raise_mdi_clk_82543 - Raise Management Data Input clock
582  *  @hw: pointer to the HW structure
583  *  @ctrl: pointer to the control register
584  *
585  *  Raise the management data input clock by setting the MDC bit in the control
586  *  register.
587  **/
588 static void e1000_raise_mdi_clk_82543(struct e1000_hw *hw, u32 * ctrl)
589 {
590         /*
591          * Raise the clock input to the Management Data Clock (by setting the
592          * MDC bit), and then delay a sufficient amount of time.
593          */
594         E1000_WRITE_REG(hw, E1000_CTRL, (*ctrl | E1000_CTRL_MDC));
595         E1000_WRITE_FLUSH(hw);
596         usec_delay(10);
597 }
598
599 /**
600  *  e1000_lower_mdi_clk_82543 - Lower Management Data Input clock
601  *  @hw: pointer to the HW structure
602  *  @ctrl: pointer to the control register
603  *
604  *  Lower the management data input clock by clearing the MDC bit in the
605  *  control register.
606  **/
607 static void e1000_lower_mdi_clk_82543(struct e1000_hw *hw, u32 * ctrl)
608 {
609         /*
610          * Lower the clock input to the Management Data Clock (by clearing the
611          * MDC bit), and then delay a sufficient amount of time.
612          */
613         E1000_WRITE_REG(hw, E1000_CTRL, (*ctrl & ~E1000_CTRL_MDC));
614         E1000_WRITE_FLUSH(hw);
615         usec_delay(10);
616 }
617
618 /**
619  *  e1000_shift_out_mdi_bits_82543 - Shift data bits our to the PHY
620  *  @hw: pointer to the HW structure
621  *  @data: data to send to the PHY
622  *  @count: number of bits to shift out
623  *
624  *  We need to shift 'count' bits out to the PHY.  So, the value in the
625  *  "data" parameter will be shifted out to the PHY one bit at a time.
626  *  In order to do this, "data" must be broken down into bits.
627  **/
628 static void e1000_shift_out_mdi_bits_82543(struct e1000_hw *hw, u32 data,
629                                                                                    u16 count)
630 {
631         u32 ctrl, mask;
632
633         /*
634          * We need to shift "count" number of bits out to the PHY.  So, the
635          * value in the "data" parameter will be shifted out to the PHY one
636          * bit at a time.  In order to do this, "data" must be broken down
637          * into bits.
638          */
639         mask = 0x01;
640         mask <<= (count - 1);
641
642         ctrl = E1000_READ_REG(hw, E1000_CTRL);
643
644         /* Set MDIO_DIR and MDC_DIR direction bits to be used as output pins. */
645         ctrl |= (E1000_CTRL_MDIO_DIR | E1000_CTRL_MDC_DIR);
646
647         while (mask) {
648                 /*
649                  * A "1" is shifted out to the PHY by setting the MDIO bit to
650                  * "1" and then raising and lowering the Management Data Clock.
651                  * A "0" is shifted out to the PHY by setting the MDIO bit to
652                  * "0" and then raising and lowering the clock.
653                  */
654                 if (data & mask)
655                         ctrl |= E1000_CTRL_MDIO;
656                 else
657                         ctrl &= ~E1000_CTRL_MDIO;
658
659                 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
660                 E1000_WRITE_FLUSH(hw);
661
662                 usec_delay(10);
663
664                 e1000_raise_mdi_clk_82543(hw, &ctrl);
665                 e1000_lower_mdi_clk_82543(hw, &ctrl);
666
667                 mask >>= 1;
668         }
669 }
670
671 /**
672  *  e1000_shift_in_mdi_bits_82543 - Shift data bits in from the PHY
673  *  @hw: pointer to the HW structure
674  *
675  *  In order to read a register from the PHY, we need to shift 18 bits
676  *  in from the PHY.  Bits are "shifted in" by raising the clock input to
677  *  the PHY (setting the MDC bit), and then reading the value of the data out
678  *  MDIO bit.
679  **/
680 static u16 e1000_shift_in_mdi_bits_82543(struct e1000_hw *hw)
681 {
682         u32 ctrl;
683         u16 data = 0;
684         u8 i;
685
686         /*
687          * In order to read a register from the PHY, we need to shift in a
688          * total of 18 bits from the PHY.  The first two bit (turnaround)
689          * times are used to avoid contention on the MDIO pin when a read
690          * operation is performed.  These two bits are ignored by us and
691          * thrown away.  Bits are "shifted in" by raising the input to the
692          * Management Data Clock (setting the MDC bit) and then reading the
693          * value of the MDIO bit.
694          */
695         ctrl = E1000_READ_REG(hw, E1000_CTRL);
696
697         /*
698          * Clear MDIO_DIR (SWDPIO1) to indicate this bit is to be used as
699          * input.
700          */
701         ctrl &= ~E1000_CTRL_MDIO_DIR;
702         ctrl &= ~E1000_CTRL_MDIO;
703
704         E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
705         E1000_WRITE_FLUSH(hw);
706
707         /*
708          * Raise and lower the clock before reading in the data.  This accounts
709          * for the turnaround bits.  The first clock occurred when we clocked
710          * out the last bit of the Register Address.
711          */
712         e1000_raise_mdi_clk_82543(hw, &ctrl);
713         e1000_lower_mdi_clk_82543(hw, &ctrl);
714
715         for (data = 0, i = 0; i < 16; i++) {
716                 data <<= 1;
717                 e1000_raise_mdi_clk_82543(hw, &ctrl);
718                 ctrl = E1000_READ_REG(hw, E1000_CTRL);
719                 /* Check to see if we shifted in a "1". */
720                 if (ctrl & E1000_CTRL_MDIO)
721                         data |= 1;
722                 e1000_lower_mdi_clk_82543(hw, &ctrl);
723         }
724
725         e1000_raise_mdi_clk_82543(hw, &ctrl);
726         e1000_lower_mdi_clk_82543(hw, &ctrl);
727
728         return data;
729 }
730
731 #if 0
732 /**
733  *  e1000_phy_force_speed_duplex_82543 - Force speed/duplex for PHY
734  *  @hw: pointer to the HW structure
735  *
736  *  Calls the function to force speed and duplex for the m88 PHY, and
737  *  if the PHY is not auto-negotiating and the speed is forced to 10Mbit,
738  *  then call the function for polarity reversal workaround.
739  **/
740 static s32 e1000_phy_force_speed_duplex_82543(struct e1000_hw *hw)
741 {
742         s32 ret_val;
743
744         DEBUGFUNC("e1000_phy_force_speed_duplex_82543");
745
746         ret_val = e1000_phy_force_speed_duplex_m88(hw);
747         if (ret_val)
748                 goto out;
749
750         if (!hw->mac.autoneg && (hw->mac.forced_speed_duplex & E1000_ALL_10_SPEED))
751                 ret_val = e1000_polarity_reversal_workaround_82543(hw);
752
753 out:
754         return ret_val;
755 }
756 #endif
757
758 /**
759  *  e1000_polarity_reversal_workaround_82543 - Workaround polarity reversal
760  *  @hw: pointer to the HW structure
761  *
762  *  When forcing link to 10 Full or 10 Half, the PHY can reverse the polarity
763  *  inadvertently.  To workaround the issue, we disable the transmitter on
764  *  the PHY until we have established the link partner's link parameters.
765  **/
766 static s32 e1000_polarity_reversal_workaround_82543(struct e1000_hw *hw)
767 {
768         s32 ret_val = E1000_SUCCESS;
769         u16 mii_status_reg;
770         u16 i;
771         bool link;
772
773         if (!(hw->phy.ops.write_reg))
774                 goto out;
775
776         /* Polarity reversal workaround for forced 10F/10H links. */
777
778         /* Disable the transmitter on the PHY */
779
780         ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0019);
781         if (ret_val)
782                 goto out;
783         ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_GEN_CONTROL, 0xFFFF);
784         if (ret_val)
785                 goto out;
786
787         ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0000);
788         if (ret_val)
789                 goto out;
790
791         /*
792          * This loop will early-out if the NO link condition has been met.
793          * In other words, DO NOT use e1000_phy_has_link_generic() here.
794          */
795         for (i = PHY_FORCE_TIME; i > 0; i--) {
796                 /*
797                  * Read the MII Status Register and wait for Link Status bit
798                  * to be clear.
799                  */
800
801                 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &mii_status_reg);
802                 if (ret_val)
803                         goto out;
804
805                 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &mii_status_reg);
806                 if (ret_val)
807                         goto out;
808
809                 if ((mii_status_reg & ~MII_SR_LINK_STATUS) == 0)
810                         break;
811                 msec_delay_irq(100);
812         }
813
814         /* Recommended delay time after link has been lost */
815         msec_delay_irq(1000);
816
817         /* Now we will re-enable the transmitter on the PHY */
818
819         ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0019);
820         if (ret_val)
821                 goto out;
822         msec_delay_irq(50);
823         ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_GEN_CONTROL, 0xFFF0);
824         if (ret_val)
825                 goto out;
826         msec_delay_irq(50);
827         ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_GEN_CONTROL, 0xFF00);
828         if (ret_val)
829                 goto out;
830         msec_delay_irq(50);
831         ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_GEN_CONTROL, 0x0000);
832         if (ret_val)
833                 goto out;
834
835         ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0000);
836         if (ret_val)
837                 goto out;
838
839         /*
840          * Read the MII Status Register and wait for Link Status bit
841          * to be set.
842          */
843         ret_val = e1000_phy_has_link_generic(hw, PHY_FORCE_TIME, 100000, &link);
844         if (ret_val)
845                 goto out;
846
847 out:
848         return ret_val;
849 }
850
851 /**
852  *  e1000_phy_hw_reset_82543 - PHY hardware reset
853  *  @hw: pointer to the HW structure
854  *
855  *  Sets the PHY_RESET_DIR bit in the extended device control register
856  *  to put the PHY into a reset and waits for completion.  Once the reset
857  *  has been accomplished, clear the PHY_RESET_DIR bit to take the PHY out
858  *  of reset.
859  **/
860 static s32 e1000_phy_hw_reset_82543(struct e1000_hw *hw)
861 {
862         u32 ctrl_ext;
863         s32 ret_val;
864
865         DEBUGFUNC("e1000_phy_hw_reset_82543");
866
867         /*
868          * Read the Extended Device Control Register, assert the PHY_RESET_DIR
869          * bit to put the PHY into reset...
870          */
871         ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
872         ctrl_ext |= E1000_CTRL_EXT_SDP4_DIR;
873         ctrl_ext &= ~E1000_CTRL_EXT_SDP4_DATA;
874         E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
875         E1000_WRITE_FLUSH(hw);
876
877         msec_delay(10);
878
879         /* ...then take it out of reset. */
880         ctrl_ext |= E1000_CTRL_EXT_SDP4_DATA;
881         E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
882         E1000_WRITE_FLUSH(hw);
883
884         usec_delay(150);
885
886         if (!(hw->phy.ops.get_cfg_done))
887                 return E1000_SUCCESS;
888
889         ret_val = hw->phy.ops.get_cfg_done(hw);
890
891         return ret_val;
892 }
893
894 /**
895  *  e1000_reset_hw_82543 - Reset hardware
896  *  @hw: pointer to the HW structure
897  *
898  *  This resets the hardware into a known state.
899  **/
900 static s32 e1000_reset_hw_82543(struct e1000_hw *hw)
901 {
902         u32 ctrl, icr;
903         s32 ret_val = E1000_SUCCESS;
904
905         DEBUGFUNC("e1000_reset_hw_82543");
906
907         DEBUGOUT("Masking off all interrupts\n");
908         E1000_WRITE_REG(hw, E1000_IMC, 0xffffffff);
909
910         E1000_WRITE_REG(hw, E1000_RCTL, 0);
911         E1000_WRITE_REG(hw, E1000_TCTL, E1000_TCTL_PSP);
912         E1000_WRITE_FLUSH(hw);
913
914         e1000_set_tbi_sbp_82543(hw, false);
915
916         /*
917          * Delay to allow any outstanding PCI transactions to complete before
918          * resetting the device
919          */
920         msec_delay(10);
921
922         ctrl = E1000_READ_REG(hw, E1000_CTRL);
923
924         DEBUGOUT("Issuing a global reset to 82543/82544 MAC\n");
925         if (hw->mac.type == e1000_82543) {
926                 E1000_WRITE_REG(hw, E1000_CTRL, ctrl | E1000_CTRL_RST);
927         } else {
928                 /*
929                  * The 82544 can't ACK the 64-bit write when issuing the
930                  * reset, so use IO-mapping as a workaround.
931                  */
932                 E1000_WRITE_REG_IO(hw, E1000_CTRL, ctrl | E1000_CTRL_RST);
933         }
934
935         /*
936          * After MAC reset, force reload of NVM to restore power-on
937          * settings to device.
938          */
939         hw->nvm.ops.reload(hw);
940         msec_delay(2);
941
942         /* Masking off and clearing any pending interrupts */
943         E1000_WRITE_REG(hw, E1000_IMC, 0xffffffff);
944         icr = E1000_READ_REG(hw, E1000_ICR);
945
946         return ret_val;
947 }
948
949 /**
950  *  e1000_init_hw_82543 - Initialize hardware
951  *  @hw: pointer to the HW structure
952  *
953  *  This inits the hardware readying it for operation.
954  **/
955 static s32 e1000_init_hw_82543(struct e1000_hw *hw)
956 {
957         struct e1000_mac_info *mac = &hw->mac;
958         struct e1000_dev_spec_82543 *dev_spec = &hw->dev_spec._82543;
959         u32 ctrl;
960         s32 ret_val;
961         u16 i;
962
963         DEBUGFUNC("e1000_init_hw_82543");
964
965         /* Disabling VLAN filtering */
966         E1000_WRITE_REG(hw, E1000_VET, 0);
967         mac->ops.clear_vfta(hw);
968
969         /* Setup the receive address. */
970         e1000_init_rx_addrs_generic(hw, mac->rar_entry_count);
971
972         /* Zero out the Multicast HASH table */
973         DEBUGOUT("Zeroing the MTA\n");
974         for (i = 0; i < mac->mta_reg_count; i++) {
975                 E1000_WRITE_REG_ARRAY(hw, E1000_MTA, i, 0);
976                 E1000_WRITE_FLUSH(hw);
977         }
978
979         /*
980          * Set the PCI priority bit correctly in the CTRL register.  This
981          * determines if the adapter gives priority to receives, or if it
982          * gives equal priority to transmits and receives.
983          */
984         if (hw->mac.type == e1000_82543 && dev_spec->dma_fairness) {
985                 ctrl = E1000_READ_REG(hw, E1000_CTRL);
986                 E1000_WRITE_REG(hw, E1000_CTRL, ctrl | E1000_CTRL_PRIOR);
987         }
988
989         e1000_pcix_mmrbc_workaround_generic(hw);
990
991         /* Setup link and flow control */
992         ret_val = mac->ops.setup_link(hw);
993
994         /*
995          * Clear all of the statistics registers (clear on read).  It is
996          * important that we do this after we have tried to establish link
997          * because the symbol error count will increment wildly if there
998          * is no link.
999          */
1000         e1000_clear_hw_cntrs_82543(hw);
1001
1002         return ret_val;
1003 }
1004
1005 /**
1006  *  e1000_setup_link_82543 - Setup flow control and link settings
1007  *  @hw: pointer to the HW structure
1008  *
1009  *  Read the EEPROM to determine the initial polarity value and write the
1010  *  extended device control register with the information before calling
1011  *  the generic setup link function, which does the following:
1012  *  Determines which flow control settings to use, then configures flow
1013  *  control.  Calls the appropriate media-specific link configuration
1014  *  function.  Assuming the adapter has a valid link partner, a valid link
1015  *  should be established.  Assumes the hardware has previously been reset
1016  *  and the transmitter and receiver are not enabled.
1017  **/
1018 static s32 e1000_setup_link_82543(struct e1000_hw *hw)
1019 {
1020         u32 ctrl_ext;
1021         s32 ret_val;
1022         u16 data;
1023
1024         DEBUGFUNC("e1000_setup_link_82543");
1025
1026         /*
1027          * Take the 4 bits from NVM word 0xF that determine the initial
1028          * polarity value for the SW controlled pins, and setup the
1029          * Extended Device Control reg with that info.
1030          * This is needed because one of the SW controlled pins is used for
1031          * signal detection.  So this should be done before phy setup.
1032          */
1033         if (hw->mac.type == e1000_82543) {
1034                 ret_val = hw->nvm.ops.read(hw, NVM_INIT_CONTROL2_REG, 1, &data);
1035                 if (ret_val) {
1036                         DEBUGOUT("NVM Read Error\n");
1037                         ret_val = -E1000_ERR_NVM;
1038                         goto out;
1039                 }
1040                 ctrl_ext = ((data & NVM_WORD0F_SWPDIO_EXT_MASK) <<
1041                                         NVM_SWDPIO_EXT_SHIFT);
1042                 E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
1043         }
1044
1045         ret_val = e1000_setup_link_generic(hw);
1046
1047 out:
1048         return ret_val;
1049 }
1050
1051 /**
1052  *  e1000_setup_copper_link_82543 - Configure copper link settings
1053  *  @hw: pointer to the HW structure
1054  *
1055  *  Configures the link for auto-neg or forced speed and duplex.  Then we check
1056  *  for link, once link is established calls to configure collision distance
1057  *  and flow control are called.
1058  **/
1059 static s32 e1000_setup_copper_link_82543(struct e1000_hw *hw)
1060 {
1061         u32 ctrl;
1062         s32 ret_val;
1063         bool link;
1064
1065         DEBUGFUNC("e1000_setup_copper_link_82543");
1066
1067         ctrl = E1000_READ_REG(hw, E1000_CTRL) | E1000_CTRL_SLU;
1068         /*
1069          * With 82543, we need to force speed and duplex on the MAC
1070          * equal to what the PHY speed and duplex configuration is.
1071          * In addition, we need to perform a hardware reset on the
1072          * PHY to take it out of reset.
1073          */
1074         if (hw->mac.type == e1000_82543) {
1075                 ctrl |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1076                 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1077                 ret_val = hw->phy.ops.reset(hw);
1078                 if (ret_val)
1079                         goto out;
1080                 hw->phy.reset_disable = false;
1081         } else {
1082                 ctrl &= ~(E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1083                 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1084         }
1085
1086         /* Set MDI/MDI-X, Polarity Reversal, and downshift settings */
1087         ret_val = e1000_copper_link_setup_m88(hw);
1088         if (ret_val)
1089                 goto out;
1090
1091         if (hw->mac.autoneg) {
1092                 /*
1093                  * Setup autoneg and flow control advertisement and perform
1094                  * autonegotiation.
1095                  */
1096                 ret_val = e1000_copper_link_autoneg(hw);
1097                 if (ret_val)
1098                         goto out;
1099         } else {
1100                 /*
1101                  * PHY will be set to 10H, 10F, 100H or 100F
1102                  * depending on user settings.
1103                  */
1104 #if 0
1105                 DEBUGOUT("Forcing Speed and Duplex\n");
1106                 ret_val = e1000_phy_force_speed_duplex_82543(hw);
1107                 if (ret_val) {
1108                         DEBUGOUT("Error Forcing Speed and Duplex\n");
1109                         goto out;
1110                 }
1111 #endif
1112         }
1113
1114         /*
1115          * Check link status. Wait up to 100 microseconds for link to become
1116          * valid.
1117          */
1118         ret_val = e1000_phy_has_link_generic(hw, COPPER_LINK_UP_LIMIT, 10, &link);
1119         if (ret_val)
1120                 goto out;
1121
1122         if (link) {
1123                 DEBUGOUT("Valid link established!!!\n");
1124                 /* Config the MAC and PHY after link is up */
1125                 if (hw->mac.type == e1000_82544) {
1126                         e1000_config_collision_dist_generic(hw);
1127                 } else {
1128                         ret_val = e1000_config_mac_to_phy_82543(hw);
1129                         if (ret_val)
1130                                 goto out;
1131                 }
1132                 ret_val = e1000_config_fc_after_link_up_generic(hw);
1133         } else {
1134                 DEBUGOUT("Unable to establish link!!!\n");
1135         }
1136
1137 out:
1138         return ret_val;
1139 }
1140
1141 /**
1142  *  e1000_setup_fiber_link_82543 - Setup link for fiber
1143  *  @hw: pointer to the HW structure
1144  *
1145  *  Configures collision distance and flow control for fiber links.  Upon
1146  *  successful setup, poll for link.
1147  **/
1148 static s32 e1000_setup_fiber_link_82543(struct e1000_hw *hw)
1149 {
1150         u32 ctrl;
1151         s32 ret_val;
1152
1153         DEBUGFUNC("e1000_setup_fiber_link_82543");
1154
1155         ctrl = E1000_READ_REG(hw, E1000_CTRL);
1156
1157         /* Take the link out of reset */
1158         ctrl &= ~E1000_CTRL_LRST;
1159
1160         e1000_config_collision_dist_generic(hw);
1161
1162         ret_val = e1000_commit_fc_settings_generic(hw);
1163         if (ret_val)
1164                 goto out;
1165
1166         DEBUGOUT("Auto-negotiation enabled\n");
1167
1168         E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1169         E1000_WRITE_FLUSH(hw);
1170         msec_delay(1);
1171
1172         /*
1173          * For these adapters, the SW definable pin 1 is cleared when the
1174          * optics detect a signal.  If we have a signal, then poll for a
1175          * "Link-Up" indication.
1176          */
1177         if (!(E1000_READ_REG(hw, E1000_CTRL) & E1000_CTRL_SWDPIN1)) {
1178                 ret_val = e1000_poll_fiber_serdes_link_generic(hw);
1179         } else {
1180                 DEBUGOUT("No signal detected\n");
1181         }
1182
1183 out:
1184         return ret_val;
1185 }
1186
1187 /**
1188  *  e1000_check_for_copper_link_82543 - Check for link (Copper)
1189  *  @hw: pointer to the HW structure
1190  *
1191  *  Checks the phy for link, if link exists, do the following:
1192  *   - check for downshift
1193  *   - do polarity workaround (if necessary)
1194  *   - configure collision distance
1195  *   - configure flow control after link up
1196  *   - configure tbi compatibility
1197  **/
1198 static s32 e1000_check_for_copper_link_82543(struct e1000_hw *hw)
1199 {
1200         struct e1000_mac_info *mac = &hw->mac;
1201         u32 icr, rctl;
1202         s32 ret_val;
1203         u16 speed, duplex;
1204         bool link;
1205
1206         DEBUGFUNC("e1000_check_for_copper_link_82543");
1207
1208         if (!mac->get_link_status) {
1209                 ret_val = E1000_SUCCESS;
1210                 goto out;
1211         }
1212
1213         ret_val = e1000_phy_has_link_generic(hw, 1, 0, &link);
1214         if (ret_val)
1215                 goto out;
1216
1217         if (!link)
1218                 goto out;       /* No link detected */
1219
1220         mac->get_link_status = false;
1221
1222         e1000_check_downshift_generic(hw);
1223
1224         /*
1225          * If we are forcing speed/duplex, then we can return since
1226          * we have already determined whether we have link or not.
1227          */
1228         if (!mac->autoneg) {
1229                 /*
1230                  * If speed and duplex are forced to 10H or 10F, then we will
1231                  * implement the polarity reversal workaround.  We disable
1232                  * interrupts first, and upon returning, place the devices
1233                  * interrupt state to its previous value except for the link
1234                  * status change interrupt which will happened due to the
1235                  * execution of this workaround.
1236                  */
1237                 if (mac->forced_speed_duplex & E1000_ALL_10_SPEED) {
1238                         E1000_WRITE_REG(hw, E1000_IMC, 0xFFFFFFFF);
1239                         ret_val = e1000_polarity_reversal_workaround_82543(hw);
1240                         icr = E1000_READ_REG(hw, E1000_ICR);
1241                         E1000_WRITE_REG(hw, E1000_ICS, (icr & ~E1000_ICS_LSC));
1242                         E1000_WRITE_REG(hw, E1000_IMS, IMS_ENABLE_MASK);
1243                 }
1244
1245                 ret_val = -E1000_ERR_CONFIG;
1246                 goto out;
1247         }
1248
1249         /*
1250          * We have a M88E1000 PHY and Auto-Neg is enabled.  If we
1251          * have Si on board that is 82544 or newer, Auto
1252          * Speed Detection takes care of MAC speed/duplex
1253          * configuration.  So we only need to configure Collision
1254          * Distance in the MAC.  Otherwise, we need to force
1255          * speed/duplex on the MAC to the current PHY speed/duplex
1256          * settings.
1257          */
1258         if (mac->type == e1000_82544)
1259                 e1000_config_collision_dist_generic(hw);
1260         else {
1261                 ret_val = e1000_config_mac_to_phy_82543(hw);
1262                 if (ret_val) {
1263                         DEBUGOUT("Error configuring MAC to PHY settings\n");
1264                         goto out;
1265                 }
1266         }
1267
1268         /*
1269          * Configure Flow Control now that Auto-Neg has completed.
1270          * First, we need to restore the desired flow control
1271          * settings because we may have had to re-autoneg with a
1272          * different link partner.
1273          */
1274         ret_val = e1000_config_fc_after_link_up_generic(hw);
1275         if (ret_val) {
1276                 DEBUGOUT("Error configuring flow control\n");
1277         }
1278
1279         /*
1280          * At this point we know that we are on copper and we have
1281          * auto-negotiated link.  These are conditions for checking the link
1282          * partner capability register.  We use the link speed to determine if
1283          * TBI compatibility needs to be turned on or off.  If the link is not
1284          * at gigabit speed, then TBI compatibility is not needed.  If we are
1285          * at gigabit speed, we turn on TBI compatibility.
1286          */
1287         if (e1000_tbi_compatibility_enabled_82543(hw)) {
1288                 ret_val = mac->ops.get_link_up_info(hw, &speed, &duplex);
1289                 if (ret_val) {
1290                         DEBUGOUT("Error getting link speed and duplex\n");
1291                         return ret_val;
1292                 }
1293                 if (speed != SPEED_1000) {
1294                         /*
1295                          * If link speed is not set to gigabit speed,
1296                          * we do not need to enable TBI compatibility.
1297                          */
1298                         if (e1000_tbi_sbp_enabled_82543(hw)) {
1299                                 /*
1300                                  * If we previously were in the mode,
1301                                  * turn it off.
1302                                  */
1303                                 e1000_set_tbi_sbp_82543(hw, false);
1304                                 rctl = E1000_READ_REG(hw, E1000_RCTL);
1305                                 rctl &= ~E1000_RCTL_SBP;
1306                                 E1000_WRITE_REG(hw, E1000_RCTL, rctl);
1307                         }
1308                 } else {
1309                         /*
1310                          * If TBI compatibility is was previously off,
1311                          * turn it on. For compatibility with a TBI link
1312                          * partner, we will store bad packets. Some
1313                          * frames have an additional byte on the end and
1314                          * will look like CRC errors to to the hardware.
1315                          */
1316                         if (!e1000_tbi_sbp_enabled_82543(hw)) {
1317                                 e1000_set_tbi_sbp_82543(hw, true);
1318                                 rctl = E1000_READ_REG(hw, E1000_RCTL);
1319                                 rctl |= E1000_RCTL_SBP;
1320                                 E1000_WRITE_REG(hw, E1000_RCTL, rctl);
1321                         }
1322                 }
1323         }
1324 out:
1325         return ret_val;
1326 }
1327
1328 /**
1329  *  e1000_check_for_fiber_link_82543 - Check for link (Fiber)
1330  *  @hw: pointer to the HW structure
1331  *
1332  *  Checks for link up on the hardware.  If link is not up and we have
1333  *  a signal, then we need to force link up.
1334  **/
1335 static s32 e1000_check_for_fiber_link_82543(struct e1000_hw *hw)
1336 {
1337         struct e1000_mac_info *mac = &hw->mac;
1338         u32 rxcw, ctrl, status;
1339         s32 ret_val = E1000_SUCCESS;
1340
1341         DEBUGFUNC("e1000_check_for_fiber_link_82543");
1342
1343         ctrl = E1000_READ_REG(hw, E1000_CTRL);
1344         status = E1000_READ_REG(hw, E1000_STATUS);
1345         rxcw = E1000_READ_REG(hw, E1000_RXCW);
1346
1347         /*
1348          * If we don't have link (auto-negotiation failed or link partner
1349          * cannot auto-negotiate), the cable is plugged in (we have signal),
1350          * and our link partner is not trying to auto-negotiate with us (we
1351          * are receiving idles or data), we need to force link up. We also
1352          * need to give auto-negotiation time to complete, in case the cable
1353          * was just plugged in. The autoneg_failed flag does this.
1354          */
1355         /* (ctrl & E1000_CTRL_SWDPIN1) == 0 == have signal */
1356         if ((!(ctrl & E1000_CTRL_SWDPIN1)) &&
1357                 (!(status & E1000_STATUS_LU)) && (!(rxcw & E1000_RXCW_C))) {
1358                 if (mac->autoneg_failed == 0) {
1359                         mac->autoneg_failed = 1;
1360                         ret_val = 0;
1361                         goto out;
1362                 }
1363                 DEBUGOUT("NOT RXing /C/, disable AutoNeg and force link.\n");
1364
1365                 /* Disable auto-negotiation in the TXCW register */
1366                 E1000_WRITE_REG(hw, E1000_TXCW, (mac->txcw & ~E1000_TXCW_ANE));
1367
1368                 /* Force link-up and also force full-duplex. */
1369                 ctrl = E1000_READ_REG(hw, E1000_CTRL);
1370                 ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FD);
1371                 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1372
1373                 /* Configure Flow Control after forcing link up. */
1374                 ret_val = e1000_config_fc_after_link_up_generic(hw);
1375                 if (ret_val) {
1376                         DEBUGOUT("Error configuring flow control\n");
1377                         goto out;
1378                 }
1379         } else if ((ctrl & E1000_CTRL_SLU) && (rxcw & E1000_RXCW_C)) {
1380                 /*
1381                  * If we are forcing link and we are receiving /C/ ordered
1382                  * sets, re-enable auto-negotiation in the TXCW register
1383                  * and disable forced link in the Device Control register
1384                  * in an attempt to auto-negotiate with our link partner.
1385                  */
1386                 DEBUGOUT("RXing /C/, enable AutoNeg and stop forcing link.\n");
1387                 E1000_WRITE_REG(hw, E1000_TXCW, mac->txcw);
1388                 E1000_WRITE_REG(hw, E1000_CTRL, (ctrl & ~E1000_CTRL_SLU));
1389
1390                 mac->serdes_has_link = true;
1391         }
1392
1393 out:
1394         return ret_val;
1395 }
1396
1397 /**
1398  *  e1000_config_mac_to_phy_82543 - Configure MAC to PHY settings
1399  *  @hw: pointer to the HW structure
1400  *
1401  *  For the 82543 silicon, we need to set the MAC to match the settings
1402  *  of the PHY, even if the PHY is auto-negotiating.
1403  **/
1404 static s32 e1000_config_mac_to_phy_82543(struct e1000_hw *hw)
1405 {
1406         u32 ctrl;
1407         s32 ret_val = E1000_SUCCESS;
1408         u16 phy_data;
1409
1410         DEBUGFUNC("e1000_config_mac_to_phy_82543");
1411
1412         if (!(hw->phy.ops.read_reg))
1413                 goto out;
1414
1415         /* Set the bits to force speed and duplex */
1416         ctrl = E1000_READ_REG(hw, E1000_CTRL);
1417         ctrl |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1418         ctrl &= ~(E1000_CTRL_SPD_SEL | E1000_CTRL_ILOS);
1419
1420         /*
1421          * Set up duplex in the Device Control and Transmit Control
1422          * registers depending on negotiated values.
1423          */
1424         ret_val = hw->phy.ops.read_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
1425         if (ret_val)
1426                 goto out;
1427
1428         ctrl &= ~E1000_CTRL_FD;
1429         if (phy_data & M88E1000_PSSR_DPLX)
1430                 ctrl |= E1000_CTRL_FD;
1431
1432         e1000_config_collision_dist_generic(hw);
1433
1434         /*
1435          * Set up speed in the Device Control register depending on
1436          * negotiated values.
1437          */
1438         if ((phy_data & M88E1000_PSSR_SPEED) == M88E1000_PSSR_1000MBS)
1439                 ctrl |= E1000_CTRL_SPD_1000;
1440         else if ((phy_data & M88E1000_PSSR_SPEED) == M88E1000_PSSR_100MBS)
1441                 ctrl |= E1000_CTRL_SPD_100;
1442
1443         E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1444
1445 out:
1446         return ret_val;
1447 }
1448
1449 /**
1450  *  e1000_write_vfta_82543 - Write value to VLAN filter table
1451  *  @hw: pointer to the HW structure
1452  *  @offset: the 32-bit offset in which to write the value to.
1453  *  @value: the 32-bit value to write at location offset.
1454  *
1455  *  This writes a 32-bit value to a 32-bit offset in the VLAN filter
1456  *  table.
1457  **/
1458 static void e1000_write_vfta_82543(struct e1000_hw *hw, u32 offset, u32 value)
1459 {
1460         u32 temp;
1461
1462         DEBUGFUNC("e1000_write_vfta_82543");
1463
1464         if ((hw->mac.type == e1000_82544) && (offset & 1)) {
1465                 temp = E1000_READ_REG_ARRAY(hw, E1000_VFTA, offset - 1);
1466                 E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, value);
1467                 E1000_WRITE_FLUSH(hw);
1468                 E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset - 1, temp);
1469                 E1000_WRITE_FLUSH(hw);
1470         } else {
1471                 e1000_write_vfta_generic(hw, offset, value);
1472         }
1473 }
1474
1475 /**
1476  *  e1000_mta_set_82543 - Set multicast filter table address
1477  *  @hw: pointer to the HW structure
1478  *  @hash_value: determines the MTA register and bit to set
1479  *
1480  *  The multicast table address is a register array of 32-bit registers.
1481  *  The hash_value is used to determine what register the bit is in, the
1482  *  current value is read, the new bit is OR'd in and the new value is
1483  *  written back into the register.
1484  **/
1485 static void e1000_mta_set_82543(struct e1000_hw *hw, u32 hash_value)
1486 {
1487         u32 hash_bit, hash_reg, mta, temp;
1488
1489         DEBUGFUNC("e1000_mta_set_82543");
1490
1491         hash_reg = (hash_value >> 5);
1492
1493         /*
1494          * If we are on an 82544 and we are trying to write an odd offset
1495          * in the MTA, save off the previous entry before writing and
1496          * restore the old value after writing.
1497          */
1498         if ((hw->mac.type == e1000_82544) && (hash_reg & 1)) {
1499                 hash_reg &= (hw->mac.mta_reg_count - 1);
1500                 hash_bit = hash_value & 0x1F;
1501                 mta = E1000_READ_REG_ARRAY(hw, E1000_MTA, hash_reg);
1502                 mta |= (1 << hash_bit);
1503                 temp = E1000_READ_REG_ARRAY(hw, E1000_MTA, hash_reg - 1);
1504
1505                 E1000_WRITE_REG_ARRAY(hw, E1000_MTA, hash_reg, mta);
1506                 E1000_WRITE_FLUSH(hw);
1507                 E1000_WRITE_REG_ARRAY(hw, E1000_MTA, hash_reg - 1, temp);
1508                 E1000_WRITE_FLUSH(hw);
1509         } else {
1510                 e1000_mta_set_generic(hw, hash_value);
1511         }
1512 }
1513
1514 /**
1515  *  e1000_led_on_82543 - Turn on SW controllable LED
1516  *  @hw: pointer to the HW structure
1517  *
1518  *  Turns the SW defined LED on.
1519  **/
1520 static s32 e1000_led_on_82543(struct e1000_hw *hw __unused)
1521 {
1522 #if 0
1523         u32 ctrl = E1000_READ_REG(hw, E1000_CTRL);
1524
1525         DEBUGFUNC("e1000_led_on_82543");
1526
1527         if (hw->mac.type == e1000_82544 &&
1528                 hw->phy.media_type == e1000_media_type_copper) {
1529                 /* Clear SW-definable Pin 0 to turn on the LED */
1530                 ctrl &= ~E1000_CTRL_SWDPIN0;
1531                 ctrl |= E1000_CTRL_SWDPIO0;
1532         } else {
1533                 /* Fiber 82544 and all 82543 use this method */
1534                 ctrl |= E1000_CTRL_SWDPIN0;
1535                 ctrl |= E1000_CTRL_SWDPIO0;
1536         }
1537         E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1538
1539         return E1000_SUCCESS;
1540 #endif
1541         return 0;
1542 }
1543
1544 /**
1545  *  e1000_led_off_82543 - Turn off SW controllable LED
1546  *  @hw: pointer to the HW structure
1547  *
1548  *  Turns the SW defined LED off.
1549  **/
1550 static s32 e1000_led_off_82543(struct e1000_hw *hw __unused)
1551 {
1552 #if 0
1553         u32 ctrl = E1000_READ_REG(hw, E1000_CTRL);
1554
1555         DEBUGFUNC("e1000_led_off_82543");
1556
1557         if (hw->mac.type == e1000_82544 &&
1558                 hw->phy.media_type == e1000_media_type_copper) {
1559                 /* Set SW-definable Pin 0 to turn off the LED */
1560                 ctrl |= E1000_CTRL_SWDPIN0;
1561                 ctrl |= E1000_CTRL_SWDPIO0;
1562         } else {
1563                 ctrl &= ~E1000_CTRL_SWDPIN0;
1564                 ctrl |= E1000_CTRL_SWDPIO0;
1565         }
1566         E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1567
1568         return E1000_SUCCESS;
1569 #endif
1570         return 0;
1571 }
1572
1573 /**
1574  *  e1000_clear_hw_cntrs_82543 - Clear device specific hardware counters
1575  *  @hw: pointer to the HW structure
1576  *
1577  *  Clears the hardware counters by reading the counter registers.
1578  **/
1579 static void e1000_clear_hw_cntrs_82543(struct e1000_hw *hw)
1580 {
1581         DEBUGFUNC("e1000_clear_hw_cntrs_82543");
1582
1583         e1000_clear_hw_cntrs_base_generic(hw);
1584
1585 #if 0
1586         E1000_READ_REG(hw, E1000_PRC64);
1587         E1000_READ_REG(hw, E1000_PRC127);
1588         E1000_READ_REG(hw, E1000_PRC255);
1589         E1000_READ_REG(hw, E1000_PRC511);
1590         E1000_READ_REG(hw, E1000_PRC1023);
1591         E1000_READ_REG(hw, E1000_PRC1522);
1592         E1000_READ_REG(hw, E1000_PTC64);
1593         E1000_READ_REG(hw, E1000_PTC127);
1594         E1000_READ_REG(hw, E1000_PTC255);
1595         E1000_READ_REG(hw, E1000_PTC511);
1596         E1000_READ_REG(hw, E1000_PTC1023);
1597         E1000_READ_REG(hw, E1000_PTC1522);
1598
1599         E1000_READ_REG(hw, E1000_ALGNERRC);
1600         E1000_READ_REG(hw, E1000_RXERRC);
1601         E1000_READ_REG(hw, E1000_TNCRS);
1602         E1000_READ_REG(hw, E1000_CEXTERR);
1603         E1000_READ_REG(hw, E1000_TSCTC);
1604         E1000_READ_REG(hw, E1000_TSCTFC);
1605 #endif
1606 }
1607
1608 static struct pci_device_id e1000_82543_nics[] = {
1609         PCI_ROM(0x8086, 0x1001, "E1000_DEV_ID_82543GC_FIBER",
1610                         "E1000_DEV_ID_82543GC_FIBER", e1000_82543),
1611         PCI_ROM(0x8086, 0x1004, "E1000_DEV_ID_82543GC_COPPER",
1612                         "E1000_DEV_ID_82543GC_COPPER", e1000_82543),
1613         PCI_ROM(0x8086, 0x1008, "E1000_DEV_ID_82544EI_COPPER",
1614                         "E1000_DEV_ID_82544EI_COPPER", e1000_82544),
1615         PCI_ROM(0x8086, 0x1009, "E1000_DEV_ID_82544EI_FIBER",
1616                         "E1000_DEV_ID_82544EI_FIBER", e1000_82544),
1617         PCI_ROM(0x8086, 0x100C, "E1000_DEV_ID_82544GC_COPPER",
1618                         "E1000_DEV_ID_82544GC_COPPER", e1000_82544),
1619         PCI_ROM(0x8086, 0x100D, "E1000_DEV_ID_82544GC_LOM",
1620                         "E1000_DEV_ID_82544GC_LOM", e1000_82544),
1621 };
1622
1623 struct pci_driver e1000_82543_driver __pci_driver = {
1624         .ids = e1000_82543_nics,
1625         .id_count = (sizeof(e1000_82543_nics) / sizeof(e1000_82543_nics[0])),
1626         .probe = e1000_probe,
1627         .remove = e1000_remove,
1628 };