2 * Copyright (C) 2005 - 2011 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 {NETSTAT
, PORTSTAT
, MISCSTAT
, DRVSTAT_TX
, DRVSTAT_RX
, ERXSTAT
,
31 #define FIELDINFO(_struct, field) FIELD_SIZEOF(_struct, field), \
32 offsetof(_struct, field)
33 #define NETSTAT_INFO(field) #field, NETSTAT,\
34 FIELDINFO(struct net_device_stats,\
36 #define DRVSTAT_TX_INFO(field) #field, DRVSTAT_TX,\
37 FIELDINFO(struct be_tx_stats, field)
38 #define DRVSTAT_RX_INFO(field) #field, DRVSTAT_RX,\
39 FIELDINFO(struct be_rx_stats, field)
40 #define MISCSTAT_INFO(field) #field, MISCSTAT,\
41 FIELDINFO(struct be_rxf_stats, field)
42 #define PORTSTAT_INFO(field) #field, PORTSTAT,\
43 FIELDINFO(struct be_port_rxf_stats, \
45 #define ERXSTAT_INFO(field) #field, ERXSTAT,\
46 FIELDINFO(struct be_erx_stats, field)
47 #define PMEMSTAT_INFO(field) #field, PMEMSTAT,\
48 FIELDINFO(struct be_pmem_stats, field)
49 #define DRVSTAT_INFO(field) #field, DRVSTAT,\
50 FIELDINFO(struct be_drv_stats, \
53 static const struct be_ethtool_stat et_stats
[] = {
54 {NETSTAT_INFO(rx_packets
)},
55 {NETSTAT_INFO(tx_packets
)},
56 {NETSTAT_INFO(rx_bytes
)},
57 {NETSTAT_INFO(tx_bytes
)},
58 {NETSTAT_INFO(rx_errors
)},
59 {NETSTAT_INFO(tx_errors
)},
60 {NETSTAT_INFO(rx_dropped
)},
61 {NETSTAT_INFO(tx_dropped
)},
62 {DRVSTAT_TX_INFO(be_tx_rate
)},
63 {DRVSTAT_TX_INFO(be_tx_reqs
)},
64 {DRVSTAT_TX_INFO(be_tx_wrbs
)},
65 {DRVSTAT_TX_INFO(be_tx_stops
)},
66 {DRVSTAT_TX_INFO(be_tx_events
)},
67 {DRVSTAT_TX_INFO(be_tx_compl
)},
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(rx_switched_unicast_packets
)},
94 {PORTSTAT_INFO(rx_switched_multicast_packets
)},
95 {PORTSTAT_INFO(rx_switched_broadcast_packets
)},
96 {PORTSTAT_INFO(tx_unicastframes
)},
97 {PORTSTAT_INFO(tx_multicastframes
)},
98 {PORTSTAT_INFO(tx_broadcastframes
)},
99 {PORTSTAT_INFO(tx_pauseframes
)},
100 {PORTSTAT_INFO(tx_controlframes
)},
101 {MISCSTAT_INFO(rx_drops_no_pbuf
)},
102 {MISCSTAT_INFO(rx_drops_no_txpb
)},
103 {MISCSTAT_INFO(rx_drops_no_erx_descr
)},
104 {MISCSTAT_INFO(rx_drops_no_tpre_descr
)},
105 {MISCSTAT_INFO(rx_drops_too_many_frags
)},
106 {MISCSTAT_INFO(rx_drops_invalid_ring
)},
107 {MISCSTAT_INFO(forwarded_packets
)},
108 {MISCSTAT_INFO(rx_drops_mtu
)},
109 {MISCSTAT_INFO(port0_jabber_events
)},
110 {MISCSTAT_INFO(port1_jabber_events
)},
111 {PMEMSTAT_INFO(eth_red_drops
)},
112 {DRVSTAT_INFO(be_on_die_temperature
)}
114 #define ETHTOOL_STATS_NUM ARRAY_SIZE(et_stats)
116 /* Stats related to multi RX queues */
117 static const struct be_ethtool_stat et_rx_stats
[] = {
118 {DRVSTAT_RX_INFO(rx_bytes
)},
119 {DRVSTAT_RX_INFO(rx_pkts
)},
120 {DRVSTAT_RX_INFO(rx_rate
)},
121 {DRVSTAT_RX_INFO(rx_polls
)},
122 {DRVSTAT_RX_INFO(rx_events
)},
123 {DRVSTAT_RX_INFO(rx_compl
)},
124 {DRVSTAT_RX_INFO(rx_mcast_pkts
)},
125 {DRVSTAT_RX_INFO(rx_post_fail
)},
126 {ERXSTAT_INFO(rx_drops_no_fragments
)}
128 #define ETHTOOL_RXSTATS_NUM (ARRAY_SIZE(et_rx_stats))
130 static const char et_self_tests
[][ETH_GSTRING_LEN
] = {
133 "External Loopback test",
138 #define ETHTOOL_TESTS_NUM ARRAY_SIZE(et_self_tests)
139 #define BE_MAC_LOOPBACK 0x0
140 #define BE_PHY_LOOPBACK 0x1
141 #define BE_ONE_PORT_EXT_LOOPBACK 0x2
142 #define BE_NO_LOOPBACK 0xff
145 be_get_drvinfo(struct net_device
*netdev
, struct ethtool_drvinfo
*drvinfo
)
147 struct be_adapter
*adapter
= netdev_priv(netdev
);
149 strcpy(drvinfo
->driver
, DRV_NAME
);
150 strcpy(drvinfo
->version
, DRV_VER
);
151 strncpy(drvinfo
->fw_version
, adapter
->fw_ver
, FW_VER_LEN
);
152 strcpy(drvinfo
->bus_info
, pci_name(adapter
->pdev
));
153 drvinfo
->testinfo_len
= 0;
154 drvinfo
->regdump_len
= 0;
155 drvinfo
->eedump_len
= 0;
159 be_get_coalesce(struct net_device
*netdev
, struct ethtool_coalesce
*coalesce
)
161 struct be_adapter
*adapter
= netdev_priv(netdev
);
162 struct be_eq_obj
*rx_eq
= &adapter
->rx_obj
[0].rx_eq
;
163 struct be_eq_obj
*tx_eq
= &adapter
->tx_eq
;
165 coalesce
->rx_coalesce_usecs
= rx_eq
->cur_eqd
;
166 coalesce
->rx_coalesce_usecs_high
= rx_eq
->max_eqd
;
167 coalesce
->rx_coalesce_usecs_low
= rx_eq
->min_eqd
;
169 coalesce
->tx_coalesce_usecs
= tx_eq
->cur_eqd
;
170 coalesce
->tx_coalesce_usecs_high
= tx_eq
->max_eqd
;
171 coalesce
->tx_coalesce_usecs_low
= tx_eq
->min_eqd
;
173 coalesce
->use_adaptive_rx_coalesce
= rx_eq
->enable_aic
;
174 coalesce
->use_adaptive_tx_coalesce
= tx_eq
->enable_aic
;
180 * This routine is used to set interrup coalescing delay
183 be_set_coalesce(struct net_device
*netdev
, struct ethtool_coalesce
*coalesce
)
185 struct be_adapter
*adapter
= netdev_priv(netdev
);
186 struct be_rx_obj
*rxo
;
187 struct be_eq_obj
*rx_eq
;
188 struct be_eq_obj
*tx_eq
= &adapter
->tx_eq
;
189 u32 tx_max
, tx_min
, tx_cur
;
190 u32 rx_max
, rx_min
, rx_cur
;
193 if (coalesce
->use_adaptive_tx_coalesce
== 1)
196 for_all_rx_queues(adapter
, rxo
, i
) {
199 if (!rx_eq
->enable_aic
&& coalesce
->use_adaptive_rx_coalesce
)
201 rx_eq
->enable_aic
= coalesce
->use_adaptive_rx_coalesce
;
203 rx_max
= coalesce
->rx_coalesce_usecs_high
;
204 rx_min
= coalesce
->rx_coalesce_usecs_low
;
205 rx_cur
= coalesce
->rx_coalesce_usecs
;
207 if (rx_eq
->enable_aic
) {
208 if (rx_max
> BE_MAX_EQD
)
212 rx_eq
->max_eqd
= rx_max
;
213 rx_eq
->min_eqd
= rx_min
;
214 if (rx_eq
->cur_eqd
> rx_max
)
215 rx_eq
->cur_eqd
= rx_max
;
216 if (rx_eq
->cur_eqd
< rx_min
)
217 rx_eq
->cur_eqd
= rx_min
;
219 if (rx_cur
> BE_MAX_EQD
)
221 if (rx_eq
->cur_eqd
!= rx_cur
) {
222 status
= be_cmd_modify_eqd(adapter
, rx_eq
->q
.id
,
225 rx_eq
->cur_eqd
= rx_cur
;
230 tx_max
= coalesce
->tx_coalesce_usecs_high
;
231 tx_min
= coalesce
->tx_coalesce_usecs_low
;
232 tx_cur
= coalesce
->tx_coalesce_usecs
;
234 if (tx_cur
> BE_MAX_EQD
)
236 if (tx_eq
->cur_eqd
!= tx_cur
) {
237 status
= be_cmd_modify_eqd(adapter
, tx_eq
->q
.id
, tx_cur
);
239 tx_eq
->cur_eqd
= tx_cur
;
245 static u32
be_get_rx_csum(struct net_device
*netdev
)
247 struct be_adapter
*adapter
= netdev_priv(netdev
);
249 return adapter
->rx_csum
;
252 static int be_set_rx_csum(struct net_device
*netdev
, uint32_t data
)
254 struct be_adapter
*adapter
= netdev_priv(netdev
);
257 adapter
->rx_csum
= true;
259 adapter
->rx_csum
= false;
265 be_get_ethtool_stats(struct net_device
*netdev
,
266 struct ethtool_stats
*stats
, uint64_t *data
)
268 struct be_adapter
*adapter
= netdev_priv(netdev
);
269 struct be_hw_stats
*hw_stats
= hw_stats_from_cmd(adapter
->stats_cmd
.va
);
270 struct be_erx_stats
*erx_stats
= &hw_stats
->erx
;
271 struct be_rx_obj
*rxo
;
275 for (i
= 0; i
< ETHTOOL_STATS_NUM
; i
++) {
276 switch (et_stats
[i
].type
) {
281 p
= &adapter
->tx_stats
;
284 p
= &hw_stats
->rxf
.port
[adapter
->port_num
];
293 p
= &adapter
->drv_stats
;
297 p
= (u8
*)p
+ et_stats
[i
].offset
;
298 data
[i
] = (et_stats
[i
].size
== sizeof(u64
)) ?
299 *(u64
*)p
: *(u32
*)p
;
302 for_all_rx_queues(adapter
, rxo
, j
) {
303 for (i
= 0; i
< ETHTOOL_RXSTATS_NUM
; i
++) {
304 switch (et_rx_stats
[i
].type
) {
306 p
= (u8
*)&rxo
->stats
+ et_rx_stats
[i
].offset
;
309 p
= (u32
*)erx_stats
+ rxo
->q
.id
;
312 data
[ETHTOOL_STATS_NUM
+ j
* ETHTOOL_RXSTATS_NUM
+ i
] =
313 (et_rx_stats
[i
].size
== sizeof(u64
)) ?
314 *(u64
*)p
: *(u32
*)p
;
320 be_get_stat_strings(struct net_device
*netdev
, uint32_t stringset
,
323 struct be_adapter
*adapter
= netdev_priv(netdev
);
328 for (i
= 0; i
< ETHTOOL_STATS_NUM
; i
++) {
329 memcpy(data
, et_stats
[i
].desc
, ETH_GSTRING_LEN
);
330 data
+= ETH_GSTRING_LEN
;
332 for (i
= 0; i
< adapter
->num_rx_qs
; i
++) {
333 for (j
= 0; j
< ETHTOOL_RXSTATS_NUM
; j
++) {
334 sprintf(data
, "rxq%d: %s", i
,
335 et_rx_stats
[j
].desc
);
336 data
+= ETH_GSTRING_LEN
;
341 for (i
= 0; i
< ETHTOOL_TESTS_NUM
; i
++) {
342 memcpy(data
, et_self_tests
[i
], ETH_GSTRING_LEN
);
343 data
+= ETH_GSTRING_LEN
;
349 static int be_get_sset_count(struct net_device
*netdev
, int stringset
)
351 struct be_adapter
*adapter
= netdev_priv(netdev
);
355 return ETHTOOL_TESTS_NUM
;
357 return ETHTOOL_STATS_NUM
+
358 adapter
->num_rx_qs
* ETHTOOL_RXSTATS_NUM
;
364 static int be_get_settings(struct net_device
*netdev
, struct ethtool_cmd
*ecmd
)
366 struct be_adapter
*adapter
= netdev_priv(netdev
);
367 struct be_dma_mem phy_cmd
;
368 struct be_cmd_resp_get_phy_info
*resp
;
371 bool link_up
= false;
375 if ((adapter
->link_speed
< 0) || (!(netdev
->flags
& IFF_UP
))) {
376 status
= be_cmd_link_status_query(adapter
, &link_up
,
377 &mac_speed
, &link_speed
);
379 be_link_status_update(adapter
, link_up
);
380 /* link_speed is in units of 10 Mbps */
382 ecmd
->speed
= link_speed
*10;
385 case PHY_LINK_SPEED_1GBPS
:
386 ecmd
->speed
= SPEED_1000
;
388 case PHY_LINK_SPEED_10GBPS
:
389 ecmd
->speed
= SPEED_10000
;
394 phy_cmd
.size
= sizeof(struct be_cmd_req_get_phy_info
);
395 phy_cmd
.va
= dma_alloc_coherent(&adapter
->pdev
->dev
,
396 phy_cmd
.size
, &phy_cmd
.dma
,
399 dev_err(&adapter
->pdev
->dev
, "Memory alloc failure\n");
402 status
= be_cmd_get_phy_info(adapter
, &phy_cmd
);
404 resp
= (struct be_cmd_resp_get_phy_info
*) phy_cmd
.va
;
405 intf_type
= le16_to_cpu(resp
->interface_type
);
408 case PHY_TYPE_XFP_10GB
:
409 case PHY_TYPE_SFP_1GB
:
410 case PHY_TYPE_SFP_PLUS_10GB
:
411 ecmd
->port
= PORT_FIBRE
;
414 ecmd
->port
= PORT_TP
;
419 case PHY_TYPE_KR_10GB
:
420 case PHY_TYPE_KX4_10GB
:
421 ecmd
->autoneg
= AUTONEG_ENABLE
;
422 ecmd
->transceiver
= XCVR_INTERNAL
;
425 ecmd
->autoneg
= AUTONEG_DISABLE
;
426 ecmd
->transceiver
= XCVR_EXTERNAL
;
431 /* Save for future use */
432 adapter
->link_speed
= ecmd
->speed
;
433 adapter
->port_type
= ecmd
->port
;
434 adapter
->transceiver
= ecmd
->transceiver
;
435 adapter
->autoneg
= ecmd
->autoneg
;
436 dma_free_coherent(&adapter
->pdev
->dev
, phy_cmd
.size
, phy_cmd
.va
,
439 ecmd
->speed
= adapter
->link_speed
;
440 ecmd
->port
= adapter
->port_type
;
441 ecmd
->transceiver
= adapter
->transceiver
;
442 ecmd
->autoneg
= adapter
->autoneg
;
445 ecmd
->duplex
= DUPLEX_FULL
;
446 ecmd
->phy_address
= adapter
->port_num
;
447 switch (ecmd
->port
) {
449 ecmd
->supported
= (SUPPORTED_10000baseT_Full
| SUPPORTED_FIBRE
);
452 ecmd
->supported
= (SUPPORTED_10000baseT_Full
| SUPPORTED_TP
);
455 ecmd
->supported
= (SUPPORTED_10000baseT_Full
| SUPPORTED_AUI
);
460 ecmd
->supported
|= SUPPORTED_1000baseT_Full
;
461 ecmd
->supported
|= SUPPORTED_Autoneg
;
462 ecmd
->advertising
|= (ADVERTISED_10000baseT_Full
|
463 ADVERTISED_1000baseT_Full
);
470 be_get_ringparam(struct net_device
*netdev
, struct ethtool_ringparam
*ring
)
472 struct be_adapter
*adapter
= netdev_priv(netdev
);
474 ring
->rx_max_pending
= adapter
->rx_obj
[0].q
.len
;
475 ring
->tx_max_pending
= adapter
->tx_obj
.q
.len
;
477 ring
->rx_pending
= atomic_read(&adapter
->rx_obj
[0].q
.used
);
478 ring
->tx_pending
= atomic_read(&adapter
->tx_obj
.q
.used
);
482 be_get_pauseparam(struct net_device
*netdev
, struct ethtool_pauseparam
*ecmd
)
484 struct be_adapter
*adapter
= netdev_priv(netdev
);
486 be_cmd_get_flow_control(adapter
, &ecmd
->tx_pause
, &ecmd
->rx_pause
);
491 be_set_pauseparam(struct net_device
*netdev
, struct ethtool_pauseparam
*ecmd
)
493 struct be_adapter
*adapter
= netdev_priv(netdev
);
496 if (ecmd
->autoneg
!= 0)
498 adapter
->tx_fc
= ecmd
->tx_pause
;
499 adapter
->rx_fc
= ecmd
->rx_pause
;
501 status
= be_cmd_set_flow_control(adapter
,
502 adapter
->tx_fc
, adapter
->rx_fc
);
504 dev_warn(&adapter
->pdev
->dev
, "Pause param set failed.\n");
510 be_phys_id(struct net_device
*netdev
, u32 data
)
512 struct be_adapter
*adapter
= netdev_priv(netdev
);
516 be_cmd_get_beacon_state(adapter
, adapter
->hba_port_num
, &cur
);
518 if (cur
== BEACON_STATE_ENABLED
)
524 status
= be_cmd_set_beacon_state(adapter
, adapter
->hba_port_num
, 0, 0,
525 BEACON_STATE_ENABLED
);
526 set_current_state(TASK_INTERRUPTIBLE
);
527 schedule_timeout(data
*HZ
);
529 status
= be_cmd_set_beacon_state(adapter
, adapter
->hba_port_num
, 0, 0,
530 BEACON_STATE_DISABLED
);
536 be_is_wol_supported(struct be_adapter
*adapter
)
538 if (!be_physfn(adapter
))
545 be_get_wol(struct net_device
*netdev
, struct ethtool_wolinfo
*wol
)
547 struct be_adapter
*adapter
= netdev_priv(netdev
);
549 if (be_is_wol_supported(adapter
))
550 wol
->supported
= WAKE_MAGIC
;
553 wol
->wolopts
= WAKE_MAGIC
;
556 memset(&wol
->sopass
, 0, sizeof(wol
->sopass
));
560 be_set_wol(struct net_device
*netdev
, struct ethtool_wolinfo
*wol
)
562 struct be_adapter
*adapter
= netdev_priv(netdev
);
564 if (wol
->wolopts
& ~WAKE_MAGIC
)
567 if ((wol
->wolopts
& WAKE_MAGIC
) && be_is_wol_supported(adapter
))
570 adapter
->wol
= false;
576 be_test_ddr_dma(struct be_adapter
*adapter
)
579 struct be_dma_mem ddrdma_cmd
;
580 static const u64 pattern
[2] = {
581 0x5a5a5a5a5a5a5a5aULL
, 0xa5a5a5a5a5a5a5a5ULL
584 ddrdma_cmd
.size
= sizeof(struct be_cmd_req_ddrdma_test
);
585 ddrdma_cmd
.va
= dma_alloc_coherent(&adapter
->pdev
->dev
, ddrdma_cmd
.size
,
586 &ddrdma_cmd
.dma
, GFP_KERNEL
);
587 if (!ddrdma_cmd
.va
) {
588 dev_err(&adapter
->pdev
->dev
, "Memory allocation failure\n");
592 for (i
= 0; i
< 2; i
++) {
593 ret
= be_cmd_ddr_dma_test(adapter
, pattern
[i
],
600 dma_free_coherent(&adapter
->pdev
->dev
, ddrdma_cmd
.size
, ddrdma_cmd
.va
,
605 static u64
be_loopback_test(struct be_adapter
*adapter
, u8 loopback_type
,
608 be_cmd_set_loopback(adapter
, adapter
->hba_port_num
,
610 *status
= be_cmd_loopback_test(adapter
, adapter
->hba_port_num
,
613 be_cmd_set_loopback(adapter
, adapter
->hba_port_num
,
619 be_self_test(struct net_device
*netdev
, struct ethtool_test
*test
, u64
*data
)
621 struct be_adapter
*adapter
= netdev_priv(netdev
);
624 u16 qos_link_speed
= 0;
626 memset(data
, 0, sizeof(u64
) * ETHTOOL_TESTS_NUM
);
628 if (test
->flags
& ETH_TEST_FL_OFFLINE
) {
629 if (be_loopback_test(adapter
, BE_MAC_LOOPBACK
,
631 test
->flags
|= ETH_TEST_FL_FAILED
;
633 if (be_loopback_test(adapter
, BE_PHY_LOOPBACK
,
635 test
->flags
|= ETH_TEST_FL_FAILED
;
637 if (be_loopback_test(adapter
, BE_ONE_PORT_EXT_LOOPBACK
,
639 test
->flags
|= ETH_TEST_FL_FAILED
;
643 if (be_test_ddr_dma(adapter
) != 0) {
645 test
->flags
|= ETH_TEST_FL_FAILED
;
648 if (be_cmd_link_status_query(adapter
, &link_up
, &mac_speed
,
649 &qos_link_speed
) != 0) {
650 test
->flags
|= ETH_TEST_FL_FAILED
;
652 } else if (!mac_speed
) {
653 test
->flags
|= ETH_TEST_FL_FAILED
;
659 be_do_flash(struct net_device
*netdev
, struct ethtool_flash
*efl
)
661 struct be_adapter
*adapter
= netdev_priv(netdev
);
662 char file_name
[ETHTOOL_FLASH_MAX_FILENAME
];
665 file_name
[ETHTOOL_FLASH_MAX_FILENAME
- 1] = 0;
666 strcpy(file_name
, efl
->data
);
667 region
= efl
->region
;
669 return be_load_fw(adapter
, file_name
);
673 be_get_eeprom_len(struct net_device
*netdev
)
675 return BE_READ_SEEPROM_LEN
;
679 be_read_eeprom(struct net_device
*netdev
, struct ethtool_eeprom
*eeprom
,
682 struct be_adapter
*adapter
= netdev_priv(netdev
);
683 struct be_dma_mem eeprom_cmd
;
684 struct be_cmd_resp_seeprom_read
*resp
;
690 eeprom
->magic
= BE_VENDOR_ID
| (adapter
->pdev
->device
<<16);
692 memset(&eeprom_cmd
, 0, sizeof(struct be_dma_mem
));
693 eeprom_cmd
.size
= sizeof(struct be_cmd_req_seeprom_read
);
694 eeprom_cmd
.va
= dma_alloc_coherent(&adapter
->pdev
->dev
, eeprom_cmd
.size
,
695 &eeprom_cmd
.dma
, GFP_KERNEL
);
697 if (!eeprom_cmd
.va
) {
698 dev_err(&adapter
->pdev
->dev
,
699 "Memory allocation failure. Could not read eeprom\n");
703 status
= be_cmd_get_seeprom_data(adapter
, &eeprom_cmd
);
706 resp
= (struct be_cmd_resp_seeprom_read
*) eeprom_cmd
.va
;
707 memcpy(data
, resp
->seeprom_data
+ eeprom
->offset
, eeprom
->len
);
709 dma_free_coherent(&adapter
->pdev
->dev
, eeprom_cmd
.size
, eeprom_cmd
.va
,
715 const struct ethtool_ops be_ethtool_ops
= {
716 .get_settings
= be_get_settings
,
717 .get_drvinfo
= be_get_drvinfo
,
718 .get_wol
= be_get_wol
,
719 .set_wol
= be_set_wol
,
720 .get_link
= ethtool_op_get_link
,
721 .get_eeprom_len
= be_get_eeprom_len
,
722 .get_eeprom
= be_read_eeprom
,
723 .get_coalesce
= be_get_coalesce
,
724 .set_coalesce
= be_set_coalesce
,
725 .get_ringparam
= be_get_ringparam
,
726 .get_pauseparam
= be_get_pauseparam
,
727 .set_pauseparam
= be_set_pauseparam
,
728 .get_rx_csum
= be_get_rx_csum
,
729 .set_rx_csum
= be_set_rx_csum
,
730 .get_tx_csum
= ethtool_op_get_tx_csum
,
731 .set_tx_csum
= ethtool_op_set_tx_hw_csum
,
732 .get_sg
= ethtool_op_get_sg
,
733 .set_sg
= ethtool_op_set_sg
,
734 .get_tso
= ethtool_op_get_tso
,
735 .set_tso
= ethtool_op_set_tso
,
736 .get_strings
= be_get_stat_strings
,
737 .phys_id
= be_phys_id
,
738 .get_sset_count
= be_get_sset_count
,
739 .get_ethtool_stats
= be_get_ethtool_stats
,
740 .flash_device
= be_do_flash
,
741 .self_test
= be_self_test
,