1 /*******************************************************************************
4 Copyright(c) 1999 - 2004 Intel Corporation. All rights reserved.
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 2 of the License, or (at your option)
11 This program is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 You should have received a copy of the GNU General Public License along with
17 this program; if not, write to the Free Software Foundation, Inc., 59
18 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 The full GNU General Public License is included in this distribution in the
24 Linux NICS <linux.nics@intel.com>
25 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27 *******************************************************************************/
29 /* ethtool support for e1000 */
33 #include <asm/uaccess.h>
35 extern char e1000_driver_name
[];
36 extern char e1000_driver_version
[];
38 extern int e1000_up(struct e1000_adapter
*adapter
);
39 extern void e1000_down(struct e1000_adapter
*adapter
);
40 extern void e1000_reset(struct e1000_adapter
*adapter
);
41 extern int e1000_set_spd_dplx(struct e1000_adapter
*adapter
, uint16_t spddplx
);
42 extern int e1000_setup_rx_resources(struct e1000_adapter
*adapter
);
43 extern int e1000_setup_tx_resources(struct e1000_adapter
*adapter
);
44 extern void e1000_free_rx_resources(struct e1000_adapter
*adapter
);
45 extern void e1000_free_tx_resources(struct e1000_adapter
*adapter
);
46 extern void e1000_update_stats(struct e1000_adapter
*adapter
);
49 char stat_string
[ETH_GSTRING_LEN
];
54 #define E1000_STAT(m) sizeof(((struct e1000_adapter *)0)->m), \
55 offsetof(struct e1000_adapter, m)
56 static const struct e1000_stats e1000_gstrings_stats
[] = {
57 { "rx_packets", E1000_STAT(net_stats
.rx_packets
) },
58 { "tx_packets", E1000_STAT(net_stats
.tx_packets
) },
59 { "rx_bytes", E1000_STAT(net_stats
.rx_bytes
) },
60 { "tx_bytes", E1000_STAT(net_stats
.tx_bytes
) },
61 { "rx_errors", E1000_STAT(net_stats
.rx_errors
) },
62 { "tx_errors", E1000_STAT(net_stats
.tx_errors
) },
63 { "rx_dropped", E1000_STAT(net_stats
.rx_dropped
) },
64 { "tx_dropped", E1000_STAT(net_stats
.tx_dropped
) },
65 { "multicast", E1000_STAT(net_stats
.multicast
) },
66 { "collisions", E1000_STAT(net_stats
.collisions
) },
67 { "rx_length_errors", E1000_STAT(net_stats
.rx_length_errors
) },
68 { "rx_over_errors", E1000_STAT(net_stats
.rx_over_errors
) },
69 { "rx_crc_errors", E1000_STAT(net_stats
.rx_crc_errors
) },
70 { "rx_frame_errors", E1000_STAT(net_stats
.rx_frame_errors
) },
71 { "rx_fifo_errors", E1000_STAT(net_stats
.rx_fifo_errors
) },
72 { "rx_missed_errors", E1000_STAT(net_stats
.rx_missed_errors
) },
73 { "tx_aborted_errors", E1000_STAT(net_stats
.tx_aborted_errors
) },
74 { "tx_carrier_errors", E1000_STAT(net_stats
.tx_carrier_errors
) },
75 { "tx_fifo_errors", E1000_STAT(net_stats
.tx_fifo_errors
) },
76 { "tx_heartbeat_errors", E1000_STAT(net_stats
.tx_heartbeat_errors
) },
77 { "tx_window_errors", E1000_STAT(net_stats
.tx_window_errors
) },
78 { "tx_abort_late_coll", E1000_STAT(stats
.latecol
) },
79 { "tx_deferred_ok", E1000_STAT(stats
.dc
) },
80 { "tx_single_coll_ok", E1000_STAT(stats
.scc
) },
81 { "tx_multi_coll_ok", E1000_STAT(stats
.mcc
) },
82 { "rx_long_length_errors", E1000_STAT(stats
.roc
) },
83 { "rx_short_length_errors", E1000_STAT(stats
.ruc
) },
84 { "rx_align_errors", E1000_STAT(stats
.algnerrc
) },
85 { "tx_tcp_seg_good", E1000_STAT(stats
.tsctc
) },
86 { "tx_tcp_seg_failed", E1000_STAT(stats
.tsctfc
) },
87 { "rx_flow_control_xon", E1000_STAT(stats
.xonrxc
) },
88 { "rx_flow_control_xoff", E1000_STAT(stats
.xoffrxc
) },
89 { "tx_flow_control_xon", E1000_STAT(stats
.xontxc
) },
90 { "tx_flow_control_xoff", E1000_STAT(stats
.xofftxc
) },
91 { "rx_long_byte_count", E1000_STAT(stats
.gorcl
) },
92 { "rx_csum_offload_good", E1000_STAT(hw_csum_good
) },
93 { "rx_csum_offload_errors", E1000_STAT(hw_csum_err
) }
95 #define E1000_STATS_LEN \
96 sizeof(e1000_gstrings_stats) / sizeof(struct e1000_stats)
97 static const char e1000_gstrings_test
[][ETH_GSTRING_LEN
] = {
98 "Register test (offline)", "Eeprom test (offline)",
99 "Interrupt test (offline)", "Loopback test (offline)",
100 "Link test (on/offline)"
102 #define E1000_TEST_LEN sizeof(e1000_gstrings_test) / ETH_GSTRING_LEN
105 e1000_get_settings(struct net_device
*netdev
, struct ethtool_cmd
*ecmd
)
107 struct e1000_adapter
*adapter
= netdev
->priv
;
108 struct e1000_hw
*hw
= &adapter
->hw
;
110 if(hw
->media_type
== e1000_media_type_copper
) {
112 ecmd
->supported
= (SUPPORTED_10baseT_Half
|
113 SUPPORTED_10baseT_Full
|
114 SUPPORTED_100baseT_Half
|
115 SUPPORTED_100baseT_Full
|
116 SUPPORTED_1000baseT_Full
|
120 ecmd
->advertising
= ADVERTISED_TP
;
122 if(hw
->autoneg
== 1) {
123 ecmd
->advertising
|= ADVERTISED_Autoneg
;
125 /* the e1000 autoneg seems to match ethtool nicely */
127 ecmd
->advertising
|= hw
->autoneg_advertised
;
130 ecmd
->port
= PORT_TP
;
131 ecmd
->phy_address
= hw
->phy_addr
;
133 if(hw
->mac_type
== e1000_82543
)
134 ecmd
->transceiver
= XCVR_EXTERNAL
;
136 ecmd
->transceiver
= XCVR_INTERNAL
;
139 ecmd
->supported
= (SUPPORTED_1000baseT_Full
|
143 ecmd
->advertising
= (SUPPORTED_1000baseT_Full
|
147 ecmd
->port
= PORT_FIBRE
;
149 if(hw
->mac_type
>= e1000_82545
)
150 ecmd
->transceiver
= XCVR_INTERNAL
;
152 ecmd
->transceiver
= XCVR_EXTERNAL
;
155 if(netif_carrier_ok(adapter
->netdev
)) {
157 e1000_get_speed_and_duplex(hw
, &adapter
->link_speed
,
158 &adapter
->link_duplex
);
159 ecmd
->speed
= adapter
->link_speed
;
161 /* unfortunatly FULL_DUPLEX != DUPLEX_FULL
162 * and HALF_DUPLEX != DUPLEX_HALF */
164 if(adapter
->link_duplex
== FULL_DUPLEX
)
165 ecmd
->duplex
= DUPLEX_FULL
;
167 ecmd
->duplex
= DUPLEX_HALF
;
173 ecmd
->autoneg
= ((hw
->media_type
== e1000_media_type_fiber
) ||
174 hw
->autoneg
) ? AUTONEG_ENABLE
: AUTONEG_DISABLE
;
179 e1000_set_settings(struct net_device
*netdev
, struct ethtool_cmd
*ecmd
)
181 struct e1000_adapter
*adapter
= netdev
->priv
;
182 struct e1000_hw
*hw
= &adapter
->hw
;
184 if(ecmd
->autoneg
== AUTONEG_ENABLE
) {
186 hw
->autoneg_advertised
= 0x002F;
187 ecmd
->advertising
= 0x002F;
189 if(e1000_set_spd_dplx(adapter
, ecmd
->speed
+ ecmd
->duplex
))
194 if(netif_running(adapter
->netdev
)) {
196 e1000_reset(adapter
);
199 e1000_reset(adapter
);
205 e1000_get_pauseparam(struct net_device
*netdev
,
206 struct ethtool_pauseparam
*pause
)
208 struct e1000_adapter
*adapter
= netdev
->priv
;
209 struct e1000_hw
*hw
= &adapter
->hw
;
212 (adapter
->fc_autoneg
? AUTONEG_ENABLE
: AUTONEG_DISABLE
);
214 if(hw
->fc
== e1000_fc_rx_pause
)
216 else if(hw
->fc
== e1000_fc_tx_pause
)
218 else if(hw
->fc
== e1000_fc_full
) {
225 e1000_set_pauseparam(struct net_device
*netdev
,
226 struct ethtool_pauseparam
*pause
)
228 struct e1000_adapter
*adapter
= netdev
->priv
;
229 struct e1000_hw
*hw
= &adapter
->hw
;
231 adapter
->fc_autoneg
= pause
->autoneg
;
233 if(pause
->rx_pause
&& pause
->tx_pause
)
234 hw
->fc
= e1000_fc_full
;
235 else if(pause
->rx_pause
&& !pause
->tx_pause
)
236 hw
->fc
= e1000_fc_rx_pause
;
237 else if(!pause
->rx_pause
&& pause
->tx_pause
)
238 hw
->fc
= e1000_fc_tx_pause
;
239 else if(!pause
->rx_pause
&& !pause
->tx_pause
)
240 hw
->fc
= e1000_fc_none
;
242 hw
->original_fc
= hw
->fc
;
244 if(adapter
->fc_autoneg
== AUTONEG_ENABLE
) {
245 if(netif_running(adapter
->netdev
)) {
249 e1000_reset(adapter
);
252 return e1000_force_mac_fc(hw
);
258 e1000_get_rx_csum(struct net_device
*netdev
)
260 struct e1000_adapter
*adapter
= netdev
->priv
;
261 return adapter
->rx_csum
;
265 e1000_set_rx_csum(struct net_device
*netdev
, uint32_t data
)
267 struct e1000_adapter
*adapter
= netdev
->priv
;
268 adapter
->rx_csum
= data
;
270 if(netif_running(netdev
)) {
274 e1000_reset(adapter
);
279 e1000_get_tx_csum(struct net_device
*netdev
)
281 return (netdev
->features
& NETIF_F_HW_CSUM
) != 0;
285 e1000_set_tx_csum(struct net_device
*netdev
, uint32_t data
)
287 struct e1000_adapter
*adapter
= netdev
->priv
;
289 if(adapter
->hw
.mac_type
< e1000_82543
) {
296 netdev
->features
|= NETIF_F_HW_CSUM
;
298 netdev
->features
&= ~NETIF_F_HW_CSUM
;
305 e1000_set_tso(struct net_device
*netdev
, uint32_t data
)
307 struct e1000_adapter
*adapter
= netdev
->priv
;
308 if ((adapter
->hw
.mac_type
< e1000_82544
) ||
309 (adapter
->hw
.mac_type
== e1000_82547
))
310 return data
? -EINVAL
: 0;
313 netdev
->features
|= NETIF_F_TSO
;
315 netdev
->features
&= ~NETIF_F_TSO
;
318 #endif /* NETIF_F_TSO */
321 e1000_get_msglevel(struct net_device
*netdev
)
323 struct e1000_adapter
*adapter
= netdev
->priv
;
324 return adapter
->msg_enable
;
328 e1000_set_msglevel(struct net_device
*netdev
, uint32_t data
)
330 struct e1000_adapter
*adapter
= netdev
->priv
;
331 adapter
->msg_enable
= data
;
335 e1000_get_regs_len(struct net_device
*netdev
)
337 #define E1000_REGS_LEN 32
338 return E1000_REGS_LEN
* sizeof(uint32_t);
342 e1000_get_regs(struct net_device
*netdev
,
343 struct ethtool_regs
*regs
, void *p
)
345 struct e1000_adapter
*adapter
= netdev
->priv
;
346 struct e1000_hw
*hw
= &adapter
->hw
;
347 uint32_t *regs_buff
= p
;
350 memset(p
, 0, E1000_REGS_LEN
* sizeof(uint32_t));
352 regs
->version
= (1 << 24) | (hw
->revision_id
<< 16) | hw
->device_id
;
354 regs_buff
[0] = E1000_READ_REG(hw
, CTRL
);
355 regs_buff
[1] = E1000_READ_REG(hw
, STATUS
);
357 regs_buff
[2] = E1000_READ_REG(hw
, RCTL
);
358 regs_buff
[3] = E1000_READ_REG(hw
, RDLEN
);
359 regs_buff
[4] = E1000_READ_REG(hw
, RDH
);
360 regs_buff
[5] = E1000_READ_REG(hw
, RDT
);
361 regs_buff
[6] = E1000_READ_REG(hw
, RDTR
);
363 regs_buff
[7] = E1000_READ_REG(hw
, TCTL
);
364 regs_buff
[8] = E1000_READ_REG(hw
, TDLEN
);
365 regs_buff
[9] = E1000_READ_REG(hw
, TDH
);
366 regs_buff
[10] = E1000_READ_REG(hw
, TDT
);
367 regs_buff
[11] = E1000_READ_REG(hw
, TIDV
);
369 regs_buff
[12] = adapter
->hw
.phy_type
; /* PHY type (IGP=1, M88=0) */
370 if(hw
->phy_type
== e1000_phy_igp
) {
371 e1000_write_phy_reg(hw
, IGP01E1000_PHY_PAGE_SELECT
,
372 IGP01E1000_PHY_AGC_A
);
373 e1000_read_phy_reg(hw
, IGP01E1000_PHY_AGC_A
&
374 IGP01E1000_PHY_PAGE_SELECT
, &phy_data
);
375 regs_buff
[13] = (uint32_t)phy_data
; /* cable length */
376 e1000_write_phy_reg(hw
, IGP01E1000_PHY_PAGE_SELECT
,
377 IGP01E1000_PHY_AGC_B
);
378 e1000_read_phy_reg(hw
, IGP01E1000_PHY_AGC_B
&
379 IGP01E1000_PHY_PAGE_SELECT
, &phy_data
);
380 regs_buff
[14] = (uint32_t)phy_data
; /* cable length */
381 e1000_write_phy_reg(hw
, IGP01E1000_PHY_PAGE_SELECT
,
382 IGP01E1000_PHY_AGC_C
);
383 e1000_read_phy_reg(hw
, IGP01E1000_PHY_AGC_C
&
384 IGP01E1000_PHY_PAGE_SELECT
, &phy_data
);
385 regs_buff
[15] = (uint32_t)phy_data
; /* cable length */
386 e1000_write_phy_reg(hw
, IGP01E1000_PHY_PAGE_SELECT
,
387 IGP01E1000_PHY_AGC_D
);
388 e1000_read_phy_reg(hw
, IGP01E1000_PHY_AGC_D
&
389 IGP01E1000_PHY_PAGE_SELECT
, &phy_data
);
390 regs_buff
[16] = (uint32_t)phy_data
; /* cable length */
391 regs_buff
[17] = 0; /* extended 10bt distance (not needed) */
392 e1000_write_phy_reg(hw
, IGP01E1000_PHY_PAGE_SELECT
, 0x0);
393 e1000_read_phy_reg(hw
, IGP01E1000_PHY_PORT_STATUS
&
394 IGP01E1000_PHY_PAGE_SELECT
, &phy_data
);
395 regs_buff
[18] = (uint32_t)phy_data
; /* cable polarity */
396 e1000_write_phy_reg(hw
, IGP01E1000_PHY_PAGE_SELECT
,
397 IGP01E1000_PHY_PCS_INIT_REG
);
398 e1000_read_phy_reg(hw
, IGP01E1000_PHY_PCS_INIT_REG
&
399 IGP01E1000_PHY_PAGE_SELECT
, &phy_data
);
400 regs_buff
[19] = (uint32_t)phy_data
; /* cable polarity */
401 regs_buff
[20] = 0; /* polarity correction enabled (always) */
402 regs_buff
[22] = 0; /* phy receive errors (unavailable) */
403 regs_buff
[23] = regs_buff
[18]; /* mdix mode */
404 e1000_write_phy_reg(hw
, IGP01E1000_PHY_PAGE_SELECT
, 0x0);
406 e1000_read_phy_reg(hw
, M88E1000_PHY_SPEC_STATUS
, &phy_data
);
407 regs_buff
[13] = (uint32_t)phy_data
; /* cable length */
408 regs_buff
[14] = 0; /* Dummy (to align w/ IGP phy reg dump) */
409 regs_buff
[15] = 0; /* Dummy (to align w/ IGP phy reg dump) */
410 regs_buff
[16] = 0; /* Dummy (to align w/ IGP phy reg dump) */
411 e1000_read_phy_reg(hw
, M88E1000_PHY_SPEC_CTRL
, &phy_data
);
412 regs_buff
[17] = (uint32_t)phy_data
; /* extended 10bt distance */
413 regs_buff
[18] = regs_buff
[13]; /* cable polarity */
414 regs_buff
[19] = 0; /* Dummy (to align w/ IGP phy reg dump) */
415 regs_buff
[20] = regs_buff
[17]; /* polarity correction */
416 /* phy receive errors */
417 regs_buff
[22] = adapter
->phy_stats
.receive_errors
;
418 regs_buff
[23] = regs_buff
[13]; /* mdix mode */
420 regs_buff
[21] = adapter
->phy_stats
.idle_errors
; /* phy idle errors */
421 e1000_read_phy_reg(hw
, PHY_1000T_STATUS
, &phy_data
);
422 regs_buff
[24] = (uint32_t)phy_data
; /* phy local receiver status */
423 regs_buff
[25] = regs_buff
[24]; /* phy remote receiver status */
424 if(hw
->mac_type
>= e1000_82540
&&
425 hw
->media_type
== e1000_media_type_copper
) {
426 regs_buff
[26] = E1000_READ_REG(hw
, MANC
);
431 e1000_get_eeprom_len(struct net_device
*netdev
)
433 struct e1000_adapter
*adapter
= netdev
->priv
;
434 return adapter
->hw
.eeprom
.word_size
* 2;
438 e1000_get_eeprom(struct net_device
*netdev
,
439 struct ethtool_eeprom
*eeprom
, uint8_t *bytes
)
441 struct e1000_adapter
*adapter
= netdev
->priv
;
442 struct e1000_hw
*hw
= &adapter
->hw
;
443 uint16_t *eeprom_buff
;
444 int first_word
, last_word
;
451 eeprom
->magic
= hw
->vendor_id
| (hw
->device_id
<< 16);
453 first_word
= eeprom
->offset
>> 1;
454 last_word
= (eeprom
->offset
+ eeprom
->len
- 1) >> 1;
456 eeprom_buff
= kmalloc(sizeof(uint16_t) *
457 (last_word
- first_word
+ 1), GFP_KERNEL
);
461 if(hw
->eeprom
.type
== e1000_eeprom_spi
)
462 ret_val
= e1000_read_eeprom(hw
, first_word
,
463 last_word
- first_word
+ 1,
466 for (i
= 0; i
< last_word
- first_word
+ 1; i
++)
467 if((ret_val
= e1000_read_eeprom(hw
, first_word
+ i
, 1,
472 /* Device's eeprom is always little-endian, word addressable */
473 for (i
= 0; i
< last_word
- first_word
+ 1; i
++)
474 le16_to_cpus(&eeprom_buff
[i
]);
476 memcpy(bytes
, (uint8_t *)eeprom_buff
+ (eeprom
->offset
& 1),
484 e1000_set_eeprom(struct net_device
*netdev
,
485 struct ethtool_eeprom
*eeprom
, uint8_t *bytes
)
487 struct e1000_adapter
*adapter
= netdev
->priv
;
488 struct e1000_hw
*hw
= &adapter
->hw
;
489 uint16_t *eeprom_buff
;
491 int max_len
, first_word
, last_word
, ret_val
= 0;
497 if(eeprom
->magic
!= (hw
->vendor_id
| (hw
->device_id
<< 16)))
500 max_len
= hw
->eeprom
.word_size
* 2;
502 first_word
= eeprom
->offset
>> 1;
503 last_word
= (eeprom
->offset
+ eeprom
->len
- 1) >> 1;
504 eeprom_buff
= kmalloc(max_len
, GFP_KERNEL
);
508 ptr
= (void *)eeprom_buff
;
510 if(eeprom
->offset
& 1) {
511 /* need read/modify/write of first changed EEPROM word */
512 /* only the second byte of the word is being modified */
513 ret_val
= e1000_read_eeprom(hw
, first_word
, 1,
517 if(((eeprom
->offset
+ eeprom
->len
) & 1) && (ret_val
== 0)) {
518 /* need read/modify/write of last changed EEPROM word */
519 /* only the first byte of the word is being modified */
520 ret_val
= e1000_read_eeprom(hw
, last_word
, 1,
521 &eeprom_buff
[last_word
- first_word
]);
524 /* Device's eeprom is always little-endian, word addressable */
525 for (i
= 0; i
< last_word
- first_word
+ 1; i
++)
526 le16_to_cpus(&eeprom_buff
[i
]);
528 memcpy(ptr
, bytes
, eeprom
->len
);
530 for (i
= 0; i
< last_word
- first_word
+ 1; i
++)
531 eeprom_buff
[i
] = cpu_to_le16(eeprom_buff
[i
]);
533 ret_val
= e1000_write_eeprom(hw
, first_word
,
534 last_word
- first_word
+ 1, eeprom_buff
);
536 /* Update the checksum over the first part of the EEPROM if needed */
537 if((ret_val
== 0) && first_word
<= EEPROM_CHECKSUM_REG
)
538 e1000_update_eeprom_checksum(hw
);
545 e1000_get_drvinfo(struct net_device
*netdev
,
546 struct ethtool_drvinfo
*drvinfo
)
548 struct e1000_adapter
*adapter
= netdev
->priv
;
550 strncpy(drvinfo
->driver
, e1000_driver_name
, 32);
551 strncpy(drvinfo
->version
, e1000_driver_version
, 32);
552 strncpy(drvinfo
->fw_version
, "N/A", 32);
553 strncpy(drvinfo
->bus_info
, pci_name(adapter
->pdev
), 32);
554 drvinfo
->n_stats
= E1000_STATS_LEN
;
555 drvinfo
->testinfo_len
= E1000_TEST_LEN
;
556 drvinfo
->regdump_len
= e1000_get_regs_len(netdev
);
557 drvinfo
->eedump_len
= e1000_get_eeprom_len(netdev
);
561 e1000_get_ringparam(struct net_device
*netdev
,
562 struct ethtool_ringparam
*ring
)
564 struct e1000_adapter
*adapter
= netdev
->priv
;
565 e1000_mac_type mac_type
= adapter
->hw
.mac_type
;
566 struct e1000_desc_ring
*txdr
= &adapter
->tx_ring
;
567 struct e1000_desc_ring
*rxdr
= &adapter
->rx_ring
;
569 ring
->rx_max_pending
= (mac_type
< e1000_82544
) ? E1000_MAX_RXD
:
571 ring
->tx_max_pending
= (mac_type
< e1000_82544
) ? E1000_MAX_TXD
:
573 ring
->rx_mini_max_pending
= 0;
574 ring
->rx_jumbo_max_pending
= 0;
575 ring
->rx_pending
= rxdr
->count
;
576 ring
->tx_pending
= txdr
->count
;
577 ring
->rx_mini_pending
= 0;
578 ring
->rx_jumbo_pending
= 0;
582 e1000_set_ringparam(struct net_device
*netdev
,
583 struct ethtool_ringparam
*ring
)
585 struct e1000_adapter
*adapter
= netdev
->priv
;
586 e1000_mac_type mac_type
= adapter
->hw
.mac_type
;
587 struct e1000_desc_ring
*txdr
= &adapter
->tx_ring
;
588 struct e1000_desc_ring
*rxdr
= &adapter
->rx_ring
;
589 struct e1000_desc_ring tx_old
, tx_new
, rx_old
, rx_new
;
592 tx_old
= adapter
->tx_ring
;
593 rx_old
= adapter
->rx_ring
;
595 if(netif_running(adapter
->netdev
))
598 rxdr
->count
= max(ring
->rx_pending
,(uint32_t)E1000_MIN_RXD
);
599 rxdr
->count
= min(rxdr
->count
,(uint32_t)(mac_type
< e1000_82544
?
600 E1000_MAX_RXD
: E1000_MAX_82544_RXD
));
601 E1000_ROUNDUP(rxdr
->count
, REQ_RX_DESCRIPTOR_MULTIPLE
);
603 txdr
->count
= max(ring
->tx_pending
,(uint32_t)E1000_MIN_TXD
);
604 txdr
->count
= min(txdr
->count
,(uint32_t)(mac_type
< e1000_82544
?
605 E1000_MAX_TXD
: E1000_MAX_82544_TXD
));
606 E1000_ROUNDUP(txdr
->count
, REQ_TX_DESCRIPTOR_MULTIPLE
);
608 if(netif_running(adapter
->netdev
)) {
609 /* Try to get new resources before deleting old */
610 if((err
= e1000_setup_rx_resources(adapter
)))
612 if((err
= e1000_setup_tx_resources(adapter
)))
615 /* save the new, restore the old in order to free it,
616 * then restore the new back again */
618 rx_new
= adapter
->rx_ring
;
619 tx_new
= adapter
->tx_ring
;
620 adapter
->rx_ring
= rx_old
;
621 adapter
->tx_ring
= tx_old
;
622 e1000_free_rx_resources(adapter
);
623 e1000_free_tx_resources(adapter
);
624 adapter
->rx_ring
= rx_new
;
625 adapter
->tx_ring
= tx_new
;
626 if((err
= e1000_up(adapter
)))
632 e1000_free_rx_resources(adapter
);
634 adapter
->rx_ring
= rx_old
;
635 adapter
->tx_ring
= tx_old
;
641 #define REG_PATTERN_TEST(R, M, W) \
643 uint32_t pat, value; \
645 {0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF}; \
646 for(pat = 0; pat < sizeof(test)/sizeof(test[0]); pat++) { \
647 E1000_WRITE_REG(&adapter->hw, R, (test[pat] & W)); \
648 value = E1000_READ_REG(&adapter->hw, R); \
649 if(value != (test[pat] & W & M)) { \
650 *data = (adapter->hw.mac_type < e1000_82543) ? \
651 E1000_82542_##R : E1000_##R; \
657 #define REG_SET_AND_CHECK(R, M, W) \
660 E1000_WRITE_REG(&adapter->hw, R, W & M); \
661 value = E1000_READ_REG(&adapter->hw, R); \
662 if ((W & M) != (value & M)) { \
663 *data = (adapter->hw.mac_type < e1000_82543) ? \
664 E1000_82542_##R : E1000_##R; \
670 e1000_reg_test(struct e1000_adapter
*adapter
, uint64_t *data
)
675 /* The status register is Read Only, so a write should fail.
676 * Some bits that get toggled are ignored.
678 value
= (E1000_READ_REG(&adapter
->hw
, STATUS
) & (0xFFFFF833));
679 E1000_WRITE_REG(&adapter
->hw
, STATUS
, (0xFFFFFFFF));
680 if(value
!= (E1000_READ_REG(&adapter
->hw
, STATUS
) & (0xFFFFF833))) {
685 REG_PATTERN_TEST(FCAL
, 0xFFFFFFFF, 0xFFFFFFFF);
686 REG_PATTERN_TEST(FCAH
, 0x0000FFFF, 0xFFFFFFFF);
687 REG_PATTERN_TEST(FCT
, 0x0000FFFF, 0xFFFFFFFF);
688 REG_PATTERN_TEST(VET
, 0x0000FFFF, 0xFFFFFFFF);
689 REG_PATTERN_TEST(RDTR
, 0x0000FFFF, 0xFFFFFFFF);
690 REG_PATTERN_TEST(RDBAH
, 0xFFFFFFFF, 0xFFFFFFFF);
691 REG_PATTERN_TEST(RDLEN
, 0x000FFF80, 0x000FFFFF);
692 REG_PATTERN_TEST(RDH
, 0x0000FFFF, 0x0000FFFF);
693 REG_PATTERN_TEST(RDT
, 0x0000FFFF, 0x0000FFFF);
694 REG_PATTERN_TEST(FCRTH
, 0x0000FFF8, 0x0000FFF8);
695 REG_PATTERN_TEST(FCTTV
, 0x0000FFFF, 0x0000FFFF);
696 REG_PATTERN_TEST(TIPG
, 0x3FFFFFFF, 0x3FFFFFFF);
697 REG_PATTERN_TEST(TDBAH
, 0xFFFFFFFF, 0xFFFFFFFF);
698 REG_PATTERN_TEST(TDLEN
, 0x000FFF80, 0x000FFFFF);
700 REG_SET_AND_CHECK(RCTL
, 0xFFFFFFFF, 0x00000000);
701 REG_SET_AND_CHECK(RCTL
, 0x06DFB3FE, 0x003FFFFB);
702 REG_SET_AND_CHECK(TCTL
, 0xFFFFFFFF, 0x00000000);
704 if(adapter
->hw
.mac_type
>= e1000_82543
) {
706 REG_SET_AND_CHECK(RCTL
, 0x06DFB3FE, 0xFFFFFFFF);
707 REG_PATTERN_TEST(RDBAL
, 0xFFFFFFF0, 0xFFFFFFFF);
708 REG_PATTERN_TEST(TXCW
, 0xC000FFFF, 0x0000FFFF);
709 REG_PATTERN_TEST(TDBAL
, 0xFFFFFFF0, 0xFFFFFFFF);
710 REG_PATTERN_TEST(TIDV
, 0x0000FFFF, 0x0000FFFF);
712 for(i
= 0; i
< E1000_RAR_ENTRIES
; i
++) {
713 REG_PATTERN_TEST(RA
+ ((i
<< 1) << 2), 0xFFFFFFFF,
715 REG_PATTERN_TEST(RA
+ (((i
<< 1) + 1) << 2), 0x8003FFFF,
721 REG_SET_AND_CHECK(RCTL
, 0xFFFFFFFF, 0x01FFFFFF);
722 REG_PATTERN_TEST(RDBAL
, 0xFFFFF000, 0xFFFFFFFF);
723 REG_PATTERN_TEST(TXCW
, 0x0000FFFF, 0x0000FFFF);
724 REG_PATTERN_TEST(TDBAL
, 0xFFFFF000, 0xFFFFFFFF);
728 for(i
= 0; i
< E1000_MC_TBL_SIZE
; i
++)
729 REG_PATTERN_TEST(MTA
+ (i
<< 2), 0xFFFFFFFF, 0xFFFFFFFF);
736 e1000_eeprom_test(struct e1000_adapter
*adapter
, uint64_t *data
)
739 uint16_t checksum
= 0;
743 /* Read and add up the contents of the EEPROM */
744 for(i
= 0; i
< (EEPROM_CHECKSUM_REG
+ 1); i
++) {
745 if((e1000_read_eeprom(&adapter
->hw
, i
, 1, &temp
)) < 0) {
752 /* If Checksum is not Correct return error else test passed */
753 if((checksum
!= (uint16_t) EEPROM_SUM
) && !(*data
))
760 e1000_test_intr(int irq
,
762 struct pt_regs
*regs
)
764 struct net_device
*netdev
= (struct net_device
*) data
;
765 struct e1000_adapter
*adapter
= netdev
->priv
;
767 adapter
->test_icr
|= E1000_READ_REG(&adapter
->hw
, ICR
);
773 e1000_intr_test(struct e1000_adapter
*adapter
, uint64_t *data
)
775 struct net_device
*netdev
= adapter
->netdev
;
776 uint32_t icr
, mask
, i
=0, shared_int
= TRUE
;
777 uint32_t irq
= adapter
->pdev
->irq
;
781 /* Hook up test interrupt handler just for this test */
782 if(!request_irq(irq
, &e1000_test_intr
, 0, netdev
->name
, netdev
)) {
784 } else if(request_irq(irq
, &e1000_test_intr
, SA_SHIRQ
, netdev
->name
, netdev
)){
789 /* Disable all the interrupts */
790 E1000_WRITE_REG(&adapter
->hw
, IMC
, 0xFFFFFFFF);
793 /* Interrupts are disabled, so read interrupt cause
794 * register (icr) twice to verify that there are no interrupts
795 * pending. icr is clear on read.
797 icr
= E1000_READ_REG(&adapter
->hw
, ICR
);
798 icr
= E1000_READ_REG(&adapter
->hw
, ICR
);
801 /* if icr is non-zero, there is no point
802 * running other interrupt tests.
808 /* Test each interrupt */
811 /* Interrupt to test */
815 /* Disable the interrupt to be reported in
816 * the cause register and then force the same
817 * interrupt and see if one gets posted. If
818 * an interrupt was posted to the bus, the
821 adapter
->test_icr
= 0;
822 E1000_WRITE_REG(&adapter
->hw
, IMC
, mask
);
823 E1000_WRITE_REG(&adapter
->hw
, ICS
, mask
);
826 if(adapter
->test_icr
& mask
) {
832 /* Enable the interrupt to be reported in
833 * the cause register and then force the same
834 * interrupt and see if one gets posted. If
835 * an interrupt was not posted to the bus, the
838 adapter
->test_icr
= 0;
839 E1000_WRITE_REG(&adapter
->hw
, IMS
, mask
);
840 E1000_WRITE_REG(&adapter
->hw
, ICS
, mask
);
843 if(!(adapter
->test_icr
& mask
)) {
849 /* Disable the other interrupts to be reported in
850 * the cause register and then force the other
851 * interrupts and see if any get posted. If
852 * an interrupt was posted to the bus, the
855 adapter
->test_icr
= 0;
856 E1000_WRITE_REG(&adapter
->hw
, IMC
, ~mask
);
857 E1000_WRITE_REG(&adapter
->hw
, ICS
, ~mask
);
860 if(adapter
->test_icr
) {
867 /* Disable all the interrupts */
868 E1000_WRITE_REG(&adapter
->hw
, IMC
, 0xFFFFFFFF);
871 /* Unhook test interrupt handler */
872 free_irq(irq
, netdev
);
878 e1000_free_desc_rings(struct e1000_adapter
*adapter
)
880 struct e1000_desc_ring
*txdr
= &adapter
->test_tx_ring
;
881 struct e1000_desc_ring
*rxdr
= &adapter
->test_rx_ring
;
882 struct pci_dev
*pdev
= adapter
->pdev
;
885 if(txdr
->desc
&& txdr
->buffer_info
) {
886 for(i
= 0; i
< txdr
->count
; i
++) {
887 if(txdr
->buffer_info
[i
].dma
)
888 pci_unmap_single(pdev
, txdr
->buffer_info
[i
].dma
,
889 txdr
->buffer_info
[i
].length
,
891 if(txdr
->buffer_info
[i
].skb
)
892 dev_kfree_skb(txdr
->buffer_info
[i
].skb
);
896 if(rxdr
->desc
&& rxdr
->buffer_info
) {
897 for(i
= 0; i
< rxdr
->count
; i
++) {
898 if(rxdr
->buffer_info
[i
].dma
)
899 pci_unmap_single(pdev
, rxdr
->buffer_info
[i
].dma
,
900 rxdr
->buffer_info
[i
].length
,
902 if(rxdr
->buffer_info
[i
].skb
)
903 dev_kfree_skb(rxdr
->buffer_info
[i
].skb
);
908 pci_free_consistent(pdev
, txdr
->size
, txdr
->desc
, txdr
->dma
);
910 pci_free_consistent(pdev
, rxdr
->size
, rxdr
->desc
, rxdr
->dma
);
912 if(txdr
->buffer_info
)
913 kfree(txdr
->buffer_info
);
914 if(rxdr
->buffer_info
)
915 kfree(rxdr
->buffer_info
);
921 e1000_setup_desc_rings(struct e1000_adapter
*adapter
)
923 struct e1000_desc_ring
*txdr
= &adapter
->test_tx_ring
;
924 struct e1000_desc_ring
*rxdr
= &adapter
->test_rx_ring
;
925 struct pci_dev
*pdev
= adapter
->pdev
;
927 int size
, i
, ret_val
;
929 /* Setup Tx descriptor ring and Tx buffers */
933 size
= txdr
->count
* sizeof(struct e1000_buffer
);
934 if(!(txdr
->buffer_info
= kmalloc(size
, GFP_KERNEL
))) {
938 memset(txdr
->buffer_info
, 0, size
);
940 txdr
->size
= txdr
->count
* sizeof(struct e1000_tx_desc
);
941 E1000_ROUNDUP(txdr
->size
, 4096);
942 if(!(txdr
->desc
= pci_alloc_consistent(pdev
, txdr
->size
, &txdr
->dma
))) {
946 memset(txdr
->desc
, 0, txdr
->size
);
947 txdr
->next_to_use
= txdr
->next_to_clean
= 0;
949 E1000_WRITE_REG(&adapter
->hw
, TDBAL
,
950 ((uint64_t) txdr
->dma
& 0x00000000FFFFFFFF));
951 E1000_WRITE_REG(&adapter
->hw
, TDBAH
, ((uint64_t) txdr
->dma
>> 32));
952 E1000_WRITE_REG(&adapter
->hw
, TDLEN
,
953 txdr
->count
* sizeof(struct e1000_tx_desc
));
954 E1000_WRITE_REG(&adapter
->hw
, TDH
, 0);
955 E1000_WRITE_REG(&adapter
->hw
, TDT
, 0);
956 E1000_WRITE_REG(&adapter
->hw
, TCTL
,
957 E1000_TCTL_PSP
| E1000_TCTL_EN
|
958 E1000_COLLISION_THRESHOLD
<< E1000_CT_SHIFT
|
959 E1000_FDX_COLLISION_DISTANCE
<< E1000_COLD_SHIFT
);
961 for(i
= 0; i
< txdr
->count
; i
++) {
962 struct e1000_tx_desc
*tx_desc
= E1000_TX_DESC(*txdr
, i
);
964 unsigned int size
= 1024;
966 if(!(skb
= alloc_skb(size
, GFP_KERNEL
))) {
971 txdr
->buffer_info
[i
].skb
= skb
;
972 txdr
->buffer_info
[i
].length
= skb
->len
;
973 txdr
->buffer_info
[i
].dma
=
974 pci_map_single(pdev
, skb
->data
, skb
->len
,
976 tx_desc
->buffer_addr
= cpu_to_le64(txdr
->buffer_info
[i
].dma
);
977 tx_desc
->lower
.data
= cpu_to_le32(skb
->len
);
978 tx_desc
->lower
.data
|= cpu_to_le32(E1000_TXD_CMD_EOP
|
981 tx_desc
->upper
.data
= 0;
984 /* Setup Rx descriptor ring and Rx buffers */
988 size
= rxdr
->count
* sizeof(struct e1000_buffer
);
989 if(!(rxdr
->buffer_info
= kmalloc(size
, GFP_KERNEL
))) {
993 memset(rxdr
->buffer_info
, 0, size
);
995 rxdr
->size
= rxdr
->count
* sizeof(struct e1000_rx_desc
);
996 if(!(rxdr
->desc
= pci_alloc_consistent(pdev
, rxdr
->size
, &rxdr
->dma
))) {
1000 memset(rxdr
->desc
, 0, rxdr
->size
);
1001 rxdr
->next_to_use
= rxdr
->next_to_clean
= 0;
1003 rctl
= E1000_READ_REG(&adapter
->hw
, RCTL
);
1004 E1000_WRITE_REG(&adapter
->hw
, RCTL
, rctl
& ~E1000_RCTL_EN
);
1005 E1000_WRITE_REG(&adapter
->hw
, RDBAL
,
1006 ((uint64_t) rxdr
->dma
& 0xFFFFFFFF));
1007 E1000_WRITE_REG(&adapter
->hw
, RDBAH
, ((uint64_t) rxdr
->dma
>> 32));
1008 E1000_WRITE_REG(&adapter
->hw
, RDLEN
, rxdr
->size
);
1009 E1000_WRITE_REG(&adapter
->hw
, RDH
, 0);
1010 E1000_WRITE_REG(&adapter
->hw
, RDT
, 0);
1011 rctl
= E1000_RCTL_EN
| E1000_RCTL_BAM
| E1000_RCTL_SZ_2048
|
1012 E1000_RCTL_LBM_NO
| E1000_RCTL_RDMTS_HALF
|
1013 (adapter
->hw
.mc_filter_type
<< E1000_RCTL_MO_SHIFT
);
1014 E1000_WRITE_REG(&adapter
->hw
, RCTL
, rctl
);
1016 for(i
= 0; i
< rxdr
->count
; i
++) {
1017 struct e1000_rx_desc
*rx_desc
= E1000_RX_DESC(*rxdr
, i
);
1018 struct sk_buff
*skb
;
1020 if(!(skb
= alloc_skb(E1000_RXBUFFER_2048
+ NET_IP_ALIGN
,
1025 skb_reserve(skb
, NET_IP_ALIGN
);
1026 rxdr
->buffer_info
[i
].skb
= skb
;
1027 rxdr
->buffer_info
[i
].length
= E1000_RXBUFFER_2048
;
1028 rxdr
->buffer_info
[i
].dma
=
1029 pci_map_single(pdev
, skb
->data
, E1000_RXBUFFER_2048
,
1030 PCI_DMA_FROMDEVICE
);
1031 rx_desc
->buffer_addr
= cpu_to_le64(rxdr
->buffer_info
[i
].dma
);
1032 memset(skb
->data
, 0x00, skb
->len
);
1038 e1000_free_desc_rings(adapter
);
1043 e1000_phy_disable_receiver(struct e1000_adapter
*adapter
)
1045 /* Write out to PHY registers 29 and 30 to disable the Receiver. */
1046 e1000_write_phy_reg(&adapter
->hw
, 29, 0x001F);
1047 e1000_write_phy_reg(&adapter
->hw
, 30, 0x8FFC);
1048 e1000_write_phy_reg(&adapter
->hw
, 29, 0x001A);
1049 e1000_write_phy_reg(&adapter
->hw
, 30, 0x8FF0);
1053 e1000_phy_reset_clk_and_crs(struct e1000_adapter
*adapter
)
1057 /* Because we reset the PHY above, we need to re-force TX_CLK in the
1058 * Extended PHY Specific Control Register to 25MHz clock. This
1059 * value defaults back to a 2.5MHz clock when the PHY is reset.
1061 e1000_read_phy_reg(&adapter
->hw
, M88E1000_EXT_PHY_SPEC_CTRL
, &phy_reg
);
1062 phy_reg
|= M88E1000_EPSCR_TX_CLK_25
;
1063 e1000_write_phy_reg(&adapter
->hw
,
1064 M88E1000_EXT_PHY_SPEC_CTRL
, phy_reg
);
1066 /* In addition, because of the s/w reset above, we need to enable
1067 * CRS on TX. This must be set for both full and half duplex
1070 e1000_read_phy_reg(&adapter
->hw
, M88E1000_PHY_SPEC_CTRL
, &phy_reg
);
1071 phy_reg
|= M88E1000_PSCR_ASSERT_CRS_ON_TX
;
1072 e1000_write_phy_reg(&adapter
->hw
,
1073 M88E1000_PHY_SPEC_CTRL
, phy_reg
);
1077 e1000_nonintegrated_phy_loopback(struct e1000_adapter
*adapter
)
1082 /* Setup the Device Control Register for PHY loopback test. */
1084 ctrl_reg
= E1000_READ_REG(&adapter
->hw
, CTRL
);
1085 ctrl_reg
|= (E1000_CTRL_ILOS
| /* Invert Loss-Of-Signal */
1086 E1000_CTRL_FRCSPD
| /* Set the Force Speed Bit */
1087 E1000_CTRL_FRCDPX
| /* Set the Force Duplex Bit */
1088 E1000_CTRL_SPD_1000
| /* Force Speed to 1000 */
1089 E1000_CTRL_FD
); /* Force Duplex to FULL */
1091 E1000_WRITE_REG(&adapter
->hw
, CTRL
, ctrl_reg
);
1093 /* Read the PHY Specific Control Register (0x10) */
1094 e1000_read_phy_reg(&adapter
->hw
, M88E1000_PHY_SPEC_CTRL
, &phy_reg
);
1096 /* Clear Auto-Crossover bits in PHY Specific Control Register
1099 phy_reg
&= ~M88E1000_PSCR_AUTO_X_MODE
;
1100 e1000_write_phy_reg(&adapter
->hw
, M88E1000_PHY_SPEC_CTRL
, phy_reg
);
1102 /* Perform software reset on the PHY */
1103 e1000_phy_reset(&adapter
->hw
);
1105 /* Have to setup TX_CLK and TX_CRS after software reset */
1106 e1000_phy_reset_clk_and_crs(adapter
);
1108 e1000_write_phy_reg(&adapter
->hw
, PHY_CTRL
, 0x8100);
1110 /* Wait for reset to complete. */
1113 /* Have to setup TX_CLK and TX_CRS after software reset */
1114 e1000_phy_reset_clk_and_crs(adapter
);
1116 /* Write out to PHY registers 29 and 30 to disable the Receiver. */
1117 e1000_phy_disable_receiver(adapter
);
1119 /* Set the loopback bit in the PHY control register. */
1120 e1000_read_phy_reg(&adapter
->hw
, PHY_CTRL
, &phy_reg
);
1121 phy_reg
|= MII_CR_LOOPBACK
;
1122 e1000_write_phy_reg(&adapter
->hw
, PHY_CTRL
, phy_reg
);
1124 /* Setup TX_CLK and TX_CRS one more time. */
1125 e1000_phy_reset_clk_and_crs(adapter
);
1127 /* Check Phy Configuration */
1128 e1000_read_phy_reg(&adapter
->hw
, PHY_CTRL
, &phy_reg
);
1129 if(phy_reg
!= 0x4100)
1132 e1000_read_phy_reg(&adapter
->hw
, M88E1000_EXT_PHY_SPEC_CTRL
, &phy_reg
);
1133 if(phy_reg
!= 0x0070)
1136 e1000_read_phy_reg(&adapter
->hw
, 29, &phy_reg
);
1137 if(phy_reg
!= 0x001A)
1144 e1000_integrated_phy_loopback(struct e1000_adapter
*adapter
)
1146 uint32_t ctrl_reg
= 0;
1147 uint32_t stat_reg
= 0;
1149 adapter
->hw
.autoneg
= FALSE
;
1151 if(adapter
->hw
.phy_type
== e1000_phy_m88
) {
1152 /* Auto-MDI/MDIX Off */
1153 e1000_write_phy_reg(&adapter
->hw
,
1154 M88E1000_PHY_SPEC_CTRL
, 0x0808);
1155 /* reset to update Auto-MDI/MDIX */
1156 e1000_write_phy_reg(&adapter
->hw
, PHY_CTRL
, 0x9140);
1158 e1000_write_phy_reg(&adapter
->hw
, PHY_CTRL
, 0x8140);
1160 /* force 1000, set loopback */
1161 e1000_write_phy_reg(&adapter
->hw
, PHY_CTRL
, 0x4140);
1163 /* Now set up the MAC to the same speed/duplex as the PHY. */
1164 ctrl_reg
= E1000_READ_REG(&adapter
->hw
, CTRL
);
1165 ctrl_reg
&= ~E1000_CTRL_SPD_SEL
; /* Clear the speed sel bits */
1166 ctrl_reg
|= (E1000_CTRL_FRCSPD
| /* Set the Force Speed Bit */
1167 E1000_CTRL_FRCDPX
| /* Set the Force Duplex Bit */
1168 E1000_CTRL_SPD_1000
|/* Force Speed to 1000 */
1169 E1000_CTRL_FD
); /* Force Duplex to FULL */
1171 if(adapter
->hw
.media_type
== e1000_media_type_copper
&&
1172 adapter
->hw
.phy_type
== e1000_phy_m88
) {
1173 ctrl_reg
|= E1000_CTRL_ILOS
; /* Invert Loss of Signal */
1175 /* Set the ILOS bit on the fiber Nic is half
1176 * duplex link is detected. */
1177 stat_reg
= E1000_READ_REG(&adapter
->hw
, STATUS
);
1178 if((stat_reg
& E1000_STATUS_FD
) == 0)
1179 ctrl_reg
|= (E1000_CTRL_ILOS
| E1000_CTRL_SLU
);
1182 E1000_WRITE_REG(&adapter
->hw
, CTRL
, ctrl_reg
);
1184 /* Disable the receiver on the PHY so when a cable is plugged in, the
1185 * PHY does not begin to autoneg when a cable is reconnected to the NIC.
1187 if(adapter
->hw
.phy_type
== e1000_phy_m88
)
1188 e1000_phy_disable_receiver(adapter
);
1196 e1000_set_phy_loopback(struct e1000_adapter
*adapter
)
1198 uint16_t phy_reg
= 0;
1201 switch (adapter
->hw
.mac_type
) {
1203 if(adapter
->hw
.media_type
== e1000_media_type_copper
) {
1204 /* Attempt to setup Loopback mode on Non-integrated PHY.
1205 * Some PHY registers get corrupted at random, so
1206 * attempt this 10 times.
1208 while(e1000_nonintegrated_phy_loopback(adapter
) &&
1218 case e1000_82545_rev_3
:
1220 case e1000_82546_rev_3
:
1222 case e1000_82541_rev_2
:
1224 case e1000_82547_rev_2
:
1225 return e1000_integrated_phy_loopback(adapter
);
1229 /* Default PHY loopback work is to read the MII
1230 * control register and assert bit 14 (loopback mode).
1232 e1000_read_phy_reg(&adapter
->hw
, PHY_CTRL
, &phy_reg
);
1233 phy_reg
|= MII_CR_LOOPBACK
;
1234 e1000_write_phy_reg(&adapter
->hw
, PHY_CTRL
, phy_reg
);
1243 e1000_setup_loopback_test(struct e1000_adapter
*adapter
)
1247 if(adapter
->hw
.media_type
== e1000_media_type_fiber
||
1248 adapter
->hw
.media_type
== e1000_media_type_internal_serdes
) {
1249 if(adapter
->hw
.mac_type
== e1000_82545
||
1250 adapter
->hw
.mac_type
== e1000_82546
||
1251 adapter
->hw
.mac_type
== e1000_82545_rev_3
||
1252 adapter
->hw
.mac_type
== e1000_82546_rev_3
)
1253 return e1000_set_phy_loopback(adapter
);
1255 rctl
= E1000_READ_REG(&adapter
->hw
, RCTL
);
1256 rctl
|= E1000_RCTL_LBM_TCVR
;
1257 E1000_WRITE_REG(&adapter
->hw
, RCTL
, rctl
);
1260 } else if(adapter
->hw
.media_type
== e1000_media_type_copper
)
1261 return e1000_set_phy_loopback(adapter
);
1267 e1000_loopback_cleanup(struct e1000_adapter
*adapter
)
1272 rctl
= E1000_READ_REG(&adapter
->hw
, RCTL
);
1273 rctl
&= ~(E1000_RCTL_LBM_TCVR
| E1000_RCTL_LBM_MAC
);
1274 E1000_WRITE_REG(&adapter
->hw
, RCTL
, rctl
);
1276 if(adapter
->hw
.media_type
== e1000_media_type_copper
||
1277 ((adapter
->hw
.media_type
== e1000_media_type_fiber
||
1278 adapter
->hw
.media_type
== e1000_media_type_internal_serdes
) &&
1279 (adapter
->hw
.mac_type
== e1000_82545
||
1280 adapter
->hw
.mac_type
== e1000_82546
||
1281 adapter
->hw
.mac_type
== e1000_82545_rev_3
||
1282 adapter
->hw
.mac_type
== e1000_82546_rev_3
))) {
1283 adapter
->hw
.autoneg
= TRUE
;
1284 e1000_read_phy_reg(&adapter
->hw
, PHY_CTRL
, &phy_reg
);
1285 if(phy_reg
& MII_CR_LOOPBACK
) {
1286 phy_reg
&= ~MII_CR_LOOPBACK
;
1287 e1000_write_phy_reg(&adapter
->hw
, PHY_CTRL
, phy_reg
);
1288 e1000_phy_reset(&adapter
->hw
);
1294 e1000_create_lbtest_frame(struct sk_buff
*skb
, unsigned int frame_size
)
1296 memset(skb
->data
, 0xFF, frame_size
);
1297 frame_size
= (frame_size
% 2) ? (frame_size
- 1) : frame_size
;
1298 memset(&skb
->data
[frame_size
/ 2], 0xAA, frame_size
/ 2 - 1);
1299 memset(&skb
->data
[frame_size
/ 2 + 10], 0xBE, 1);
1300 memset(&skb
->data
[frame_size
/ 2 + 12], 0xAF, 1);
1304 e1000_check_lbtest_frame(struct sk_buff
*skb
, unsigned int frame_size
)
1306 frame_size
= (frame_size
% 2) ? (frame_size
- 1) : frame_size
;
1307 if(*(skb
->data
+ 3) == 0xFF) {
1308 if((*(skb
->data
+ frame_size
/ 2 + 10) == 0xBE) &&
1309 (*(skb
->data
+ frame_size
/ 2 + 12) == 0xAF)) {
1317 e1000_run_loopback_test(struct e1000_adapter
*adapter
)
1319 struct e1000_desc_ring
*txdr
= &adapter
->test_tx_ring
;
1320 struct e1000_desc_ring
*rxdr
= &adapter
->test_rx_ring
;
1321 struct pci_dev
*pdev
= adapter
->pdev
;
1324 E1000_WRITE_REG(&adapter
->hw
, RDT
, rxdr
->count
- 1);
1326 for(i
= 0; i
< 64; i
++) {
1327 e1000_create_lbtest_frame(txdr
->buffer_info
[i
].skb
, 1024);
1328 pci_dma_sync_single_for_device(pdev
, txdr
->buffer_info
[i
].dma
,
1329 txdr
->buffer_info
[i
].length
,
1332 E1000_WRITE_REG(&adapter
->hw
, TDT
, i
);
1336 pci_dma_sync_single_for_cpu(pdev
, rxdr
->buffer_info
[0].dma
,
1337 rxdr
->buffer_info
[0].length
, PCI_DMA_FROMDEVICE
);
1339 return e1000_check_lbtest_frame(rxdr
->buffer_info
[0].skb
, 1024);
1343 e1000_loopback_test(struct e1000_adapter
*adapter
, uint64_t *data
)
1345 if((*data
= e1000_setup_desc_rings(adapter
))) goto err_loopback
;
1346 if((*data
= e1000_setup_loopback_test(adapter
))) goto err_loopback
;
1347 *data
= e1000_run_loopback_test(adapter
);
1348 e1000_loopback_cleanup(adapter
);
1349 e1000_free_desc_rings(adapter
);
1355 e1000_link_test(struct e1000_adapter
*adapter
, uint64_t *data
)
1358 e1000_check_for_link(&adapter
->hw
);
1360 if(!(E1000_READ_REG(&adapter
->hw
, STATUS
) & E1000_STATUS_LU
)) {
1367 e1000_diag_test_count(struct net_device
*netdev
)
1369 return E1000_TEST_LEN
;
1373 e1000_diag_test(struct net_device
*netdev
,
1374 struct ethtool_test
*eth_test
, uint64_t *data
)
1376 struct e1000_adapter
*adapter
= netdev
->priv
;
1377 boolean_t if_running
= netif_running(netdev
);
1379 if(eth_test
->flags
== ETH_TEST_FL_OFFLINE
) {
1382 /* save speed, duplex, autoneg settings */
1383 uint16_t autoneg_advertised
= adapter
->hw
.autoneg_advertised
;
1384 uint8_t forced_speed_duplex
= adapter
->hw
.forced_speed_duplex
;
1385 uint8_t autoneg
= adapter
->hw
.autoneg
;
1387 /* Link test performed before hardware reset so autoneg doesn't
1388 * interfere with test result */
1389 if(e1000_link_test(adapter
, &data
[4]))
1390 eth_test
->flags
|= ETH_TEST_FL_FAILED
;
1393 e1000_down(adapter
);
1395 e1000_reset(adapter
);
1397 if(e1000_reg_test(adapter
, &data
[0]))
1398 eth_test
->flags
|= ETH_TEST_FL_FAILED
;
1400 e1000_reset(adapter
);
1401 if(e1000_eeprom_test(adapter
, &data
[1]))
1402 eth_test
->flags
|= ETH_TEST_FL_FAILED
;
1404 e1000_reset(adapter
);
1405 if(e1000_intr_test(adapter
, &data
[2]))
1406 eth_test
->flags
|= ETH_TEST_FL_FAILED
;
1408 e1000_reset(adapter
);
1409 if(e1000_loopback_test(adapter
, &data
[3]))
1410 eth_test
->flags
|= ETH_TEST_FL_FAILED
;
1412 /* restore speed, duplex, autoneg settings */
1413 adapter
->hw
.autoneg_advertised
= autoneg_advertised
;
1414 adapter
->hw
.forced_speed_duplex
= forced_speed_duplex
;
1415 adapter
->hw
.autoneg
= autoneg
;
1417 e1000_reset(adapter
);
1422 if(e1000_link_test(adapter
, &data
[4]))
1423 eth_test
->flags
|= ETH_TEST_FL_FAILED
;
1425 /* Offline tests aren't run; pass by default */
1434 e1000_get_wol(struct net_device
*netdev
, struct ethtool_wolinfo
*wol
)
1436 struct e1000_adapter
*adapter
= netdev
->priv
;
1437 struct e1000_hw
*hw
= &adapter
->hw
;
1439 switch(adapter
->hw
.device_id
) {
1440 case E1000_DEV_ID_82542
:
1441 case E1000_DEV_ID_82543GC_FIBER
:
1442 case E1000_DEV_ID_82543GC_COPPER
:
1443 case E1000_DEV_ID_82544EI_FIBER
:
1444 case E1000_DEV_ID_82546EB_QUAD_COPPER
:
1449 case E1000_DEV_ID_82546EB_FIBER
:
1450 case E1000_DEV_ID_82546GB_FIBER
:
1451 /* Wake events only supported on port A for dual fiber */
1452 if(E1000_READ_REG(hw
, STATUS
) & E1000_STATUS_FUNC_1
) {
1460 wol
->supported
= WAKE_UCAST
| WAKE_MCAST
|
1461 WAKE_BCAST
| WAKE_MAGIC
;
1464 if(adapter
->wol
& E1000_WUFC_EX
)
1465 wol
->wolopts
|= WAKE_UCAST
;
1466 if(adapter
->wol
& E1000_WUFC_MC
)
1467 wol
->wolopts
|= WAKE_MCAST
;
1468 if(adapter
->wol
& E1000_WUFC_BC
)
1469 wol
->wolopts
|= WAKE_BCAST
;
1470 if(adapter
->wol
& E1000_WUFC_MAG
)
1471 wol
->wolopts
|= WAKE_MAGIC
;
1477 e1000_set_wol(struct net_device
*netdev
, struct ethtool_wolinfo
*wol
)
1479 struct e1000_adapter
*adapter
= netdev
->priv
;
1480 struct e1000_hw
*hw
= &adapter
->hw
;
1482 switch(adapter
->hw
.device_id
) {
1483 case E1000_DEV_ID_82542
:
1484 case E1000_DEV_ID_82543GC_FIBER
:
1485 case E1000_DEV_ID_82543GC_COPPER
:
1486 case E1000_DEV_ID_82544EI_FIBER
:
1487 case E1000_DEV_ID_82546EB_QUAD_COPPER
:
1488 return wol
->wolopts
? -EOPNOTSUPP
: 0;
1490 case E1000_DEV_ID_82546EB_FIBER
:
1491 case E1000_DEV_ID_82546GB_FIBER
:
1492 /* Wake events only supported on port A for dual fiber */
1493 if(E1000_READ_REG(hw
, STATUS
) & E1000_STATUS_FUNC_1
)
1494 return wol
->wolopts
? -EOPNOTSUPP
: 0;
1498 if(wol
->wolopts
& (WAKE_PHY
| WAKE_ARP
| WAKE_MAGICSECURE
))
1503 if(wol
->wolopts
& WAKE_UCAST
)
1504 adapter
->wol
|= E1000_WUFC_EX
;
1505 if(wol
->wolopts
& WAKE_MCAST
)
1506 adapter
->wol
|= E1000_WUFC_MC
;
1507 if(wol
->wolopts
& WAKE_BCAST
)
1508 adapter
->wol
|= E1000_WUFC_BC
;
1509 if(wol
->wolopts
& WAKE_MAGIC
)
1510 adapter
->wol
|= E1000_WUFC_MAG
;
1516 /* toggle LED 4 times per second = 2 "blinks" per second */
1517 #define E1000_ID_INTERVAL (HZ/4)
1519 /* bit defines for adapter->led_status */
1520 #define E1000_LED_ON 0
1523 e1000_led_blink_callback(unsigned long data
)
1525 struct e1000_adapter
*adapter
= (struct e1000_adapter
*) data
;
1527 if(test_and_change_bit(E1000_LED_ON
, &adapter
->led_status
))
1528 e1000_led_off(&adapter
->hw
);
1530 e1000_led_on(&adapter
->hw
);
1532 mod_timer(&adapter
->blink_timer
, jiffies
+ E1000_ID_INTERVAL
);
1536 e1000_phys_id(struct net_device
*netdev
, uint32_t data
)
1538 struct e1000_adapter
*adapter
= netdev
->priv
;
1540 if(!data
|| data
> (uint32_t)(MAX_SCHEDULE_TIMEOUT
/ HZ
))
1541 data
= (uint32_t)(MAX_SCHEDULE_TIMEOUT
/ HZ
);
1543 if(!adapter
->blink_timer
.function
) {
1544 init_timer(&adapter
->blink_timer
);
1545 adapter
->blink_timer
.function
= e1000_led_blink_callback
;
1546 adapter
->blink_timer
.data
= (unsigned long) adapter
;
1549 e1000_setup_led(&adapter
->hw
);
1550 mod_timer(&adapter
->blink_timer
, jiffies
);
1552 set_current_state(TASK_INTERRUPTIBLE
);
1554 schedule_timeout(data
* HZ
);
1555 del_timer_sync(&adapter
->blink_timer
);
1556 e1000_led_off(&adapter
->hw
);
1557 clear_bit(E1000_LED_ON
, &adapter
->led_status
);
1558 e1000_cleanup_led(&adapter
->hw
);
1564 e1000_nway_reset(struct net_device
*netdev
)
1566 struct e1000_adapter
*adapter
= netdev
->priv
;
1567 if(netif_running(netdev
)) {
1568 e1000_down(adapter
);
1575 e1000_get_stats_count(struct net_device
*netdev
)
1577 return E1000_STATS_LEN
;
1581 e1000_get_ethtool_stats(struct net_device
*netdev
,
1582 struct ethtool_stats
*stats
, uint64_t *data
)
1584 struct e1000_adapter
*adapter
= netdev
->priv
;
1587 e1000_update_stats(adapter
);
1588 for(i
= 0; i
< E1000_STATS_LEN
; i
++) {
1589 char *p
= (char *)adapter
+e1000_gstrings_stats
[i
].stat_offset
;
1590 data
[i
] = (e1000_gstrings_stats
[i
].sizeof_stat
==
1591 sizeof(uint64_t)) ? *(uint64_t *)p
: *(uint32_t *)p
;
1596 e1000_get_strings(struct net_device
*netdev
, uint32_t stringset
, uint8_t *data
)
1602 memcpy(data
, *e1000_gstrings_test
,
1603 E1000_TEST_LEN
*ETH_GSTRING_LEN
);
1606 for (i
=0; i
< E1000_STATS_LEN
; i
++) {
1607 memcpy(data
+ i
* ETH_GSTRING_LEN
,
1608 e1000_gstrings_stats
[i
].stat_string
,
1615 struct ethtool_ops e1000_ethtool_ops
= {
1616 .get_settings
= e1000_get_settings
,
1617 .set_settings
= e1000_set_settings
,
1618 .get_drvinfo
= e1000_get_drvinfo
,
1619 .get_regs_len
= e1000_get_regs_len
,
1620 .get_regs
= e1000_get_regs
,
1621 .get_wol
= e1000_get_wol
,
1622 .set_wol
= e1000_set_wol
,
1623 .get_msglevel
= e1000_get_msglevel
,
1624 .set_msglevel
= e1000_set_msglevel
,
1625 .nway_reset
= e1000_nway_reset
,
1626 .get_link
= ethtool_op_get_link
,
1627 .get_eeprom_len
= e1000_get_eeprom_len
,
1628 .get_eeprom
= e1000_get_eeprom
,
1629 .set_eeprom
= e1000_set_eeprom
,
1630 .get_ringparam
= e1000_get_ringparam
,
1631 .set_ringparam
= e1000_set_ringparam
,
1632 .get_pauseparam
= e1000_get_pauseparam
,
1633 .set_pauseparam
= e1000_set_pauseparam
,
1634 .get_rx_csum
= e1000_get_rx_csum
,
1635 .set_rx_csum
= e1000_set_rx_csum
,
1636 .get_tx_csum
= e1000_get_tx_csum
,
1637 .set_tx_csum
= e1000_set_tx_csum
,
1638 .get_sg
= ethtool_op_get_sg
,
1639 .set_sg
= ethtool_op_set_sg
,
1641 .get_tso
= ethtool_op_get_tso
,
1642 .set_tso
= e1000_set_tso
,
1644 .self_test_count
= e1000_diag_test_count
,
1645 .self_test
= e1000_diag_test
,
1646 .get_strings
= e1000_get_strings
,
1647 .phys_id
= e1000_phys_id
,
1648 .get_stats_count
= e1000_get_stats_count
,
1649 .get_ethtool_stats
= e1000_get_ethtool_stats
,
1652 void set_ethtool_ops(struct net_device
*netdev
)
1654 SET_ETHTOOL_OPS(netdev
, &e1000_ethtool_ops
);