PageRenderTime 44ms CodeModel.GetById 17ms app.highlight 23ms RepoModel.GetById 0ms app.codeStats 1ms

/drivers/net/ixgbevf/ethtool.c

https://bitbucket.org/ndreys/linux-sunxi
C | 742 lines | 585 code | 92 blank | 65 comment | 66 complexity | 0269354e8d3067362ef1faf10b519cd7 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
  1/*******************************************************************************
  2
  3  Intel 82599 Virtual Function driver
  4  Copyright(c) 1999 - 2009 Intel Corporation.
  5
  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
 16  this program; if not, write to the Free Software Foundation, Inc.,
 17  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
 18
 19  The full GNU General Public License is included in this distribution in
 20  the file called "COPYING".
 21
 22  Contact Information:
 23  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
 24  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 25
 26*******************************************************************************/
 27
 28/* ethtool support for ixgbevf */
 29
 30#include <linux/types.h>
 31#include <linux/module.h>
 32#include <linux/slab.h>
 33#include <linux/pci.h>
 34#include <linux/netdevice.h>
 35#include <linux/ethtool.h>
 36#include <linux/vmalloc.h>
 37#include <linux/if_vlan.h>
 38#include <linux/uaccess.h>
 39
 40#include "ixgbevf.h"
 41
 42#define IXGBE_ALL_RAR_ENTRIES 16
 43
 44#ifdef ETHTOOL_GSTATS
 45struct ixgbe_stats {
 46	char stat_string[ETH_GSTRING_LEN];
 47	int sizeof_stat;
 48	int stat_offset;
 49	int base_stat_offset;
 50	int saved_reset_offset;
 51};
 52
 53#define IXGBEVF_STAT(m, b, r)  sizeof(((struct ixgbevf_adapter *)0)->m), \
 54			    offsetof(struct ixgbevf_adapter, m),         \
 55			    offsetof(struct ixgbevf_adapter, b),         \
 56			    offsetof(struct ixgbevf_adapter, r)
 57static struct ixgbe_stats ixgbe_gstrings_stats[] = {
 58	{"rx_packets", IXGBEVF_STAT(stats.vfgprc, stats.base_vfgprc,
 59				    stats.saved_reset_vfgprc)},
 60	{"tx_packets", IXGBEVF_STAT(stats.vfgptc, stats.base_vfgptc,
 61				    stats.saved_reset_vfgptc)},
 62	{"rx_bytes", IXGBEVF_STAT(stats.vfgorc, stats.base_vfgorc,
 63				  stats.saved_reset_vfgorc)},
 64	{"tx_bytes", IXGBEVF_STAT(stats.vfgotc, stats.base_vfgotc,
 65				  stats.saved_reset_vfgotc)},
 66	{"tx_busy", IXGBEVF_STAT(tx_busy, zero_base, zero_base)},
 67	{"multicast", IXGBEVF_STAT(stats.vfmprc, stats.base_vfmprc,
 68				   stats.saved_reset_vfmprc)},
 69	{"rx_csum_offload_good", IXGBEVF_STAT(hw_csum_rx_good, zero_base,
 70					      zero_base)},
 71	{"rx_csum_offload_errors", IXGBEVF_STAT(hw_csum_rx_error, zero_base,
 72						zero_base)},
 73	{"tx_csum_offload_ctxt", IXGBEVF_STAT(hw_csum_tx_good, zero_base,
 74					      zero_base)},
 75	{"rx_header_split", IXGBEVF_STAT(rx_hdr_split, zero_base, zero_base)},
 76};
 77
 78#define IXGBE_QUEUE_STATS_LEN 0
 79#define IXGBE_GLOBAL_STATS_LEN	ARRAY_SIZE(ixgbe_gstrings_stats)
 80
 81#define IXGBEVF_STATS_LEN (IXGBE_GLOBAL_STATS_LEN + IXGBE_QUEUE_STATS_LEN)
 82#endif /* ETHTOOL_GSTATS */
 83#ifdef ETHTOOL_TEST
 84static const char ixgbe_gstrings_test[][ETH_GSTRING_LEN] = {
 85	"Register test  (offline)",
 86	"Link test   (on/offline)"
 87};
 88#define IXGBE_TEST_LEN (sizeof(ixgbe_gstrings_test) / ETH_GSTRING_LEN)
 89#endif /* ETHTOOL_TEST */
 90
 91static int ixgbevf_get_settings(struct net_device *netdev,
 92				struct ethtool_cmd *ecmd)
 93{
 94	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 95	struct ixgbe_hw *hw = &adapter->hw;
 96	u32 link_speed = 0;
 97	bool link_up;
 98
 99	ecmd->supported = SUPPORTED_10000baseT_Full;
100	ecmd->autoneg = AUTONEG_DISABLE;
101	ecmd->transceiver = XCVR_DUMMY1;
102	ecmd->port = -1;
103
104	hw->mac.ops.check_link(hw, &link_speed, &link_up, false);
105
106	if (link_up) {
107		ethtool_cmd_speed_set(
108			ecmd,
109			(link_speed == IXGBE_LINK_SPEED_10GB_FULL) ?
110			SPEED_10000 : SPEED_1000);
111		ecmd->duplex = DUPLEX_FULL;
112	} else {
113		ethtool_cmd_speed_set(ecmd, -1);
114		ecmd->duplex = -1;
115	}
116
117	return 0;
118}
119
120static u32 ixgbevf_get_rx_csum(struct net_device *netdev)
121{
122	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
123	return adapter->flags & IXGBE_FLAG_RX_CSUM_ENABLED;
124}
125
126static int ixgbevf_set_rx_csum(struct net_device *netdev, u32 data)
127{
128	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
129	if (data)
130		adapter->flags |= IXGBE_FLAG_RX_CSUM_ENABLED;
131	else
132		adapter->flags &= ~IXGBE_FLAG_RX_CSUM_ENABLED;
133
134	if (netif_running(netdev)) {
135		if (!adapter->dev_closed)
136			ixgbevf_reinit_locked(adapter);
137	} else {
138		ixgbevf_reset(adapter);
139	}
140
141	return 0;
142}
143
144static int ixgbevf_set_tso(struct net_device *netdev, u32 data)
145{
146	if (data) {
147		netdev->features |= NETIF_F_TSO;
148		netdev->features |= NETIF_F_TSO6;
149	} else {
150		netif_tx_stop_all_queues(netdev);
151		netdev->features &= ~NETIF_F_TSO;
152		netdev->features &= ~NETIF_F_TSO6;
153		netif_tx_start_all_queues(netdev);
154	}
155	return 0;
156}
157
158static u32 ixgbevf_get_msglevel(struct net_device *netdev)
159{
160	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
161	return adapter->msg_enable;
162}
163
164static void ixgbevf_set_msglevel(struct net_device *netdev, u32 data)
165{
166	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
167	adapter->msg_enable = data;
168}
169
170#define IXGBE_GET_STAT(_A_, _R_) (_A_->stats._R_)
171
172static char *ixgbevf_reg_names[] = {
173	"IXGBE_VFCTRL",
174	"IXGBE_VFSTATUS",
175	"IXGBE_VFLINKS",
176	"IXGBE_VFRXMEMWRAP",
177	"IXGBE_VFFRTIMER",
178	"IXGBE_VTEICR",
179	"IXGBE_VTEICS",
180	"IXGBE_VTEIMS",
181	"IXGBE_VTEIMC",
182	"IXGBE_VTEIAC",
183	"IXGBE_VTEIAM",
184	"IXGBE_VTEITR",
185	"IXGBE_VTIVAR",
186	"IXGBE_VTIVAR_MISC",
187	"IXGBE_VFRDBAL0",
188	"IXGBE_VFRDBAL1",
189	"IXGBE_VFRDBAH0",
190	"IXGBE_VFRDBAH1",
191	"IXGBE_VFRDLEN0",
192	"IXGBE_VFRDLEN1",
193	"IXGBE_VFRDH0",
194	"IXGBE_VFRDH1",
195	"IXGBE_VFRDT0",
196	"IXGBE_VFRDT1",
197	"IXGBE_VFRXDCTL0",
198	"IXGBE_VFRXDCTL1",
199	"IXGBE_VFSRRCTL0",
200	"IXGBE_VFSRRCTL1",
201	"IXGBE_VFPSRTYPE",
202	"IXGBE_VFTDBAL0",
203	"IXGBE_VFTDBAL1",
204	"IXGBE_VFTDBAH0",
205	"IXGBE_VFTDBAH1",
206	"IXGBE_VFTDLEN0",
207	"IXGBE_VFTDLEN1",
208	"IXGBE_VFTDH0",
209	"IXGBE_VFTDH1",
210	"IXGBE_VFTDT0",
211	"IXGBE_VFTDT1",
212	"IXGBE_VFTXDCTL0",
213	"IXGBE_VFTXDCTL1",
214	"IXGBE_VFTDWBAL0",
215	"IXGBE_VFTDWBAL1",
216	"IXGBE_VFTDWBAH0",
217	"IXGBE_VFTDWBAH1"
218};
219
220
221static int ixgbevf_get_regs_len(struct net_device *netdev)
222{
223	return (ARRAY_SIZE(ixgbevf_reg_names)) * sizeof(u32);
224}
225
226static void ixgbevf_get_regs(struct net_device *netdev,
227			     struct ethtool_regs *regs,
228			     void *p)
229{
230	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
231	struct ixgbe_hw *hw = &adapter->hw;
232	u32 *regs_buff = p;
233	u32 regs_len = ixgbevf_get_regs_len(netdev);
234	u8 i;
235
236	memset(p, 0, regs_len);
237
238	regs->version = (1 << 24) | hw->revision_id << 16 | hw->device_id;
239
240	/* General Registers */
241	regs_buff[0] = IXGBE_READ_REG(hw, IXGBE_VFCTRL);
242	regs_buff[1] = IXGBE_READ_REG(hw, IXGBE_VFSTATUS);
243	regs_buff[2] = IXGBE_READ_REG(hw, IXGBE_VFLINKS);
244	regs_buff[3] = IXGBE_READ_REG(hw, IXGBE_VFRXMEMWRAP);
245	regs_buff[4] = IXGBE_READ_REG(hw, IXGBE_VFFRTIMER);
246
247	/* Interrupt */
248	/* don't read EICR because it can clear interrupt causes, instead
249	 * read EICS which is a shadow but doesn't clear EICR */
250	regs_buff[5] = IXGBE_READ_REG(hw, IXGBE_VTEICS);
251	regs_buff[6] = IXGBE_READ_REG(hw, IXGBE_VTEICS);
252	regs_buff[7] = IXGBE_READ_REG(hw, IXGBE_VTEIMS);
253	regs_buff[8] = IXGBE_READ_REG(hw, IXGBE_VTEIMC);
254	regs_buff[9] = IXGBE_READ_REG(hw, IXGBE_VTEIAC);
255	regs_buff[10] = IXGBE_READ_REG(hw, IXGBE_VTEIAM);
256	regs_buff[11] = IXGBE_READ_REG(hw, IXGBE_VTEITR(0));
257	regs_buff[12] = IXGBE_READ_REG(hw, IXGBE_VTIVAR(0));
258	regs_buff[13] = IXGBE_READ_REG(hw, IXGBE_VTIVAR_MISC);
259
260	/* Receive DMA */
261	for (i = 0; i < 2; i++)
262		regs_buff[14 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDBAL(i));
263	for (i = 0; i < 2; i++)
264		regs_buff[16 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDBAH(i));
265	for (i = 0; i < 2; i++)
266		regs_buff[18 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDLEN(i));
267	for (i = 0; i < 2; i++)
268		regs_buff[20 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDH(i));
269	for (i = 0; i < 2; i++)
270		regs_buff[22 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDT(i));
271	for (i = 0; i < 2; i++)
272		regs_buff[24 + i] = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i));
273	for (i = 0; i < 2; i++)
274		regs_buff[26 + i] = IXGBE_READ_REG(hw, IXGBE_VFSRRCTL(i));
275
276	/* Receive */
277	regs_buff[28] = IXGBE_READ_REG(hw, IXGBE_VFPSRTYPE);
278
279	/* Transmit */
280	for (i = 0; i < 2; i++)
281		regs_buff[29 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDBAL(i));
282	for (i = 0; i < 2; i++)
283		regs_buff[31 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDBAH(i));
284	for (i = 0; i < 2; i++)
285		regs_buff[33 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDLEN(i));
286	for (i = 0; i < 2; i++)
287		regs_buff[35 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDH(i));
288	for (i = 0; i < 2; i++)
289		regs_buff[37 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDT(i));
290	for (i = 0; i < 2; i++)
291		regs_buff[39 + i] = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i));
292	for (i = 0; i < 2; i++)
293		regs_buff[41 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDWBAL(i));
294	for (i = 0; i < 2; i++)
295		regs_buff[43 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDWBAH(i));
296
297	for (i = 0; i < ARRAY_SIZE(ixgbevf_reg_names); i++)
298		hw_dbg(hw, "%s\t%8.8x\n", ixgbevf_reg_names[i], regs_buff[i]);
299}
300
301static void ixgbevf_get_drvinfo(struct net_device *netdev,
302				struct ethtool_drvinfo *drvinfo)
303{
304	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
305
306	strlcpy(drvinfo->driver, ixgbevf_driver_name, 32);
307	strlcpy(drvinfo->version, ixgbevf_driver_version, 32);
308
309	strlcpy(drvinfo->fw_version, "N/A", 4);
310	strlcpy(drvinfo->bus_info, pci_name(adapter->pdev), 32);
311}
312
313static void ixgbevf_get_ringparam(struct net_device *netdev,
314				  struct ethtool_ringparam *ring)
315{
316	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
317	struct ixgbevf_ring *tx_ring = adapter->tx_ring;
318	struct ixgbevf_ring *rx_ring = adapter->rx_ring;
319
320	ring->rx_max_pending = IXGBEVF_MAX_RXD;
321	ring->tx_max_pending = IXGBEVF_MAX_TXD;
322	ring->rx_mini_max_pending = 0;
323	ring->rx_jumbo_max_pending = 0;
324	ring->rx_pending = rx_ring->count;
325	ring->tx_pending = tx_ring->count;
326	ring->rx_mini_pending = 0;
327	ring->rx_jumbo_pending = 0;
328}
329
330static int ixgbevf_set_ringparam(struct net_device *netdev,
331				 struct ethtool_ringparam *ring)
332{
333	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
334	struct ixgbevf_ring *tx_ring = NULL, *rx_ring = NULL;
335	int i, err = 0;
336	u32 new_rx_count, new_tx_count;
337
338	if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
339		return -EINVAL;
340
341	new_rx_count = max(ring->rx_pending, (u32)IXGBEVF_MIN_RXD);
342	new_rx_count = min(new_rx_count, (u32)IXGBEVF_MAX_RXD);
343	new_rx_count = ALIGN(new_rx_count, IXGBE_REQ_RX_DESCRIPTOR_MULTIPLE);
344
345	new_tx_count = max(ring->tx_pending, (u32)IXGBEVF_MIN_TXD);
346	new_tx_count = min(new_tx_count, (u32)IXGBEVF_MAX_TXD);
347	new_tx_count = ALIGN(new_tx_count, IXGBE_REQ_TX_DESCRIPTOR_MULTIPLE);
348
349	if ((new_tx_count == adapter->tx_ring->count) &&
350	    (new_rx_count == adapter->rx_ring->count)) {
351		/* nothing to do */
352		return 0;
353	}
354
355	while (test_and_set_bit(__IXGBEVF_RESETTING, &adapter->state))
356		msleep(1);
357
358	/*
359	 * If the adapter isn't up and running then just set the
360	 * new parameters and scurry for the exits.
361	 */
362	if (!netif_running(adapter->netdev)) {
363		for (i = 0; i < adapter->num_tx_queues; i++)
364			adapter->tx_ring[i].count = new_tx_count;
365		for (i = 0; i < adapter->num_rx_queues; i++)
366			adapter->rx_ring[i].count = new_rx_count;
367		adapter->tx_ring_count = new_tx_count;
368		adapter->rx_ring_count = new_rx_count;
369		goto clear_reset;
370	}
371
372	tx_ring = kcalloc(adapter->num_tx_queues,
373			  sizeof(struct ixgbevf_ring), GFP_KERNEL);
374	if (!tx_ring) {
375		err = -ENOMEM;
376		goto clear_reset;
377	}
378
379	rx_ring = kcalloc(adapter->num_rx_queues,
380			  sizeof(struct ixgbevf_ring), GFP_KERNEL);
381	if (!rx_ring) {
382		err = -ENOMEM;
383		goto err_rx_setup;
384	}
385
386	ixgbevf_down(adapter);
387
388	memcpy(tx_ring, adapter->tx_ring,
389	       adapter->num_tx_queues * sizeof(struct ixgbevf_ring));
390	for (i = 0; i < adapter->num_tx_queues; i++) {
391		tx_ring[i].count = new_tx_count;
392		err = ixgbevf_setup_tx_resources(adapter, &tx_ring[i]);
393		if (err) {
394			while (i) {
395				i--;
396				ixgbevf_free_tx_resources(adapter,
397							  &tx_ring[i]);
398			}
399			goto err_tx_ring_setup;
400		}
401		tx_ring[i].v_idx = adapter->tx_ring[i].v_idx;
402	}
403
404	memcpy(rx_ring, adapter->rx_ring,
405	       adapter->num_rx_queues * sizeof(struct ixgbevf_ring));
406	for (i = 0; i < adapter->num_rx_queues; i++) {
407		rx_ring[i].count = new_rx_count;
408		err = ixgbevf_setup_rx_resources(adapter, &rx_ring[i]);
409		if (err) {
410			while (i) {
411				i--;
412				ixgbevf_free_rx_resources(adapter,
413							  &rx_ring[i]);
414			}
415				goto err_rx_ring_setup;
416		}
417		rx_ring[i].v_idx = adapter->rx_ring[i].v_idx;
418	}
419
420	/*
421	 * Only switch to new rings if all the prior allocations
422	 * and ring setups have succeeded.
423	 */
424	kfree(adapter->tx_ring);
425	adapter->tx_ring = tx_ring;
426	adapter->tx_ring_count = new_tx_count;
427
428	kfree(adapter->rx_ring);
429	adapter->rx_ring = rx_ring;
430	adapter->rx_ring_count = new_rx_count;
431
432	/* success! */
433	ixgbevf_up(adapter);
434
435	goto clear_reset;
436
437err_rx_ring_setup:
438	for(i = 0; i < adapter->num_tx_queues; i++)
439		ixgbevf_free_tx_resources(adapter, &tx_ring[i]);
440
441err_tx_ring_setup:
442	kfree(rx_ring);
443
444err_rx_setup:
445	kfree(tx_ring);
446
447clear_reset:
448	clear_bit(__IXGBEVF_RESETTING, &adapter->state);
449	return err;
450}
451
452static int ixgbevf_get_sset_count(struct net_device *dev, int stringset)
453{
454       switch (stringset) {
455       case ETH_SS_TEST:
456	       return IXGBE_TEST_LEN;
457       case ETH_SS_STATS:
458	       return IXGBE_GLOBAL_STATS_LEN;
459       default:
460	       return -EINVAL;
461       }
462}
463
464static void ixgbevf_get_ethtool_stats(struct net_device *netdev,
465				      struct ethtool_stats *stats, u64 *data)
466{
467	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
468	int i;
469
470	ixgbevf_update_stats(adapter);
471	for (i = 0; i < IXGBE_GLOBAL_STATS_LEN; i++) {
472		char *p = (char *)adapter +
473			ixgbe_gstrings_stats[i].stat_offset;
474		char *b = (char *)adapter +
475			ixgbe_gstrings_stats[i].base_stat_offset;
476		char *r = (char *)adapter +
477			ixgbe_gstrings_stats[i].saved_reset_offset;
478		data[i] = ((ixgbe_gstrings_stats[i].sizeof_stat ==
479			    sizeof(u64)) ? *(u64 *)p : *(u32 *)p) -
480			  ((ixgbe_gstrings_stats[i].sizeof_stat ==
481			    sizeof(u64)) ? *(u64 *)b : *(u32 *)b) +
482			  ((ixgbe_gstrings_stats[i].sizeof_stat ==
483			    sizeof(u64)) ? *(u64 *)r : *(u32 *)r);
484	}
485}
486
487static void ixgbevf_get_strings(struct net_device *netdev, u32 stringset,
488				u8 *data)
489{
490	char *p = (char *)data;
491	int i;
492
493	switch (stringset) {
494	case ETH_SS_TEST:
495		memcpy(data, *ixgbe_gstrings_test,
496		       IXGBE_TEST_LEN * ETH_GSTRING_LEN);
497		break;
498	case ETH_SS_STATS:
499		for (i = 0; i < IXGBE_GLOBAL_STATS_LEN; i++) {
500			memcpy(p, ixgbe_gstrings_stats[i].stat_string,
501			       ETH_GSTRING_LEN);
502			p += ETH_GSTRING_LEN;
503		}
504		break;
505	}
506}
507
508static int ixgbevf_link_test(struct ixgbevf_adapter *adapter, u64 *data)
509{
510	struct ixgbe_hw *hw = &adapter->hw;
511	bool link_up;
512	u32 link_speed = 0;
513	*data = 0;
514
515	hw->mac.ops.check_link(hw, &link_speed, &link_up, true);
516	if (!link_up)
517		*data = 1;
518
519	return *data;
520}
521
522/* ethtool register test data */
523struct ixgbevf_reg_test {
524	u16 reg;
525	u8  array_len;
526	u8  test_type;
527	u32 mask;
528	u32 write;
529};
530
531/* In the hardware, registers are laid out either singly, in arrays
532 * spaced 0x40 bytes apart, or in contiguous tables.  We assume
533 * most tests take place on arrays or single registers (handled
534 * as a single-element array) and special-case the tables.
535 * Table tests are always pattern tests.
536 *
537 * We also make provision for some required setup steps by specifying
538 * registers to be written without any read-back testing.
539 */
540
541#define PATTERN_TEST	1
542#define SET_READ_TEST	2
543#define WRITE_NO_TEST	3
544#define TABLE32_TEST	4
545#define TABLE64_TEST_LO	5
546#define TABLE64_TEST_HI	6
547
548/* default VF register test */
549static const struct ixgbevf_reg_test reg_test_vf[] = {
550	{ IXGBE_VFRDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFF80 },
551	{ IXGBE_VFRDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF },
552	{ IXGBE_VFRDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFFFF },
553	{ IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, IXGBE_RXDCTL_ENABLE },
554	{ IXGBE_VFRDT(0), 2, PATTERN_TEST, 0x0000FFFF, 0x0000FFFF },
555	{ IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, 0 },
556	{ IXGBE_VFTDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFFFF },
557	{ IXGBE_VFTDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF },
558	{ IXGBE_VFTDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFF80 },
559	{ 0, 0, 0, 0 }
560};
561
562static const u32 register_test_patterns[] = {
563	0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF
564};
565
566#define REG_PATTERN_TEST(R, M, W)                                             \
567{                                                                             \
568	u32 pat, val, before;                                                 \
569	for (pat = 0; pat < ARRAY_SIZE(register_test_patterns); pat++) {      \
570		before = readl(adapter->hw.hw_addr + R);                      \
571		writel((register_test_patterns[pat] & W),                     \
572		       (adapter->hw.hw_addr + R));                            \
573		val = readl(adapter->hw.hw_addr + R);                         \
574		if (val != (register_test_patterns[pat] & W & M)) {           \
575			hw_dbg(&adapter->hw,                                  \
576			"pattern test reg %04X failed: got "                  \
577			"0x%08X expected 0x%08X\n",                           \
578			R, val, (register_test_patterns[pat] & W & M));       \
579			*data = R;                                            \
580			writel(before, adapter->hw.hw_addr + R);              \
581			return 1;                                             \
582		}                                                             \
583		writel(before, adapter->hw.hw_addr + R);                      \
584	}                                                                     \
585}
586
587#define REG_SET_AND_CHECK(R, M, W)                                            \
588{                                                                             \
589	u32 val, before;                                                      \
590	before = readl(adapter->hw.hw_addr + R);                              \
591	writel((W & M), (adapter->hw.hw_addr + R));                           \
592	val = readl(adapter->hw.hw_addr + R);                                 \
593	if ((W & M) != (val & M)) {                                           \
594		printk(KERN_ERR "set/check reg %04X test failed: got 0x%08X " \
595				 "expected 0x%08X\n", R, (val & M), (W & M)); \
596		*data = R;                                                    \
597		writel(before, (adapter->hw.hw_addr + R));                    \
598		return 1;                                                     \
599	}                                                                     \
600	writel(before, (adapter->hw.hw_addr + R));                            \
601}
602
603static int ixgbevf_reg_test(struct ixgbevf_adapter *adapter, u64 *data)
604{
605	const struct ixgbevf_reg_test *test;
606	u32 i;
607
608	test = reg_test_vf;
609
610	/*
611	 * Perform the register test, looping through the test table
612	 * until we either fail or reach the null entry.
613	 */
614	while (test->reg) {
615		for (i = 0; i < test->array_len; i++) {
616			switch (test->test_type) {
617			case PATTERN_TEST:
618				REG_PATTERN_TEST(test->reg + (i * 0x40),
619						test->mask,
620						test->write);
621				break;
622			case SET_READ_TEST:
623				REG_SET_AND_CHECK(test->reg + (i * 0x40),
624						test->mask,
625						test->write);
626				break;
627			case WRITE_NO_TEST:
628				writel(test->write,
629				       (adapter->hw.hw_addr + test->reg)
630				       + (i * 0x40));
631				break;
632			case TABLE32_TEST:
633				REG_PATTERN_TEST(test->reg + (i * 4),
634						test->mask,
635						test->write);
636				break;
637			case TABLE64_TEST_LO:
638				REG_PATTERN_TEST(test->reg + (i * 8),
639						test->mask,
640						test->write);
641				break;
642			case TABLE64_TEST_HI:
643				REG_PATTERN_TEST((test->reg + 4) + (i * 8),
644						test->mask,
645						test->write);
646				break;
647			}
648		}
649		test++;
650	}
651
652	*data = 0;
653	return *data;
654}
655
656static void ixgbevf_diag_test(struct net_device *netdev,
657			      struct ethtool_test *eth_test, u64 *data)
658{
659	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
660	bool if_running = netif_running(netdev);
661
662	set_bit(__IXGBEVF_TESTING, &adapter->state);
663	if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
664		/* Offline tests */
665
666		hw_dbg(&adapter->hw, "offline testing starting\n");
667
668		/* Link test performed before hardware reset so autoneg doesn't
669		 * interfere with test result */
670		if (ixgbevf_link_test(adapter, &data[1]))
671			eth_test->flags |= ETH_TEST_FL_FAILED;
672
673		if (if_running)
674			/* indicate we're in test mode */
675			dev_close(netdev);
676		else
677			ixgbevf_reset(adapter);
678
679		hw_dbg(&adapter->hw, "register testing starting\n");
680		if (ixgbevf_reg_test(adapter, &data[0]))
681			eth_test->flags |= ETH_TEST_FL_FAILED;
682
683		ixgbevf_reset(adapter);
684
685		clear_bit(__IXGBEVF_TESTING, &adapter->state);
686		if (if_running)
687			dev_open(netdev);
688	} else {
689		hw_dbg(&adapter->hw, "online testing starting\n");
690		/* Online tests */
691		if (ixgbevf_link_test(adapter, &data[1]))
692			eth_test->flags |= ETH_TEST_FL_FAILED;
693
694		/* Online tests aren't run; pass by default */
695		data[0] = 0;
696
697		clear_bit(__IXGBEVF_TESTING, &adapter->state);
698	}
699	msleep_interruptible(4 * 1000);
700}
701
702static int ixgbevf_nway_reset(struct net_device *netdev)
703{
704	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
705
706	if (netif_running(netdev)) {
707		if (!adapter->dev_closed)
708			ixgbevf_reinit_locked(adapter);
709	}
710
711	return 0;
712}
713
714static struct ethtool_ops ixgbevf_ethtool_ops = {
715	.get_settings           = ixgbevf_get_settings,
716	.get_drvinfo            = ixgbevf_get_drvinfo,
717	.get_regs_len           = ixgbevf_get_regs_len,
718	.get_regs               = ixgbevf_get_regs,
719	.nway_reset             = ixgbevf_nway_reset,
720	.get_link               = ethtool_op_get_link,
721	.get_ringparam          = ixgbevf_get_ringparam,
722	.set_ringparam          = ixgbevf_set_ringparam,
723	.get_rx_csum            = ixgbevf_get_rx_csum,
724	.set_rx_csum            = ixgbevf_set_rx_csum,
725	.get_tx_csum            = ethtool_op_get_tx_csum,
726	.set_tx_csum            = ethtool_op_set_tx_ipv6_csum,
727	.get_sg                 = ethtool_op_get_sg,
728	.set_sg                 = ethtool_op_set_sg,
729	.get_msglevel           = ixgbevf_get_msglevel,
730	.set_msglevel           = ixgbevf_set_msglevel,
731	.get_tso                = ethtool_op_get_tso,
732	.set_tso                = ixgbevf_set_tso,
733	.self_test              = ixgbevf_diag_test,
734	.get_sset_count         = ixgbevf_get_sset_count,
735	.get_strings            = ixgbevf_get_strings,
736	.get_ethtool_stats      = ixgbevf_get_ethtool_stats,
737};
738
739void ixgbevf_set_ethtool_ops(struct net_device *netdev)
740{
741	SET_ETHTOOL_OPS(netdev, &ixgbevf_ethtool_ops);
742}