[mirror_ubuntu-artful-kernel.git] / drivers / net / ethernet / intel / igbvf / ethtool.c

/*******************************************************************************

  Intel(R) 82576 Virtual Function Linux driver
  Copyright(c) 2009 - 2012 Intel Corporation.

  This program is free software; you can redistribute it and/or modify it
  under the terms and conditions of the GNU General Public License,
  version 2, as published by the Free Software Foundation.

  This program is distributed in the hope it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  more details.

  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

  The full GNU General Public License is included in this distribution in
  the file called "COPYING".

  Contact Information:
  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

*******************************************************************************/

/* ethtool support for igbvf */

#include <linux/netdevice.h>
#include <linux/ethtool.h>
#include <linux/pci.h>
#include <linux/vmalloc.h>
#include <linux/delay.h>

#include "igbvf.h"
#include <linux/if_vlan.h>


struct igbvf_stats {
	char stat_string[ETH_GSTRING_LEN];
	int sizeof_stat;
	int stat_offset;
	int base_stat_offset;
};

#define IGBVF_STAT(current, base) \
		sizeof(((struct igbvf_adapter *)0)->current), \
		offsetof(struct igbvf_adapter, current), \
		offsetof(struct igbvf_adapter, base)

static const struct igbvf_stats igbvf_gstrings_stats[] = {
	{ "rx_packets", IGBVF_STAT(stats.gprc, stats.base_gprc) },
	{ "tx_packets", IGBVF_STAT(stats.gptc, stats.base_gptc) },
	{ "rx_bytes", IGBVF_STAT(stats.gorc, stats.base_gorc) },
	{ "tx_bytes", IGBVF_STAT(stats.gotc, stats.base_gotc) },
	{ "multicast", IGBVF_STAT(stats.mprc, stats.base_mprc) },
	{ "lbrx_bytes", IGBVF_STAT(stats.gorlbc, stats.base_gorlbc) },
	{ "lbrx_packets", IGBVF_STAT(stats.gprlbc, stats.base_gprlbc) },
	{ "tx_restart_queue", IGBVF_STAT(restart_queue, zero_base) },
	{ "rx_long_byte_count", IGBVF_STAT(stats.gorc, stats.base_gorc) },
	{ "rx_csum_offload_good", IGBVF_STAT(hw_csum_good, zero_base) },
	{ "rx_csum_offload_errors", IGBVF_STAT(hw_csum_err, zero_base) },
	{ "rx_header_split", IGBVF_STAT(rx_hdr_split, zero_base) },
	{ "alloc_rx_buff_failed", IGBVF_STAT(alloc_rx_buff_failed, zero_base) },
};

#define IGBVF_GLOBAL_STATS_LEN ARRAY_SIZE(igbvf_gstrings_stats)

static const char igbvf_gstrings_test[][ETH_GSTRING_LEN] = {
	"Link test   (on/offline)"
};

#define IGBVF_TEST_LEN ARRAY_SIZE(igbvf_gstrings_test)

static int igbvf_get_settings(struct net_device *netdev,
                              struct ethtool_cmd *ecmd)
{
	struct igbvf_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
	u32 status;

	ecmd->supported   = SUPPORTED_1000baseT_Full;

	ecmd->advertising = ADVERTISED_1000baseT_Full;

	ecmd->port = -1;
	ecmd->transceiver = XCVR_DUMMY1;

	status = er32(STATUS);
	if (status & E1000_STATUS_LU) {
		if (status & E1000_STATUS_SPEED_1000)
			ethtool_cmd_speed_set(ecmd, SPEED_1000);
		else if (status & E1000_STATUS_SPEED_100)
			ethtool_cmd_speed_set(ecmd, SPEED_100);
		else
			ethtool_cmd_speed_set(ecmd, SPEED_10);

		if (status & E1000_STATUS_FD)
			ecmd->duplex = DUPLEX_FULL;
		else
			ecmd->duplex = DUPLEX_HALF;
	} else {
		ethtool_cmd_speed_set(ecmd, -1);
		ecmd->duplex = -1;
	}

	ecmd->autoneg = AUTONEG_DISABLE;

	return 0;
}

static int igbvf_set_settings(struct net_device *netdev,
                              struct ethtool_cmd *ecmd)
{
	return -EOPNOTSUPP;
}

static void igbvf_get_pauseparam(struct net_device *netdev,
                                 struct ethtool_pauseparam *pause)
{
	return;
}

static int igbvf_set_pauseparam(struct net_device *netdev,
                                struct ethtool_pauseparam *pause)
{
	return -EOPNOTSUPP;
}

static u32 igbvf_get_msglevel(struct net_device *netdev)
{
	struct igbvf_adapter *adapter = netdev_priv(netdev);
	return adapter->msg_enable;
}

static void igbvf_set_msglevel(struct net_device *netdev, u32 data)
{
	struct igbvf_adapter *adapter = netdev_priv(netdev);
	adapter->msg_enable = data;
}

static int igbvf_get_regs_len(struct net_device *netdev)
{
#define IGBVF_REGS_LEN 8
	return IGBVF_REGS_LEN * sizeof(u32);
}

static void igbvf_get_regs(struct net_device *netdev,
                           struct ethtool_regs *regs, void *p)
{
	struct igbvf_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
	u32 *regs_buff = p;

	memset(p, 0, IGBVF_REGS_LEN * sizeof(u32));

	regs->version = (1 << 24) | (adapter->pdev->revision << 16) |
			adapter->pdev->device;

	regs_buff[0] = er32(CTRL);
	regs_buff[1] = er32(STATUS);

	regs_buff[2] = er32(RDLEN(0));
	regs_buff[3] = er32(RDH(0));
	regs_buff[4] = er32(RDT(0));

	regs_buff[5] = er32(TDLEN(0));
	regs_buff[6] = er32(TDH(0));
	regs_buff[7] = er32(TDT(0));
}

static int igbvf_get_eeprom_len(struct net_device *netdev)
{
	return 0;
}

static int igbvf_get_eeprom(struct net_device *netdev,
                            struct ethtool_eeprom *eeprom, u8 *bytes)
{
	return -EOPNOTSUPP;
}

static int igbvf_set_eeprom(struct net_device *netdev,
                            struct ethtool_eeprom *eeprom, u8 *bytes)
{
	return -EOPNOTSUPP;
}

static void igbvf_get_drvinfo(struct net_device *netdev,
                              struct ethtool_drvinfo *drvinfo)
{
	struct igbvf_adapter *adapter = netdev_priv(netdev);

	strlcpy(drvinfo->driver,  igbvf_driver_name, sizeof(drvinfo->driver));
	strlcpy(drvinfo->version, igbvf_driver_version,
		sizeof(drvinfo->version));
	strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
		sizeof(drvinfo->bus_info));
	drvinfo->regdump_len = igbvf_get_regs_len(netdev);
	drvinfo->eedump_len = igbvf_get_eeprom_len(netdev);
}

static void igbvf_get_ringparam(struct net_device *netdev,
                                struct ethtool_ringparam *ring)
{
	struct igbvf_adapter *adapter = netdev_priv(netdev);
	struct igbvf_ring *tx_ring = adapter->tx_ring;
	struct igbvf_ring *rx_ring = adapter->rx_ring;

	ring->rx_max_pending = IGBVF_MAX_RXD;
	ring->tx_max_pending = IGBVF_MAX_TXD;
	ring->rx_pending = rx_ring->count;
	ring->tx_pending = tx_ring->count;
}

static int igbvf_set_ringparam(struct net_device *netdev,
                               struct ethtool_ringparam *ring)
{
	struct igbvf_adapter *adapter = netdev_priv(netdev);
	struct igbvf_ring *temp_ring;
	int err = 0;
	u32 new_rx_count, new_tx_count;

	if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
		return -EINVAL;

	new_rx_count = max(ring->rx_pending, (u32)IGBVF_MIN_RXD);
	new_rx_count = min(new_rx_count, (u32)IGBVF_MAX_RXD);
	new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE);

	new_tx_count = max(ring->tx_pending, (u32)IGBVF_MIN_TXD);
	new_tx_count = min(new_tx_count, (u32)IGBVF_MAX_TXD);
	new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE);

	if ((new_tx_count == adapter->tx_ring->count) &&
	    (new_rx_count == adapter->rx_ring->count)) {
		/* nothing to do */
		return 0;
	}

	while (test_and_set_bit(__IGBVF_RESETTING, &adapter->state))
		msleep(1);

	if (!netif_running(adapter->netdev)) {
		adapter->tx_ring->count = new_tx_count;
		adapter->rx_ring->count = new_rx_count;
		goto clear_reset;
	}

	temp_ring = vmalloc(sizeof(struct igbvf_ring));
	if (!temp_ring) {
		err = -ENOMEM;
		goto clear_reset;
	}

	igbvf_down(adapter);

	/*
	 * We can't just free everything and then setup again,
	 * because the ISRs in MSI-X mode get passed pointers
	 * to the tx and rx ring structs.
	 */
	if (new_tx_count != adapter->tx_ring->count) {
		memcpy(temp_ring, adapter->tx_ring, sizeof(struct igbvf_ring));

		temp_ring->count = new_tx_count;
		err = igbvf_setup_tx_resources(adapter, temp_ring);
		if (err)
			goto err_setup;

		igbvf_free_tx_resources(adapter->tx_ring);

		memcpy(adapter->tx_ring, temp_ring, sizeof(struct igbvf_ring));
	}

	if (new_rx_count != adapter->rx_ring->count) {
		memcpy(temp_ring, adapter->rx_ring, sizeof(struct igbvf_ring));

		temp_ring->count = new_rx_count;
		err = igbvf_setup_rx_resources(adapter, temp_ring);
		if (err)
			goto err_setup;

		igbvf_free_rx_resources(adapter->rx_ring);

		memcpy(adapter->rx_ring, temp_ring,sizeof(struct igbvf_ring));
	}
err_setup:
	igbvf_up(adapter);
	vfree(temp_ring);
clear_reset:
	clear_bit(__IGBVF_RESETTING, &adapter->state);
	return err;
}

static int igbvf_link_test(struct igbvf_adapter *adapter, u64 *data)
{
	struct e1000_hw *hw = &adapter->hw;
	*data = 0;

	hw->mac.ops.check_for_link(hw);

	if (!(er32(STATUS) & E1000_STATUS_LU))
		*data = 1;

	return *data;
}

static void igbvf_diag_test(struct net_device *netdev,
                            struct ethtool_test *eth_test, u64 *data)
{
	struct igbvf_adapter *adapter = netdev_priv(netdev);

	set_bit(__IGBVF_TESTING, &adapter->state);

	/*
	 * Link test performed before hardware reset so autoneg doesn't
	 * interfere with test result
	 */
	if (igbvf_link_test(adapter, &data[0]))
		eth_test->flags |= ETH_TEST_FL_FAILED;

	clear_bit(__IGBVF_TESTING, &adapter->state);
	msleep_interruptible(4 * 1000);
}

static void igbvf_get_wol(struct net_device *netdev,
                          struct ethtool_wolinfo *wol)
{
	wol->supported = 0;
	wol->wolopts = 0;
}

static int igbvf_set_wol(struct net_device *netdev,
                         struct ethtool_wolinfo *wol)
{
	return -EOPNOTSUPP;
}

static int igbvf_get_coalesce(struct net_device *netdev,
                              struct ethtool_coalesce *ec)
{
	struct igbvf_adapter *adapter = netdev_priv(netdev);

	if (adapter->itr_setting <= 3)
		ec->rx_coalesce_usecs = adapter->itr_setting;
	else
		ec->rx_coalesce_usecs = adapter->itr_setting >> 2;

	return 0;
}

static int igbvf_set_coalesce(struct net_device *netdev,
                              struct ethtool_coalesce *ec)
{
	struct igbvf_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;

	if ((ec->rx_coalesce_usecs > IGBVF_MAX_ITR_USECS) ||
	    ((ec->rx_coalesce_usecs > 3) &&
	     (ec->rx_coalesce_usecs < IGBVF_MIN_ITR_USECS)) ||
	    (ec->rx_coalesce_usecs == 2))
		return -EINVAL;

	/* convert to rate of irq's per second */
	if (ec->rx_coalesce_usecs && ec->rx_coalesce_usecs <= 3) {
		adapter->itr = IGBVF_START_ITR;
		adapter->itr_setting = ec->rx_coalesce_usecs;
	} else {
		adapter->itr = ec->rx_coalesce_usecs << 2;
		adapter->itr_setting = adapter->itr;
	}

	writel(adapter->itr,
	       hw->hw_addr + adapter->rx_ring[0].itr_register);

	return 0;
}

static int igbvf_nway_reset(struct net_device *netdev)
{
	struct igbvf_adapter *adapter = netdev_priv(netdev);
	if (netif_running(netdev))
		igbvf_reinit_locked(adapter);
	return 0;
}


static void igbvf_get_ethtool_stats(struct net_device *netdev,
                                    struct ethtool_stats *stats,
                                    u64 *data)
{
	struct igbvf_adapter *adapter = netdev_priv(netdev);
	int i;

	igbvf_update_stats(adapter);
	for (i = 0; i < IGBVF_GLOBAL_STATS_LEN; i++) {
		char *p = (char *)adapter +
		          igbvf_gstrings_stats[i].stat_offset;
		char *b = (char *)adapter +
		          igbvf_gstrings_stats[i].base_stat_offset;
		data[i] = ((igbvf_gstrings_stats[i].sizeof_stat ==
		            sizeof(u64)) ? (*(u64 *)p - *(u64 *)b) :
		            (*(u32 *)p - *(u32 *)b));
	}

}

static int igbvf_get_sset_count(struct net_device *dev, int stringset)
{
	switch(stringset) {
	case ETH_SS_TEST:
		return IGBVF_TEST_LEN;
	case ETH_SS_STATS:
		return IGBVF_GLOBAL_STATS_LEN;
	default:
		return -EINVAL;
	}
}

static void igbvf_get_strings(struct net_device *netdev, u32 stringset,
                              u8 *data)
{
	u8 *p = data;
	int i;

	switch (stringset) {
	case ETH_SS_TEST:
		memcpy(data, *igbvf_gstrings_test, sizeof(igbvf_gstrings_test));
		break;
	case ETH_SS_STATS:
		for (i = 0; i < IGBVF_GLOBAL_STATS_LEN; i++) {
			memcpy(p, igbvf_gstrings_stats[i].stat_string,
			       ETH_GSTRING_LEN);
			p += ETH_GSTRING_LEN;
		}
		break;
	}
}

static const struct ethtool_ops igbvf_ethtool_ops = {
	.get_settings		= igbvf_get_settings,
	.set_settings		= igbvf_set_settings,
	.get_drvinfo		= igbvf_get_drvinfo,
	.get_regs_len		= igbvf_get_regs_len,
	.get_regs		= igbvf_get_regs,
	.get_wol		= igbvf_get_wol,
	.set_wol		= igbvf_set_wol,
	.get_msglevel		= igbvf_get_msglevel,
	.set_msglevel		= igbvf_set_msglevel,
	.nway_reset		= igbvf_nway_reset,
	.get_link		= ethtool_op_get_link,
	.get_eeprom_len		= igbvf_get_eeprom_len,
	.get_eeprom		= igbvf_get_eeprom,
	.set_eeprom		= igbvf_set_eeprom,
	.get_ringparam		= igbvf_get_ringparam,
	.set_ringparam		= igbvf_set_ringparam,
	.get_pauseparam		= igbvf_get_pauseparam,
	.set_pauseparam		= igbvf_set_pauseparam,
	.self_test		= igbvf_diag_test,
	.get_sset_count		= igbvf_get_sset_count,
	.get_strings		= igbvf_get_strings,
	.get_ethtool_stats	= igbvf_get_ethtool_stats,
	.get_coalesce		= igbvf_get_coalesce,
	.set_coalesce		= igbvf_set_coalesce,
};

void igbvf_set_ethtool_ops(struct net_device *netdev)
{
	SET_ETHTOOL_OPS(netdev, &igbvf_ethtool_ops);
}
Commit	Line	Data
d4e0fe01 AD	1	/*******************************************************************************
	2
	3	Intel(R) 82576 Virtual Function Linux driver
2a06ed92	4	Copyright(c) 2009 - 2012 Intel Corporation.
d4e0fe01 AD	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 igbvf */
	29
	30	#include <linux/netdevice.h>
	31	#include <linux/ethtool.h>
	32	#include <linux/pci.h>
	33	#include <linux/vmalloc.h>
	34	#include <linux/delay.h>
	35
	36	#include "igbvf.h"
	37	#include <linux/if_vlan.h>
	38
	39
	40	struct igbvf_stats {
	41	char stat_string[ETH_GSTRING_LEN];
	42	int sizeof_stat;
	43	int stat_offset;
	44	int base_stat_offset;
	45	};
	46
	47	#define IGBVF_STAT(current, base) \
	48	sizeof(((struct igbvf_adapter *)0)->current), \
	49	offsetof(struct igbvf_adapter, current), \
	50	offsetof(struct igbvf_adapter, base)
	51
	52	static const struct igbvf_stats igbvf_gstrings_stats[] = {
	53	{ "rx_packets", IGBVF_STAT(stats.gprc, stats.base_gprc) },
	54	{ "tx_packets", IGBVF_STAT(stats.gptc, stats.base_gptc) },
	55	{ "rx_bytes", IGBVF_STAT(stats.gorc, stats.base_gorc) },
	56	{ "tx_bytes", IGBVF_STAT(stats.gotc, stats.base_gotc) },
	57	{ "multicast", IGBVF_STAT(stats.mprc, stats.base_mprc) },
	58	{ "lbrx_bytes", IGBVF_STAT(stats.gorlbc, stats.base_gorlbc) },
	59	{ "lbrx_packets", IGBVF_STAT(stats.gprlbc, stats.base_gprlbc) },
	60	{ "tx_restart_queue", IGBVF_STAT(restart_queue, zero_base) },
	61	{ "rx_long_byte_count", IGBVF_STAT(stats.gorc, stats.base_gorc) },
	62	{ "rx_csum_offload_good", IGBVF_STAT(hw_csum_good, zero_base) },
	63	{ "rx_csum_offload_errors", IGBVF_STAT(hw_csum_err, zero_base) },
	64	{ "rx_header_split", IGBVF_STAT(rx_hdr_split, zero_base) },
	65	{ "alloc_rx_buff_failed", IGBVF_STAT(alloc_rx_buff_failed, zero_base) },
	66	};
	67
	68	#define IGBVF_GLOBAL_STATS_LEN ARRAY_SIZE(igbvf_gstrings_stats)
69
70	static const char igbvf_gstrings_test[][ETH_GSTRING_LEN] = {
71	"Link test (on/offline)"
72	};
73
74	#define IGBVF_TEST_LEN ARRAY_SIZE(igbvf_gstrings_test)
75
76	static int igbvf_get_settings(struct net_device *netdev,
77	struct ethtool_cmd *ecmd)
78	{
79	struct igbvf_adapter *adapter = netdev_priv(netdev);
80	struct e1000_hw *hw = &adapter->hw;
81	u32 status;
82
83	ecmd->supported = SUPPORTED_1000baseT_Full;
84
85	ecmd->advertising = ADVERTISED_1000baseT_Full;
86
87	ecmd->port = -1;
88	ecmd->transceiver = XCVR_DUMMY1;
89
90	status = er32(STATUS);
91	if (status & E1000_STATUS_LU) {
92	if (status & E1000_STATUS_SPEED_1000)
70739497	93	ethtool_cmd_speed_set(ecmd, SPEED_1000);
d4e0fe01	94	else if (status & E1000_STATUS_SPEED_100)
70739497	95	ethtool_cmd_speed_set(ecmd, SPEED_100);
d4e0fe01	96	else
70739497	97	ethtool_cmd_speed_set(ecmd, SPEED_10);
d4e0fe01 AD	98
	99	if (status & E1000_STATUS_FD)
	100	ecmd->duplex = DUPLEX_FULL;
	101	else
	102	ecmd->duplex = DUPLEX_HALF;
	103	} else {
70739497	104	ethtool_cmd_speed_set(ecmd, -1);
d4e0fe01 AD	105	ecmd->duplex = -1;
	106	}
	107
	108	ecmd->autoneg = AUTONEG_DISABLE;
	109
	110	return 0;
	111	}
	112
d4e0fe01 AD	113	static int igbvf_set_settings(struct net_device *netdev,
	114	struct ethtool_cmd *ecmd)
	115	{
	116	return -EOPNOTSUPP;
	117	}
	118
	119	static void igbvf_get_pauseparam(struct net_device *netdev,
	120	struct ethtool_pauseparam *pause)
	121	{
	122	return;
	123	}
	124
	125	static int igbvf_set_pauseparam(struct net_device *netdev,
	126	struct ethtool_pauseparam *pause)
	127	{
	128	return -EOPNOTSUPP;
	129	}
	130
d4e0fe01 AD	131	static u32 igbvf_get_msglevel(struct net_device *netdev)
	132	{
	133	struct igbvf_adapter *adapter = netdev_priv(netdev);
	134	return adapter->msg_enable;
	135	}
	136
	137	static void igbvf_set_msglevel(struct net_device *netdev, u32 data)
	138	{
	139	struct igbvf_adapter *adapter = netdev_priv(netdev);
	140	adapter->msg_enable = data;
	141	}
	142
	143	static int igbvf_get_regs_len(struct net_device *netdev)
	144	{
	145	#define IGBVF_REGS_LEN 8
	146	return IGBVF_REGS_LEN * sizeof(u32);
	147	}
	148
	149	static void igbvf_get_regs(struct net_device *netdev,
	150	struct ethtool_regs regs, void p)
	151	{
	152	struct igbvf_adapter *adapter = netdev_priv(netdev);
	153	struct e1000_hw *hw = &adapter->hw;
	154	u32 *regs_buff = p;
d4e0fe01 AD	155
	156	memset(p, 0, IGBVF_REGS_LEN * sizeof(u32));
	157
ff938e43 SS	158	regs->version = (1 << 24) \| (adapter->pdev->revision << 16) \|
ff938e43 SS	159	adapter->pdev->device;
d4e0fe01 AD	160
	161	regs_buff[0] = er32(CTRL);
	162	regs_buff[1] = er32(STATUS);
	163
	164	regs_buff[2] = er32(RDLEN(0));
	165	regs_buff[3] = er32(RDH(0));
	166	regs_buff[4] = er32(RDT(0));
	167
	168	regs_buff[5] = er32(TDLEN(0));
	169	regs_buff[6] = er32(TDH(0));
	170	regs_buff[7] = er32(TDT(0));
	171	}
	172
	173	static int igbvf_get_eeprom_len(struct net_device *netdev)
	174	{
	175	return 0;
	176	}
	177
	178	static int igbvf_get_eeprom(struct net_device *netdev,
	179	struct ethtool_eeprom eeprom, u8 bytes)
	180	{
	181	return -EOPNOTSUPP;
	182	}
	183
	184	static int igbvf_set_eeprom(struct net_device *netdev,
	185	struct ethtool_eeprom eeprom, u8 bytes)
	186	{
	187	return -EOPNOTSUPP;
	188	}
	189
	190	static void igbvf_get_drvinfo(struct net_device *netdev,
	191	struct ethtool_drvinfo *drvinfo)
	192	{
	193	struct igbvf_adapter *adapter = netdev_priv(netdev);
d4e0fe01	194
612a94d6 RJ	195	strlcpy(drvinfo->driver, igbvf_driver_name, sizeof(drvinfo->driver));
	196	strlcpy(drvinfo->version, igbvf_driver_version,
	197	sizeof(drvinfo->version));
612a94d6 RJ	198	strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
612a94d6 RJ	199	sizeof(drvinfo->bus_info));
d4e0fe01 AD	200	drvinfo->regdump_len = igbvf_get_regs_len(netdev);
	201	drvinfo->eedump_len = igbvf_get_eeprom_len(netdev);
	202	}
	203
	204	static void igbvf_get_ringparam(struct net_device *netdev,
	205	struct ethtool_ringparam *ring)
	206	{
	207	struct igbvf_adapter *adapter = netdev_priv(netdev);
	208	struct igbvf_ring *tx_ring = adapter->tx_ring;
	209	struct igbvf_ring *rx_ring = adapter->rx_ring;
	210
	211	ring->rx_max_pending = IGBVF_MAX_RXD;
	212	ring->tx_max_pending = IGBVF_MAX_TXD;
d4e0fe01 AD	213	ring->rx_pending = rx_ring->count;
d4e0fe01 AD	214	ring->tx_pending = tx_ring->count;
d4e0fe01 AD	215	}
	216
	217	static int igbvf_set_ringparam(struct net_device *netdev,
	218	struct ethtool_ringparam *ring)
	219	{
	220	struct igbvf_adapter *adapter = netdev_priv(netdev);
	221	struct igbvf_ring *temp_ring;
39305965	222	int err = 0;
d4e0fe01 AD	223	u32 new_rx_count, new_tx_count;
	224
	225	if ((ring->rx_mini_pending) \|\| (ring->rx_jumbo_pending))
	226	return -EINVAL;
	227
	228	new_rx_count = max(ring->rx_pending, (u32)IGBVF_MIN_RXD);
	229	new_rx_count = min(new_rx_count, (u32)IGBVF_MAX_RXD);
	230	new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE);
	231
	232	new_tx_count = max(ring->tx_pending, (u32)IGBVF_MIN_TXD);
	233	new_tx_count = min(new_tx_count, (u32)IGBVF_MAX_TXD);
	234	new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE);
	235
	236	if ((new_tx_count == adapter->tx_ring->count) &&
	237	(new_rx_count == adapter->rx_ring->count)) {
	238	/* nothing to do */
	239	return 0;
	240	}
	241
d4e0fe01 AD	242	while (test_and_set_bit(__IGBVF_RESETTING, &adapter->state))
	243	msleep(1);
	244
39305965 AD	245	if (!netif_running(adapter->netdev)) {
	246	adapter->tx_ring->count = new_tx_count;
	247	adapter->rx_ring->count = new_rx_count;
	248	goto clear_reset;
	249	}
	250
	251	temp_ring = vmalloc(sizeof(struct igbvf_ring));
	252	if (!temp_ring) {
	253	err = -ENOMEM;
	254	goto clear_reset;
	255	}
	256
	257	igbvf_down(adapter);
d4e0fe01 AD	258
	259	/*
	260	* We can't just free everything and then setup again,
	261	* because the ISRs in MSI-X mode get passed pointers
	262	* to the tx and rx ring structs.
	263	*/
	264	if (new_tx_count != adapter->tx_ring->count) {
	265	memcpy(temp_ring, adapter->tx_ring, sizeof(struct igbvf_ring));
	266
	267	temp_ring->count = new_tx_count;
	268	err = igbvf_setup_tx_resources(adapter, temp_ring);
	269	if (err)
	270	goto err_setup;
	271
	272	igbvf_free_tx_resources(adapter->tx_ring);
	273
	274	memcpy(adapter->tx_ring, temp_ring, sizeof(struct igbvf_ring));
	275	}
	276
	277	if (new_rx_count != adapter->rx_ring->count) {
	278	memcpy(temp_ring, adapter->rx_ring, sizeof(struct igbvf_ring));
	279
	280	temp_ring->count = new_rx_count;
	281	err = igbvf_setup_rx_resources(adapter, temp_ring);
	282	if (err)
	283	goto err_setup;
	284
	285	igbvf_free_rx_resources(adapter->rx_ring);
	286
	287	memcpy(adapter->rx_ring, temp_ring,sizeof(struct igbvf_ring));
	288	}
d4e0fe01	289	err_setup:
39305965	290	igbvf_up(adapter);
d4e0fe01	291	vfree(temp_ring);
39305965 AD	292	clear_reset:
39305965 AD	293	clear_bit(__IGBVF_RESETTING, &adapter->state);
d4e0fe01 AD	294	return err;
	295	}
	296
	297	static int igbvf_link_test(struct igbvf_adapter adapter, u64 data)
	298	{
	299	struct e1000_hw *hw = &adapter->hw;
	300	*data = 0;
	301
	302	hw->mac.ops.check_for_link(hw);
	303
	304	if (!(er32(STATUS) & E1000_STATUS_LU))
	305	*data = 1;
	306
	307	return *data;
	308	}
	309
d4e0fe01 AD	310	static void igbvf_diag_test(struct net_device *netdev,
	311	struct ethtool_test eth_test, u64 data)
	312	{
	313	struct igbvf_adapter *adapter = netdev_priv(netdev);
	314
	315	set_bit(__IGBVF_TESTING, &adapter->state);
	316
	317	/*
	318	* Link test performed before hardware reset so autoneg doesn't
	319	* interfere with test result
	320	*/
	321	if (igbvf_link_test(adapter, &data[0]))
	322	eth_test->flags \|= ETH_TEST_FL_FAILED;
	323
	324	clear_bit(__IGBVF_TESTING, &adapter->state);
	325	msleep_interruptible(4 * 1000);
	326	}
	327
	328	static void igbvf_get_wol(struct net_device *netdev,
	329	struct ethtool_wolinfo *wol)
	330	{
	331	wol->supported = 0;
	332	wol->wolopts = 0;
d4e0fe01 AD	333	}
	334
	335	static int igbvf_set_wol(struct net_device *netdev,
	336	struct ethtool_wolinfo *wol)
	337	{
	338	return -EOPNOTSUPP;
	339	}
	340
d4e0fe01 AD	341	static int igbvf_get_coalesce(struct net_device *netdev,
	342	struct ethtool_coalesce *ec)
	343	{
	344	struct igbvf_adapter *adapter = netdev_priv(netdev);
	345
	346	if (adapter->itr_setting <= 3)
	347	ec->rx_coalesce_usecs = adapter->itr_setting;
	348	else
	349	ec->rx_coalesce_usecs = adapter->itr_setting >> 2;
	350
	351	return 0;
	352	}
	353
	354	static int igbvf_set_coalesce(struct net_device *netdev,
	355	struct ethtool_coalesce *ec)
	356	{
	357	struct igbvf_adapter *adapter = netdev_priv(netdev);
	358	struct e1000_hw *hw = &adapter->hw;
	359
	360	if ((ec->rx_coalesce_usecs > IGBVF_MAX_ITR_USECS) \|\|
	361	((ec->rx_coalesce_usecs > 3) &&
	362	(ec->rx_coalesce_usecs < IGBVF_MIN_ITR_USECS)) \|\|
	363	(ec->rx_coalesce_usecs == 2))
	364	return -EINVAL;
	365
	366	/* convert to rate of irq's per second */
	367	if (ec->rx_coalesce_usecs && ec->rx_coalesce_usecs <= 3) {
	368	adapter->itr = IGBVF_START_ITR;
	369	adapter->itr_setting = ec->rx_coalesce_usecs;
	370	} else {
	371	adapter->itr = ec->rx_coalesce_usecs << 2;
	372	adapter->itr_setting = adapter->itr;
	373	}
	374
	375	writel(adapter->itr,
	376	hw->hw_addr + adapter->rx_ring[0].itr_register);
	377
	378	return 0;
	379	}
	380
	381	static int igbvf_nway_reset(struct net_device *netdev)
	382	{
	383	struct igbvf_adapter *adapter = netdev_priv(netdev);
	384	if (netif_running(netdev))
	385	igbvf_reinit_locked(adapter);
	386	return 0;
	387	}
	388
	389
	390	static void igbvf_get_ethtool_stats(struct net_device *netdev,
	391	struct ethtool_stats *stats,
	392	u64 *data)
	393	{
	394	struct igbvf_adapter *adapter = netdev_priv(netdev);
	395	int i;
	396
	397	igbvf_update_stats(adapter);
	398	for (i = 0; i < IGBVF_GLOBAL_STATS_LEN; i++) {
	399	char p = (char )adapter +
	400	igbvf_gstrings_stats[i].stat_offset;
	401	char b = (char )adapter +
	402	igbvf_gstrings_stats[i].base_stat_offset;
	403	data[i] = ((igbvf_gstrings_stats[i].sizeof_stat ==
	404	sizeof(u64)) ? ((u64 )p - (u64 )b) :
405	((u32 )p - (u32 )b));
406	}
407
408	}
409
15f0a394 BH	410	static int igbvf_get_sset_count(struct net_device *dev, int stringset)
	411	{
	412	switch(stringset) {
	413	case ETH_SS_TEST:
	414	return IGBVF_TEST_LEN;
	415	case ETH_SS_STATS:
	416	return IGBVF_GLOBAL_STATS_LEN;
	417	default:
	418	return -EINVAL;
	419	}
	420	}
	421
d4e0fe01 AD	422	static void igbvf_get_strings(struct net_device *netdev, u32 stringset,
	423	u8 *data)
	424	{
	425	u8 *p = data;
	426	int i;
	427
	428	switch (stringset) {
	429	case ETH_SS_TEST:
	430	memcpy(data, *igbvf_gstrings_test, sizeof(igbvf_gstrings_test));
	431	break;
	432	case ETH_SS_STATS:
	433	for (i = 0; i < IGBVF_GLOBAL_STATS_LEN; i++) {
	434	memcpy(p, igbvf_gstrings_stats[i].stat_string,
	435	ETH_GSTRING_LEN);
	436	p += ETH_GSTRING_LEN;
	437	}
	438	break;
	439	}
	440	}
	441
	442	static const struct ethtool_ops igbvf_ethtool_ops = {
	443	.get_settings = igbvf_get_settings,
	444	.set_settings = igbvf_set_settings,
	445	.get_drvinfo = igbvf_get_drvinfo,
	446	.get_regs_len = igbvf_get_regs_len,
	447	.get_regs = igbvf_get_regs,
	448	.get_wol = igbvf_get_wol,
	449	.set_wol = igbvf_set_wol,
	450	.get_msglevel = igbvf_get_msglevel,
	451	.set_msglevel = igbvf_set_msglevel,
	452	.nway_reset = igbvf_nway_reset,
ed4ba4b5	453	.get_link = ethtool_op_get_link,
d4e0fe01 AD	454	.get_eeprom_len = igbvf_get_eeprom_len,
	455	.get_eeprom = igbvf_get_eeprom,
	456	.set_eeprom = igbvf_set_eeprom,
	457	.get_ringparam = igbvf_get_ringparam,
	458	.set_ringparam = igbvf_set_ringparam,
	459	.get_pauseparam = igbvf_get_pauseparam,
	460	.set_pauseparam = igbvf_set_pauseparam,
d4e0fe01	461	.self_test = igbvf_diag_test,
15f0a394	462	.get_sset_count = igbvf_get_sset_count,
d4e0fe01	463	.get_strings = igbvf_get_strings,
d4e0fe01	464	.get_ethtool_stats = igbvf_get_ethtool_stats,
d4e0fe01 AD	465	.get_coalesce = igbvf_get_coalesce,
	466	.set_coalesce = igbvf_set_coalesce,
	467	};
	468
	469	void igbvf_set_ethtool_ops(struct net_device *netdev)
	470	{
b2f0f6bb	471	SET_ETHTOOL_OPS(netdev, &igbvf_ethtool_ops);
d4e0fe01	472	}