1 /*******************************************************************************
3 Intel 10 Gigabit PCI Express Linux driver
4 Copyright(c) 1999 - 2016 Intel Corporation.
6 This program is free software; you can redistribute it and/or modify it
7 under the terms and conditions of the GNU General Public License,
8 version 2, as published by the Free Software Foundation.
10 This program is distributed in the hope it will be useful, but WITHOUT
11 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 You should have received a copy of the GNU General Public License along with
16 this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
19 The full GNU General Public License is included in this distribution in
20 the file called "COPYING".
23 Linux NICS <linux.nics@intel.com>
24 e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
25 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27 *******************************************************************************/
29 /* ethtool support for ixgbe */
31 #include <linux/interrupt.h>
32 #include <linux/types.h>
33 #include <linux/module.h>
34 #include <linux/slab.h>
35 #include <linux/pci.h>
36 #include <linux/netdevice.h>
37 #include <linux/ethtool.h>
38 #include <linux/vmalloc.h>
39 #include <linux/highmem.h>
40 #include <linux/uaccess.h>
43 #include "ixgbe_phy.h"
46 #define IXGBE_ALL_RAR_ENTRIES 16
48 enum {NETDEV_STATS
, IXGBE_STATS
};
51 char stat_string
[ETH_GSTRING_LEN
];
57 #define IXGBE_STAT(m) IXGBE_STATS, \
58 sizeof(((struct ixgbe_adapter *)0)->m), \
59 offsetof(struct ixgbe_adapter, m)
60 #define IXGBE_NETDEV_STAT(m) NETDEV_STATS, \
61 sizeof(((struct rtnl_link_stats64 *)0)->m), \
62 offsetof(struct rtnl_link_stats64, m)
64 static const struct ixgbe_stats ixgbe_gstrings_stats
[] = {
65 {"rx_packets", IXGBE_NETDEV_STAT(rx_packets
)},
66 {"tx_packets", IXGBE_NETDEV_STAT(tx_packets
)},
67 {"rx_bytes", IXGBE_NETDEV_STAT(rx_bytes
)},
68 {"tx_bytes", IXGBE_NETDEV_STAT(tx_bytes
)},
69 {"rx_pkts_nic", IXGBE_STAT(stats
.gprc
)},
70 {"tx_pkts_nic", IXGBE_STAT(stats
.gptc
)},
71 {"rx_bytes_nic", IXGBE_STAT(stats
.gorc
)},
72 {"tx_bytes_nic", IXGBE_STAT(stats
.gotc
)},
73 {"lsc_int", IXGBE_STAT(lsc_int
)},
74 {"tx_busy", IXGBE_STAT(tx_busy
)},
75 {"non_eop_descs", IXGBE_STAT(non_eop_descs
)},
76 {"rx_errors", IXGBE_NETDEV_STAT(rx_errors
)},
77 {"tx_errors", IXGBE_NETDEV_STAT(tx_errors
)},
78 {"rx_dropped", IXGBE_NETDEV_STAT(rx_dropped
)},
79 {"tx_dropped", IXGBE_NETDEV_STAT(tx_dropped
)},
80 {"multicast", IXGBE_NETDEV_STAT(multicast
)},
81 {"broadcast", IXGBE_STAT(stats
.bprc
)},
82 {"rx_no_buffer_count", IXGBE_STAT(stats
.rnbc
[0]) },
83 {"collisions", IXGBE_NETDEV_STAT(collisions
)},
84 {"rx_over_errors", IXGBE_NETDEV_STAT(rx_over_errors
)},
85 {"rx_crc_errors", IXGBE_NETDEV_STAT(rx_crc_errors
)},
86 {"rx_frame_errors", IXGBE_NETDEV_STAT(rx_frame_errors
)},
87 {"hw_rsc_aggregated", IXGBE_STAT(rsc_total_count
)},
88 {"hw_rsc_flushed", IXGBE_STAT(rsc_total_flush
)},
89 {"fdir_match", IXGBE_STAT(stats
.fdirmatch
)},
90 {"fdir_miss", IXGBE_STAT(stats
.fdirmiss
)},
91 {"fdir_overflow", IXGBE_STAT(fdir_overflow
)},
92 {"rx_fifo_errors", IXGBE_NETDEV_STAT(rx_fifo_errors
)},
93 {"rx_missed_errors", IXGBE_NETDEV_STAT(rx_missed_errors
)},
94 {"tx_aborted_errors", IXGBE_NETDEV_STAT(tx_aborted_errors
)},
95 {"tx_carrier_errors", IXGBE_NETDEV_STAT(tx_carrier_errors
)},
96 {"tx_fifo_errors", IXGBE_NETDEV_STAT(tx_fifo_errors
)},
97 {"tx_heartbeat_errors", IXGBE_NETDEV_STAT(tx_heartbeat_errors
)},
98 {"tx_timeout_count", IXGBE_STAT(tx_timeout_count
)},
99 {"tx_restart_queue", IXGBE_STAT(restart_queue
)},
100 {"rx_long_length_errors", IXGBE_STAT(stats
.roc
)},
101 {"rx_short_length_errors", IXGBE_STAT(stats
.ruc
)},
102 {"tx_flow_control_xon", IXGBE_STAT(stats
.lxontxc
)},
103 {"rx_flow_control_xon", IXGBE_STAT(stats
.lxonrxc
)},
104 {"tx_flow_control_xoff", IXGBE_STAT(stats
.lxofftxc
)},
105 {"rx_flow_control_xoff", IXGBE_STAT(stats
.lxoffrxc
)},
106 {"rx_csum_offload_errors", IXGBE_STAT(hw_csum_rx_error
)},
107 {"alloc_rx_page_failed", IXGBE_STAT(alloc_rx_page_failed
)},
108 {"alloc_rx_buff_failed", IXGBE_STAT(alloc_rx_buff_failed
)},
109 {"rx_no_dma_resources", IXGBE_STAT(hw_rx_no_dma_resources
)},
110 {"os2bmc_rx_by_bmc", IXGBE_STAT(stats
.o2bgptc
)},
111 {"os2bmc_tx_by_bmc", IXGBE_STAT(stats
.b2ospc
)},
112 {"os2bmc_tx_by_host", IXGBE_STAT(stats
.o2bspc
)},
113 {"os2bmc_rx_by_host", IXGBE_STAT(stats
.b2ogprc
)},
115 {"fcoe_bad_fccrc", IXGBE_STAT(stats
.fccrc
)},
116 {"rx_fcoe_dropped", IXGBE_STAT(stats
.fcoerpdc
)},
117 {"rx_fcoe_packets", IXGBE_STAT(stats
.fcoeprc
)},
118 {"rx_fcoe_dwords", IXGBE_STAT(stats
.fcoedwrc
)},
119 {"fcoe_noddp", IXGBE_STAT(stats
.fcoe_noddp
)},
120 {"fcoe_noddp_ext_buff", IXGBE_STAT(stats
.fcoe_noddp_ext_buff
)},
121 {"tx_fcoe_packets", IXGBE_STAT(stats
.fcoeptc
)},
122 {"tx_fcoe_dwords", IXGBE_STAT(stats
.fcoedwtc
)},
123 #endif /* IXGBE_FCOE */
126 /* ixgbe allocates num_tx_queues and num_rx_queues symmetrically so
127 * we set the num_rx_queues to evaluate to num_tx_queues. This is
128 * used because we do not have a good way to get the max number of
129 * rx queues with CONFIG_RPS disabled.
131 #define IXGBE_NUM_RX_QUEUES netdev->num_tx_queues
133 #define IXGBE_QUEUE_STATS_LEN ( \
134 (netdev->num_tx_queues + IXGBE_NUM_RX_QUEUES) * \
135 (sizeof(struct ixgbe_queue_stats) / sizeof(u64)))
136 #define IXGBE_GLOBAL_STATS_LEN ARRAY_SIZE(ixgbe_gstrings_stats)
137 #define IXGBE_PB_STATS_LEN ( \
138 (sizeof(((struct ixgbe_adapter *)0)->stats.pxonrxc) + \
139 sizeof(((struct ixgbe_adapter *)0)->stats.pxontxc) + \
140 sizeof(((struct ixgbe_adapter *)0)->stats.pxoffrxc) + \
141 sizeof(((struct ixgbe_adapter *)0)->stats.pxofftxc)) \
143 #define IXGBE_STATS_LEN (IXGBE_GLOBAL_STATS_LEN + \
144 IXGBE_PB_STATS_LEN + \
145 IXGBE_QUEUE_STATS_LEN)
147 static const char ixgbe_gstrings_test
[][ETH_GSTRING_LEN
] = {
148 "Register test (offline)", "Eeprom test (offline)",
149 "Interrupt test (offline)", "Loopback test (offline)",
150 "Link test (on/offline)"
152 #define IXGBE_TEST_LEN sizeof(ixgbe_gstrings_test) / ETH_GSTRING_LEN
154 static const char ixgbe_priv_flags_strings
[][ETH_GSTRING_LEN
] = {
155 #define IXGBE_PRIV_FLAGS_LEGACY_RX BIT(0)
159 #define IXGBE_PRIV_FLAGS_STR_LEN ARRAY_SIZE(ixgbe_priv_flags_strings)
161 /* currently supported speeds for 10G */
162 #define ADVRTSD_MSK_10G (SUPPORTED_10000baseT_Full | \
163 SUPPORTED_10000baseKX4_Full | \
164 SUPPORTED_10000baseKR_Full)
166 #define ixgbe_isbackplane(type) ((type) == ixgbe_media_type_backplane)
168 static u32
ixgbe_get_supported_10gtypes(struct ixgbe_hw
*hw
)
170 if (!ixgbe_isbackplane(hw
->phy
.media_type
))
171 return SUPPORTED_10000baseT_Full
;
173 switch (hw
->device_id
) {
174 case IXGBE_DEV_ID_82598
:
175 case IXGBE_DEV_ID_82599_KX4
:
176 case IXGBE_DEV_ID_82599_KX4_MEZZ
:
177 case IXGBE_DEV_ID_X550EM_X_KX4
:
178 return SUPPORTED_10000baseKX4_Full
;
179 case IXGBE_DEV_ID_82598_BX
:
180 case IXGBE_DEV_ID_82599_KR
:
181 case IXGBE_DEV_ID_X550EM_X_KR
:
182 return SUPPORTED_10000baseKR_Full
;
184 return SUPPORTED_10000baseKX4_Full
|
185 SUPPORTED_10000baseKR_Full
;
189 static int ixgbe_get_settings(struct net_device
*netdev
,
190 struct ethtool_cmd
*ecmd
)
192 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
193 struct ixgbe_hw
*hw
= &adapter
->hw
;
194 ixgbe_link_speed supported_link
;
195 bool autoneg
= false;
197 hw
->mac
.ops
.get_link_capabilities(hw
, &supported_link
, &autoneg
);
199 /* set the supported link speeds */
200 if (supported_link
& IXGBE_LINK_SPEED_10GB_FULL
)
201 ecmd
->supported
|= ixgbe_get_supported_10gtypes(hw
);
202 if (supported_link
& IXGBE_LINK_SPEED_1GB_FULL
)
203 ecmd
->supported
|= (ixgbe_isbackplane(hw
->phy
.media_type
)) ?
204 SUPPORTED_1000baseKX_Full
:
205 SUPPORTED_1000baseT_Full
;
206 if (supported_link
& IXGBE_LINK_SPEED_100_FULL
)
207 ecmd
->supported
|= SUPPORTED_100baseT_Full
;
208 if (supported_link
& IXGBE_LINK_SPEED_10_FULL
)
209 ecmd
->supported
|= SUPPORTED_10baseT_Full
;
211 /* default advertised speed if phy.autoneg_advertised isn't set */
212 ecmd
->advertising
= ecmd
->supported
;
213 /* set the advertised speeds */
214 if (hw
->phy
.autoneg_advertised
) {
215 ecmd
->advertising
= 0;
216 if (hw
->phy
.autoneg_advertised
& IXGBE_LINK_SPEED_10_FULL
)
217 ecmd
->advertising
|= ADVERTISED_10baseT_Full
;
218 if (hw
->phy
.autoneg_advertised
& IXGBE_LINK_SPEED_100_FULL
)
219 ecmd
->advertising
|= ADVERTISED_100baseT_Full
;
220 if (hw
->phy
.autoneg_advertised
& IXGBE_LINK_SPEED_10GB_FULL
)
221 ecmd
->advertising
|= ecmd
->supported
& ADVRTSD_MSK_10G
;
222 if (hw
->phy
.autoneg_advertised
& IXGBE_LINK_SPEED_1GB_FULL
) {
223 if (ecmd
->supported
& SUPPORTED_1000baseKX_Full
)
224 ecmd
->advertising
|= ADVERTISED_1000baseKX_Full
;
226 ecmd
->advertising
|= ADVERTISED_1000baseT_Full
;
229 if (hw
->phy
.multispeed_fiber
&& !autoneg
) {
230 if (supported_link
& IXGBE_LINK_SPEED_10GB_FULL
)
231 ecmd
->advertising
= ADVERTISED_10000baseT_Full
;
236 ecmd
->supported
|= SUPPORTED_Autoneg
;
237 ecmd
->advertising
|= ADVERTISED_Autoneg
;
238 ecmd
->autoneg
= AUTONEG_ENABLE
;
240 ecmd
->autoneg
= AUTONEG_DISABLE
;
242 ecmd
->transceiver
= XCVR_EXTERNAL
;
244 /* Determine the remaining settings based on the PHY type. */
245 switch (adapter
->hw
.phy
.type
) {
248 case ixgbe_phy_x550em_ext_t
:
250 case ixgbe_phy_cu_unknown
:
251 ecmd
->supported
|= SUPPORTED_TP
;
252 ecmd
->advertising
|= ADVERTISED_TP
;
253 ecmd
->port
= PORT_TP
;
256 ecmd
->supported
|= SUPPORTED_FIBRE
;
257 ecmd
->advertising
|= ADVERTISED_FIBRE
;
258 ecmd
->port
= PORT_FIBRE
;
261 case ixgbe_phy_sfp_passive_tyco
:
262 case ixgbe_phy_sfp_passive_unknown
:
263 case ixgbe_phy_sfp_ftl
:
264 case ixgbe_phy_sfp_avago
:
265 case ixgbe_phy_sfp_intel
:
266 case ixgbe_phy_sfp_unknown
:
267 case ixgbe_phy_qsfp_passive_unknown
:
268 case ixgbe_phy_qsfp_active_unknown
:
269 case ixgbe_phy_qsfp_intel
:
270 case ixgbe_phy_qsfp_unknown
:
271 /* SFP+ devices, further checking needed */
272 switch (adapter
->hw
.phy
.sfp_type
) {
273 case ixgbe_sfp_type_da_cu
:
274 case ixgbe_sfp_type_da_cu_core0
:
275 case ixgbe_sfp_type_da_cu_core1
:
276 ecmd
->supported
|= SUPPORTED_FIBRE
;
277 ecmd
->advertising
|= ADVERTISED_FIBRE
;
278 ecmd
->port
= PORT_DA
;
280 case ixgbe_sfp_type_sr
:
281 case ixgbe_sfp_type_lr
:
282 case ixgbe_sfp_type_srlr_core0
:
283 case ixgbe_sfp_type_srlr_core1
:
284 case ixgbe_sfp_type_1g_sx_core0
:
285 case ixgbe_sfp_type_1g_sx_core1
:
286 case ixgbe_sfp_type_1g_lx_core0
:
287 case ixgbe_sfp_type_1g_lx_core1
:
288 ecmd
->supported
|= SUPPORTED_FIBRE
;
289 ecmd
->advertising
|= ADVERTISED_FIBRE
;
290 ecmd
->port
= PORT_FIBRE
;
292 case ixgbe_sfp_type_not_present
:
293 ecmd
->supported
|= SUPPORTED_FIBRE
;
294 ecmd
->advertising
|= ADVERTISED_FIBRE
;
295 ecmd
->port
= PORT_NONE
;
297 case ixgbe_sfp_type_1g_cu_core0
:
298 case ixgbe_sfp_type_1g_cu_core1
:
299 ecmd
->supported
|= SUPPORTED_TP
;
300 ecmd
->advertising
|= ADVERTISED_TP
;
301 ecmd
->port
= PORT_TP
;
303 case ixgbe_sfp_type_unknown
:
305 ecmd
->supported
|= SUPPORTED_FIBRE
;
306 ecmd
->advertising
|= ADVERTISED_FIBRE
;
307 ecmd
->port
= PORT_OTHER
;
312 ecmd
->supported
|= SUPPORTED_FIBRE
;
313 ecmd
->advertising
|= ADVERTISED_FIBRE
;
314 ecmd
->port
= PORT_NONE
;
316 case ixgbe_phy_unknown
:
317 case ixgbe_phy_generic
:
318 case ixgbe_phy_sfp_unsupported
:
320 ecmd
->supported
|= SUPPORTED_FIBRE
;
321 ecmd
->advertising
|= ADVERTISED_FIBRE
;
322 ecmd
->port
= PORT_OTHER
;
326 /* Indicate pause support */
327 ecmd
->supported
|= SUPPORTED_Pause
;
329 switch (hw
->fc
.requested_mode
) {
331 ecmd
->advertising
|= ADVERTISED_Pause
;
333 case ixgbe_fc_rx_pause
:
334 ecmd
->advertising
|= ADVERTISED_Pause
|
335 ADVERTISED_Asym_Pause
;
337 case ixgbe_fc_tx_pause
:
338 ecmd
->advertising
|= ADVERTISED_Asym_Pause
;
341 ecmd
->advertising
&= ~(ADVERTISED_Pause
|
342 ADVERTISED_Asym_Pause
);
345 if (netif_carrier_ok(netdev
)) {
346 switch (adapter
->link_speed
) {
347 case IXGBE_LINK_SPEED_10GB_FULL
:
348 ethtool_cmd_speed_set(ecmd
, SPEED_10000
);
350 case IXGBE_LINK_SPEED_5GB_FULL
:
351 ethtool_cmd_speed_set(ecmd
, SPEED_5000
);
353 case IXGBE_LINK_SPEED_2_5GB_FULL
:
354 ethtool_cmd_speed_set(ecmd
, SPEED_2500
);
356 case IXGBE_LINK_SPEED_1GB_FULL
:
357 ethtool_cmd_speed_set(ecmd
, SPEED_1000
);
359 case IXGBE_LINK_SPEED_100_FULL
:
360 ethtool_cmd_speed_set(ecmd
, SPEED_100
);
362 case IXGBE_LINK_SPEED_10_FULL
:
363 ethtool_cmd_speed_set(ecmd
, SPEED_10
);
368 ecmd
->duplex
= DUPLEX_FULL
;
370 ethtool_cmd_speed_set(ecmd
, SPEED_UNKNOWN
);
371 ecmd
->duplex
= DUPLEX_UNKNOWN
;
377 static int ixgbe_set_settings(struct net_device
*netdev
,
378 struct ethtool_cmd
*ecmd
)
380 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
381 struct ixgbe_hw
*hw
= &adapter
->hw
;
385 if ((hw
->phy
.media_type
== ixgbe_media_type_copper
) ||
386 (hw
->phy
.multispeed_fiber
)) {
388 * this function does not support duplex forcing, but can
389 * limit the advertising of the adapter to the specified speed
391 if (ecmd
->advertising
& ~ecmd
->supported
)
394 /* only allow one speed at a time if no autoneg */
395 if (!ecmd
->autoneg
&& hw
->phy
.multispeed_fiber
) {
396 if (ecmd
->advertising
==
397 (ADVERTISED_10000baseT_Full
|
398 ADVERTISED_1000baseT_Full
))
402 old
= hw
->phy
.autoneg_advertised
;
404 if (ecmd
->advertising
& ADVERTISED_10000baseT_Full
)
405 advertised
|= IXGBE_LINK_SPEED_10GB_FULL
;
407 if (ecmd
->advertising
& ADVERTISED_1000baseT_Full
)
408 advertised
|= IXGBE_LINK_SPEED_1GB_FULL
;
410 if (ecmd
->advertising
& ADVERTISED_100baseT_Full
)
411 advertised
|= IXGBE_LINK_SPEED_100_FULL
;
413 if (ecmd
->advertising
& ADVERTISED_10baseT_Full
)
414 advertised
|= IXGBE_LINK_SPEED_10_FULL
;
416 if (old
== advertised
)
418 /* this sets the link speed and restarts auto-neg */
419 while (test_and_set_bit(__IXGBE_IN_SFP_INIT
, &adapter
->state
))
420 usleep_range(1000, 2000);
422 hw
->mac
.autotry_restart
= true;
423 err
= hw
->mac
.ops
.setup_link(hw
, advertised
, true);
425 e_info(probe
, "setup link failed with code %d\n", err
);
426 hw
->mac
.ops
.setup_link(hw
, old
, true);
428 clear_bit(__IXGBE_IN_SFP_INIT
, &adapter
->state
);
430 /* in this case we currently only support 10Gb/FULL */
431 u32 speed
= ethtool_cmd_speed(ecmd
);
432 if ((ecmd
->autoneg
== AUTONEG_ENABLE
) ||
433 (ecmd
->advertising
!= ADVERTISED_10000baseT_Full
) ||
434 (speed
+ ecmd
->duplex
!= SPEED_10000
+ DUPLEX_FULL
))
441 static void ixgbe_get_pauseparam(struct net_device
*netdev
,
442 struct ethtool_pauseparam
*pause
)
444 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
445 struct ixgbe_hw
*hw
= &adapter
->hw
;
447 if (ixgbe_device_supports_autoneg_fc(hw
) &&
448 !hw
->fc
.disable_fc_autoneg
)
453 if (hw
->fc
.current_mode
== ixgbe_fc_rx_pause
) {
455 } else if (hw
->fc
.current_mode
== ixgbe_fc_tx_pause
) {
457 } else if (hw
->fc
.current_mode
== ixgbe_fc_full
) {
463 static int ixgbe_set_pauseparam(struct net_device
*netdev
,
464 struct ethtool_pauseparam
*pause
)
466 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
467 struct ixgbe_hw
*hw
= &adapter
->hw
;
468 struct ixgbe_fc_info fc
= hw
->fc
;
470 /* 82598 does no support link flow control with DCB enabled */
471 if ((hw
->mac
.type
== ixgbe_mac_82598EB
) &&
472 (adapter
->flags
& IXGBE_FLAG_DCB_ENABLED
))
475 /* some devices do not support autoneg of link flow control */
476 if ((pause
->autoneg
== AUTONEG_ENABLE
) &&
477 !ixgbe_device_supports_autoneg_fc(hw
))
480 fc
.disable_fc_autoneg
= (pause
->autoneg
!= AUTONEG_ENABLE
);
482 if ((pause
->rx_pause
&& pause
->tx_pause
) || pause
->autoneg
)
483 fc
.requested_mode
= ixgbe_fc_full
;
484 else if (pause
->rx_pause
&& !pause
->tx_pause
)
485 fc
.requested_mode
= ixgbe_fc_rx_pause
;
486 else if (!pause
->rx_pause
&& pause
->tx_pause
)
487 fc
.requested_mode
= ixgbe_fc_tx_pause
;
489 fc
.requested_mode
= ixgbe_fc_none
;
491 /* if the thing changed then we'll update and use new autoneg */
492 if (memcmp(&fc
, &hw
->fc
, sizeof(struct ixgbe_fc_info
))) {
494 if (netif_running(netdev
))
495 ixgbe_reinit_locked(adapter
);
497 ixgbe_reset(adapter
);
503 static u32
ixgbe_get_msglevel(struct net_device
*netdev
)
505 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
506 return adapter
->msg_enable
;
509 static void ixgbe_set_msglevel(struct net_device
*netdev
, u32 data
)
511 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
512 adapter
->msg_enable
= data
;
515 static int ixgbe_get_regs_len(struct net_device
*netdev
)
517 #define IXGBE_REGS_LEN 1139
518 return IXGBE_REGS_LEN
* sizeof(u32
);
521 #define IXGBE_GET_STAT(_A_, _R_) _A_->stats._R_
523 static void ixgbe_get_regs(struct net_device
*netdev
,
524 struct ethtool_regs
*regs
, void *p
)
526 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
527 struct ixgbe_hw
*hw
= &adapter
->hw
;
531 memset(p
, 0, IXGBE_REGS_LEN
* sizeof(u32
));
533 regs
->version
= hw
->mac
.type
<< 24 | hw
->revision_id
<< 16 |
536 /* General Registers */
537 regs_buff
[0] = IXGBE_READ_REG(hw
, IXGBE_CTRL
);
538 regs_buff
[1] = IXGBE_READ_REG(hw
, IXGBE_STATUS
);
539 regs_buff
[2] = IXGBE_READ_REG(hw
, IXGBE_CTRL_EXT
);
540 regs_buff
[3] = IXGBE_READ_REG(hw
, IXGBE_ESDP
);
541 regs_buff
[4] = IXGBE_READ_REG(hw
, IXGBE_EODSDP
);
542 regs_buff
[5] = IXGBE_READ_REG(hw
, IXGBE_LEDCTL
);
543 regs_buff
[6] = IXGBE_READ_REG(hw
, IXGBE_FRTIMER
);
544 regs_buff
[7] = IXGBE_READ_REG(hw
, IXGBE_TCPTIMER
);
547 regs_buff
[8] = IXGBE_READ_REG(hw
, IXGBE_EEC(hw
));
548 regs_buff
[9] = IXGBE_READ_REG(hw
, IXGBE_EERD
);
549 regs_buff
[10] = IXGBE_READ_REG(hw
, IXGBE_FLA(hw
));
550 regs_buff
[11] = IXGBE_READ_REG(hw
, IXGBE_EEMNGCTL
);
551 regs_buff
[12] = IXGBE_READ_REG(hw
, IXGBE_EEMNGDATA
);
552 regs_buff
[13] = IXGBE_READ_REG(hw
, IXGBE_FLMNGCTL
);
553 regs_buff
[14] = IXGBE_READ_REG(hw
, IXGBE_FLMNGDATA
);
554 regs_buff
[15] = IXGBE_READ_REG(hw
, IXGBE_FLMNGCNT
);
555 regs_buff
[16] = IXGBE_READ_REG(hw
, IXGBE_FLOP
);
556 regs_buff
[17] = IXGBE_READ_REG(hw
, IXGBE_GRC(hw
));
559 /* don't read EICR because it can clear interrupt causes, instead
560 * read EICS which is a shadow but doesn't clear EICR */
561 regs_buff
[18] = IXGBE_READ_REG(hw
, IXGBE_EICS
);
562 regs_buff
[19] = IXGBE_READ_REG(hw
, IXGBE_EICS
);
563 regs_buff
[20] = IXGBE_READ_REG(hw
, IXGBE_EIMS
);
564 regs_buff
[21] = IXGBE_READ_REG(hw
, IXGBE_EIMC
);
565 regs_buff
[22] = IXGBE_READ_REG(hw
, IXGBE_EIAC
);
566 regs_buff
[23] = IXGBE_READ_REG(hw
, IXGBE_EIAM
);
567 regs_buff
[24] = IXGBE_READ_REG(hw
, IXGBE_EITR(0));
568 regs_buff
[25] = IXGBE_READ_REG(hw
, IXGBE_IVAR(0));
569 regs_buff
[26] = IXGBE_READ_REG(hw
, IXGBE_MSIXT
);
570 regs_buff
[27] = IXGBE_READ_REG(hw
, IXGBE_MSIXPBA
);
571 regs_buff
[28] = IXGBE_READ_REG(hw
, IXGBE_PBACL(0));
572 regs_buff
[29] = IXGBE_READ_REG(hw
, IXGBE_GPIE
);
575 regs_buff
[30] = IXGBE_READ_REG(hw
, IXGBE_PFCTOP
);
576 for (i
= 0; i
< 4; i
++)
577 regs_buff
[31 + i
] = IXGBE_READ_REG(hw
, IXGBE_FCTTV(i
));
578 for (i
= 0; i
< 8; i
++) {
579 switch (hw
->mac
.type
) {
580 case ixgbe_mac_82598EB
:
581 regs_buff
[35 + i
] = IXGBE_READ_REG(hw
, IXGBE_FCRTL(i
));
582 regs_buff
[43 + i
] = IXGBE_READ_REG(hw
, IXGBE_FCRTH(i
));
584 case ixgbe_mac_82599EB
:
587 case ixgbe_mac_X550EM_x
:
588 case ixgbe_mac_x550em_a
:
589 regs_buff
[35 + i
] = IXGBE_READ_REG(hw
, IXGBE_FCRTL_82599(i
));
590 regs_buff
[43 + i
] = IXGBE_READ_REG(hw
, IXGBE_FCRTH_82599(i
));
596 regs_buff
[51] = IXGBE_READ_REG(hw
, IXGBE_FCRTV
);
597 regs_buff
[52] = IXGBE_READ_REG(hw
, IXGBE_TFCS
);
600 for (i
= 0; i
< 64; i
++)
601 regs_buff
[53 + i
] = IXGBE_READ_REG(hw
, IXGBE_RDBAL(i
));
602 for (i
= 0; i
< 64; i
++)
603 regs_buff
[117 + i
] = IXGBE_READ_REG(hw
, IXGBE_RDBAH(i
));
604 for (i
= 0; i
< 64; i
++)
605 regs_buff
[181 + i
] = IXGBE_READ_REG(hw
, IXGBE_RDLEN(i
));
606 for (i
= 0; i
< 64; i
++)
607 regs_buff
[245 + i
] = IXGBE_READ_REG(hw
, IXGBE_RDH(i
));
608 for (i
= 0; i
< 64; i
++)
609 regs_buff
[309 + i
] = IXGBE_READ_REG(hw
, IXGBE_RDT(i
));
610 for (i
= 0; i
< 64; i
++)
611 regs_buff
[373 + i
] = IXGBE_READ_REG(hw
, IXGBE_RXDCTL(i
));
612 for (i
= 0; i
< 16; i
++)
613 regs_buff
[437 + i
] = IXGBE_READ_REG(hw
, IXGBE_SRRCTL(i
));
614 for (i
= 0; i
< 16; i
++)
615 regs_buff
[453 + i
] = IXGBE_READ_REG(hw
, IXGBE_DCA_RXCTRL(i
));
616 regs_buff
[469] = IXGBE_READ_REG(hw
, IXGBE_RDRXCTL
);
617 for (i
= 0; i
< 8; i
++)
618 regs_buff
[470 + i
] = IXGBE_READ_REG(hw
, IXGBE_RXPBSIZE(i
));
619 regs_buff
[478] = IXGBE_READ_REG(hw
, IXGBE_RXCTRL
);
620 regs_buff
[479] = IXGBE_READ_REG(hw
, IXGBE_DROPEN
);
623 regs_buff
[480] = IXGBE_READ_REG(hw
, IXGBE_RXCSUM
);
624 regs_buff
[481] = IXGBE_READ_REG(hw
, IXGBE_RFCTL
);
625 for (i
= 0; i
< 16; i
++)
626 regs_buff
[482 + i
] = IXGBE_READ_REG(hw
, IXGBE_RAL(i
));
627 for (i
= 0; i
< 16; i
++)
628 regs_buff
[498 + i
] = IXGBE_READ_REG(hw
, IXGBE_RAH(i
));
629 regs_buff
[514] = IXGBE_READ_REG(hw
, IXGBE_PSRTYPE(0));
630 regs_buff
[515] = IXGBE_READ_REG(hw
, IXGBE_FCTRL
);
631 regs_buff
[516] = IXGBE_READ_REG(hw
, IXGBE_VLNCTRL
);
632 regs_buff
[517] = IXGBE_READ_REG(hw
, IXGBE_MCSTCTRL
);
633 regs_buff
[518] = IXGBE_READ_REG(hw
, IXGBE_MRQC
);
634 regs_buff
[519] = IXGBE_READ_REG(hw
, IXGBE_VMD_CTL
);
635 for (i
= 0; i
< 8; i
++)
636 regs_buff
[520 + i
] = IXGBE_READ_REG(hw
, IXGBE_IMIR(i
));
637 for (i
= 0; i
< 8; i
++)
638 regs_buff
[528 + i
] = IXGBE_READ_REG(hw
, IXGBE_IMIREXT(i
));
639 regs_buff
[536] = IXGBE_READ_REG(hw
, IXGBE_IMIRVP
);
642 for (i
= 0; i
< 32; i
++)
643 regs_buff
[537 + i
] = IXGBE_READ_REG(hw
, IXGBE_TDBAL(i
));
644 for (i
= 0; i
< 32; i
++)
645 regs_buff
[569 + i
] = IXGBE_READ_REG(hw
, IXGBE_TDBAH(i
));
646 for (i
= 0; i
< 32; i
++)
647 regs_buff
[601 + i
] = IXGBE_READ_REG(hw
, IXGBE_TDLEN(i
));
648 for (i
= 0; i
< 32; i
++)
649 regs_buff
[633 + i
] = IXGBE_READ_REG(hw
, IXGBE_TDH(i
));
650 for (i
= 0; i
< 32; i
++)
651 regs_buff
[665 + i
] = IXGBE_READ_REG(hw
, IXGBE_TDT(i
));
652 for (i
= 0; i
< 32; i
++)
653 regs_buff
[697 + i
] = IXGBE_READ_REG(hw
, IXGBE_TXDCTL(i
));
654 for (i
= 0; i
< 32; i
++)
655 regs_buff
[729 + i
] = IXGBE_READ_REG(hw
, IXGBE_TDWBAL(i
));
656 for (i
= 0; i
< 32; i
++)
657 regs_buff
[761 + i
] = IXGBE_READ_REG(hw
, IXGBE_TDWBAH(i
));
658 regs_buff
[793] = IXGBE_READ_REG(hw
, IXGBE_DTXCTL
);
659 for (i
= 0; i
< 16; i
++)
660 regs_buff
[794 + i
] = IXGBE_READ_REG(hw
, IXGBE_DCA_TXCTRL(i
));
661 regs_buff
[810] = IXGBE_READ_REG(hw
, IXGBE_TIPG
);
662 for (i
= 0; i
< 8; i
++)
663 regs_buff
[811 + i
] = IXGBE_READ_REG(hw
, IXGBE_TXPBSIZE(i
));
664 regs_buff
[819] = IXGBE_READ_REG(hw
, IXGBE_MNGTXMAP
);
667 regs_buff
[820] = IXGBE_READ_REG(hw
, IXGBE_WUC
);
668 regs_buff
[821] = IXGBE_READ_REG(hw
, IXGBE_WUFC
);
669 regs_buff
[822] = IXGBE_READ_REG(hw
, IXGBE_WUS
);
670 regs_buff
[823] = IXGBE_READ_REG(hw
, IXGBE_IPAV
);
671 regs_buff
[824] = IXGBE_READ_REG(hw
, IXGBE_IP4AT
);
672 regs_buff
[825] = IXGBE_READ_REG(hw
, IXGBE_IP6AT
);
673 regs_buff
[826] = IXGBE_READ_REG(hw
, IXGBE_WUPL
);
674 regs_buff
[827] = IXGBE_READ_REG(hw
, IXGBE_WUPM
);
675 regs_buff
[828] = IXGBE_READ_REG(hw
, IXGBE_FHFT(0));
678 regs_buff
[829] = IXGBE_READ_REG(hw
, IXGBE_RMCS
); /* same as FCCFG */
679 regs_buff
[831] = IXGBE_READ_REG(hw
, IXGBE_PDPMCS
); /* same as RTTPCS */
681 switch (hw
->mac
.type
) {
682 case ixgbe_mac_82598EB
:
683 regs_buff
[830] = IXGBE_READ_REG(hw
, IXGBE_DPMCS
);
684 regs_buff
[832] = IXGBE_READ_REG(hw
, IXGBE_RUPPBMR
);
685 for (i
= 0; i
< 8; i
++)
687 IXGBE_READ_REG(hw
, IXGBE_RT2CR(i
));
688 for (i
= 0; i
< 8; i
++)
690 IXGBE_READ_REG(hw
, IXGBE_RT2SR(i
));
691 for (i
= 0; i
< 8; i
++)
693 IXGBE_READ_REG(hw
, IXGBE_TDTQ2TCCR(i
));
694 for (i
= 0; i
< 8; i
++)
696 IXGBE_READ_REG(hw
, IXGBE_TDTQ2TCSR(i
));
698 case ixgbe_mac_82599EB
:
701 case ixgbe_mac_X550EM_x
:
702 case ixgbe_mac_x550em_a
:
703 regs_buff
[830] = IXGBE_READ_REG(hw
, IXGBE_RTTDCS
);
704 regs_buff
[832] = IXGBE_READ_REG(hw
, IXGBE_RTRPCS
);
705 for (i
= 0; i
< 8; i
++)
707 IXGBE_READ_REG(hw
, IXGBE_RTRPT4C(i
));
708 for (i
= 0; i
< 8; i
++)
710 IXGBE_READ_REG(hw
, IXGBE_RTRPT4S(i
));
711 for (i
= 0; i
< 8; i
++)
713 IXGBE_READ_REG(hw
, IXGBE_RTTDT2C(i
));
714 for (i
= 0; i
< 8; i
++)
716 IXGBE_READ_REG(hw
, IXGBE_RTTDT2S(i
));
722 for (i
= 0; i
< 8; i
++)
724 IXGBE_READ_REG(hw
, IXGBE_TDPT2TCCR(i
)); /* same as RTTPT2C */
725 for (i
= 0; i
< 8; i
++)
727 IXGBE_READ_REG(hw
, IXGBE_TDPT2TCSR(i
)); /* same as RTTPT2S */
730 regs_buff
[881] = IXGBE_GET_STAT(adapter
, crcerrs
);
731 regs_buff
[882] = IXGBE_GET_STAT(adapter
, illerrc
);
732 regs_buff
[883] = IXGBE_GET_STAT(adapter
, errbc
);
733 regs_buff
[884] = IXGBE_GET_STAT(adapter
, mspdc
);
734 for (i
= 0; i
< 8; i
++)
735 regs_buff
[885 + i
] = IXGBE_GET_STAT(adapter
, mpc
[i
]);
736 regs_buff
[893] = IXGBE_GET_STAT(adapter
, mlfc
);
737 regs_buff
[894] = IXGBE_GET_STAT(adapter
, mrfc
);
738 regs_buff
[895] = IXGBE_GET_STAT(adapter
, rlec
);
739 regs_buff
[896] = IXGBE_GET_STAT(adapter
, lxontxc
);
740 regs_buff
[897] = IXGBE_GET_STAT(adapter
, lxonrxc
);
741 regs_buff
[898] = IXGBE_GET_STAT(adapter
, lxofftxc
);
742 regs_buff
[899] = IXGBE_GET_STAT(adapter
, lxoffrxc
);
743 for (i
= 0; i
< 8; i
++)
744 regs_buff
[900 + i
] = IXGBE_GET_STAT(adapter
, pxontxc
[i
]);
745 for (i
= 0; i
< 8; i
++)
746 regs_buff
[908 + i
] = IXGBE_GET_STAT(adapter
, pxonrxc
[i
]);
747 for (i
= 0; i
< 8; i
++)
748 regs_buff
[916 + i
] = IXGBE_GET_STAT(adapter
, pxofftxc
[i
]);
749 for (i
= 0; i
< 8; i
++)
750 regs_buff
[924 + i
] = IXGBE_GET_STAT(adapter
, pxoffrxc
[i
]);
751 regs_buff
[932] = IXGBE_GET_STAT(adapter
, prc64
);
752 regs_buff
[933] = IXGBE_GET_STAT(adapter
, prc127
);
753 regs_buff
[934] = IXGBE_GET_STAT(adapter
, prc255
);
754 regs_buff
[935] = IXGBE_GET_STAT(adapter
, prc511
);
755 regs_buff
[936] = IXGBE_GET_STAT(adapter
, prc1023
);
756 regs_buff
[937] = IXGBE_GET_STAT(adapter
, prc1522
);
757 regs_buff
[938] = IXGBE_GET_STAT(adapter
, gprc
);
758 regs_buff
[939] = IXGBE_GET_STAT(adapter
, bprc
);
759 regs_buff
[940] = IXGBE_GET_STAT(adapter
, mprc
);
760 regs_buff
[941] = IXGBE_GET_STAT(adapter
, gptc
);
761 regs_buff
[942] = (u32
)IXGBE_GET_STAT(adapter
, gorc
);
762 regs_buff
[943] = (u32
)(IXGBE_GET_STAT(adapter
, gorc
) >> 32);
763 regs_buff
[944] = (u32
)IXGBE_GET_STAT(adapter
, gotc
);
764 regs_buff
[945] = (u32
)(IXGBE_GET_STAT(adapter
, gotc
) >> 32);
765 for (i
= 0; i
< 8; i
++)
766 regs_buff
[946 + i
] = IXGBE_GET_STAT(adapter
, rnbc
[i
]);
767 regs_buff
[954] = IXGBE_GET_STAT(adapter
, ruc
);
768 regs_buff
[955] = IXGBE_GET_STAT(adapter
, rfc
);
769 regs_buff
[956] = IXGBE_GET_STAT(adapter
, roc
);
770 regs_buff
[957] = IXGBE_GET_STAT(adapter
, rjc
);
771 regs_buff
[958] = IXGBE_GET_STAT(adapter
, mngprc
);
772 regs_buff
[959] = IXGBE_GET_STAT(adapter
, mngpdc
);
773 regs_buff
[960] = IXGBE_GET_STAT(adapter
, mngptc
);
774 regs_buff
[961] = (u32
)IXGBE_GET_STAT(adapter
, tor
);
775 regs_buff
[962] = (u32
)(IXGBE_GET_STAT(adapter
, tor
) >> 32);
776 regs_buff
[963] = IXGBE_GET_STAT(adapter
, tpr
);
777 regs_buff
[964] = IXGBE_GET_STAT(adapter
, tpt
);
778 regs_buff
[965] = IXGBE_GET_STAT(adapter
, ptc64
);
779 regs_buff
[966] = IXGBE_GET_STAT(adapter
, ptc127
);
780 regs_buff
[967] = IXGBE_GET_STAT(adapter
, ptc255
);
781 regs_buff
[968] = IXGBE_GET_STAT(adapter
, ptc511
);
782 regs_buff
[969] = IXGBE_GET_STAT(adapter
, ptc1023
);
783 regs_buff
[970] = IXGBE_GET_STAT(adapter
, ptc1522
);
784 regs_buff
[971] = IXGBE_GET_STAT(adapter
, mptc
);
785 regs_buff
[972] = IXGBE_GET_STAT(adapter
, bptc
);
786 regs_buff
[973] = IXGBE_GET_STAT(adapter
, xec
);
787 for (i
= 0; i
< 16; i
++)
788 regs_buff
[974 + i
] = IXGBE_GET_STAT(adapter
, qprc
[i
]);
789 for (i
= 0; i
< 16; i
++)
790 regs_buff
[990 + i
] = IXGBE_GET_STAT(adapter
, qptc
[i
]);
791 for (i
= 0; i
< 16; i
++)
792 regs_buff
[1006 + i
] = IXGBE_GET_STAT(adapter
, qbrc
[i
]);
793 for (i
= 0; i
< 16; i
++)
794 regs_buff
[1022 + i
] = IXGBE_GET_STAT(adapter
, qbtc
[i
]);
797 regs_buff
[1038] = IXGBE_READ_REG(hw
, IXGBE_PCS1GCFIG
);
798 regs_buff
[1039] = IXGBE_READ_REG(hw
, IXGBE_PCS1GLCTL
);
799 regs_buff
[1040] = IXGBE_READ_REG(hw
, IXGBE_PCS1GLSTA
);
800 regs_buff
[1041] = IXGBE_READ_REG(hw
, IXGBE_PCS1GDBG0
);
801 regs_buff
[1042] = IXGBE_READ_REG(hw
, IXGBE_PCS1GDBG1
);
802 regs_buff
[1043] = IXGBE_READ_REG(hw
, IXGBE_PCS1GANA
);
803 regs_buff
[1044] = IXGBE_READ_REG(hw
, IXGBE_PCS1GANLP
);
804 regs_buff
[1045] = IXGBE_READ_REG(hw
, IXGBE_PCS1GANNP
);
805 regs_buff
[1046] = IXGBE_READ_REG(hw
, IXGBE_PCS1GANLPNP
);
806 regs_buff
[1047] = IXGBE_READ_REG(hw
, IXGBE_HLREG0
);
807 regs_buff
[1048] = IXGBE_READ_REG(hw
, IXGBE_HLREG1
);
808 regs_buff
[1049] = IXGBE_READ_REG(hw
, IXGBE_PAP
);
809 regs_buff
[1050] = IXGBE_READ_REG(hw
, IXGBE_MACA
);
810 regs_buff
[1051] = IXGBE_READ_REG(hw
, IXGBE_APAE
);
811 regs_buff
[1052] = IXGBE_READ_REG(hw
, IXGBE_ARD
);
812 regs_buff
[1053] = IXGBE_READ_REG(hw
, IXGBE_AIS
);
813 regs_buff
[1054] = IXGBE_READ_REG(hw
, IXGBE_MSCA
);
814 regs_buff
[1055] = IXGBE_READ_REG(hw
, IXGBE_MSRWD
);
815 regs_buff
[1056] = IXGBE_READ_REG(hw
, IXGBE_MLADD
);
816 regs_buff
[1057] = IXGBE_READ_REG(hw
, IXGBE_MHADD
);
817 regs_buff
[1058] = IXGBE_READ_REG(hw
, IXGBE_TREG
);
818 regs_buff
[1059] = IXGBE_READ_REG(hw
, IXGBE_PCSS1
);
819 regs_buff
[1060] = IXGBE_READ_REG(hw
, IXGBE_PCSS2
);
820 regs_buff
[1061] = IXGBE_READ_REG(hw
, IXGBE_XPCSS
);
821 regs_buff
[1062] = IXGBE_READ_REG(hw
, IXGBE_SERDESC
);
822 regs_buff
[1063] = IXGBE_READ_REG(hw
, IXGBE_MACS
);
823 regs_buff
[1064] = IXGBE_READ_REG(hw
, IXGBE_AUTOC
);
824 regs_buff
[1065] = IXGBE_READ_REG(hw
, IXGBE_LINKS
);
825 regs_buff
[1066] = IXGBE_READ_REG(hw
, IXGBE_AUTOC2
);
826 regs_buff
[1067] = IXGBE_READ_REG(hw
, IXGBE_AUTOC3
);
827 regs_buff
[1068] = IXGBE_READ_REG(hw
, IXGBE_ANLP1
);
828 regs_buff
[1069] = IXGBE_READ_REG(hw
, IXGBE_ANLP2
);
829 regs_buff
[1070] = IXGBE_READ_REG(hw
, IXGBE_ATLASCTL
);
832 regs_buff
[1071] = IXGBE_READ_REG(hw
, IXGBE_RDSTATCTL
);
833 for (i
= 0; i
< 8; i
++)
834 regs_buff
[1072 + i
] = IXGBE_READ_REG(hw
, IXGBE_RDSTAT(i
));
835 regs_buff
[1080] = IXGBE_READ_REG(hw
, IXGBE_RDHMPN
);
836 for (i
= 0; i
< 4; i
++)
837 regs_buff
[1081 + i
] = IXGBE_READ_REG(hw
, IXGBE_RIC_DW(i
));
838 regs_buff
[1085] = IXGBE_READ_REG(hw
, IXGBE_RDPROBE
);
839 regs_buff
[1086] = IXGBE_READ_REG(hw
, IXGBE_TDSTATCTL
);
840 for (i
= 0; i
< 8; i
++)
841 regs_buff
[1087 + i
] = IXGBE_READ_REG(hw
, IXGBE_TDSTAT(i
));
842 regs_buff
[1095] = IXGBE_READ_REG(hw
, IXGBE_TDHMPN
);
843 for (i
= 0; i
< 4; i
++)
844 regs_buff
[1096 + i
] = IXGBE_READ_REG(hw
, IXGBE_TIC_DW(i
));
845 regs_buff
[1100] = IXGBE_READ_REG(hw
, IXGBE_TDPROBE
);
846 regs_buff
[1101] = IXGBE_READ_REG(hw
, IXGBE_TXBUFCTRL
);
847 for (i
= 0; i
< 4; i
++)
848 regs_buff
[1102 + i
] = IXGBE_READ_REG(hw
, IXGBE_TXBUFDATA(i
));
849 regs_buff
[1106] = IXGBE_READ_REG(hw
, IXGBE_RXBUFCTRL
);
850 for (i
= 0; i
< 4; i
++)
851 regs_buff
[1107 + i
] = IXGBE_READ_REG(hw
, IXGBE_RXBUFDATA(i
));
852 for (i
= 0; i
< 8; i
++)
853 regs_buff
[1111 + i
] = IXGBE_READ_REG(hw
, IXGBE_PCIE_DIAG(i
));
854 regs_buff
[1119] = IXGBE_READ_REG(hw
, IXGBE_RFVAL
);
855 regs_buff
[1120] = IXGBE_READ_REG(hw
, IXGBE_MDFTC1
);
856 regs_buff
[1121] = IXGBE_READ_REG(hw
, IXGBE_MDFTC2
);
857 regs_buff
[1122] = IXGBE_READ_REG(hw
, IXGBE_MDFTFIFO1
);
858 regs_buff
[1123] = IXGBE_READ_REG(hw
, IXGBE_MDFTFIFO2
);
859 regs_buff
[1124] = IXGBE_READ_REG(hw
, IXGBE_MDFTS
);
860 regs_buff
[1125] = IXGBE_READ_REG(hw
, IXGBE_PCIEECCCTL
);
861 regs_buff
[1126] = IXGBE_READ_REG(hw
, IXGBE_PBTXECC
);
862 regs_buff
[1127] = IXGBE_READ_REG(hw
, IXGBE_PBRXECC
);
864 /* 82599 X540 specific registers */
865 regs_buff
[1128] = IXGBE_READ_REG(hw
, IXGBE_MFLCN
);
867 /* 82599 X540 specific DCB registers */
868 regs_buff
[1129] = IXGBE_READ_REG(hw
, IXGBE_RTRUP2TC
);
869 regs_buff
[1130] = IXGBE_READ_REG(hw
, IXGBE_RTTUP2TC
);
870 for (i
= 0; i
< 4; i
++)
871 regs_buff
[1131 + i
] = IXGBE_READ_REG(hw
, IXGBE_TXLLQ(i
));
872 regs_buff
[1135] = IXGBE_READ_REG(hw
, IXGBE_RTTBCNRM
);
873 /* same as RTTQCNRM */
874 regs_buff
[1136] = IXGBE_READ_REG(hw
, IXGBE_RTTBCNRD
);
875 /* same as RTTQCNRR */
877 /* X540 specific DCB registers */
878 regs_buff
[1137] = IXGBE_READ_REG(hw
, IXGBE_RTTQCNCR
);
879 regs_buff
[1138] = IXGBE_READ_REG(hw
, IXGBE_RTTQCNTG
);
882 static int ixgbe_get_eeprom_len(struct net_device
*netdev
)
884 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
885 return adapter
->hw
.eeprom
.word_size
* 2;
888 static int ixgbe_get_eeprom(struct net_device
*netdev
,
889 struct ethtool_eeprom
*eeprom
, u8
*bytes
)
891 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
892 struct ixgbe_hw
*hw
= &adapter
->hw
;
894 int first_word
, last_word
, eeprom_len
;
898 if (eeprom
->len
== 0)
901 eeprom
->magic
= hw
->vendor_id
| (hw
->device_id
<< 16);
903 first_word
= eeprom
->offset
>> 1;
904 last_word
= (eeprom
->offset
+ eeprom
->len
- 1) >> 1;
905 eeprom_len
= last_word
- first_word
+ 1;
907 eeprom_buff
= kmalloc(sizeof(u16
) * eeprom_len
, GFP_KERNEL
);
911 ret_val
= hw
->eeprom
.ops
.read_buffer(hw
, first_word
, eeprom_len
,
914 /* Device's eeprom is always little-endian, word addressable */
915 for (i
= 0; i
< eeprom_len
; i
++)
916 le16_to_cpus(&eeprom_buff
[i
]);
918 memcpy(bytes
, (u8
*)eeprom_buff
+ (eeprom
->offset
& 1), eeprom
->len
);
924 static int ixgbe_set_eeprom(struct net_device
*netdev
,
925 struct ethtool_eeprom
*eeprom
, u8
*bytes
)
927 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
928 struct ixgbe_hw
*hw
= &adapter
->hw
;
931 int max_len
, first_word
, last_word
, ret_val
= 0;
934 if (eeprom
->len
== 0)
937 if (eeprom
->magic
!= (hw
->vendor_id
| (hw
->device_id
<< 16)))
940 max_len
= hw
->eeprom
.word_size
* 2;
942 first_word
= eeprom
->offset
>> 1;
943 last_word
= (eeprom
->offset
+ eeprom
->len
- 1) >> 1;
944 eeprom_buff
= kmalloc(max_len
, GFP_KERNEL
);
950 if (eeprom
->offset
& 1) {
952 * need read/modify/write of first changed EEPROM word
953 * only the second byte of the word is being modified
955 ret_val
= hw
->eeprom
.ops
.read(hw
, first_word
, &eeprom_buff
[0]);
961 if ((eeprom
->offset
+ eeprom
->len
) & 1) {
963 * need read/modify/write of last changed EEPROM word
964 * only the first byte of the word is being modified
966 ret_val
= hw
->eeprom
.ops
.read(hw
, last_word
,
967 &eeprom_buff
[last_word
- first_word
]);
972 /* Device's eeprom is always little-endian, word addressable */
973 for (i
= 0; i
< last_word
- first_word
+ 1; i
++)
974 le16_to_cpus(&eeprom_buff
[i
]);
976 memcpy(ptr
, bytes
, eeprom
->len
);
978 for (i
= 0; i
< last_word
- first_word
+ 1; i
++)
979 cpu_to_le16s(&eeprom_buff
[i
]);
981 ret_val
= hw
->eeprom
.ops
.write_buffer(hw
, first_word
,
982 last_word
- first_word
+ 1,
985 /* Update the checksum */
987 hw
->eeprom
.ops
.update_checksum(hw
);
994 static void ixgbe_get_drvinfo(struct net_device
*netdev
,
995 struct ethtool_drvinfo
*drvinfo
)
997 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
1000 strlcpy(drvinfo
->driver
, ixgbe_driver_name
, sizeof(drvinfo
->driver
));
1001 strlcpy(drvinfo
->version
, ixgbe_driver_version
,
1002 sizeof(drvinfo
->version
));
1004 nvm_track_id
= (adapter
->eeprom_verh
<< 16) |
1005 adapter
->eeprom_verl
;
1006 snprintf(drvinfo
->fw_version
, sizeof(drvinfo
->fw_version
), "0x%08x",
1009 strlcpy(drvinfo
->bus_info
, pci_name(adapter
->pdev
),
1010 sizeof(drvinfo
->bus_info
));
1012 drvinfo
->n_priv_flags
= IXGBE_PRIV_FLAGS_STR_LEN
;
1015 static void ixgbe_get_ringparam(struct net_device
*netdev
,
1016 struct ethtool_ringparam
*ring
)
1018 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
1019 struct ixgbe_ring
*tx_ring
= adapter
->tx_ring
[0];
1020 struct ixgbe_ring
*rx_ring
= adapter
->rx_ring
[0];
1022 ring
->rx_max_pending
= IXGBE_MAX_RXD
;
1023 ring
->tx_max_pending
= IXGBE_MAX_TXD
;
1024 ring
->rx_pending
= rx_ring
->count
;
1025 ring
->tx_pending
= tx_ring
->count
;
1028 static int ixgbe_set_ringparam(struct net_device
*netdev
,
1029 struct ethtool_ringparam
*ring
)
1031 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
1032 struct ixgbe_ring
*temp_ring
;
1034 u32 new_rx_count
, new_tx_count
;
1036 if ((ring
->rx_mini_pending
) || (ring
->rx_jumbo_pending
))
1039 new_tx_count
= clamp_t(u32
, ring
->tx_pending
,
1040 IXGBE_MIN_TXD
, IXGBE_MAX_TXD
);
1041 new_tx_count
= ALIGN(new_tx_count
, IXGBE_REQ_TX_DESCRIPTOR_MULTIPLE
);
1043 new_rx_count
= clamp_t(u32
, ring
->rx_pending
,
1044 IXGBE_MIN_RXD
, IXGBE_MAX_RXD
);
1045 new_rx_count
= ALIGN(new_rx_count
, IXGBE_REQ_RX_DESCRIPTOR_MULTIPLE
);
1047 if ((new_tx_count
== adapter
->tx_ring_count
) &&
1048 (new_rx_count
== adapter
->rx_ring_count
)) {
1053 while (test_and_set_bit(__IXGBE_RESETTING
, &adapter
->state
))
1054 usleep_range(1000, 2000);
1056 if (!netif_running(adapter
->netdev
)) {
1057 for (i
= 0; i
< adapter
->num_tx_queues
; i
++)
1058 adapter
->tx_ring
[i
]->count
= new_tx_count
;
1059 for (i
= 0; i
< adapter
->num_rx_queues
; i
++)
1060 adapter
->rx_ring
[i
]->count
= new_rx_count
;
1061 adapter
->tx_ring_count
= new_tx_count
;
1062 adapter
->rx_ring_count
= new_rx_count
;
1066 /* allocate temporary buffer to store rings in */
1067 i
= max_t(int, adapter
->num_tx_queues
, adapter
->num_rx_queues
);
1068 temp_ring
= vmalloc(i
* sizeof(struct ixgbe_ring
));
1075 ixgbe_down(adapter
);
1078 * Setup new Tx resources and free the old Tx resources in that order.
1079 * We can then assign the new resources to the rings via a memcpy.
1080 * The advantage to this approach is that we are guaranteed to still
1081 * have resources even in the case of an allocation failure.
1083 if (new_tx_count
!= adapter
->tx_ring_count
) {
1084 for (i
= 0; i
< adapter
->num_tx_queues
; i
++) {
1085 memcpy(&temp_ring
[i
], adapter
->tx_ring
[i
],
1086 sizeof(struct ixgbe_ring
));
1088 temp_ring
[i
].count
= new_tx_count
;
1089 err
= ixgbe_setup_tx_resources(&temp_ring
[i
]);
1093 ixgbe_free_tx_resources(&temp_ring
[i
]);
1099 for (i
= 0; i
< adapter
->num_tx_queues
; i
++) {
1100 ixgbe_free_tx_resources(adapter
->tx_ring
[i
]);
1102 memcpy(adapter
->tx_ring
[i
], &temp_ring
[i
],
1103 sizeof(struct ixgbe_ring
));
1106 adapter
->tx_ring_count
= new_tx_count
;
1109 /* Repeat the process for the Rx rings if needed */
1110 if (new_rx_count
!= adapter
->rx_ring_count
) {
1111 for (i
= 0; i
< adapter
->num_rx_queues
; i
++) {
1112 memcpy(&temp_ring
[i
], adapter
->rx_ring
[i
],
1113 sizeof(struct ixgbe_ring
));
1115 temp_ring
[i
].count
= new_rx_count
;
1116 err
= ixgbe_setup_rx_resources(&temp_ring
[i
]);
1120 ixgbe_free_rx_resources(&temp_ring
[i
]);
1127 for (i
= 0; i
< adapter
->num_rx_queues
; i
++) {
1128 ixgbe_free_rx_resources(adapter
->rx_ring
[i
]);
1130 memcpy(adapter
->rx_ring
[i
], &temp_ring
[i
],
1131 sizeof(struct ixgbe_ring
));
1134 adapter
->rx_ring_count
= new_rx_count
;
1141 clear_bit(__IXGBE_RESETTING
, &adapter
->state
);
1145 static int ixgbe_get_sset_count(struct net_device
*netdev
, int sset
)
1149 return IXGBE_TEST_LEN
;
1151 return IXGBE_STATS_LEN
;
1152 case ETH_SS_PRIV_FLAGS
:
1153 return IXGBE_PRIV_FLAGS_STR_LEN
;
1159 static void ixgbe_get_ethtool_stats(struct net_device
*netdev
,
1160 struct ethtool_stats
*stats
, u64
*data
)
1162 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
1163 struct rtnl_link_stats64 temp
;
1164 const struct rtnl_link_stats64
*net_stats
;
1166 struct ixgbe_ring
*ring
;
1170 ixgbe_update_stats(adapter
);
1171 net_stats
= dev_get_stats(netdev
, &temp
);
1172 for (i
= 0; i
< IXGBE_GLOBAL_STATS_LEN
; i
++) {
1173 switch (ixgbe_gstrings_stats
[i
].type
) {
1175 p
= (char *) net_stats
+
1176 ixgbe_gstrings_stats
[i
].stat_offset
;
1179 p
= (char *) adapter
+
1180 ixgbe_gstrings_stats
[i
].stat_offset
;
1187 data
[i
] = (ixgbe_gstrings_stats
[i
].sizeof_stat
==
1188 sizeof(u64
)) ? *(u64
*)p
: *(u32
*)p
;
1190 for (j
= 0; j
< netdev
->num_tx_queues
; j
++) {
1191 ring
= adapter
->tx_ring
[j
];
1200 start
= u64_stats_fetch_begin_irq(&ring
->syncp
);
1201 data
[i
] = ring
->stats
.packets
;
1202 data
[i
+1] = ring
->stats
.bytes
;
1203 } while (u64_stats_fetch_retry_irq(&ring
->syncp
, start
));
1206 for (j
= 0; j
< IXGBE_NUM_RX_QUEUES
; j
++) {
1207 ring
= adapter
->rx_ring
[j
];
1216 start
= u64_stats_fetch_begin_irq(&ring
->syncp
);
1217 data
[i
] = ring
->stats
.packets
;
1218 data
[i
+1] = ring
->stats
.bytes
;
1219 } while (u64_stats_fetch_retry_irq(&ring
->syncp
, start
));
1223 for (j
= 0; j
< IXGBE_MAX_PACKET_BUFFERS
; j
++) {
1224 data
[i
++] = adapter
->stats
.pxontxc
[j
];
1225 data
[i
++] = adapter
->stats
.pxofftxc
[j
];
1227 for (j
= 0; j
< IXGBE_MAX_PACKET_BUFFERS
; j
++) {
1228 data
[i
++] = adapter
->stats
.pxonrxc
[j
];
1229 data
[i
++] = adapter
->stats
.pxoffrxc
[j
];
1233 static void ixgbe_get_strings(struct net_device
*netdev
, u32 stringset
,
1236 char *p
= (char *)data
;
1239 switch (stringset
) {
1241 for (i
= 0; i
< IXGBE_TEST_LEN
; i
++) {
1242 memcpy(data
, ixgbe_gstrings_test
[i
], ETH_GSTRING_LEN
);
1243 data
+= ETH_GSTRING_LEN
;
1247 for (i
= 0; i
< IXGBE_GLOBAL_STATS_LEN
; i
++) {
1248 memcpy(p
, ixgbe_gstrings_stats
[i
].stat_string
,
1250 p
+= ETH_GSTRING_LEN
;
1252 for (i
= 0; i
< netdev
->num_tx_queues
; i
++) {
1253 sprintf(p
, "tx_queue_%u_packets", i
);
1254 p
+= ETH_GSTRING_LEN
;
1255 sprintf(p
, "tx_queue_%u_bytes", i
);
1256 p
+= ETH_GSTRING_LEN
;
1258 for (i
= 0; i
< IXGBE_NUM_RX_QUEUES
; i
++) {
1259 sprintf(p
, "rx_queue_%u_packets", i
);
1260 p
+= ETH_GSTRING_LEN
;
1261 sprintf(p
, "rx_queue_%u_bytes", i
);
1262 p
+= ETH_GSTRING_LEN
;
1264 for (i
= 0; i
< IXGBE_MAX_PACKET_BUFFERS
; i
++) {
1265 sprintf(p
, "tx_pb_%u_pxon", i
);
1266 p
+= ETH_GSTRING_LEN
;
1267 sprintf(p
, "tx_pb_%u_pxoff", i
);
1268 p
+= ETH_GSTRING_LEN
;
1270 for (i
= 0; i
< IXGBE_MAX_PACKET_BUFFERS
; i
++) {
1271 sprintf(p
, "rx_pb_%u_pxon", i
);
1272 p
+= ETH_GSTRING_LEN
;
1273 sprintf(p
, "rx_pb_%u_pxoff", i
);
1274 p
+= ETH_GSTRING_LEN
;
1276 /* BUG_ON(p - data != IXGBE_STATS_LEN * ETH_GSTRING_LEN); */
1278 case ETH_SS_PRIV_FLAGS
:
1279 memcpy(data
, ixgbe_priv_flags_strings
,
1280 IXGBE_PRIV_FLAGS_STR_LEN
* ETH_GSTRING_LEN
);
1284 static int ixgbe_link_test(struct ixgbe_adapter
*adapter
, u64
*data
)
1286 struct ixgbe_hw
*hw
= &adapter
->hw
;
1290 if (ixgbe_removed(hw
->hw_addr
)) {
1296 hw
->mac
.ops
.check_link(hw
, &link_speed
, &link_up
, true);
1304 /* ethtool register test data */
1305 struct ixgbe_reg_test
{
1313 /* In the hardware, registers are laid out either singly, in arrays
1314 * spaced 0x40 bytes apart, or in contiguous tables. We assume
1315 * most tests take place on arrays or single registers (handled
1316 * as a single-element array) and special-case the tables.
1317 * Table tests are always pattern tests.
1319 * We also make provision for some required setup steps by specifying
1320 * registers to be written without any read-back testing.
1323 #define PATTERN_TEST 1
1324 #define SET_READ_TEST 2
1325 #define WRITE_NO_TEST 3
1326 #define TABLE32_TEST 4
1327 #define TABLE64_TEST_LO 5
1328 #define TABLE64_TEST_HI 6
1330 /* default 82599 register test */
1331 static const struct ixgbe_reg_test reg_test_82599
[] = {
1332 { IXGBE_FCRTL_82599(0), 1, PATTERN_TEST
, 0x8007FFF0, 0x8007FFF0 },
1333 { IXGBE_FCRTH_82599(0), 1, PATTERN_TEST
, 0x8007FFF0, 0x8007FFF0 },
1334 { IXGBE_PFCTOP
, 1, PATTERN_TEST
, 0xFFFFFFFF, 0xFFFFFFFF },
1335 { IXGBE_VLNCTRL
, 1, PATTERN_TEST
, 0x00000000, 0x00000000 },
1336 { IXGBE_RDBAL(0), 4, PATTERN_TEST
, 0xFFFFFF80, 0xFFFFFF80 },
1337 { IXGBE_RDBAH(0), 4, PATTERN_TEST
, 0xFFFFFFFF, 0xFFFFFFFF },
1338 { IXGBE_RDLEN(0), 4, PATTERN_TEST
, 0x000FFF80, 0x000FFFFF },
1339 { IXGBE_RXDCTL(0), 4, WRITE_NO_TEST
, 0, IXGBE_RXDCTL_ENABLE
},
1340 { IXGBE_RDT(0), 4, PATTERN_TEST
, 0x0000FFFF, 0x0000FFFF },
1341 { IXGBE_RXDCTL(0), 4, WRITE_NO_TEST
, 0, 0 },
1342 { IXGBE_FCRTH(0), 1, PATTERN_TEST
, 0x8007FFF0, 0x8007FFF0 },
1343 { IXGBE_FCTTV(0), 1, PATTERN_TEST
, 0xFFFFFFFF, 0xFFFFFFFF },
1344 { IXGBE_TDBAL(0), 4, PATTERN_TEST
, 0xFFFFFF80, 0xFFFFFFFF },
1345 { IXGBE_TDBAH(0), 4, PATTERN_TEST
, 0xFFFFFFFF, 0xFFFFFFFF },
1346 { IXGBE_TDLEN(0), 4, PATTERN_TEST
, 0x000FFF80, 0x000FFF80 },
1347 { IXGBE_RXCTRL
, 1, SET_READ_TEST
, 0x00000001, 0x00000001 },
1348 { IXGBE_RAL(0), 16, TABLE64_TEST_LO
, 0xFFFFFFFF, 0xFFFFFFFF },
1349 { IXGBE_RAL(0), 16, TABLE64_TEST_HI
, 0x8001FFFF, 0x800CFFFF },
1350 { IXGBE_MTA(0), 128, TABLE32_TEST
, 0xFFFFFFFF, 0xFFFFFFFF },
1354 /* default 82598 register test */
1355 static const struct ixgbe_reg_test reg_test_82598
[] = {
1356 { IXGBE_FCRTL(0), 1, PATTERN_TEST
, 0x8007FFF0, 0x8007FFF0 },
1357 { IXGBE_FCRTH(0), 1, PATTERN_TEST
, 0x8007FFF0, 0x8007FFF0 },
1358 { IXGBE_PFCTOP
, 1, PATTERN_TEST
, 0xFFFFFFFF, 0xFFFFFFFF },
1359 { IXGBE_VLNCTRL
, 1, PATTERN_TEST
, 0x00000000, 0x00000000 },
1360 { IXGBE_RDBAL(0), 4, PATTERN_TEST
, 0xFFFFFF80, 0xFFFFFFFF },
1361 { IXGBE_RDBAH(0), 4, PATTERN_TEST
, 0xFFFFFFFF, 0xFFFFFFFF },
1362 { IXGBE_RDLEN(0), 4, PATTERN_TEST
, 0x000FFF80, 0x000FFFFF },
1363 /* Enable all four RX queues before testing. */
1364 { IXGBE_RXDCTL(0), 4, WRITE_NO_TEST
, 0, IXGBE_RXDCTL_ENABLE
},
1365 /* RDH is read-only for 82598, only test RDT. */
1366 { IXGBE_RDT(0), 4, PATTERN_TEST
, 0x0000FFFF, 0x0000FFFF },
1367 { IXGBE_RXDCTL(0), 4, WRITE_NO_TEST
, 0, 0 },
1368 { IXGBE_FCRTH(0), 1, PATTERN_TEST
, 0x8007FFF0, 0x8007FFF0 },
1369 { IXGBE_FCTTV(0), 1, PATTERN_TEST
, 0xFFFFFFFF, 0xFFFFFFFF },
1370 { IXGBE_TIPG
, 1, PATTERN_TEST
, 0x000000FF, 0x000000FF },
1371 { IXGBE_TDBAL(0), 4, PATTERN_TEST
, 0xFFFFFF80, 0xFFFFFFFF },
1372 { IXGBE_TDBAH(0), 4, PATTERN_TEST
, 0xFFFFFFFF, 0xFFFFFFFF },
1373 { IXGBE_TDLEN(0), 4, PATTERN_TEST
, 0x000FFF80, 0x000FFFFF },
1374 { IXGBE_RXCTRL
, 1, SET_READ_TEST
, 0x00000003, 0x00000003 },
1375 { IXGBE_DTXCTL
, 1, SET_READ_TEST
, 0x00000005, 0x00000005 },
1376 { IXGBE_RAL(0), 16, TABLE64_TEST_LO
, 0xFFFFFFFF, 0xFFFFFFFF },
1377 { IXGBE_RAL(0), 16, TABLE64_TEST_HI
, 0x800CFFFF, 0x800CFFFF },
1378 { IXGBE_MTA(0), 128, TABLE32_TEST
, 0xFFFFFFFF, 0xFFFFFFFF },
1382 static bool reg_pattern_test(struct ixgbe_adapter
*adapter
, u64
*data
, int reg
,
1383 u32 mask
, u32 write
)
1385 u32 pat
, val
, before
;
1386 static const u32 test_pattern
[] = {
1387 0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF};
1389 if (ixgbe_removed(adapter
->hw
.hw_addr
)) {
1393 for (pat
= 0; pat
< ARRAY_SIZE(test_pattern
); pat
++) {
1394 before
= ixgbe_read_reg(&adapter
->hw
, reg
);
1395 ixgbe_write_reg(&adapter
->hw
, reg
, test_pattern
[pat
] & write
);
1396 val
= ixgbe_read_reg(&adapter
->hw
, reg
);
1397 if (val
!= (test_pattern
[pat
] & write
& mask
)) {
1398 e_err(drv
, "pattern test reg %04X failed: got 0x%08X expected 0x%08X\n",
1399 reg
, val
, (test_pattern
[pat
] & write
& mask
));
1401 ixgbe_write_reg(&adapter
->hw
, reg
, before
);
1404 ixgbe_write_reg(&adapter
->hw
, reg
, before
);
1409 static bool reg_set_and_check(struct ixgbe_adapter
*adapter
, u64
*data
, int reg
,
1410 u32 mask
, u32 write
)
1414 if (ixgbe_removed(adapter
->hw
.hw_addr
)) {
1418 before
= ixgbe_read_reg(&adapter
->hw
, reg
);
1419 ixgbe_write_reg(&adapter
->hw
, reg
, write
& mask
);
1420 val
= ixgbe_read_reg(&adapter
->hw
, reg
);
1421 if ((write
& mask
) != (val
& mask
)) {
1422 e_err(drv
, "set/check reg %04X test failed: got 0x%08X expected 0x%08X\n",
1423 reg
, (val
& mask
), (write
& mask
));
1425 ixgbe_write_reg(&adapter
->hw
, reg
, before
);
1428 ixgbe_write_reg(&adapter
->hw
, reg
, before
);
1432 static int ixgbe_reg_test(struct ixgbe_adapter
*adapter
, u64
*data
)
1434 const struct ixgbe_reg_test
*test
;
1435 u32 value
, before
, after
;
1438 if (ixgbe_removed(adapter
->hw
.hw_addr
)) {
1439 e_err(drv
, "Adapter removed - register test blocked\n");
1443 switch (adapter
->hw
.mac
.type
) {
1444 case ixgbe_mac_82598EB
:
1445 toggle
= 0x7FFFF3FF;
1446 test
= reg_test_82598
;
1448 case ixgbe_mac_82599EB
:
1449 case ixgbe_mac_X540
:
1450 case ixgbe_mac_X550
:
1451 case ixgbe_mac_X550EM_x
:
1452 case ixgbe_mac_x550em_a
:
1453 toggle
= 0x7FFFF30F;
1454 test
= reg_test_82599
;
1462 * Because the status register is such a special case,
1463 * we handle it separately from the rest of the register
1464 * tests. Some bits are read-only, some toggle, and some
1465 * are writeable on newer MACs.
1467 before
= ixgbe_read_reg(&adapter
->hw
, IXGBE_STATUS
);
1468 value
= (ixgbe_read_reg(&adapter
->hw
, IXGBE_STATUS
) & toggle
);
1469 ixgbe_write_reg(&adapter
->hw
, IXGBE_STATUS
, toggle
);
1470 after
= ixgbe_read_reg(&adapter
->hw
, IXGBE_STATUS
) & toggle
;
1471 if (value
!= after
) {
1472 e_err(drv
, "failed STATUS register test got: 0x%08X expected: 0x%08X\n",
1477 /* restore previous status */
1478 ixgbe_write_reg(&adapter
->hw
, IXGBE_STATUS
, before
);
1481 * Perform the remainder of the register test, looping through
1482 * the test table until we either fail or reach the null entry.
1485 for (i
= 0; i
< test
->array_len
; i
++) {
1488 switch (test
->test_type
) {
1490 b
= reg_pattern_test(adapter
, data
,
1491 test
->reg
+ (i
* 0x40),
1496 b
= reg_set_and_check(adapter
, data
,
1497 test
->reg
+ (i
* 0x40),
1502 ixgbe_write_reg(&adapter
->hw
,
1503 test
->reg
+ (i
* 0x40),
1507 b
= reg_pattern_test(adapter
, data
,
1508 test
->reg
+ (i
* 4),
1512 case TABLE64_TEST_LO
:
1513 b
= reg_pattern_test(adapter
, data
,
1514 test
->reg
+ (i
* 8),
1518 case TABLE64_TEST_HI
:
1519 b
= reg_pattern_test(adapter
, data
,
1520 (test
->reg
+ 4) + (i
* 8),
1535 static int ixgbe_eeprom_test(struct ixgbe_adapter
*adapter
, u64
*data
)
1537 struct ixgbe_hw
*hw
= &adapter
->hw
;
1538 if (hw
->eeprom
.ops
.validate_checksum(hw
, NULL
))
1545 static irqreturn_t
ixgbe_test_intr(int irq
, void *data
)
1547 struct net_device
*netdev
= (struct net_device
*) data
;
1548 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
1550 adapter
->test_icr
|= IXGBE_READ_REG(&adapter
->hw
, IXGBE_EICR
);
1555 static int ixgbe_intr_test(struct ixgbe_adapter
*adapter
, u64
*data
)
1557 struct net_device
*netdev
= adapter
->netdev
;
1558 u32 mask
, i
= 0, shared_int
= true;
1559 u32 irq
= adapter
->pdev
->irq
;
1563 /* Hook up test interrupt handler just for this test */
1564 if (adapter
->msix_entries
) {
1565 /* NOTE: we don't test MSI-X interrupts here, yet */
1567 } else if (adapter
->flags
& IXGBE_FLAG_MSI_ENABLED
) {
1569 if (request_irq(irq
, ixgbe_test_intr
, 0, netdev
->name
,
1574 } else if (!request_irq(irq
, ixgbe_test_intr
, IRQF_PROBE_SHARED
,
1575 netdev
->name
, netdev
)) {
1577 } else if (request_irq(irq
, ixgbe_test_intr
, IRQF_SHARED
,
1578 netdev
->name
, netdev
)) {
1582 e_info(hw
, "testing %s interrupt\n", shared_int
?
1583 "shared" : "unshared");
1585 /* Disable all the interrupts */
1586 IXGBE_WRITE_REG(&adapter
->hw
, IXGBE_EIMC
, 0xFFFFFFFF);
1587 IXGBE_WRITE_FLUSH(&adapter
->hw
);
1588 usleep_range(10000, 20000);
1590 /* Test each interrupt */
1591 for (; i
< 10; i
++) {
1592 /* Interrupt to test */
1597 * Disable the interrupts to be reported in
1598 * the cause register and then force the same
1599 * interrupt and see if one gets posted. If
1600 * an interrupt was posted to the bus, the
1603 adapter
->test_icr
= 0;
1604 IXGBE_WRITE_REG(&adapter
->hw
, IXGBE_EIMC
,
1605 ~mask
& 0x00007FFF);
1606 IXGBE_WRITE_REG(&adapter
->hw
, IXGBE_EICS
,
1607 ~mask
& 0x00007FFF);
1608 IXGBE_WRITE_FLUSH(&adapter
->hw
);
1609 usleep_range(10000, 20000);
1611 if (adapter
->test_icr
& mask
) {
1618 * Enable the interrupt to be reported in the cause
1619 * register and then force the same interrupt and see
1620 * if one gets posted. If an interrupt was not posted
1621 * to the bus, the test failed.
1623 adapter
->test_icr
= 0;
1624 IXGBE_WRITE_REG(&adapter
->hw
, IXGBE_EIMS
, mask
);
1625 IXGBE_WRITE_REG(&adapter
->hw
, IXGBE_EICS
, mask
);
1626 IXGBE_WRITE_FLUSH(&adapter
->hw
);
1627 usleep_range(10000, 20000);
1629 if (!(adapter
->test_icr
& mask
)) {
1636 * Disable the other interrupts to be reported in
1637 * the cause register and then force the other
1638 * interrupts and see if any get posted. If
1639 * an interrupt was posted to the bus, the
1642 adapter
->test_icr
= 0;
1643 IXGBE_WRITE_REG(&adapter
->hw
, IXGBE_EIMC
,
1644 ~mask
& 0x00007FFF);
1645 IXGBE_WRITE_REG(&adapter
->hw
, IXGBE_EICS
,
1646 ~mask
& 0x00007FFF);
1647 IXGBE_WRITE_FLUSH(&adapter
->hw
);
1648 usleep_range(10000, 20000);
1650 if (adapter
->test_icr
) {
1657 /* Disable all the interrupts */
1658 IXGBE_WRITE_REG(&adapter
->hw
, IXGBE_EIMC
, 0xFFFFFFFF);
1659 IXGBE_WRITE_FLUSH(&adapter
->hw
);
1660 usleep_range(10000, 20000);
1662 /* Unhook test interrupt handler */
1663 free_irq(irq
, netdev
);
1668 static void ixgbe_free_desc_rings(struct ixgbe_adapter
*adapter
)
1670 struct ixgbe_ring
*tx_ring
= &adapter
->test_tx_ring
;
1671 struct ixgbe_ring
*rx_ring
= &adapter
->test_rx_ring
;
1672 struct ixgbe_hw
*hw
= &adapter
->hw
;
1675 /* shut down the DMA engines now so they can be reinitialized later */
1678 hw
->mac
.ops
.disable_rx(hw
);
1679 ixgbe_disable_rx_queue(adapter
, rx_ring
);
1682 reg_ctl
= IXGBE_READ_REG(hw
, IXGBE_TXDCTL(tx_ring
->reg_idx
));
1683 reg_ctl
&= ~IXGBE_TXDCTL_ENABLE
;
1684 IXGBE_WRITE_REG(hw
, IXGBE_TXDCTL(tx_ring
->reg_idx
), reg_ctl
);
1686 switch (hw
->mac
.type
) {
1687 case ixgbe_mac_82599EB
:
1688 case ixgbe_mac_X540
:
1689 case ixgbe_mac_X550
:
1690 case ixgbe_mac_X550EM_x
:
1691 case ixgbe_mac_x550em_a
:
1692 reg_ctl
= IXGBE_READ_REG(hw
, IXGBE_DMATXCTL
);
1693 reg_ctl
&= ~IXGBE_DMATXCTL_TE
;
1694 IXGBE_WRITE_REG(hw
, IXGBE_DMATXCTL
, reg_ctl
);
1700 ixgbe_reset(adapter
);
1702 ixgbe_free_tx_resources(&adapter
->test_tx_ring
);
1703 ixgbe_free_rx_resources(&adapter
->test_rx_ring
);
1706 static int ixgbe_setup_desc_rings(struct ixgbe_adapter
*adapter
)
1708 struct ixgbe_ring
*tx_ring
= &adapter
->test_tx_ring
;
1709 struct ixgbe_ring
*rx_ring
= &adapter
->test_rx_ring
;
1710 struct ixgbe_hw
*hw
= &adapter
->hw
;
1715 /* Setup Tx descriptor ring and Tx buffers */
1716 tx_ring
->count
= IXGBE_DEFAULT_TXD
;
1717 tx_ring
->queue_index
= 0;
1718 tx_ring
->dev
= &adapter
->pdev
->dev
;
1719 tx_ring
->netdev
= adapter
->netdev
;
1720 tx_ring
->reg_idx
= adapter
->tx_ring
[0]->reg_idx
;
1722 err
= ixgbe_setup_tx_resources(tx_ring
);
1726 switch (adapter
->hw
.mac
.type
) {
1727 case ixgbe_mac_82599EB
:
1728 case ixgbe_mac_X540
:
1729 case ixgbe_mac_X550
:
1730 case ixgbe_mac_X550EM_x
:
1731 case ixgbe_mac_x550em_a
:
1732 reg_data
= IXGBE_READ_REG(&adapter
->hw
, IXGBE_DMATXCTL
);
1733 reg_data
|= IXGBE_DMATXCTL_TE
;
1734 IXGBE_WRITE_REG(&adapter
->hw
, IXGBE_DMATXCTL
, reg_data
);
1740 ixgbe_configure_tx_ring(adapter
, tx_ring
);
1742 /* Setup Rx Descriptor ring and Rx buffers */
1743 rx_ring
->count
= IXGBE_DEFAULT_RXD
;
1744 rx_ring
->queue_index
= 0;
1745 rx_ring
->dev
= &adapter
->pdev
->dev
;
1746 rx_ring
->netdev
= adapter
->netdev
;
1747 rx_ring
->reg_idx
= adapter
->rx_ring
[0]->reg_idx
;
1749 err
= ixgbe_setup_rx_resources(rx_ring
);
1755 hw
->mac
.ops
.disable_rx(hw
);
1757 ixgbe_configure_rx_ring(adapter
, rx_ring
);
1759 rctl
= IXGBE_READ_REG(&adapter
->hw
, IXGBE_RXCTRL
);
1760 rctl
|= IXGBE_RXCTRL_DMBYPS
;
1761 IXGBE_WRITE_REG(&adapter
->hw
, IXGBE_RXCTRL
, rctl
);
1763 hw
->mac
.ops
.enable_rx(hw
);
1768 ixgbe_free_desc_rings(adapter
);
1772 static int ixgbe_setup_loopback_test(struct ixgbe_adapter
*adapter
)
1774 struct ixgbe_hw
*hw
= &adapter
->hw
;
1778 /* Setup MAC loopback */
1779 reg_data
= IXGBE_READ_REG(hw
, IXGBE_HLREG0
);
1780 reg_data
|= IXGBE_HLREG0_LPBK
;
1781 IXGBE_WRITE_REG(hw
, IXGBE_HLREG0
, reg_data
);
1783 reg_data
= IXGBE_READ_REG(hw
, IXGBE_FCTRL
);
1784 reg_data
|= IXGBE_FCTRL_BAM
| IXGBE_FCTRL_SBP
| IXGBE_FCTRL_MPE
;
1785 IXGBE_WRITE_REG(hw
, IXGBE_FCTRL
, reg_data
);
1787 /* X540 and X550 needs to set the MACC.FLU bit to force link up */
1788 switch (adapter
->hw
.mac
.type
) {
1789 case ixgbe_mac_X540
:
1790 case ixgbe_mac_X550
:
1791 case ixgbe_mac_X550EM_x
:
1792 case ixgbe_mac_x550em_a
:
1793 reg_data
= IXGBE_READ_REG(hw
, IXGBE_MACC
);
1794 reg_data
|= IXGBE_MACC_FLU
;
1795 IXGBE_WRITE_REG(hw
, IXGBE_MACC
, reg_data
);
1798 if (hw
->mac
.orig_autoc
) {
1799 reg_data
= hw
->mac
.orig_autoc
| IXGBE_AUTOC_FLU
;
1800 IXGBE_WRITE_REG(hw
, IXGBE_AUTOC
, reg_data
);
1805 IXGBE_WRITE_FLUSH(hw
);
1806 usleep_range(10000, 20000);
1808 /* Disable Atlas Tx lanes; re-enabled in reset path */
1809 if (hw
->mac
.type
== ixgbe_mac_82598EB
) {
1812 hw
->mac
.ops
.read_analog_reg8(hw
, IXGBE_ATLAS_PDN_LPBK
, &atlas
);
1813 atlas
|= IXGBE_ATLAS_PDN_TX_REG_EN
;
1814 hw
->mac
.ops
.write_analog_reg8(hw
, IXGBE_ATLAS_PDN_LPBK
, atlas
);
1816 hw
->mac
.ops
.read_analog_reg8(hw
, IXGBE_ATLAS_PDN_10G
, &atlas
);
1817 atlas
|= IXGBE_ATLAS_PDN_TX_10G_QL_ALL
;
1818 hw
->mac
.ops
.write_analog_reg8(hw
, IXGBE_ATLAS_PDN_10G
, atlas
);
1820 hw
->mac
.ops
.read_analog_reg8(hw
, IXGBE_ATLAS_PDN_1G
, &atlas
);
1821 atlas
|= IXGBE_ATLAS_PDN_TX_1G_QL_ALL
;
1822 hw
->mac
.ops
.write_analog_reg8(hw
, IXGBE_ATLAS_PDN_1G
, atlas
);
1824 hw
->mac
.ops
.read_analog_reg8(hw
, IXGBE_ATLAS_PDN_AN
, &atlas
);
1825 atlas
|= IXGBE_ATLAS_PDN_TX_AN_QL_ALL
;
1826 hw
->mac
.ops
.write_analog_reg8(hw
, IXGBE_ATLAS_PDN_AN
, atlas
);
1832 static void ixgbe_loopback_cleanup(struct ixgbe_adapter
*adapter
)
1836 reg_data
= IXGBE_READ_REG(&adapter
->hw
, IXGBE_HLREG0
);
1837 reg_data
&= ~IXGBE_HLREG0_LPBK
;
1838 IXGBE_WRITE_REG(&adapter
->hw
, IXGBE_HLREG0
, reg_data
);
1841 static void ixgbe_create_lbtest_frame(struct sk_buff
*skb
,
1842 unsigned int frame_size
)
1844 memset(skb
->data
, 0xFF, frame_size
);
1846 memset(&skb
->data
[frame_size
], 0xAA, frame_size
/ 2 - 1);
1847 memset(&skb
->data
[frame_size
+ 10], 0xBE, 1);
1848 memset(&skb
->data
[frame_size
+ 12], 0xAF, 1);
1851 static bool ixgbe_check_lbtest_frame(struct ixgbe_rx_buffer
*rx_buffer
,
1852 unsigned int frame_size
)
1854 unsigned char *data
;
1859 data
= kmap(rx_buffer
->page
) + rx_buffer
->page_offset
;
1861 if (data
[3] != 0xFF ||
1862 data
[frame_size
+ 10] != 0xBE ||
1863 data
[frame_size
+ 12] != 0xAF)
1866 kunmap(rx_buffer
->page
);
1871 static u16
ixgbe_clean_test_rings(struct ixgbe_ring
*rx_ring
,
1872 struct ixgbe_ring
*tx_ring
,
1875 union ixgbe_adv_rx_desc
*rx_desc
;
1876 struct ixgbe_rx_buffer
*rx_buffer
;
1877 struct ixgbe_tx_buffer
*tx_buffer
;
1878 u16 rx_ntc
, tx_ntc
, count
= 0;
1880 /* initialize next to clean and descriptor values */
1881 rx_ntc
= rx_ring
->next_to_clean
;
1882 tx_ntc
= tx_ring
->next_to_clean
;
1883 rx_desc
= IXGBE_RX_DESC(rx_ring
, rx_ntc
);
1885 while (rx_desc
->wb
.upper
.length
) {
1886 /* check Rx buffer */
1887 rx_buffer
= &rx_ring
->rx_buffer_info
[rx_ntc
];
1889 /* sync Rx buffer for CPU read */
1890 dma_sync_single_for_cpu(rx_ring
->dev
,
1892 ixgbe_rx_bufsz(rx_ring
),
1895 /* verify contents of skb */
1896 if (ixgbe_check_lbtest_frame(rx_buffer
, size
))
1899 /* sync Rx buffer for device write */
1900 dma_sync_single_for_device(rx_ring
->dev
,
1902 ixgbe_rx_bufsz(rx_ring
),
1905 /* unmap buffer on Tx side */
1906 tx_buffer
= &tx_ring
->tx_buffer_info
[tx_ntc
];
1908 /* Free all the Tx ring sk_buffs */
1909 dev_kfree_skb_any(tx_buffer
->skb
);
1911 /* unmap skb header data */
1912 dma_unmap_single(tx_ring
->dev
,
1913 dma_unmap_addr(tx_buffer
, dma
),
1914 dma_unmap_len(tx_buffer
, len
),
1916 dma_unmap_len_set(tx_buffer
, len
, 0);
1918 /* increment Rx/Tx next to clean counters */
1920 if (rx_ntc
== rx_ring
->count
)
1923 if (tx_ntc
== tx_ring
->count
)
1926 /* fetch next descriptor */
1927 rx_desc
= IXGBE_RX_DESC(rx_ring
, rx_ntc
);
1930 netdev_tx_reset_queue(txring_txq(tx_ring
));
1932 /* re-map buffers to ring, store next to clean values */
1933 ixgbe_alloc_rx_buffers(rx_ring
, count
);
1934 rx_ring
->next_to_clean
= rx_ntc
;
1935 tx_ring
->next_to_clean
= tx_ntc
;
1940 static int ixgbe_run_loopback_test(struct ixgbe_adapter
*adapter
)
1942 struct ixgbe_ring
*tx_ring
= &adapter
->test_tx_ring
;
1943 struct ixgbe_ring
*rx_ring
= &adapter
->test_rx_ring
;
1944 int i
, j
, lc
, good_cnt
, ret_val
= 0;
1945 unsigned int size
= 1024;
1946 netdev_tx_t tx_ret_val
;
1947 struct sk_buff
*skb
;
1948 u32 flags_orig
= adapter
->flags
;
1950 /* DCB can modify the frames on Tx */
1951 adapter
->flags
&= ~IXGBE_FLAG_DCB_ENABLED
;
1953 /* allocate test skb */
1954 skb
= alloc_skb(size
, GFP_KERNEL
);
1958 /* place data into test skb */
1959 ixgbe_create_lbtest_frame(skb
, size
);
1963 * Calculate the loop count based on the largest descriptor ring
1964 * The idea is to wrap the largest ring a number of times using 64
1965 * send/receive pairs during each loop
1968 if (rx_ring
->count
<= tx_ring
->count
)
1969 lc
= ((tx_ring
->count
/ 64) * 2) + 1;
1971 lc
= ((rx_ring
->count
/ 64) * 2) + 1;
1973 for (j
= 0; j
<= lc
; j
++) {
1974 /* reset count of good packets */
1977 /* place 64 packets on the transmit queue*/
1978 for (i
= 0; i
< 64; i
++) {
1980 tx_ret_val
= ixgbe_xmit_frame_ring(skb
,
1983 if (tx_ret_val
== NETDEV_TX_OK
)
1987 if (good_cnt
!= 64) {
1992 /* allow 200 milliseconds for packets to go from Tx to Rx */
1995 good_cnt
= ixgbe_clean_test_rings(rx_ring
, tx_ring
, size
);
1996 if (good_cnt
!= 64) {
2002 /* free the original skb */
2004 adapter
->flags
= flags_orig
;
2009 static int ixgbe_loopback_test(struct ixgbe_adapter
*adapter
, u64
*data
)
2011 *data
= ixgbe_setup_desc_rings(adapter
);
2014 *data
= ixgbe_setup_loopback_test(adapter
);
2017 *data
= ixgbe_run_loopback_test(adapter
);
2018 ixgbe_loopback_cleanup(adapter
);
2021 ixgbe_free_desc_rings(adapter
);
2026 static void ixgbe_diag_test(struct net_device
*netdev
,
2027 struct ethtool_test
*eth_test
, u64
*data
)
2029 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
2030 bool if_running
= netif_running(netdev
);
2032 if (ixgbe_removed(adapter
->hw
.hw_addr
)) {
2033 e_err(hw
, "Adapter removed - test blocked\n");
2039 eth_test
->flags
|= ETH_TEST_FL_FAILED
;
2042 set_bit(__IXGBE_TESTING
, &adapter
->state
);
2043 if (eth_test
->flags
== ETH_TEST_FL_OFFLINE
) {
2044 struct ixgbe_hw
*hw
= &adapter
->hw
;
2046 if (adapter
->flags
& IXGBE_FLAG_SRIOV_ENABLED
) {
2048 for (i
= 0; i
< adapter
->num_vfs
; i
++) {
2049 if (adapter
->vfinfo
[i
].clear_to_send
) {
2050 netdev_warn(netdev
, "offline diagnostic is not supported when VFs are present\n");
2056 eth_test
->flags
|= ETH_TEST_FL_FAILED
;
2057 clear_bit(__IXGBE_TESTING
,
2065 e_info(hw
, "offline testing starting\n");
2067 /* Link test performed before hardware reset so autoneg doesn't
2068 * interfere with test result
2070 if (ixgbe_link_test(adapter
, &data
[4]))
2071 eth_test
->flags
|= ETH_TEST_FL_FAILED
;
2074 /* indicate we're in test mode */
2075 ixgbe_close(netdev
);
2077 ixgbe_reset(adapter
);
2079 e_info(hw
, "register testing starting\n");
2080 if (ixgbe_reg_test(adapter
, &data
[0]))
2081 eth_test
->flags
|= ETH_TEST_FL_FAILED
;
2083 ixgbe_reset(adapter
);
2084 e_info(hw
, "eeprom testing starting\n");
2085 if (ixgbe_eeprom_test(adapter
, &data
[1]))
2086 eth_test
->flags
|= ETH_TEST_FL_FAILED
;
2088 ixgbe_reset(adapter
);
2089 e_info(hw
, "interrupt testing starting\n");
2090 if (ixgbe_intr_test(adapter
, &data
[2]))
2091 eth_test
->flags
|= ETH_TEST_FL_FAILED
;
2093 /* If SRIOV or VMDq is enabled then skip MAC
2094 * loopback diagnostic. */
2095 if (adapter
->flags
& (IXGBE_FLAG_SRIOV_ENABLED
|
2096 IXGBE_FLAG_VMDQ_ENABLED
)) {
2097 e_info(hw
, "Skip MAC loopback diagnostic in VT mode\n");
2102 ixgbe_reset(adapter
);
2103 e_info(hw
, "loopback testing starting\n");
2104 if (ixgbe_loopback_test(adapter
, &data
[3]))
2105 eth_test
->flags
|= ETH_TEST_FL_FAILED
;
2108 ixgbe_reset(adapter
);
2110 /* clear testing bit and return adapter to previous state */
2111 clear_bit(__IXGBE_TESTING
, &adapter
->state
);
2114 else if (hw
->mac
.ops
.disable_tx_laser
)
2115 hw
->mac
.ops
.disable_tx_laser(hw
);
2117 e_info(hw
, "online testing starting\n");
2120 if (ixgbe_link_test(adapter
, &data
[4]))
2121 eth_test
->flags
|= ETH_TEST_FL_FAILED
;
2123 /* Offline tests aren't run; pass by default */
2129 clear_bit(__IXGBE_TESTING
, &adapter
->state
);
2133 msleep_interruptible(4 * 1000);
2136 static int ixgbe_wol_exclusion(struct ixgbe_adapter
*adapter
,
2137 struct ethtool_wolinfo
*wol
)
2139 struct ixgbe_hw
*hw
= &adapter
->hw
;
2142 /* WOL not supported for all devices */
2143 if (!ixgbe_wol_supported(adapter
, hw
->device_id
,
2144 hw
->subsystem_device_id
)) {
2152 static void ixgbe_get_wol(struct net_device
*netdev
,
2153 struct ethtool_wolinfo
*wol
)
2155 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
2157 wol
->supported
= WAKE_UCAST
| WAKE_MCAST
|
2158 WAKE_BCAST
| WAKE_MAGIC
;
2161 if (ixgbe_wol_exclusion(adapter
, wol
) ||
2162 !device_can_wakeup(&adapter
->pdev
->dev
))
2165 if (adapter
->wol
& IXGBE_WUFC_EX
)
2166 wol
->wolopts
|= WAKE_UCAST
;
2167 if (adapter
->wol
& IXGBE_WUFC_MC
)
2168 wol
->wolopts
|= WAKE_MCAST
;
2169 if (adapter
->wol
& IXGBE_WUFC_BC
)
2170 wol
->wolopts
|= WAKE_BCAST
;
2171 if (adapter
->wol
& IXGBE_WUFC_MAG
)
2172 wol
->wolopts
|= WAKE_MAGIC
;
2175 static int ixgbe_set_wol(struct net_device
*netdev
, struct ethtool_wolinfo
*wol
)
2177 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
2179 if (wol
->wolopts
& (WAKE_PHY
| WAKE_ARP
| WAKE_MAGICSECURE
))
2182 if (ixgbe_wol_exclusion(adapter
, wol
))
2183 return wol
->wolopts
? -EOPNOTSUPP
: 0;
2187 if (wol
->wolopts
& WAKE_UCAST
)
2188 adapter
->wol
|= IXGBE_WUFC_EX
;
2189 if (wol
->wolopts
& WAKE_MCAST
)
2190 adapter
->wol
|= IXGBE_WUFC_MC
;
2191 if (wol
->wolopts
& WAKE_BCAST
)
2192 adapter
->wol
|= IXGBE_WUFC_BC
;
2193 if (wol
->wolopts
& WAKE_MAGIC
)
2194 adapter
->wol
|= IXGBE_WUFC_MAG
;
2196 device_set_wakeup_enable(&adapter
->pdev
->dev
, adapter
->wol
);
2201 static int ixgbe_nway_reset(struct net_device
*netdev
)
2203 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
2205 if (netif_running(netdev
))
2206 ixgbe_reinit_locked(adapter
);
2211 static int ixgbe_set_phys_id(struct net_device
*netdev
,
2212 enum ethtool_phys_id_state state
)
2214 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
2215 struct ixgbe_hw
*hw
= &adapter
->hw
;
2218 case ETHTOOL_ID_ACTIVE
:
2219 adapter
->led_reg
= IXGBE_READ_REG(hw
, IXGBE_LEDCTL
);
2223 hw
->mac
.ops
.led_on(hw
, hw
->mac
.led_link_act
);
2226 case ETHTOOL_ID_OFF
:
2227 hw
->mac
.ops
.led_off(hw
, hw
->mac
.led_link_act
);
2230 case ETHTOOL_ID_INACTIVE
:
2231 /* Restore LED settings */
2232 IXGBE_WRITE_REG(&adapter
->hw
, IXGBE_LEDCTL
, adapter
->led_reg
);
2239 static int ixgbe_get_coalesce(struct net_device
*netdev
,
2240 struct ethtool_coalesce
*ec
)
2242 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
2244 /* only valid if in constant ITR mode */
2245 if (adapter
->rx_itr_setting
<= 1)
2246 ec
->rx_coalesce_usecs
= adapter
->rx_itr_setting
;
2248 ec
->rx_coalesce_usecs
= adapter
->rx_itr_setting
>> 2;
2250 /* if in mixed tx/rx queues per vector mode, report only rx settings */
2251 if (adapter
->q_vector
[0]->tx
.count
&& adapter
->q_vector
[0]->rx
.count
)
2254 /* only valid if in constant ITR mode */
2255 if (adapter
->tx_itr_setting
<= 1)
2256 ec
->tx_coalesce_usecs
= adapter
->tx_itr_setting
;
2258 ec
->tx_coalesce_usecs
= adapter
->tx_itr_setting
>> 2;
2264 * this function must be called before setting the new value of
2267 static bool ixgbe_update_rsc(struct ixgbe_adapter
*adapter
)
2269 struct net_device
*netdev
= adapter
->netdev
;
2271 /* nothing to do if LRO or RSC are not enabled */
2272 if (!(adapter
->flags2
& IXGBE_FLAG2_RSC_CAPABLE
) ||
2273 !(netdev
->features
& NETIF_F_LRO
))
2276 /* check the feature flag value and enable RSC if necessary */
2277 if (adapter
->rx_itr_setting
== 1 ||
2278 adapter
->rx_itr_setting
> IXGBE_MIN_RSC_ITR
) {
2279 if (!(adapter
->flags2
& IXGBE_FLAG2_RSC_ENABLED
)) {
2280 adapter
->flags2
|= IXGBE_FLAG2_RSC_ENABLED
;
2281 e_info(probe
, "rx-usecs value high enough to re-enable RSC\n");
2284 /* if interrupt rate is too high then disable RSC */
2285 } else if (adapter
->flags2
& IXGBE_FLAG2_RSC_ENABLED
) {
2286 adapter
->flags2
&= ~IXGBE_FLAG2_RSC_ENABLED
;
2287 e_info(probe
, "rx-usecs set too low, disabling RSC\n");
2293 static int ixgbe_set_coalesce(struct net_device
*netdev
,
2294 struct ethtool_coalesce
*ec
)
2296 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
2297 struct ixgbe_q_vector
*q_vector
;
2299 u16 tx_itr_param
, rx_itr_param
, tx_itr_prev
;
2300 bool need_reset
= false;
2302 if (adapter
->q_vector
[0]->tx
.count
&& adapter
->q_vector
[0]->rx
.count
) {
2303 /* reject Tx specific changes in case of mixed RxTx vectors */
2304 if (ec
->tx_coalesce_usecs
)
2306 tx_itr_prev
= adapter
->rx_itr_setting
;
2308 tx_itr_prev
= adapter
->tx_itr_setting
;
2311 if ((ec
->rx_coalesce_usecs
> (IXGBE_MAX_EITR
>> 2)) ||
2312 (ec
->tx_coalesce_usecs
> (IXGBE_MAX_EITR
>> 2)))
2315 if (ec
->rx_coalesce_usecs
> 1)
2316 adapter
->rx_itr_setting
= ec
->rx_coalesce_usecs
<< 2;
2318 adapter
->rx_itr_setting
= ec
->rx_coalesce_usecs
;
2320 if (adapter
->rx_itr_setting
== 1)
2321 rx_itr_param
= IXGBE_20K_ITR
;
2323 rx_itr_param
= adapter
->rx_itr_setting
;
2325 if (ec
->tx_coalesce_usecs
> 1)
2326 adapter
->tx_itr_setting
= ec
->tx_coalesce_usecs
<< 2;
2328 adapter
->tx_itr_setting
= ec
->tx_coalesce_usecs
;
2330 if (adapter
->tx_itr_setting
== 1)
2331 tx_itr_param
= IXGBE_12K_ITR
;
2333 tx_itr_param
= adapter
->tx_itr_setting
;
2336 if (adapter
->q_vector
[0]->tx
.count
&& adapter
->q_vector
[0]->rx
.count
)
2337 adapter
->tx_itr_setting
= adapter
->rx_itr_setting
;
2339 /* detect ITR changes that require update of TXDCTL.WTHRESH */
2340 if ((adapter
->tx_itr_setting
!= 1) &&
2341 (adapter
->tx_itr_setting
< IXGBE_100K_ITR
)) {
2342 if ((tx_itr_prev
== 1) ||
2343 (tx_itr_prev
>= IXGBE_100K_ITR
))
2346 if ((tx_itr_prev
!= 1) &&
2347 (tx_itr_prev
< IXGBE_100K_ITR
))
2351 /* check the old value and enable RSC if necessary */
2352 need_reset
|= ixgbe_update_rsc(adapter
);
2354 for (i
= 0; i
< adapter
->num_q_vectors
; i
++) {
2355 q_vector
= adapter
->q_vector
[i
];
2356 if (q_vector
->tx
.count
&& !q_vector
->rx
.count
)
2358 q_vector
->itr
= tx_itr_param
;
2360 /* rx only or mixed */
2361 q_vector
->itr
= rx_itr_param
;
2362 ixgbe_write_eitr(q_vector
);
2366 * do reset here at the end to make sure EITR==0 case is handled
2367 * correctly w.r.t stopping tx, and changing TXDCTL.WTHRESH settings
2368 * also locks in RSC enable/disable which requires reset
2371 ixgbe_do_reset(netdev
);
2376 static int ixgbe_get_ethtool_fdir_entry(struct ixgbe_adapter
*adapter
,
2377 struct ethtool_rxnfc
*cmd
)
2379 union ixgbe_atr_input
*mask
= &adapter
->fdir_mask
;
2380 struct ethtool_rx_flow_spec
*fsp
=
2381 (struct ethtool_rx_flow_spec
*)&cmd
->fs
;
2382 struct hlist_node
*node2
;
2383 struct ixgbe_fdir_filter
*rule
= NULL
;
2385 /* report total rule count */
2386 cmd
->data
= (1024 << adapter
->fdir_pballoc
) - 2;
2388 hlist_for_each_entry_safe(rule
, node2
,
2389 &adapter
->fdir_filter_list
, fdir_node
) {
2390 if (fsp
->location
<= rule
->sw_idx
)
2394 if (!rule
|| fsp
->location
!= rule
->sw_idx
)
2397 /* fill out the flow spec entry */
2399 /* set flow type field */
2400 switch (rule
->filter
.formatted
.flow_type
) {
2401 case IXGBE_ATR_FLOW_TYPE_TCPV4
:
2402 fsp
->flow_type
= TCP_V4_FLOW
;
2404 case IXGBE_ATR_FLOW_TYPE_UDPV4
:
2405 fsp
->flow_type
= UDP_V4_FLOW
;
2407 case IXGBE_ATR_FLOW_TYPE_SCTPV4
:
2408 fsp
->flow_type
= SCTP_V4_FLOW
;
2410 case IXGBE_ATR_FLOW_TYPE_IPV4
:
2411 fsp
->flow_type
= IP_USER_FLOW
;
2412 fsp
->h_u
.usr_ip4_spec
.ip_ver
= ETH_RX_NFC_IP4
;
2413 fsp
->h_u
.usr_ip4_spec
.proto
= 0;
2414 fsp
->m_u
.usr_ip4_spec
.proto
= 0;
2420 fsp
->h_u
.tcp_ip4_spec
.psrc
= rule
->filter
.formatted
.src_port
;
2421 fsp
->m_u
.tcp_ip4_spec
.psrc
= mask
->formatted
.src_port
;
2422 fsp
->h_u
.tcp_ip4_spec
.pdst
= rule
->filter
.formatted
.dst_port
;
2423 fsp
->m_u
.tcp_ip4_spec
.pdst
= mask
->formatted
.dst_port
;
2424 fsp
->h_u
.tcp_ip4_spec
.ip4src
= rule
->filter
.formatted
.src_ip
[0];
2425 fsp
->m_u
.tcp_ip4_spec
.ip4src
= mask
->formatted
.src_ip
[0];
2426 fsp
->h_u
.tcp_ip4_spec
.ip4dst
= rule
->filter
.formatted
.dst_ip
[0];
2427 fsp
->m_u
.tcp_ip4_spec
.ip4dst
= mask
->formatted
.dst_ip
[0];
2428 fsp
->h_ext
.vlan_tci
= rule
->filter
.formatted
.vlan_id
;
2429 fsp
->m_ext
.vlan_tci
= mask
->formatted
.vlan_id
;
2430 fsp
->h_ext
.vlan_etype
= rule
->filter
.formatted
.flex_bytes
;
2431 fsp
->m_ext
.vlan_etype
= mask
->formatted
.flex_bytes
;
2432 fsp
->h_ext
.data
[1] = htonl(rule
->filter
.formatted
.vm_pool
);
2433 fsp
->m_ext
.data
[1] = htonl(mask
->formatted
.vm_pool
);
2434 fsp
->flow_type
|= FLOW_EXT
;
2437 if (rule
->action
== IXGBE_FDIR_DROP_QUEUE
)
2438 fsp
->ring_cookie
= RX_CLS_FLOW_DISC
;
2440 fsp
->ring_cookie
= rule
->action
;
2445 static int ixgbe_get_ethtool_fdir_all(struct ixgbe_adapter
*adapter
,
2446 struct ethtool_rxnfc
*cmd
,
2449 struct hlist_node
*node2
;
2450 struct ixgbe_fdir_filter
*rule
;
2453 /* report total rule count */
2454 cmd
->data
= (1024 << adapter
->fdir_pballoc
) - 2;
2456 hlist_for_each_entry_safe(rule
, node2
,
2457 &adapter
->fdir_filter_list
, fdir_node
) {
2458 if (cnt
== cmd
->rule_cnt
)
2460 rule_locs
[cnt
] = rule
->sw_idx
;
2464 cmd
->rule_cnt
= cnt
;
2469 static int ixgbe_get_rss_hash_opts(struct ixgbe_adapter
*adapter
,
2470 struct ethtool_rxnfc
*cmd
)
2474 /* Report default options for RSS on ixgbe */
2475 switch (cmd
->flow_type
) {
2477 cmd
->data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
2480 if (adapter
->flags2
& IXGBE_FLAG2_RSS_FIELD_IPV4_UDP
)
2481 cmd
->data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
2484 case AH_ESP_V4_FLOW
:
2488 cmd
->data
|= RXH_IP_SRC
| RXH_IP_DST
;
2491 cmd
->data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
2494 if (adapter
->flags2
& IXGBE_FLAG2_RSS_FIELD_IPV6_UDP
)
2495 cmd
->data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
2498 case AH_ESP_V6_FLOW
:
2502 cmd
->data
|= RXH_IP_SRC
| RXH_IP_DST
;
2511 static int ixgbe_get_rxnfc(struct net_device
*dev
, struct ethtool_rxnfc
*cmd
,
2514 struct ixgbe_adapter
*adapter
= netdev_priv(dev
);
2515 int ret
= -EOPNOTSUPP
;
2518 case ETHTOOL_GRXRINGS
:
2519 cmd
->data
= adapter
->num_rx_queues
;
2522 case ETHTOOL_GRXCLSRLCNT
:
2523 cmd
->rule_cnt
= adapter
->fdir_filter_count
;
2526 case ETHTOOL_GRXCLSRULE
:
2527 ret
= ixgbe_get_ethtool_fdir_entry(adapter
, cmd
);
2529 case ETHTOOL_GRXCLSRLALL
:
2530 ret
= ixgbe_get_ethtool_fdir_all(adapter
, cmd
, rule_locs
);
2533 ret
= ixgbe_get_rss_hash_opts(adapter
, cmd
);
2542 int ixgbe_update_ethtool_fdir_entry(struct ixgbe_adapter
*adapter
,
2543 struct ixgbe_fdir_filter
*input
,
2546 struct ixgbe_hw
*hw
= &adapter
->hw
;
2547 struct hlist_node
*node2
;
2548 struct ixgbe_fdir_filter
*rule
, *parent
;
2554 hlist_for_each_entry_safe(rule
, node2
,
2555 &adapter
->fdir_filter_list
, fdir_node
) {
2556 /* hash found, or no matching entry */
2557 if (rule
->sw_idx
>= sw_idx
)
2562 /* if there is an old rule occupying our place remove it */
2563 if (rule
&& (rule
->sw_idx
== sw_idx
)) {
2564 if (!input
|| (rule
->filter
.formatted
.bkt_hash
!=
2565 input
->filter
.formatted
.bkt_hash
)) {
2566 err
= ixgbe_fdir_erase_perfect_filter_82599(hw
,
2571 hlist_del(&rule
->fdir_node
);
2573 adapter
->fdir_filter_count
--;
2577 * If no input this was a delete, err should be 0 if a rule was
2578 * successfully found and removed from the list else -EINVAL
2583 /* initialize node and set software index */
2584 INIT_HLIST_NODE(&input
->fdir_node
);
2586 /* add filter to the list */
2588 hlist_add_behind(&input
->fdir_node
, &parent
->fdir_node
);
2590 hlist_add_head(&input
->fdir_node
,
2591 &adapter
->fdir_filter_list
);
2594 adapter
->fdir_filter_count
++;
2599 static int ixgbe_flowspec_to_flow_type(struct ethtool_rx_flow_spec
*fsp
,
2602 switch (fsp
->flow_type
& ~FLOW_EXT
) {
2604 *flow_type
= IXGBE_ATR_FLOW_TYPE_TCPV4
;
2607 *flow_type
= IXGBE_ATR_FLOW_TYPE_UDPV4
;
2610 *flow_type
= IXGBE_ATR_FLOW_TYPE_SCTPV4
;
2613 switch (fsp
->h_u
.usr_ip4_spec
.proto
) {
2615 *flow_type
= IXGBE_ATR_FLOW_TYPE_TCPV4
;
2618 *flow_type
= IXGBE_ATR_FLOW_TYPE_UDPV4
;
2621 *flow_type
= IXGBE_ATR_FLOW_TYPE_SCTPV4
;
2624 if (!fsp
->m_u
.usr_ip4_spec
.proto
) {
2625 *flow_type
= IXGBE_ATR_FLOW_TYPE_IPV4
;
2639 static int ixgbe_add_ethtool_fdir_entry(struct ixgbe_adapter
*adapter
,
2640 struct ethtool_rxnfc
*cmd
)
2642 struct ethtool_rx_flow_spec
*fsp
=
2643 (struct ethtool_rx_flow_spec
*)&cmd
->fs
;
2644 struct ixgbe_hw
*hw
= &adapter
->hw
;
2645 struct ixgbe_fdir_filter
*input
;
2646 union ixgbe_atr_input mask
;
2650 if (!(adapter
->flags
& IXGBE_FLAG_FDIR_PERFECT_CAPABLE
))
2653 /* ring_cookie is a masked into a set of queues and ixgbe pools or
2654 * we use the drop index.
2656 if (fsp
->ring_cookie
== RX_CLS_FLOW_DISC
) {
2657 queue
= IXGBE_FDIR_DROP_QUEUE
;
2659 u32 ring
= ethtool_get_flow_spec_ring(fsp
->ring_cookie
);
2660 u8 vf
= ethtool_get_flow_spec_ring_vf(fsp
->ring_cookie
);
2662 if (!vf
&& (ring
>= adapter
->num_rx_queues
))
2665 ((vf
> adapter
->num_vfs
) ||
2666 ring
>= adapter
->num_rx_queues_per_pool
))
2669 /* Map the ring onto the absolute queue index */
2671 queue
= adapter
->rx_ring
[ring
]->reg_idx
;
2674 adapter
->num_rx_queues_per_pool
) + ring
;
2677 /* Don't allow indexes to exist outside of available space */
2678 if (fsp
->location
>= ((1024 << adapter
->fdir_pballoc
) - 2)) {
2679 e_err(drv
, "Location out of range\n");
2683 input
= kzalloc(sizeof(*input
), GFP_ATOMIC
);
2687 memset(&mask
, 0, sizeof(union ixgbe_atr_input
));
2690 input
->sw_idx
= fsp
->location
;
2692 /* record flow type */
2693 if (!ixgbe_flowspec_to_flow_type(fsp
,
2694 &input
->filter
.formatted
.flow_type
)) {
2695 e_err(drv
, "Unrecognized flow type\n");
2699 mask
.formatted
.flow_type
= IXGBE_ATR_L4TYPE_IPV6_MASK
|
2700 IXGBE_ATR_L4TYPE_MASK
;
2702 if (input
->filter
.formatted
.flow_type
== IXGBE_ATR_FLOW_TYPE_IPV4
)
2703 mask
.formatted
.flow_type
&= IXGBE_ATR_L4TYPE_IPV6_MASK
;
2705 /* Copy input into formatted structures */
2706 input
->filter
.formatted
.src_ip
[0] = fsp
->h_u
.tcp_ip4_spec
.ip4src
;
2707 mask
.formatted
.src_ip
[0] = fsp
->m_u
.tcp_ip4_spec
.ip4src
;
2708 input
->filter
.formatted
.dst_ip
[0] = fsp
->h_u
.tcp_ip4_spec
.ip4dst
;
2709 mask
.formatted
.dst_ip
[0] = fsp
->m_u
.tcp_ip4_spec
.ip4dst
;
2710 input
->filter
.formatted
.src_port
= fsp
->h_u
.tcp_ip4_spec
.psrc
;
2711 mask
.formatted
.src_port
= fsp
->m_u
.tcp_ip4_spec
.psrc
;
2712 input
->filter
.formatted
.dst_port
= fsp
->h_u
.tcp_ip4_spec
.pdst
;
2713 mask
.formatted
.dst_port
= fsp
->m_u
.tcp_ip4_spec
.pdst
;
2715 if (fsp
->flow_type
& FLOW_EXT
) {
2716 input
->filter
.formatted
.vm_pool
=
2717 (unsigned char)ntohl(fsp
->h_ext
.data
[1]);
2718 mask
.formatted
.vm_pool
=
2719 (unsigned char)ntohl(fsp
->m_ext
.data
[1]);
2720 input
->filter
.formatted
.vlan_id
= fsp
->h_ext
.vlan_tci
;
2721 mask
.formatted
.vlan_id
= fsp
->m_ext
.vlan_tci
;
2722 input
->filter
.formatted
.flex_bytes
=
2723 fsp
->h_ext
.vlan_etype
;
2724 mask
.formatted
.flex_bytes
= fsp
->m_ext
.vlan_etype
;
2727 /* determine if we need to drop or route the packet */
2728 if (fsp
->ring_cookie
== RX_CLS_FLOW_DISC
)
2729 input
->action
= IXGBE_FDIR_DROP_QUEUE
;
2731 input
->action
= fsp
->ring_cookie
;
2733 spin_lock(&adapter
->fdir_perfect_lock
);
2735 if (hlist_empty(&adapter
->fdir_filter_list
)) {
2736 /* save mask and program input mask into HW */
2737 memcpy(&adapter
->fdir_mask
, &mask
, sizeof(mask
));
2738 err
= ixgbe_fdir_set_input_mask_82599(hw
, &mask
);
2740 e_err(drv
, "Error writing mask\n");
2741 goto err_out_w_lock
;
2743 } else if (memcmp(&adapter
->fdir_mask
, &mask
, sizeof(mask
))) {
2744 e_err(drv
, "Only one mask supported per port\n");
2745 goto err_out_w_lock
;
2748 /* apply mask and compute/store hash */
2749 ixgbe_atr_compute_perfect_hash_82599(&input
->filter
, &mask
);
2751 /* program filters to filter memory */
2752 err
= ixgbe_fdir_write_perfect_filter_82599(hw
,
2753 &input
->filter
, input
->sw_idx
, queue
);
2755 goto err_out_w_lock
;
2757 ixgbe_update_ethtool_fdir_entry(adapter
, input
, input
->sw_idx
);
2759 spin_unlock(&adapter
->fdir_perfect_lock
);
2763 spin_unlock(&adapter
->fdir_perfect_lock
);
2769 static int ixgbe_del_ethtool_fdir_entry(struct ixgbe_adapter
*adapter
,
2770 struct ethtool_rxnfc
*cmd
)
2772 struct ethtool_rx_flow_spec
*fsp
=
2773 (struct ethtool_rx_flow_spec
*)&cmd
->fs
;
2776 spin_lock(&adapter
->fdir_perfect_lock
);
2777 err
= ixgbe_update_ethtool_fdir_entry(adapter
, NULL
, fsp
->location
);
2778 spin_unlock(&adapter
->fdir_perfect_lock
);
2783 #define UDP_RSS_FLAGS (IXGBE_FLAG2_RSS_FIELD_IPV4_UDP | \
2784 IXGBE_FLAG2_RSS_FIELD_IPV6_UDP)
2785 static int ixgbe_set_rss_hash_opt(struct ixgbe_adapter
*adapter
,
2786 struct ethtool_rxnfc
*nfc
)
2788 u32 flags2
= adapter
->flags2
;
2791 * RSS does not support anything other than hashing
2792 * to queues on src and dst IPs and ports
2794 if (nfc
->data
& ~(RXH_IP_SRC
| RXH_IP_DST
|
2795 RXH_L4_B_0_1
| RXH_L4_B_2_3
))
2798 switch (nfc
->flow_type
) {
2801 if (!(nfc
->data
& RXH_IP_SRC
) ||
2802 !(nfc
->data
& RXH_IP_DST
) ||
2803 !(nfc
->data
& RXH_L4_B_0_1
) ||
2804 !(nfc
->data
& RXH_L4_B_2_3
))
2808 if (!(nfc
->data
& RXH_IP_SRC
) ||
2809 !(nfc
->data
& RXH_IP_DST
))
2811 switch (nfc
->data
& (RXH_L4_B_0_1
| RXH_L4_B_2_3
)) {
2813 flags2
&= ~IXGBE_FLAG2_RSS_FIELD_IPV4_UDP
;
2815 case (RXH_L4_B_0_1
| RXH_L4_B_2_3
):
2816 flags2
|= IXGBE_FLAG2_RSS_FIELD_IPV4_UDP
;
2823 if (!(nfc
->data
& RXH_IP_SRC
) ||
2824 !(nfc
->data
& RXH_IP_DST
))
2826 switch (nfc
->data
& (RXH_L4_B_0_1
| RXH_L4_B_2_3
)) {
2828 flags2
&= ~IXGBE_FLAG2_RSS_FIELD_IPV6_UDP
;
2830 case (RXH_L4_B_0_1
| RXH_L4_B_2_3
):
2831 flags2
|= IXGBE_FLAG2_RSS_FIELD_IPV6_UDP
;
2837 case AH_ESP_V4_FLOW
:
2841 case AH_ESP_V6_FLOW
:
2845 if (!(nfc
->data
& RXH_IP_SRC
) ||
2846 !(nfc
->data
& RXH_IP_DST
) ||
2847 (nfc
->data
& RXH_L4_B_0_1
) ||
2848 (nfc
->data
& RXH_L4_B_2_3
))
2855 /* if we changed something we need to update flags */
2856 if (flags2
!= adapter
->flags2
) {
2857 struct ixgbe_hw
*hw
= &adapter
->hw
;
2859 unsigned int pf_pool
= adapter
->num_vfs
;
2861 if ((hw
->mac
.type
>= ixgbe_mac_X550
) &&
2862 (adapter
->flags
& IXGBE_FLAG_SRIOV_ENABLED
))
2863 mrqc
= IXGBE_READ_REG(hw
, IXGBE_PFVFMRQC(pf_pool
));
2865 mrqc
= IXGBE_READ_REG(hw
, IXGBE_MRQC
);
2867 if ((flags2
& UDP_RSS_FLAGS
) &&
2868 !(adapter
->flags2
& UDP_RSS_FLAGS
))
2869 e_warn(drv
, "enabling UDP RSS: fragmented packets may arrive out of order to the stack above\n");
2871 adapter
->flags2
= flags2
;
2873 /* Perform hash on these packet types */
2874 mrqc
|= IXGBE_MRQC_RSS_FIELD_IPV4
2875 | IXGBE_MRQC_RSS_FIELD_IPV4_TCP
2876 | IXGBE_MRQC_RSS_FIELD_IPV6
2877 | IXGBE_MRQC_RSS_FIELD_IPV6_TCP
;
2879 mrqc
&= ~(IXGBE_MRQC_RSS_FIELD_IPV4_UDP
|
2880 IXGBE_MRQC_RSS_FIELD_IPV6_UDP
);
2882 if (flags2
& IXGBE_FLAG2_RSS_FIELD_IPV4_UDP
)
2883 mrqc
|= IXGBE_MRQC_RSS_FIELD_IPV4_UDP
;
2885 if (flags2
& IXGBE_FLAG2_RSS_FIELD_IPV6_UDP
)
2886 mrqc
|= IXGBE_MRQC_RSS_FIELD_IPV6_UDP
;
2888 if ((hw
->mac
.type
>= ixgbe_mac_X550
) &&
2889 (adapter
->flags
& IXGBE_FLAG_SRIOV_ENABLED
))
2890 IXGBE_WRITE_REG(hw
, IXGBE_PFVFMRQC(pf_pool
), mrqc
);
2892 IXGBE_WRITE_REG(hw
, IXGBE_MRQC
, mrqc
);
2898 static int ixgbe_set_rxnfc(struct net_device
*dev
, struct ethtool_rxnfc
*cmd
)
2900 struct ixgbe_adapter
*adapter
= netdev_priv(dev
);
2901 int ret
= -EOPNOTSUPP
;
2904 case ETHTOOL_SRXCLSRLINS
:
2905 ret
= ixgbe_add_ethtool_fdir_entry(adapter
, cmd
);
2907 case ETHTOOL_SRXCLSRLDEL
:
2908 ret
= ixgbe_del_ethtool_fdir_entry(adapter
, cmd
);
2911 ret
= ixgbe_set_rss_hash_opt(adapter
, cmd
);
2920 static int ixgbe_rss_indir_tbl_max(struct ixgbe_adapter
*adapter
)
2922 if (adapter
->hw
.mac
.type
< ixgbe_mac_X550
)
2928 static u32
ixgbe_get_rxfh_key_size(struct net_device
*netdev
)
2930 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
2932 return sizeof(adapter
->rss_key
);
2935 static u32
ixgbe_rss_indir_size(struct net_device
*netdev
)
2937 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
2939 return ixgbe_rss_indir_tbl_entries(adapter
);
2942 static void ixgbe_get_reta(struct ixgbe_adapter
*adapter
, u32
*indir
)
2944 int i
, reta_size
= ixgbe_rss_indir_tbl_entries(adapter
);
2945 u16 rss_m
= adapter
->ring_feature
[RING_F_RSS
].mask
;
2947 if (adapter
->flags
& IXGBE_FLAG_SRIOV_ENABLED
)
2948 rss_m
= adapter
->ring_feature
[RING_F_RSS
].indices
- 1;
2950 for (i
= 0; i
< reta_size
; i
++)
2951 indir
[i
] = adapter
->rss_indir_tbl
[i
] & rss_m
;
2954 static int ixgbe_get_rxfh(struct net_device
*netdev
, u32
*indir
, u8
*key
,
2957 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
2960 *hfunc
= ETH_RSS_HASH_TOP
;
2963 ixgbe_get_reta(adapter
, indir
);
2966 memcpy(key
, adapter
->rss_key
, ixgbe_get_rxfh_key_size(netdev
));
2971 static int ixgbe_set_rxfh(struct net_device
*netdev
, const u32
*indir
,
2972 const u8
*key
, const u8 hfunc
)
2974 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
2976 u32 reta_entries
= ixgbe_rss_indir_tbl_entries(adapter
);
2981 /* Fill out the redirection table */
2983 int max_queues
= min_t(int, adapter
->num_rx_queues
,
2984 ixgbe_rss_indir_tbl_max(adapter
));
2986 /*Allow at least 2 queues w/ SR-IOV.*/
2987 if ((adapter
->flags
& IXGBE_FLAG_SRIOV_ENABLED
) &&
2991 /* Verify user input. */
2992 for (i
= 0; i
< reta_entries
; i
++)
2993 if (indir
[i
] >= max_queues
)
2996 for (i
= 0; i
< reta_entries
; i
++)
2997 adapter
->rss_indir_tbl
[i
] = indir
[i
];
3000 /* Fill out the rss hash key */
3002 memcpy(adapter
->rss_key
, key
, ixgbe_get_rxfh_key_size(netdev
));
3003 ixgbe_store_key(adapter
);
3006 ixgbe_store_reta(adapter
);
3011 static int ixgbe_get_ts_info(struct net_device
*dev
,
3012 struct ethtool_ts_info
*info
)
3014 struct ixgbe_adapter
*adapter
= netdev_priv(dev
);
3016 /* we always support timestamping disabled */
3017 info
->rx_filters
= BIT(HWTSTAMP_FILTER_NONE
);
3019 switch (adapter
->hw
.mac
.type
) {
3020 case ixgbe_mac_X550
:
3021 case ixgbe_mac_X550EM_x
:
3022 case ixgbe_mac_x550em_a
:
3023 info
->rx_filters
|= BIT(HWTSTAMP_FILTER_ALL
);
3025 case ixgbe_mac_X540
:
3026 case ixgbe_mac_82599EB
:
3027 info
->so_timestamping
=
3028 SOF_TIMESTAMPING_TX_SOFTWARE
|
3029 SOF_TIMESTAMPING_RX_SOFTWARE
|
3030 SOF_TIMESTAMPING_SOFTWARE
|
3031 SOF_TIMESTAMPING_TX_HARDWARE
|
3032 SOF_TIMESTAMPING_RX_HARDWARE
|
3033 SOF_TIMESTAMPING_RAW_HARDWARE
;
3035 if (adapter
->ptp_clock
)
3036 info
->phc_index
= ptp_clock_index(adapter
->ptp_clock
);
3038 info
->phc_index
= -1;
3041 BIT(HWTSTAMP_TX_OFF
) |
3042 BIT(HWTSTAMP_TX_ON
);
3045 BIT(HWTSTAMP_FILTER_PTP_V1_L4_SYNC
) |
3046 BIT(HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ
) |
3047 BIT(HWTSTAMP_FILTER_PTP_V2_EVENT
);
3050 return ethtool_op_get_ts_info(dev
, info
);
3055 static unsigned int ixgbe_max_channels(struct ixgbe_adapter
*adapter
)
3057 unsigned int max_combined
;
3058 u8 tcs
= netdev_get_num_tc(adapter
->netdev
);
3060 if (!(adapter
->flags
& IXGBE_FLAG_MSIX_ENABLED
)) {
3061 /* We only support one q_vector without MSI-X */
3063 } else if (adapter
->flags
& IXGBE_FLAG_SRIOV_ENABLED
) {
3064 /* Limit value based on the queue mask */
3065 max_combined
= adapter
->ring_feature
[RING_F_RSS
].mask
+ 1;
3066 } else if (tcs
> 1) {
3067 /* For DCB report channels per traffic class */
3068 if (adapter
->hw
.mac
.type
== ixgbe_mac_82598EB
) {
3069 /* 8 TC w/ 4 queues per TC */
3071 } else if (tcs
> 4) {
3072 /* 8 TC w/ 8 queues per TC */
3075 /* 4 TC w/ 16 queues per TC */
3078 } else if (adapter
->atr_sample_rate
) {
3079 /* support up to 64 queues with ATR */
3080 max_combined
= IXGBE_MAX_FDIR_INDICES
;
3082 /* support up to 16 queues with RSS */
3083 max_combined
= ixgbe_max_rss_indices(adapter
);
3086 return max_combined
;
3089 static void ixgbe_get_channels(struct net_device
*dev
,
3090 struct ethtool_channels
*ch
)
3092 struct ixgbe_adapter
*adapter
= netdev_priv(dev
);
3094 /* report maximum channels */
3095 ch
->max_combined
= ixgbe_max_channels(adapter
);
3097 /* report info for other vector */
3098 if (adapter
->flags
& IXGBE_FLAG_MSIX_ENABLED
) {
3099 ch
->max_other
= NON_Q_VECTORS
;
3100 ch
->other_count
= NON_Q_VECTORS
;
3103 /* record RSS queues */
3104 ch
->combined_count
= adapter
->ring_feature
[RING_F_RSS
].indices
;
3106 /* nothing else to report if RSS is disabled */
3107 if (ch
->combined_count
== 1)
3110 /* we do not support ATR queueing if SR-IOV is enabled */
3111 if (adapter
->flags
& IXGBE_FLAG_SRIOV_ENABLED
)
3114 /* same thing goes for being DCB enabled */
3115 if (netdev_get_num_tc(dev
) > 1)
3118 /* if ATR is disabled we can exit */
3119 if (!adapter
->atr_sample_rate
)
3122 /* report flow director queues as maximum channels */
3123 ch
->combined_count
= adapter
->ring_feature
[RING_F_FDIR
].indices
;
3126 static int ixgbe_set_channels(struct net_device
*dev
,
3127 struct ethtool_channels
*ch
)
3129 struct ixgbe_adapter
*adapter
= netdev_priv(dev
);
3130 unsigned int count
= ch
->combined_count
;
3131 u8 max_rss_indices
= ixgbe_max_rss_indices(adapter
);
3133 /* verify they are not requesting separate vectors */
3134 if (!count
|| ch
->rx_count
|| ch
->tx_count
)
3137 /* verify other_count has not changed */
3138 if (ch
->other_count
!= NON_Q_VECTORS
)
3141 /* verify the number of channels does not exceed hardware limits */
3142 if (count
> ixgbe_max_channels(adapter
))
3145 /* update feature limits from largest to smallest supported values */
3146 adapter
->ring_feature
[RING_F_FDIR
].limit
= count
;
3149 if (count
> max_rss_indices
)
3150 count
= max_rss_indices
;
3151 adapter
->ring_feature
[RING_F_RSS
].limit
= count
;
3154 /* cap FCoE limit at 8 */
3155 if (count
> IXGBE_FCRETA_SIZE
)
3156 count
= IXGBE_FCRETA_SIZE
;
3157 adapter
->ring_feature
[RING_F_FCOE
].limit
= count
;
3160 /* use setup TC to update any traffic class queue mapping */
3161 return ixgbe_setup_tc(dev
, netdev_get_num_tc(dev
));
3164 static int ixgbe_get_module_info(struct net_device
*dev
,
3165 struct ethtool_modinfo
*modinfo
)
3167 struct ixgbe_adapter
*adapter
= netdev_priv(dev
);
3168 struct ixgbe_hw
*hw
= &adapter
->hw
;
3170 u8 sff8472_rev
, addr_mode
;
3171 bool page_swap
= false;
3173 if (hw
->phy
.type
== ixgbe_phy_fw
)
3176 /* Check whether we support SFF-8472 or not */
3177 status
= hw
->phy
.ops
.read_i2c_eeprom(hw
,
3178 IXGBE_SFF_SFF_8472_COMP
,
3183 /* addressing mode is not supported */
3184 status
= hw
->phy
.ops
.read_i2c_eeprom(hw
,
3185 IXGBE_SFF_SFF_8472_SWAP
,
3190 if (addr_mode
& IXGBE_SFF_ADDRESSING_MODE
) {
3191 e_err(drv
, "Address change required to access page 0xA2, but not supported. Please report the module type to the driver maintainers.\n");
3195 if (sff8472_rev
== IXGBE_SFF_SFF_8472_UNSUP
|| page_swap
) {
3196 /* We have a SFP, but it does not support SFF-8472 */
3197 modinfo
->type
= ETH_MODULE_SFF_8079
;
3198 modinfo
->eeprom_len
= ETH_MODULE_SFF_8079_LEN
;
3200 /* We have a SFP which supports a revision of SFF-8472. */
3201 modinfo
->type
= ETH_MODULE_SFF_8472
;
3202 modinfo
->eeprom_len
= ETH_MODULE_SFF_8472_LEN
;
3208 static int ixgbe_get_module_eeprom(struct net_device
*dev
,
3209 struct ethtool_eeprom
*ee
,
3212 struct ixgbe_adapter
*adapter
= netdev_priv(dev
);
3213 struct ixgbe_hw
*hw
= &adapter
->hw
;
3214 s32 status
= IXGBE_ERR_PHY_ADDR_INVALID
;
3221 if (hw
->phy
.type
== ixgbe_phy_fw
)
3224 for (i
= ee
->offset
; i
< ee
->offset
+ ee
->len
; i
++) {
3225 /* I2C reads can take long time */
3226 if (test_bit(__IXGBE_IN_SFP_INIT
, &adapter
->state
))
3229 if (i
< ETH_MODULE_SFF_8079_LEN
)
3230 status
= hw
->phy
.ops
.read_i2c_eeprom(hw
, i
, &databyte
);
3232 status
= hw
->phy
.ops
.read_i2c_sff8472(hw
, i
, &databyte
);
3237 data
[i
- ee
->offset
] = databyte
;
3243 static const struct {
3244 ixgbe_link_speed mac_speed
;
3246 } ixgbe_ls_map
[] = {
3247 { IXGBE_LINK_SPEED_10_FULL
, SUPPORTED_10baseT_Full
},
3248 { IXGBE_LINK_SPEED_100_FULL
, SUPPORTED_100baseT_Full
},
3249 { IXGBE_LINK_SPEED_1GB_FULL
, SUPPORTED_1000baseT_Full
},
3250 { IXGBE_LINK_SPEED_2_5GB_FULL
, SUPPORTED_2500baseX_Full
},
3251 { IXGBE_LINK_SPEED_10GB_FULL
, SUPPORTED_10000baseT_Full
},
3254 static const struct {
3257 } ixgbe_lp_map
[] = {
3258 { FW_PHY_ACT_UD_2_100M_TX_EEE
, SUPPORTED_100baseT_Full
},
3259 { FW_PHY_ACT_UD_2_1G_T_EEE
, SUPPORTED_1000baseT_Full
},
3260 { FW_PHY_ACT_UD_2_10G_T_EEE
, SUPPORTED_10000baseT_Full
},
3261 { FW_PHY_ACT_UD_2_1G_KX_EEE
, SUPPORTED_1000baseKX_Full
},
3262 { FW_PHY_ACT_UD_2_10G_KX4_EEE
, SUPPORTED_10000baseKX4_Full
},
3263 { FW_PHY_ACT_UD_2_10G_KR_EEE
, SUPPORTED_10000baseKR_Full
},
3267 ixgbe_get_eee_fw(struct ixgbe_adapter
*adapter
, struct ethtool_eee
*edata
)
3269 u32 info
[FW_PHY_ACT_DATA_COUNT
] = { 0 };
3270 struct ixgbe_hw
*hw
= &adapter
->hw
;
3274 rc
= ixgbe_fw_phy_activity(hw
, FW_PHY_ACT_UD_2
, &info
);
3278 edata
->lp_advertised
= 0;
3279 for (i
= 0; i
< ARRAY_SIZE(ixgbe_lp_map
); ++i
) {
3280 if (info
[0] & ixgbe_lp_map
[i
].lp_advertised
)
3281 edata
->lp_advertised
|= ixgbe_lp_map
[i
].mac_speed
;
3284 edata
->supported
= 0;
3285 for (i
= 0; i
< ARRAY_SIZE(ixgbe_ls_map
); ++i
) {
3286 if (hw
->phy
.eee_speeds_supported
& ixgbe_ls_map
[i
].mac_speed
)
3287 edata
->supported
|= ixgbe_ls_map
[i
].supported
;
3290 edata
->advertised
= 0;
3291 for (i
= 0; i
< ARRAY_SIZE(ixgbe_ls_map
); ++i
) {
3292 if (hw
->phy
.eee_speeds_advertised
& ixgbe_ls_map
[i
].mac_speed
)
3293 edata
->advertised
|= ixgbe_ls_map
[i
].supported
;
3296 edata
->eee_enabled
= !!edata
->advertised
;
3297 edata
->tx_lpi_enabled
= edata
->eee_enabled
;
3298 if (edata
->advertised
& edata
->lp_advertised
)
3299 edata
->eee_active
= true;
3304 static int ixgbe_get_eee(struct net_device
*netdev
, struct ethtool_eee
*edata
)
3306 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
3307 struct ixgbe_hw
*hw
= &adapter
->hw
;
3309 if (!(adapter
->flags2
& IXGBE_FLAG2_EEE_CAPABLE
))
3312 if (hw
->phy
.eee_speeds_supported
&& hw
->phy
.type
== ixgbe_phy_fw
)
3313 return ixgbe_get_eee_fw(adapter
, edata
);
3318 static int ixgbe_set_eee(struct net_device
*netdev
, struct ethtool_eee
*edata
)
3320 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
3321 struct ixgbe_hw
*hw
= &adapter
->hw
;
3322 struct ethtool_eee eee_data
;
3325 if (!(adapter
->flags2
& IXGBE_FLAG2_EEE_CAPABLE
))
3328 memset(&eee_data
, 0, sizeof(struct ethtool_eee
));
3330 ret_val
= ixgbe_get_eee(netdev
, &eee_data
);
3334 if (eee_data
.eee_enabled
&& !edata
->eee_enabled
) {
3335 if (eee_data
.tx_lpi_enabled
!= edata
->tx_lpi_enabled
) {
3336 e_err(drv
, "Setting EEE tx-lpi is not supported\n");
3340 if (eee_data
.tx_lpi_timer
!= edata
->tx_lpi_timer
) {
3342 "Setting EEE Tx LPI timer is not supported\n");
3346 if (eee_data
.advertised
!= edata
->advertised
) {
3348 "Setting EEE advertised speeds is not supported\n");
3353 if (eee_data
.eee_enabled
!= edata
->eee_enabled
) {
3354 if (edata
->eee_enabled
) {
3355 adapter
->flags2
|= IXGBE_FLAG2_EEE_ENABLED
;
3356 hw
->phy
.eee_speeds_advertised
=
3357 hw
->phy
.eee_speeds_supported
;
3359 adapter
->flags2
&= ~IXGBE_FLAG2_EEE_ENABLED
;
3360 hw
->phy
.eee_speeds_advertised
= 0;
3364 if (netif_running(netdev
))
3365 ixgbe_reinit_locked(adapter
);
3367 ixgbe_reset(adapter
);
3373 static u32
ixgbe_get_priv_flags(struct net_device
*netdev
)
3375 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
3378 if (adapter
->flags2
& IXGBE_FLAG2_RX_LEGACY
)
3379 priv_flags
|= IXGBE_PRIV_FLAGS_LEGACY_RX
;
3384 static int ixgbe_set_priv_flags(struct net_device
*netdev
, u32 priv_flags
)
3386 struct ixgbe_adapter
*adapter
= netdev_priv(netdev
);
3387 unsigned int flags2
= adapter
->flags2
;
3389 flags2
&= ~IXGBE_FLAG2_RX_LEGACY
;
3390 if (priv_flags
& IXGBE_PRIV_FLAGS_LEGACY_RX
)
3391 flags2
|= IXGBE_FLAG2_RX_LEGACY
;
3393 if (flags2
!= adapter
->flags2
) {
3394 adapter
->flags2
= flags2
;
3396 /* reset interface to repopulate queues */
3397 if (netif_running(netdev
))
3398 ixgbe_reinit_locked(adapter
);
3404 static const struct ethtool_ops ixgbe_ethtool_ops
= {
3405 .get_settings
= ixgbe_get_settings
,
3406 .set_settings
= ixgbe_set_settings
,
3407 .get_drvinfo
= ixgbe_get_drvinfo
,
3408 .get_regs_len
= ixgbe_get_regs_len
,
3409 .get_regs
= ixgbe_get_regs
,
3410 .get_wol
= ixgbe_get_wol
,
3411 .set_wol
= ixgbe_set_wol
,
3412 .nway_reset
= ixgbe_nway_reset
,
3413 .get_link
= ethtool_op_get_link
,
3414 .get_eeprom_len
= ixgbe_get_eeprom_len
,
3415 .get_eeprom
= ixgbe_get_eeprom
,
3416 .set_eeprom
= ixgbe_set_eeprom
,
3417 .get_ringparam
= ixgbe_get_ringparam
,
3418 .set_ringparam
= ixgbe_set_ringparam
,
3419 .get_pauseparam
= ixgbe_get_pauseparam
,
3420 .set_pauseparam
= ixgbe_set_pauseparam
,
3421 .get_msglevel
= ixgbe_get_msglevel
,
3422 .set_msglevel
= ixgbe_set_msglevel
,
3423 .self_test
= ixgbe_diag_test
,
3424 .get_strings
= ixgbe_get_strings
,
3425 .set_phys_id
= ixgbe_set_phys_id
,
3426 .get_sset_count
= ixgbe_get_sset_count
,
3427 .get_ethtool_stats
= ixgbe_get_ethtool_stats
,
3428 .get_coalesce
= ixgbe_get_coalesce
,
3429 .set_coalesce
= ixgbe_set_coalesce
,
3430 .get_rxnfc
= ixgbe_get_rxnfc
,
3431 .set_rxnfc
= ixgbe_set_rxnfc
,
3432 .get_rxfh_indir_size
= ixgbe_rss_indir_size
,
3433 .get_rxfh_key_size
= ixgbe_get_rxfh_key_size
,
3434 .get_rxfh
= ixgbe_get_rxfh
,
3435 .set_rxfh
= ixgbe_set_rxfh
,
3436 .get_eee
= ixgbe_get_eee
,
3437 .set_eee
= ixgbe_set_eee
,
3438 .get_channels
= ixgbe_get_channels
,
3439 .set_channels
= ixgbe_set_channels
,
3440 .get_priv_flags
= ixgbe_get_priv_flags
,
3441 .set_priv_flags
= ixgbe_set_priv_flags
,
3442 .get_ts_info
= ixgbe_get_ts_info
,
3443 .get_module_info
= ixgbe_get_module_info
,
3444 .get_module_eeprom
= ixgbe_get_module_eeprom
,
3447 void ixgbe_set_ethtool_ops(struct net_device
*netdev
)
3449 netdev
->ethtool_ops
= &ixgbe_ethtool_ops
;