2 * Copyright (C) 2005 - 2010 ServerEngines
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License version 2
7 * as published by the Free Software Foundation. The full GNU General
8 * Public License is included in this distribution in the file called COPYING.
10 * Contact Information:
11 * linux-drivers@serverengines.com
14 * 209 N. Fair Oaks Ave
20 #include <linux/ethtool.h>
22 struct be_ethtool_stat
{
23 char desc
[ETH_GSTRING_LEN
];
29 enum {NETSTAT
, PORTSTAT
, MISCSTAT
, DRVSTAT_TX
, DRVSTAT_RX
, ERXSTAT
};
30 #define FIELDINFO(_struct, field) FIELD_SIZEOF(_struct, field), \
31 offsetof(_struct, field)
32 #define NETSTAT_INFO(field) #field, NETSTAT,\
33 FIELDINFO(struct net_device_stats,\
35 #define DRVSTAT_TX_INFO(field) #field, DRVSTAT_TX,\
36 FIELDINFO(struct be_tx_stats, field)
37 #define DRVSTAT_RX_INFO(field) #field, DRVSTAT_RX,\
38 FIELDINFO(struct be_rx_stats, field)
39 #define MISCSTAT_INFO(field) #field, MISCSTAT,\
40 FIELDINFO(struct be_rxf_stats, field)
41 #define PORTSTAT_INFO(field) #field, PORTSTAT,\
42 FIELDINFO(struct be_port_rxf_stats, \
44 #define ERXSTAT_INFO(field) #field, ERXSTAT,\
45 FIELDINFO(struct be_erx_stats, field)
47 static const struct be_ethtool_stat et_stats
[] = {
48 {NETSTAT_INFO(rx_packets
)},
49 {NETSTAT_INFO(tx_packets
)},
50 {NETSTAT_INFO(rx_bytes
)},
51 {NETSTAT_INFO(tx_bytes
)},
52 {NETSTAT_INFO(rx_errors
)},
53 {NETSTAT_INFO(tx_errors
)},
54 {NETSTAT_INFO(rx_dropped
)},
55 {NETSTAT_INFO(tx_dropped
)},
56 {DRVSTAT_TX_INFO(be_tx_rate
)},
57 {DRVSTAT_TX_INFO(be_tx_reqs
)},
58 {DRVSTAT_TX_INFO(be_tx_wrbs
)},
59 {DRVSTAT_TX_INFO(be_tx_stops
)},
60 {DRVSTAT_TX_INFO(be_tx_events
)},
61 {DRVSTAT_TX_INFO(be_tx_compl
)},
62 {PORTSTAT_INFO(rx_unicast_frames
)},
63 {PORTSTAT_INFO(rx_multicast_frames
)},
64 {PORTSTAT_INFO(rx_broadcast_frames
)},
65 {PORTSTAT_INFO(rx_crc_errors
)},
66 {PORTSTAT_INFO(rx_alignment_symbol_errors
)},
67 {PORTSTAT_INFO(rx_pause_frames
)},
68 {PORTSTAT_INFO(rx_control_frames
)},
69 {PORTSTAT_INFO(rx_in_range_errors
)},
70 {PORTSTAT_INFO(rx_out_range_errors
)},
71 {PORTSTAT_INFO(rx_frame_too_long
)},
72 {PORTSTAT_INFO(rx_address_match_errors
)},
73 {PORTSTAT_INFO(rx_vlan_mismatch
)},
74 {PORTSTAT_INFO(rx_dropped_too_small
)},
75 {PORTSTAT_INFO(rx_dropped_too_short
)},
76 {PORTSTAT_INFO(rx_dropped_header_too_small
)},
77 {PORTSTAT_INFO(rx_dropped_tcp_length
)},
78 {PORTSTAT_INFO(rx_dropped_runt
)},
79 {PORTSTAT_INFO(rx_fifo_overflow
)},
80 {PORTSTAT_INFO(rx_input_fifo_overflow
)},
81 {PORTSTAT_INFO(rx_ip_checksum_errs
)},
82 {PORTSTAT_INFO(rx_tcp_checksum_errs
)},
83 {PORTSTAT_INFO(rx_udp_checksum_errs
)},
84 {PORTSTAT_INFO(rx_non_rss_packets
)},
85 {PORTSTAT_INFO(rx_ipv4_packets
)},
86 {PORTSTAT_INFO(rx_ipv6_packets
)},
87 {PORTSTAT_INFO(rx_switched_unicast_packets
)},
88 {PORTSTAT_INFO(rx_switched_multicast_packets
)},
89 {PORTSTAT_INFO(rx_switched_broadcast_packets
)},
90 {PORTSTAT_INFO(tx_unicastframes
)},
91 {PORTSTAT_INFO(tx_multicastframes
)},
92 {PORTSTAT_INFO(tx_broadcastframes
)},
93 {PORTSTAT_INFO(tx_pauseframes
)},
94 {PORTSTAT_INFO(tx_controlframes
)},
95 {MISCSTAT_INFO(rx_drops_no_pbuf
)},
96 {MISCSTAT_INFO(rx_drops_no_txpb
)},
97 {MISCSTAT_INFO(rx_drops_no_erx_descr
)},
98 {MISCSTAT_INFO(rx_drops_no_tpre_descr
)},
99 {MISCSTAT_INFO(rx_drops_too_many_frags
)},
100 {MISCSTAT_INFO(rx_drops_invalid_ring
)},
101 {MISCSTAT_INFO(forwarded_packets
)},
102 {MISCSTAT_INFO(rx_drops_mtu
)}
104 #define ETHTOOL_STATS_NUM ARRAY_SIZE(et_stats)
106 /* Stats related to multi RX queues */
107 static const struct be_ethtool_stat et_rx_stats
[] = {
108 {DRVSTAT_RX_INFO(rx_bytes
)},
109 {DRVSTAT_RX_INFO(rx_pkts
)},
110 {DRVSTAT_RX_INFO(rx_rate
)},
111 {DRVSTAT_RX_INFO(rx_polls
)},
112 {DRVSTAT_RX_INFO(rx_events
)},
113 {DRVSTAT_RX_INFO(rx_compl
)},
114 {DRVSTAT_RX_INFO(rx_mcast_pkts
)},
115 {DRVSTAT_RX_INFO(rx_post_fail
)},
116 {ERXSTAT_INFO(rx_drops_no_fragments
)}
118 #define ETHTOOL_RXSTATS_NUM (ARRAY_SIZE(et_rx_stats))
120 static const char et_self_tests
[][ETH_GSTRING_LEN
] = {
123 "External Loopback test",
128 #define ETHTOOL_TESTS_NUM ARRAY_SIZE(et_self_tests)
129 #define BE_MAC_LOOPBACK 0x0
130 #define BE_PHY_LOOPBACK 0x1
131 #define BE_ONE_PORT_EXT_LOOPBACK 0x2
132 #define BE_NO_LOOPBACK 0xff
135 be_get_drvinfo(struct net_device
*netdev
, struct ethtool_drvinfo
*drvinfo
)
137 struct be_adapter
*adapter
= netdev_priv(netdev
);
139 strcpy(drvinfo
->driver
, DRV_NAME
);
140 strcpy(drvinfo
->version
, DRV_VER
);
141 strncpy(drvinfo
->fw_version
, adapter
->fw_ver
, FW_VER_LEN
);
142 strcpy(drvinfo
->bus_info
, pci_name(adapter
->pdev
));
143 drvinfo
->testinfo_len
= 0;
144 drvinfo
->regdump_len
= 0;
145 drvinfo
->eedump_len
= 0;
149 be_get_coalesce(struct net_device
*netdev
, struct ethtool_coalesce
*coalesce
)
151 struct be_adapter
*adapter
= netdev_priv(netdev
);
152 struct be_eq_obj
*rx_eq
= &adapter
->rx_obj
[0].rx_eq
;
153 struct be_eq_obj
*tx_eq
= &adapter
->tx_eq
;
155 coalesce
->rx_coalesce_usecs
= rx_eq
->cur_eqd
;
156 coalesce
->rx_coalesce_usecs_high
= rx_eq
->max_eqd
;
157 coalesce
->rx_coalesce_usecs_low
= rx_eq
->min_eqd
;
159 coalesce
->tx_coalesce_usecs
= tx_eq
->cur_eqd
;
160 coalesce
->tx_coalesce_usecs_high
= tx_eq
->max_eqd
;
161 coalesce
->tx_coalesce_usecs_low
= tx_eq
->min_eqd
;
163 coalesce
->use_adaptive_rx_coalesce
= rx_eq
->enable_aic
;
164 coalesce
->use_adaptive_tx_coalesce
= tx_eq
->enable_aic
;
170 * This routine is used to set interrup coalescing delay
173 be_set_coalesce(struct net_device
*netdev
, struct ethtool_coalesce
*coalesce
)
175 struct be_adapter
*adapter
= netdev_priv(netdev
);
176 struct be_rx_obj
*rxo
;
177 struct be_eq_obj
*rx_eq
;
178 struct be_eq_obj
*tx_eq
= &adapter
->tx_eq
;
179 u32 tx_max
, tx_min
, tx_cur
;
180 u32 rx_max
, rx_min
, rx_cur
;
183 if (coalesce
->use_adaptive_tx_coalesce
== 1)
186 for_all_rx_queues(adapter
, rxo
, i
) {
189 if (!rx_eq
->enable_aic
&& coalesce
->use_adaptive_rx_coalesce
)
191 rx_eq
->enable_aic
= coalesce
->use_adaptive_rx_coalesce
;
193 rx_max
= coalesce
->rx_coalesce_usecs_high
;
194 rx_min
= coalesce
->rx_coalesce_usecs_low
;
195 rx_cur
= coalesce
->rx_coalesce_usecs
;
197 if (rx_eq
->enable_aic
) {
198 if (rx_max
> BE_MAX_EQD
)
202 rx_eq
->max_eqd
= rx_max
;
203 rx_eq
->min_eqd
= rx_min
;
204 if (rx_eq
->cur_eqd
> rx_max
)
205 rx_eq
->cur_eqd
= rx_max
;
206 if (rx_eq
->cur_eqd
< rx_min
)
207 rx_eq
->cur_eqd
= rx_min
;
209 if (rx_cur
> BE_MAX_EQD
)
211 if (rx_eq
->cur_eqd
!= rx_cur
) {
212 status
= be_cmd_modify_eqd(adapter
, rx_eq
->q
.id
,
215 rx_eq
->cur_eqd
= rx_cur
;
220 tx_max
= coalesce
->tx_coalesce_usecs_high
;
221 tx_min
= coalesce
->tx_coalesce_usecs_low
;
222 tx_cur
= coalesce
->tx_coalesce_usecs
;
224 if (tx_cur
> BE_MAX_EQD
)
226 if (tx_eq
->cur_eqd
!= tx_cur
) {
227 status
= be_cmd_modify_eqd(adapter
, tx_eq
->q
.id
, tx_cur
);
229 tx_eq
->cur_eqd
= tx_cur
;
235 static u32
be_get_rx_csum(struct net_device
*netdev
)
237 struct be_adapter
*adapter
= netdev_priv(netdev
);
239 return adapter
->rx_csum
;
242 static int be_set_rx_csum(struct net_device
*netdev
, uint32_t data
)
244 struct be_adapter
*adapter
= netdev_priv(netdev
);
247 adapter
->rx_csum
= true;
249 adapter
->rx_csum
= false;
255 be_get_ethtool_stats(struct net_device
*netdev
,
256 struct ethtool_stats
*stats
, uint64_t *data
)
258 struct be_adapter
*adapter
= netdev_priv(netdev
);
259 struct be_hw_stats
*hw_stats
= hw_stats_from_cmd(adapter
->stats_cmd
.va
);
260 struct be_erx_stats
*erx_stats
= &hw_stats
->erx
;
261 struct be_rx_obj
*rxo
;
265 for (i
= 0; i
< ETHTOOL_STATS_NUM
; i
++) {
266 switch (et_stats
[i
].type
) {
271 p
= &adapter
->tx_stats
;
274 p
= &hw_stats
->rxf
.port
[adapter
->port_num
];
281 p
= (u8
*)p
+ et_stats
[i
].offset
;
282 data
[i
] = (et_stats
[i
].size
== sizeof(u64
)) ?
283 *(u64
*)p
: *(u32
*)p
;
286 for_all_rx_queues(adapter
, rxo
, j
) {
287 for (i
= 0; i
< ETHTOOL_RXSTATS_NUM
; i
++) {
288 switch (et_rx_stats
[i
].type
) {
290 p
= (u8
*)&rxo
->stats
+ et_rx_stats
[i
].offset
;
293 p
= (u32
*)erx_stats
+ rxo
->q
.id
;
296 data
[ETHTOOL_STATS_NUM
+ j
* ETHTOOL_RXSTATS_NUM
+ i
] =
297 (et_rx_stats
[i
].size
== sizeof(u64
)) ?
298 *(u64
*)p
: *(u32
*)p
;
304 be_get_stat_strings(struct net_device
*netdev
, uint32_t stringset
,
307 struct be_adapter
*adapter
= netdev_priv(netdev
);
312 for (i
= 0; i
< ETHTOOL_STATS_NUM
; i
++) {
313 memcpy(data
, et_stats
[i
].desc
, ETH_GSTRING_LEN
);
314 data
+= ETH_GSTRING_LEN
;
316 for (i
= 0; i
< adapter
->num_rx_qs
; i
++) {
317 for (j
= 0; j
< ETHTOOL_RXSTATS_NUM
; j
++) {
318 sprintf(data
, "rxq%d: %s", i
,
319 et_rx_stats
[j
].desc
);
320 data
+= ETH_GSTRING_LEN
;
325 for (i
= 0; i
< ETHTOOL_TESTS_NUM
; i
++) {
326 memcpy(data
, et_self_tests
[i
], ETH_GSTRING_LEN
);
327 data
+= ETH_GSTRING_LEN
;
333 static int be_get_sset_count(struct net_device
*netdev
, int stringset
)
335 struct be_adapter
*adapter
= netdev_priv(netdev
);
339 return ETHTOOL_TESTS_NUM
;
341 return ETHTOOL_STATS_NUM
+
342 adapter
->num_rx_qs
* ETHTOOL_RXSTATS_NUM
;
348 static int be_get_settings(struct net_device
*netdev
, struct ethtool_cmd
*ecmd
)
350 struct be_adapter
*adapter
= netdev_priv(netdev
);
351 struct be_dma_mem phy_cmd
;
352 struct be_cmd_resp_get_phy_info
*resp
;
355 bool link_up
= false;
359 if ((adapter
->link_speed
< 0) || (!(netdev
->flags
& IFF_UP
))) {
360 status
= be_cmd_link_status_query(adapter
, &link_up
,
361 &mac_speed
, &link_speed
);
363 be_link_status_update(adapter
, link_up
);
364 /* link_speed is in units of 10 Mbps */
366 ecmd
->speed
= link_speed
*10;
369 case PHY_LINK_SPEED_1GBPS
:
370 ecmd
->speed
= SPEED_1000
;
372 case PHY_LINK_SPEED_10GBPS
:
373 ecmd
->speed
= SPEED_10000
;
378 phy_cmd
.size
= sizeof(struct be_cmd_req_get_phy_info
);
379 phy_cmd
.va
= pci_alloc_consistent(adapter
->pdev
, phy_cmd
.size
,
382 dev_err(&adapter
->pdev
->dev
, "Memory alloc failure\n");
385 status
= be_cmd_get_phy_info(adapter
, &phy_cmd
);
387 resp
= (struct be_cmd_resp_get_phy_info
*) phy_cmd
.va
;
388 intf_type
= le16_to_cpu(resp
->interface_type
);
391 case PHY_TYPE_XFP_10GB
:
392 case PHY_TYPE_SFP_1GB
:
393 case PHY_TYPE_SFP_PLUS_10GB
:
394 ecmd
->port
= PORT_FIBRE
;
397 ecmd
->port
= PORT_TP
;
402 case PHY_TYPE_KR_10GB
:
403 case PHY_TYPE_KX4_10GB
:
404 ecmd
->autoneg
= AUTONEG_ENABLE
;
405 ecmd
->transceiver
= XCVR_INTERNAL
;
408 ecmd
->autoneg
= AUTONEG_DISABLE
;
409 ecmd
->transceiver
= XCVR_EXTERNAL
;
414 /* Save for future use */
415 adapter
->link_speed
= ecmd
->speed
;
416 adapter
->port_type
= ecmd
->port
;
417 adapter
->transceiver
= ecmd
->transceiver
;
418 adapter
->autoneg
= ecmd
->autoneg
;
419 pci_free_consistent(adapter
->pdev
, phy_cmd
.size
,
420 phy_cmd
.va
, phy_cmd
.dma
);
422 ecmd
->speed
= adapter
->link_speed
;
423 ecmd
->port
= adapter
->port_type
;
424 ecmd
->transceiver
= adapter
->transceiver
;
425 ecmd
->autoneg
= adapter
->autoneg
;
428 ecmd
->duplex
= DUPLEX_FULL
;
429 ecmd
->phy_address
= adapter
->port_num
;
430 switch (ecmd
->port
) {
432 ecmd
->supported
= (SUPPORTED_10000baseT_Full
| SUPPORTED_FIBRE
);
435 ecmd
->supported
= (SUPPORTED_10000baseT_Full
| SUPPORTED_TP
);
438 ecmd
->supported
= (SUPPORTED_10000baseT_Full
| SUPPORTED_AUI
);
443 ecmd
->supported
|= SUPPORTED_1000baseT_Full
;
444 ecmd
->supported
|= SUPPORTED_Autoneg
;
445 ecmd
->advertising
|= (ADVERTISED_10000baseT_Full
|
446 ADVERTISED_1000baseT_Full
);
453 be_get_ringparam(struct net_device
*netdev
, struct ethtool_ringparam
*ring
)
455 struct be_adapter
*adapter
= netdev_priv(netdev
);
457 ring
->rx_max_pending
= adapter
->rx_obj
[0].q
.len
;
458 ring
->tx_max_pending
= adapter
->tx_obj
.q
.len
;
460 ring
->rx_pending
= atomic_read(&adapter
->rx_obj
[0].q
.used
);
461 ring
->tx_pending
= atomic_read(&adapter
->tx_obj
.q
.used
);
465 be_get_pauseparam(struct net_device
*netdev
, struct ethtool_pauseparam
*ecmd
)
467 struct be_adapter
*adapter
= netdev_priv(netdev
);
469 be_cmd_get_flow_control(adapter
, &ecmd
->tx_pause
, &ecmd
->rx_pause
);
474 be_set_pauseparam(struct net_device
*netdev
, struct ethtool_pauseparam
*ecmd
)
476 struct be_adapter
*adapter
= netdev_priv(netdev
);
479 if (ecmd
->autoneg
!= 0)
481 adapter
->tx_fc
= ecmd
->tx_pause
;
482 adapter
->rx_fc
= ecmd
->rx_pause
;
484 status
= be_cmd_set_flow_control(adapter
,
485 adapter
->tx_fc
, adapter
->rx_fc
);
487 dev_warn(&adapter
->pdev
->dev
, "Pause param set failed.\n");
493 be_phys_id(struct net_device
*netdev
, u32 data
)
495 struct be_adapter
*adapter
= netdev_priv(netdev
);
499 be_cmd_get_beacon_state(adapter
, adapter
->port_num
, &cur
);
501 if (cur
== BEACON_STATE_ENABLED
)
507 status
= be_cmd_set_beacon_state(adapter
, adapter
->port_num
, 0, 0,
508 BEACON_STATE_ENABLED
);
509 set_current_state(TASK_INTERRUPTIBLE
);
510 schedule_timeout(data
*HZ
);
512 status
= be_cmd_set_beacon_state(adapter
, adapter
->port_num
, 0, 0,
513 BEACON_STATE_DISABLED
);
519 be_get_wol(struct net_device
*netdev
, struct ethtool_wolinfo
*wol
)
521 struct be_adapter
*adapter
= netdev_priv(netdev
);
523 wol
->supported
= WAKE_MAGIC
;
525 wol
->wolopts
= WAKE_MAGIC
;
528 memset(&wol
->sopass
, 0, sizeof(wol
->sopass
));
532 be_set_wol(struct net_device
*netdev
, struct ethtool_wolinfo
*wol
)
534 struct be_adapter
*adapter
= netdev_priv(netdev
);
536 if (wol
->wolopts
& ~WAKE_MAGIC
)
539 if (wol
->wolopts
& WAKE_MAGIC
)
542 adapter
->wol
= false;
548 be_test_ddr_dma(struct be_adapter
*adapter
)
551 struct be_dma_mem ddrdma_cmd
;
552 u64 pattern
[2] = {0x5a5a5a5a5a5a5a5aULL
, 0xa5a5a5a5a5a5a5a5ULL
};
554 ddrdma_cmd
.size
= sizeof(struct be_cmd_req_ddrdma_test
);
555 ddrdma_cmd
.va
= pci_alloc_consistent(adapter
->pdev
, ddrdma_cmd
.size
,
557 if (!ddrdma_cmd
.va
) {
558 dev_err(&adapter
->pdev
->dev
, "Memory allocation failure\n");
562 for (i
= 0; i
< 2; i
++) {
563 ret
= be_cmd_ddr_dma_test(adapter
, pattern
[i
],
570 pci_free_consistent(adapter
->pdev
, ddrdma_cmd
.size
,
571 ddrdma_cmd
.va
, ddrdma_cmd
.dma
);
575 static u64
be_loopback_test(struct be_adapter
*adapter
, u8 loopback_type
,
578 be_cmd_set_loopback(adapter
, adapter
->port_num
,
580 *status
= be_cmd_loopback_test(adapter
, adapter
->port_num
,
583 be_cmd_set_loopback(adapter
, adapter
->port_num
,
589 be_self_test(struct net_device
*netdev
, struct ethtool_test
*test
, u64
*data
)
591 struct be_adapter
*adapter
= netdev_priv(netdev
);
594 u16 qos_link_speed
= 0;
596 memset(data
, 0, sizeof(u64
) * ETHTOOL_TESTS_NUM
);
598 if (test
->flags
& ETH_TEST_FL_OFFLINE
) {
599 if (be_loopback_test(adapter
, BE_MAC_LOOPBACK
,
601 test
->flags
|= ETH_TEST_FL_FAILED
;
603 if (be_loopback_test(adapter
, BE_PHY_LOOPBACK
,
605 test
->flags
|= ETH_TEST_FL_FAILED
;
607 if (be_loopback_test(adapter
, BE_ONE_PORT_EXT_LOOPBACK
,
609 test
->flags
|= ETH_TEST_FL_FAILED
;
613 if (be_test_ddr_dma(adapter
) != 0) {
615 test
->flags
|= ETH_TEST_FL_FAILED
;
618 if (be_cmd_link_status_query(adapter
, &link_up
, &mac_speed
,
619 &qos_link_speed
) != 0) {
620 test
->flags
|= ETH_TEST_FL_FAILED
;
622 } else if (mac_speed
) {
628 be_do_flash(struct net_device
*netdev
, struct ethtool_flash
*efl
)
630 struct be_adapter
*adapter
= netdev_priv(netdev
);
631 char file_name
[ETHTOOL_FLASH_MAX_FILENAME
];
634 file_name
[ETHTOOL_FLASH_MAX_FILENAME
- 1] = 0;
635 strcpy(file_name
, efl
->data
);
636 region
= efl
->region
;
638 return be_load_fw(adapter
, file_name
);
642 be_get_eeprom_len(struct net_device
*netdev
)
644 return BE_READ_SEEPROM_LEN
;
648 be_read_eeprom(struct net_device
*netdev
, struct ethtool_eeprom
*eeprom
,
651 struct be_adapter
*adapter
= netdev_priv(netdev
);
652 struct be_dma_mem eeprom_cmd
;
653 struct be_cmd_resp_seeprom_read
*resp
;
659 eeprom
->magic
= BE_VENDOR_ID
| (adapter
->pdev
->device
<<16);
661 memset(&eeprom_cmd
, 0, sizeof(struct be_dma_mem
));
662 eeprom_cmd
.size
= sizeof(struct be_cmd_req_seeprom_read
);
663 eeprom_cmd
.va
= pci_alloc_consistent(adapter
->pdev
, eeprom_cmd
.size
,
666 if (!eeprom_cmd
.va
) {
667 dev_err(&adapter
->pdev
->dev
,
668 "Memory allocation failure. Could not read eeprom\n");
672 status
= be_cmd_get_seeprom_data(adapter
, &eeprom_cmd
);
675 resp
= (struct be_cmd_resp_seeprom_read
*) eeprom_cmd
.va
;
676 memcpy(data
, resp
->seeprom_data
+ eeprom
->offset
, eeprom
->len
);
678 pci_free_consistent(adapter
->pdev
, eeprom_cmd
.size
, eeprom_cmd
.va
,
684 const struct ethtool_ops be_ethtool_ops
= {
685 .get_settings
= be_get_settings
,
686 .get_drvinfo
= be_get_drvinfo
,
687 .get_wol
= be_get_wol
,
688 .set_wol
= be_set_wol
,
689 .get_link
= ethtool_op_get_link
,
690 .get_eeprom_len
= be_get_eeprom_len
,
691 .get_eeprom
= be_read_eeprom
,
692 .get_coalesce
= be_get_coalesce
,
693 .set_coalesce
= be_set_coalesce
,
694 .get_ringparam
= be_get_ringparam
,
695 .get_pauseparam
= be_get_pauseparam
,
696 .set_pauseparam
= be_set_pauseparam
,
697 .get_rx_csum
= be_get_rx_csum
,
698 .set_rx_csum
= be_set_rx_csum
,
699 .get_tx_csum
= ethtool_op_get_tx_csum
,
700 .set_tx_csum
= ethtool_op_set_tx_hw_csum
,
701 .get_sg
= ethtool_op_get_sg
,
702 .set_sg
= ethtool_op_set_sg
,
703 .get_tso
= ethtool_op_get_tso
,
704 .set_tso
= ethtool_op_set_tso
,
705 .get_strings
= be_get_stat_strings
,
706 .phys_id
= be_phys_id
,
707 .get_sset_count
= be_get_sset_count
,
708 .get_ethtool_stats
= be_get_ethtool_stats
,
709 .flash_device
= be_do_flash
,
710 .self_test
= be_self_test
,