leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/jkirsher/net-next

Browse Source 
Jeff Kirsher says:

====================
Intel Wired LAN Driver Updates 2015-02-24

This series contains updates to i40e and i40evf only, which bumps their
versions to i40e 1.2.9 and i40evf 1.2.3.

Paul fixes i40e_debug_aq() for big endian machines by adding the
appropriate LExx_TO_CPU wrappers.

Catherine adds a requested speed variable to the link_status to store the
last speeds we requested from the firmware and use the advertised speed
settings in get_settings in ethtool now that we have it.  Due to the
new code addition, she also refactors get_settings to improve readability
and to accommodate some of the longer lines of code by adding two
functions i40e_get_settings_link_up() and i40e_get_settings_link_down().

Carolyn adds a struct to the VSI struct to keep track of RXNFC settings
done via ethtool.  Adds more information to the interrupt vector
names, specifically to the VF misc vector name so that we can distinguish
between all the interrupts.

Ashish enables the i40evf driver to enable debug prints via ethtool.

Mitch updates i40e to enable packet split only when IOMMU is in use,
since it shows a distinct advantage over the single-buffer path
because it minimizes DMA mapping and unmapping.  Also adds the receive
routine in use to the features log message to be able to print the
receive packet split status.

Greg adds the ability to get, set and commit permanently the NPAR
partition BW configuration through configfs.  Enables an application
to query the i40e driver's private flags to get the status of NPAR
enablement via ethtool.

Neerav adds support for bridge offload ndo_ops getlink and setlink
to enable bridge hardware mode as per the mode set via IFLA_BRIDGE_MODE.
The support is only enabled in the case of a PF VSI and not available for
any other VSI type.

Kevin fixes i40e by ensuring the BUF and FLAG_RD flags are set for
indirect admin queue command.

Vasu updates the driver to setup FCoE netdev device type as "fcoe", so that
it shows up in sysfs as FCoE device.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2015-02-25 18:13:07 -05:00
commit 009f33ed6f
16 changed files with 1130 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
drivers/net/ethernet/intel/i40e/Makefile
View File

@ -1,7 +1,7 @@
################################################################################ ################################################################################
# #
# Intel Ethernet Controller XL710 Family Linux Driver # Intel Ethernet Controller XL710 Family Linux Driver
# Copyright(c) 2013 - 2014 Intel Corporation. # Copyright(c) 2013 - 2015 Intel Corporation.
# #
# This program is free software; you can redistribute it and/or modify it # This program is free software; you can redistribute it and/or modify it
# under the terms and conditions of the GNU General Public License, # under the terms and conditions of the GNU General Public License,
@ -37,6 +37,7 @@ i40e-objs := i40e_main.o \
i40e_hmc.o \ i40e_hmc.o \
i40e_lan_hmc.o \ i40e_lan_hmc.o \
i40e_nvm.o \ i40e_nvm.o \
i40e_configfs.o \
i40e_debugfs.o \ i40e_debugfs.o \
i40e_diag.o \ i40e_diag.o \
i40e_txrx.o \ i40e_txrx.o \

24
drivers/net/ethernet/intel/i40e/i40e.h
View File

@ -1,7 +1,7 @@
/******************************************************************************* /*******************************************************************************
* *
* Intel Ethernet Controller XL710 Family Linux Driver * Intel Ethernet Controller XL710 Family Linux Driver
* Copyright(c) 2013 - 2014 Intel Corporation. * Copyright(c) 2013 - 2015 Intel Corporation.
* *
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License, * under the terms and conditions of the GNU General Public License,
@ -36,6 +36,7 @@
#include <linux/aer.h> #include <linux/aer.h>
#include <linux/netdevice.h> #include <linux/netdevice.h>
#include <linux/ioport.h> #include <linux/ioport.h>
#include <linux/iommu.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/list.h> #include <linux/list.h>
#include <linux/string.h> #include <linux/string.h>
@ -49,6 +50,7 @@
#include <net/ip6_checksum.h> #include <net/ip6_checksum.h>
#include <linux/ethtool.h> #include <linux/ethtool.h>
#include <linux/if_vlan.h> #include <linux/if_vlan.h>
#include <linux/if_bridge.h>
#include <linux/clocksource.h> #include <linux/clocksource.h>
#include <linux/net_tstamp.h> #include <linux/net_tstamp.h>
#include <linux/ptp_clock_kernel.h> #include <linux/ptp_clock_kernel.h>
@ -94,6 +96,9 @@
#define I40E_QUEUE_WAIT_RETRY_LIMIT 10 #define I40E_QUEUE_WAIT_RETRY_LIMIT 10
#define I40E_INT_NAME_STR_LEN (IFNAMSIZ + 9) #define I40E_INT_NAME_STR_LEN (IFNAMSIZ + 9)
/* Ethtool Private Flags */
#define I40E_PRIV_FLAGS_NPAR_FLAG (1 << 0)
#define I40E_NVM_VERSION_LO_SHIFT 0 #define I40E_NVM_VERSION_LO_SHIFT 0
#define I40E_NVM_VERSION_LO_MASK (0xff << I40E_NVM_VERSION_LO_SHIFT) #define I40E_NVM_VERSION_LO_MASK (0xff << I40E_NVM_VERSION_LO_SHIFT)
#define I40E_NVM_VERSION_HI_SHIFT 12 #define I40E_NVM_VERSION_HI_SHIFT 12
@ -384,6 +389,9 @@ struct i40e_pf {
bool ptp_tx; bool ptp_tx;
bool ptp_rx; bool ptp_rx;
u16 rss_table_size; u16 rss_table_size;
/* These are only valid in NPAR modes */
u32 npar_max_bw;
u32 npar_min_bw;
}; };
struct i40e_mac_filter { struct i40e_mac_filter {
@ -406,6 +414,7 @@ struct i40e_veb {
u16 uplink_seid; u16 uplink_seid;
u16 stats_idx; /* index of VEB parent */ u16 stats_idx; /* index of VEB parent */
u8 enabled_tc; u8 enabled_tc;
u16 bridge_mode; /* Bridge Mode (VEB/VEPA) */
u16 flags; u16 flags;
u16 bw_limit; u16 bw_limit;
u8 bw_max_quanta; u8 bw_max_quanta;
@ -505,6 +514,9 @@ struct i40e_vsi {
/* VSI specific handlers */ /* VSI specific handlers */
irqreturn_t (*irq_handler)(int irq, void *data); irqreturn_t (*irq_handler)(int irq, void *data);
/* current rxnfc data */
struct ethtool_rxnfc rxnfc; /* current rss hash opts */
} ____cacheline_internodealigned_in_smp; } ____cacheline_internodealigned_in_smp;
struct i40e_netdev_priv { struct i40e_netdev_priv {
@ -681,6 +693,7 @@ int i40e_vlan_rx_add_vid(struct net_device *netdev,
int i40e_vlan_rx_kill_vid(struct net_device *netdev, int i40e_vlan_rx_kill_vid(struct net_device *netdev,
__always_unused __be16 proto, u16 vid); __always_unused __be16 proto, u16 vid);
#endif #endif
int i40e_open(struct net_device *netdev);
int i40e_vsi_open(struct i40e_vsi *vsi); int i40e_vsi_open(struct i40e_vsi *vsi);
void i40e_vlan_stripping_disable(struct i40e_vsi *vsi); void i40e_vlan_stripping_disable(struct i40e_vsi *vsi);
int i40e_vsi_add_vlan(struct i40e_vsi *vsi, s16 vid); int i40e_vsi_add_vlan(struct i40e_vsi *vsi, s16 vid);
@ -691,7 +704,6 @@ bool i40e_is_vsi_in_vlan(struct i40e_vsi *vsi);
struct i40e_mac_filter *i40e_find_mac(struct i40e_vsi *vsi, u8 *macaddr, struct i40e_mac_filter *i40e_find_mac(struct i40e_vsi *vsi, u8 *macaddr,
bool is_vf, bool is_netdev); bool is_vf, bool is_netdev);
#ifdef I40E_FCOE #ifdef I40E_FCOE
int i40e_open(struct net_device *netdev);
int i40e_close(struct net_device *netdev); int i40e_close(struct net_device *netdev);
int i40e_setup_tc(struct net_device *netdev, u8 tc); int i40e_setup_tc(struct net_device *netdev, u8 tc);
void i40e_netpoll(struct net_device *netdev); void i40e_netpoll(struct net_device *netdev);
@ -728,4 +740,12 @@ int i40e_ptp_set_ts_config(struct i40e_pf *pf, struct ifreq *ifr);
int i40e_ptp_get_ts_config(struct i40e_pf *pf, struct ifreq *ifr); int i40e_ptp_get_ts_config(struct i40e_pf *pf, struct ifreq *ifr);
void i40e_ptp_init(struct i40e_pf *pf); void i40e_ptp_init(struct i40e_pf *pf);
void i40e_ptp_stop(struct i40e_pf *pf); void i40e_ptp_stop(struct i40e_pf *pf);
int i40e_is_vsi_uplink_mode_veb(struct i40e_vsi *vsi);
#if IS_ENABLED(CONFIG_CONFIGFS_FS)
int i40e_configfs_init(void);
void i40e_configfs_exit(void);
#endif /* CONFIG_CONFIGFS_FS */
i40e_status i40e_get_npar_bw_setting(struct i40e_pf *pf);
i40e_status i40e_set_npar_bw_setting(struct i40e_pf *pf);
i40e_status i40e_commit_npar_bw_setting(struct i40e_pf *pf);
#endif /* _I40E_H_ */ #endif /* _I40E_H_ */

150
drivers/net/ethernet/intel/i40e/i40e_common.c
View File

@ -1,7 +1,7 @@
/******************************************************************************* /*******************************************************************************
* *
* Intel Ethernet Controller XL710 Family Linux Driver * Intel Ethernet Controller XL710 Family Linux Driver
* Copyright(c) 2013 - 2014 Intel Corporation. * Copyright(c) 2013 - 2015 Intel Corporation.
* *
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License, * under the terms and conditions of the GNU General Public License,
@ -94,16 +94,19 @@ void i40e_debug_aq(struct i40e_hw *hw, enum i40e_debug_mask mask, void *desc,
i40e_debug(hw, mask, i40e_debug(hw, mask,
"AQ CMD: opcode 0x%04X, flags 0x%04X, datalen 0x%04X, retval 0x%04X\n", "AQ CMD: opcode 0x%04X, flags 0x%04X, datalen 0x%04X, retval 0x%04X\n",
aq_desc->opcode, aq_desc->flags, aq_desc->datalen, le16_to_cpu(aq_desc->opcode),
aq_desc->retval); le16_to_cpu(aq_desc->flags),
le16_to_cpu(aq_desc->datalen),
le16_to_cpu(aq_desc->retval));
i40e_debug(hw, mask, "\tcookie (h,l) 0x%08X 0x%08X\n", i40e_debug(hw, mask, "\tcookie (h,l) 0x%08X 0x%08X\n",
aq_desc->cookie_high, aq_desc->cookie_low); le32_to_cpu(aq_desc->cookie_high),
le32_to_cpu(aq_desc->cookie_low));
i40e_debug(hw, mask, "\tparam (0,1) 0x%08X 0x%08X\n", i40e_debug(hw, mask, "\tparam (0,1) 0x%08X 0x%08X\n",
aq_desc->params.internal.param0, le32_to_cpu(aq_desc->params.internal.param0),
aq_desc->params.internal.param1); le32_to_cpu(aq_desc->params.internal.param1));
i40e_debug(hw, mask, "\taddr (h,l) 0x%08X 0x%08X\n", i40e_debug(hw, mask, "\taddr (h,l) 0x%08X 0x%08X\n",
aq_desc->params.external.addr_high, le32_to_cpu(aq_desc->params.external.addr_high),
aq_desc->params.external.addr_low); le32_to_cpu(aq_desc->params.external.addr_low));
if ((buffer != NULL) && (aq_desc->datalen != 0)) { if ((buffer != NULL) && (aq_desc->datalen != 0)) {
memset(data, 0, sizeof(data)); memset(data, 0, sizeof(data));
@ -116,15 +119,19 @@ void i40e_debug_aq(struct i40e_hw *hw, enum i40e_debug_mask mask, void *desc,
if ((i % 16) == 15) { if ((i % 16) == 15) {
i40e_debug(hw, mask, i40e_debug(hw, mask,
"\t0x%04X %08X %08X %08X %08X\n", "\t0x%04X %08X %08X %08X %08X\n",
i - 15, data[0], data[1], data[2], i - 15, le32_to_cpu(data[0]),
data[3]); le32_to_cpu(data[1]),
le32_to_cpu(data[2]),
le32_to_cpu(data[3]));
memset(data, 0, sizeof(data)); memset(data, 0, sizeof(data));
} }
} }
if ((i % 16) != 0) if ((i % 16) != 0)
i40e_debug(hw, mask, "\t0x%04X %08X %08X %08X %08X\n", i40e_debug(hw, mask, "\t0x%04X %08X %08X %08X %08X\n",
i - (i % 16), data[0], data[1], data[2], i - (i % 16), le32_to_cpu(data[0]),
data[3]); le32_to_cpu(data[1]),
le32_to_cpu(data[2]),
le32_to_cpu(data[3]));
} }
} }
@ -1787,7 +1794,7 @@ i40e_status i40e_aq_send_driver_version(struct i40e_hw *hw,
i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_driver_version); i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_driver_version);
desc.flags |= cpu_to_le16(I40E_AQ_FLAG_SI); desc.flags |= cpu_to_le16(I40E_AQ_FLAG_BUF | I40E_AQ_FLAG_RD);
cmd->driver_major_ver = dv->major_version; cmd->driver_major_ver = dv->major_version;
cmd->driver_minor_ver = dv->minor_version; cmd->driver_minor_ver = dv->minor_version;
cmd->driver_build_ver = dv->build_version; cmd->driver_build_ver = dv->build_version;
@ -3346,6 +3353,47 @@ i40e_status i40e_aq_add_rem_control_packet_filter(struct i40e_hw *hw,
return status; return status;
} }
/**
* i40e_aq_alternate_read
* @hw: pointer to the hardware structure
* @reg_addr0: address of first dword to be read
* @reg_val0: pointer for data read from 'reg_addr0'
* @reg_addr1: address of second dword to be read
* @reg_val1: pointer for data read from 'reg_addr1'
*
* Read one or two dwords from alternate structure. Fields are indicated
* by 'reg_addr0' and 'reg_addr1' register numbers. If 'reg_val1' pointer
* is not passed then only register at 'reg_addr0' is read.
*
**/
i40e_status i40e_aq_alternate_read(struct i40e_hw *hw,
u32 reg_addr0, u32 *reg_val0,
u32 reg_addr1, u32 *reg_val1)
{
struct i40e_aq_desc desc;
struct i40e_aqc_alternate_write *cmd_resp =
(struct i40e_aqc_alternate_write *)&desc.params.raw;
i40e_status status;
if (!reg_val0)
return I40E_ERR_PARAM;
i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_alternate_read);
cmd_resp->address0 = cpu_to_le32(reg_addr0);
cmd_resp->address1 = cpu_to_le32(reg_addr1);
status = i40e_asq_send_command(hw, &desc, NULL, 0, NULL);
if (!status) {
*reg_val0 = le32_to_cpu(cmd_resp->data0);
if (reg_val1)
*reg_val1 = le32_to_cpu(cmd_resp->data1);
}
return status;
}
/** /**
* i40e_aq_resume_port_tx * i40e_aq_resume_port_tx
* @hw: pointer to the hardware structure * @hw: pointer to the hardware structure
@ -3410,3 +3458,79 @@ void i40e_set_pci_config_data(struct i40e_hw *hw, u16 link_status)
break; break;
} }
} }
/**
* i40e_read_bw_from_alt_ram
* @hw: pointer to the hardware structure
* @max_bw: pointer for max_bw read
* @min_bw: pointer for min_bw read
* @min_valid: pointer for bool that is true if min_bw is a valid value
* @max_valid: pointer for bool that is true if max_bw is a valid value
*
* Read bw from the alternate ram for the given pf
**/
i40e_status i40e_read_bw_from_alt_ram(struct i40e_hw *hw,
u32 *max_bw, u32 *min_bw,
bool *min_valid, bool *max_valid)
{
i40e_status status;
u32 max_bw_addr, min_bw_addr;
/* Calculate the address of the min/max bw registers */
max_bw_addr = I40E_ALT_STRUCT_FIRST_PF_OFFSET +
I40E_ALT_STRUCT_MAX_BW_OFFSET +
(I40E_ALT_STRUCT_DWORDS_PER_PF * hw->pf_id);
min_bw_addr = I40E_ALT_STRUCT_FIRST_PF_OFFSET +
I40E_ALT_STRUCT_MIN_BW_OFFSET +
(I40E_ALT_STRUCT_DWORDS_PER_PF * hw->pf_id);
/* Read the bandwidths from alt ram */
status = i40e_aq_alternate_read(hw, max_bw_addr, max_bw,
min_bw_addr, min_bw);
if (*min_bw & I40E_ALT_BW_VALID_MASK)
*min_valid = true;
else
*min_valid = false;
if (*max_bw & I40E_ALT_BW_VALID_MASK)
*max_valid = true;
else
*max_valid = false;
return status;
}
/**
* i40e_aq_configure_partition_bw
* @hw: pointer to the hardware structure
* @bw_data: Buffer holding valid pfs and bw limits
* @cmd_details: pointer to command details
*
* Configure partitions guaranteed/max bw
**/
i40e_status i40e_aq_configure_partition_bw(struct i40e_hw *hw,
struct i40e_aqc_configure_partition_bw_data *bw_data,
struct i40e_asq_cmd_details *cmd_details)
{
i40e_status status;
struct i40e_aq_desc desc;
u16 bwd_size = sizeof(*bw_data);
i40e_fill_default_direct_cmd_desc(&desc,
i40e_aqc_opc_configure_partition_bw);
/* Indirect command */
desc.flags |= cpu_to_le16((u16)I40E_AQ_FLAG_BUF);
desc.flags |= cpu_to_le16((u16)I40E_AQ_FLAG_RD);
if (bwd_size > I40E_AQ_LARGE_BUF)
desc.flags |= cpu_to_le16((u16)I40E_AQ_FLAG_LB);
desc.datalen = cpu_to_le16(bwd_size);
status = i40e_asq_send_command(hw, &desc, bw_data, bwd_size,
cmd_details);
return status;
}

354
drivers/net/ethernet/intel/i40e/i40e_configfs.c Normal file
View File

@ -0,0 +1,354 @@
/*******************************************************************************
*
* Intel Ethernet Controller XL710 Family Linux Driver
* Copyright(c) 2013 - 2015 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
*
******************************************************************************/
#include <linux/configfs.h>
#include "i40e.h"
#if IS_ENABLED(CONFIG_CONFIGFS_FS)
/**
* configfs structure for i40e
*
* This file adds code for configfs support for the i40e driver. This sets
* up a filesystem under /sys/kernel/config in which configuration changes
* can be made for the driver's netdevs.
*
* The initialization in this code creates the "i40e" entry in the configfs
* system. After that, the user needs to use mkdir to create configurations
* for specific netdev ports; for example "mkdir eth3". This code will verify
* that such a netdev exists and that it is owned by i40e.
*
**/
struct i40e_cfgfs_vsi {
struct config_item item;
struct i40e_vsi *vsi;
};
static inline struct i40e_cfgfs_vsi *to_i40e_cfgfs_vsi(struct config_item *item)
{
return item ? container_of(item, struct i40e_cfgfs_vsi, item) : NULL;
}
static struct configfs_attribute i40e_cfgfs_vsi_attr_min_bw = {
.ca_owner = THIS_MODULE,
.ca_name = "min_bw",
.ca_mode = S_IRUGO | S_IWUSR,
};
static struct configfs_attribute i40e_cfgfs_vsi_attr_max_bw = {
.ca_owner = THIS_MODULE,
.ca_name = "max_bw",
.ca_mode = S_IRUGO | S_IWUSR,
};
static struct configfs_attribute i40e_cfgfs_vsi_attr_commit = {
.ca_owner = THIS_MODULE,
.ca_name = "commit",
.ca_mode = S_IRUGO | S_IWUSR,
};
static struct configfs_attribute i40e_cfgfs_vsi_attr_port_count = {
.ca_owner = THIS_MODULE,
.ca_name = "ports",
.ca_mode = S_IRUGO | S_IWUSR,
};
static struct configfs_attribute i40e_cfgfs_vsi_attr_part_count = {
.ca_owner = THIS_MODULE,
.ca_name = "partitions",
.ca_mode = S_IRUGO | S_IWUSR,
};
static struct configfs_attribute *i40e_cfgfs_vsi_attrs[] = {
&i40e_cfgfs_vsi_attr_min_bw,
&i40e_cfgfs_vsi_attr_max_bw,
&i40e_cfgfs_vsi_attr_commit,
&i40e_cfgfs_vsi_attr_port_count,
&i40e_cfgfs_vsi_attr_part_count,
NULL,
};
/**
* i40e_cfgfs_vsi_attr_show - Show a VSI's NPAR BW partition info
* @item: A pointer back to the configfs item created on driver load
* @attr: A pointer to this item's configuration attribute
* @page: A pointer to the output buffer
**/
static ssize_t i40e_cfgfs_vsi_attr_show(struct config_item *item,
struct configfs_attribute *attr,
char *page)
{
struct i40e_cfgfs_vsi *i40e_cfgfs_vsi = to_i40e_cfgfs_vsi(item);
struct i40e_pf *pf = i40e_cfgfs_vsi->vsi->back;
ssize_t count;
if (i40e_cfgfs_vsi->vsi != pf->vsi[pf->lan_vsi])
return 0;
if (strncmp(attr->ca_name, "min_bw", 6) == 0)
count = sprintf(page, "%s %s %d%%\n",
i40e_cfgfs_vsi->vsi->netdev->name,
(pf->npar_min_bw & I40E_ALT_BW_RELATIVE_MASK) ?
"Relative Min BW" : "Absolute Min BW",
pf->npar_min_bw & I40E_ALT_BW_VALUE_MASK);
else if (strncmp(attr->ca_name, "max_bw", 6) == 0)
count = sprintf(page, "%s %s %d%%\n",
i40e_cfgfs_vsi->vsi->netdev->name,
(pf->npar_max_bw & I40E_ALT_BW_RELATIVE_MASK) ?
"Relative Max BW" : "Absolute Max BW",
pf->npar_max_bw & I40E_ALT_BW_VALUE_MASK);
else if (strncmp(attr->ca_name, "ports", 5) == 0)
count = sprintf(page, "%d\n",
pf->hw.num_ports);
else if (strncmp(attr->ca_name, "partitions", 10) == 0)
count = sprintf(page, "%d\n",
pf->hw.num_partitions);
else
return 0;
return count;
}
/**
* i40e_cfgfs_vsi_attr_store - Show a VSI's NPAR BW partition info
* @item: A pointer back to the configfs item created on driver load
* @attr: A pointer to this item's configuration attribute
* @page: A pointer to the user input buffer holding the user input values
**/
static ssize_t i40e_cfgfs_vsi_attr_store(struct config_item *item,
struct configfs_attribute *attr,
const char *page, size_t count)
{
struct i40e_cfgfs_vsi *i40e_cfgfs_vsi = to_i40e_cfgfs_vsi(item);
struct i40e_pf *pf = i40e_cfgfs_vsi->vsi->back;
char *p = (char *)page;
int rc;
unsigned long tmp;
if (i40e_cfgfs_vsi->vsi != pf->vsi[pf->lan_vsi])
return 0;
if (!p || (*p && (*p == '\n')))
return -EINVAL;
rc = kstrtoul(p, 10, &tmp);
if (rc)
return rc;
if (tmp > 100)
return -ERANGE;
if (strncmp(attr->ca_name, "min_bw", 6) == 0) {
if (tmp > (pf->npar_max_bw & I40E_ALT_BW_VALUE_MASK))
return -ERANGE;
/* Preserve the valid and relative BW bits - the rest is
* don't care.
*/
pf->npar_min_bw &= (I40E_ALT_BW_RELATIVE_MASK |
I40E_ALT_BW_VALID_MASK);
pf->npar_min_bw |= (tmp & I40E_ALT_BW_VALUE_MASK);
i40e_set_npar_bw_setting(pf);
} else if (strncmp(attr->ca_name, "max_bw", 6) == 0) {
if (tmp < 1 ||
tmp < (pf->npar_min_bw & I40E_ALT_BW_VALUE_MASK))
return -ERANGE;
/* Preserve the valid and relative BW bits - the rest is
* don't care.
*/
pf->npar_max_bw &= (I40E_ALT_BW_RELATIVE_MASK |
I40E_ALT_BW_VALID_MASK);
pf->npar_max_bw |= (tmp & I40E_ALT_BW_VALUE_MASK);
i40e_set_npar_bw_setting(pf);
} else if (strncmp(attr->ca_name, "commit", 6) == 0 && tmp == 1) {
if (i40e_commit_npar_bw_setting(pf))
return -EIO;
}
return count;
}
/**
* i40e_cfgfs_vsi_release - Free up the configuration item memory
* @item: A pointer back to the configfs item created on driver load
**/
static void i40e_cfgfs_vsi_release(struct config_item *item)
{
kfree(to_i40e_cfgfs_vsi(item));
}
static struct configfs_item_operations i40e_cfgfs_vsi_item_ops = {
.release = i40e_cfgfs_vsi_release,
.show_attribute = i40e_cfgfs_vsi_attr_show,
.store_attribute = i40e_cfgfs_vsi_attr_store,
};
static struct config_item_type i40e_cfgfs_vsi_type = {
.ct_item_ops = &i40e_cfgfs_vsi_item_ops,
.ct_attrs = i40e_cfgfs_vsi_attrs,
.ct_owner = THIS_MODULE,
};
struct i40e_cfgfs_group {
struct config_group group;
};
/**
* to_i40e_cfgfs_group - Get the group pointer from the config item
* @item: A pointer back to the configfs item created on driver load
**/
static inline struct i40e_cfgfs_group *
to_i40e_cfgfs_group(struct config_item *item)
{
return item ? container_of(to_config_group(item),
struct i40e_cfgfs_group, group) : NULL;
}
/**
* i40e_cfgfs_group_make_item - Create the configfs item with group container
* @group: A pointer to our configfs group
* @name: A pointer to the nume of the device we're looking for
**/
static struct config_item *
i40e_cfgfs_group_make_item(struct config_group *group, const char *name)
{
struct i40e_cfgfs_vsi *i40e_cfgfs_vsi;
struct net_device *netdev;
struct i40e_netdev_priv *np;
read_lock(&dev_base_lock);
netdev = first_net_device(&init_net);
while (netdev) {
if (strncmp(netdev->name, name, sizeof(netdev->name)) == 0)
break;
netdev = next_net_device(netdev);
}
read_unlock(&dev_base_lock);
if (!netdev)
return ERR_PTR(-ENODEV);
/* is this netdev owned by i40e? */
if (netdev->netdev_ops->ndo_open != i40e_open)
return ERR_PTR(-EACCES);
i40e_cfgfs_vsi = kzalloc(sizeof(*i40e_cfgfs_vsi), GFP_KERNEL);
if (!i40e_cfgfs_vsi)
return ERR_PTR(-ENOMEM);
np = netdev_priv(netdev);
i40e_cfgfs_vsi->vsi = np->vsi;
config_item_init_type_name(&i40e_cfgfs_vsi->item, name,
&i40e_cfgfs_vsi_type);
return &i40e_cfgfs_vsi->item;
}
static struct configfs_attribute i40e_cfgfs_group_attr_description = {
.ca_owner = THIS_MODULE,
.ca_name = "description",
.ca_mode = S_IRUGO,
};
static struct configfs_attribute *i40e_cfgfs_group_attrs[] = {
&i40e_cfgfs_group_attr_description,
NULL,
};
static ssize_t i40e_cfgfs_group_attr_show(struct config_item *item,
struct configfs_attribute *attr,
char *page)
{
return sprintf(page,
"i40e\n"
"\n"
"This subsystem allows the modification of network port configurations.\n"
"To start, use the name of the network port to be configured in a 'mkdir'\n"
"command, e.g. 'mkdir eth3'.\n");
}
static void i40e_cfgfs_group_release(struct config_item *item)
{
kfree(to_i40e_cfgfs_group(item));
}
static struct configfs_item_operations i40e_cfgfs_group_item_ops = {
.release = i40e_cfgfs_group_release,
.show_attribute = i40e_cfgfs_group_attr_show,
};
/* Note that, since no extra work is required on ->drop_item(),
* no ->drop_item() is provided.
*/
static struct configfs_group_operations i40e_cfgfs_group_ops = {
.make_item = i40e_cfgfs_group_make_item,
};
static struct config_item_type i40e_cfgfs_group_type = {
.ct_item_ops = &i40e_cfgfs_group_item_ops,
.ct_group_ops = &i40e_cfgfs_group_ops,
.ct_attrs = i40e_cfgfs_group_attrs,
.ct_owner = THIS_MODULE,
};
static struct configfs_subsystem i40e_cfgfs_group_subsys = {
.su_group = {
.cg_item = {
.ci_namebuf = "i40e",
.ci_type = &i40e_cfgfs_group_type,
},
},
};
/**
* i40e_configfs_init - Initialize configfs support for our driver
**/
int i40e_configfs_init(void)
{
int ret;
struct configfs_subsystem *subsys;
subsys = &i40e_cfgfs_group_subsys;
config_group_init(&subsys->su_group);
mutex_init(&subsys->su_mutex);
ret = configfs_register_subsystem(subsys);
if (ret) {
pr_err("Error %d while registering configfs subsystem %s\n",
ret, subsys->su_group.cg_item.ci_namebuf);
return ret;
}
return 0;
}
/**
* i40e_configfs_init - Bail out - unregister configfs subsystem and release
**/
void i40e_configfs_exit(void)
{
configfs_unregister_subsystem(&i40e_cfgfs_group_subsys);
}
#endif /* IS_ENABLED(CONFIG_CONFIGFS_FS) */

5
drivers/net/ethernet/intel/i40e/i40e_debugfs.c
View File

@ -921,9 +921,10 @@ static void i40e_dbg_dump_veb_seid(struct i40e_pf *pf, int seid)
return; return;
} }
dev_info(&pf->pdev->dev, dev_info(&pf->pdev->dev,
"veb idx=%d,%d stats_ic=%d seid=%d uplink=%d\n", "veb idx=%d,%d stats_ic=%d seid=%d uplink=%d mode=%s\n",
veb->idx, veb->veb_idx, veb->stats_idx, veb->seid, veb->idx, veb->veb_idx, veb->stats_idx, veb->seid,
veb->uplink_seid); veb->uplink_seid,
veb->bridge_mode == BRIDGE_MODE_VEPA ? "VEPA" : "VEB");
i40e_dbg_dump_eth_stats(pf, &veb->stats); i40e_dbg_dump_eth_stats(pf, &veb->stats);
} }

330
drivers/net/ethernet/intel/i40e/i40e_ethtool.c
View File

@ -1,7 +1,7 @@
/******************************************************************************* /*******************************************************************************
* *
* Intel Ethernet Controller XL710 Family Linux Driver * Intel Ethernet Controller XL710 Family Linux Driver
* Copyright(c) 2013 - 2014 Intel Corporation. * Copyright(c) 2013 - 2015 Intel Corporation.
* *
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License, * under the terms and conditions of the GNU General Public License,
@ -217,6 +217,13 @@ static const char i40e_gstrings_test[][ETH_GSTRING_LEN] = {
#define I40E_TEST_LEN (sizeof(i40e_gstrings_test) / ETH_GSTRING_LEN) #define I40E_TEST_LEN (sizeof(i40e_gstrings_test) / ETH_GSTRING_LEN)
static const char i40e_priv_flags_strings[][ETH_GSTRING_LEN] = {
"NPAR",
};
#define I40E_PRIV_FLAGS_STR_LEN \
(sizeof(i40e_priv_flags_strings) / ETH_GSTRING_LEN)
/** /**
* i40e_partition_setting_complaint - generic complaint for MFP restriction * i40e_partition_setting_complaint - generic complaint for MFP restriction
* @pf: the PF struct * @pf: the PF struct
@ -228,73 +235,20 @@ static void i40e_partition_setting_complaint(struct i40e_pf *pf)
} }
/** /**
* i40e_get_settings - Get Link Speed and Duplex settings * i40e_get_settings_link_up - Get the Link settings for when link is up
* @hw: hw structure
* @ecmd: ethtool command to fill in
* @netdev: network interface device structure * @netdev: network interface device structure
* @ecmd: ethtool command
* *
* Reports speed/duplex settings based on media_type
**/ **/
static int i40e_get_settings(struct net_device *netdev, static void i40e_get_settings_link_up(struct i40e_hw *hw,
struct ethtool_cmd *ecmd) struct ethtool_cmd *ecmd,
struct net_device *netdev)
{ {
struct i40e_netdev_priv *np = netdev_priv(netdev);
struct i40e_pf *pf = np->vsi->back;
struct i40e_hw *hw = &pf->hw;
struct i40e_link_status *hw_link_info = &hw->phy.link_info; struct i40e_link_status *hw_link_info = &hw->phy.link_info;
bool link_up = hw_link_info->link_info & I40E_AQ_LINK_UP;
u32 link_speed = hw_link_info->link_speed; u32 link_speed = hw_link_info->link_speed;
/* hardware is either in 40G mode or 10G mode /* Initialize supported and advertised settings based on phy settings */
* NOTE: this section initializes supported and advertising
*/
if (!link_up) {
/* link is down and the driver needs to fall back on
* device ID to determine what kinds of info to display,
* it's mostly a guess that may change when link is up
*/
switch (hw->device_id) {
case I40E_DEV_ID_QSFP_A:
case I40E_DEV_ID_QSFP_B:
case I40E_DEV_ID_QSFP_C:
/* pluggable QSFP */
ecmd->supported = SUPPORTED_40000baseSR4_Full |
SUPPORTED_40000baseCR4_Full |
SUPPORTED_40000baseLR4_Full;
ecmd->advertising = ADVERTISED_40000baseSR4_Full |
ADVERTISED_40000baseCR4_Full |
ADVERTISED_40000baseLR4_Full;
break;
case I40E_DEV_ID_KX_B:
/* backplane 40G */
ecmd->supported = SUPPORTED_40000baseKR4_Full;
ecmd->advertising = ADVERTISED_40000baseKR4_Full;
break;
case I40E_DEV_ID_KX_C:
/* backplane 10G */
ecmd->supported = SUPPORTED_10000baseKR_Full;
ecmd->advertising = ADVERTISED_10000baseKR_Full;
break;
case I40E_DEV_ID_10G_BASE_T:
ecmd->supported = SUPPORTED_10000baseT_Full |
SUPPORTED_1000baseT_Full |
SUPPORTED_100baseT_Full;
ecmd->advertising = ADVERTISED_10000baseT_Full |
ADVERTISED_1000baseT_Full |
ADVERTISED_100baseT_Full;
break;
default:
/* all the rest are 10G/1G */
ecmd->supported = SUPPORTED_10000baseT_Full |
SUPPORTED_1000baseT_Full;
ecmd->advertising = ADVERTISED_10000baseT_Full |
ADVERTISED_1000baseT_Full;
break;
}
/* skip phy_type use as it is zero when link is down */
goto no_valid_phy_type;
}
switch (hw_link_info->phy_type) { switch (hw_link_info->phy_type) {
case I40E_PHY_TYPE_40GBASE_CR4: case I40E_PHY_TYPE_40GBASE_CR4:
case I40E_PHY_TYPE_40GBASE_CR4_CU: case I40E_PHY_TYPE_40GBASE_CR4_CU:
@ -303,6 +257,10 @@ static int i40e_get_settings(struct net_device *netdev,
ecmd->advertising = ADVERTISED_Autoneg | ecmd->advertising = ADVERTISED_Autoneg |
ADVERTISED_40000baseCR4_Full; ADVERTISED_40000baseCR4_Full;
break; break;
case I40E_PHY_TYPE_XLAUI:
case I40E_PHY_TYPE_XLPPI:
ecmd->supported = SUPPORTED_40000baseCR4_Full;
break;
case I40E_PHY_TYPE_40GBASE_KR4: case I40E_PHY_TYPE_40GBASE_KR4:
ecmd->supported = SUPPORTED_Autoneg | ecmd->supported = SUPPORTED_Autoneg |
SUPPORTED_40000baseKR4_Full; SUPPORTED_40000baseKR4_Full;
@ -310,8 +268,6 @@ static int i40e_get_settings(struct net_device *netdev,
ADVERTISED_40000baseKR4_Full; ADVERTISED_40000baseKR4_Full;
break; break;
case I40E_PHY_TYPE_40GBASE_SR4: case I40E_PHY_TYPE_40GBASE_SR4:
case I40E_PHY_TYPE_XLPPI:
case I40E_PHY_TYPE_XLAUI:
ecmd->supported = SUPPORTED_40000baseSR4_Full; ecmd->supported = SUPPORTED_40000baseSR4_Full;
break; break;
case I40E_PHY_TYPE_40GBASE_LR4: case I40E_PHY_TYPE_40GBASE_LR4:
@ -333,20 +289,40 @@ static int i40e_get_settings(struct net_device *netdev,
case I40E_PHY_TYPE_10GBASE_LR: case I40E_PHY_TYPE_10GBASE_LR:
case I40E_PHY_TYPE_1000BASE_SX: case I40E_PHY_TYPE_1000BASE_SX:
case I40E_PHY_TYPE_1000BASE_LX: case I40E_PHY_TYPE_1000BASE_LX:
ecmd->supported = SUPPORTED_10000baseT_Full; ecmd->supported = SUPPORTED_10000baseT_Full |
ecmd->supported |= SUPPORTED_1000baseT_Full; SUPPORTED_1000baseT_Full;
if (hw_link_info->requested_speeds & I40E_LINK_SPEED_10GB)
ecmd->advertising |= ADVERTISED_10000baseT_Full;
if (hw_link_info->requested_speeds & I40E_LINK_SPEED_1GB)
ecmd->advertising |= ADVERTISED_1000baseT_Full;
break;
case I40E_PHY_TYPE_1000BASE_KX:
ecmd->supported = SUPPORTED_Autoneg |
SUPPORTED_1000baseKX_Full;
ecmd->advertising = ADVERTISED_Autoneg |
ADVERTISED_1000baseKX_Full;
break; break;
case I40E_PHY_TYPE_10GBASE_CR1_CU:
case I40E_PHY_TYPE_10GBASE_CR1:
case I40E_PHY_TYPE_10GBASE_T: case I40E_PHY_TYPE_10GBASE_T:
case I40E_PHY_TYPE_1000BASE_T:
case I40E_PHY_TYPE_100BASE_TX:
ecmd->supported = SUPPORTED_Autoneg | ecmd->supported = SUPPORTED_Autoneg |
SUPPORTED_10000baseT_Full | SUPPORTED_10000baseT_Full |
SUPPORTED_1000baseT_Full | SUPPORTED_1000baseT_Full |
SUPPORTED_100baseT_Full; SUPPORTED_100baseT_Full;
ecmd->advertising = ADVERTISED_Autoneg;
if (hw_link_info->requested_speeds & I40E_LINK_SPEED_10GB)
ecmd->advertising |= ADVERTISED_10000baseT_Full;
if (hw_link_info->requested_speeds & I40E_LINK_SPEED_1GB)
ecmd->advertising |= ADVERTISED_1000baseT_Full;
if (hw_link_info->requested_speeds & I40E_LINK_SPEED_100MB)
ecmd->advertising |= ADVERTISED_100baseT_Full;
break;
case I40E_PHY_TYPE_10GBASE_CR1_CU:
case I40E_PHY_TYPE_10GBASE_CR1:
ecmd->supported = SUPPORTED_Autoneg |
SUPPORTED_10000baseT_Full;
ecmd->advertising = ADVERTISED_Autoneg | ecmd->advertising = ADVERTISED_Autoneg |
ADVERTISED_10000baseT_Full | ADVERTISED_10000baseT_Full;
ADVERTISED_1000baseT_Full |
ADVERTISED_100baseT_Full;
break; break;
case I40E_PHY_TYPE_XAUI: case I40E_PHY_TYPE_XAUI:
case I40E_PHY_TYPE_XFI: case I40E_PHY_TYPE_XFI:
@ -354,34 +330,14 @@ static int i40e_get_settings(struct net_device *netdev,
case I40E_PHY_TYPE_10GBASE_SFPP_CU: case I40E_PHY_TYPE_10GBASE_SFPP_CU:
ecmd->supported = SUPPORTED_10000baseT_Full; ecmd->supported = SUPPORTED_10000baseT_Full;
break; break;
case I40E_PHY_TYPE_1000BASE_KX:
case I40E_PHY_TYPE_1000BASE_T:
ecmd->supported = SUPPORTED_Autoneg |
SUPPORTED_10000baseT_Full |
SUPPORTED_1000baseT_Full |
SUPPORTED_100baseT_Full;
ecmd->advertising = ADVERTISED_Autoneg |
ADVERTISED_10000baseT_Full |
ADVERTISED_1000baseT_Full |
ADVERTISED_100baseT_Full;
break;
case I40E_PHY_TYPE_100BASE_TX:
ecmd->supported = SUPPORTED_Autoneg |
SUPPORTED_10000baseT_Full |
SUPPORTED_1000baseT_Full |
SUPPORTED_100baseT_Full;
ecmd->advertising = ADVERTISED_Autoneg |
ADVERTISED_10000baseT_Full |
ADVERTISED_1000baseT_Full |
ADVERTISED_100baseT_Full;
break;
case I40E_PHY_TYPE_SGMII: case I40E_PHY_TYPE_SGMII:
ecmd->supported = SUPPORTED_Autoneg | ecmd->supported = SUPPORTED_Autoneg |
SUPPORTED_1000baseT_Full | SUPPORTED_1000baseT_Full |
SUPPORTED_100baseT_Full; SUPPORTED_100baseT_Full;
ecmd->advertising = ADVERTISED_Autoneg | if (hw_link_info->requested_speeds & I40E_LINK_SPEED_1GB)
ADVERTISED_1000baseT_Full | ecmd->advertising |= ADVERTISED_1000baseT_Full;
ADVERTISED_100baseT_Full; if (hw_link_info->requested_speeds & I40E_LINK_SPEED_100MB)
ecmd->advertising |= ADVERTISED_100baseT_Full;
break; break;
default: default:
/* if we got here and link is up something bad is afoot */ /* if we got here and link is up something bad is afoot */
@ -389,8 +345,118 @@ static int i40e_get_settings(struct net_device *netdev,
hw_link_info->phy_type); hw_link_info->phy_type);
} }
no_valid_phy_type: /* Set speed and duplex */
/* this is if autoneg is enabled or disabled */ switch (link_speed) {
case I40E_LINK_SPEED_40GB:
/* need a SPEED_40000 in ethtool.h */
ethtool_cmd_speed_set(ecmd, 40000);
break;
case I40E_LINK_SPEED_10GB:
ethtool_cmd_speed_set(ecmd, SPEED_10000);
break;
case I40E_LINK_SPEED_1GB:
ethtool_cmd_speed_set(ecmd, SPEED_1000);
break;
case I40E_LINK_SPEED_100MB:
ethtool_cmd_speed_set(ecmd, SPEED_100);
break;
default:
break;
}
ecmd->duplex = DUPLEX_FULL;
}
/**
* i40e_get_settings_link_down - Get the Link settings for when link is down
* @hw: hw structure
* @ecmd: ethtool command to fill in
*
* Reports link settings that can be determined when link is down
**/
static void i40e_get_settings_link_down(struct i40e_hw *hw,
struct ethtool_cmd *ecmd)
{
struct i40e_link_status *hw_link_info = &hw->phy.link_info;
/* link is down and the driver needs to fall back on
* device ID to determine what kinds of info to display,
* it's mostly a guess that may change when link is up
*/
switch (hw->device_id) {
case I40E_DEV_ID_QSFP_A:
case I40E_DEV_ID_QSFP_B:
case I40E_DEV_ID_QSFP_C:
/* pluggable QSFP */
ecmd->supported = SUPPORTED_40000baseSR4_Full |
SUPPORTED_40000baseCR4_Full |
SUPPORTED_40000baseLR4_Full;
ecmd->advertising = ADVERTISED_40000baseSR4_Full |
ADVERTISED_40000baseCR4_Full |
ADVERTISED_40000baseLR4_Full;
break;
case I40E_DEV_ID_KX_B:
/* backplane 40G */
ecmd->supported = SUPPORTED_40000baseKR4_Full;
ecmd->advertising = ADVERTISED_40000baseKR4_Full;
break;
case I40E_DEV_ID_KX_C:
/* backplane 10G */
ecmd->supported = SUPPORTED_10000baseKR_Full;
ecmd->advertising = ADVERTISED_10000baseKR_Full;
break;
case I40E_DEV_ID_10G_BASE_T:
ecmd->supported = SUPPORTED_10000baseT_Full |
SUPPORTED_1000baseT_Full |
SUPPORTED_100baseT_Full;
/* Figure out what has been requested */
if (hw_link_info->requested_speeds & I40E_LINK_SPEED_10GB)
ecmd->advertising |= ADVERTISED_10000baseT_Full;
if (hw_link_info->requested_speeds & I40E_LINK_SPEED_1GB)
ecmd->advertising |= ADVERTISED_1000baseT_Full;
if (hw_link_info->requested_speeds & I40E_LINK_SPEED_100MB)
ecmd->advertising |= ADVERTISED_100baseT_Full;
break;
default:
/* all the rest are 10G/1G */
ecmd->supported = SUPPORTED_10000baseT_Full |
SUPPORTED_1000baseT_Full;
/* Figure out what has been requested */
if (hw_link_info->requested_speeds & I40E_LINK_SPEED_10GB)
ecmd->advertising |= ADVERTISED_10000baseT_Full;
if (hw_link_info->requested_speeds & I40E_LINK_SPEED_1GB)
ecmd->advertising |= ADVERTISED_1000baseT_Full;
break;
}
/* With no link speed and duplex are unknown */
ethtool_cmd_speed_set(ecmd, SPEED_UNKNOWN);
ecmd->duplex = DUPLEX_UNKNOWN;
}
/**
* i40e_get_settings - Get Link Speed and Duplex settings
* @netdev: network interface device structure
* @ecmd: ethtool command
*
* Reports speed/duplex settings based on media_type
**/
static int i40e_get_settings(struct net_device *netdev,
struct ethtool_cmd *ecmd)
{
struct i40e_netdev_priv *np = netdev_priv(netdev);
struct i40e_pf *pf = np->vsi->back;
struct i40e_hw *hw = &pf->hw;
struct i40e_link_status *hw_link_info = &hw->phy.link_info;
bool link_up = hw_link_info->link_info & I40E_AQ_LINK_UP;
if (link_up)
i40e_get_settings_link_up(hw, ecmd, netdev);
else
i40e_get_settings_link_down(hw, ecmd);
/* Now set the settings that don't rely on link being up/down */
/* Set autoneg settings */
ecmd->autoneg = ((hw_link_info->an_info & I40E_AQ_AN_COMPLETED) ? ecmd->autoneg = ((hw_link_info->an_info & I40E_AQ_AN_COMPLETED) ?
AUTONEG_ENABLE : AUTONEG_DISABLE); AUTONEG_ENABLE : AUTONEG_DISABLE);
@ -423,11 +489,13 @@ no_valid_phy_type:
break; break;
} }
/* Set transceiver */
ecmd->transceiver = XCVR_EXTERNAL; ecmd->transceiver = XCVR_EXTERNAL;
/* Set flow control settings */
ecmd->supported |= SUPPORTED_Pause; ecmd->supported |= SUPPORTED_Pause;
switch (hw->fc.current_mode) { switch (hw->fc.requested_mode) {
case I40E_FC_FULL: case I40E_FC_FULL:
ecmd->advertising |= ADVERTISED_Pause; ecmd->advertising |= ADVERTISED_Pause;
break; break;
@ -444,30 +512,6 @@ no_valid_phy_type:
break; break;
} }
if (link_up) {
switch (link_speed) {
case I40E_LINK_SPEED_40GB:
/* need a SPEED_40000 in ethtool.h */
ethtool_cmd_speed_set(ecmd, 40000);
break;
case I40E_LINK_SPEED_10GB:
ethtool_cmd_speed_set(ecmd, SPEED_10000);
break;
case I40E_LINK_SPEED_1GB:
ethtool_cmd_speed_set(ecmd, SPEED_1000);
break;
case I40E_LINK_SPEED_100MB:
ethtool_cmd_speed_set(ecmd, SPEED_100);
break;
default:
break;
}
ecmd->duplex = DUPLEX_FULL;
} else {
ethtool_cmd_speed_set(ecmd, SPEED_UNKNOWN);
ecmd->duplex = DUPLEX_UNKNOWN;
}
return 0; return 0;
} }
@ -600,6 +644,8 @@ static int i40e_set_settings(struct net_device *netdev,
config.eeer = abilities.eeer_val; config.eeer = abilities.eeer_val;
config.low_power_ctrl = abilities.d3_lpan; config.low_power_ctrl = abilities.d3_lpan;
/* save the requested speeds */
hw->phy.link_info.requested_speeds = config.link_speed;
/* set link and auto negotiation so changes take effect */ /* set link and auto negotiation so changes take effect */
config.abilities |= I40E_AQ_PHY_ENABLE_ATOMIC_LINK; config.abilities |= I40E_AQ_PHY_ENABLE_ATOMIC_LINK;
/* If link is up put link down */ /* If link is up put link down */
@ -997,6 +1043,7 @@ static void i40e_get_drvinfo(struct net_device *netdev,
sizeof(drvinfo->fw_version)); sizeof(drvinfo->fw_version));
strlcpy(drvinfo->bus_info, pci_name(pf->pdev), strlcpy(drvinfo->bus_info, pci_name(pf->pdev),
sizeof(drvinfo->bus_info)); sizeof(drvinfo->bus_info));
drvinfo->n_priv_flags = I40E_PRIV_FLAGS_STR_LEN;
} }
static void i40e_get_ringparam(struct net_device *netdev, static void i40e_get_ringparam(struct net_device *netdev,
@ -1184,6 +1231,8 @@ static int i40e_get_sset_count(struct net_device *netdev, int sset)
} else { } else {
return I40E_VSI_STATS_LEN(netdev); return I40E_VSI_STATS_LEN(netdev);
} }
case ETH_SS_PRIV_FLAGS:
return I40E_PRIV_FLAGS_STR_LEN;
default: default:
return -EOPNOTSUPP; return -EOPNOTSUPP;
} }
@ -1357,6 +1406,13 @@ static void i40e_get_strings(struct net_device *netdev, u32 stringset,
} }
/* BUG_ON(p - data != I40E_STATS_LEN * ETH_GSTRING_LEN); */ /* BUG_ON(p - data != I40E_STATS_LEN * ETH_GSTRING_LEN); */
break; break;
case ETH_SS_PRIV_FLAGS:
for (i = 0; i < I40E_PRIV_FLAGS_STR_LEN; i++) {
memcpy(data, i40e_priv_flags_strings[i],
ETH_GSTRING_LEN);
data += ETH_GSTRING_LEN;
}
break;
} }
} }
@ -1702,6 +1758,11 @@ static int i40e_get_rss_hash_opts(struct i40e_pf *pf, struct ethtool_rxnfc *cmd)
{ {
cmd->data = 0; cmd->data = 0;
if (pf->vsi[pf->lan_vsi]->rxnfc.data != 0) {
cmd->data = pf->vsi[pf->lan_vsi]->rxnfc.data;
cmd->flow_type = pf->vsi[pf->lan_vsi]->rxnfc.flow_type;
return 0;
}
/* Report default options for RSS on i40e */ /* Report default options for RSS on i40e */
switch (cmd->flow_type) { switch (cmd->flow_type) {
case TCP_V4_FLOW: case TCP_V4_FLOW:
@ -1973,6 +2034,9 @@ static int i40e_set_rss_hash_opt(struct i40e_pf *pf, struct ethtool_rxnfc *nfc)
wr32(hw, I40E_PFQF_HENA(1), (u32)(hena >> 32)); wr32(hw, I40E_PFQF_HENA(1), (u32)(hena >> 32));
i40e_flush(hw); i40e_flush(hw);
/* Save setting for future output/update */
pf->vsi[pf->lan_vsi]->rxnfc = *nfc;
return 0; return 0;
} }
@ -2294,6 +2358,29 @@ static int i40e_set_channels(struct net_device *dev,
return -EINVAL; return -EINVAL;
} }
/**
* i40e_get_priv_flags - report device private flags
* @dev: network interface device structure
*
* The get string set count and the string set should be matched for each
* flag returned. Add new strings for each flag to the i40e_priv_flags_strings
* array.
*
* Returns a u32 bitmap of flags.
**/
u32 i40e_get_priv_flags(struct net_device *dev)
{
struct i40e_netdev_priv *np = netdev_priv(dev);
struct i40e_vsi *vsi = np->vsi;
struct i40e_pf *pf = vsi->back;
u32 ret_flags = 0;
ret_flags |= pf->hw.func_caps.npar_enable ?
I40E_PRIV_FLAGS_NPAR_FLAG : 0;
return ret_flags;
}
static const struct ethtool_ops i40e_ethtool_ops = { static const struct ethtool_ops i40e_ethtool_ops = {
.get_settings = i40e_get_settings, .get_settings = i40e_get_settings,
.set_settings = i40e_set_settings, .set_settings = i40e_set_settings,
@ -2325,6 +2412,7 @@ static const struct ethtool_ops i40e_ethtool_ops = {
.get_channels = i40e_get_channels, .get_channels = i40e_get_channels,
.set_channels = i40e_set_channels, .set_channels = i40e_set_channels,
.get_ts_info = i40e_get_ts_info, .get_ts_info = i40e_get_ts_info,
.get_priv_flags = i40e_get_priv_flags,
}; };
void i40e_set_ethtool_ops(struct net_device *netdev) void i40e_set_ethtool_ops(struct net_device *netdev)

18
drivers/net/ethernet/intel/i40e/i40e_fcoe.c
View File

@ -1,7 +1,7 @@
/******************************************************************************* /*******************************************************************************
* *
* Intel Ethernet Controller XL710 Family Linux Driver * Intel Ethernet Controller XL710 Family Linux Driver
* Copyright(c) 2013 - 2014 Intel Corporation. * Copyright(c) 2013 - 2015 Intel Corporation.
* *
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License, * under the terms and conditions of the GNU General Public License,
@ -385,8 +385,7 @@ int i40e_fcoe_vsi_init(struct i40e_vsi *vsi, struct i40e_vsi_context *ctxt)
ctxt->flags = I40E_AQ_VSI_TYPE_PF; ctxt->flags = I40E_AQ_VSI_TYPE_PF;
/* FCoE VSI would need the following sections */ /* FCoE VSI would need the following sections */
info->valid_sections |= cpu_to_le16(I40E_AQ_VSI_PROP_SWITCH_VALID | info->valid_sections |= cpu_to_le16(I40E_AQ_VSI_PROP_QUEUE_OPT_VALID);
I40E_AQ_VSI_PROP_QUEUE_OPT_VALID);
/* FCoE VSI does not need these sections */ /* FCoE VSI does not need these sections */
info->valid_sections &= cpu_to_le16(~(I40E_AQ_VSI_PROP_SECURITY_VALID | info->valid_sections &= cpu_to_le16(~(I40E_AQ_VSI_PROP_SECURITY_VALID |
@ -395,7 +394,12 @@ int i40e_fcoe_vsi_init(struct i40e_vsi *vsi, struct i40e_vsi_context *ctxt)
I40E_AQ_VSI_PROP_INGRESS_UP_VALID | I40E_AQ_VSI_PROP_INGRESS_UP_VALID |
I40E_AQ_VSI_PROP_EGRESS_UP_VALID)); I40E_AQ_VSI_PROP_EGRESS_UP_VALID));
info->switch_id = cpu_to_le16(I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB); if (i40e_is_vsi_uplink_mode_veb(vsi)) {
info->valid_sections |=
cpu_to_le16(I40E_AQ_VSI_PROP_SWITCH_VALID);
info->switch_id =
cpu_to_le16(I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB);
}
enabled_tc = i40e_get_fcoe_tc_map(pf); enabled_tc = i40e_get_fcoe_tc_map(pf);
i40e_vsi_setup_queue_map(vsi, ctxt, enabled_tc, true); i40e_vsi_setup_queue_map(vsi, ctxt, enabled_tc, true);
@ -1470,6 +1474,11 @@ static const struct net_device_ops i40e_fcoe_netdev_ops = {
.ndo_set_features = i40e_fcoe_set_features, .ndo_set_features = i40e_fcoe_set_features,
}; };
/* fcoe network device type */
static struct device_type fcoe_netdev_type = {
.name = "fcoe",
};
/** /**
* i40e_fcoe_config_netdev - prepares the VSI context for creating a FCoE VSI * i40e_fcoe_config_netdev - prepares the VSI context for creating a FCoE VSI
* @vsi: pointer to the associated VSI struct * @vsi: pointer to the associated VSI struct
@ -1503,6 +1512,7 @@ void i40e_fcoe_config_netdev(struct net_device *netdev, struct i40e_vsi *vsi)
strlcpy(netdev->name, "fcoe%d", IFNAMSIZ-1); strlcpy(netdev->name, "fcoe%d", IFNAMSIZ-1);
netdev->mtu = FCOE_MTU; netdev->mtu = FCOE_MTU;
SET_NETDEV_DEV(netdev, &pf->pdev->dev); SET_NETDEV_DEV(netdev, &pf->pdev->dev);
SET_NETDEV_DEVTYPE(netdev, &fcoe_netdev_type);
/* set different dev_port value 1 for FCoE netdev than the default /* set different dev_port value 1 for FCoE netdev than the default
* zero dev_port value for PF netdev, this helps biosdevname user * zero dev_port value for PF netdev, this helps biosdevname user
* tool to differentiate them correctly while both attached to the * tool to differentiate them correctly while both attached to the

358
drivers/net/ethernet/intel/i40e/i40e_main.c
View File

@ -1,7 +1,7 @@
/******************************************************************************* /*******************************************************************************
* *
* Intel Ethernet Controller XL710 Family Linux Driver * Intel Ethernet Controller XL710 Family Linux Driver
* Copyright(c) 2013 - 2014 Intel Corporation. * Copyright(c) 2013 - 2015 Intel Corporation.
* *
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License, * under the terms and conditions of the GNU General Public License,
@ -39,7 +39,7 @@ static const char i40e_driver_string[] =
#define DRV_VERSION_MAJOR 1 #define DRV_VERSION_MAJOR 1
#define DRV_VERSION_MINOR 2 #define DRV_VERSION_MINOR 2
#define DRV_VERSION_BUILD 8 #define DRV_VERSION_BUILD 9
#define DRV_VERSION __stringify(DRV_VERSION_MAJOR) "." \ #define DRV_VERSION __stringify(DRV_VERSION_MAJOR) "." \
__stringify(DRV_VERSION_MINOR) "." \ __stringify(DRV_VERSION_MINOR) "." \
__stringify(DRV_VERSION_BUILD) DRV_KERN __stringify(DRV_VERSION_BUILD) DRV_KERN
@ -4835,11 +4835,7 @@ exit:
* *
* Returns 0 on success, negative value on failure * Returns 0 on success, negative value on failure
**/ **/
#ifdef I40E_FCOE
int i40e_open(struct net_device *netdev) int i40e_open(struct net_device *netdev)
#else
static int i40e_open(struct net_device *netdev)
#endif
{ {
struct i40e_netdev_priv *np = netdev_priv(netdev); struct i40e_netdev_priv *np = netdev_priv(netdev);
struct i40e_vsi *vsi = np->vsi; struct i40e_vsi *vsi = np->vsi;
@ -5875,6 +5871,26 @@ static void i40e_verify_eeprom(struct i40e_pf *pf)
} }
} }
/**
* i40e_config_bridge_mode - Configure the HW bridge mode
* @veb: pointer to the bridge instance
*
* Configure the loop back mode for the LAN VSI that is downlink to the
* specified HW bridge instance. It is expected this function is called
* when a new HW bridge is instantiated.
**/
static void i40e_config_bridge_mode(struct i40e_veb *veb)
{
struct i40e_pf *pf = veb->pf;
dev_info(&pf->pdev->dev, "enabling bridge mode: %s\n",
veb->bridge_mode == BRIDGE_MODE_VEPA ? "VEPA" : "VEB");
if (veb->bridge_mode & BRIDGE_MODE_VEPA)
i40e_disable_pf_switch_lb(pf);
else
i40e_enable_pf_switch_lb(pf);
}
/** /**
* i40e_reconstitute_veb - rebuild the VEB and anything connected to it * i40e_reconstitute_veb - rebuild the VEB and anything connected to it
* @veb: pointer to the VEB instance * @veb: pointer to the VEB instance
@ -5921,8 +5937,7 @@ static int i40e_reconstitute_veb(struct i40e_veb *veb)
if (ret) if (ret)
goto end_reconstitute; goto end_reconstitute;
/* Enable LB mode for the main VSI now that it is on a VEB */ i40e_config_bridge_mode(veb);
i40e_enable_pf_switch_lb(pf);
/* create the remaining VSIs attached to this VEB */ /* create the remaining VSIs attached to this VEB */
for (v = 0; v < pf->num_alloc_vsi; v++) { for (v = 0; v < pf->num_alloc_vsi; v++) {
@ -7253,6 +7268,128 @@ int i40e_reconfig_rss_queues(struct i40e_pf *pf, int queue_count)
return pf->rss_size; return pf->rss_size;
} }
/**
* i40e_get_npar_bw_setting - Retrieve BW settings for this PF partition
* @pf: board private structure
**/
i40e_status i40e_get_npar_bw_setting(struct i40e_pf *pf)
{
i40e_status status;
bool min_valid, max_valid;
u32 max_bw, min_bw;
status = i40e_read_bw_from_alt_ram(&pf->hw, &max_bw, &min_bw,
&min_valid, &max_valid);
if (!status) {
if (min_valid)
pf->npar_min_bw = min_bw;
if (max_valid)
pf->npar_max_bw = max_bw;
}
return status;
}
/**
* i40e_set_npar_bw_setting - Set BW settings for this PF partition
* @pf: board private structure
**/
i40e_status i40e_set_npar_bw_setting(struct i40e_pf *pf)
{
struct i40e_aqc_configure_partition_bw_data bw_data;
i40e_status status;
/* Set the valid bit for this pf */
bw_data.pf_valid_bits = cpu_to_le16(1 << pf->hw.pf_id);
bw_data.max_bw[pf->hw.pf_id] = pf->npar_max_bw & I40E_ALT_BW_VALUE_MASK;
bw_data.min_bw[pf->hw.pf_id] = pf->npar_min_bw & I40E_ALT_BW_VALUE_MASK;
/* Set the new bandwidths */
status = i40e_aq_configure_partition_bw(&pf->hw, &bw_data, NULL);
return status;
}
/**
* i40e_commit_npar_bw_setting - Commit BW settings for this PF partition
* @pf: board private structure
**/
i40e_status i40e_commit_npar_bw_setting(struct i40e_pf *pf)
{
/* Commit temporary BW setting to permanent NVM image */
enum i40e_admin_queue_err last_aq_status;
i40e_status ret;
u16 nvm_word;
if (pf->hw.partition_id != 1) {
dev_info(&pf->pdev->dev,
"Commit BW only works on partition 1! This is partition %d",
pf->hw.partition_id);
ret = I40E_NOT_SUPPORTED;
goto bw_commit_out;
}
/* Acquire NVM for read access */
ret = i40e_acquire_nvm(&pf->hw, I40E_RESOURCE_READ);
last_aq_status = pf->hw.aq.asq_last_status;
if (ret) {
dev_info(&pf->pdev->dev,
"Cannot acquire NVM for read access, err %d: aq_err %d\n",
ret, last_aq_status);
goto bw_commit_out;
}
/* Read word 0x10 of NVM - SW compatibility word 1 */
ret = i40e_aq_read_nvm(&pf->hw,
I40E_SR_NVM_CONTROL_WORD,
0x10, sizeof(nvm_word), &nvm_word,
false, NULL);
/* Save off last admin queue command status before releasing
* the NVM
*/
last_aq_status = pf->hw.aq.asq_last_status;
i40e_release_nvm(&pf->hw);
if (ret) {
dev_info(&pf->pdev->dev, "NVM read error, err %d aq_err %d\n",
ret, last_aq_status);
goto bw_commit_out;
}
/* Wait a bit for NVM release to complete */
msleep(50);
/* Acquire NVM for write access */
ret = i40e_acquire_nvm(&pf->hw, I40E_RESOURCE_WRITE);
last_aq_status = pf->hw.aq.asq_last_status;
if (ret) {
dev_info(&pf->pdev->dev,
"Cannot acquire NVM for write access, err %d: aq_err %d\n",
ret, last_aq_status);
goto bw_commit_out;
}
/* Write it back out unchanged to initiate update NVM,
* which will force a write of the shadow (alt) RAM to
* the NVM - thus storing the bandwidth values permanently.
*/
ret = i40e_aq_update_nvm(&pf->hw,
I40E_SR_NVM_CONTROL_WORD,
0x10, sizeof(nvm_word),
&nvm_word, true, NULL);
/* Save off last admin queue command status before releasing
* the NVM
*/
last_aq_status = pf->hw.aq.asq_last_status;
i40e_release_nvm(&pf->hw);
if (ret)
dev_info(&pf->pdev->dev,
"BW settings NOT SAVED, err %d aq_err %d\n",
ret, last_aq_status);
bw_commit_out:
return ret;
}
/** /**
* i40e_sw_init - Initialize general software structures (struct i40e_pf) * i40e_sw_init - Initialize general software structures (struct i40e_pf)
* @pf: board private structure to initialize * @pf: board private structure to initialize
@ -7279,8 +7416,12 @@ static int i40e_sw_init(struct i40e_pf *pf)
/* Set default capability flags */ /* Set default capability flags */
pf->flags = I40E_FLAG_RX_CSUM_ENABLED | pf->flags = I40E_FLAG_RX_CSUM_ENABLED |
I40E_FLAG_MSI_ENABLED | I40E_FLAG_MSI_ENABLED |
I40E_FLAG_MSIX_ENABLED | I40E_FLAG_MSIX_ENABLED;
I40E_FLAG_RX_PS_ENABLED;
if (iommu_present(&pci_bus_type))
pf->flags |= I40E_FLAG_RX_PS_ENABLED;
else
pf->flags |= I40E_FLAG_RX_1BUF_ENABLED;
/* Set default ITR */ /* Set default ITR */
pf->rx_itr_default = I40E_ITR_DYNAMIC | I40E_ITR_RX_DEF; pf->rx_itr_default = I40E_ITR_DYNAMIC | I40E_ITR_RX_DEF;
@ -7302,6 +7443,13 @@ static int i40e_sw_init(struct i40e_pf *pf)
if (pf->hw.func_caps.npar_enable || pf->hw.func_caps.mfp_mode_1) { if (pf->hw.func_caps.npar_enable || pf->hw.func_caps.mfp_mode_1) {
pf->flags |= I40E_FLAG_MFP_ENABLED; pf->flags |= I40E_FLAG_MFP_ENABLED;
dev_info(&pf->pdev->dev, "MFP mode Enabled\n"); dev_info(&pf->pdev->dev, "MFP mode Enabled\n");
if (i40e_get_npar_bw_setting(pf))
dev_warn(&pf->pdev->dev,
"Could not get NPAR bw settings\n");
else
dev_info(&pf->pdev->dev,
"Min BW = %8.8x, Max BW = %8.8x\n",
pf->npar_min_bw, pf->npar_max_bw);
} }
/* FW/NVM is not yet fixed in this regard */ /* FW/NVM is not yet fixed in this regard */
@ -7608,7 +7756,119 @@ static int i40e_ndo_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
return err; return err;
} }
static const struct net_device_ops i40e_netdev_ops = { #ifdef HAVE_BRIDGE_ATTRIBS
/**
* i40e_ndo_bridge_setlink - Set the hardware bridge mode
* @dev: the netdev being configured
* @nlh: RTNL message
*
* Inserts a new hardware bridge if not already created and
* enables the bridging mode requested (VEB or VEPA). If the
* hardware bridge has already been inserted and the request
* is to change the mode then that requires a PF reset to
* allow rebuild of the components with required hardware
* bridge mode enabled.
**/
static int i40e_ndo_bridge_setlink(struct net_device *dev,
struct nlmsghdr *nlh)
{
struct i40e_netdev_priv *np = netdev_priv(dev);
struct i40e_vsi *vsi = np->vsi;
struct i40e_pf *pf = vsi->back;
struct i40e_veb *veb = NULL;
struct nlattr *attr, *br_spec;
int i, rem;
/* Only for PF VSI for now */
if (vsi->seid != pf->vsi[pf->lan_vsi]->seid)
return -EOPNOTSUPP;
/* Find the HW bridge for PF VSI */
for (i = 0; i < I40E_MAX_VEB && !veb; i++) {
if (pf->veb[i] && pf->veb[i]->seid == vsi->uplink_seid)
veb = pf->veb[i];
}
br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
nla_for_each_nested(attr, br_spec, rem) {
__u16 mode;
if (nla_type(attr) != IFLA_BRIDGE_MODE)
continue;
mode = nla_get_u16(attr);
if ((mode != BRIDGE_MODE_VEPA) &&
(mode != BRIDGE_MODE_VEB))
return -EINVAL;
/* Insert a new HW bridge */
if (!veb) {
veb = i40e_veb_setup(pf, 0, vsi->uplink_seid, vsi->seid,
vsi->tc_config.enabled_tc);
if (veb) {
veb->bridge_mode = mode;
i40e_config_bridge_mode(veb);
} else {
/* No Bridge HW offload available */
return -ENOENT;
}
break;
} else if (mode != veb->bridge_mode) {
/* Existing HW bridge but different mode needs reset */
veb->bridge_mode = mode;
i40e_do_reset(pf, (1 << __I40E_PF_RESET_REQUESTED));
break;
}
}
return 0;
}
/**
* i40e_ndo_bridge_getlink - Get the hardware bridge mode
* @skb: skb buff
* @pid: process id
* @seq: RTNL message seq #
* @dev: the netdev being configured
* @filter_mask: unused
*
* Return the mode in which the hardware bridge is operating in
* i.e VEB or VEPA.
**/
#ifdef HAVE_BRIDGE_FILTER
static int i40e_ndo_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
struct net_device *dev,
u32 __always_unused filter_mask)
#else
static int i40e_ndo_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
struct net_device *dev)
#endif /* HAVE_BRIDGE_FILTER */
{
struct i40e_netdev_priv *np = netdev_priv(dev);
struct i40e_vsi *vsi = np->vsi;
struct i40e_pf *pf = vsi->back;
struct i40e_veb *veb = NULL;
int i;
/* Only for PF VSI for now */
if (vsi->seid != pf->vsi[pf->lan_vsi]->seid)
return -EOPNOTSUPP;
/* Find the HW bridge for the PF VSI */
for (i = 0; i < I40E_MAX_VEB && !veb; i++) {
if (pf->veb[i] && pf->veb[i]->seid == vsi->uplink_seid)
veb = pf->veb[i];
}
if (!veb)
return 0;
return ndo_dflt_bridge_getlink(skb, pid, seq, dev, veb->bridge_mode);
}
#endif /* HAVE_BRIDGE_ATTRIBS */
const struct net_device_ops i40e_netdev_ops = {
.ndo_open = i40e_open, .ndo_open = i40e_open,
.ndo_stop = i40e_close, .ndo_stop = i40e_close,
.ndo_start_xmit = i40e_lan_xmit_frame, .ndo_start_xmit = i40e_lan_xmit_frame,
@ -7642,6 +7902,10 @@ static const struct net_device_ops i40e_netdev_ops = {
#endif #endif
.ndo_get_phys_port_id = i40e_get_phys_port_id, .ndo_get_phys_port_id = i40e_get_phys_port_id,
.ndo_fdb_add = i40e_ndo_fdb_add, .ndo_fdb_add = i40e_ndo_fdb_add,
#ifdef HAVE_BRIDGE_ATTRIBS
.ndo_bridge_getlink = i40e_ndo_bridge_getlink,
.ndo_bridge_setlink = i40e_ndo_bridge_setlink,
#endif /* HAVE_BRIDGE_ATTRIBS */
}; };
/** /**
@ -7753,6 +8017,30 @@ static void i40e_vsi_delete(struct i40e_vsi *vsi)
i40e_aq_delete_element(&vsi->back->hw, vsi->seid, NULL); i40e_aq_delete_element(&vsi->back->hw, vsi->seid, NULL);
} }
/**
* i40e_is_vsi_uplink_mode_veb - Check if the VSI's uplink bridge mode is VEB
* @vsi: the VSI being queried
*
* Returns 1 if HW bridge mode is VEB and return 0 in case of VEPA mode
**/
int i40e_is_vsi_uplink_mode_veb(struct i40e_vsi *vsi)
{
struct i40e_veb *veb;
struct i40e_pf *pf = vsi->back;
/* Uplink is not a bridge so default to VEB */
if (vsi->veb_idx == I40E_NO_VEB)
return 1;
veb = pf->veb[vsi->veb_idx];
/* Uplink is a bridge in VEPA mode */
if (veb && (veb->bridge_mode & BRIDGE_MODE_VEPA))
return 0;
/* Uplink is a bridge in VEB mode */
return 1;
}
/** /**
* i40e_add_vsi - Add a VSI to the switch * i40e_add_vsi - Add a VSI to the switch
* @vsi: the VSI being configured * @vsi: the VSI being configured
@ -7840,10 +8128,12 @@ static int i40e_add_vsi(struct i40e_vsi *vsi)
ctxt.uplink_seid = vsi->uplink_seid; ctxt.uplink_seid = vsi->uplink_seid;
ctxt.connection_type = I40E_AQ_VSI_CONN_TYPE_NORMAL; ctxt.connection_type = I40E_AQ_VSI_CONN_TYPE_NORMAL;
ctxt.flags = I40E_AQ_VSI_TYPE_PF; ctxt.flags = I40E_AQ_VSI_TYPE_PF;
ctxt.info.valid_sections |= if (i40e_is_vsi_uplink_mode_veb(vsi)) {
ctxt.info.valid_sections |=
cpu_to_le16(I40E_AQ_VSI_PROP_SWITCH_VALID); cpu_to_le16(I40E_AQ_VSI_PROP_SWITCH_VALID);
ctxt.info.switch_id = ctxt.info.switch_id =
cpu_to_le16(I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB); cpu_to_le16(I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB);
}
i40e_vsi_setup_queue_map(vsi, &ctxt, enabled_tc, true); i40e_vsi_setup_queue_map(vsi, &ctxt, enabled_tc, true);
break; break;
@ -7854,13 +8144,15 @@ static int i40e_add_vsi(struct i40e_vsi *vsi)
ctxt.connection_type = I40E_AQ_VSI_CONN_TYPE_NORMAL; ctxt.connection_type = I40E_AQ_VSI_CONN_TYPE_NORMAL;
ctxt.flags = I40E_AQ_VSI_TYPE_VMDQ2; ctxt.flags = I40E_AQ_VSI_TYPE_VMDQ2;
ctxt.info.valid_sections |= cpu_to_le16(I40E_AQ_VSI_PROP_SWITCH_VALID);
/* This VSI is connected to VEB so the switch_id /* This VSI is connected to VEB so the switch_id
* should be set to zero by default. * should be set to zero by default.
*/ */
ctxt.info.switch_id = 0; if (i40e_is_vsi_uplink_mode_veb(vsi)) {
ctxt.info.switch_id |= cpu_to_le16(I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB); ctxt.info.valid_sections |=
cpu_to_le16(I40E_AQ_VSI_PROP_SWITCH_VALID);
ctxt.info.switch_id =
cpu_to_le16(I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB);
}
/* Setup the VSI tx/rx queue map for TC0 only for now */ /* Setup the VSI tx/rx queue map for TC0 only for now */
i40e_vsi_setup_queue_map(vsi, &ctxt, enabled_tc, true); i40e_vsi_setup_queue_map(vsi, &ctxt, enabled_tc, true);
@ -7873,12 +8165,15 @@ static int i40e_add_vsi(struct i40e_vsi *vsi)
ctxt.connection_type = I40E_AQ_VSI_CONN_TYPE_NORMAL; ctxt.connection_type = I40E_AQ_VSI_CONN_TYPE_NORMAL;
ctxt.flags = I40E_AQ_VSI_TYPE_VF; ctxt.flags = I40E_AQ_VSI_TYPE_VF;
ctxt.info.valid_sections |= cpu_to_le16(I40E_AQ_VSI_PROP_SWITCH_VALID);
/* This VSI is connected to VEB so the switch_id /* This VSI is connected to VEB so the switch_id
* should be set to zero by default. * should be set to zero by default.
*/ */
ctxt.info.switch_id = cpu_to_le16(I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB); if (i40e_is_vsi_uplink_mode_veb(vsi)) {
ctxt.info.valid_sections |=
cpu_to_le16(I40E_AQ_VSI_PROP_SWITCH_VALID);
ctxt.info.switch_id =
cpu_to_le16(I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB);
}
ctxt.info.valid_sections |= cpu_to_le16(I40E_AQ_VSI_PROP_VLAN_VALID); ctxt.info.valid_sections |= cpu_to_le16(I40E_AQ_VSI_PROP_VLAN_VALID);
ctxt.info.port_vlan_flags |= I40E_AQ_VSI_PVLAN_MODE_ALL; ctxt.info.port_vlan_flags |= I40E_AQ_VSI_PVLAN_MODE_ALL;
@ -8236,7 +8531,7 @@ struct i40e_vsi *i40e_vsi_setup(struct i40e_pf *pf, u8 type,
__func__); __func__);
return NULL; return NULL;
} }
i40e_enable_pf_switch_lb(pf); i40e_config_bridge_mode(veb);
} }
for (i = 0; i < I40E_MAX_VEB && !veb; i++) { for (i = 0; i < I40E_MAX_VEB && !veb; i++) {
if (pf->veb[i] && pf->veb[i]->seid == vsi->uplink_seid) if (pf->veb[i] && pf->veb[i]->seid == vsi->uplink_seid)
@ -9061,8 +9356,10 @@ static void i40e_print_features(struct i40e_pf *pf)
#ifdef CONFIG_PCI_IOV #ifdef CONFIG_PCI_IOV
buf += sprintf(buf, "VFs: %d ", pf->num_req_vfs); buf += sprintf(buf, "VFs: %d ", pf->num_req_vfs);
#endif #endif
buf += sprintf(buf, "VSIs: %d QP: %d ", pf->hw.func_caps.num_vsis, buf += sprintf(buf, "VSIs: %d QP: %d RX: %s ",
pf->vsi[pf->lan_vsi]->num_queue_pairs); pf->hw.func_caps.num_vsis,
pf->vsi[pf->lan_vsi]->num_queue_pairs,
pf->flags & I40E_FLAG_RX_PS_ENABLED ? "PS" : "1BUF");
if (pf->flags & I40E_FLAG_RSS_ENABLED) if (pf->flags & I40E_FLAG_RSS_ENABLED)
buf += sprintf(buf, "RSS "); buf += sprintf(buf, "RSS ");
@ -9099,6 +9396,7 @@ static void i40e_print_features(struct i40e_pf *pf)
**/ **/
static int i40e_probe(struct pci_dev *pdev, const struct pci_device_id *ent) static int i40e_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{ {
struct i40e_aq_get_phy_abilities_resp abilities;
struct i40e_pf *pf; struct i40e_pf *pf;
struct i40e_hw *hw; struct i40e_hw *hw;
static u16 pfs_found; static u16 pfs_found;
@ -9454,6 +9752,13 @@ static int i40e_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
dev_warn(&pdev->dev, "Please move the device to a different PCI-e link with more lanes and/or higher transfer rate.\n"); dev_warn(&pdev->dev, "Please move the device to a different PCI-e link with more lanes and/or higher transfer rate.\n");
} }
/* get the requested speeds from the fw */
err = i40e_aq_get_phy_capabilities(hw, false, false, &abilities, NULL);
if (err)
dev_info(&pf->pdev->dev, "get phy abilities failed, aq_err %d, advertised speed settings may not be correct\n",
err);
pf->hw.phy.link_info.requested_speeds = abilities.link_speed;
/* print a string summarizing features */ /* print a string summarizing features */
i40e_print_features(pf); i40e_print_features(pf);
@ -9802,6 +10107,10 @@ static int __init i40e_init_module(void)
pr_info("%s: %s - version %s\n", i40e_driver_name, pr_info("%s: %s - version %s\n", i40e_driver_name,
i40e_driver_string, i40e_driver_version_str); i40e_driver_string, i40e_driver_version_str);
pr_info("%s: %s\n", i40e_driver_name, i40e_copyright); pr_info("%s: %s\n", i40e_driver_name, i40e_copyright);
#if IS_ENABLED(CONFIG_CONFIGFS_FS)
i40e_configfs_init();
#endif /* CONFIG_CONFIGFS_FS */
i40e_dbg_init(); i40e_dbg_init();
return pci_register_driver(&i40e_driver); return pci_register_driver(&i40e_driver);
} }
@ -9817,5 +10126,8 @@ static void __exit i40e_exit_module(void)
{ {
pci_unregister_driver(&i40e_driver); pci_unregister_driver(&i40e_driver);
i40e_dbg_exit(); i40e_dbg_exit();
#if IS_ENABLED(CONFIG_CONFIGFS_FS)
i40e_configfs_exit();
#endif /* CONFIG_CONFIGFS_FS */
} }
module_exit(i40e_exit_module); module_exit(i40e_exit_module);

8
drivers/net/ethernet/intel/i40e/i40e_prototype.h
View File

@ -1,7 +1,7 @@
/******************************************************************************* /*******************************************************************************
* *
* Intel Ethernet Controller XL710 Family Linux Driver * Intel Ethernet Controller XL710 Family Linux Driver
* Copyright(c) 2013 - 2014 Intel Corporation. * Copyright(c) 2013 - 2015 Intel Corporation.
* *
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License, * under the terms and conditions of the GNU General Public License,
@ -246,6 +246,12 @@ void i40e_clear_hw(struct i40e_hw *hw);
void i40e_clear_pxe_mode(struct i40e_hw *hw); void i40e_clear_pxe_mode(struct i40e_hw *hw);
bool i40e_get_link_status(struct i40e_hw *hw); bool i40e_get_link_status(struct i40e_hw *hw);
i40e_status i40e_get_mac_addr(struct i40e_hw *hw, u8 *mac_addr); i40e_status i40e_get_mac_addr(struct i40e_hw *hw, u8 *mac_addr);
i40e_status i40e_read_bw_from_alt_ram(struct i40e_hw *hw,
u32 *max_bw, u32 *min_bw, bool *min_valid,
bool *max_valid);
i40e_status i40e_aq_configure_partition_bw(struct i40e_hw *hw,
struct i40e_aqc_configure_partition_bw_data *bw_data,
struct i40e_asq_cmd_details *cmd_details);
i40e_status i40e_get_port_mac_addr(struct i40e_hw *hw, u8 *mac_addr); i40e_status i40e_get_port_mac_addr(struct i40e_hw *hw, u8 *mac_addr);
i40e_status i40e_read_pba_string(struct i40e_hw *hw, u8 *pba_num, i40e_status i40e_read_pba_string(struct i40e_hw *hw, u8 *pba_num,
u32 pba_num_size); u32 pba_num_size);

16
drivers/net/ethernet/intel/i40e/i40e_type.h
View File

@ -1,7 +1,7 @@
/******************************************************************************* /*******************************************************************************
* *
* Intel Ethernet Controller XL710 Family Linux Driver * Intel Ethernet Controller XL710 Family Linux Driver
* Copyright(c) 2013 - 2014 Intel Corporation. * Copyright(c) 2013 - 2015 Intel Corporation.
* *
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License, * under the terms and conditions of the GNU General Public License,
@ -180,6 +180,7 @@ struct i40e_link_status {
u16 max_frame_size; u16 max_frame_size;
bool crc_enable; bool crc_enable;
u8 pacing; u8 pacing;
u8 requested_speeds;
}; };
struct i40e_phy_info { struct i40e_phy_info {
@ -1400,6 +1401,19 @@ struct i40e_lldp_variables {
u16 crc8; u16 crc8;
}; };
/* Offsets into Alternate Ram */
#define I40E_ALT_STRUCT_FIRST_PF_OFFSET 0 /* in dwords */
#define I40E_ALT_STRUCT_DWORDS_PER_PF 64 /* in dwords */
#define I40E_ALT_STRUCT_OUTER_VLAN_TAG_OFFSET 0xD /* in dwords */
#define I40E_ALT_STRUCT_USER_PRIORITY_OFFSET 0xC /* in dwords */
#define I40E_ALT_STRUCT_MIN_BW_OFFSET 0xE /* in dwords */
#define I40E_ALT_STRUCT_MAX_BW_OFFSET 0xF /* in dwords */
/* Alternate Ram Bandwidth Masks */
#define I40E_ALT_BW_VALUE_MASK 0xFF
#define I40E_ALT_BW_RELATIVE_MASK 0x40000000
#define I40E_ALT_BW_VALID_MASK 0x80000000
/* RSS Hash Table Size */ /* RSS Hash Table Size */
#define I40E_PFQF_CTL_0_HASHLUTSIZE_512 0x00010000 #define I40E_PFQF_CTL_0_HASHLUTSIZE_512 0x00010000
#endif /* _I40E_TYPE_H_ */ #endif /* _I40E_TYPE_H_ */

5
drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c
View File

@ -1,7 +1,7 @@
/******************************************************************************* /*******************************************************************************
* *
* Intel Ethernet Controller XL710 Family Linux Driver * Intel Ethernet Controller XL710 Family Linux Driver
* Copyright(c) 2013 - 2014 Intel Corporation. * Copyright(c) 2013 - 2015 Intel Corporation.
* *
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License, * under the terms and conditions of the GNU General Public License,
@ -752,7 +752,7 @@ void i40e_enable_pf_switch_lb(struct i40e_pf *pf)
* *
* disable switch loop back or die - no point in a return value * disable switch loop back or die - no point in a return value
**/ **/
static void i40e_disable_pf_switch_lb(struct i40e_pf *pf) void i40e_disable_pf_switch_lb(struct i40e_pf *pf)
{ {
struct i40e_vsi *vsi = pf->vsi[pf->lan_vsi]; struct i40e_vsi *vsi = pf->vsi[pf->lan_vsi];
struct i40e_vsi_context ctxt; struct i40e_vsi_context ctxt;
@ -891,7 +891,6 @@ int i40e_alloc_vfs(struct i40e_pf *pf, u16 num_alloc_vfs)
} }
pf->num_alloc_vfs = num_alloc_vfs; pf->num_alloc_vfs = num_alloc_vfs;
i40e_enable_pf_switch_lb(pf);
err_alloc: err_alloc:
if (ret) if (ret)
i40e_free_vfs(pf); i40e_free_vfs(pf);

3
drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.h
View File

@ -1,7 +1,7 @@
/******************************************************************************* /*******************************************************************************
* *
* Intel Ethernet Controller XL710 Family Linux Driver * Intel Ethernet Controller XL710 Family Linux Driver
* Copyright(c) 2013 - 2014 Intel Corporation. * Copyright(c) 2013 - 2015 Intel Corporation.
* *
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License, * under the terms and conditions of the GNU General Public License,
@ -127,5 +127,6 @@ int i40e_ndo_set_vf_spoofchk(struct net_device *netdev, int vf_id, bool enable);
void i40e_vc_notify_link_state(struct i40e_pf *pf); void i40e_vc_notify_link_state(struct i40e_pf *pf);
void i40e_vc_notify_reset(struct i40e_pf *pf); void i40e_vc_notify_reset(struct i40e_pf *pf);
void i40e_enable_pf_switch_lb(struct i40e_pf *pf); void i40e_enable_pf_switch_lb(struct i40e_pf *pf);
void i40e_disable_pf_switch_lb(struct i40e_pf *pf);
#endif /* _I40E_VIRTCHNL_PF_H_ */ #endif /* _I40E_VIRTCHNL_PF_H_ */

29
drivers/net/ethernet/intel/i40evf/i40e_common.c
View File

@ -94,16 +94,19 @@ void i40evf_debug_aq(struct i40e_hw *hw, enum i40e_debug_mask mask, void *desc,
i40e_debug(hw, mask, i40e_debug(hw, mask,
"AQ CMD: opcode 0x%04X, flags 0x%04X, datalen 0x%04X, retval 0x%04X\n", "AQ CMD: opcode 0x%04X, flags 0x%04X, datalen 0x%04X, retval 0x%04X\n",
aq_desc->opcode, aq_desc->flags, aq_desc->datalen, le16_to_cpu(aq_desc->opcode),
aq_desc->retval); le16_to_cpu(aq_desc->flags),
le16_to_cpu(aq_desc->datalen),
le16_to_cpu(aq_desc->retval));
i40e_debug(hw, mask, "\tcookie (h,l) 0x%08X 0x%08X\n", i40e_debug(hw, mask, "\tcookie (h,l) 0x%08X 0x%08X\n",
aq_desc->cookie_high, aq_desc->cookie_low); le32_to_cpu(aq_desc->cookie_high),
le32_to_cpu(aq_desc->cookie_low));
i40e_debug(hw, mask, "\tparam (0,1) 0x%08X 0x%08X\n", i40e_debug(hw, mask, "\tparam (0,1) 0x%08X 0x%08X\n",
aq_desc->params.internal.param0, le32_to_cpu(aq_desc->params.internal.param0),
aq_desc->params.internal.param1); le32_to_cpu(aq_desc->params.internal.param1));
i40e_debug(hw, mask, "\taddr (h,l) 0x%08X 0x%08X\n", i40e_debug(hw, mask, "\taddr (h,l) 0x%08X 0x%08X\n",
aq_desc->params.external.addr_high, le32_to_cpu(aq_desc->params.external.addr_high),
aq_desc->params.external.addr_low); le32_to_cpu(aq_desc->params.external.addr_low));
if ((buffer != NULL) && (aq_desc->datalen != 0)) { if ((buffer != NULL) && (aq_desc->datalen != 0)) {
memset(data, 0, sizeof(data)); memset(data, 0, sizeof(data));
@ -116,15 +119,19 @@ void i40evf_debug_aq(struct i40e_hw *hw, enum i40e_debug_mask mask, void *desc,
if ((i % 16) == 15) { if ((i % 16) == 15) {
i40e_debug(hw, mask, i40e_debug(hw, mask,
"\t0x%04X %08X %08X %08X %08X\n", "\t0x%04X %08X %08X %08X %08X\n",
i - 15, data[0], data[1], data[2], i - 15, le32_to_cpu(data[0]),
data[3]); le32_to_cpu(data[1]),
le32_to_cpu(data[2]),
le32_to_cpu(data[3]));
memset(data, 0, sizeof(data)); memset(data, 0, sizeof(data));
} }
} }
if ((i % 16) != 0) if ((i % 16) != 0)
i40e_debug(hw, mask, "\t0x%04X %08X %08X %08X %08X\n", i40e_debug(hw, mask, "\t0x%04X %08X %08X %08X %08X\n",
i - (i % 16), data[0], data[1], data[2], i - (i % 16), le32_to_cpu(data[0]),
data[3]); le32_to_cpu(data[1]),
le32_to_cpu(data[2]),
le32_to_cpu(data[3]));
} }
} }

3
drivers/net/ethernet/intel/i40evf/i40e_type.h
View File

@ -1,7 +1,7 @@
/******************************************************************************* /*******************************************************************************
* *
* Intel Ethernet Controller XL710 Family Linux Virtual Function Driver * Intel Ethernet Controller XL710 Family Linux Virtual Function Driver
* Copyright(c) 2013 - 2014 Intel Corporation. * Copyright(c) 2013 - 2015 Intel Corporation.
* *
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License, * under the terms and conditions of the GNU General Public License,
@ -180,6 +180,7 @@ struct i40e_link_status {
u16 max_frame_size; u16 max_frame_size;
bool crc_enable; bool crc_enable;
u8 pacing; u8 pacing;
u8 requested_speeds;
}; };
struct i40e_phy_info { struct i40e_phy_info {

6
drivers/net/ethernet/intel/i40evf/i40evf_ethtool.c
View File

@ -1,7 +1,7 @@
/******************************************************************************* /*******************************************************************************
* *
* Intel Ethernet Controller XL710 Family Linux Virtual Function Driver * Intel Ethernet Controller XL710 Family Linux Virtual Function Driver
* Copyright(c) 2013 - 2014 Intel Corporation. * Copyright(c) 2013 - 2015 Intel Corporation.
* *
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License, * under the terms and conditions of the GNU General Public License,
@ -180,7 +180,7 @@ static u32 i40evf_get_msglevel(struct net_device *netdev)
} }
/** /**
* i40evf_get_msglevel - Set debug message level * i40evf_set_msglevel - Set debug message level
* @netdev: network interface device structure * @netdev: network interface device structure
* @data: message level * @data: message level
* *
@ -191,6 +191,8 @@ static void i40evf_set_msglevel(struct net_device *netdev, u32 data)
{ {
struct i40evf_adapter *adapter = netdev_priv(netdev); struct i40evf_adapter *adapter = netdev_priv(netdev);
if (I40E_DEBUG_USER & data)
adapter->hw.debug_mask = data;
adapter->msg_enable = data; adapter->msg_enable = data;
} }

7
drivers/net/ethernet/intel/i40evf/i40evf_main.c
View File

@ -1,7 +1,7 @@
/******************************************************************************* /*******************************************************************************
* *
* Intel Ethernet Controller XL710 Family Linux Virtual Function Driver * Intel Ethernet Controller XL710 Family Linux Virtual Function Driver
* Copyright(c) 2013 - 2014 Intel Corporation. * Copyright(c) 2013 - 2015 Intel Corporation.
* *
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License, * under the terms and conditions of the GNU General Public License,
@ -36,7 +36,7 @@ char i40evf_driver_name[] = "i40evf";
static const char i40evf_driver_string[] = static const char i40evf_driver_string[] =
"Intel(R) XL710/X710 Virtual Function Network Driver"; "Intel(R) XL710/X710 Virtual Function Network Driver";
#define DRV_VERSION "1.2.2" #define DRV_VERSION "1.2.3"
const char i40evf_driver_version[] = DRV_VERSION; const char i40evf_driver_version[] = DRV_VERSION;
static const char i40evf_copyright[] = static const char i40evf_copyright[] =
"Copyright (c) 2013 - 2014 Intel Corporation."; "Copyright (c) 2013 - 2014 Intel Corporation.";
@ -524,7 +524,8 @@ static int i40evf_request_misc_irq(struct i40evf_adapter *adapter)
int err; int err;
snprintf(adapter->misc_vector_name, snprintf(adapter->misc_vector_name,
sizeof(adapter->misc_vector_name) - 1, "i40evf:mbx"); sizeof(adapter->misc_vector_name) - 1, "i40evf-%s:mbx",
dev_name(&adapter->pdev->dev));
err = request_irq(adapter->msix_entries[0].vector, err = request_irq(adapter->msix_entries[0].vector,
&i40evf_msix_aq, 0, &i40evf_msix_aq, 0,
adapter->misc_vector_name, netdev); adapter->misc_vector_name, netdev);