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