[linux.git] / drivers / net / igbvf / ethtool.c

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

  Intel(R) 82576 Virtual Function Linux driver
  Copyright(c) 2009 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 <[email protected]>
  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)
			ecmd->speed = 1000;
		else if (status & E1000_STATUS_SPEED_100)
			ecmd->speed = 100;
		else
			ecmd->speed = 10;

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

	ecmd->autoneg = AUTONEG_DISABLE;

	return 0;
}

static u32 igbvf_get_link(struct net_device *netdev)
{
	return netif_carrier_ok(netdev);
}

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_rx_csum(struct net_device *netdev)
{
	struct igbvf_adapter *adapter = netdev_priv(netdev);
	return !(adapter->flags & IGBVF_FLAG_RX_CSUM_DISABLED);
}

static int igbvf_set_rx_csum(struct net_device *netdev, u32 data)
{
	struct igbvf_adapter *adapter = netdev_priv(netdev);

	if (data)
		adapter->flags &= ~IGBVF_FLAG_RX_CSUM_DISABLED;
	else
		adapter->flags |= IGBVF_FLAG_RX_CSUM_DISABLED;

	return 0;
}

static u32 igbvf_get_tx_csum(struct net_device *netdev)
{
	return ((netdev->features & NETIF_F_IP_CSUM) != 0);
}

static int igbvf_set_tx_csum(struct net_device *netdev, u32 data)
{
	if (data)
		netdev->features |= (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
	else
		netdev->features &= ~(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
	return 0;
}

static int igbvf_set_tso(struct net_device *netdev, u32 data)
{
	struct igbvf_adapter *adapter = netdev_priv(netdev);

	if (data) {
		netdev->features |= NETIF_F_TSO;
		netdev->features |= NETIF_F_TSO6;
	} else {
		netdev->features &= ~NETIF_F_TSO;
		netdev->features &= ~NETIF_F_TSO6;
	}

	dev_info(&adapter->pdev->dev, "TSO is %s\n",
	         data ? "Enabled" : "Disabled");
	return 0;
}

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;
	u8 revision_id;

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

	pci_read_config_byte(adapter->pdev, PCI_REVISION_ID, &revision_id);

	regs->version = (1 << 24) | (revision_id << 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);
	char firmware_version[32] = "N/A";

	strncpy(drvinfo->driver,  igbvf_driver_name, 32);
	strncpy(drvinfo->version, igbvf_driver_version, 32);
	strncpy(drvinfo->fw_version, firmware_version, 32);
	strncpy(drvinfo->bus_info, pci_name(adapter->pdev), 32);
	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_mini_max_pending = 0;
	ring->rx_jumbo_max_pending = 0;
	ring->rx_pending = rx_ring->count;
	ring->tx_pending = tx_ring->count;
	ring->rx_mini_pending = 0;
	ring->rx_jumbo_pending = 0;
}

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;

	return;
}

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

static int igbvf_phys_id(struct net_device *netdev, u32 data)
{
	return 0;
}

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		= igbvf_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,
	.get_rx_csum            = igbvf_get_rx_csum,
	.set_rx_csum            = igbvf_set_rx_csum,
	.get_tx_csum		= igbvf_get_tx_csum,
	.set_tx_csum		= igbvf_set_tx_csum,
	.get_sg			= ethtool_op_get_sg,
	.set_sg			= ethtool_op_set_sg,
	.get_tso		= ethtool_op_get_tso,
	.set_tso		= igbvf_set_tso,
	.self_test		= igbvf_diag_test,
	.get_sset_count		= igbvf_get_sset_count,
	.get_strings		= igbvf_get_strings,
	.phys_id		= igbvf_phys_id,
	.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)
{
	/* have to "undeclare" const on this struct to remove warnings */
	SET_ETHTOOL_OPS(netdev, (struct ethtool_ops *)&igbvf_ethtool_ops);
}
Commit	Line	Data
d4e0fe01 AD	1	/*******************************************************************************
	2
	3	Intel(R) 82576 Virtual Function Linux driver
	4	Copyright(c) 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 <[email protected]>
	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)
93	ecmd->speed = 1000;
94	else if (status & E1000_STATUS_SPEED_100)
95	ecmd->speed = 100;
96	else
97	ecmd->speed = 10;
98
99	if (status & E1000_STATUS_FD)
100	ecmd->duplex = DUPLEX_FULL;
101	else
102	ecmd->duplex = DUPLEX_HALF;
103	} else {
104	ecmd->speed = -1;
105	ecmd->duplex = -1;
106	}
107
108	ecmd->autoneg = AUTONEG_DISABLE;
109
110	return 0;
111	}
112
113	static u32 igbvf_get_link(struct net_device *netdev)
114	{
115	return netif_carrier_ok(netdev);
116	}
117
118	static int igbvf_set_settings(struct net_device *netdev,
119	struct ethtool_cmd *ecmd)
120	{
121	return -EOPNOTSUPP;
122	}
123
124	static void igbvf_get_pauseparam(struct net_device *netdev,
125	struct ethtool_pauseparam *pause)
126	{
127	return;
128	}
129
130	static int igbvf_set_pauseparam(struct net_device *netdev,
131	struct ethtool_pauseparam *pause)
132	{
133	return -EOPNOTSUPP;
134	}
135
0364d6fd AD	136	static u32 igbvf_get_rx_csum(struct net_device *netdev)
	137	{
	138	struct igbvf_adapter *adapter = netdev_priv(netdev);
	139	return !(adapter->flags & IGBVF_FLAG_RX_CSUM_DISABLED);
	140	}
	141
	142	static int igbvf_set_rx_csum(struct net_device *netdev, u32 data)
	143	{
	144	struct igbvf_adapter *adapter = netdev_priv(netdev);
	145
	146	if (data)
	147	adapter->flags &= ~IGBVF_FLAG_RX_CSUM_DISABLED;
	148	else
	149	adapter->flags \|= IGBVF_FLAG_RX_CSUM_DISABLED;
	150
	151	return 0;
	152	}
	153
d4e0fe01 AD	154	static u32 igbvf_get_tx_csum(struct net_device *netdev)
	155	{
	156	return ((netdev->features & NETIF_F_IP_CSUM) != 0);
	157	}
	158
	159	static int igbvf_set_tx_csum(struct net_device *netdev, u32 data)
	160	{
	161	if (data)
	162	netdev->features \|= (NETIF_F_IP_CSUM \| NETIF_F_IPV6_CSUM);
	163	else
	164	netdev->features &= ~(NETIF_F_IP_CSUM \| NETIF_F_IPV6_CSUM);
	165	return 0;
	166	}
	167
	168	static int igbvf_set_tso(struct net_device *netdev, u32 data)
	169	{
	170	struct igbvf_adapter *adapter = netdev_priv(netdev);
d4e0fe01 AD	171
	172	if (data) {
	173	netdev->features \|= NETIF_F_TSO;
	174	netdev->features \|= NETIF_F_TSO6;
	175	} else {
	176	netdev->features &= ~NETIF_F_TSO;
	177	netdev->features &= ~NETIF_F_TSO6;
d4e0fe01 AD	178	}
d4e0fe01 AD	179
d4e0fe01 AD	180	dev_info(&adapter->pdev->dev, "TSO is %s\n",
d4e0fe01 AD	181	data ? "Enabled" : "Disabled");
d4e0fe01 AD	182	return 0;
	183	}
	184
	185	static u32 igbvf_get_msglevel(struct net_device *netdev)
	186	{
	187	struct igbvf_adapter *adapter = netdev_priv(netdev);
	188	return adapter->msg_enable;
	189	}
	190
	191	static void igbvf_set_msglevel(struct net_device *netdev, u32 data)
	192	{
	193	struct igbvf_adapter *adapter = netdev_priv(netdev);
	194	adapter->msg_enable = data;
	195	}
	196
	197	static int igbvf_get_regs_len(struct net_device *netdev)
	198	{
	199	#define IGBVF_REGS_LEN 8
	200	return IGBVF_REGS_LEN * sizeof(u32);
	201	}
	202
	203	static void igbvf_get_regs(struct net_device *netdev,
	204	struct ethtool_regs regs, void p)
	205	{
	206	struct igbvf_adapter *adapter = netdev_priv(netdev);
	207	struct e1000_hw *hw = &adapter->hw;
	208	u32 *regs_buff = p;
	209	u8 revision_id;
	210
	211	memset(p, 0, IGBVF_REGS_LEN * sizeof(u32));
	212
	213	pci_read_config_byte(adapter->pdev, PCI_REVISION_ID, &revision_id);
	214
	215	regs->version = (1 << 24) \| (revision_id << 16) \| adapter->pdev->device;
	216
	217	regs_buff[0] = er32(CTRL);
	218	regs_buff[1] = er32(STATUS);
	219
	220	regs_buff[2] = er32(RDLEN(0));
	221	regs_buff[3] = er32(RDH(0));
	222	regs_buff[4] = er32(RDT(0));
	223
	224	regs_buff[5] = er32(TDLEN(0));
	225	regs_buff[6] = er32(TDH(0));
	226	regs_buff[7] = er32(TDT(0));
	227	}
	228
	229	static int igbvf_get_eeprom_len(struct net_device *netdev)
	230	{
	231	return 0;
	232	}
	233
	234	static int igbvf_get_eeprom(struct net_device *netdev,
	235	struct ethtool_eeprom eeprom, u8 bytes)
	236	{
	237	return -EOPNOTSUPP;
	238	}
	239
	240	static int igbvf_set_eeprom(struct net_device *netdev,
	241	struct ethtool_eeprom eeprom, u8 bytes)
	242	{
	243	return -EOPNOTSUPP;
	244	}
	245
246	static void igbvf_get_drvinfo(struct net_device *netdev,
247	struct ethtool_drvinfo *drvinfo)
248	{
249	struct igbvf_adapter *adapter = netdev_priv(netdev);
250	char firmware_version[32] = "N/A";
251
252	strncpy(drvinfo->driver, igbvf_driver_name, 32);
253	strncpy(drvinfo->version, igbvf_driver_version, 32);
254	strncpy(drvinfo->fw_version, firmware_version, 32);
255	strncpy(drvinfo->bus_info, pci_name(adapter->pdev), 32);
256	drvinfo->regdump_len = igbvf_get_regs_len(netdev);
257	drvinfo->eedump_len = igbvf_get_eeprom_len(netdev);
258	}
259
260	static void igbvf_get_ringparam(struct net_device *netdev,
261	struct ethtool_ringparam *ring)
262	{
263	struct igbvf_adapter *adapter = netdev_priv(netdev);
264	struct igbvf_ring *tx_ring = adapter->tx_ring;
265	struct igbvf_ring *rx_ring = adapter->rx_ring;
266
267	ring->rx_max_pending = IGBVF_MAX_RXD;
268	ring->tx_max_pending = IGBVF_MAX_TXD;
269	ring->rx_mini_max_pending = 0;
270	ring->rx_jumbo_max_pending = 0;
271	ring->rx_pending = rx_ring->count;
272	ring->tx_pending = tx_ring->count;
273	ring->rx_mini_pending = 0;
274	ring->rx_jumbo_pending = 0;
275	}
276
277	static int igbvf_set_ringparam(struct net_device *netdev,
278	struct ethtool_ringparam *ring)
279	{
280	struct igbvf_adapter *adapter = netdev_priv(netdev);
281	struct igbvf_ring *temp_ring;
39305965	282	int err = 0;
d4e0fe01 AD	283	u32 new_rx_count, new_tx_count;
	284
	285	if ((ring->rx_mini_pending) \|\| (ring->rx_jumbo_pending))
	286	return -EINVAL;
	287
	288	new_rx_count = max(ring->rx_pending, (u32)IGBVF_MIN_RXD);
	289	new_rx_count = min(new_rx_count, (u32)IGBVF_MAX_RXD);
	290	new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE);
	291
	292	new_tx_count = max(ring->tx_pending, (u32)IGBVF_MIN_TXD);
	293	new_tx_count = min(new_tx_count, (u32)IGBVF_MAX_TXD);
	294	new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE);
	295
	296	if ((new_tx_count == adapter->tx_ring->count) &&
	297	(new_rx_count == adapter->rx_ring->count)) {
	298	/* nothing to do */
	299	return 0;
	300	}
	301
d4e0fe01 AD	302	while (test_and_set_bit(__IGBVF_RESETTING, &adapter->state))
	303	msleep(1);
	304
39305965 AD	305	if (!netif_running(adapter->netdev)) {
	306	adapter->tx_ring->count = new_tx_count;
	307	adapter->rx_ring->count = new_rx_count;
	308	goto clear_reset;
	309	}
	310
	311	temp_ring = vmalloc(sizeof(struct igbvf_ring));
	312	if (!temp_ring) {
	313	err = -ENOMEM;
	314	goto clear_reset;
	315	}
	316
	317	igbvf_down(adapter);
d4e0fe01 AD	318
	319	/*
	320	* We can't just free everything and then setup again,
	321	* because the ISRs in MSI-X mode get passed pointers
	322	* to the tx and rx ring structs.
	323	*/
	324	if (new_tx_count != adapter->tx_ring->count) {
	325	memcpy(temp_ring, adapter->tx_ring, sizeof(struct igbvf_ring));
	326
	327	temp_ring->count = new_tx_count;
	328	err = igbvf_setup_tx_resources(adapter, temp_ring);
	329	if (err)
	330	goto err_setup;
	331
	332	igbvf_free_tx_resources(adapter->tx_ring);
	333
	334	memcpy(adapter->tx_ring, temp_ring, sizeof(struct igbvf_ring));
	335	}
	336
	337	if (new_rx_count != adapter->rx_ring->count) {
	338	memcpy(temp_ring, adapter->rx_ring, sizeof(struct igbvf_ring));
	339
	340	temp_ring->count = new_rx_count;
	341	err = igbvf_setup_rx_resources(adapter, temp_ring);
	342	if (err)
	343	goto err_setup;
	344
	345	igbvf_free_rx_resources(adapter->rx_ring);
	346
	347	memcpy(adapter->rx_ring, temp_ring,sizeof(struct igbvf_ring));
	348	}
d4e0fe01	349	err_setup:
39305965	350	igbvf_up(adapter);
d4e0fe01	351	vfree(temp_ring);
39305965 AD	352	clear_reset:
39305965 AD	353	clear_bit(__IGBVF_RESETTING, &adapter->state);
d4e0fe01 AD	354	return err;
	355	}
	356
	357	static int igbvf_link_test(struct igbvf_adapter adapter, u64 data)
	358	{
	359	struct e1000_hw *hw = &adapter->hw;
	360	*data = 0;
	361
	362	hw->mac.ops.check_for_link(hw);
	363
	364	if (!(er32(STATUS) & E1000_STATUS_LU))
	365	*data = 1;
	366
	367	return *data;
	368	}
	369
d4e0fe01 AD	370	static void igbvf_diag_test(struct net_device *netdev,
	371	struct ethtool_test eth_test, u64 data)
	372	{
	373	struct igbvf_adapter *adapter = netdev_priv(netdev);
	374
	375	set_bit(__IGBVF_TESTING, &adapter->state);
	376
	377	/*
	378	* Link test performed before hardware reset so autoneg doesn't
	379	* interfere with test result
	380	*/
	381	if (igbvf_link_test(adapter, &data[0]))
	382	eth_test->flags \|= ETH_TEST_FL_FAILED;
	383
	384	clear_bit(__IGBVF_TESTING, &adapter->state);
	385	msleep_interruptible(4 * 1000);
	386	}
	387
	388	static void igbvf_get_wol(struct net_device *netdev,
	389	struct ethtool_wolinfo *wol)
	390	{
	391	wol->supported = 0;
	392	wol->wolopts = 0;
	393
	394	return;
	395	}
	396
	397	static int igbvf_set_wol(struct net_device *netdev,
	398	struct ethtool_wolinfo *wol)
	399	{
	400	return -EOPNOTSUPP;
	401	}
	402
	403	static int igbvf_phys_id(struct net_device *netdev, u32 data)
	404	{
	405	return 0;
	406	}
	407
	408	static int igbvf_get_coalesce(struct net_device *netdev,
	409	struct ethtool_coalesce *ec)
	410	{
	411	struct igbvf_adapter *adapter = netdev_priv(netdev);
	412
	413	if (adapter->itr_setting <= 3)
	414	ec->rx_coalesce_usecs = adapter->itr_setting;
	415	else
	416	ec->rx_coalesce_usecs = adapter->itr_setting >> 2;
	417
	418	return 0;
	419	}
	420
	421	static int igbvf_set_coalesce(struct net_device *netdev,
	422	struct ethtool_coalesce *ec)
	423	{
	424	struct igbvf_adapter *adapter = netdev_priv(netdev);
	425	struct e1000_hw *hw = &adapter->hw;
	426
	427	if ((ec->rx_coalesce_usecs > IGBVF_MAX_ITR_USECS) \|\|
	428	((ec->rx_coalesce_usecs > 3) &&
	429	(ec->rx_coalesce_usecs < IGBVF_MIN_ITR_USECS)) \|\|
	430	(ec->rx_coalesce_usecs == 2))
	431	return -EINVAL;
	432
	433	/* convert to rate of irq's per second */
434	if (ec->rx_coalesce_usecs && ec->rx_coalesce_usecs <= 3) {
435	adapter->itr = IGBVF_START_ITR;
436	adapter->itr_setting = ec->rx_coalesce_usecs;
437	} else {
438	adapter->itr = ec->rx_coalesce_usecs << 2;
439	adapter->itr_setting = adapter->itr;
440	}
441
442	writel(adapter->itr,
443	hw->hw_addr + adapter->rx_ring[0].itr_register);
444
445	return 0;
446	}
447
448	static int igbvf_nway_reset(struct net_device *netdev)
449	{
450	struct igbvf_adapter *adapter = netdev_priv(netdev);
451	if (netif_running(netdev))
452	igbvf_reinit_locked(adapter);
453	return 0;
454	}
455
456
457	static void igbvf_get_ethtool_stats(struct net_device *netdev,
458	struct ethtool_stats *stats,
459	u64 *data)
460	{
461	struct igbvf_adapter *adapter = netdev_priv(netdev);
462	int i;
463
464	igbvf_update_stats(adapter);
465	for (i = 0; i < IGBVF_GLOBAL_STATS_LEN; i++) {
466	char p = (char )adapter +
467	igbvf_gstrings_stats[i].stat_offset;
468	char b = (char )adapter +
469	igbvf_gstrings_stats[i].base_stat_offset;
470	data[i] = ((igbvf_gstrings_stats[i].sizeof_stat ==
471	sizeof(u64)) ? ((u64 )p - (u64 )b) :
472	((u32 )p - (u32 )b));
473	}
474
475	}
476
15f0a394 BH	477	static int igbvf_get_sset_count(struct net_device *dev, int stringset)
	478	{
	479	switch(stringset) {
	480	case ETH_SS_TEST:
	481	return IGBVF_TEST_LEN;
	482	case ETH_SS_STATS:
	483	return IGBVF_GLOBAL_STATS_LEN;
	484	default:
	485	return -EINVAL;
	486	}
	487	}
	488
d4e0fe01 AD	489	static void igbvf_get_strings(struct net_device *netdev, u32 stringset,
	490	u8 *data)
	491	{
	492	u8 *p = data;
	493	int i;
	494
	495	switch (stringset) {
	496	case ETH_SS_TEST:
	497	memcpy(data, *igbvf_gstrings_test, sizeof(igbvf_gstrings_test));
	498	break;
	499	case ETH_SS_STATS:
	500	for (i = 0; i < IGBVF_GLOBAL_STATS_LEN; i++) {
	501	memcpy(p, igbvf_gstrings_stats[i].stat_string,
	502	ETH_GSTRING_LEN);
	503	p += ETH_GSTRING_LEN;
	504	}
	505	break;
	506	}
	507	}
	508
	509	static const struct ethtool_ops igbvf_ethtool_ops = {
	510	.get_settings = igbvf_get_settings,
	511	.set_settings = igbvf_set_settings,
	512	.get_drvinfo = igbvf_get_drvinfo,
	513	.get_regs_len = igbvf_get_regs_len,
	514	.get_regs = igbvf_get_regs,
	515	.get_wol = igbvf_get_wol,
	516	.set_wol = igbvf_set_wol,
	517	.get_msglevel = igbvf_get_msglevel,
	518	.set_msglevel = igbvf_set_msglevel,
	519	.nway_reset = igbvf_nway_reset,
	520	.get_link = igbvf_get_link,
	521	.get_eeprom_len = igbvf_get_eeprom_len,
	522	.get_eeprom = igbvf_get_eeprom,
	523	.set_eeprom = igbvf_set_eeprom,
	524	.get_ringparam = igbvf_get_ringparam,
	525	.set_ringparam = igbvf_set_ringparam,
	526	.get_pauseparam = igbvf_get_pauseparam,
	527	.set_pauseparam = igbvf_set_pauseparam,
0364d6fd AD	528	.get_rx_csum = igbvf_get_rx_csum,
0364d6fd AD	529	.set_rx_csum = igbvf_set_rx_csum,
d4e0fe01 AD	530	.get_tx_csum = igbvf_get_tx_csum,
	531	.set_tx_csum = igbvf_set_tx_csum,
	532	.get_sg = ethtool_op_get_sg,
	533	.set_sg = ethtool_op_set_sg,
	534	.get_tso = ethtool_op_get_tso,
	535	.set_tso = igbvf_set_tso,
	536	.self_test = igbvf_diag_test,
15f0a394	537	.get_sset_count = igbvf_get_sset_count,
d4e0fe01 AD	538	.get_strings = igbvf_get_strings,
	539	.phys_id = igbvf_phys_id,
	540	.get_ethtool_stats = igbvf_get_ethtool_stats,
d4e0fe01 AD	541	.get_coalesce = igbvf_get_coalesce,
	542	.set_coalesce = igbvf_set_coalesce,
	543	};
	544
	545	void igbvf_set_ethtool_ops(struct net_device *netdev)
	546	{
	547	/* have to "undeclare" const on this struct to remove warnings */
	548	SET_ETHTOOL_OPS(netdev, (struct ethtool_ops *)&igbvf_ethtool_ops);
	549	}