Release 4.11 drivers/net/ethernet/intel/igbvf/ethtool.c

Directory: drivers/net/ethernet/intel/igbvf
/*******************************************************************************

  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, see <http://www.gnu.org/licenses/>.

  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, SPEED_UNKNOWN);
		ecmd->duplex = DUPLEX_UNKNOWN;
	}

	ecmd->autoneg = AUTONEG_DISABLE;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 137 86.71% 1 33.33%
David Decotigny 19 12.03% 1 33.33%
Jiri Pirko 2 1.27% 1 33.33%
Total 158 100.00% 3 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 20 100.00% 1 100.00%
Total 20 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 14 93.33% 1 50.00%
Stephen Hemminger 1 6.67% 1 50.00%
Total 15 100.00% 2 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 20 100.00% 1 100.00%
Total 20 100.00% 1 100.00%



static u32 igbvf_get_msglevel(struct net_device *netdev)
{
	struct igbvf_adapter *adapter = netdev_priv(netdev);

	return adapter->msg_enable;
}

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



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

	adapter->msg_enable = data;
}

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%



static int igbvf_get_regs_len(struct net_device *netdev)
{

#define IGBVF_REGS_LEN 8
	return IGBVF_REGS_LEN * sizeof(u32);
}

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 23 100.00% 1 100.00%
Total 23 100.00% 1 100.00%



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 = (1u << 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));
}

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 178 96.74% 1 33.33%
Sergei Shtylyov 5 2.72% 1 33.33%
Jacob E Keller 1 0.54% 1 33.33%
Total 184 100.00% 3 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 14 100.00% 1 100.00%
Total 14 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%



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));
}

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 58 73.42% 1 50.00%
Rick Jones 21 26.58% 1 50.00%
Total 79 100.00% 2 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 72 100.00% 1 100.00%
Total 72 100.00% 1 100.00%



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_t(u32, ring->rx_pending, IGBVF_MIN_RXD);
	new_rx_count = min_t(u32, new_rx_count, IGBVF_MAX_RXD);
	new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE);

	new_tx_count = max_t(u32, ring->tx_pending, IGBVF_MIN_TXD);
	new_tx_count = min_t(u32, new_tx_count, 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))
		usleep_range(1000, 2000);

	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;
}

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 387 95.79% 2 50.00%
Jeff Kirsher 17 4.21% 2 50.00%
Total 404 100.00% 4 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 62 100.00% 1 100.00%
Total 62 100.00% 1 100.00%



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);
}

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 76 98.70% 1 50.00%
Jeff Kirsher 1 1.30% 1 50.00%
Total 77 100.00% 2 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 20 100.00% 1 100.00%
Total 20 100.00% 1 100.00%



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

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

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 53 94.64% 1 50.00%
Mitch A Williams 3 5.36% 1 50.00%
Total 56 100.00% 2 100.00%



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_MIN_ITR_USECS) &&
	    (ec->rx_coalesce_usecs <= IGBVF_MAX_ITR_USECS)) {
		adapter->current_itr = ec->rx_coalesce_usecs << 2;
		adapter->requested_itr = 1000000000 /
					(adapter->current_itr * 256);
	} else if ((ec->rx_coalesce_usecs == 3) ||
		   (ec->rx_coalesce_usecs == 2)) {
		adapter->current_itr = IGBVF_START_ITR;
		adapter->requested_itr = ec->rx_coalesce_usecs;
	} else if (ec->rx_coalesce_usecs == 0) {
		/* The user's desire is to turn off interrupt throttling
                 * altogether, but due to HW limitations, we can't do that.
                 * Instead we set a very small value in EITR, which would
                 * allow ~967k interrupts per second, but allow the adapter's
                 * internal clocking to still function properly.
                 */
		adapter->current_itr = 4;
		adapter->requested_itr = 1000000000 /
					(adapter->current_itr * 256);
	} else {
		return -EINVAL;
	}

	writel(adapter->current_itr,
	       hw->hw_addr + adapter->rx_ring->itr_register);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 107 61.49% 1 25.00%
Mitch A Williams 64 36.78% 2 50.00%
Jeff Kirsher 3 1.72% 1 25.00%
Total 174 100.00% 4 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 36 100.00% 1 100.00%
Total 36 100.00% 1 100.00%



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));
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 140 100.00% 1 100.00%
Total 140 100.00% 1 100.00%



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;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Ben Hutchings 37 100.00% 1 100.00%
Total 37 100.00% 1 100.00%



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;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 87 100.00% 1 100.00%
Total 87 100.00% 1 100.00%


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)
{
	netdev->ethtool_ops = &igbvf_ethtool_ops;
}
Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 14 82.35% 1 50.00%
Wilfried Klaebe 3 17.65% 1 50.00%
Total 17 100.00% 2 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
Alexander Duyck 1997 91.56% 2 13.33%
Mitch A Williams 67 3.07% 2 13.33%
Ben Hutchings 43 1.97% 2 13.33%
Jeff Kirsher 22 1.01% 2 13.33%
Rick Jones 21 0.96% 1 6.67%
David Decotigny 19 0.87% 1 6.67%
Sergei Shtylyov 5 0.23% 1 6.67%
Wilfried Klaebe 3 0.14% 1 6.67%
Jiri Pirko 2 0.09% 1 6.67%
Jacob E Keller 1 0.05% 1 6.67%
Stephen Hemminger 1 0.05% 1 6.67%
Total 2181 100.00% 15 100.00%
Directory: drivers/net/ethernet/intel/igbvf

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Alexander Duyck	137	86.71%	1	33.33%
David Decotigny	19	12.03%	1	33.33%
Jiri Pirko	2	1.27%	1	33.33%
Total	158	100.00%	3	100.00%
cregit-Linux how code gets into the kernel

Release 4.11 drivers/net/ethernet/intel/igbvf/ethtool.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
