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
, 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_INFO(field) #field, DRVSTAT,\
36 FIELDINFO(struct be_drvr_stats, field)
37 #define MISCSTAT_INFO(field) #field, MISCSTAT,\
38 FIELDINFO(struct be_rxf_stats, field)
39 #define PORTSTAT_INFO(field) #field, PORTSTAT,\
40 FIELDINFO(struct be_port_rxf_stats, \
42 #define ERXSTAT_INFO(field) #field, ERXSTAT,\
43 FIELDINFO(struct be_erx_stats, field)
45 static const struct be_ethtool_stat et_stats
[] = {
46 {NETSTAT_INFO(rx_packets
)},
47 {NETSTAT_INFO(tx_packets
)},
48 {NETSTAT_INFO(rx_bytes
)},
49 {NETSTAT_INFO(tx_bytes
)},
50 {NETSTAT_INFO(rx_errors
)},
51 {NETSTAT_INFO(tx_errors
)},
52 {NETSTAT_INFO(rx_dropped
)},
53 {NETSTAT_INFO(tx_dropped
)},
54 {DRVSTAT_INFO(be_tx_reqs
)},
55 {DRVSTAT_INFO(be_tx_stops
)},
56 {DRVSTAT_INFO(be_fwd_reqs
)},
57 {DRVSTAT_INFO(be_tx_wrbs
)},
58 {DRVSTAT_INFO(be_rx_polls
)},
59 {DRVSTAT_INFO(be_tx_events
)},
60 {DRVSTAT_INFO(be_rx_events
)},
61 {DRVSTAT_INFO(be_tx_compl
)},
62 {DRVSTAT_INFO(be_rx_compl
)},
63 {DRVSTAT_INFO(be_ethrx_post_fail
)},
64 {DRVSTAT_INFO(be_802_3_dropped_frames
)},
65 {DRVSTAT_INFO(be_802_3_malformed_frames
)},
66 {DRVSTAT_INFO(be_tx_rate
)},
67 {DRVSTAT_INFO(be_rx_rate
)},
68 {PORTSTAT_INFO(rx_unicast_frames
)},
69 {PORTSTAT_INFO(rx_multicast_frames
)},
70 {PORTSTAT_INFO(rx_broadcast_frames
)},
71 {PORTSTAT_INFO(rx_crc_errors
)},
72 {PORTSTAT_INFO(rx_alignment_symbol_errors
)},
73 {PORTSTAT_INFO(rx_pause_frames
)},
74 {PORTSTAT_INFO(rx_control_frames
)},
75 {PORTSTAT_INFO(rx_in_range_errors
)},
76 {PORTSTAT_INFO(rx_out_range_errors
)},
77 {PORTSTAT_INFO(rx_frame_too_long
)},
78 {PORTSTAT_INFO(rx_address_match_errors
)},
79 {PORTSTAT_INFO(rx_vlan_mismatch
)},
80 {PORTSTAT_INFO(rx_dropped_too_small
)},
81 {PORTSTAT_INFO(rx_dropped_too_short
)},
82 {PORTSTAT_INFO(rx_dropped_header_too_small
)},
83 {PORTSTAT_INFO(rx_dropped_tcp_length
)},
84 {PORTSTAT_INFO(rx_dropped_runt
)},
85 {PORTSTAT_INFO(rx_fifo_overflow
)},
86 {PORTSTAT_INFO(rx_input_fifo_overflow
)},
87 {PORTSTAT_INFO(rx_ip_checksum_errs
)},
88 {PORTSTAT_INFO(rx_tcp_checksum_errs
)},
89 {PORTSTAT_INFO(rx_udp_checksum_errs
)},
90 {PORTSTAT_INFO(rx_non_rss_packets
)},
91 {PORTSTAT_INFO(rx_ipv4_packets
)},
92 {PORTSTAT_INFO(rx_ipv6_packets
)},
93 {PORTSTAT_INFO(tx_unicastframes
)},
94 {PORTSTAT_INFO(tx_multicastframes
)},
95 {PORTSTAT_INFO(tx_broadcastframes
)},
96 {PORTSTAT_INFO(tx_pauseframes
)},
97 {PORTSTAT_INFO(tx_controlframes
)},
98 {MISCSTAT_INFO(rx_drops_no_pbuf
)},
99 {MISCSTAT_INFO(rx_drops_no_txpb
)},
100 {MISCSTAT_INFO(rx_drops_no_erx_descr
)},
101 {MISCSTAT_INFO(rx_drops_no_tpre_descr
)},
102 {MISCSTAT_INFO(rx_drops_too_many_frags
)},
103 {MISCSTAT_INFO(rx_drops_invalid_ring
)},
104 {MISCSTAT_INFO(forwarded_packets
)},
105 {MISCSTAT_INFO(rx_drops_mtu
)},
106 {ERXSTAT_INFO(rx_drops_no_fragments
)},
108 #define ETHTOOL_STATS_NUM ARRAY_SIZE(et_stats)
110 static const char et_self_tests
[][ETH_GSTRING_LEN
] = {
113 "External Loopback test",
118 #define ETHTOOL_TESTS_NUM ARRAY_SIZE(et_self_tests)
119 #define BE_MAC_LOOPBACK 0x0
120 #define BE_PHY_LOOPBACK 0x1
121 #define BE_ONE_PORT_EXT_LOOPBACK 0x2
122 #define BE_NO_LOOPBACK 0xff
125 be_get_drvinfo(struct net_device
*netdev
, struct ethtool_drvinfo
*drvinfo
)
127 struct be_adapter
*adapter
= netdev_priv(netdev
);
129 strcpy(drvinfo
->driver
, DRV_NAME
);
130 strcpy(drvinfo
->version
, DRV_VER
);
131 strncpy(drvinfo
->fw_version
, adapter
->fw_ver
, FW_VER_LEN
);
132 strcpy(drvinfo
->bus_info
, pci_name(adapter
->pdev
));
133 drvinfo
->testinfo_len
= 0;
134 drvinfo
->regdump_len
= 0;
135 drvinfo
->eedump_len
= 0;
139 be_get_coalesce(struct net_device
*netdev
, struct ethtool_coalesce
*coalesce
)
141 struct be_adapter
*adapter
= netdev_priv(netdev
);
142 struct be_eq_obj
*rx_eq
= &adapter
->rx_eq
;
143 struct be_eq_obj
*tx_eq
= &adapter
->tx_eq
;
145 coalesce
->rx_coalesce_usecs
= rx_eq
->cur_eqd
;
146 coalesce
->rx_coalesce_usecs_high
= rx_eq
->max_eqd
;
147 coalesce
->rx_coalesce_usecs_low
= rx_eq
->min_eqd
;
149 coalesce
->tx_coalesce_usecs
= tx_eq
->cur_eqd
;
150 coalesce
->tx_coalesce_usecs_high
= tx_eq
->max_eqd
;
151 coalesce
->tx_coalesce_usecs_low
= tx_eq
->min_eqd
;
153 coalesce
->use_adaptive_rx_coalesce
= rx_eq
->enable_aic
;
154 coalesce
->use_adaptive_tx_coalesce
= tx_eq
->enable_aic
;
160 * This routine is used to set interrup coalescing delay
163 be_set_coalesce(struct net_device
*netdev
, struct ethtool_coalesce
*coalesce
)
165 struct be_adapter
*adapter
= netdev_priv(netdev
);
166 struct be_eq_obj
*rx_eq
= &adapter
->rx_eq
;
167 struct be_eq_obj
*tx_eq
= &adapter
->tx_eq
;
168 u32 tx_max
, tx_min
, tx_cur
;
169 u32 rx_max
, rx_min
, rx_cur
;
172 if (coalesce
->use_adaptive_tx_coalesce
== 1)
175 /* if AIC is being turned on now, start with an EQD of 0 */
176 if (rx_eq
->enable_aic
== 0 &&
177 coalesce
->use_adaptive_rx_coalesce
== 1) {
180 rx_eq
->enable_aic
= coalesce
->use_adaptive_rx_coalesce
;
182 rx_max
= coalesce
->rx_coalesce_usecs_high
;
183 rx_min
= coalesce
->rx_coalesce_usecs_low
;
184 rx_cur
= coalesce
->rx_coalesce_usecs
;
186 tx_max
= coalesce
->tx_coalesce_usecs_high
;
187 tx_min
= coalesce
->tx_coalesce_usecs_low
;
188 tx_cur
= coalesce
->tx_coalesce_usecs
;
190 if (tx_cur
> BE_MAX_EQD
)
192 if (tx_eq
->cur_eqd
!= tx_cur
) {
193 status
= be_cmd_modify_eqd(adapter
, tx_eq
->q
.id
, tx_cur
);
195 tx_eq
->cur_eqd
= tx_cur
;
198 if (rx_eq
->enable_aic
) {
199 if (rx_max
> BE_MAX_EQD
)
203 rx_eq
->max_eqd
= rx_max
;
204 rx_eq
->min_eqd
= rx_min
;
205 if (rx_eq
->cur_eqd
> rx_max
)
206 rx_eq
->cur_eqd
= rx_max
;
207 if (rx_eq
->cur_eqd
< rx_min
)
208 rx_eq
->cur_eqd
= rx_min
;
210 if (rx_cur
> BE_MAX_EQD
)
212 if (rx_eq
->cur_eqd
!= rx_cur
) {
213 status
= be_cmd_modify_eqd(adapter
, rx_eq
->q
.id
,
216 rx_eq
->cur_eqd
= rx_cur
;
222 static u32
be_get_rx_csum(struct net_device
*netdev
)
224 struct be_adapter
*adapter
= netdev_priv(netdev
);
226 return adapter
->rx_csum
;
229 static int be_set_rx_csum(struct net_device
*netdev
, uint32_t data
)
231 struct be_adapter
*adapter
= netdev_priv(netdev
);
234 adapter
->rx_csum
= true;
236 adapter
->rx_csum
= false;
242 be_get_ethtool_stats(struct net_device
*netdev
,
243 struct ethtool_stats
*stats
, uint64_t *data
)
245 struct be_adapter
*adapter
= netdev_priv(netdev
);
246 struct be_drvr_stats
*drvr_stats
= &adapter
->stats
.drvr_stats
;
247 struct be_hw_stats
*hw_stats
= hw_stats_from_cmd(adapter
->stats
.cmd
.va
);
248 struct be_rxf_stats
*rxf_stats
= &hw_stats
->rxf
;
249 struct be_port_rxf_stats
*port_stats
=
250 &rxf_stats
->port
[adapter
->port_num
];
251 struct net_device_stats
*net_stats
= &netdev
->stats
;
252 struct be_erx_stats
*erx_stats
= &hw_stats
->erx
;
256 for (i
= 0; i
< ETHTOOL_STATS_NUM
; i
++) {
257 switch (et_stats
[i
].type
) {
270 case ERXSTAT
: /* Currently only one ERX stat is provided */
271 p
= (u32
*)erx_stats
+ adapter
->rx_obj
.q
.id
;
275 p
= (u8
*)p
+ et_stats
[i
].offset
;
276 data
[i
] = (et_stats
[i
].size
== sizeof(u64
)) ?
277 *(u64
*)p
: *(u32
*)p
;
282 be_get_stat_strings(struct net_device
*netdev
, uint32_t stringset
,
288 for (i
= 0; i
< ETHTOOL_STATS_NUM
; i
++) {
289 memcpy(data
, et_stats
[i
].desc
, ETH_GSTRING_LEN
);
290 data
+= ETH_GSTRING_LEN
;
294 for (i
= 0; i
< ETHTOOL_TESTS_NUM
; i
++) {
295 memcpy(data
, et_self_tests
[i
], ETH_GSTRING_LEN
);
296 data
+= ETH_GSTRING_LEN
;
302 static int be_get_sset_count(struct net_device
*netdev
, int stringset
)
306 return ETHTOOL_TESTS_NUM
;
308 return ETHTOOL_STATS_NUM
;
314 static int be_get_settings(struct net_device
*netdev
, struct ethtool_cmd
*ecmd
)
316 struct be_adapter
*adapter
= netdev_priv(netdev
);
317 struct be_dma_mem phy_cmd
;
318 struct be_cmd_resp_get_phy_info
*resp
;
321 bool link_up
= false;
325 if (adapter
->link_speed
< 0) {
326 status
= be_cmd_link_status_query(adapter
, &link_up
,
327 &mac_speed
, &link_speed
);
329 /* link_speed is in units of 10 Mbps */
331 ecmd
->speed
= link_speed
*10;
334 case PHY_LINK_SPEED_1GBPS
:
335 ecmd
->speed
= SPEED_1000
;
337 case PHY_LINK_SPEED_10GBPS
:
338 ecmd
->speed
= SPEED_10000
;
343 phy_cmd
.size
= sizeof(struct be_cmd_req_get_phy_info
);
344 phy_cmd
.va
= pci_alloc_consistent(adapter
->pdev
, phy_cmd
.size
,
347 dev_err(&adapter
->pdev
->dev
, "Memory alloc failure\n");
350 status
= be_cmd_get_phy_info(adapter
, &phy_cmd
);
352 resp
= (struct be_cmd_resp_get_phy_info
*) phy_cmd
.va
;
353 intf_type
= le16_to_cpu(resp
->interface_type
);
356 case PHY_TYPE_XFP_10GB
:
357 case PHY_TYPE_SFP_1GB
:
358 case PHY_TYPE_SFP_PLUS_10GB
:
359 ecmd
->port
= PORT_FIBRE
;
362 ecmd
->port
= PORT_TP
;
367 case PHY_TYPE_KR_10GB
:
368 case PHY_TYPE_KX4_10GB
:
369 ecmd
->autoneg
= AUTONEG_ENABLE
;
370 ecmd
->transceiver
= XCVR_INTERNAL
;
373 ecmd
->autoneg
= AUTONEG_DISABLE
;
374 ecmd
->transceiver
= XCVR_EXTERNAL
;
379 /* Save for future use */
380 adapter
->link_speed
= ecmd
->speed
;
381 adapter
->port_type
= ecmd
->port
;
382 adapter
->transceiver
= ecmd
->transceiver
;
383 adapter
->autoneg
= ecmd
->autoneg
;
384 pci_free_consistent(adapter
->pdev
, phy_cmd
.size
,
385 phy_cmd
.va
, phy_cmd
.dma
);
387 ecmd
->speed
= adapter
->link_speed
;
388 ecmd
->port
= adapter
->port_type
;
389 ecmd
->transceiver
= adapter
->transceiver
;
390 ecmd
->autoneg
= adapter
->autoneg
;
393 ecmd
->duplex
= DUPLEX_FULL
;
394 ecmd
->phy_address
= adapter
->port_num
;
395 switch (ecmd
->port
) {
397 ecmd
->supported
= (SUPPORTED_10000baseT_Full
| SUPPORTED_FIBRE
);
400 ecmd
->supported
= (SUPPORTED_10000baseT_Full
| SUPPORTED_TP
);
403 ecmd
->supported
= (SUPPORTED_10000baseT_Full
| SUPPORTED_AUI
);
408 ecmd
->supported
|= SUPPORTED_1000baseT_Full
;
409 ecmd
->supported
|= SUPPORTED_Autoneg
;
410 ecmd
->advertising
|= (ADVERTISED_10000baseT_Full
|
411 ADVERTISED_1000baseT_Full
);
418 be_get_ringparam(struct net_device
*netdev
, struct ethtool_ringparam
*ring
)
420 struct be_adapter
*adapter
= netdev_priv(netdev
);
422 ring
->rx_max_pending
= adapter
->rx_obj
.q
.len
;
423 ring
->tx_max_pending
= adapter
->tx_obj
.q
.len
;
425 ring
->rx_pending
= atomic_read(&adapter
->rx_obj
.q
.used
);
426 ring
->tx_pending
= atomic_read(&adapter
->tx_obj
.q
.used
);
430 be_get_pauseparam(struct net_device
*netdev
, struct ethtool_pauseparam
*ecmd
)
432 struct be_adapter
*adapter
= netdev_priv(netdev
);
434 be_cmd_get_flow_control(adapter
, &ecmd
->tx_pause
, &ecmd
->rx_pause
);
439 be_set_pauseparam(struct net_device
*netdev
, struct ethtool_pauseparam
*ecmd
)
441 struct be_adapter
*adapter
= netdev_priv(netdev
);
444 if (ecmd
->autoneg
!= 0)
446 adapter
->tx_fc
= ecmd
->tx_pause
;
447 adapter
->rx_fc
= ecmd
->rx_pause
;
449 status
= be_cmd_set_flow_control(adapter
,
450 adapter
->tx_fc
, adapter
->rx_fc
);
452 dev_warn(&adapter
->pdev
->dev
, "Pause param set failed.\n");
458 be_phys_id(struct net_device
*netdev
, u32 data
)
460 struct be_adapter
*adapter
= netdev_priv(netdev
);
464 be_cmd_get_beacon_state(adapter
, adapter
->port_num
, &cur
);
466 if (cur
== BEACON_STATE_ENABLED
)
472 status
= be_cmd_set_beacon_state(adapter
, adapter
->port_num
, 0, 0,
473 BEACON_STATE_ENABLED
);
474 set_current_state(TASK_INTERRUPTIBLE
);
475 schedule_timeout(data
*HZ
);
477 status
= be_cmd_set_beacon_state(adapter
, adapter
->port_num
, 0, 0,
478 BEACON_STATE_DISABLED
);
484 be_get_wol(struct net_device
*netdev
, struct ethtool_wolinfo
*wol
)
486 struct be_adapter
*adapter
= netdev_priv(netdev
);
488 wol
->supported
= WAKE_MAGIC
;
490 wol
->wolopts
= WAKE_MAGIC
;
493 memset(&wol
->sopass
, 0, sizeof(wol
->sopass
));
497 be_set_wol(struct net_device
*netdev
, struct ethtool_wolinfo
*wol
)
499 struct be_adapter
*adapter
= netdev_priv(netdev
);
501 if (wol
->wolopts
& ~WAKE_MAGIC
)
504 if (wol
->wolopts
& WAKE_MAGIC
)
507 adapter
->wol
= false;
513 be_test_ddr_dma(struct be_adapter
*adapter
)
516 struct be_dma_mem ddrdma_cmd
;
517 u64 pattern
[2] = {0x5a5a5a5a5a5a5a5aULL
, 0xa5a5a5a5a5a5a5a5ULL
};
519 ddrdma_cmd
.size
= sizeof(struct be_cmd_req_ddrdma_test
);
520 ddrdma_cmd
.va
= pci_alloc_consistent(adapter
->pdev
, ddrdma_cmd
.size
,
522 if (!ddrdma_cmd
.va
) {
523 dev_err(&adapter
->pdev
->dev
, "Memory allocation failure\n");
527 for (i
= 0; i
< 2; i
++) {
528 ret
= be_cmd_ddr_dma_test(adapter
, pattern
[i
],
535 pci_free_consistent(adapter
->pdev
, ddrdma_cmd
.size
,
536 ddrdma_cmd
.va
, ddrdma_cmd
.dma
);
540 static u64
be_loopback_test(struct be_adapter
*adapter
, u8 loopback_type
,
543 be_cmd_set_loopback(adapter
, adapter
->port_num
,
545 *status
= be_cmd_loopback_test(adapter
, adapter
->port_num
,
548 be_cmd_set_loopback(adapter
, adapter
->port_num
,
554 be_self_test(struct net_device
*netdev
, struct ethtool_test
*test
, u64
*data
)
556 struct be_adapter
*adapter
= netdev_priv(netdev
);
559 u16 qos_link_speed
= 0;
561 memset(data
, 0, sizeof(u64
) * ETHTOOL_TESTS_NUM
);
563 if (test
->flags
& ETH_TEST_FL_OFFLINE
) {
564 if (be_loopback_test(adapter
, BE_MAC_LOOPBACK
,
566 test
->flags
|= ETH_TEST_FL_FAILED
;
568 if (be_loopback_test(adapter
, BE_PHY_LOOPBACK
,
570 test
->flags
|= ETH_TEST_FL_FAILED
;
572 if (be_loopback_test(adapter
, BE_ONE_PORT_EXT_LOOPBACK
,
574 test
->flags
|= ETH_TEST_FL_FAILED
;
578 if (be_test_ddr_dma(adapter
) != 0) {
580 test
->flags
|= ETH_TEST_FL_FAILED
;
583 if (be_cmd_link_status_query(adapter
, &link_up
, &mac_speed
,
584 &qos_link_speed
) != 0) {
585 test
->flags
|= ETH_TEST_FL_FAILED
;
587 } else if (mac_speed
) {
593 be_do_flash(struct net_device
*netdev
, struct ethtool_flash
*efl
)
595 struct be_adapter
*adapter
= netdev_priv(netdev
);
596 char file_name
[ETHTOOL_FLASH_MAX_FILENAME
];
599 file_name
[ETHTOOL_FLASH_MAX_FILENAME
- 1] = 0;
600 strcpy(file_name
, efl
->data
);
601 region
= efl
->region
;
603 return be_load_fw(adapter
, file_name
);
607 be_get_eeprom_len(struct net_device
*netdev
)
609 return BE_READ_SEEPROM_LEN
;
613 be_read_eeprom(struct net_device
*netdev
, struct ethtool_eeprom
*eeprom
,
616 struct be_adapter
*adapter
= netdev_priv(netdev
);
617 struct be_dma_mem eeprom_cmd
;
618 struct be_cmd_resp_seeprom_read
*resp
;
624 eeprom
->magic
= BE_VENDOR_ID
| (adapter
->pdev
->device
<<16);
626 memset(&eeprom_cmd
, 0, sizeof(struct be_dma_mem
));
627 eeprom_cmd
.size
= sizeof(struct be_cmd_req_seeprom_read
);
628 eeprom_cmd
.va
= pci_alloc_consistent(adapter
->pdev
, eeprom_cmd
.size
,
631 if (!eeprom_cmd
.va
) {
632 dev_err(&adapter
->pdev
->dev
,
633 "Memory allocation failure. Could not read eeprom\n");
637 status
= be_cmd_get_seeprom_data(adapter
, &eeprom_cmd
);
640 resp
= (struct be_cmd_resp_seeprom_read
*) eeprom_cmd
.va
;
641 memcpy(data
, resp
->seeprom_data
+ eeprom
->offset
, eeprom
->len
);
643 pci_free_consistent(adapter
->pdev
, eeprom_cmd
.size
, eeprom_cmd
.va
,
649 const struct ethtool_ops be_ethtool_ops
= {
650 .get_settings
= be_get_settings
,
651 .get_drvinfo
= be_get_drvinfo
,
652 .get_wol
= be_get_wol
,
653 .set_wol
= be_set_wol
,
654 .get_link
= ethtool_op_get_link
,
655 .get_eeprom_len
= be_get_eeprom_len
,
656 .get_eeprom
= be_read_eeprom
,
657 .get_coalesce
= be_get_coalesce
,
658 .set_coalesce
= be_set_coalesce
,
659 .get_ringparam
= be_get_ringparam
,
660 .get_pauseparam
= be_get_pauseparam
,
661 .set_pauseparam
= be_set_pauseparam
,
662 .get_rx_csum
= be_get_rx_csum
,
663 .set_rx_csum
= be_set_rx_csum
,
664 .get_tx_csum
= ethtool_op_get_tx_csum
,
665 .set_tx_csum
= ethtool_op_set_tx_hw_csum
,
666 .get_sg
= ethtool_op_get_sg
,
667 .set_sg
= ethtool_op_set_sg
,
668 .get_tso
= ethtool_op_get_tso
,
669 .set_tso
= ethtool_op_set_tso
,
670 .get_strings
= be_get_stat_strings
,
671 .phys_id
= be_phys_id
,
672 .get_sset_count
= be_get_sset_count
,
673 .get_ethtool_stats
= be_get_ethtool_stats
,
674 .flash_device
= be_do_flash
,
675 .self_test
= be_self_test
,