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 times the TX queue was stopped due to lack
197 * of spaces in the TXQ.
199 {DRVSTAT_TX_INFO(tx_stops
)},
200 /* Pkts dropped in the driver's transmit path */
201 {DRVSTAT_TX_INFO(tx_drv_drops
)}
204 #define ETHTOOL_TXSTATS_NUM (ARRAY_SIZE(et_tx_stats))
206 static const char et_self_tests
[][ETH_GSTRING_LEN
] = {
209 "External Loopback test",
214 #define ETHTOOL_TESTS_NUM ARRAY_SIZE(et_self_tests)
215 #define BE_MAC_LOOPBACK 0x0
216 #define BE_PHY_LOOPBACK 0x1
217 #define BE_ONE_PORT_EXT_LOOPBACK 0x2
218 #define BE_NO_LOOPBACK 0xff
220 static void be_get_drvinfo(struct net_device
*netdev
,
221 struct ethtool_drvinfo
*drvinfo
)
223 struct be_adapter
*adapter
= netdev_priv(netdev
);
225 strlcpy(drvinfo
->driver
, DRV_NAME
, sizeof(drvinfo
->driver
));
226 strlcpy(drvinfo
->version
, DRV_VER
, sizeof(drvinfo
->version
));
227 if (!memcmp(adapter
->fw_ver
, adapter
->fw_on_flash
, FW_VER_LEN
))
228 strlcpy(drvinfo
->fw_version
, adapter
->fw_ver
,
229 sizeof(drvinfo
->fw_version
));
231 snprintf(drvinfo
->fw_version
, sizeof(drvinfo
->fw_version
),
232 "%s [%s]", adapter
->fw_ver
, adapter
->fw_on_flash
);
234 strlcpy(drvinfo
->bus_info
, pci_name(adapter
->pdev
),
235 sizeof(drvinfo
->bus_info
));
236 drvinfo
->testinfo_len
= 0;
237 drvinfo
->regdump_len
= 0;
238 drvinfo
->eedump_len
= 0;
241 static u32
lancer_cmd_get_file_len(struct be_adapter
*adapter
, u8
*file_name
)
243 u32 data_read
= 0, eof
;
245 struct be_dma_mem data_len_cmd
;
248 memset(&data_len_cmd
, 0, sizeof(data_len_cmd
));
249 /* data_offset and data_size should be 0 to get reg len */
250 status
= lancer_cmd_read_object(adapter
, &data_len_cmd
, 0, 0,
251 file_name
, &data_read
, &eof
,
257 static int lancer_cmd_read_file(struct be_adapter
*adapter
, u8
*file_name
,
258 u32 buf_len
, void *buf
)
260 struct be_dma_mem read_cmd
;
261 u32 read_len
= 0, total_read_len
= 0, chunk_size
;
266 read_cmd
.size
= LANCER_READ_FILE_CHUNK
;
267 read_cmd
.va
= pci_alloc_consistent(adapter
->pdev
, read_cmd
.size
,
271 dev_err(&adapter
->pdev
->dev
,
272 "Memory allocation failure while reading dump\n");
276 while ((total_read_len
< buf_len
) && !eof
) {
277 chunk_size
= min_t(u32
, (buf_len
- total_read_len
),
278 LANCER_READ_FILE_CHUNK
);
279 chunk_size
= ALIGN(chunk_size
, 4);
280 status
= lancer_cmd_read_object(adapter
, &read_cmd
, chunk_size
,
281 total_read_len
, file_name
,
282 &read_len
, &eof
, &addn_status
);
284 memcpy(buf
+ total_read_len
, read_cmd
.va
, read_len
);
285 total_read_len
+= read_len
;
286 eof
&= LANCER_READ_FILE_EOF_MASK
;
292 pci_free_consistent(adapter
->pdev
, read_cmd
.size
, read_cmd
.va
,
298 static int be_get_reg_len(struct net_device
*netdev
)
300 struct be_adapter
*adapter
= netdev_priv(netdev
);
303 if (!check_privilege(adapter
, MAX_PRIVILEGES
))
306 if (be_physfn(adapter
)) {
307 if (lancer_chip(adapter
))
308 log_size
= lancer_cmd_get_file_len(adapter
,
309 LANCER_FW_DUMP_FILE
);
311 be_cmd_get_reg_len(adapter
, &log_size
);
317 be_get_regs(struct net_device
*netdev
, struct ethtool_regs
*regs
, void *buf
)
319 struct be_adapter
*adapter
= netdev_priv(netdev
);
321 if (be_physfn(adapter
)) {
322 memset(buf
, 0, regs
->len
);
323 if (lancer_chip(adapter
))
324 lancer_cmd_read_file(adapter
, LANCER_FW_DUMP_FILE
,
327 be_cmd_get_regs(adapter
, regs
->len
, buf
);
331 static int be_get_coalesce(struct net_device
*netdev
,
332 struct ethtool_coalesce
*et
)
334 struct be_adapter
*adapter
= netdev_priv(netdev
);
335 struct be_aic_obj
*aic
= &adapter
->aic_obj
[0];
337 et
->rx_coalesce_usecs
= aic
->prev_eqd
;
338 et
->rx_coalesce_usecs_high
= aic
->max_eqd
;
339 et
->rx_coalesce_usecs_low
= aic
->min_eqd
;
341 et
->tx_coalesce_usecs
= aic
->prev_eqd
;
342 et
->tx_coalesce_usecs_high
= aic
->max_eqd
;
343 et
->tx_coalesce_usecs_low
= aic
->min_eqd
;
345 et
->use_adaptive_rx_coalesce
= aic
->enable
;
346 et
->use_adaptive_tx_coalesce
= aic
->enable
;
351 /* TX attributes are ignored. Only RX attributes are considered
352 * eqd cmd is issued in the worker thread.
354 static int be_set_coalesce(struct net_device
*netdev
,
355 struct ethtool_coalesce
*et
)
357 struct be_adapter
*adapter
= netdev_priv(netdev
);
358 struct be_aic_obj
*aic
= &adapter
->aic_obj
[0];
359 struct be_eq_obj
*eqo
;
362 for_all_evt_queues(adapter
, eqo
, i
) {
363 aic
->enable
= et
->use_adaptive_rx_coalesce
;
364 aic
->max_eqd
= min(et
->rx_coalesce_usecs_high
, BE_MAX_EQD
);
365 aic
->min_eqd
= min(et
->rx_coalesce_usecs_low
, aic
->max_eqd
);
366 aic
->et_eqd
= min(et
->rx_coalesce_usecs
, aic
->max_eqd
);
367 aic
->et_eqd
= max(aic
->et_eqd
, aic
->min_eqd
);
374 static void be_get_ethtool_stats(struct net_device
*netdev
,
375 struct ethtool_stats
*stats
, uint64_t *data
)
377 struct be_adapter
*adapter
= netdev_priv(netdev
);
378 struct be_rx_obj
*rxo
;
379 struct be_tx_obj
*txo
;
381 unsigned int i
, j
, base
= 0, start
;
383 for (i
= 0; i
< ETHTOOL_STATS_NUM
; i
++) {
384 p
= (u8
*)&adapter
->drv_stats
+ et_stats
[i
].offset
;
387 base
+= ETHTOOL_STATS_NUM
;
389 for_all_rx_queues(adapter
, rxo
, j
) {
390 struct be_rx_stats
*stats
= rx_stats(rxo
);
393 start
= u64_stats_fetch_begin_irq(&stats
->sync
);
394 data
[base
] = stats
->rx_bytes
;
395 data
[base
+ 1] = stats
->rx_pkts
;
396 } while (u64_stats_fetch_retry_irq(&stats
->sync
, start
));
398 for (i
= 2; i
< ETHTOOL_RXSTATS_NUM
; i
++) {
399 p
= (u8
*)stats
+ et_rx_stats
[i
].offset
;
400 data
[base
+ i
] = *(u32
*)p
;
402 base
+= ETHTOOL_RXSTATS_NUM
;
405 for_all_tx_queues(adapter
, txo
, j
) {
406 struct be_tx_stats
*stats
= tx_stats(txo
);
409 start
= u64_stats_fetch_begin_irq(&stats
->sync_compl
);
410 data
[base
] = stats
->tx_compl
;
411 } while (u64_stats_fetch_retry_irq(&stats
->sync_compl
, start
));
414 start
= u64_stats_fetch_begin_irq(&stats
->sync
);
415 for (i
= 1; i
< ETHTOOL_TXSTATS_NUM
; i
++) {
416 p
= (u8
*)stats
+ et_tx_stats
[i
].offset
;
418 (et_tx_stats
[i
].size
== sizeof(u64
)) ?
419 *(u64
*)p
: *(u32
*)p
;
421 } while (u64_stats_fetch_retry_irq(&stats
->sync
, start
));
422 base
+= ETHTOOL_TXSTATS_NUM
;
426 static void be_get_stat_strings(struct net_device
*netdev
, uint32_t stringset
,
429 struct be_adapter
*adapter
= netdev_priv(netdev
);
434 for (i
= 0; i
< ETHTOOL_STATS_NUM
; i
++) {
435 memcpy(data
, et_stats
[i
].desc
, ETH_GSTRING_LEN
);
436 data
+= ETH_GSTRING_LEN
;
438 for (i
= 0; i
< adapter
->num_rx_qs
; i
++) {
439 for (j
= 0; j
< ETHTOOL_RXSTATS_NUM
; j
++) {
440 sprintf(data
, "rxq%d: %s", i
,
441 et_rx_stats
[j
].desc
);
442 data
+= ETH_GSTRING_LEN
;
445 for (i
= 0; i
< adapter
->num_tx_qs
; i
++) {
446 for (j
= 0; j
< ETHTOOL_TXSTATS_NUM
; j
++) {
447 sprintf(data
, "txq%d: %s", i
,
448 et_tx_stats
[j
].desc
);
449 data
+= ETH_GSTRING_LEN
;
454 for (i
= 0; i
< ETHTOOL_TESTS_NUM
; i
++) {
455 memcpy(data
, et_self_tests
[i
], ETH_GSTRING_LEN
);
456 data
+= ETH_GSTRING_LEN
;
462 static int be_get_sset_count(struct net_device
*netdev
, int stringset
)
464 struct be_adapter
*adapter
= netdev_priv(netdev
);
468 return ETHTOOL_TESTS_NUM
;
470 return ETHTOOL_STATS_NUM
+
471 adapter
->num_rx_qs
* ETHTOOL_RXSTATS_NUM
+
472 adapter
->num_tx_qs
* ETHTOOL_TXSTATS_NUM
;
478 static u32
be_get_port_type(struct be_adapter
*adapter
)
482 switch (adapter
->phy
.interface_type
) {
483 case PHY_TYPE_BASET_1GB
:
484 case PHY_TYPE_BASEX_1GB
:
488 case PHY_TYPE_SFP_PLUS_10GB
:
489 if (adapter
->phy
.cable_type
& SFP_PLUS_COPPER_CABLE
)
495 if (adapter
->phy
.cable_type
& QSFP_PLUS_CR4_CABLE
)
500 case PHY_TYPE_XFP_10GB
:
501 case PHY_TYPE_SFP_1GB
:
504 case PHY_TYPE_BASET_10GB
:
514 static u32
convert_to_et_setting(struct be_adapter
*adapter
, u32 if_speeds
)
518 switch (adapter
->phy
.interface_type
) {
519 case PHY_TYPE_BASET_1GB
:
520 case PHY_TYPE_BASEX_1GB
:
523 if (if_speeds
& BE_SUPPORTED_SPEED_1GBPS
)
524 val
|= SUPPORTED_1000baseT_Full
;
525 if (if_speeds
& BE_SUPPORTED_SPEED_100MBPS
)
526 val
|= SUPPORTED_100baseT_Full
;
527 if (if_speeds
& BE_SUPPORTED_SPEED_10MBPS
)
528 val
|= SUPPORTED_10baseT_Full
;
530 case PHY_TYPE_KX4_10GB
:
531 val
|= SUPPORTED_Backplane
;
532 if (if_speeds
& BE_SUPPORTED_SPEED_1GBPS
)
533 val
|= SUPPORTED_1000baseKX_Full
;
534 if (if_speeds
& BE_SUPPORTED_SPEED_10GBPS
)
535 val
|= SUPPORTED_10000baseKX4_Full
;
537 case PHY_TYPE_KR2_20GB
:
538 val
|= SUPPORTED_Backplane
;
539 if (if_speeds
& BE_SUPPORTED_SPEED_10GBPS
)
540 val
|= SUPPORTED_10000baseKR_Full
;
541 if (if_speeds
& BE_SUPPORTED_SPEED_20GBPS
)
542 val
|= SUPPORTED_20000baseKR2_Full
;
544 case PHY_TYPE_KR_10GB
:
545 val
|= SUPPORTED_Backplane
|
546 SUPPORTED_10000baseKR_Full
;
548 case PHY_TYPE_KR4_40GB
:
549 val
|= SUPPORTED_Backplane
;
550 if (if_speeds
& BE_SUPPORTED_SPEED_10GBPS
)
551 val
|= SUPPORTED_10000baseKR_Full
;
552 if (if_speeds
& BE_SUPPORTED_SPEED_40GBPS
)
553 val
|= SUPPORTED_40000baseKR4_Full
;
556 if (if_speeds
& BE_SUPPORTED_SPEED_40GBPS
) {
557 switch (adapter
->phy
.cable_type
) {
558 case QSFP_PLUS_CR4_CABLE
:
559 val
|= SUPPORTED_40000baseCR4_Full
;
561 case QSFP_PLUS_LR4_CABLE
:
562 val
|= SUPPORTED_40000baseLR4_Full
;
565 val
|= SUPPORTED_40000baseSR4_Full
;
569 case PHY_TYPE_SFP_PLUS_10GB
:
570 case PHY_TYPE_XFP_10GB
:
571 case PHY_TYPE_SFP_1GB
:
572 val
|= SUPPORTED_FIBRE
;
573 if (if_speeds
& BE_SUPPORTED_SPEED_10GBPS
)
574 val
|= SUPPORTED_10000baseT_Full
;
575 if (if_speeds
& BE_SUPPORTED_SPEED_1GBPS
)
576 val
|= SUPPORTED_1000baseT_Full
;
578 case PHY_TYPE_BASET_10GB
:
580 if (if_speeds
& BE_SUPPORTED_SPEED_10GBPS
)
581 val
|= SUPPORTED_10000baseT_Full
;
582 if (if_speeds
& BE_SUPPORTED_SPEED_1GBPS
)
583 val
|= SUPPORTED_1000baseT_Full
;
584 if (if_speeds
& BE_SUPPORTED_SPEED_100MBPS
)
585 val
|= SUPPORTED_100baseT_Full
;
594 bool be_pause_supported(struct be_adapter
*adapter
)
596 return (adapter
->phy
.interface_type
== PHY_TYPE_SFP_PLUS_10GB
||
597 adapter
->phy
.interface_type
== PHY_TYPE_XFP_10GB
) ?
601 static int be_get_settings(struct net_device
*netdev
, struct ethtool_cmd
*ecmd
)
603 struct be_adapter
*adapter
= netdev_priv(netdev
);
610 if (adapter
->phy
.link_speed
< 0) {
611 status
= be_cmd_link_status_query(adapter
, &link_speed
,
614 be_link_status_update(adapter
, link_status
);
615 ethtool_cmd_speed_set(ecmd
, link_speed
);
617 status
= be_cmd_get_phy_info(adapter
);
619 auto_speeds
= adapter
->phy
.auto_speeds_supported
;
620 fixed_speeds
= adapter
->phy
.fixed_speeds_supported
;
622 be_cmd_query_cable_type(adapter
);
625 convert_to_et_setting(adapter
,
629 convert_to_et_setting(adapter
, auto_speeds
);
631 ecmd
->port
= be_get_port_type(adapter
);
633 if (adapter
->phy
.auto_speeds_supported
) {
634 ecmd
->supported
|= SUPPORTED_Autoneg
;
635 ecmd
->autoneg
= AUTONEG_ENABLE
;
636 ecmd
->advertising
|= ADVERTISED_Autoneg
;
639 ecmd
->supported
|= SUPPORTED_Pause
;
640 if (be_pause_supported(adapter
))
641 ecmd
->advertising
|= ADVERTISED_Pause
;
643 switch (adapter
->phy
.interface_type
) {
644 case PHY_TYPE_KR_10GB
:
645 case PHY_TYPE_KX4_10GB
:
646 ecmd
->transceiver
= XCVR_INTERNAL
;
649 ecmd
->transceiver
= XCVR_EXTERNAL
;
653 ecmd
->port
= PORT_OTHER
;
654 ecmd
->autoneg
= AUTONEG_DISABLE
;
655 ecmd
->transceiver
= XCVR_DUMMY1
;
658 /* Save for future use */
659 adapter
->phy
.link_speed
= ethtool_cmd_speed(ecmd
);
660 adapter
->phy
.port_type
= ecmd
->port
;
661 adapter
->phy
.transceiver
= ecmd
->transceiver
;
662 adapter
->phy
.autoneg
= ecmd
->autoneg
;
663 adapter
->phy
.advertising
= ecmd
->advertising
;
664 adapter
->phy
.supported
= ecmd
->supported
;
666 ethtool_cmd_speed_set(ecmd
, adapter
->phy
.link_speed
);
667 ecmd
->port
= adapter
->phy
.port_type
;
668 ecmd
->transceiver
= adapter
->phy
.transceiver
;
669 ecmd
->autoneg
= adapter
->phy
.autoneg
;
670 ecmd
->advertising
= adapter
->phy
.advertising
;
671 ecmd
->supported
= adapter
->phy
.supported
;
674 ecmd
->duplex
= netif_carrier_ok(netdev
) ? DUPLEX_FULL
: DUPLEX_UNKNOWN
;
675 ecmd
->phy_address
= adapter
->port_num
;
680 static void be_get_ringparam(struct net_device
*netdev
,
681 struct ethtool_ringparam
*ring
)
683 struct be_adapter
*adapter
= netdev_priv(netdev
);
685 ring
->rx_max_pending
= adapter
->rx_obj
[0].q
.len
;
686 ring
->rx_pending
= adapter
->rx_obj
[0].q
.len
;
687 ring
->tx_max_pending
= adapter
->tx_obj
[0].q
.len
;
688 ring
->tx_pending
= adapter
->tx_obj
[0].q
.len
;
692 be_get_pauseparam(struct net_device
*netdev
, struct ethtool_pauseparam
*ecmd
)
694 struct be_adapter
*adapter
= netdev_priv(netdev
);
696 be_cmd_get_flow_control(adapter
, &ecmd
->tx_pause
, &ecmd
->rx_pause
);
697 ecmd
->autoneg
= adapter
->phy
.fc_autoneg
;
701 be_set_pauseparam(struct net_device
*netdev
, struct ethtool_pauseparam
*ecmd
)
703 struct be_adapter
*adapter
= netdev_priv(netdev
);
706 if (ecmd
->autoneg
!= adapter
->phy
.fc_autoneg
)
708 adapter
->tx_fc
= ecmd
->tx_pause
;
709 adapter
->rx_fc
= ecmd
->rx_pause
;
711 status
= be_cmd_set_flow_control(adapter
,
712 adapter
->tx_fc
, adapter
->rx_fc
);
714 dev_warn(&adapter
->pdev
->dev
, "Pause param set failed\n");
716 return be_cmd_status(status
);
719 static int be_set_phys_id(struct net_device
*netdev
,
720 enum ethtool_phys_id_state state
)
722 struct be_adapter
*adapter
= netdev_priv(netdev
);
725 case ETHTOOL_ID_ACTIVE
:
726 be_cmd_get_beacon_state(adapter
, adapter
->hba_port_num
,
727 &adapter
->beacon_state
);
728 return 1; /* cycle on/off once per second */
731 be_cmd_set_beacon_state(adapter
, adapter
->hba_port_num
, 0, 0,
732 BEACON_STATE_ENABLED
);
736 be_cmd_set_beacon_state(adapter
, adapter
->hba_port_num
, 0, 0,
737 BEACON_STATE_DISABLED
);
740 case ETHTOOL_ID_INACTIVE
:
741 be_cmd_set_beacon_state(adapter
, adapter
->hba_port_num
, 0, 0,
742 adapter
->beacon_state
);
748 static int be_set_dump(struct net_device
*netdev
, struct ethtool_dump
*dump
)
750 struct be_adapter
*adapter
= netdev_priv(netdev
);
751 struct device
*dev
= &adapter
->pdev
->dev
;
754 if (!lancer_chip(adapter
) ||
755 !check_privilege(adapter
, MAX_PRIVILEGES
))
758 switch (dump
->flag
) {
759 case LANCER_INITIATE_FW_DUMP
:
760 status
= lancer_initiate_dump(adapter
);
762 dev_info(dev
, "FW dump initiated successfully\n");
764 case LANCER_DELETE_FW_DUMP
:
765 status
= lancer_delete_dump(adapter
);
767 dev_info(dev
, "FW dump deleted successfully\n");
770 dev_err(dev
, "Invalid dump level: 0x%x\n", dump
->flag
);
776 static void be_get_wol(struct net_device
*netdev
, struct ethtool_wolinfo
*wol
)
778 struct be_adapter
*adapter
= netdev_priv(netdev
);
780 if (adapter
->wol_cap
& BE_WOL_CAP
) {
781 wol
->supported
|= WAKE_MAGIC
;
783 wol
->wolopts
|= WAKE_MAGIC
;
787 memset(&wol
->sopass
, 0, sizeof(wol
->sopass
));
790 static int be_set_wol(struct net_device
*netdev
, struct ethtool_wolinfo
*wol
)
792 struct be_adapter
*adapter
= netdev_priv(netdev
);
794 if (wol
->wolopts
& ~WAKE_MAGIC
)
797 if (!(adapter
->wol_cap
& BE_WOL_CAP
)) {
798 dev_warn(&adapter
->pdev
->dev
, "WOL not supported\n");
802 if (wol
->wolopts
& WAKE_MAGIC
)
803 adapter
->wol_en
= true;
805 adapter
->wol_en
= false;
810 static int be_test_ddr_dma(struct be_adapter
*adapter
)
813 struct be_dma_mem ddrdma_cmd
;
814 static const u64 pattern
[2] = {
815 0x5a5a5a5a5a5a5a5aULL
, 0xa5a5a5a5a5a5a5a5ULL
818 ddrdma_cmd
.size
= sizeof(struct be_cmd_req_ddrdma_test
);
819 ddrdma_cmd
.va
= dma_alloc_coherent(&adapter
->pdev
->dev
, ddrdma_cmd
.size
,
820 &ddrdma_cmd
.dma
, GFP_KERNEL
);
824 for (i
= 0; i
< 2; i
++) {
825 ret
= be_cmd_ddr_dma_test(adapter
, pattern
[i
],
832 dma_free_coherent(&adapter
->pdev
->dev
, ddrdma_cmd
.size
, ddrdma_cmd
.va
,
834 return be_cmd_status(ret
);
837 static u64
be_loopback_test(struct be_adapter
*adapter
, u8 loopback_type
,
840 be_cmd_set_loopback(adapter
, adapter
->hba_port_num
, loopback_type
, 1);
841 *status
= be_cmd_loopback_test(adapter
, adapter
->hba_port_num
,
842 loopback_type
, 1500, 2, 0xabc);
843 be_cmd_set_loopback(adapter
, adapter
->hba_port_num
, BE_NO_LOOPBACK
, 1);
847 static void be_self_test(struct net_device
*netdev
, struct ethtool_test
*test
,
850 struct be_adapter
*adapter
= netdev_priv(netdev
);
854 if (adapter
->function_caps
& BE_FUNCTION_CAPS_SUPER_NIC
) {
855 dev_err(&adapter
->pdev
->dev
, "Self test not supported\n");
856 test
->flags
|= ETH_TEST_FL_FAILED
;
860 memset(data
, 0, sizeof(u64
) * ETHTOOL_TESTS_NUM
);
862 if (test
->flags
& ETH_TEST_FL_OFFLINE
) {
863 if (be_loopback_test(adapter
, BE_MAC_LOOPBACK
, &data
[0]) != 0)
864 test
->flags
|= ETH_TEST_FL_FAILED
;
866 if (be_loopback_test(adapter
, BE_PHY_LOOPBACK
, &data
[1]) != 0)
867 test
->flags
|= ETH_TEST_FL_FAILED
;
869 if (test
->flags
& ETH_TEST_FL_EXTERNAL_LB
) {
870 if (be_loopback_test(adapter
, BE_ONE_PORT_EXT_LOOPBACK
,
872 test
->flags
|= ETH_TEST_FL_FAILED
;
873 test
->flags
|= ETH_TEST_FL_EXTERNAL_LB_DONE
;
877 if (!lancer_chip(adapter
) && be_test_ddr_dma(adapter
) != 0) {
879 test
->flags
|= ETH_TEST_FL_FAILED
;
882 status
= be_cmd_link_status_query(adapter
, NULL
, &link_status
, 0);
884 test
->flags
|= ETH_TEST_FL_FAILED
;
886 } else if (!link_status
) {
887 test
->flags
|= ETH_TEST_FL_FAILED
;
892 static int be_do_flash(struct net_device
*netdev
, struct ethtool_flash
*efl
)
894 struct be_adapter
*adapter
= netdev_priv(netdev
);
896 return be_load_fw(adapter
, efl
->data
);
899 static int be_get_eeprom_len(struct net_device
*netdev
)
901 struct be_adapter
*adapter
= netdev_priv(netdev
);
903 if (!check_privilege(adapter
, MAX_PRIVILEGES
))
906 if (lancer_chip(adapter
)) {
907 if (be_physfn(adapter
))
908 return lancer_cmd_get_file_len(adapter
,
911 return lancer_cmd_get_file_len(adapter
,
914 return BE_READ_SEEPROM_LEN
;
918 static int be_read_eeprom(struct net_device
*netdev
,
919 struct ethtool_eeprom
*eeprom
, uint8_t *data
)
921 struct be_adapter
*adapter
= netdev_priv(netdev
);
922 struct be_dma_mem eeprom_cmd
;
923 struct be_cmd_resp_seeprom_read
*resp
;
929 if (lancer_chip(adapter
)) {
930 if (be_physfn(adapter
))
931 return lancer_cmd_read_file(adapter
, LANCER_VPD_PF_FILE
,
934 return lancer_cmd_read_file(adapter
, LANCER_VPD_VF_FILE
,
938 eeprom
->magic
= BE_VENDOR_ID
| (adapter
->pdev
->device
<<16);
940 memset(&eeprom_cmd
, 0, sizeof(struct be_dma_mem
));
941 eeprom_cmd
.size
= sizeof(struct be_cmd_req_seeprom_read
);
942 eeprom_cmd
.va
= dma_alloc_coherent(&adapter
->pdev
->dev
, eeprom_cmd
.size
,
943 &eeprom_cmd
.dma
, GFP_KERNEL
);
948 status
= be_cmd_get_seeprom_data(adapter
, &eeprom_cmd
);
951 resp
= eeprom_cmd
.va
;
952 memcpy(data
, resp
->seeprom_data
+ eeprom
->offset
, eeprom
->len
);
954 dma_free_coherent(&adapter
->pdev
->dev
, eeprom_cmd
.size
, eeprom_cmd
.va
,
957 return be_cmd_status(status
);
960 static u32
be_get_msg_level(struct net_device
*netdev
)
962 struct be_adapter
*adapter
= netdev_priv(netdev
);
964 return adapter
->msg_enable
;
967 static void be_set_msg_level(struct net_device
*netdev
, u32 level
)
969 struct be_adapter
*adapter
= netdev_priv(netdev
);
971 if (adapter
->msg_enable
== level
)
974 if ((level
& NETIF_MSG_HW
) != (adapter
->msg_enable
& NETIF_MSG_HW
))
975 if (BEx_chip(adapter
))
976 be_cmd_set_fw_log_level(adapter
, level
& NETIF_MSG_HW
?
977 FW_LOG_LEVEL_DEFAULT
:
979 adapter
->msg_enable
= level
;
982 static u64
be_get_rss_hash_opts(struct be_adapter
*adapter
, u64 flow_type
)
988 if (adapter
->rss_info
.rss_flags
& RSS_ENABLE_IPV4
)
989 data
|= RXH_IP_DST
| RXH_IP_SRC
;
990 if (adapter
->rss_info
.rss_flags
& RSS_ENABLE_TCP_IPV4
)
991 data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
994 if (adapter
->rss_info
.rss_flags
& RSS_ENABLE_IPV4
)
995 data
|= RXH_IP_DST
| RXH_IP_SRC
;
996 if (adapter
->rss_info
.rss_flags
& RSS_ENABLE_UDP_IPV4
)
997 data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
1000 if (adapter
->rss_info
.rss_flags
& RSS_ENABLE_IPV6
)
1001 data
|= RXH_IP_DST
| RXH_IP_SRC
;
1002 if (adapter
->rss_info
.rss_flags
& RSS_ENABLE_TCP_IPV6
)
1003 data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
1006 if (adapter
->rss_info
.rss_flags
& RSS_ENABLE_IPV6
)
1007 data
|= RXH_IP_DST
| RXH_IP_SRC
;
1008 if (adapter
->rss_info
.rss_flags
& RSS_ENABLE_UDP_IPV6
)
1009 data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
1016 static int be_get_rxnfc(struct net_device
*netdev
, struct ethtool_rxnfc
*cmd
,
1019 struct be_adapter
*adapter
= netdev_priv(netdev
);
1021 if (!be_multi_rxq(adapter
)) {
1022 dev_info(&adapter
->pdev
->dev
,
1023 "ethtool::get_rxnfc: RX flow hashing is disabled\n");
1029 cmd
->data
= be_get_rss_hash_opts(adapter
, cmd
->flow_type
);
1031 case ETHTOOL_GRXRINGS
:
1032 cmd
->data
= adapter
->num_rx_qs
- 1;
1041 static int be_set_rss_hash_opts(struct be_adapter
*adapter
,
1042 struct ethtool_rxnfc
*cmd
)
1044 struct be_rx_obj
*rxo
;
1045 int status
= 0, i
, j
;
1047 u32 rss_flags
= adapter
->rss_info
.rss_flags
;
1049 if (cmd
->data
!= L3_RSS_FLAGS
&&
1050 cmd
->data
!= (L3_RSS_FLAGS
| L4_RSS_FLAGS
))
1053 switch (cmd
->flow_type
) {
1055 if (cmd
->data
== L3_RSS_FLAGS
)
1056 rss_flags
&= ~RSS_ENABLE_TCP_IPV4
;
1057 else if (cmd
->data
== (L3_RSS_FLAGS
| L4_RSS_FLAGS
))
1058 rss_flags
|= RSS_ENABLE_IPV4
|
1059 RSS_ENABLE_TCP_IPV4
;
1062 if (cmd
->data
== L3_RSS_FLAGS
)
1063 rss_flags
&= ~RSS_ENABLE_TCP_IPV6
;
1064 else if (cmd
->data
== (L3_RSS_FLAGS
| L4_RSS_FLAGS
))
1065 rss_flags
|= RSS_ENABLE_IPV6
|
1066 RSS_ENABLE_TCP_IPV6
;
1069 if ((cmd
->data
== (L3_RSS_FLAGS
| L4_RSS_FLAGS
)) &&
1073 if (cmd
->data
== L3_RSS_FLAGS
)
1074 rss_flags
&= ~RSS_ENABLE_UDP_IPV4
;
1075 else if (cmd
->data
== (L3_RSS_FLAGS
| L4_RSS_FLAGS
))
1076 rss_flags
|= RSS_ENABLE_IPV4
|
1077 RSS_ENABLE_UDP_IPV4
;
1080 if ((cmd
->data
== (L3_RSS_FLAGS
| L4_RSS_FLAGS
)) &&
1084 if (cmd
->data
== L3_RSS_FLAGS
)
1085 rss_flags
&= ~RSS_ENABLE_UDP_IPV6
;
1086 else if (cmd
->data
== (L3_RSS_FLAGS
| L4_RSS_FLAGS
))
1087 rss_flags
|= RSS_ENABLE_IPV6
|
1088 RSS_ENABLE_UDP_IPV6
;
1094 if (rss_flags
== adapter
->rss_info
.rss_flags
)
1097 if (be_multi_rxq(adapter
)) {
1098 for (j
= 0; j
< 128; j
+= adapter
->num_rx_qs
- 1) {
1099 for_all_rss_queues(adapter
, rxo
, i
) {
1102 rsstable
[j
+ i
] = rxo
->rss_id
;
1107 status
= be_cmd_rss_config(adapter
, adapter
->rss_info
.rsstable
,
1108 rss_flags
, 128, adapter
->rss_info
.rss_hkey
);
1110 adapter
->rss_info
.rss_flags
= rss_flags
;
1112 return be_cmd_status(status
);
1115 static int be_set_rxnfc(struct net_device
*netdev
, struct ethtool_rxnfc
*cmd
)
1117 struct be_adapter
*adapter
= netdev_priv(netdev
);
1120 if (!be_multi_rxq(adapter
)) {
1121 dev_err(&adapter
->pdev
->dev
,
1122 "ethtool::set_rxnfc: RX flow hashing is disabled\n");
1128 status
= be_set_rss_hash_opts(adapter
, cmd
);
1137 static void be_get_channels(struct net_device
*netdev
,
1138 struct ethtool_channels
*ch
)
1140 struct be_adapter
*adapter
= netdev_priv(netdev
);
1142 ch
->combined_count
= adapter
->num_evt_qs
;
1143 ch
->max_combined
= be_max_qs(adapter
);
1146 static int be_set_channels(struct net_device
*netdev
,
1147 struct ethtool_channels
*ch
)
1149 struct be_adapter
*adapter
= netdev_priv(netdev
);
1152 if (ch
->rx_count
|| ch
->tx_count
|| ch
->other_count
||
1153 !ch
->combined_count
|| ch
->combined_count
> be_max_qs(adapter
))
1156 adapter
->cfg_num_qs
= ch
->combined_count
;
1158 status
= be_update_queues(adapter
);
1159 return be_cmd_status(status
);
1162 static u32
be_get_rxfh_indir_size(struct net_device
*netdev
)
1164 return RSS_INDIR_TABLE_LEN
;
1167 static u32
be_get_rxfh_key_size(struct net_device
*netdev
)
1169 return RSS_HASH_KEY_LEN
;
1172 static int be_get_rxfh(struct net_device
*netdev
, u32
*indir
, u8
*hkey
,
1175 struct be_adapter
*adapter
= netdev_priv(netdev
);
1177 struct rss_info
*rss
= &adapter
->rss_info
;
1180 for (i
= 0; i
< RSS_INDIR_TABLE_LEN
; i
++)
1181 indir
[i
] = rss
->rss_queue
[i
];
1185 memcpy(hkey
, rss
->rss_hkey
, RSS_HASH_KEY_LEN
);
1188 *hfunc
= ETH_RSS_HASH_TOP
;
1193 static int be_set_rxfh(struct net_device
*netdev
, const u32
*indir
,
1194 const u8
*hkey
, const u8 hfunc
)
1197 struct be_adapter
*adapter
= netdev_priv(netdev
);
1198 u8 rsstable
[RSS_INDIR_TABLE_LEN
];
1200 /* We do not allow change in unsupported parameters */
1201 if (hfunc
!= ETH_RSS_HASH_NO_CHANGE
&& hfunc
!= ETH_RSS_HASH_TOP
)
1205 struct be_rx_obj
*rxo
;
1207 for (i
= 0; i
< RSS_INDIR_TABLE_LEN
; i
++) {
1209 rxo
= &adapter
->rx_obj
[j
];
1210 rsstable
[i
] = rxo
->rss_id
;
1211 adapter
->rss_info
.rss_queue
[i
] = j
;
1214 memcpy(rsstable
, adapter
->rss_info
.rsstable
,
1215 RSS_INDIR_TABLE_LEN
);
1219 hkey
= adapter
->rss_info
.rss_hkey
;
1221 rc
= be_cmd_rss_config(adapter
, rsstable
,
1222 adapter
->rss_info
.rss_flags
,
1223 RSS_INDIR_TABLE_LEN
, hkey
);
1225 adapter
->rss_info
.rss_flags
= RSS_ENABLE_NONE
;
1228 memcpy(adapter
->rss_info
.rss_hkey
, hkey
, RSS_HASH_KEY_LEN
);
1229 memcpy(adapter
->rss_info
.rsstable
, rsstable
,
1230 RSS_INDIR_TABLE_LEN
);
1234 static int be_get_module_info(struct net_device
*netdev
,
1235 struct ethtool_modinfo
*modinfo
)
1237 struct be_adapter
*adapter
= netdev_priv(netdev
);
1238 u8 page_data
[PAGE_DATA_LEN
];
1241 if (!check_privilege(adapter
, MAX_PRIVILEGES
))
1244 status
= be_cmd_read_port_transceiver_data(adapter
, TR_PAGE_A0
,
1247 if (!page_data
[SFP_PLUS_SFF_8472_COMP
]) {
1248 modinfo
->type
= ETH_MODULE_SFF_8079
;
1249 modinfo
->eeprom_len
= PAGE_DATA_LEN
;
1251 modinfo
->type
= ETH_MODULE_SFF_8472
;
1252 modinfo
->eeprom_len
= 2 * PAGE_DATA_LEN
;
1255 return be_cmd_status(status
);
1258 static int be_get_module_eeprom(struct net_device
*netdev
,
1259 struct ethtool_eeprom
*eeprom
, u8
*data
)
1261 struct be_adapter
*adapter
= netdev_priv(netdev
);
1264 if (!check_privilege(adapter
, MAX_PRIVILEGES
))
1267 status
= be_cmd_read_port_transceiver_data(adapter
, TR_PAGE_A0
,
1272 if (eeprom
->offset
+ eeprom
->len
> PAGE_DATA_LEN
) {
1273 status
= be_cmd_read_port_transceiver_data(adapter
,
1281 memcpy(data
, data
+ eeprom
->offset
, eeprom
->len
);
1283 return be_cmd_status(status
);
1286 const struct ethtool_ops be_ethtool_ops
= {
1287 .get_settings
= be_get_settings
,
1288 .get_drvinfo
= be_get_drvinfo
,
1289 .get_wol
= be_get_wol
,
1290 .set_wol
= be_set_wol
,
1291 .get_link
= ethtool_op_get_link
,
1292 .get_eeprom_len
= be_get_eeprom_len
,
1293 .get_eeprom
= be_read_eeprom
,
1294 .get_coalesce
= be_get_coalesce
,
1295 .set_coalesce
= be_set_coalesce
,
1296 .get_ringparam
= be_get_ringparam
,
1297 .get_pauseparam
= be_get_pauseparam
,
1298 .set_pauseparam
= be_set_pauseparam
,
1299 .get_strings
= be_get_stat_strings
,
1300 .set_phys_id
= be_set_phys_id
,
1301 .set_dump
= be_set_dump
,
1302 .get_msglevel
= be_get_msg_level
,
1303 .set_msglevel
= be_set_msg_level
,
1304 .get_sset_count
= be_get_sset_count
,
1305 .get_ethtool_stats
= be_get_ethtool_stats
,
1306 .get_regs_len
= be_get_reg_len
,
1307 .get_regs
= be_get_regs
,
1308 .flash_device
= be_do_flash
,
1309 .self_test
= be_self_test
,
1310 .get_rxnfc
= be_get_rxnfc
,
1311 .set_rxnfc
= be_set_rxnfc
,
1312 .get_rxfh_indir_size
= be_get_rxfh_indir_size
,
1313 .get_rxfh_key_size
= be_get_rxfh_key_size
,
1314 .get_rxfh
= be_get_rxfh
,
1315 .set_rxfh
= be_set_rxfh
,
1316 .get_channels
= be_get_channels
,
1317 .set_channels
= be_set_channels
,
1318 .get_module_info
= be_get_module_info
,
1319 .get_module_eeprom
= be_get_module_eeprom