blob: 91a1190990aeac395cbf03695611a220599c5c35 [file] [log] [blame]
Alexander Duyckd4e0fe02009-04-07 14:37:34 +00001/*******************************************************************************
2
3 Intel(R) 82576 Virtual Function Linux driver
Mitch A Williams2a06ed92012-01-17 04:09:05 +00004 Copyright(c) 2009 - 2012 Intel Corporation.
Alexander Duyckd4e0fe02009-04-07 14:37:34 +00005
6 This program is free software; you can redistribute it and/or modify it
7 under the terms and conditions of the GNU General Public License,
8 version 2, as published by the Free Software Foundation.
9
10 This program is distributed in the hope it will be useful, but WITHOUT
11 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 more details.
14
15 You should have received a copy of the GNU General Public License along with
Jeff Kirsher03405012015-01-21 09:57:50 +000016 this program; if not, see <http://www.gnu.org/licenses/>.
Alexander Duyckd4e0fe02009-04-07 14:37:34 +000017
18 The full GNU General Public License is included in this distribution in
19 the file called "COPYING".
20
21 Contact Information:
22 e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
23 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
24
25*******************************************************************************/
26
27/* ethtool support for igbvf */
28
29#include <linux/netdevice.h>
30#include <linux/ethtool.h>
31#include <linux/pci.h>
32#include <linux/vmalloc.h>
33#include <linux/delay.h>
34
35#include "igbvf.h"
36#include <linux/if_vlan.h>
37
Alexander Duyckd4e0fe02009-04-07 14:37:34 +000038struct igbvf_stats {
39 char stat_string[ETH_GSTRING_LEN];
40 int sizeof_stat;
41 int stat_offset;
42 int base_stat_offset;
43};
44
45#define IGBVF_STAT(current, base) \
46 sizeof(((struct igbvf_adapter *)0)->current), \
47 offsetof(struct igbvf_adapter, current), \
48 offsetof(struct igbvf_adapter, base)
49
50static const struct igbvf_stats igbvf_gstrings_stats[] = {
51 { "rx_packets", IGBVF_STAT(stats.gprc, stats.base_gprc) },
52 { "tx_packets", IGBVF_STAT(stats.gptc, stats.base_gptc) },
53 { "rx_bytes", IGBVF_STAT(stats.gorc, stats.base_gorc) },
54 { "tx_bytes", IGBVF_STAT(stats.gotc, stats.base_gotc) },
55 { "multicast", IGBVF_STAT(stats.mprc, stats.base_mprc) },
56 { "lbrx_bytes", IGBVF_STAT(stats.gorlbc, stats.base_gorlbc) },
57 { "lbrx_packets", IGBVF_STAT(stats.gprlbc, stats.base_gprlbc) },
58 { "tx_restart_queue", IGBVF_STAT(restart_queue, zero_base) },
59 { "rx_long_byte_count", IGBVF_STAT(stats.gorc, stats.base_gorc) },
60 { "rx_csum_offload_good", IGBVF_STAT(hw_csum_good, zero_base) },
61 { "rx_csum_offload_errors", IGBVF_STAT(hw_csum_err, zero_base) },
62 { "rx_header_split", IGBVF_STAT(rx_hdr_split, zero_base) },
63 { "alloc_rx_buff_failed", IGBVF_STAT(alloc_rx_buff_failed, zero_base) },
64};
65
66#define IGBVF_GLOBAL_STATS_LEN ARRAY_SIZE(igbvf_gstrings_stats)
67
68static const char igbvf_gstrings_test[][ETH_GSTRING_LEN] = {
69 "Link test (on/offline)"
70};
71
72#define IGBVF_TEST_LEN ARRAY_SIZE(igbvf_gstrings_test)
73
74static int igbvf_get_settings(struct net_device *netdev,
Jeff Kirsher03405012015-01-21 09:57:50 +000075 struct ethtool_cmd *ecmd)
Alexander Duyckd4e0fe02009-04-07 14:37:34 +000076{
77 struct igbvf_adapter *adapter = netdev_priv(netdev);
78 struct e1000_hw *hw = &adapter->hw;
79 u32 status;
80
81 ecmd->supported = SUPPORTED_1000baseT_Full;
82
83 ecmd->advertising = ADVERTISED_1000baseT_Full;
84
85 ecmd->port = -1;
86 ecmd->transceiver = XCVR_DUMMY1;
87
88 status = er32(STATUS);
89 if (status & E1000_STATUS_LU) {
90 if (status & E1000_STATUS_SPEED_1000)
David Decotigny70739492011-04-27 18:32:40 +000091 ethtool_cmd_speed_set(ecmd, SPEED_1000);
Alexander Duyckd4e0fe02009-04-07 14:37:34 +000092 else if (status & E1000_STATUS_SPEED_100)
David Decotigny70739492011-04-27 18:32:40 +000093 ethtool_cmd_speed_set(ecmd, SPEED_100);
Alexander Duyckd4e0fe02009-04-07 14:37:34 +000094 else
David Decotigny70739492011-04-27 18:32:40 +000095 ethtool_cmd_speed_set(ecmd, SPEED_10);
Alexander Duyckd4e0fe02009-04-07 14:37:34 +000096
97 if (status & E1000_STATUS_FD)
98 ecmd->duplex = DUPLEX_FULL;
99 else
100 ecmd->duplex = DUPLEX_HALF;
101 } else {
Jiri Pirko537fae02014-06-06 14:17:00 +0200102 ethtool_cmd_speed_set(ecmd, SPEED_UNKNOWN);
103 ecmd->duplex = DUPLEX_UNKNOWN;
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000104 }
105
106 ecmd->autoneg = AUTONEG_DISABLE;
107
108 return 0;
109}
110
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000111static int igbvf_set_settings(struct net_device *netdev,
Jeff Kirsher03405012015-01-21 09:57:50 +0000112 struct ethtool_cmd *ecmd)
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000113{
114 return -EOPNOTSUPP;
115}
116
117static void igbvf_get_pauseparam(struct net_device *netdev,
Jeff Kirsher03405012015-01-21 09:57:50 +0000118 struct ethtool_pauseparam *pause)
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000119{
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000120}
121
122static int igbvf_set_pauseparam(struct net_device *netdev,
Jeff Kirsher03405012015-01-21 09:57:50 +0000123 struct ethtool_pauseparam *pause)
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000124{
125 return -EOPNOTSUPP;
126}
127
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000128static u32 igbvf_get_msglevel(struct net_device *netdev)
129{
130 struct igbvf_adapter *adapter = netdev_priv(netdev);
Jeff Kirsher03405012015-01-21 09:57:50 +0000131
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000132 return adapter->msg_enable;
133}
134
135static void igbvf_set_msglevel(struct net_device *netdev, u32 data)
136{
137 struct igbvf_adapter *adapter = netdev_priv(netdev);
Jeff Kirsher03405012015-01-21 09:57:50 +0000138
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000139 adapter->msg_enable = data;
140}
141
142static int igbvf_get_regs_len(struct net_device *netdev)
143{
144#define IGBVF_REGS_LEN 8
145 return IGBVF_REGS_LEN * sizeof(u32);
146}
147
148static void igbvf_get_regs(struct net_device *netdev,
Jeff Kirsher03405012015-01-21 09:57:50 +0000149 struct ethtool_regs *regs, void *p)
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000150{
151 struct igbvf_adapter *adapter = netdev_priv(netdev);
152 struct e1000_hw *hw = &adapter->hw;
153 u32 *regs_buff = p;
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000154
155 memset(p, 0, IGBVF_REGS_LEN * sizeof(u32));
156
Sergei Shtylyovff938e42011-02-28 11:57:33 -0800157 regs->version = (1 << 24) | (adapter->pdev->revision << 16) |
158 adapter->pdev->device;
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000159
160 regs_buff[0] = er32(CTRL);
161 regs_buff[1] = er32(STATUS);
162
163 regs_buff[2] = er32(RDLEN(0));
164 regs_buff[3] = er32(RDH(0));
165 regs_buff[4] = er32(RDT(0));
166
167 regs_buff[5] = er32(TDLEN(0));
168 regs_buff[6] = er32(TDH(0));
169 regs_buff[7] = er32(TDT(0));
170}
171
172static int igbvf_get_eeprom_len(struct net_device *netdev)
173{
174 return 0;
175}
176
177static int igbvf_get_eeprom(struct net_device *netdev,
Jeff Kirsher03405012015-01-21 09:57:50 +0000178 struct ethtool_eeprom *eeprom, u8 *bytes)
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000179{
180 return -EOPNOTSUPP;
181}
182
183static int igbvf_set_eeprom(struct net_device *netdev,
Jeff Kirsher03405012015-01-21 09:57:50 +0000184 struct ethtool_eeprom *eeprom, u8 *bytes)
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000185{
186 return -EOPNOTSUPP;
187}
188
189static void igbvf_get_drvinfo(struct net_device *netdev,
Jeff Kirsher03405012015-01-21 09:57:50 +0000190 struct ethtool_drvinfo *drvinfo)
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000191{
192 struct igbvf_adapter *adapter = netdev_priv(netdev);
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000193
Rick Jones612a94d2011-11-14 08:13:25 +0000194 strlcpy(drvinfo->driver, igbvf_driver_name, sizeof(drvinfo->driver));
195 strlcpy(drvinfo->version, igbvf_driver_version,
196 sizeof(drvinfo->version));
Rick Jones612a94d2011-11-14 08:13:25 +0000197 strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
198 sizeof(drvinfo->bus_info));
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000199 drvinfo->regdump_len = igbvf_get_regs_len(netdev);
200 drvinfo->eedump_len = igbvf_get_eeprom_len(netdev);
201}
202
203static void igbvf_get_ringparam(struct net_device *netdev,
Jeff Kirsher03405012015-01-21 09:57:50 +0000204 struct ethtool_ringparam *ring)
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000205{
206 struct igbvf_adapter *adapter = netdev_priv(netdev);
207 struct igbvf_ring *tx_ring = adapter->tx_ring;
208 struct igbvf_ring *rx_ring = adapter->rx_ring;
209
210 ring->rx_max_pending = IGBVF_MAX_RXD;
211 ring->tx_max_pending = IGBVF_MAX_TXD;
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000212 ring->rx_pending = rx_ring->count;
213 ring->tx_pending = tx_ring->count;
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000214}
215
216static int igbvf_set_ringparam(struct net_device *netdev,
Jeff Kirsher03405012015-01-21 09:57:50 +0000217 struct ethtool_ringparam *ring)
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000218{
219 struct igbvf_adapter *adapter = netdev_priv(netdev);
220 struct igbvf_ring *temp_ring;
Alexander Duyck39305962009-10-26 11:32:25 +0000221 int err = 0;
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000222 u32 new_rx_count, new_tx_count;
223
224 if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
225 return -EINVAL;
226
227 new_rx_count = max(ring->rx_pending, (u32)IGBVF_MIN_RXD);
228 new_rx_count = min(new_rx_count, (u32)IGBVF_MAX_RXD);
229 new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE);
230
231 new_tx_count = max(ring->tx_pending, (u32)IGBVF_MIN_TXD);
232 new_tx_count = min(new_tx_count, (u32)IGBVF_MAX_TXD);
233 new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE);
234
235 if ((new_tx_count == adapter->tx_ring->count) &&
236 (new_rx_count == adapter->rx_ring->count)) {
237 /* nothing to do */
238 return 0;
239 }
240
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000241 while (test_and_set_bit(__IGBVF_RESETTING, &adapter->state))
242 msleep(1);
243
Alexander Duyck39305962009-10-26 11:32:25 +0000244 if (!netif_running(adapter->netdev)) {
245 adapter->tx_ring->count = new_tx_count;
246 adapter->rx_ring->count = new_rx_count;
247 goto clear_reset;
248 }
249
250 temp_ring = vmalloc(sizeof(struct igbvf_ring));
251 if (!temp_ring) {
252 err = -ENOMEM;
253 goto clear_reset;
254 }
255
256 igbvf_down(adapter);
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000257
Jeff Kirsher03405012015-01-21 09:57:50 +0000258 /* We can't just free everything and then setup again,
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000259 * because the ISRs in MSI-X mode get passed pointers
Jeff Kirsher03405012015-01-21 09:57:50 +0000260 * to the Tx and Rx ring structs.
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000261 */
262 if (new_tx_count != adapter->tx_ring->count) {
263 memcpy(temp_ring, adapter->tx_ring, sizeof(struct igbvf_ring));
264
265 temp_ring->count = new_tx_count;
266 err = igbvf_setup_tx_resources(adapter, temp_ring);
267 if (err)
268 goto err_setup;
269
270 igbvf_free_tx_resources(adapter->tx_ring);
271
272 memcpy(adapter->tx_ring, temp_ring, sizeof(struct igbvf_ring));
273 }
274
275 if (new_rx_count != adapter->rx_ring->count) {
276 memcpy(temp_ring, adapter->rx_ring, sizeof(struct igbvf_ring));
277
278 temp_ring->count = new_rx_count;
279 err = igbvf_setup_rx_resources(adapter, temp_ring);
280 if (err)
281 goto err_setup;
282
283 igbvf_free_rx_resources(adapter->rx_ring);
284
Jeff Kirsher03405012015-01-21 09:57:50 +0000285 memcpy(adapter->rx_ring, temp_ring, sizeof(struct igbvf_ring));
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000286 }
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000287err_setup:
Alexander Duyck39305962009-10-26 11:32:25 +0000288 igbvf_up(adapter);
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000289 vfree(temp_ring);
Alexander Duyck39305962009-10-26 11:32:25 +0000290clear_reset:
291 clear_bit(__IGBVF_RESETTING, &adapter->state);
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000292 return err;
293}
294
295static int igbvf_link_test(struct igbvf_adapter *adapter, u64 *data)
296{
297 struct e1000_hw *hw = &adapter->hw;
298 *data = 0;
299
300 hw->mac.ops.check_for_link(hw);
301
302 if (!(er32(STATUS) & E1000_STATUS_LU))
303 *data = 1;
304
305 return *data;
306}
307
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000308static void igbvf_diag_test(struct net_device *netdev,
Jeff Kirsher03405012015-01-21 09:57:50 +0000309 struct ethtool_test *eth_test, u64 *data)
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000310{
311 struct igbvf_adapter *adapter = netdev_priv(netdev);
312
313 set_bit(__IGBVF_TESTING, &adapter->state);
314
Jeff Kirsher03405012015-01-21 09:57:50 +0000315 /* Link test performed before hardware reset so autoneg doesn't
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000316 * interfere with test result
317 */
318 if (igbvf_link_test(adapter, &data[0]))
319 eth_test->flags |= ETH_TEST_FL_FAILED;
320
321 clear_bit(__IGBVF_TESTING, &adapter->state);
322 msleep_interruptible(4 * 1000);
323}
324
325static void igbvf_get_wol(struct net_device *netdev,
Jeff Kirsher03405012015-01-21 09:57:50 +0000326 struct ethtool_wolinfo *wol)
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000327{
328 wol->supported = 0;
329 wol->wolopts = 0;
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000330}
331
332static int igbvf_set_wol(struct net_device *netdev,
Jeff Kirsher03405012015-01-21 09:57:50 +0000333 struct ethtool_wolinfo *wol)
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000334{
335 return -EOPNOTSUPP;
336}
337
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000338static int igbvf_get_coalesce(struct net_device *netdev,
Jeff Kirsher03405012015-01-21 09:57:50 +0000339 struct ethtool_coalesce *ec)
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000340{
341 struct igbvf_adapter *adapter = netdev_priv(netdev);
342
Mitch A Williamsab50a2a2012-01-14 08:10:50 +0000343 if (adapter->requested_itr <= 3)
344 ec->rx_coalesce_usecs = adapter->requested_itr;
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000345 else
Mitch A Williamsab50a2a2012-01-14 08:10:50 +0000346 ec->rx_coalesce_usecs = adapter->current_itr >> 2;
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000347
348 return 0;
349}
350
351static int igbvf_set_coalesce(struct net_device *netdev,
Jeff Kirsher03405012015-01-21 09:57:50 +0000352 struct ethtool_coalesce *ec)
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000353{
354 struct igbvf_adapter *adapter = netdev_priv(netdev);
355 struct e1000_hw *hw = &adapter->hw;
356
Mitch A Williams0e90b492012-06-30 00:23:19 +0000357 if ((ec->rx_coalesce_usecs >= IGBVF_MIN_ITR_USECS) &&
Jeff Kirsher03405012015-01-21 09:57:50 +0000358 (ec->rx_coalesce_usecs <= IGBVF_MAX_ITR_USECS)) {
Mitch A Williamsab50a2a2012-01-14 08:10:50 +0000359 adapter->current_itr = ec->rx_coalesce_usecs << 2;
360 adapter->requested_itr = 1000000000 /
361 (adapter->current_itr * 256);
Mitch A Williams0e90b492012-06-30 00:23:19 +0000362 } else if ((ec->rx_coalesce_usecs == 3) ||
363 (ec->rx_coalesce_usecs == 2)) {
364 adapter->current_itr = IGBVF_START_ITR;
365 adapter->requested_itr = ec->rx_coalesce_usecs;
366 } else if (ec->rx_coalesce_usecs == 0) {
Jeff Kirsher03405012015-01-21 09:57:50 +0000367 /* The user's desire is to turn off interrupt throttling
Mitch A Williams0e90b492012-06-30 00:23:19 +0000368 * altogether, but due to HW limitations, we can't do that.
369 * Instead we set a very small value in EITR, which would
370 * allow ~967k interrupts per second, but allow the adapter's
371 * internal clocking to still function properly.
372 */
373 adapter->current_itr = 4;
374 adapter->requested_itr = 1000000000 /
375 (adapter->current_itr * 256);
Jeff Kirsher03405012015-01-21 09:57:50 +0000376 } else {
Mitch A Williams0e90b492012-06-30 00:23:19 +0000377 return -EINVAL;
Jeff Kirsher03405012015-01-21 09:57:50 +0000378 }
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000379
Mitch A Williamsab50a2a2012-01-14 08:10:50 +0000380 writel(adapter->current_itr,
381 hw->hw_addr + adapter->rx_ring->itr_register);
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000382
383 return 0;
384}
385
386static int igbvf_nway_reset(struct net_device *netdev)
387{
388 struct igbvf_adapter *adapter = netdev_priv(netdev);
Jeff Kirsher03405012015-01-21 09:57:50 +0000389
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000390 if (netif_running(netdev))
391 igbvf_reinit_locked(adapter);
392 return 0;
393}
394
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000395static void igbvf_get_ethtool_stats(struct net_device *netdev,
Jeff Kirsher03405012015-01-21 09:57:50 +0000396 struct ethtool_stats *stats,
397 u64 *data)
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000398{
399 struct igbvf_adapter *adapter = netdev_priv(netdev);
400 int i;
401
402 igbvf_update_stats(adapter);
403 for (i = 0; i < IGBVF_GLOBAL_STATS_LEN; i++) {
404 char *p = (char *)adapter +
Jeff Kirsher03405012015-01-21 09:57:50 +0000405 igbvf_gstrings_stats[i].stat_offset;
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000406 char *b = (char *)adapter +
Jeff Kirsher03405012015-01-21 09:57:50 +0000407 igbvf_gstrings_stats[i].base_stat_offset;
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000408 data[i] = ((igbvf_gstrings_stats[i].sizeof_stat ==
Jeff Kirsher03405012015-01-21 09:57:50 +0000409 sizeof(u64)) ? (*(u64 *)p - *(u64 *)b) :
410 (*(u32 *)p - *(u32 *)b));
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000411 }
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000412}
413
Ben Hutchings15f0a392009-10-01 11:58:24 +0000414static int igbvf_get_sset_count(struct net_device *dev, int stringset)
415{
Jeff Kirsher03405012015-01-21 09:57:50 +0000416 switch (stringset) {
Ben Hutchings15f0a392009-10-01 11:58:24 +0000417 case ETH_SS_TEST:
418 return IGBVF_TEST_LEN;
419 case ETH_SS_STATS:
420 return IGBVF_GLOBAL_STATS_LEN;
421 default:
422 return -EINVAL;
423 }
424}
425
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000426static void igbvf_get_strings(struct net_device *netdev, u32 stringset,
Jeff Kirsher03405012015-01-21 09:57:50 +0000427 u8 *data)
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000428{
429 u8 *p = data;
430 int i;
431
432 switch (stringset) {
433 case ETH_SS_TEST:
434 memcpy(data, *igbvf_gstrings_test, sizeof(igbvf_gstrings_test));
435 break;
436 case ETH_SS_STATS:
437 for (i = 0; i < IGBVF_GLOBAL_STATS_LEN; i++) {
438 memcpy(p, igbvf_gstrings_stats[i].stat_string,
439 ETH_GSTRING_LEN);
440 p += ETH_GSTRING_LEN;
441 }
442 break;
443 }
444}
445
446static const struct ethtool_ops igbvf_ethtool_ops = {
447 .get_settings = igbvf_get_settings,
448 .set_settings = igbvf_set_settings,
449 .get_drvinfo = igbvf_get_drvinfo,
450 .get_regs_len = igbvf_get_regs_len,
451 .get_regs = igbvf_get_regs,
452 .get_wol = igbvf_get_wol,
453 .set_wol = igbvf_set_wol,
454 .get_msglevel = igbvf_get_msglevel,
455 .set_msglevel = igbvf_set_msglevel,
456 .nway_reset = igbvf_nway_reset,
Ben Hutchingsed4ba4b2010-12-09 12:10:25 +0000457 .get_link = ethtool_op_get_link,
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000458 .get_eeprom_len = igbvf_get_eeprom_len,
459 .get_eeprom = igbvf_get_eeprom,
460 .set_eeprom = igbvf_set_eeprom,
461 .get_ringparam = igbvf_get_ringparam,
462 .set_ringparam = igbvf_set_ringparam,
463 .get_pauseparam = igbvf_get_pauseparam,
464 .set_pauseparam = igbvf_set_pauseparam,
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000465 .self_test = igbvf_diag_test,
Ben Hutchings15f0a392009-10-01 11:58:24 +0000466 .get_sset_count = igbvf_get_sset_count,
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000467 .get_strings = igbvf_get_strings,
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000468 .get_ethtool_stats = igbvf_get_ethtool_stats,
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000469 .get_coalesce = igbvf_get_coalesce,
470 .set_coalesce = igbvf_set_coalesce,
471};
472
473void igbvf_set_ethtool_ops(struct net_device *netdev)
474{
Wilfried Klaebe7ad24ea2014-05-11 00:12:32 +0000475 netdev->ethtool_ops = &igbvf_ethtool_ops;
Alexander Duyckd4e0fe02009-04-07 14:37:34 +0000476}