1 /******************************************************************************
2 SPDX-License-Identifier: BSD-3-Clause
3
4 Copyright (c) 2001-2020, Intel Corporation
5 All rights reserved.
6
7 Redistribution and use in source and binary forms, with or without
8 modification, are permitted provided that the following conditions are met:
9
10 1. Redistributions of source code must retain the above copyright notice,
11 this list of conditions and the following disclaimer.
12
13 2. Redistributions in binary form must reproduce the above copyright
14 notice, this list of conditions and the following disclaimer in the
15 documentation and/or other materials provided with the distribution.
16
17 3. Neither the name of the Intel Corporation nor the names of its
18 contributors may be used to endorse or promote products derived from
19 this software without specific prior written permission.
20
21 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
25 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 POSSIBILITY OF SUCH DAMAGE.
32
33 ******************************************************************************/
34 /*$FreeBSD$*/
35
36 /*
37 * 82540EM Gigabit Ethernet Controller
38 * 82540EP Gigabit Ethernet Controller
39 * 82545EM Gigabit Ethernet Controller (Copper)
40 * 82545EM Gigabit Ethernet Controller (Fiber)
41 * 82545GM Gigabit Ethernet Controller
42 * 82546EB Gigabit Ethernet Controller (Copper)
43 * 82546EB Gigabit Ethernet Controller (Fiber)
44 * 82546GB Gigabit Ethernet Controller
45 */
46
47 #include "e1000_api.h"
48
49 static s32 e1000_init_phy_params_82540(struct e1000_hw *hw);
50 static s32 e1000_init_nvm_params_82540(struct e1000_hw *hw);
51 static s32 e1000_init_mac_params_82540(struct e1000_hw *hw);
52 static s32 e1000_adjust_serdes_amplitude_82540(struct e1000_hw *hw);
53 static void e1000_clear_hw_cntrs_82540(struct e1000_hw *hw);
54 static s32 e1000_init_hw_82540(struct e1000_hw *hw);
55 static s32 e1000_reset_hw_82540(struct e1000_hw *hw);
56 static s32 e1000_set_phy_mode_82540(struct e1000_hw *hw);
57 static s32 e1000_set_vco_speed_82540(struct e1000_hw *hw);
58 static s32 e1000_setup_copper_link_82540(struct e1000_hw *hw);
59 static s32 e1000_setup_fiber_serdes_link_82540(struct e1000_hw *hw);
60 static void e1000_power_down_phy_copper_82540(struct e1000_hw *hw);
61 static s32 e1000_read_mac_addr_82540(struct e1000_hw *hw);
62
63 /**
64 * e1000_init_phy_params_82540 - Init PHY func ptrs.
65 * @hw: pointer to the HW structure
66 **/
67 static s32 e1000_init_phy_params_82540(struct e1000_hw *hw)
68 {
69 struct e1000_phy_info *phy = &hw->phy;
70 s32 ret_val;
71
72 phy->addr = 1;
73 phy->autoneg_mask = AUTONEG_ADVERTISE_SPEED_DEFAULT;
74 phy->reset_delay_us = 10000;
75 phy->type = e1000_phy_m88;
76
77 /* Function Pointers */
78 phy->ops.check_polarity = e1000_check_polarity_m88;
79 phy->ops.commit = e1000_phy_sw_reset_generic;
80 phy->ops.force_speed_duplex = e1000_phy_force_speed_duplex_m88;
81 phy->ops.get_cable_length = e1000_get_cable_length_m88;
82 phy->ops.get_cfg_done = e1000_get_cfg_done_generic;
83 phy->ops.read_reg = e1000_read_phy_reg_m88;
84 phy->ops.reset = e1000_phy_hw_reset_generic;
85 phy->ops.write_reg = e1000_write_phy_reg_m88;
86 phy->ops.get_info = e1000_get_phy_info_m88;
87 phy->ops.power_up = e1000_power_up_phy_copper;
88 phy->ops.power_down = e1000_power_down_phy_copper_82540;
89
90 ret_val = e1000_get_phy_id(hw);
91 if (ret_val)
92 goto out;
93
94 /* Verify phy id */
95 switch (hw->mac.type) {
96 case e1000_82540:
97 case e1000_82545:
98 case e1000_82545_rev_3:
99 case e1000_82546:
100 case e1000_82546_rev_3:
101 if (phy->id == M88E1011_I_PHY_ID)
102 break;
103 /* FALLTHROUGH */
104 default:
105 ret_val = -E1000_ERR_PHY;
106 goto out;
107 break;
108 }
109
110 out:
111 return ret_val;
112 }
113
114 /**
115 * e1000_init_nvm_params_82540 - Init NVM func ptrs.
116 * @hw: pointer to the HW structure
117 **/
118 static s32 e1000_init_nvm_params_82540(struct e1000_hw *hw)
119 {
120 struct e1000_nvm_info *nvm = &hw->nvm;
121 u32 eecd = E1000_READ_REG(hw, E1000_EECD);
122
123 DEBUGFUNC("e1000_init_nvm_params_82540");
124
125 nvm->type = e1000_nvm_eeprom_microwire;
126 nvm->delay_usec = 50;
127 nvm->opcode_bits = 3;
128 switch (nvm->override) {
129 case e1000_nvm_override_microwire_large:
130 nvm->address_bits = 8;
131 nvm->word_size = 256;
132 break;
133 case e1000_nvm_override_microwire_small:
134 nvm->address_bits = 6;
135 nvm->word_size = 64;
136 break;
137 default:
138 nvm->address_bits = eecd & E1000_EECD_SIZE ? 8 : 6;
139 nvm->word_size = eecd & E1000_EECD_SIZE ? 256 : 64;
140 break;
141 }
142
143 /* Function Pointers */
144 nvm->ops.acquire = e1000_acquire_nvm_generic;
145 nvm->ops.read = e1000_read_nvm_microwire;
146 nvm->ops.release = e1000_release_nvm_generic;
147 nvm->ops.update = e1000_update_nvm_checksum_generic;
148 nvm->ops.valid_led_default = e1000_valid_led_default_generic;
149 nvm->ops.validate = e1000_validate_nvm_checksum_generic;
150 nvm->ops.write = e1000_write_nvm_microwire;
151
152 return E1000_SUCCESS;
153 }
154
155 /**
156 * e1000_init_mac_params_82540 - Init MAC func ptrs.
157 * @hw: pointer to the HW structure
158 **/
159 static s32 e1000_init_mac_params_82540(struct e1000_hw *hw)
160 {
161 struct e1000_mac_info *mac = &hw->mac;
162 s32 ret_val = E1000_SUCCESS;
163
164 DEBUGFUNC("e1000_init_mac_params_82540");
165
166 /* Set media type */
167 switch (hw->device_id) {
168 case E1000_DEV_ID_82545EM_FIBER:
169 case E1000_DEV_ID_82545GM_FIBER:
170 case E1000_DEV_ID_82546EB_FIBER:
171 case E1000_DEV_ID_82546GB_FIBER:
172 hw->phy.media_type = e1000_media_type_fiber;
173 break;
174 case E1000_DEV_ID_82545GM_SERDES:
175 case E1000_DEV_ID_82546GB_SERDES:
176 hw->phy.media_type = e1000_media_type_internal_serdes;
177 break;
178 default:
179 hw->phy.media_type = e1000_media_type_copper;
180 break;
181 }
182
183 /* Set mta register count */
184 mac->mta_reg_count = 128;
185 /* Set rar entry count */
186 mac->rar_entry_count = E1000_RAR_ENTRIES;
187
188 /* Function pointers */
189
190 /* bus type/speed/width */
191 mac->ops.get_bus_info = e1000_get_bus_info_pci_generic;
192 /* function id */
193 mac->ops.set_lan_id = e1000_set_lan_id_multi_port_pci;
194 /* reset */
195 mac->ops.reset_hw = e1000_reset_hw_82540;
196 /* hw initialization */
197 mac->ops.init_hw = e1000_init_hw_82540;
198 /* link setup */
199 mac->ops.setup_link = e1000_setup_link_generic;
200 /* physical interface setup */
201 mac->ops.setup_physical_interface =
202 (hw->phy.media_type == e1000_media_type_copper)
203 ? e1000_setup_copper_link_82540
204 : e1000_setup_fiber_serdes_link_82540;
205 /* check for link */
206 switch (hw->phy.media_type) {
207 case e1000_media_type_copper:
208 mac->ops.check_for_link = e1000_check_for_copper_link_generic;
209 break;
210 case e1000_media_type_fiber:
211 mac->ops.check_for_link = e1000_check_for_fiber_link_generic;
212 break;
213 case e1000_media_type_internal_serdes:
214 mac->ops.check_for_link = e1000_check_for_serdes_link_generic;
215 break;
216 default:
217 ret_val = -E1000_ERR_CONFIG;
218 goto out;
219 break;
220 }
221 /* link info */
222 mac->ops.get_link_up_info =
223 (hw->phy.media_type == e1000_media_type_copper)
224 ? e1000_get_speed_and_duplex_copper_generic
225 : e1000_get_speed_and_duplex_fiber_serdes_generic;
226 /* multicast address update */
227 mac->ops.update_mc_addr_list = e1000_update_mc_addr_list_generic;
228 /* writing VFTA */
229 mac->ops.write_vfta = e1000_write_vfta_generic;
230 /* clearing VFTA */
231 mac->ops.clear_vfta = e1000_clear_vfta_generic;
232 /* read mac address */
233 mac->ops.read_mac_addr = e1000_read_mac_addr_82540;
234 /* ID LED init */
235 mac->ops.id_led_init = e1000_id_led_init_generic;
236 /* setup LED */
237 mac->ops.setup_led = e1000_setup_led_generic;
238 /* cleanup LED */
239 mac->ops.cleanup_led = e1000_cleanup_led_generic;
240 /* turn on/off LED */
241 mac->ops.led_on = e1000_led_on_generic;
242 mac->ops.led_off = e1000_led_off_generic;
243 /* clear hardware counters */
244 mac->ops.clear_hw_cntrs = e1000_clear_hw_cntrs_82540;
245
246 out:
247 return ret_val;
248 }
249
250 /**
251 * e1000_init_function_pointers_82540 - Init func ptrs.
252 * @hw: pointer to the HW structure
253 *
254 * Called to initialize all function pointers and parameters.
255 **/
256 void e1000_init_function_pointers_82540(struct e1000_hw *hw)
257 {
258 DEBUGFUNC("e1000_init_function_pointers_82540");
259
260 hw->mac.ops.init_params = e1000_init_mac_params_82540;
261 hw->nvm.ops.init_params = e1000_init_nvm_params_82540;
262 hw->phy.ops.init_params = e1000_init_phy_params_82540;
263 }
264
265 /**
266 * e1000_reset_hw_82540 - Reset hardware
267 * @hw: pointer to the HW structure
268 *
269 * This resets the hardware into a known state.
270 **/
271 static s32 e1000_reset_hw_82540(struct e1000_hw *hw)
272 {
273 u32 ctrl, manc;
274 s32 ret_val = E1000_SUCCESS;
275
276 DEBUGFUNC("e1000_reset_hw_82540");
277
278 DEBUGOUT("Masking off all interrupts\n");
279 E1000_WRITE_REG(hw, E1000_IMC, 0xFFFFFFFF);
280
281 E1000_WRITE_REG(hw, E1000_RCTL, 0);
282 E1000_WRITE_REG(hw, E1000_TCTL, E1000_TCTL_PSP);
283 E1000_WRITE_FLUSH(hw);
284
285 /*
286 * Delay to allow any outstanding PCI transactions to complete
287 * before resetting the device.
288 */
289 msec_delay(10);
290
291 ctrl = E1000_READ_REG(hw, E1000_CTRL);
292
293 DEBUGOUT("Issuing a global reset to 82540/82545/82546 MAC\n");
294 switch (hw->mac.type) {
295 case e1000_82545_rev_3:
296 case e1000_82546_rev_3:
297 E1000_WRITE_REG(hw, E1000_CTRL_DUP, ctrl | E1000_CTRL_RST);
298 break;
299 default:
300 /*
301 * These controllers can't ack the 64-bit write when
302 * issuing the reset, so we use IO-mapping as a
303 * workaround to issue the reset.
304 */
305 E1000_WRITE_REG_IO(hw, E1000_CTRL, ctrl | E1000_CTRL_RST);
306 break;
307 }
308
309 /* Wait for EEPROM reload */
310 msec_delay(5);
311
312 /* Disable HW ARPs on ASF enabled adapters */
313 manc = E1000_READ_REG(hw, E1000_MANC);
314 manc &= ~E1000_MANC_ARP_EN;
315 E1000_WRITE_REG(hw, E1000_MANC, manc);
316
317 E1000_WRITE_REG(hw, E1000_IMC, 0xffffffff);
318 E1000_READ_REG(hw, E1000_ICR);
319
320 return ret_val;
321 }
322
323 /**
324 * e1000_init_hw_82540 - Initialize hardware
325 * @hw: pointer to the HW structure
326 *
327 * This inits the hardware readying it for operation.
328 **/
329 static s32 e1000_init_hw_82540(struct e1000_hw *hw)
330 {
331 struct e1000_mac_info *mac = &hw->mac;
332 u32 txdctl, ctrl_ext;
333 s32 ret_val;
334 u16 i;
335
336 DEBUGFUNC("e1000_init_hw_82540");
337
338 /* Initialize identification LED */
339 ret_val = mac->ops.id_led_init(hw);
340 if (ret_val) {
341 DEBUGOUT("Error initializing identification LED\n");
342 /* This is not fatal and we should not stop init due to this */
343 }
344
345 /* Disabling VLAN filtering */
346 DEBUGOUT("Initializing the IEEE VLAN\n");
347 if (mac->type < e1000_82545_rev_3)
348 E1000_WRITE_REG(hw, E1000_VET, 0);
349
350 mac->ops.clear_vfta(hw);
351
352 /* Setup the receive address. */
353 e1000_init_rx_addrs_generic(hw, mac->rar_entry_count);
354
355 /* Zero out the Multicast HASH table */
356 DEBUGOUT("Zeroing the MTA\n");
357 for (i = 0; i < mac->mta_reg_count; i++) {
358 E1000_WRITE_REG_ARRAY(hw, E1000_MTA, i, 0);
359 /*
360 * Avoid back to back register writes by adding the register
361 * read (flush). This is to protect against some strange
362 * bridge configurations that may issue Memory Write Block
363 * (MWB) to our register space. The *_rev_3 hardware at
364 * least doesn't respond correctly to every other dword in an
365 * MWB to our register space.
366 */
367 E1000_WRITE_FLUSH(hw);
368 }
369
370 if (mac->type < e1000_82545_rev_3)
371 e1000_pcix_mmrbc_workaround_generic(hw);
372
373 /* Setup link and flow control */
374 ret_val = mac->ops.setup_link(hw);
375
376 txdctl = E1000_READ_REG(hw, E1000_TXDCTL(0));
377 txdctl = (txdctl & ~E1000_TXDCTL_WTHRESH) |
378 E1000_TXDCTL_FULL_TX_DESC_WB;
379 E1000_WRITE_REG(hw, E1000_TXDCTL(0), txdctl);
380
381 /*
382 * Clear all of the statistics registers (clear on read). It is
383 * important that we do this after we have tried to establish link
384 * because the symbol error count will increment wildly if there
385 * is no link.
386 */
387 e1000_clear_hw_cntrs_82540(hw);
388
389 if ((hw->device_id == E1000_DEV_ID_82546GB_QUAD_COPPER) ||
390 (hw->device_id == E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3)) {
391 ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
392 /*
393 * Relaxed ordering must be disabled to avoid a parity
394 * error crash in a PCI slot.
395 */
396 ctrl_ext |= E1000_CTRL_EXT_RO_DIS;
397 E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
398 }
399
400 return ret_val;
401 }
402
403 /**
404 * e1000_setup_copper_link_82540 - Configure copper link settings
405 * @hw: pointer to the HW structure
406 *
407 * Calls the appropriate function to configure the link for auto-neg or forced
408 * speed and duplex. Then we check for link, once link is established calls
409 * to configure collision distance and flow control are called. If link is
410 * not established, we return -E1000_ERR_PHY (-2).
411 **/
412 static s32 e1000_setup_copper_link_82540(struct e1000_hw *hw)
413 {
414 u32 ctrl;
415 s32 ret_val;
416 u16 data;
417
418 DEBUGFUNC("e1000_setup_copper_link_82540");
419
420 ctrl = E1000_READ_REG(hw, E1000_CTRL);
421 ctrl |= E1000_CTRL_SLU;
422 ctrl &= ~(E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
423 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
424
425 ret_val = e1000_set_phy_mode_82540(hw);
426 if (ret_val)
427 goto out;
428
429 if (hw->mac.type == e1000_82545_rev_3 ||
430 hw->mac.type == e1000_82546_rev_3) {
431 ret_val = hw->phy.ops.read_reg(hw, M88E1000_PHY_SPEC_CTRL,
432 &data);
433 if (ret_val)
434 goto out;
435 data |= 0x00000008;
436 ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_SPEC_CTRL,
437 data);
438 if (ret_val)
439 goto out;
440 }
441
442 ret_val = e1000_copper_link_setup_m88(hw);
443 if (ret_val)
444 goto out;
445
446 ret_val = e1000_setup_copper_link_generic(hw);
447
448 out:
449 return ret_val;
450 }
451
452 /**
453 * e1000_setup_fiber_serdes_link_82540 - Setup link for fiber/serdes
454 * @hw: pointer to the HW structure
455 *
456 * Set the output amplitude to the value in the EEPROM and adjust the VCO
457 * speed to improve Bit Error Rate (BER) performance. Configures collision
458 * distance and flow control for fiber and serdes links. Upon successful
459 * setup, poll for link.
460 **/
461 static s32 e1000_setup_fiber_serdes_link_82540(struct e1000_hw *hw)
462 {
463 struct e1000_mac_info *mac = &hw->mac;
464 s32 ret_val = E1000_SUCCESS;
465
466 DEBUGFUNC("e1000_setup_fiber_serdes_link_82540");
467
468 switch (mac->type) {
469 case e1000_82545_rev_3:
470 case e1000_82546_rev_3:
471 if (hw->phy.media_type == e1000_media_type_internal_serdes) {
472 /*
473 * If we're on serdes media, adjust the output
474 * amplitude to value set in the EEPROM.
475 */
476 ret_val = e1000_adjust_serdes_amplitude_82540(hw);
477 if (ret_val)
478 goto out;
479 }
480 /* Adjust VCO speed to improve BER performance */
481 ret_val = e1000_set_vco_speed_82540(hw);
482 if (ret_val)
483 goto out;
484 default:
485 break;
486 }
487
488 ret_val = e1000_setup_fiber_serdes_link_generic(hw);
489
490 out:
491 return ret_val;
492 }
493
494 /**
495 * e1000_adjust_serdes_amplitude_82540 - Adjust amplitude based on EEPROM
496 * @hw: pointer to the HW structure
497 *
498 * Adjust the SERDES output amplitude based on the EEPROM settings.
499 **/
500 static s32 e1000_adjust_serdes_amplitude_82540(struct e1000_hw *hw)
501 {
502 s32 ret_val;
503 u16 nvm_data;
504
505 DEBUGFUNC("e1000_adjust_serdes_amplitude_82540");
506
507 ret_val = hw->nvm.ops.read(hw, NVM_SERDES_AMPLITUDE, 1, &nvm_data);
508 if (ret_val)
509 goto out;
510
511 if (nvm_data != NVM_RESERVED_WORD) {
512 /* Adjust serdes output amplitude only. */
513 nvm_data &= NVM_SERDES_AMPLITUDE_MASK;
514 ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_EXT_CTRL,
515 nvm_data);
516 if (ret_val)
517 goto out;
518 }
519
520 out:
521 return ret_val;
522 }
523
524 /**
525 * e1000_set_vco_speed_82540 - Set VCO speed for better performance
526 * @hw: pointer to the HW structure
527 *
528 * Set the VCO speed to improve Bit Error Rate (BER) performance.
529 **/
530 static s32 e1000_set_vco_speed_82540(struct e1000_hw *hw)
531 {
532 s32 ret_val;
533 u16 default_page = 0;
534 u16 phy_data;
535
536 DEBUGFUNC("e1000_set_vco_speed_82540");
537
538 /* Set PHY register 30, page 5, bit 8 to 0 */
539
540 ret_val = hw->phy.ops.read_reg(hw, M88E1000_PHY_PAGE_SELECT,
541 &default_page);
542 if (ret_val)
543 goto out;
544
545 ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0005);
546 if (ret_val)
547 goto out;
548
549 ret_val = hw->phy.ops.read_reg(hw, M88E1000_PHY_GEN_CONTROL, &phy_data);
550 if (ret_val)
551 goto out;
552
553 phy_data &= ~M88E1000_PHY_VCO_REG_BIT8;
554 ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_GEN_CONTROL, phy_data);
555 if (ret_val)
556 goto out;
557
558 /* Set PHY register 30, page 4, bit 11 to 1 */
559
560 ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_PAGE_SELECT, 0x0004);
561 if (ret_val)
562 goto out;
563
564 ret_val = hw->phy.ops.read_reg(hw, M88E1000_PHY_GEN_CONTROL, &phy_data);
565 if (ret_val)
566 goto out;
567
568 phy_data |= M88E1000_PHY_VCO_REG_BIT11;
569 ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_GEN_CONTROL, phy_data);
570 if (ret_val)
571 goto out;
572
573 ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_PAGE_SELECT,
574 default_page);
575
576 out:
577 return ret_val;
578 }
579
580 /**
581 * e1000_set_phy_mode_82540 - Set PHY to class A mode
582 * @hw: pointer to the HW structure
583 *
584 * Sets the PHY to class A mode and assumes the following operations will
585 * follow to enable the new class mode:
586 * 1. Do a PHY soft reset.
587 * 2. Restart auto-negotiation or force link.
588 **/
589 static s32 e1000_set_phy_mode_82540(struct e1000_hw *hw)
590 {
591 s32 ret_val = E1000_SUCCESS;
592 u16 nvm_data;
593
594 DEBUGFUNC("e1000_set_phy_mode_82540");
595
596 if (hw->mac.type != e1000_82545_rev_3)
597 goto out;
598
599 ret_val = hw->nvm.ops.read(hw, NVM_PHY_CLASS_WORD, 1, &nvm_data);
600 if (ret_val) {
601 ret_val = -E1000_ERR_PHY;
602 goto out;
603 }
604
605 if ((nvm_data != NVM_RESERVED_WORD) && (nvm_data & NVM_PHY_CLASS_A)) {
606 ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_PAGE_SELECT,
607 0x000B);
608 if (ret_val) {
609 ret_val = -E1000_ERR_PHY;
610 goto out;
611 }
612 ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_GEN_CONTROL,
613 0x8104);
614 if (ret_val) {
615 ret_val = -E1000_ERR_PHY;
616 goto out;
617 }
618
619 }
620
621 out:
622 return ret_val;
623 }
624
625 /**
626 * e1000_power_down_phy_copper_82540 - Remove link in case of PHY power down
627 * @hw: pointer to the HW structure
628 *
629 * In the case of a PHY power down to save power, or to turn off link during a
630 * driver unload, or wake on lan is not enabled, remove the link.
631 **/
632 static void e1000_power_down_phy_copper_82540(struct e1000_hw *hw)
633 {
634 /* If the management interface is not enabled, then power down */
635 if (!(E1000_READ_REG(hw, E1000_MANC) & E1000_MANC_SMBUS_EN))
636 e1000_power_down_phy_copper(hw);
637
638 return;
639 }
640
641 /**
642 * e1000_clear_hw_cntrs_82540 - Clear device specific hardware counters
643 * @hw: pointer to the HW structure
644 *
645 * Clears the hardware counters by reading the counter registers.
646 **/
647 static void e1000_clear_hw_cntrs_82540(struct e1000_hw *hw)
648 {
649 DEBUGFUNC("e1000_clear_hw_cntrs_82540");
650
651 e1000_clear_hw_cntrs_base_generic(hw);
652
653 E1000_READ_REG(hw, E1000_PRC64);
654 E1000_READ_REG(hw, E1000_PRC127);
655 E1000_READ_REG(hw, E1000_PRC255);
656 E1000_READ_REG(hw, E1000_PRC511);
657 E1000_READ_REG(hw, E1000_PRC1023);
658 E1000_READ_REG(hw, E1000_PRC1522);
659 E1000_READ_REG(hw, E1000_PTC64);
660 E1000_READ_REG(hw, E1000_PTC127);
661 E1000_READ_REG(hw, E1000_PTC255);
662 E1000_READ_REG(hw, E1000_PTC511);
663 E1000_READ_REG(hw, E1000_PTC1023);
664 E1000_READ_REG(hw, E1000_PTC1522);
665
666 E1000_READ_REG(hw, E1000_ALGNERRC);
667 E1000_READ_REG(hw, E1000_RXERRC);
668 E1000_READ_REG(hw, E1000_TNCRS);
669 E1000_READ_REG(hw, E1000_CEXTERR);
670 E1000_READ_REG(hw, E1000_TSCTC);
671 E1000_READ_REG(hw, E1000_TSCTFC);
672
673 E1000_READ_REG(hw, E1000_MGTPRC);
674 E1000_READ_REG(hw, E1000_MGTPDC);
675 E1000_READ_REG(hw, E1000_MGTPTC);
676 }
677
678 /**
679 * e1000_read_mac_addr_82540 - Read device MAC address
680 * @hw: pointer to the HW structure
681 *
682 * Reads the device MAC address from the EEPROM and stores the value.
683 * Since devices with two ports use the same EEPROM, we increment the
684 * last bit in the MAC address for the second port.
685 *
686 * This version is being used over generic because of customer issues
687 * with VmWare and Virtual Box when using generic. It seems in
688 * the emulated 82545, RAR[0] does NOT have a valid address after a
689 * reset, this older method works and using this breaks nothing for
690 * these legacy adapters.
691 **/
692 s32 e1000_read_mac_addr_82540(struct e1000_hw *hw)
693 {
694 s32 ret_val = E1000_SUCCESS;
695 u16 offset, nvm_data, i;
696
697 DEBUGFUNC("e1000_read_mac_addr");
698
699 for (i = 0; i < ETHER_ADDR_LEN; i += 2) {
700 offset = i >> 1;
701 ret_val = hw->nvm.ops.read(hw, offset, 1, &nvm_data);
702 if (ret_val) {
703 DEBUGOUT("NVM Read Error\n");
704 goto out;
705 }
706 hw->mac.perm_addr[i] = (u8)(nvm_data & 0xFF);
707 hw->mac.perm_addr[i+1] = (u8)(nvm_data >> 8);
708 }
709
710 /* Flip last bit of mac address if we're on second port */
711 if (hw->bus.func == E1000_FUNC_1)
712 hw->mac.perm_addr[5] ^= 1;
713
714 for (i = 0; i < ETHER_ADDR_LEN; i++)
715 hw->mac.addr[i] = hw->mac.perm_addr[i];
716
717 out:
718 return ret_val;
719 }
Cache object: d928858fcbf8826de98390ebff47c18f
|