mirror of https://gitee.com/openkylin/linux.git
1704 lines
52 KiB
C
1704 lines
52 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/* Copyright (c) 2018, Intel Corporation. */
|
|
|
|
/* ethtool support for ice */
|
|
|
|
#include "ice.h"
|
|
|
|
struct ice_stats {
|
|
char stat_string[ETH_GSTRING_LEN];
|
|
int sizeof_stat;
|
|
int stat_offset;
|
|
};
|
|
|
|
#define ICE_STAT(_type, _name, _stat) { \
|
|
.stat_string = _name, \
|
|
.sizeof_stat = FIELD_SIZEOF(_type, _stat), \
|
|
.stat_offset = offsetof(_type, _stat) \
|
|
}
|
|
|
|
#define ICE_VSI_STAT(_name, _stat) \
|
|
ICE_STAT(struct ice_vsi, _name, _stat)
|
|
#define ICE_PF_STAT(_name, _stat) \
|
|
ICE_STAT(struct ice_pf, _name, _stat)
|
|
|
|
static int ice_q_stats_len(struct net_device *netdev)
|
|
{
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
|
|
return ((np->vsi->alloc_txq + np->vsi->alloc_rxq) *
|
|
(sizeof(struct ice_q_stats) / sizeof(u64)));
|
|
}
|
|
|
|
#define ICE_PF_STATS_LEN ARRAY_SIZE(ice_gstrings_pf_stats)
|
|
#define ICE_VSI_STATS_LEN ARRAY_SIZE(ice_gstrings_vsi_stats)
|
|
|
|
#define ICE_ALL_STATS_LEN(n) (ICE_PF_STATS_LEN + ICE_VSI_STATS_LEN + \
|
|
ice_q_stats_len(n))
|
|
|
|
static const struct ice_stats ice_gstrings_vsi_stats[] = {
|
|
ICE_VSI_STAT("tx_unicast", eth_stats.tx_unicast),
|
|
ICE_VSI_STAT("rx_unicast", eth_stats.rx_unicast),
|
|
ICE_VSI_STAT("tx_multicast", eth_stats.tx_multicast),
|
|
ICE_VSI_STAT("rx_multicast", eth_stats.rx_multicast),
|
|
ICE_VSI_STAT("tx_broadcast", eth_stats.tx_broadcast),
|
|
ICE_VSI_STAT("rx_broadcast", eth_stats.rx_broadcast),
|
|
ICE_VSI_STAT("tx_bytes", eth_stats.tx_bytes),
|
|
ICE_VSI_STAT("rx_bytes", eth_stats.rx_bytes),
|
|
ICE_VSI_STAT("rx_discards", eth_stats.rx_discards),
|
|
ICE_VSI_STAT("tx_errors", eth_stats.tx_errors),
|
|
ICE_VSI_STAT("tx_linearize", tx_linearize),
|
|
ICE_VSI_STAT("rx_unknown_protocol", eth_stats.rx_unknown_protocol),
|
|
ICE_VSI_STAT("rx_alloc_fail", rx_buf_failed),
|
|
ICE_VSI_STAT("rx_pg_alloc_fail", rx_page_failed),
|
|
};
|
|
|
|
/* These PF_STATs might look like duplicates of some NETDEV_STATs,
|
|
* but they aren't. This device is capable of supporting multiple
|
|
* VSIs/netdevs on a single PF. The NETDEV_STATs are for individual
|
|
* netdevs whereas the PF_STATs are for the physical function that's
|
|
* hosting these netdevs.
|
|
*
|
|
* The PF_STATs are appended to the netdev stats only when ethtool -S
|
|
* is queried on the base PF netdev.
|
|
*/
|
|
static struct ice_stats ice_gstrings_pf_stats[] = {
|
|
ICE_PF_STAT("tx_bytes", stats.eth.tx_bytes),
|
|
ICE_PF_STAT("rx_bytes", stats.eth.rx_bytes),
|
|
ICE_PF_STAT("tx_unicast", stats.eth.tx_unicast),
|
|
ICE_PF_STAT("rx_unicast", stats.eth.rx_unicast),
|
|
ICE_PF_STAT("tx_multicast", stats.eth.tx_multicast),
|
|
ICE_PF_STAT("rx_multicast", stats.eth.rx_multicast),
|
|
ICE_PF_STAT("tx_broadcast", stats.eth.tx_broadcast),
|
|
ICE_PF_STAT("rx_broadcast", stats.eth.rx_broadcast),
|
|
ICE_PF_STAT("tx_errors", stats.eth.tx_errors),
|
|
ICE_PF_STAT("tx_size_64", stats.tx_size_64),
|
|
ICE_PF_STAT("rx_size_64", stats.rx_size_64),
|
|
ICE_PF_STAT("tx_size_127", stats.tx_size_127),
|
|
ICE_PF_STAT("rx_size_127", stats.rx_size_127),
|
|
ICE_PF_STAT("tx_size_255", stats.tx_size_255),
|
|
ICE_PF_STAT("rx_size_255", stats.rx_size_255),
|
|
ICE_PF_STAT("tx_size_511", stats.tx_size_511),
|
|
ICE_PF_STAT("rx_size_511", stats.rx_size_511),
|
|
ICE_PF_STAT("tx_size_1023", stats.tx_size_1023),
|
|
ICE_PF_STAT("rx_size_1023", stats.rx_size_1023),
|
|
ICE_PF_STAT("tx_size_1522", stats.tx_size_1522),
|
|
ICE_PF_STAT("rx_size_1522", stats.rx_size_1522),
|
|
ICE_PF_STAT("tx_size_big", stats.tx_size_big),
|
|
ICE_PF_STAT("rx_size_big", stats.rx_size_big),
|
|
ICE_PF_STAT("link_xon_tx", stats.link_xon_tx),
|
|
ICE_PF_STAT("link_xon_rx", stats.link_xon_rx),
|
|
ICE_PF_STAT("link_xoff_tx", stats.link_xoff_tx),
|
|
ICE_PF_STAT("link_xoff_rx", stats.link_xoff_rx),
|
|
ICE_PF_STAT("tx_dropped_link_down", stats.tx_dropped_link_down),
|
|
ICE_PF_STAT("rx_undersize", stats.rx_undersize),
|
|
ICE_PF_STAT("rx_fragments", stats.rx_fragments),
|
|
ICE_PF_STAT("rx_oversize", stats.rx_oversize),
|
|
ICE_PF_STAT("rx_jabber", stats.rx_jabber),
|
|
ICE_PF_STAT("rx_csum_bad", hw_csum_rx_error),
|
|
ICE_PF_STAT("rx_length_errors", stats.rx_len_errors),
|
|
ICE_PF_STAT("rx_dropped", stats.eth.rx_discards),
|
|
ICE_PF_STAT("rx_crc_errors", stats.crc_errors),
|
|
ICE_PF_STAT("illegal_bytes", stats.illegal_bytes),
|
|
ICE_PF_STAT("mac_local_faults", stats.mac_local_faults),
|
|
ICE_PF_STAT("mac_remote_faults", stats.mac_remote_faults),
|
|
};
|
|
|
|
static u32 ice_regs_dump_list[] = {
|
|
PFGEN_STATE,
|
|
PRTGEN_STATUS,
|
|
QRX_CTRL(0),
|
|
QINT_TQCTL(0),
|
|
QINT_RQCTL(0),
|
|
PFINT_OICR_ENA,
|
|
QRX_ITR(0),
|
|
};
|
|
|
|
/**
|
|
* ice_nvm_version_str - format the NVM version strings
|
|
* @hw: ptr to the hardware info
|
|
*/
|
|
static char *ice_nvm_version_str(struct ice_hw *hw)
|
|
{
|
|
static char buf[ICE_ETHTOOL_FWVER_LEN];
|
|
u8 ver, patch;
|
|
u32 full_ver;
|
|
u16 build;
|
|
|
|
full_ver = hw->nvm.oem_ver;
|
|
ver = (u8)((full_ver & ICE_OEM_VER_MASK) >> ICE_OEM_VER_SHIFT);
|
|
build = (u16)((full_ver & ICE_OEM_VER_BUILD_MASK) >>
|
|
ICE_OEM_VER_BUILD_SHIFT);
|
|
patch = (u8)(full_ver & ICE_OEM_VER_PATCH_MASK);
|
|
|
|
snprintf(buf, sizeof(buf), "%x.%02x 0x%x %d.%d.%d",
|
|
(hw->nvm.ver & ICE_NVM_VER_HI_MASK) >> ICE_NVM_VER_HI_SHIFT,
|
|
(hw->nvm.ver & ICE_NVM_VER_LO_MASK) >> ICE_NVM_VER_LO_SHIFT,
|
|
hw->nvm.eetrack, ver, build, patch);
|
|
|
|
return buf;
|
|
}
|
|
|
|
static void
|
|
ice_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *drvinfo)
|
|
{
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ice_vsi *vsi = np->vsi;
|
|
struct ice_pf *pf = vsi->back;
|
|
|
|
strlcpy(drvinfo->driver, KBUILD_MODNAME, sizeof(drvinfo->driver));
|
|
strlcpy(drvinfo->version, ice_drv_ver, sizeof(drvinfo->version));
|
|
strlcpy(drvinfo->fw_version, ice_nvm_version_str(&pf->hw),
|
|
sizeof(drvinfo->fw_version));
|
|
strlcpy(drvinfo->bus_info, pci_name(pf->pdev),
|
|
sizeof(drvinfo->bus_info));
|
|
}
|
|
|
|
static int ice_get_regs_len(struct net_device __always_unused *netdev)
|
|
{
|
|
return sizeof(ice_regs_dump_list);
|
|
}
|
|
|
|
static void
|
|
ice_get_regs(struct net_device *netdev, struct ethtool_regs *regs, void *p)
|
|
{
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ice_pf *pf = np->vsi->back;
|
|
struct ice_hw *hw = &pf->hw;
|
|
u32 *regs_buf = (u32 *)p;
|
|
int i;
|
|
|
|
regs->version = 1;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(ice_regs_dump_list); ++i)
|
|
regs_buf[i] = rd32(hw, ice_regs_dump_list[i]);
|
|
}
|
|
|
|
static u32 ice_get_msglevel(struct net_device *netdev)
|
|
{
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ice_pf *pf = np->vsi->back;
|
|
|
|
#ifndef CONFIG_DYNAMIC_DEBUG
|
|
if (pf->hw.debug_mask)
|
|
netdev_info(netdev, "hw debug_mask: 0x%llX\n",
|
|
pf->hw.debug_mask);
|
|
#endif /* !CONFIG_DYNAMIC_DEBUG */
|
|
|
|
return pf->msg_enable;
|
|
}
|
|
|
|
static void ice_set_msglevel(struct net_device *netdev, u32 data)
|
|
{
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ice_pf *pf = np->vsi->back;
|
|
|
|
#ifndef CONFIG_DYNAMIC_DEBUG
|
|
if (ICE_DBG_USER & data)
|
|
pf->hw.debug_mask = data;
|
|
else
|
|
pf->msg_enable = data;
|
|
#else
|
|
pf->msg_enable = data;
|
|
#endif /* !CONFIG_DYNAMIC_DEBUG */
|
|
}
|
|
|
|
static void ice_get_strings(struct net_device *netdev, u32 stringset, u8 *data)
|
|
{
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ice_vsi *vsi = np->vsi;
|
|
char *p = (char *)data;
|
|
unsigned int i;
|
|
|
|
switch (stringset) {
|
|
case ETH_SS_STATS:
|
|
for (i = 0; i < ICE_VSI_STATS_LEN; i++) {
|
|
snprintf(p, ETH_GSTRING_LEN, "%s",
|
|
ice_gstrings_vsi_stats[i].stat_string);
|
|
p += ETH_GSTRING_LEN;
|
|
}
|
|
|
|
ice_for_each_alloc_txq(vsi, i) {
|
|
snprintf(p, ETH_GSTRING_LEN,
|
|
"tx-queue-%u.tx_packets", i);
|
|
p += ETH_GSTRING_LEN;
|
|
snprintf(p, ETH_GSTRING_LEN, "tx-queue-%u.tx_bytes", i);
|
|
p += ETH_GSTRING_LEN;
|
|
}
|
|
|
|
ice_for_each_alloc_rxq(vsi, i) {
|
|
snprintf(p, ETH_GSTRING_LEN,
|
|
"rx-queue-%u.rx_packets", i);
|
|
p += ETH_GSTRING_LEN;
|
|
snprintf(p, ETH_GSTRING_LEN, "rx-queue-%u.rx_bytes", i);
|
|
p += ETH_GSTRING_LEN;
|
|
}
|
|
|
|
if (vsi->type != ICE_VSI_PF)
|
|
return;
|
|
|
|
for (i = 0; i < ICE_PF_STATS_LEN; i++) {
|
|
snprintf(p, ETH_GSTRING_LEN, "port.%s",
|
|
ice_gstrings_pf_stats[i].stat_string);
|
|
p += ETH_GSTRING_LEN;
|
|
}
|
|
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static int ice_get_sset_count(struct net_device *netdev, int sset)
|
|
{
|
|
switch (sset) {
|
|
case ETH_SS_STATS:
|
|
/* The number (and order) of strings reported *must* remain
|
|
* constant for a given netdevice. This function must not
|
|
* report a different number based on run time parameters
|
|
* (such as the number of queues in use, or the setting of
|
|
* a private ethtool flag). This is due to the nature of the
|
|
* ethtool stats API.
|
|
*
|
|
* User space programs such as ethtool must make 3 separate
|
|
* ioctl requests, one for size, one for the strings, and
|
|
* finally one for the stats. Since these cross into
|
|
* user space, changes to the number or size could result in
|
|
* undefined memory access or incorrect string<->value
|
|
* correlations for statistics.
|
|
*
|
|
* Even if it appears to be safe, changes to the size or
|
|
* order of strings will suffer from race conditions and are
|
|
* not safe.
|
|
*/
|
|
return ICE_ALL_STATS_LEN(netdev);
|
|
default:
|
|
return -EOPNOTSUPP;
|
|
}
|
|
}
|
|
|
|
static void
|
|
ice_get_ethtool_stats(struct net_device *netdev,
|
|
struct ethtool_stats __always_unused *stats, u64 *data)
|
|
{
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ice_vsi *vsi = np->vsi;
|
|
struct ice_pf *pf = vsi->back;
|
|
struct ice_ring *ring;
|
|
unsigned int j = 0;
|
|
int i = 0;
|
|
char *p;
|
|
|
|
for (j = 0; j < ICE_VSI_STATS_LEN; j++) {
|
|
p = (char *)vsi + ice_gstrings_vsi_stats[j].stat_offset;
|
|
data[i++] = (ice_gstrings_vsi_stats[j].sizeof_stat ==
|
|
sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
|
|
}
|
|
|
|
/* populate per queue stats */
|
|
rcu_read_lock();
|
|
|
|
ice_for_each_alloc_txq(vsi, j) {
|
|
ring = READ_ONCE(vsi->tx_rings[j]);
|
|
if (ring) {
|
|
data[i++] = ring->stats.pkts;
|
|
data[i++] = ring->stats.bytes;
|
|
} else {
|
|
data[i++] = 0;
|
|
data[i++] = 0;
|
|
}
|
|
}
|
|
|
|
ice_for_each_alloc_rxq(vsi, j) {
|
|
ring = READ_ONCE(vsi->rx_rings[j]);
|
|
if (ring) {
|
|
data[i++] = ring->stats.pkts;
|
|
data[i++] = ring->stats.bytes;
|
|
} else {
|
|
data[i++] = 0;
|
|
data[i++] = 0;
|
|
}
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
if (vsi->type != ICE_VSI_PF)
|
|
return;
|
|
|
|
for (j = 0; j < ICE_PF_STATS_LEN; j++) {
|
|
p = (char *)pf + ice_gstrings_pf_stats[j].stat_offset;
|
|
data[i++] = (ice_gstrings_pf_stats[j].sizeof_stat ==
|
|
sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ice_phy_type_to_ethtool - convert the phy_types to ethtool link modes
|
|
* @netdev: network interface device structure
|
|
* @ks: ethtool link ksettings struct to fill out
|
|
*/
|
|
static void ice_phy_type_to_ethtool(struct net_device *netdev,
|
|
struct ethtool_link_ksettings *ks)
|
|
{
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ice_link_status *hw_link_info;
|
|
struct ice_vsi *vsi = np->vsi;
|
|
u64 phy_types_low;
|
|
|
|
hw_link_info = &vsi->port_info->phy.link_info;
|
|
phy_types_low = vsi->port_info->phy.phy_type_low;
|
|
|
|
ethtool_link_ksettings_zero_link_mode(ks, supported);
|
|
ethtool_link_ksettings_zero_link_mode(ks, advertising);
|
|
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_100BASE_TX ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_100M_SGMII) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
100baseT_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_100MB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
100baseT_Full);
|
|
}
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_1000BASE_T ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_1G_SGMII) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
1000baseT_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_1000MB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
1000baseT_Full);
|
|
}
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_1000BASE_KX) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
1000baseKX_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_1000MB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
1000baseKX_Full);
|
|
}
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_1000BASE_SX ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_1000BASE_LX) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
1000baseX_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_1000MB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
1000baseX_Full);
|
|
}
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_2500BASE_T) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
2500baseT_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_2500MB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
2500baseT_Full);
|
|
}
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_2500BASE_X ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_2500BASE_KX) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
2500baseX_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_2500MB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
2500baseX_Full);
|
|
}
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_5GBASE_T ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_5GBASE_KR) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
5000baseT_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_5GB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
5000baseT_Full);
|
|
}
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_10GBASE_T ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_10G_SFI_DA ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_10G_SFI_AOC_ACC ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_10G_SFI_C2C) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
10000baseT_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_10GB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
10000baseT_Full);
|
|
}
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_10GBASE_KR_CR1) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
10000baseKR_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_10GB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
10000baseKR_Full);
|
|
}
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_10GBASE_SR) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
10000baseSR_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_10GB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
10000baseSR_Full);
|
|
}
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_10GBASE_LR) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
10000baseLR_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_10GB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
10000baseLR_Full);
|
|
}
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_T ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_CR ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_CR_S ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_CR1 ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_25G_AUI_AOC_ACC ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_25G_AUI_C2C) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
25000baseCR_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_25GB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
25000baseCR_Full);
|
|
}
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_SR ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_LR) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
25000baseSR_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_25GB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
25000baseSR_Full);
|
|
}
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_KR ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_KR_S ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_KR1) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
25000baseKR_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_25GB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
25000baseKR_Full);
|
|
}
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_40GBASE_KR4) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
40000baseKR4_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_40GB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
40000baseKR4_Full);
|
|
}
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_40GBASE_CR4 ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_40G_XLAUI_AOC_ACC ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_40G_XLAUI) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
40000baseCR4_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_40GB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
40000baseCR4_Full);
|
|
}
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_40GBASE_SR4) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
40000baseSR4_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_40GB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
40000baseSR4_Full);
|
|
}
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_40GBASE_LR4) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
40000baseLR4_Full);
|
|
if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_40GB)
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
40000baseLR4_Full);
|
|
}
|
|
|
|
/* Autoneg PHY types */
|
|
if (phy_types_low & ICE_PHY_TYPE_LOW_100BASE_TX ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_1000BASE_T ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_1000BASE_KX ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_2500BASE_T ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_2500BASE_KX ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_5GBASE_T ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_5GBASE_KR ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_10GBASE_T ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_10GBASE_KR_CR1 ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_T ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_CR ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_CR_S ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_CR1 ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_KR ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_KR_S ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_KR1 ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_40GBASE_CR4 ||
|
|
phy_types_low & ICE_PHY_TYPE_LOW_40GBASE_KR4) {
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
Autoneg);
|
|
}
|
|
}
|
|
|
|
#define TEST_SET_BITS_TIMEOUT 50
|
|
#define TEST_SET_BITS_SLEEP_MAX 2000
|
|
#define TEST_SET_BITS_SLEEP_MIN 1000
|
|
|
|
/**
|
|
* ice_get_settings_link_up - Get Link settings for when link is up
|
|
* @ks: ethtool ksettings to fill in
|
|
* @netdev: network interface device structure
|
|
*/
|
|
static void ice_get_settings_link_up(struct ethtool_link_ksettings *ks,
|
|
struct net_device *netdev)
|
|
{
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ethtool_link_ksettings cap_ksettings;
|
|
struct ice_link_status *link_info;
|
|
struct ice_vsi *vsi = np->vsi;
|
|
bool unrecog_phy_low = false;
|
|
|
|
link_info = &vsi->port_info->phy.link_info;
|
|
|
|
/* Initialize supported and advertised settings based on phy settings */
|
|
switch (link_info->phy_type_low) {
|
|
case ICE_PHY_TYPE_LOW_100BASE_TX:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
100baseT_Full);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
100baseT_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_100M_SGMII:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
100baseT_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_1000BASE_T:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
1000baseT_Full);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
1000baseT_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_1G_SGMII:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
1000baseT_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_1000BASE_SX:
|
|
case ICE_PHY_TYPE_LOW_1000BASE_LX:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
1000baseX_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_1000BASE_KX:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
1000baseKX_Full);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
1000baseKX_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_2500BASE_T:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
2500baseT_Full);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
2500baseT_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_2500BASE_X:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
2500baseX_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_2500BASE_KX:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
2500baseX_Full);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
2500baseX_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_5GBASE_T:
|
|
case ICE_PHY_TYPE_LOW_5GBASE_KR:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
5000baseT_Full);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
5000baseT_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_10GBASE_T:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
10000baseT_Full);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
10000baseT_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_10G_SFI_DA:
|
|
case ICE_PHY_TYPE_LOW_10G_SFI_AOC_ACC:
|
|
case ICE_PHY_TYPE_LOW_10G_SFI_C2C:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
10000baseT_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_10GBASE_SR:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
10000baseSR_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_10GBASE_LR:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
10000baseLR_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_10GBASE_KR_CR1:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
10000baseKR_Full);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
10000baseKR_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_25GBASE_T:
|
|
case ICE_PHY_TYPE_LOW_25GBASE_CR:
|
|
case ICE_PHY_TYPE_LOW_25GBASE_CR_S:
|
|
case ICE_PHY_TYPE_LOW_25GBASE_CR1:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
25000baseCR_Full);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
25000baseCR_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_25G_AUI_AOC_ACC:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
25000baseCR_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_25GBASE_SR:
|
|
case ICE_PHY_TYPE_LOW_25GBASE_LR:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
25000baseSR_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_25GBASE_KR:
|
|
case ICE_PHY_TYPE_LOW_25GBASE_KR1:
|
|
case ICE_PHY_TYPE_LOW_25GBASE_KR_S:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
25000baseKR_Full);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
25000baseKR_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_40GBASE_CR4:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
40000baseCR4_Full);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
40000baseCR4_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_40G_XLAUI_AOC_ACC:
|
|
case ICE_PHY_TYPE_LOW_40G_XLAUI:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
40000baseCR4_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_40GBASE_SR4:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
40000baseSR4_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_40GBASE_LR4:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
40000baseLR4_Full);
|
|
break;
|
|
case ICE_PHY_TYPE_LOW_40GBASE_KR4:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, supported,
|
|
40000baseKR4_Full);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
40000baseKR4_Full);
|
|
break;
|
|
default:
|
|
unrecog_phy_low = true;
|
|
}
|
|
|
|
if (unrecog_phy_low) {
|
|
/* if we got here and link is up something bad is afoot */
|
|
netdev_info(netdev, "WARNING: Unrecognized PHY_Low (0x%llx).\n",
|
|
(u64)link_info->phy_type_low);
|
|
}
|
|
|
|
/* Now that we've worked out everything that could be supported by the
|
|
* current PHY type, get what is supported by the NVM and intersect
|
|
* them to get what is truly supported
|
|
*/
|
|
memset(&cap_ksettings, 0, sizeof(struct ethtool_link_ksettings));
|
|
ice_phy_type_to_ethtool(netdev, &cap_ksettings);
|
|
ethtool_intersect_link_masks(ks, &cap_ksettings);
|
|
|
|
switch (link_info->link_speed) {
|
|
case ICE_AQ_LINK_SPEED_40GB:
|
|
ks->base.speed = SPEED_40000;
|
|
break;
|
|
case ICE_AQ_LINK_SPEED_25GB:
|
|
ks->base.speed = SPEED_25000;
|
|
break;
|
|
case ICE_AQ_LINK_SPEED_20GB:
|
|
ks->base.speed = SPEED_20000;
|
|
break;
|
|
case ICE_AQ_LINK_SPEED_10GB:
|
|
ks->base.speed = SPEED_10000;
|
|
break;
|
|
case ICE_AQ_LINK_SPEED_5GB:
|
|
ks->base.speed = SPEED_5000;
|
|
break;
|
|
case ICE_AQ_LINK_SPEED_2500MB:
|
|
ks->base.speed = SPEED_2500;
|
|
break;
|
|
case ICE_AQ_LINK_SPEED_1000MB:
|
|
ks->base.speed = SPEED_1000;
|
|
break;
|
|
case ICE_AQ_LINK_SPEED_100MB:
|
|
ks->base.speed = SPEED_100;
|
|
break;
|
|
default:
|
|
netdev_info(netdev,
|
|
"WARNING: Unrecognized link_speed (0x%x).\n",
|
|
link_info->link_speed);
|
|
break;
|
|
}
|
|
ks->base.duplex = DUPLEX_FULL;
|
|
}
|
|
|
|
/**
|
|
* ice_get_settings_link_down - Get the Link settings when link is down
|
|
* @ks: ethtool ksettings to fill in
|
|
* @netdev: network interface device structure
|
|
*
|
|
* Reports link settings that can be determined when link is down
|
|
*/
|
|
static void
|
|
ice_get_settings_link_down(struct ethtool_link_ksettings *ks,
|
|
struct net_device __always_unused *netdev)
|
|
{
|
|
/* link is down and the driver needs to fall back on
|
|
* supported phy types to figure out what info to display
|
|
*/
|
|
ice_phy_type_to_ethtool(netdev, ks);
|
|
|
|
/* With no link, speed and duplex are unknown */
|
|
ks->base.speed = SPEED_UNKNOWN;
|
|
ks->base.duplex = DUPLEX_UNKNOWN;
|
|
}
|
|
|
|
/**
|
|
* ice_get_link_ksettings - Get Link Speed and Duplex settings
|
|
* @netdev: network interface device structure
|
|
* @ks: ethtool ksettings
|
|
*
|
|
* Reports speed/duplex settings based on media_type
|
|
*/
|
|
static int ice_get_link_ksettings(struct net_device *netdev,
|
|
struct ethtool_link_ksettings *ks)
|
|
{
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ice_link_status *hw_link_info;
|
|
struct ice_vsi *vsi = np->vsi;
|
|
|
|
ethtool_link_ksettings_zero_link_mode(ks, supported);
|
|
ethtool_link_ksettings_zero_link_mode(ks, advertising);
|
|
hw_link_info = &vsi->port_info->phy.link_info;
|
|
|
|
/* set speed and duplex */
|
|
if (hw_link_info->link_info & ICE_AQ_LINK_UP)
|
|
ice_get_settings_link_up(ks, netdev);
|
|
else
|
|
ice_get_settings_link_down(ks, netdev);
|
|
|
|
/* set autoneg settings */
|
|
ks->base.autoneg = (hw_link_info->an_info & ICE_AQ_AN_COMPLETED) ?
|
|
AUTONEG_ENABLE : AUTONEG_DISABLE;
|
|
|
|
/* set media type settings */
|
|
switch (vsi->port_info->phy.media_type) {
|
|
case ICE_MEDIA_FIBER:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, FIBRE);
|
|
ks->base.port = PORT_FIBRE;
|
|
break;
|
|
case ICE_MEDIA_BASET:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, TP);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising, TP);
|
|
ks->base.port = PORT_TP;
|
|
break;
|
|
case ICE_MEDIA_BACKPLANE:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, Backplane);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
Backplane);
|
|
ks->base.port = PORT_NONE;
|
|
break;
|
|
case ICE_MEDIA_DA:
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, FIBRE);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising, FIBRE);
|
|
ks->base.port = PORT_DA;
|
|
break;
|
|
default:
|
|
ks->base.port = PORT_OTHER;
|
|
break;
|
|
}
|
|
|
|
/* flow control is symmetric and always supported */
|
|
ethtool_link_ksettings_add_link_mode(ks, supported, Pause);
|
|
|
|
switch (vsi->port_info->fc.req_mode) {
|
|
case ICE_FC_FULL:
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising, Pause);
|
|
break;
|
|
case ICE_FC_TX_PAUSE:
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
Asym_Pause);
|
|
break;
|
|
case ICE_FC_RX_PAUSE:
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising, Pause);
|
|
ethtool_link_ksettings_add_link_mode(ks, advertising,
|
|
Asym_Pause);
|
|
break;
|
|
case ICE_FC_PFC:
|
|
default:
|
|
ethtool_link_ksettings_del_link_mode(ks, advertising, Pause);
|
|
ethtool_link_ksettings_del_link_mode(ks, advertising,
|
|
Asym_Pause);
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ice_ksettings_find_adv_link_speed - Find advertising link speed
|
|
* @ks: ethtool ksettings
|
|
*/
|
|
static u16
|
|
ice_ksettings_find_adv_link_speed(const struct ethtool_link_ksettings *ks)
|
|
{
|
|
u16 adv_link_speed = 0;
|
|
|
|
if (ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
100baseT_Full))
|
|
adv_link_speed |= ICE_AQ_LINK_SPEED_100MB;
|
|
if (ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
1000baseX_Full))
|
|
adv_link_speed |= ICE_AQ_LINK_SPEED_1000MB;
|
|
if (ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
1000baseT_Full) ||
|
|
ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
1000baseKX_Full))
|
|
adv_link_speed |= ICE_AQ_LINK_SPEED_1000MB;
|
|
if (ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
2500baseT_Full))
|
|
adv_link_speed |= ICE_AQ_LINK_SPEED_2500MB;
|
|
if (ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
2500baseX_Full))
|
|
adv_link_speed |= ICE_AQ_LINK_SPEED_2500MB;
|
|
if (ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
5000baseT_Full))
|
|
adv_link_speed |= ICE_AQ_LINK_SPEED_5GB;
|
|
if (ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
10000baseT_Full) ||
|
|
ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
10000baseKR_Full))
|
|
adv_link_speed |= ICE_AQ_LINK_SPEED_10GB;
|
|
if (ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
10000baseSR_Full) ||
|
|
ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
10000baseLR_Full))
|
|
adv_link_speed |= ICE_AQ_LINK_SPEED_10GB;
|
|
if (ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
25000baseCR_Full) ||
|
|
ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
25000baseSR_Full) ||
|
|
ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
25000baseKR_Full))
|
|
adv_link_speed |= ICE_AQ_LINK_SPEED_25GB;
|
|
if (ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
40000baseCR4_Full) ||
|
|
ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
40000baseSR4_Full) ||
|
|
ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
40000baseLR4_Full) ||
|
|
ethtool_link_ksettings_test_link_mode(ks, advertising,
|
|
40000baseKR4_Full))
|
|
adv_link_speed |= ICE_AQ_LINK_SPEED_40GB;
|
|
|
|
return adv_link_speed;
|
|
}
|
|
|
|
/**
|
|
* ice_setup_autoneg
|
|
* @p: port info
|
|
* @ks: ethtool_link_ksettings
|
|
* @config: configuration that will be sent down to FW
|
|
* @autoneg_enabled: autonegotiation is enabled or not
|
|
* @autoneg_changed: will there a change in autonegotiation
|
|
* @netdev: network interface device structure
|
|
*
|
|
* Setup PHY autonegotiation feature
|
|
*/
|
|
static int
|
|
ice_setup_autoneg(struct ice_port_info *p, struct ethtool_link_ksettings *ks,
|
|
struct ice_aqc_set_phy_cfg_data *config,
|
|
u8 autoneg_enabled, u8 *autoneg_changed,
|
|
struct net_device *netdev)
|
|
{
|
|
int err = 0;
|
|
|
|
*autoneg_changed = 0;
|
|
|
|
/* Check autoneg */
|
|
if (autoneg_enabled == AUTONEG_ENABLE) {
|
|
/* If autoneg was not already enabled */
|
|
if (!(p->phy.link_info.an_info & ICE_AQ_AN_COMPLETED)) {
|
|
/* If autoneg is not supported, return error */
|
|
if (!ethtool_link_ksettings_test_link_mode(ks,
|
|
supported,
|
|
Autoneg)) {
|
|
netdev_info(netdev, "Autoneg not supported on this phy.\n");
|
|
err = -EINVAL;
|
|
} else {
|
|
/* Autoneg is allowed to change */
|
|
config->caps |= ICE_AQ_PHY_ENA_AUTO_LINK_UPDT;
|
|
*autoneg_changed = 1;
|
|
}
|
|
}
|
|
} else {
|
|
/* If autoneg is currently enabled */
|
|
if (p->phy.link_info.an_info & ICE_AQ_AN_COMPLETED) {
|
|
/* If autoneg is supported 10GBASE_T is the only phy
|
|
* that can disable it, so otherwise return error
|
|
*/
|
|
if (ethtool_link_ksettings_test_link_mode(ks,
|
|
supported,
|
|
Autoneg)) {
|
|
netdev_info(netdev, "Autoneg cannot be disabled on this phy\n");
|
|
err = -EINVAL;
|
|
} else {
|
|
/* Autoneg is allowed to change */
|
|
config->caps &= ~ICE_AQ_PHY_ENA_AUTO_LINK_UPDT;
|
|
*autoneg_changed = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* ice_set_link_ksettings - Set Speed and Duplex
|
|
* @netdev: network interface device structure
|
|
* @ks: ethtool ksettings
|
|
*
|
|
* Set speed/duplex per media_types advertised/forced
|
|
*/
|
|
static int ice_set_link_ksettings(struct net_device *netdev,
|
|
const struct ethtool_link_ksettings *ks)
|
|
{
|
|
u8 autoneg, timeout = TEST_SET_BITS_TIMEOUT, lport = 0;
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ethtool_link_ksettings safe_ks, copy_ks;
|
|
struct ice_aqc_get_phy_caps_data *abilities;
|
|
u16 adv_link_speed, curr_link_speed, idx;
|
|
struct ice_aqc_set_phy_cfg_data config;
|
|
struct ice_pf *pf = np->vsi->back;
|
|
struct ice_port_info *p;
|
|
u8 autoneg_changed = 0;
|
|
enum ice_status status;
|
|
u64 phy_type_low;
|
|
int err = 0;
|
|
bool linkup;
|
|
|
|
p = np->vsi->port_info;
|
|
|
|
if (!p)
|
|
return -EOPNOTSUPP;
|
|
|
|
/* Check if this is lan vsi */
|
|
for (idx = 0 ; idx < pf->num_alloc_vsi ; idx++) {
|
|
if (pf->vsi[idx]->type == ICE_VSI_PF) {
|
|
if (np->vsi != pf->vsi[idx])
|
|
return -EOPNOTSUPP;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (p->phy.media_type != ICE_MEDIA_BASET &&
|
|
p->phy.media_type != ICE_MEDIA_FIBER &&
|
|
p->phy.media_type != ICE_MEDIA_BACKPLANE &&
|
|
p->phy.media_type != ICE_MEDIA_DA &&
|
|
p->phy.link_info.link_info & ICE_AQ_LINK_UP)
|
|
return -EOPNOTSUPP;
|
|
|
|
/* copy the ksettings to copy_ks to avoid modifying the original */
|
|
memcpy(©_ks, ks, sizeof(struct ethtool_link_ksettings));
|
|
|
|
/* save autoneg out of ksettings */
|
|
autoneg = copy_ks.base.autoneg;
|
|
|
|
memset(&safe_ks, 0, sizeof(safe_ks));
|
|
|
|
/* Get link modes supported by hardware.*/
|
|
ice_phy_type_to_ethtool(netdev, &safe_ks);
|
|
|
|
/* and check against modes requested by user.
|
|
* Return an error if unsupported mode was set.
|
|
*/
|
|
if (!bitmap_subset(copy_ks.link_modes.advertising,
|
|
safe_ks.link_modes.supported,
|
|
__ETHTOOL_LINK_MODE_MASK_NBITS))
|
|
return -EINVAL;
|
|
|
|
/* get our own copy of the bits to check against */
|
|
memset(&safe_ks, 0, sizeof(struct ethtool_link_ksettings));
|
|
safe_ks.base.cmd = copy_ks.base.cmd;
|
|
safe_ks.base.link_mode_masks_nwords =
|
|
copy_ks.base.link_mode_masks_nwords;
|
|
ice_get_link_ksettings(netdev, &safe_ks);
|
|
|
|
/* set autoneg back to what it currently is */
|
|
copy_ks.base.autoneg = safe_ks.base.autoneg;
|
|
/* we don't compare the speed */
|
|
copy_ks.base.speed = safe_ks.base.speed;
|
|
|
|
/* If copy_ks.base and safe_ks.base are not the same now, then they are
|
|
* trying to set something that we do not support.
|
|
*/
|
|
if (memcmp(©_ks.base, &safe_ks.base,
|
|
sizeof(struct ethtool_link_settings)))
|
|
return -EOPNOTSUPP;
|
|
|
|
while (test_and_set_bit(__ICE_CFG_BUSY, pf->state)) {
|
|
timeout--;
|
|
if (!timeout)
|
|
return -EBUSY;
|
|
usleep_range(TEST_SET_BITS_SLEEP_MIN, TEST_SET_BITS_SLEEP_MAX);
|
|
}
|
|
|
|
abilities = devm_kzalloc(&pf->pdev->dev, sizeof(*abilities),
|
|
GFP_KERNEL);
|
|
if (!abilities)
|
|
return -ENOMEM;
|
|
|
|
/* Get the current phy config */
|
|
status = ice_aq_get_phy_caps(p, false, ICE_AQC_REPORT_SW_CFG, abilities,
|
|
NULL);
|
|
if (status) {
|
|
err = -EAGAIN;
|
|
goto done;
|
|
}
|
|
|
|
/* Copy abilities to config in case autoneg is not set below */
|
|
memset(&config, 0, sizeof(struct ice_aqc_set_phy_cfg_data));
|
|
config.caps = abilities->caps & ~ICE_AQC_PHY_AN_MODE;
|
|
if (abilities->caps & ICE_AQC_PHY_AN_MODE)
|
|
config.caps |= ICE_AQ_PHY_ENA_AUTO_LINK_UPDT;
|
|
|
|
/* Check autoneg */
|
|
err = ice_setup_autoneg(p, &safe_ks, &config, autoneg, &autoneg_changed,
|
|
netdev);
|
|
|
|
if (err)
|
|
goto done;
|
|
|
|
/* Call to get the current link speed */
|
|
p->phy.get_link_info = true;
|
|
status = ice_get_link_status(p, &linkup);
|
|
if (status) {
|
|
err = -EAGAIN;
|
|
goto done;
|
|
}
|
|
|
|
curr_link_speed = p->phy.link_info.link_speed;
|
|
adv_link_speed = ice_ksettings_find_adv_link_speed(ks);
|
|
|
|
/* If speed didn't get set, set it to what it currently is.
|
|
* This is needed because if advertise is 0 (as it is when autoneg
|
|
* is disabled) then speed won't get set.
|
|
*/
|
|
if (!adv_link_speed)
|
|
adv_link_speed = curr_link_speed;
|
|
|
|
/* Convert the advertise link speeds to their corresponded PHY_TYPE */
|
|
ice_update_phy_type(&phy_type_low, adv_link_speed);
|
|
|
|
if (!autoneg_changed && adv_link_speed == curr_link_speed) {
|
|
netdev_info(netdev, "Nothing changed, exiting without setting anything.\n");
|
|
goto done;
|
|
}
|
|
|
|
/* copy over the rest of the abilities */
|
|
config.low_power_ctrl = abilities->low_power_ctrl;
|
|
config.eee_cap = abilities->eee_cap;
|
|
config.eeer_value = abilities->eeer_value;
|
|
config.link_fec_opt = abilities->link_fec_options;
|
|
|
|
/* save the requested speeds */
|
|
p->phy.link_info.req_speeds = adv_link_speed;
|
|
|
|
/* set link and auto negotiation so changes take effect */
|
|
config.caps |= ICE_AQ_PHY_ENA_LINK;
|
|
|
|
if (phy_type_low) {
|
|
config.phy_type_low = cpu_to_le64(phy_type_low) &
|
|
abilities->phy_type_low;
|
|
} else {
|
|
err = -EAGAIN;
|
|
netdev_info(netdev, "Nothing changed. No PHY_TYPE is corresponded to advertised link speed.\n");
|
|
goto done;
|
|
}
|
|
|
|
/* If link is up put link down */
|
|
if (p->phy.link_info.link_info & ICE_AQ_LINK_UP) {
|
|
/* Tell the OS link is going down, the link will go
|
|
* back up when fw says it is ready asynchronously
|
|
*/
|
|
ice_print_link_msg(np->vsi, false);
|
|
netif_carrier_off(netdev);
|
|
netif_tx_stop_all_queues(netdev);
|
|
}
|
|
|
|
/* make the aq call */
|
|
status = ice_aq_set_phy_cfg(&pf->hw, lport, &config, NULL);
|
|
if (status) {
|
|
netdev_info(netdev, "Set phy config failed,\n");
|
|
err = -EAGAIN;
|
|
}
|
|
|
|
done:
|
|
devm_kfree(&pf->pdev->dev, abilities);
|
|
clear_bit(__ICE_CFG_BUSY, pf->state);
|
|
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* ice_get_rxnfc - command to get RX flow classification rules
|
|
* @netdev: network interface device structure
|
|
* @cmd: ethtool rxnfc command
|
|
* @rule_locs: buffer to rturn Rx flow classification rules
|
|
*
|
|
* Returns Success if the command is supported.
|
|
*/
|
|
static int ice_get_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd,
|
|
u32 __always_unused *rule_locs)
|
|
{
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ice_vsi *vsi = np->vsi;
|
|
int ret = -EOPNOTSUPP;
|
|
|
|
switch (cmd->cmd) {
|
|
case ETHTOOL_GRXRINGS:
|
|
cmd->data = vsi->rss_size;
|
|
ret = 0;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
ice_get_ringparam(struct net_device *netdev, struct ethtool_ringparam *ring)
|
|
{
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ice_vsi *vsi = np->vsi;
|
|
|
|
ring->rx_max_pending = ICE_MAX_NUM_DESC;
|
|
ring->tx_max_pending = ICE_MAX_NUM_DESC;
|
|
ring->rx_pending = vsi->rx_rings[0]->count;
|
|
ring->tx_pending = vsi->tx_rings[0]->count;
|
|
|
|
/* Rx mini and jumbo rings are not supported */
|
|
ring->rx_mini_max_pending = 0;
|
|
ring->rx_jumbo_max_pending = 0;
|
|
ring->rx_mini_pending = 0;
|
|
ring->rx_jumbo_pending = 0;
|
|
}
|
|
|
|
static int
|
|
ice_set_ringparam(struct net_device *netdev, struct ethtool_ringparam *ring)
|
|
{
|
|
struct ice_ring *tx_rings = NULL, *rx_rings = NULL;
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ice_vsi *vsi = np->vsi;
|
|
struct ice_pf *pf = vsi->back;
|
|
int i, timeout = 50, err = 0;
|
|
u32 new_rx_cnt, new_tx_cnt;
|
|
|
|
if (ring->tx_pending > ICE_MAX_NUM_DESC ||
|
|
ring->tx_pending < ICE_MIN_NUM_DESC ||
|
|
ring->rx_pending > ICE_MAX_NUM_DESC ||
|
|
ring->rx_pending < ICE_MIN_NUM_DESC) {
|
|
netdev_err(netdev, "Descriptors requested (Tx: %d / Rx: %d) out of range [%d-%d] (increment %d)\n",
|
|
ring->tx_pending, ring->rx_pending,
|
|
ICE_MIN_NUM_DESC, ICE_MAX_NUM_DESC,
|
|
ICE_REQ_DESC_MULTIPLE);
|
|
return -EINVAL;
|
|
}
|
|
|
|
new_tx_cnt = ALIGN(ring->tx_pending, ICE_REQ_DESC_MULTIPLE);
|
|
if (new_tx_cnt != ring->tx_pending)
|
|
netdev_info(netdev,
|
|
"Requested Tx descriptor count rounded up to %d\n",
|
|
new_tx_cnt);
|
|
new_rx_cnt = ALIGN(ring->rx_pending, ICE_REQ_DESC_MULTIPLE);
|
|
if (new_rx_cnt != ring->rx_pending)
|
|
netdev_info(netdev,
|
|
"Requested Rx descriptor count rounded up to %d\n",
|
|
new_rx_cnt);
|
|
|
|
/* if nothing to do return success */
|
|
if (new_tx_cnt == vsi->tx_rings[0]->count &&
|
|
new_rx_cnt == vsi->rx_rings[0]->count) {
|
|
netdev_dbg(netdev, "Nothing to change, descriptor count is same as requested\n");
|
|
return 0;
|
|
}
|
|
|
|
while (test_and_set_bit(__ICE_CFG_BUSY, pf->state)) {
|
|
timeout--;
|
|
if (!timeout)
|
|
return -EBUSY;
|
|
usleep_range(1000, 2000);
|
|
}
|
|
|
|
/* set for the next time the netdev is started */
|
|
if (!netif_running(vsi->netdev)) {
|
|
for (i = 0; i < vsi->alloc_txq; i++)
|
|
vsi->tx_rings[i]->count = new_tx_cnt;
|
|
for (i = 0; i < vsi->alloc_rxq; i++)
|
|
vsi->rx_rings[i]->count = new_rx_cnt;
|
|
netdev_dbg(netdev, "Link is down, descriptor count change happens when link is brought up\n");
|
|
goto done;
|
|
}
|
|
|
|
if (new_tx_cnt == vsi->tx_rings[0]->count)
|
|
goto process_rx;
|
|
|
|
/* alloc updated Tx resources */
|
|
netdev_info(netdev, "Changing Tx descriptor count from %d to %d\n",
|
|
vsi->tx_rings[0]->count, new_tx_cnt);
|
|
|
|
tx_rings = devm_kcalloc(&pf->pdev->dev, vsi->alloc_txq,
|
|
sizeof(struct ice_ring), GFP_KERNEL);
|
|
if (!tx_rings) {
|
|
err = -ENOMEM;
|
|
goto done;
|
|
}
|
|
|
|
for (i = 0; i < vsi->alloc_txq; i++) {
|
|
/* clone ring and setup updated count */
|
|
tx_rings[i] = *vsi->tx_rings[i];
|
|
tx_rings[i].count = new_tx_cnt;
|
|
tx_rings[i].desc = NULL;
|
|
tx_rings[i].tx_buf = NULL;
|
|
err = ice_setup_tx_ring(&tx_rings[i]);
|
|
if (err) {
|
|
while (i) {
|
|
i--;
|
|
ice_clean_tx_ring(&tx_rings[i]);
|
|
}
|
|
devm_kfree(&pf->pdev->dev, tx_rings);
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
process_rx:
|
|
if (new_rx_cnt == vsi->rx_rings[0]->count)
|
|
goto process_link;
|
|
|
|
/* alloc updated Rx resources */
|
|
netdev_info(netdev, "Changing Rx descriptor count from %d to %d\n",
|
|
vsi->rx_rings[0]->count, new_rx_cnt);
|
|
|
|
rx_rings = devm_kcalloc(&pf->pdev->dev, vsi->alloc_rxq,
|
|
sizeof(struct ice_ring), GFP_KERNEL);
|
|
if (!rx_rings) {
|
|
err = -ENOMEM;
|
|
goto done;
|
|
}
|
|
|
|
for (i = 0; i < vsi->alloc_rxq; i++) {
|
|
/* clone ring and setup updated count */
|
|
rx_rings[i] = *vsi->rx_rings[i];
|
|
rx_rings[i].count = new_rx_cnt;
|
|
rx_rings[i].desc = NULL;
|
|
rx_rings[i].rx_buf = NULL;
|
|
/* this is to allow wr32 to have something to write to
|
|
* during early allocation of Rx buffers
|
|
*/
|
|
rx_rings[i].tail = vsi->back->hw.hw_addr + PRTGEN_STATUS;
|
|
|
|
err = ice_setup_rx_ring(&rx_rings[i]);
|
|
if (err)
|
|
goto rx_unwind;
|
|
|
|
/* allocate Rx buffers */
|
|
err = ice_alloc_rx_bufs(&rx_rings[i],
|
|
ICE_DESC_UNUSED(&rx_rings[i]));
|
|
rx_unwind:
|
|
if (err) {
|
|
while (i) {
|
|
i--;
|
|
ice_free_rx_ring(&rx_rings[i]);
|
|
}
|
|
devm_kfree(&pf->pdev->dev, rx_rings);
|
|
err = -ENOMEM;
|
|
goto free_tx;
|
|
}
|
|
}
|
|
|
|
process_link:
|
|
/* Bring interface down, copy in the new ring info, then restore the
|
|
* interface. if VSI is up, bring it down and then back up
|
|
*/
|
|
if (!test_and_set_bit(__ICE_DOWN, vsi->state)) {
|
|
ice_down(vsi);
|
|
|
|
if (tx_rings) {
|
|
for (i = 0; i < vsi->alloc_txq; i++) {
|
|
ice_free_tx_ring(vsi->tx_rings[i]);
|
|
*vsi->tx_rings[i] = tx_rings[i];
|
|
}
|
|
devm_kfree(&pf->pdev->dev, tx_rings);
|
|
}
|
|
|
|
if (rx_rings) {
|
|
for (i = 0; i < vsi->alloc_rxq; i++) {
|
|
ice_free_rx_ring(vsi->rx_rings[i]);
|
|
/* copy the real tail offset */
|
|
rx_rings[i].tail = vsi->rx_rings[i]->tail;
|
|
/* this is to fake out the allocation routine
|
|
* into thinking it has to realloc everything
|
|
* but the recycling logic will let us re-use
|
|
* the buffers allocated above
|
|
*/
|
|
rx_rings[i].next_to_use = 0;
|
|
rx_rings[i].next_to_clean = 0;
|
|
rx_rings[i].next_to_alloc = 0;
|
|
*vsi->rx_rings[i] = rx_rings[i];
|
|
}
|
|
devm_kfree(&pf->pdev->dev, rx_rings);
|
|
}
|
|
|
|
ice_up(vsi);
|
|
}
|
|
goto done;
|
|
|
|
free_tx:
|
|
/* error cleanup if the Rx allocations failed after getting Tx */
|
|
if (tx_rings) {
|
|
for (i = 0; i < vsi->alloc_txq; i++)
|
|
ice_free_tx_ring(&tx_rings[i]);
|
|
devm_kfree(&pf->pdev->dev, tx_rings);
|
|
}
|
|
|
|
done:
|
|
clear_bit(__ICE_CFG_BUSY, pf->state);
|
|
return err;
|
|
}
|
|
|
|
static int ice_nway_reset(struct net_device *netdev)
|
|
{
|
|
/* restart autonegotiation */
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ice_link_status *hw_link_info;
|
|
struct ice_vsi *vsi = np->vsi;
|
|
struct ice_port_info *pi;
|
|
enum ice_status status;
|
|
bool link_up;
|
|
|
|
pi = vsi->port_info;
|
|
hw_link_info = &pi->phy.link_info;
|
|
link_up = hw_link_info->link_info & ICE_AQ_LINK_UP;
|
|
|
|
status = ice_aq_set_link_restart_an(pi, link_up, NULL);
|
|
if (status) {
|
|
netdev_info(netdev, "link restart failed, err %d aq_err %d\n",
|
|
status, pi->hw->adminq.sq_last_status);
|
|
return -EIO;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ice_get_pauseparam - Get Flow Control status
|
|
* @netdev: network interface device structure
|
|
* @pause: ethernet pause (flow control) parameters
|
|
*/
|
|
static void
|
|
ice_get_pauseparam(struct net_device *netdev, struct ethtool_pauseparam *pause)
|
|
{
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ice_port_info *pi;
|
|
|
|
pi = np->vsi->port_info;
|
|
pause->autoneg =
|
|
((pi->phy.link_info.an_info & ICE_AQ_AN_COMPLETED) ?
|
|
AUTONEG_ENABLE : AUTONEG_DISABLE);
|
|
|
|
if (pi->fc.current_mode == ICE_FC_RX_PAUSE) {
|
|
pause->rx_pause = 1;
|
|
} else if (pi->fc.current_mode == ICE_FC_TX_PAUSE) {
|
|
pause->tx_pause = 1;
|
|
} else if (pi->fc.current_mode == ICE_FC_FULL) {
|
|
pause->rx_pause = 1;
|
|
pause->tx_pause = 1;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ice_set_pauseparam - Set Flow Control parameter
|
|
* @netdev: network interface device structure
|
|
* @pause: return tx/rx flow control status
|
|
*/
|
|
static int
|
|
ice_set_pauseparam(struct net_device *netdev, struct ethtool_pauseparam *pause)
|
|
{
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ice_link_status *hw_link_info;
|
|
struct ice_pf *pf = np->vsi->back;
|
|
struct ice_vsi *vsi = np->vsi;
|
|
struct ice_hw *hw = &pf->hw;
|
|
struct ice_port_info *pi;
|
|
enum ice_status status;
|
|
u8 aq_failures;
|
|
bool link_up;
|
|
int err = 0;
|
|
|
|
pi = vsi->port_info;
|
|
hw_link_info = &pi->phy.link_info;
|
|
link_up = hw_link_info->link_info & ICE_AQ_LINK_UP;
|
|
|
|
/* Changing the port's flow control is not supported if this isn't the
|
|
* PF VSI
|
|
*/
|
|
if (vsi->type != ICE_VSI_PF) {
|
|
netdev_info(netdev, "Changing flow control parameters only supported for PF VSI\n");
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
if (pause->autoneg != (hw_link_info->an_info & ICE_AQ_AN_COMPLETED)) {
|
|
netdev_info(netdev, "To change autoneg please use: ethtool -s <dev> autoneg <on|off>\n");
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
/* If we have link and don't have autoneg */
|
|
if (!test_bit(__ICE_DOWN, pf->state) &&
|
|
!(hw_link_info->an_info & ICE_AQ_AN_COMPLETED)) {
|
|
/* Send message that it might not necessarily work*/
|
|
netdev_info(netdev, "Autoneg did not complete so changing settings may not result in an actual change.\n");
|
|
}
|
|
|
|
if (pause->rx_pause && pause->tx_pause)
|
|
pi->fc.req_mode = ICE_FC_FULL;
|
|
else if (pause->rx_pause && !pause->tx_pause)
|
|
pi->fc.req_mode = ICE_FC_RX_PAUSE;
|
|
else if (!pause->rx_pause && pause->tx_pause)
|
|
pi->fc.req_mode = ICE_FC_TX_PAUSE;
|
|
else if (!pause->rx_pause && !pause->tx_pause)
|
|
pi->fc.req_mode = ICE_FC_NONE;
|
|
else
|
|
return -EINVAL;
|
|
|
|
/* Tell the OS link is going down, the link will go back up when fw
|
|
* says it is ready asynchronously
|
|
*/
|
|
ice_print_link_msg(vsi, false);
|
|
netif_carrier_off(netdev);
|
|
netif_tx_stop_all_queues(netdev);
|
|
|
|
/* Set the FC mode and only restart AN if link is up */
|
|
status = ice_set_fc(pi, &aq_failures, link_up);
|
|
|
|
if (aq_failures & ICE_SET_FC_AQ_FAIL_GET) {
|
|
netdev_info(netdev, "Set fc failed on the get_phy_capabilities call with err %d aq_err %d\n",
|
|
status, hw->adminq.sq_last_status);
|
|
err = -EAGAIN;
|
|
} else if (aq_failures & ICE_SET_FC_AQ_FAIL_SET) {
|
|
netdev_info(netdev, "Set fc failed on the set_phy_config call with err %d aq_err %d\n",
|
|
status, hw->adminq.sq_last_status);
|
|
err = -EAGAIN;
|
|
} else if (aq_failures & ICE_SET_FC_AQ_FAIL_UPDATE) {
|
|
netdev_info(netdev, "Set fc failed on the get_link_info call with err %d aq_err %d\n",
|
|
status, hw->adminq.sq_last_status);
|
|
err = -EAGAIN;
|
|
}
|
|
|
|
if (!test_bit(__ICE_DOWN, pf->state)) {
|
|
/* Give it a little more time to try to come back. If still
|
|
* down, restart autoneg link or reinitialize the interface.
|
|
*/
|
|
msleep(75);
|
|
if (!test_bit(__ICE_DOWN, pf->state))
|
|
return ice_nway_reset(netdev);
|
|
|
|
ice_down(vsi);
|
|
ice_up(vsi);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* ice_get_rxfh_key_size - get the RSS hash key size
|
|
* @netdev: network interface device structure
|
|
*
|
|
* Returns the table size.
|
|
*/
|
|
static u32 ice_get_rxfh_key_size(struct net_device __always_unused *netdev)
|
|
{
|
|
return ICE_VSIQF_HKEY_ARRAY_SIZE;
|
|
}
|
|
|
|
/**
|
|
* ice_get_rxfh_indir_size - get the rx flow hash indirection table size
|
|
* @netdev: network interface device structure
|
|
*
|
|
* Returns the table size.
|
|
*/
|
|
static u32 ice_get_rxfh_indir_size(struct net_device *netdev)
|
|
{
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
|
|
return np->vsi->rss_table_size;
|
|
}
|
|
|
|
/**
|
|
* ice_get_rxfh - get the rx flow hash indirection table
|
|
* @netdev: network interface device structure
|
|
* @indir: indirection table
|
|
* @key: hash key
|
|
* @hfunc: hash function
|
|
*
|
|
* Reads the indirection table directly from the hardware.
|
|
*/
|
|
static int
|
|
ice_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key, u8 *hfunc)
|
|
{
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ice_vsi *vsi = np->vsi;
|
|
struct ice_pf *pf = vsi->back;
|
|
int ret = 0, i;
|
|
u8 *lut;
|
|
|
|
if (hfunc)
|
|
*hfunc = ETH_RSS_HASH_TOP;
|
|
|
|
if (!indir)
|
|
return 0;
|
|
|
|
if (!test_bit(ICE_FLAG_RSS_ENA, pf->flags)) {
|
|
/* RSS not supported return error here */
|
|
netdev_warn(netdev, "RSS is not configured on this VSI!\n");
|
|
return -EIO;
|
|
}
|
|
|
|
lut = devm_kzalloc(&pf->pdev->dev, vsi->rss_table_size, GFP_KERNEL);
|
|
if (!lut)
|
|
return -ENOMEM;
|
|
|
|
if (ice_get_rss(vsi, key, lut, vsi->rss_table_size)) {
|
|
ret = -EIO;
|
|
goto out;
|
|
}
|
|
|
|
for (i = 0; i < vsi->rss_table_size; i++)
|
|
indir[i] = (u32)(lut[i]);
|
|
|
|
out:
|
|
devm_kfree(&pf->pdev->dev, lut);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* ice_set_rxfh - set the rx flow hash indirection table
|
|
* @netdev: network interface device structure
|
|
* @indir: indirection table
|
|
* @key: hash key
|
|
* @hfunc: hash function
|
|
*
|
|
* Returns -EINVAL if the table specifies an invalid queue id, otherwise
|
|
* returns 0 after programming the table.
|
|
*/
|
|
static int ice_set_rxfh(struct net_device *netdev, const u32 *indir,
|
|
const u8 *key, const u8 hfunc)
|
|
{
|
|
struct ice_netdev_priv *np = netdev_priv(netdev);
|
|
struct ice_vsi *vsi = np->vsi;
|
|
struct ice_pf *pf = vsi->back;
|
|
u8 *seed = NULL;
|
|
|
|
if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (!test_bit(ICE_FLAG_RSS_ENA, pf->flags)) {
|
|
/* RSS not supported return error here */
|
|
netdev_warn(netdev, "RSS is not configured on this VSI!\n");
|
|
return -EIO;
|
|
}
|
|
|
|
if (key) {
|
|
if (!vsi->rss_hkey_user) {
|
|
vsi->rss_hkey_user =
|
|
devm_kzalloc(&pf->pdev->dev,
|
|
ICE_VSIQF_HKEY_ARRAY_SIZE,
|
|
GFP_KERNEL);
|
|
if (!vsi->rss_hkey_user)
|
|
return -ENOMEM;
|
|
}
|
|
memcpy(vsi->rss_hkey_user, key, ICE_VSIQF_HKEY_ARRAY_SIZE);
|
|
seed = vsi->rss_hkey_user;
|
|
}
|
|
|
|
if (!vsi->rss_lut_user) {
|
|
vsi->rss_lut_user = devm_kzalloc(&pf->pdev->dev,
|
|
vsi->rss_table_size,
|
|
GFP_KERNEL);
|
|
if (!vsi->rss_lut_user)
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/* Each 32 bits pointed by 'indir' is stored with a lut entry */
|
|
if (indir) {
|
|
int i;
|
|
|
|
for (i = 0; i < vsi->rss_table_size; i++)
|
|
vsi->rss_lut_user[i] = (u8)(indir[i]);
|
|
} else {
|
|
ice_fill_rss_lut(vsi->rss_lut_user, vsi->rss_table_size,
|
|
vsi->rss_size);
|
|
}
|
|
|
|
if (ice_set_rss(vsi, seed, vsi->rss_lut_user, vsi->rss_table_size))
|
|
return -EIO;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct ethtool_ops ice_ethtool_ops = {
|
|
.get_link_ksettings = ice_get_link_ksettings,
|
|
.set_link_ksettings = ice_set_link_ksettings,
|
|
.get_drvinfo = ice_get_drvinfo,
|
|
.get_regs_len = ice_get_regs_len,
|
|
.get_regs = ice_get_regs,
|
|
.get_msglevel = ice_get_msglevel,
|
|
.set_msglevel = ice_set_msglevel,
|
|
.get_link = ethtool_op_get_link,
|
|
.get_strings = ice_get_strings,
|
|
.get_ethtool_stats = ice_get_ethtool_stats,
|
|
.get_sset_count = ice_get_sset_count,
|
|
.get_rxnfc = ice_get_rxnfc,
|
|
.get_ringparam = ice_get_ringparam,
|
|
.set_ringparam = ice_set_ringparam,
|
|
.nway_reset = ice_nway_reset,
|
|
.get_pauseparam = ice_get_pauseparam,
|
|
.set_pauseparam = ice_set_pauseparam,
|
|
.get_rxfh_key_size = ice_get_rxfh_key_size,
|
|
.get_rxfh_indir_size = ice_get_rxfh_indir_size,
|
|
.get_rxfh = ice_get_rxfh,
|
|
.set_rxfh = ice_set_rxfh,
|
|
};
|
|
|
|
/**
|
|
* ice_set_ethtool_ops - setup netdev ethtool ops
|
|
* @netdev: network interface device structure
|
|
*
|
|
* setup netdev ethtool ops with ice specific ops
|
|
*/
|
|
void ice_set_ethtool_ops(struct net_device *netdev)
|
|
{
|
|
netdev->ethtool_ops = &ice_ethtool_ops;
|
|
}
|