2 * Copyright (C) 2005 - 2014 Emulex
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@emulex.com
15 * Costa Mesa, CA 92626
20 #include <linux/ethtool.h>
22 struct be_ethtool_stat
{
23 char desc
[ETH_GSTRING_LEN
];
29 enum {DRVSTAT_TX
, DRVSTAT_RX
, DRVSTAT
};
30 #define FIELDINFO(_struct, field) FIELD_SIZEOF(_struct, field), \
31 offsetof(_struct, field)
32 #define DRVSTAT_TX_INFO(field) #field, DRVSTAT_TX,\
33 FIELDINFO(struct be_tx_stats, field)
34 #define DRVSTAT_RX_INFO(field) #field, DRVSTAT_RX,\
35 FIELDINFO(struct be_rx_stats, field)
36 #define DRVSTAT_INFO(field) #field, DRVSTAT,\
37 FIELDINFO(struct be_drv_stats, field)
39 static const struct be_ethtool_stat et_stats
[] = {
40 {DRVSTAT_INFO(rx_crc_errors
)},
41 {DRVSTAT_INFO(rx_alignment_symbol_errors
)},
42 {DRVSTAT_INFO(rx_pause_frames
)},
43 {DRVSTAT_INFO(rx_control_frames
)},
44 /* Received packets dropped when the Ethernet length field
45 * is not equal to the actual Ethernet data length.
47 {DRVSTAT_INFO(rx_in_range_errors
)},
48 /* Received packets dropped when their length field is >= 1501 bytes
51 {DRVSTAT_INFO(rx_out_range_errors
)},
52 /* Received packets dropped when they are longer than 9216 bytes */
53 {DRVSTAT_INFO(rx_frame_too_long
)},
54 /* Received packets dropped when they don't pass the unicast or
55 * multicast address filtering.
57 {DRVSTAT_INFO(rx_address_filtered
)},
58 /* Received packets dropped when IP packet length field is less than
59 * the IP header length field.
61 {DRVSTAT_INFO(rx_dropped_too_small
)},
62 /* Received packets dropped when IP length field is greater than
63 * the actual packet length.
65 {DRVSTAT_INFO(rx_dropped_too_short
)},
66 /* Received packets dropped when the IP header length field is less
69 {DRVSTAT_INFO(rx_dropped_header_too_small
)},
70 /* Received packets dropped when the TCP header length field is less
71 * than 5 or the TCP header length + IP header length is more
72 * than IP packet length.
74 {DRVSTAT_INFO(rx_dropped_tcp_length
)},
75 {DRVSTAT_INFO(rx_dropped_runt
)},
76 /* Number of received packets dropped when a fifo for descriptors going
77 * into the packet demux block overflows. In normal operation, this
78 * fifo must never overflow.
80 {DRVSTAT_INFO(rxpp_fifo_overflow_drop
)},
81 /* Received packets dropped when the RX block runs out of space in
82 * one of its input FIFOs. This could happen due a long burst of
83 * minimum-sized (64b) frames in the receive path.
84 * This counter may also be erroneously incremented rarely.
86 {DRVSTAT_INFO(rx_input_fifo_overflow_drop
)},
87 {DRVSTAT_INFO(rx_ip_checksum_errs
)},
88 {DRVSTAT_INFO(rx_tcp_checksum_errs
)},
89 {DRVSTAT_INFO(rx_udp_checksum_errs
)},
90 {DRVSTAT_INFO(tx_pauseframes
)},
91 {DRVSTAT_INFO(tx_controlframes
)},
92 {DRVSTAT_INFO(rx_priority_pause_frames
)},
93 {DRVSTAT_INFO(tx_priority_pauseframes
)},
94 /* Received packets dropped when an internal fifo going into
95 * main packet buffer tank (PMEM) overflows.
97 {DRVSTAT_INFO(pmem_fifo_overflow_drop
)},
98 {DRVSTAT_INFO(jabber_events
)},
99 /* Received packets dropped due to lack of available HW packet buffers
100 * used to temporarily hold the received packets.
102 {DRVSTAT_INFO(rx_drops_no_pbuf
)},
103 /* Received packets dropped due to input receive buffer
104 * descriptor fifo overflowing.
106 {DRVSTAT_INFO(rx_drops_no_erx_descr
)},
107 /* Packets dropped because the internal FIFO to the offloaded TCP
108 * receive processing block is full. This could happen only for
109 * offloaded iSCSI or FCoE trarffic.
111 {DRVSTAT_INFO(rx_drops_no_tpre_descr
)},
112 /* Received packets dropped when they need more than 8
113 * receive buffers. This cannot happen as the driver configures
114 * 2048 byte receive buffers.
116 {DRVSTAT_INFO(rx_drops_too_many_frags
)},
117 {DRVSTAT_INFO(forwarded_packets
)},
118 /* Received packets dropped when the frame length
119 * is more than 9018 bytes
121 {DRVSTAT_INFO(rx_drops_mtu
)},
122 /* Number of dma mapping errors */
123 {DRVSTAT_INFO(dma_map_errors
)},
124 /* Number of packets dropped due to random early drop function */
125 {DRVSTAT_INFO(eth_red_drops
)},
126 {DRVSTAT_INFO(be_on_die_temperature
)},
127 {DRVSTAT_INFO(rx_roce_bytes_lsd
)},
128 {DRVSTAT_INFO(rx_roce_bytes_msd
)},
129 {DRVSTAT_INFO(rx_roce_frames
)},
130 {DRVSTAT_INFO(roce_drops_payload_len
)},
131 {DRVSTAT_INFO(roce_drops_crc
)}
134 #define ETHTOOL_STATS_NUM ARRAY_SIZE(et_stats)
136 /* Stats related to multi RX queues: get_stats routine assumes bytes, pkts
137 * are first and second members respectively.
139 static const struct be_ethtool_stat et_rx_stats
[] = {
140 {DRVSTAT_RX_INFO(rx_bytes
)},/* If moving this member see above note */
141 {DRVSTAT_RX_INFO(rx_pkts
)}, /* If moving this member see above note */
142 {DRVSTAT_RX_INFO(rx_compl
)},
143 {DRVSTAT_RX_INFO(rx_compl_err
)},
144 {DRVSTAT_RX_INFO(rx_mcast_pkts
)},
145 /* Number of page allocation failures while posting receive buffers
148 {DRVSTAT_RX_INFO(rx_post_fail
)},
149 /* Recevied packets dropped due to skb allocation failure */
150 {DRVSTAT_RX_INFO(rx_drops_no_skbs
)},
151 /* Received packets dropped due to lack of available fetched buffers
152 * posted by the driver.
154 {DRVSTAT_RX_INFO(rx_drops_no_frags
)}
157 #define ETHTOOL_RXSTATS_NUM (ARRAY_SIZE(et_rx_stats))
159 /* Stats related to multi TX queues: get_stats routine assumes compl is the
162 static const struct be_ethtool_stat et_tx_stats
[] = {
163 {DRVSTAT_TX_INFO(tx_compl
)}, /* If moving this member see above note */
164 /* This counter is incremented when the HW encounters an error while
165 * parsing the packet header of an outgoing TX request. This counter is
166 * applicable only for BE2, BE3 and Skyhawk based adapters.
168 {DRVSTAT_TX_INFO(tx_hdr_parse_err
)},
169 /* This counter is incremented when an error occurs in the DMA
170 * operation associated with the TX request from the host to the device.
172 {DRVSTAT_TX_INFO(tx_dma_err
)},
173 /* This counter is incremented when MAC or VLAN spoof checking is
174 * enabled on the interface and the TX request fails the spoof check
177 {DRVSTAT_TX_INFO(tx_spoof_check_err
)},
178 /* This counter is incremented when the HW encounters an error while
179 * performing TSO offload. This counter is applicable only for Lancer
182 {DRVSTAT_TX_INFO(tx_tso_err
)},
183 /* This counter is incremented when the HW detects Q-in-Q style VLAN
184 * tagging in a packet and such tagging is not expected on the outgoing
185 * interface. This counter is applicable only for Lancer adapters.
187 {DRVSTAT_TX_INFO(tx_qinq_err
)},
188 /* This counter is incremented when the HW detects parity errors in the
189 * packet data. This counter is applicable only for Lancer adapters.
191 {DRVSTAT_TX_INFO(tx_internal_parity_err
)},
192 {DRVSTAT_TX_INFO(tx_bytes
)},
193 {DRVSTAT_TX_INFO(tx_pkts
)},
194 /* Number of skbs queued for trasmission by the driver */
195 {DRVSTAT_TX_INFO(tx_reqs
)},
196 /* Number of TX work request blocks DMAed to HW */
197 {DRVSTAT_TX_INFO(tx_wrbs
)},
198 /* Number of times the TX queue was stopped due to lack
199 * of spaces in the TXQ.
201 {DRVSTAT_TX_INFO(tx_stops
)},
202 /* Pkts dropped in the driver's transmit path */
203 {DRVSTAT_TX_INFO(tx_drv_drops
)}
206 #define ETHTOOL_TXSTATS_NUM (ARRAY_SIZE(et_tx_stats))
208 static const char et_self_tests
[][ETH_GSTRING_LEN
] = {
211 "External Loopback test",
216 #define ETHTOOL_TESTS_NUM ARRAY_SIZE(et_self_tests)
217 #define BE_MAC_LOOPBACK 0x0
218 #define BE_PHY_LOOPBACK 0x1
219 #define BE_ONE_PORT_EXT_LOOPBACK 0x2
220 #define BE_NO_LOOPBACK 0xff
222 static void be_get_drvinfo(struct net_device
*netdev
,
223 struct ethtool_drvinfo
*drvinfo
)
225 struct be_adapter
*adapter
= netdev_priv(netdev
);
227 strlcpy(drvinfo
->driver
, DRV_NAME
, sizeof(drvinfo
->driver
));
228 strlcpy(drvinfo
->version
, DRV_VER
, sizeof(drvinfo
->version
));
229 if (!memcmp(adapter
->fw_ver
, adapter
->fw_on_flash
, FW_VER_LEN
))
230 strlcpy(drvinfo
->fw_version
, adapter
->fw_ver
,
231 sizeof(drvinfo
->fw_version
));
233 snprintf(drvinfo
->fw_version
, sizeof(drvinfo
->fw_version
),
234 "%s [%s]", adapter
->fw_ver
, adapter
->fw_on_flash
);
236 strlcpy(drvinfo
->bus_info
, pci_name(adapter
->pdev
),
237 sizeof(drvinfo
->bus_info
));
238 drvinfo
->testinfo_len
= 0;
239 drvinfo
->regdump_len
= 0;
240 drvinfo
->eedump_len
= 0;
243 static u32
lancer_cmd_get_file_len(struct be_adapter
*adapter
, u8
*file_name
)
245 u32 data_read
= 0, eof
;
247 struct be_dma_mem data_len_cmd
;
250 memset(&data_len_cmd
, 0, sizeof(data_len_cmd
));
251 /* data_offset and data_size should be 0 to get reg len */
252 status
= lancer_cmd_read_object(adapter
, &data_len_cmd
, 0, 0,
253 file_name
, &data_read
, &eof
,
259 static int lancer_cmd_read_file(struct be_adapter
*adapter
, u8
*file_name
,
260 u32 buf_len
, void *buf
)
262 struct be_dma_mem read_cmd
;
263 u32 read_len
= 0, total_read_len
= 0, chunk_size
;
268 read_cmd
.size
= LANCER_READ_FILE_CHUNK
;
269 read_cmd
.va
= pci_alloc_consistent(adapter
->pdev
, read_cmd
.size
,
273 dev_err(&adapter
->pdev
->dev
,
274 "Memory allocation failure while reading dump\n");
278 while ((total_read_len
< buf_len
) && !eof
) {
279 chunk_size
= min_t(u32
, (buf_len
- total_read_len
),
280 LANCER_READ_FILE_CHUNK
);
281 chunk_size
= ALIGN(chunk_size
, 4);
282 status
= lancer_cmd_read_object(adapter
, &read_cmd
, chunk_size
,
283 total_read_len
, file_name
,
284 &read_len
, &eof
, &addn_status
);
286 memcpy(buf
+ total_read_len
, read_cmd
.va
, read_len
);
287 total_read_len
+= read_len
;
288 eof
&= LANCER_READ_FILE_EOF_MASK
;
294 pci_free_consistent(adapter
->pdev
, read_cmd
.size
, read_cmd
.va
,
300 static int be_get_reg_len(struct net_device
*netdev
)
302 struct be_adapter
*adapter
= netdev_priv(netdev
);
305 if (!check_privilege(adapter
, MAX_PRIVILEGES
))
308 if (be_physfn(adapter
)) {
309 if (lancer_chip(adapter
))
310 log_size
= lancer_cmd_get_file_len(adapter
,
311 LANCER_FW_DUMP_FILE
);
313 be_cmd_get_reg_len(adapter
, &log_size
);
319 be_get_regs(struct net_device
*netdev
, struct ethtool_regs
*regs
, void *buf
)
321 struct be_adapter
*adapter
= netdev_priv(netdev
);
323 if (be_physfn(adapter
)) {
324 memset(buf
, 0, regs
->len
);
325 if (lancer_chip(adapter
))
326 lancer_cmd_read_file(adapter
, LANCER_FW_DUMP_FILE
,
329 be_cmd_get_regs(adapter
, regs
->len
, buf
);
333 static int be_get_coalesce(struct net_device
*netdev
,
334 struct ethtool_coalesce
*et
)
336 struct be_adapter
*adapter
= netdev_priv(netdev
);
337 struct be_aic_obj
*aic
= &adapter
->aic_obj
[0];
339 et
->rx_coalesce_usecs
= aic
->prev_eqd
;
340 et
->rx_coalesce_usecs_high
= aic
->max_eqd
;
341 et
->rx_coalesce_usecs_low
= aic
->min_eqd
;
343 et
->tx_coalesce_usecs
= aic
->prev_eqd
;
344 et
->tx_coalesce_usecs_high
= aic
->max_eqd
;
345 et
->tx_coalesce_usecs_low
= aic
->min_eqd
;
347 et
->use_adaptive_rx_coalesce
= aic
->enable
;
348 et
->use_adaptive_tx_coalesce
= aic
->enable
;
353 /* TX attributes are ignored. Only RX attributes are considered
354 * eqd cmd is issued in the worker thread.
356 static int be_set_coalesce(struct net_device
*netdev
,
357 struct ethtool_coalesce
*et
)
359 struct be_adapter
*adapter
= netdev_priv(netdev
);
360 struct be_aic_obj
*aic
= &adapter
->aic_obj
[0];
361 struct be_eq_obj
*eqo
;
364 for_all_evt_queues(adapter
, eqo
, i
) {
365 aic
->enable
= et
->use_adaptive_rx_coalesce
;
366 aic
->max_eqd
= min(et
->rx_coalesce_usecs_high
, BE_MAX_EQD
);
367 aic
->min_eqd
= min(et
->rx_coalesce_usecs_low
, aic
->max_eqd
);
368 aic
->et_eqd
= min(et
->rx_coalesce_usecs
, aic
->max_eqd
);
369 aic
->et_eqd
= max(aic
->et_eqd
, aic
->min_eqd
);
376 static void be_get_ethtool_stats(struct net_device
*netdev
,
377 struct ethtool_stats
*stats
, uint64_t *data
)
379 struct be_adapter
*adapter
= netdev_priv(netdev
);
380 struct be_rx_obj
*rxo
;
381 struct be_tx_obj
*txo
;
383 unsigned int i
, j
, base
= 0, start
;
385 for (i
= 0; i
< ETHTOOL_STATS_NUM
; i
++) {
386 p
= (u8
*)&adapter
->drv_stats
+ et_stats
[i
].offset
;
389 base
+= ETHTOOL_STATS_NUM
;
391 for_all_rx_queues(adapter
, rxo
, j
) {
392 struct be_rx_stats
*stats
= rx_stats(rxo
);
395 start
= u64_stats_fetch_begin_irq(&stats
->sync
);
396 data
[base
] = stats
->rx_bytes
;
397 data
[base
+ 1] = stats
->rx_pkts
;
398 } while (u64_stats_fetch_retry_irq(&stats
->sync
, start
));
400 for (i
= 2; i
< ETHTOOL_RXSTATS_NUM
; i
++) {
401 p
= (u8
*)stats
+ et_rx_stats
[i
].offset
;
402 data
[base
+ i
] = *(u32
*)p
;
404 base
+= ETHTOOL_RXSTATS_NUM
;
407 for_all_tx_queues(adapter
, txo
, j
) {
408 struct be_tx_stats
*stats
= tx_stats(txo
);
411 start
= u64_stats_fetch_begin_irq(&stats
->sync_compl
);
412 data
[base
] = stats
->tx_compl
;
413 } while (u64_stats_fetch_retry_irq(&stats
->sync_compl
, start
));
416 start
= u64_stats_fetch_begin_irq(&stats
->sync
);
417 for (i
= 1; i
< ETHTOOL_TXSTATS_NUM
; i
++) {
418 p
= (u8
*)stats
+ et_tx_stats
[i
].offset
;
420 (et_tx_stats
[i
].size
== sizeof(u64
)) ?
421 *(u64
*)p
: *(u32
*)p
;
423 } while (u64_stats_fetch_retry_irq(&stats
->sync
, start
));
424 base
+= ETHTOOL_TXSTATS_NUM
;
428 static void be_get_stat_strings(struct net_device
*netdev
, uint32_t stringset
,
431 struct be_adapter
*adapter
= netdev_priv(netdev
);
436 for (i
= 0; i
< ETHTOOL_STATS_NUM
; i
++) {
437 memcpy(data
, et_stats
[i
].desc
, ETH_GSTRING_LEN
);
438 data
+= ETH_GSTRING_LEN
;
440 for (i
= 0; i
< adapter
->num_rx_qs
; i
++) {
441 for (j
= 0; j
< ETHTOOL_RXSTATS_NUM
; j
++) {
442 sprintf(data
, "rxq%d: %s", i
,
443 et_rx_stats
[j
].desc
);
444 data
+= ETH_GSTRING_LEN
;
447 for (i
= 0; i
< adapter
->num_tx_qs
; i
++) {
448 for (j
= 0; j
< ETHTOOL_TXSTATS_NUM
; j
++) {
449 sprintf(data
, "txq%d: %s", i
,
450 et_tx_stats
[j
].desc
);
451 data
+= ETH_GSTRING_LEN
;
456 for (i
= 0; i
< ETHTOOL_TESTS_NUM
; i
++) {
457 memcpy(data
, et_self_tests
[i
], ETH_GSTRING_LEN
);
458 data
+= ETH_GSTRING_LEN
;
464 static int be_get_sset_count(struct net_device
*netdev
, int stringset
)
466 struct be_adapter
*adapter
= netdev_priv(netdev
);
470 return ETHTOOL_TESTS_NUM
;
472 return ETHTOOL_STATS_NUM
+
473 adapter
->num_rx_qs
* ETHTOOL_RXSTATS_NUM
+
474 adapter
->num_tx_qs
* ETHTOOL_TXSTATS_NUM
;
480 static u32
be_get_port_type(struct be_adapter
*adapter
)
484 switch (adapter
->phy
.interface_type
) {
485 case PHY_TYPE_BASET_1GB
:
486 case PHY_TYPE_BASEX_1GB
:
490 case PHY_TYPE_SFP_PLUS_10GB
:
491 if (adapter
->phy
.cable_type
& SFP_PLUS_COPPER_CABLE
)
497 if (adapter
->phy
.cable_type
& QSFP_PLUS_CR4_CABLE
)
502 case PHY_TYPE_XFP_10GB
:
503 case PHY_TYPE_SFP_1GB
:
506 case PHY_TYPE_BASET_10GB
:
516 static u32
convert_to_et_setting(struct be_adapter
*adapter
, u32 if_speeds
)
520 switch (adapter
->phy
.interface_type
) {
521 case PHY_TYPE_BASET_1GB
:
522 case PHY_TYPE_BASEX_1GB
:
525 if (if_speeds
& BE_SUPPORTED_SPEED_1GBPS
)
526 val
|= SUPPORTED_1000baseT_Full
;
527 if (if_speeds
& BE_SUPPORTED_SPEED_100MBPS
)
528 val
|= SUPPORTED_100baseT_Full
;
529 if (if_speeds
& BE_SUPPORTED_SPEED_10MBPS
)
530 val
|= SUPPORTED_10baseT_Full
;
532 case PHY_TYPE_KX4_10GB
:
533 val
|= SUPPORTED_Backplane
;
534 if (if_speeds
& BE_SUPPORTED_SPEED_1GBPS
)
535 val
|= SUPPORTED_1000baseKX_Full
;
536 if (if_speeds
& BE_SUPPORTED_SPEED_10GBPS
)
537 val
|= SUPPORTED_10000baseKX4_Full
;
539 case PHY_TYPE_KR2_20GB
:
540 val
|= SUPPORTED_Backplane
;
541 if (if_speeds
& BE_SUPPORTED_SPEED_10GBPS
)
542 val
|= SUPPORTED_10000baseKR_Full
;
543 if (if_speeds
& BE_SUPPORTED_SPEED_20GBPS
)
544 val
|= SUPPORTED_20000baseKR2_Full
;
546 case PHY_TYPE_KR_10GB
:
547 val
|= SUPPORTED_Backplane
|
548 SUPPORTED_10000baseKR_Full
;
550 case PHY_TYPE_KR4_40GB
:
551 val
|= SUPPORTED_Backplane
;
552 if (if_speeds
& BE_SUPPORTED_SPEED_10GBPS
)
553 val
|= SUPPORTED_10000baseKR_Full
;
554 if (if_speeds
& BE_SUPPORTED_SPEED_40GBPS
)
555 val
|= SUPPORTED_40000baseKR4_Full
;
558 if (if_speeds
& BE_SUPPORTED_SPEED_40GBPS
) {
559 switch (adapter
->phy
.cable_type
) {
560 case QSFP_PLUS_CR4_CABLE
:
561 val
|= SUPPORTED_40000baseCR4_Full
;
563 case QSFP_PLUS_LR4_CABLE
:
564 val
|= SUPPORTED_40000baseLR4_Full
;
567 val
|= SUPPORTED_40000baseSR4_Full
;
571 case PHY_TYPE_SFP_PLUS_10GB
:
572 case PHY_TYPE_XFP_10GB
:
573 case PHY_TYPE_SFP_1GB
:
574 val
|= SUPPORTED_FIBRE
;
575 if (if_speeds
& BE_SUPPORTED_SPEED_10GBPS
)
576 val
|= SUPPORTED_10000baseT_Full
;
577 if (if_speeds
& BE_SUPPORTED_SPEED_1GBPS
)
578 val
|= SUPPORTED_1000baseT_Full
;
580 case PHY_TYPE_BASET_10GB
:
582 if (if_speeds
& BE_SUPPORTED_SPEED_10GBPS
)
583 val
|= SUPPORTED_10000baseT_Full
;
584 if (if_speeds
& BE_SUPPORTED_SPEED_1GBPS
)
585 val
|= SUPPORTED_1000baseT_Full
;
586 if (if_speeds
& BE_SUPPORTED_SPEED_100MBPS
)
587 val
|= SUPPORTED_100baseT_Full
;
596 bool be_pause_supported(struct be_adapter
*adapter
)
598 return (adapter
->phy
.interface_type
== PHY_TYPE_SFP_PLUS_10GB
||
599 adapter
->phy
.interface_type
== PHY_TYPE_XFP_10GB
) ?
603 static int be_get_settings(struct net_device
*netdev
, struct ethtool_cmd
*ecmd
)
605 struct be_adapter
*adapter
= netdev_priv(netdev
);
612 if (adapter
->phy
.link_speed
< 0) {
613 status
= be_cmd_link_status_query(adapter
, &link_speed
,
616 be_link_status_update(adapter
, link_status
);
617 ethtool_cmd_speed_set(ecmd
, link_speed
);
619 status
= be_cmd_get_phy_info(adapter
);
621 auto_speeds
= adapter
->phy
.auto_speeds_supported
;
622 fixed_speeds
= adapter
->phy
.fixed_speeds_supported
;
624 be_cmd_query_cable_type(adapter
);
627 convert_to_et_setting(adapter
,
631 convert_to_et_setting(adapter
, auto_speeds
);
633 ecmd
->port
= be_get_port_type(adapter
);
635 if (adapter
->phy
.auto_speeds_supported
) {
636 ecmd
->supported
|= SUPPORTED_Autoneg
;
637 ecmd
->autoneg
= AUTONEG_ENABLE
;
638 ecmd
->advertising
|= ADVERTISED_Autoneg
;
641 ecmd
->supported
|= SUPPORTED_Pause
;
642 if (be_pause_supported(adapter
))
643 ecmd
->advertising
|= ADVERTISED_Pause
;
645 switch (adapter
->phy
.interface_type
) {
646 case PHY_TYPE_KR_10GB
:
647 case PHY_TYPE_KX4_10GB
:
648 ecmd
->transceiver
= XCVR_INTERNAL
;
651 ecmd
->transceiver
= XCVR_EXTERNAL
;
655 ecmd
->port
= PORT_OTHER
;
656 ecmd
->autoneg
= AUTONEG_DISABLE
;
657 ecmd
->transceiver
= XCVR_DUMMY1
;
660 /* Save for future use */
661 adapter
->phy
.link_speed
= ethtool_cmd_speed(ecmd
);
662 adapter
->phy
.port_type
= ecmd
->port
;
663 adapter
->phy
.transceiver
= ecmd
->transceiver
;
664 adapter
->phy
.autoneg
= ecmd
->autoneg
;
665 adapter
->phy
.advertising
= ecmd
->advertising
;
666 adapter
->phy
.supported
= ecmd
->supported
;
668 ethtool_cmd_speed_set(ecmd
, adapter
->phy
.link_speed
);
669 ecmd
->port
= adapter
->phy
.port_type
;
670 ecmd
->transceiver
= adapter
->phy
.transceiver
;
671 ecmd
->autoneg
= adapter
->phy
.autoneg
;
672 ecmd
->advertising
= adapter
->phy
.advertising
;
673 ecmd
->supported
= adapter
->phy
.supported
;
676 ecmd
->duplex
= netif_carrier_ok(netdev
) ? DUPLEX_FULL
: DUPLEX_UNKNOWN
;
677 ecmd
->phy_address
= adapter
->port_num
;
682 static void be_get_ringparam(struct net_device
*netdev
,
683 struct ethtool_ringparam
*ring
)
685 struct be_adapter
*adapter
= netdev_priv(netdev
);
687 ring
->rx_max_pending
= adapter
->rx_obj
[0].q
.len
;
688 ring
->rx_pending
= adapter
->rx_obj
[0].q
.len
;
689 ring
->tx_max_pending
= adapter
->tx_obj
[0].q
.len
;
690 ring
->tx_pending
= adapter
->tx_obj
[0].q
.len
;
694 be_get_pauseparam(struct net_device
*netdev
, struct ethtool_pauseparam
*ecmd
)
696 struct be_adapter
*adapter
= netdev_priv(netdev
);
698 be_cmd_get_flow_control(adapter
, &ecmd
->tx_pause
, &ecmd
->rx_pause
);
699 ecmd
->autoneg
= adapter
->phy
.fc_autoneg
;
703 be_set_pauseparam(struct net_device
*netdev
, struct ethtool_pauseparam
*ecmd
)
705 struct be_adapter
*adapter
= netdev_priv(netdev
);
708 if (ecmd
->autoneg
!= adapter
->phy
.fc_autoneg
)
710 adapter
->tx_fc
= ecmd
->tx_pause
;
711 adapter
->rx_fc
= ecmd
->rx_pause
;
713 status
= be_cmd_set_flow_control(adapter
,
714 adapter
->tx_fc
, adapter
->rx_fc
);
716 dev_warn(&adapter
->pdev
->dev
, "Pause param set failed\n");
718 return be_cmd_status(status
);
721 static int be_set_phys_id(struct net_device
*netdev
,
722 enum ethtool_phys_id_state state
)
724 struct be_adapter
*adapter
= netdev_priv(netdev
);
727 case ETHTOOL_ID_ACTIVE
:
728 be_cmd_get_beacon_state(adapter
, adapter
->hba_port_num
,
729 &adapter
->beacon_state
);
730 return 1; /* cycle on/off once per second */
733 be_cmd_set_beacon_state(adapter
, adapter
->hba_port_num
, 0, 0,
734 BEACON_STATE_ENABLED
);
738 be_cmd_set_beacon_state(adapter
, adapter
->hba_port_num
, 0, 0,
739 BEACON_STATE_DISABLED
);
742 case ETHTOOL_ID_INACTIVE
:
743 be_cmd_set_beacon_state(adapter
, adapter
->hba_port_num
, 0, 0,
744 adapter
->beacon_state
);
750 static int be_set_dump(struct net_device
*netdev
, struct ethtool_dump
*dump
)
752 struct be_adapter
*adapter
= netdev_priv(netdev
);
753 struct device
*dev
= &adapter
->pdev
->dev
;
756 if (!lancer_chip(adapter
) ||
757 !check_privilege(adapter
, MAX_PRIVILEGES
))
760 switch (dump
->flag
) {
761 case LANCER_INITIATE_FW_DUMP
:
762 status
= lancer_initiate_dump(adapter
);
764 dev_info(dev
, "FW dump initiated successfully\n");
766 case LANCER_DELETE_FW_DUMP
:
767 status
= lancer_delete_dump(adapter
);
769 dev_info(dev
, "FW dump deleted successfully\n");
772 dev_err(dev
, "Invalid dump level: 0x%x\n", dump
->flag
);
778 static void be_get_wol(struct net_device
*netdev
, struct ethtool_wolinfo
*wol
)
780 struct be_adapter
*adapter
= netdev_priv(netdev
);
782 if (adapter
->wol_cap
& BE_WOL_CAP
) {
783 wol
->supported
|= WAKE_MAGIC
;
785 wol
->wolopts
|= WAKE_MAGIC
;
789 memset(&wol
->sopass
, 0, sizeof(wol
->sopass
));
792 static int be_set_wol(struct net_device
*netdev
, struct ethtool_wolinfo
*wol
)
794 struct be_adapter
*adapter
= netdev_priv(netdev
);
796 if (wol
->wolopts
& ~WAKE_MAGIC
)
799 if (!(adapter
->wol_cap
& BE_WOL_CAP
)) {
800 dev_warn(&adapter
->pdev
->dev
, "WOL not supported\n");
804 if (wol
->wolopts
& WAKE_MAGIC
)
805 adapter
->wol_en
= true;
807 adapter
->wol_en
= false;
812 static int be_test_ddr_dma(struct be_adapter
*adapter
)
815 struct be_dma_mem ddrdma_cmd
;
816 static const u64 pattern
[2] = {
817 0x5a5a5a5a5a5a5a5aULL
, 0xa5a5a5a5a5a5a5a5ULL
820 ddrdma_cmd
.size
= sizeof(struct be_cmd_req_ddrdma_test
);
821 ddrdma_cmd
.va
= dma_alloc_coherent(&adapter
->pdev
->dev
, ddrdma_cmd
.size
,
822 &ddrdma_cmd
.dma
, GFP_KERNEL
);
826 for (i
= 0; i
< 2; i
++) {
827 ret
= be_cmd_ddr_dma_test(adapter
, pattern
[i
],
834 dma_free_coherent(&adapter
->pdev
->dev
, ddrdma_cmd
.size
, ddrdma_cmd
.va
,
836 return be_cmd_status(ret
);
839 static u64
be_loopback_test(struct be_adapter
*adapter
, u8 loopback_type
,
842 be_cmd_set_loopback(adapter
, adapter
->hba_port_num
, loopback_type
, 1);
843 *status
= be_cmd_loopback_test(adapter
, adapter
->hba_port_num
,
844 loopback_type
, 1500, 2, 0xabc);
845 be_cmd_set_loopback(adapter
, adapter
->hba_port_num
, BE_NO_LOOPBACK
, 1);
849 static void be_self_test(struct net_device
*netdev
, struct ethtool_test
*test
,
852 struct be_adapter
*adapter
= netdev_priv(netdev
);
856 if (adapter
->function_caps
& BE_FUNCTION_CAPS_SUPER_NIC
) {
857 dev_err(&adapter
->pdev
->dev
, "Self test not supported\n");
858 test
->flags
|= ETH_TEST_FL_FAILED
;
862 memset(data
, 0, sizeof(u64
) * ETHTOOL_TESTS_NUM
);
864 if (test
->flags
& ETH_TEST_FL_OFFLINE
) {
865 if (be_loopback_test(adapter
, BE_MAC_LOOPBACK
, &data
[0]) != 0)
866 test
->flags
|= ETH_TEST_FL_FAILED
;
868 if (be_loopback_test(adapter
, BE_PHY_LOOPBACK
, &data
[1]) != 0)
869 test
->flags
|= ETH_TEST_FL_FAILED
;
871 if (test
->flags
& ETH_TEST_FL_EXTERNAL_LB
) {
872 if (be_loopback_test(adapter
, BE_ONE_PORT_EXT_LOOPBACK
,
874 test
->flags
|= ETH_TEST_FL_FAILED
;
875 test
->flags
|= ETH_TEST_FL_EXTERNAL_LB_DONE
;
879 if (!lancer_chip(adapter
) && be_test_ddr_dma(adapter
) != 0) {
881 test
->flags
|= ETH_TEST_FL_FAILED
;
884 status
= be_cmd_link_status_query(adapter
, NULL
, &link_status
, 0);
886 test
->flags
|= ETH_TEST_FL_FAILED
;
888 } else if (!link_status
) {
889 test
->flags
|= ETH_TEST_FL_FAILED
;
894 static int be_do_flash(struct net_device
*netdev
, struct ethtool_flash
*efl
)
896 struct be_adapter
*adapter
= netdev_priv(netdev
);
898 return be_load_fw(adapter
, efl
->data
);
901 static int be_get_eeprom_len(struct net_device
*netdev
)
903 struct be_adapter
*adapter
= netdev_priv(netdev
);
905 if (!check_privilege(adapter
, MAX_PRIVILEGES
))
908 if (lancer_chip(adapter
)) {
909 if (be_physfn(adapter
))
910 return lancer_cmd_get_file_len(adapter
,
913 return lancer_cmd_get_file_len(adapter
,
916 return BE_READ_SEEPROM_LEN
;
920 static int be_read_eeprom(struct net_device
*netdev
,
921 struct ethtool_eeprom
*eeprom
, uint8_t *data
)
923 struct be_adapter
*adapter
= netdev_priv(netdev
);
924 struct be_dma_mem eeprom_cmd
;
925 struct be_cmd_resp_seeprom_read
*resp
;
931 if (lancer_chip(adapter
)) {
932 if (be_physfn(adapter
))
933 return lancer_cmd_read_file(adapter
, LANCER_VPD_PF_FILE
,
936 return lancer_cmd_read_file(adapter
, LANCER_VPD_VF_FILE
,
940 eeprom
->magic
= BE_VENDOR_ID
| (adapter
->pdev
->device
<<16);
942 memset(&eeprom_cmd
, 0, sizeof(struct be_dma_mem
));
943 eeprom_cmd
.size
= sizeof(struct be_cmd_req_seeprom_read
);
944 eeprom_cmd
.va
= dma_alloc_coherent(&adapter
->pdev
->dev
, eeprom_cmd
.size
,
945 &eeprom_cmd
.dma
, GFP_KERNEL
);
950 status
= be_cmd_get_seeprom_data(adapter
, &eeprom_cmd
);
953 resp
= eeprom_cmd
.va
;
954 memcpy(data
, resp
->seeprom_data
+ eeprom
->offset
, eeprom
->len
);
956 dma_free_coherent(&adapter
->pdev
->dev
, eeprom_cmd
.size
, eeprom_cmd
.va
,
959 return be_cmd_status(status
);
962 static u32
be_get_msg_level(struct net_device
*netdev
)
964 struct be_adapter
*adapter
= netdev_priv(netdev
);
966 return adapter
->msg_enable
;
969 static void be_set_msg_level(struct net_device
*netdev
, u32 level
)
971 struct be_adapter
*adapter
= netdev_priv(netdev
);
973 if (adapter
->msg_enable
== level
)
976 if ((level
& NETIF_MSG_HW
) != (adapter
->msg_enable
& NETIF_MSG_HW
))
977 if (BEx_chip(adapter
))
978 be_cmd_set_fw_log_level(adapter
, level
& NETIF_MSG_HW
?
979 FW_LOG_LEVEL_DEFAULT
:
981 adapter
->msg_enable
= level
;
984 static u64
be_get_rss_hash_opts(struct be_adapter
*adapter
, u64 flow_type
)
990 if (adapter
->rss_info
.rss_flags
& RSS_ENABLE_IPV4
)
991 data
|= RXH_IP_DST
| RXH_IP_SRC
;
992 if (adapter
->rss_info
.rss_flags
& RSS_ENABLE_TCP_IPV4
)
993 data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
996 if (adapter
->rss_info
.rss_flags
& RSS_ENABLE_IPV4
)
997 data
|= RXH_IP_DST
| RXH_IP_SRC
;
998 if (adapter
->rss_info
.rss_flags
& RSS_ENABLE_UDP_IPV4
)
999 data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
1002 if (adapter
->rss_info
.rss_flags
& RSS_ENABLE_IPV6
)
1003 data
|= RXH_IP_DST
| RXH_IP_SRC
;
1004 if (adapter
->rss_info
.rss_flags
& RSS_ENABLE_TCP_IPV6
)
1005 data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
1008 if (adapter
->rss_info
.rss_flags
& RSS_ENABLE_IPV6
)
1009 data
|= RXH_IP_DST
| RXH_IP_SRC
;
1010 if (adapter
->rss_info
.rss_flags
& RSS_ENABLE_UDP_IPV6
)
1011 data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
1018 static int be_get_rxnfc(struct net_device
*netdev
, struct ethtool_rxnfc
*cmd
,
1021 struct be_adapter
*adapter
= netdev_priv(netdev
);
1023 if (!be_multi_rxq(adapter
)) {
1024 dev_info(&adapter
->pdev
->dev
,
1025 "ethtool::get_rxnfc: RX flow hashing is disabled\n");
1031 cmd
->data
= be_get_rss_hash_opts(adapter
, cmd
->flow_type
);
1033 case ETHTOOL_GRXRINGS
:
1034 cmd
->data
= adapter
->num_rx_qs
- 1;
1043 static int be_set_rss_hash_opts(struct be_adapter
*adapter
,
1044 struct ethtool_rxnfc
*cmd
)
1046 struct be_rx_obj
*rxo
;
1047 int status
= 0, i
, j
;
1049 u32 rss_flags
= adapter
->rss_info
.rss_flags
;
1051 if (cmd
->data
!= L3_RSS_FLAGS
&&
1052 cmd
->data
!= (L3_RSS_FLAGS
| L4_RSS_FLAGS
))
1055 switch (cmd
->flow_type
) {
1057 if (cmd
->data
== L3_RSS_FLAGS
)
1058 rss_flags
&= ~RSS_ENABLE_TCP_IPV4
;
1059 else if (cmd
->data
== (L3_RSS_FLAGS
| L4_RSS_FLAGS
))
1060 rss_flags
|= RSS_ENABLE_IPV4
|
1061 RSS_ENABLE_TCP_IPV4
;
1064 if (cmd
->data
== L3_RSS_FLAGS
)
1065 rss_flags
&= ~RSS_ENABLE_TCP_IPV6
;
1066 else if (cmd
->data
== (L3_RSS_FLAGS
| L4_RSS_FLAGS
))
1067 rss_flags
|= RSS_ENABLE_IPV6
|
1068 RSS_ENABLE_TCP_IPV6
;
1071 if ((cmd
->data
== (L3_RSS_FLAGS
| L4_RSS_FLAGS
)) &&
1075 if (cmd
->data
== L3_RSS_FLAGS
)
1076 rss_flags
&= ~RSS_ENABLE_UDP_IPV4
;
1077 else if (cmd
->data
== (L3_RSS_FLAGS
| L4_RSS_FLAGS
))
1078 rss_flags
|= RSS_ENABLE_IPV4
|
1079 RSS_ENABLE_UDP_IPV4
;
1082 if ((cmd
->data
== (L3_RSS_FLAGS
| L4_RSS_FLAGS
)) &&
1086 if (cmd
->data
== L3_RSS_FLAGS
)
1087 rss_flags
&= ~RSS_ENABLE_UDP_IPV6
;
1088 else if (cmd
->data
== (L3_RSS_FLAGS
| L4_RSS_FLAGS
))
1089 rss_flags
|= RSS_ENABLE_IPV6
|
1090 RSS_ENABLE_UDP_IPV6
;
1096 if (rss_flags
== adapter
->rss_info
.rss_flags
)
1099 if (be_multi_rxq(adapter
)) {
1100 for (j
= 0; j
< 128; j
+= adapter
->num_rx_qs
- 1) {
1101 for_all_rss_queues(adapter
, rxo
, i
) {
1104 rsstable
[j
+ i
] = rxo
->rss_id
;
1109 status
= be_cmd_rss_config(adapter
, adapter
->rss_info
.rsstable
,
1110 rss_flags
, 128, adapter
->rss_info
.rss_hkey
);
1112 adapter
->rss_info
.rss_flags
= rss_flags
;
1114 return be_cmd_status(status
);
1117 static int be_set_rxnfc(struct net_device
*netdev
, struct ethtool_rxnfc
*cmd
)
1119 struct be_adapter
*adapter
= netdev_priv(netdev
);
1122 if (!be_multi_rxq(adapter
)) {
1123 dev_err(&adapter
->pdev
->dev
,
1124 "ethtool::set_rxnfc: RX flow hashing is disabled\n");
1130 status
= be_set_rss_hash_opts(adapter
, cmd
);
1139 static void be_get_channels(struct net_device
*netdev
,
1140 struct ethtool_channels
*ch
)
1142 struct be_adapter
*adapter
= netdev_priv(netdev
);
1144 ch
->combined_count
= adapter
->num_evt_qs
;
1145 ch
->max_combined
= be_max_qs(adapter
);
1148 static int be_set_channels(struct net_device
*netdev
,
1149 struct ethtool_channels
*ch
)
1151 struct be_adapter
*adapter
= netdev_priv(netdev
);
1154 if (ch
->rx_count
|| ch
->tx_count
|| ch
->other_count
||
1155 !ch
->combined_count
|| ch
->combined_count
> be_max_qs(adapter
))
1158 adapter
->cfg_num_qs
= ch
->combined_count
;
1160 status
= be_update_queues(adapter
);
1161 return be_cmd_status(status
);
1164 static u32
be_get_rxfh_indir_size(struct net_device
*netdev
)
1166 return RSS_INDIR_TABLE_LEN
;
1169 static u32
be_get_rxfh_key_size(struct net_device
*netdev
)
1171 return RSS_HASH_KEY_LEN
;
1174 static int be_get_rxfh(struct net_device
*netdev
, u32
*indir
, u8
*hkey
)
1176 struct be_adapter
*adapter
= netdev_priv(netdev
);
1178 struct rss_info
*rss
= &adapter
->rss_info
;
1181 for (i
= 0; i
< RSS_INDIR_TABLE_LEN
; i
++)
1182 indir
[i
] = rss
->rss_queue
[i
];
1186 memcpy(hkey
, rss
->rss_hkey
, RSS_HASH_KEY_LEN
);
1191 static int be_set_rxfh(struct net_device
*netdev
, const u32
*indir
,
1195 struct be_adapter
*adapter
= netdev_priv(netdev
);
1196 u8 rsstable
[RSS_INDIR_TABLE_LEN
];
1199 struct be_rx_obj
*rxo
;
1201 for (i
= 0; i
< RSS_INDIR_TABLE_LEN
; i
++) {
1203 rxo
= &adapter
->rx_obj
[j
];
1204 rsstable
[i
] = rxo
->rss_id
;
1205 adapter
->rss_info
.rss_queue
[i
] = j
;
1208 memcpy(rsstable
, adapter
->rss_info
.rsstable
,
1209 RSS_INDIR_TABLE_LEN
);
1213 hkey
= adapter
->rss_info
.rss_hkey
;
1215 rc
= be_cmd_rss_config(adapter
, rsstable
,
1216 adapter
->rss_info
.rss_flags
,
1217 RSS_INDIR_TABLE_LEN
, hkey
);
1219 adapter
->rss_info
.rss_flags
= RSS_ENABLE_NONE
;
1222 memcpy(adapter
->rss_info
.rss_hkey
, hkey
, RSS_HASH_KEY_LEN
);
1223 memcpy(adapter
->rss_info
.rsstable
, rsstable
,
1224 RSS_INDIR_TABLE_LEN
);
1228 static int be_get_module_info(struct net_device
*netdev
,
1229 struct ethtool_modinfo
*modinfo
)
1231 struct be_adapter
*adapter
= netdev_priv(netdev
);
1232 u8 page_data
[PAGE_DATA_LEN
];
1235 if (!check_privilege(adapter
, MAX_PRIVILEGES
))
1238 status
= be_cmd_read_port_transceiver_data(adapter
, TR_PAGE_A0
,
1241 if (!page_data
[SFP_PLUS_SFF_8472_COMP
]) {
1242 modinfo
->type
= ETH_MODULE_SFF_8079
;
1243 modinfo
->eeprom_len
= PAGE_DATA_LEN
;
1245 modinfo
->type
= ETH_MODULE_SFF_8472
;
1246 modinfo
->eeprom_len
= 2 * PAGE_DATA_LEN
;
1249 return be_cmd_status(status
);
1252 static int be_get_module_eeprom(struct net_device
*netdev
,
1253 struct ethtool_eeprom
*eeprom
, u8
*data
)
1255 struct be_adapter
*adapter
= netdev_priv(netdev
);
1258 if (!check_privilege(adapter
, MAX_PRIVILEGES
))
1261 status
= be_cmd_read_port_transceiver_data(adapter
, TR_PAGE_A0
,
1266 if (eeprom
->offset
+ eeprom
->len
> PAGE_DATA_LEN
) {
1267 status
= be_cmd_read_port_transceiver_data(adapter
,
1275 memcpy(data
, data
+ eeprom
->offset
, eeprom
->len
);
1277 return be_cmd_status(status
);
1280 const struct ethtool_ops be_ethtool_ops
= {
1281 .get_settings
= be_get_settings
,
1282 .get_drvinfo
= be_get_drvinfo
,
1283 .get_wol
= be_get_wol
,
1284 .set_wol
= be_set_wol
,
1285 .get_link
= ethtool_op_get_link
,
1286 .get_eeprom_len
= be_get_eeprom_len
,
1287 .get_eeprom
= be_read_eeprom
,
1288 .get_coalesce
= be_get_coalesce
,
1289 .set_coalesce
= be_set_coalesce
,
1290 .get_ringparam
= be_get_ringparam
,
1291 .get_pauseparam
= be_get_pauseparam
,
1292 .set_pauseparam
= be_set_pauseparam
,
1293 .get_strings
= be_get_stat_strings
,
1294 .set_phys_id
= be_set_phys_id
,
1295 .set_dump
= be_set_dump
,
1296 .get_msglevel
= be_get_msg_level
,
1297 .set_msglevel
= be_set_msg_level
,
1298 .get_sset_count
= be_get_sset_count
,
1299 .get_ethtool_stats
= be_get_ethtool_stats
,
1300 .get_regs_len
= be_get_reg_len
,
1301 .get_regs
= be_get_regs
,
1302 .flash_device
= be_do_flash
,
1303 .self_test
= be_self_test
,
1304 .get_rxnfc
= be_get_rxnfc
,
1305 .set_rxnfc
= be_set_rxnfc
,
1306 .get_rxfh_indir_size
= be_get_rxfh_indir_size
,
1307 .get_rxfh_key_size
= be_get_rxfh_key_size
,
1308 .get_rxfh
= be_get_rxfh
,
1309 .set_rxfh
= be_set_rxfh
,
1310 .get_channels
= be_get_channels
,
1311 .set_channels
= be_set_channels
,
1312 .get_module_info
= be_get_module_info
,
1313 .get_module_eeprom
= be_get_module_eeprom