Commit 3049f0fd authored by David S. Miller's avatar David S. Miller

Merge branch '40GbE' of git://git.kernel.org/pub/scm/linux/kernel/git/jkirsher/net-queue

Jeff Kirsher says:

====================
Intel Wired LAN Driver Updates 2020-06-11

This series contains fixes to the iavf driver.

Brett fixes the supported link speeds in the iavf driver, which was only
able to report speeds that the i40e driver supported and was missing the
speeds supported by the ice driver.  In addition, fix how 2.5 and 5.0
GbE speeds are reported.

Alek fixes a enum comparison that was comparing two different enums that
may have different values, so update the comparison to use matching
enums.

Paul increases the time to complete a reset to allow for 128 VFs to
complete a reset.
====================
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 07007dbe 8e3e4b9d
......@@ -87,6 +87,10 @@ struct iavf_vsi {
#define IAVF_HLUT_ARRAY_SIZE ((IAVF_VFQF_HLUT_MAX_INDEX + 1) * 4)
#define IAVF_MBPS_DIVISOR 125000 /* divisor to convert to Mbps */
#define IAVF_VIRTCHNL_VF_RESOURCE_SIZE (sizeof(struct virtchnl_vf_resource) + \
(IAVF_MAX_VF_VSI * \
sizeof(struct virtchnl_vsi_resource)))
/* MAX_MSIX_Q_VECTORS of these are allocated,
* but we only use one per queue-specific vector.
*/
......@@ -215,6 +219,10 @@ struct iavf_cloud_filter {
bool add; /* filter needs to be added */
};
#define IAVF_RESET_WAIT_MS 10
#define IAVF_RESET_WAIT_DETECTED_COUNT 500
#define IAVF_RESET_WAIT_COMPLETE_COUNT 2000
/* board specific private data structure */
struct iavf_adapter {
struct work_struct reset_task;
......@@ -306,6 +314,14 @@ struct iavf_adapter {
bool netdev_registered;
bool link_up;
enum virtchnl_link_speed link_speed;
/* This is only populated if the VIRTCHNL_VF_CAP_ADV_LINK_SPEED is set
* in vf_res->vf_cap_flags. Use ADV_LINK_SUPPORT macro to determine if
* this field is valid. This field should be used going forward and the
* enum virtchnl_link_speed above should be considered the legacy way of
* storing/communicating link speeds.
*/
u32 link_speed_mbps;
enum virtchnl_ops current_op;
#define CLIENT_ALLOWED(_a) ((_a)->vf_res ? \
(_a)->vf_res->vf_cap_flags & \
......@@ -322,6 +338,8 @@ struct iavf_adapter {
VIRTCHNL_VF_OFFLOAD_RSS_PF)))
#define VLAN_ALLOWED(_a) ((_a)->vf_res->vf_cap_flags & \
VIRTCHNL_VF_OFFLOAD_VLAN)
#define ADV_LINK_SUPPORT(_a) ((_a)->vf_res->vf_cap_flags & \
VIRTCHNL_VF_CAP_ADV_LINK_SPEED)
struct virtchnl_vf_resource *vf_res; /* incl. all VSIs */
struct virtchnl_vsi_resource *vsi_res; /* our LAN VSI */
struct virtchnl_version_info pf_version;
......
......@@ -278,35 +278,46 @@ static int iavf_get_link_ksettings(struct net_device *netdev,
ethtool_link_ksettings_zero_link_mode(cmd, supported);
cmd->base.autoneg = AUTONEG_DISABLE;
cmd->base.port = PORT_NONE;
/* Set speed and duplex */
cmd->base.duplex = DUPLEX_FULL;
if (ADV_LINK_SUPPORT(adapter)) {
if (adapter->link_speed_mbps &&
adapter->link_speed_mbps < U32_MAX)
cmd->base.speed = adapter->link_speed_mbps;
else
cmd->base.speed = SPEED_UNKNOWN;
return 0;
}
switch (adapter->link_speed) {
case IAVF_LINK_SPEED_40GB:
case VIRTCHNL_LINK_SPEED_40GB:
cmd->base.speed = SPEED_40000;
break;
case IAVF_LINK_SPEED_25GB:
#ifdef SPEED_25000
case VIRTCHNL_LINK_SPEED_25GB:
cmd->base.speed = SPEED_25000;
#else
netdev_info(netdev,
"Speed is 25G, display not supported by this version of ethtool.\n");
#endif
break;
case IAVF_LINK_SPEED_20GB:
case VIRTCHNL_LINK_SPEED_20GB:
cmd->base.speed = SPEED_20000;
break;
case IAVF_LINK_SPEED_10GB:
case VIRTCHNL_LINK_SPEED_10GB:
cmd->base.speed = SPEED_10000;
break;
case IAVF_LINK_SPEED_1GB:
case VIRTCHNL_LINK_SPEED_5GB:
cmd->base.speed = SPEED_5000;
break;
case VIRTCHNL_LINK_SPEED_2_5GB:
cmd->base.speed = SPEED_2500;
break;
case VIRTCHNL_LINK_SPEED_1GB:
cmd->base.speed = SPEED_1000;
break;
case IAVF_LINK_SPEED_100MB:
case VIRTCHNL_LINK_SPEED_100MB:
cmd->base.speed = SPEED_100;
break;
default:
break;
}
cmd->base.duplex = DUPLEX_FULL;
return 0;
}
......
......@@ -1756,18 +1756,18 @@ static int iavf_init_get_resources(struct iavf_adapter *adapter)
struct net_device *netdev = adapter->netdev;
struct pci_dev *pdev = adapter->pdev;
struct iavf_hw *hw = &adapter->hw;
int err = 0, bufsz;
int err;
WARN_ON(adapter->state != __IAVF_INIT_GET_RESOURCES);
/* aq msg sent, awaiting reply */
if (!adapter->vf_res) {
bufsz = sizeof(struct virtchnl_vf_resource) +
(IAVF_MAX_VF_VSI *
sizeof(struct virtchnl_vsi_resource));
adapter->vf_res = kzalloc(bufsz, GFP_KERNEL);
if (!adapter->vf_res)
adapter->vf_res = kzalloc(IAVF_VIRTCHNL_VF_RESOURCE_SIZE,
GFP_KERNEL);
if (!adapter->vf_res) {
err = -ENOMEM;
goto err;
}
}
err = iavf_get_vf_config(adapter);
if (err == IAVF_ERR_ADMIN_QUEUE_NO_WORK) {
err = iavf_send_vf_config_msg(adapter);
......@@ -2036,7 +2036,7 @@ static void iavf_disable_vf(struct iavf_adapter *adapter)
iavf_reset_interrupt_capability(adapter);
iavf_free_queues(adapter);
iavf_free_q_vectors(adapter);
kfree(adapter->vf_res);
memset(adapter->vf_res, 0, IAVF_VIRTCHNL_VF_RESOURCE_SIZE);
iavf_shutdown_adminq(&adapter->hw);
adapter->netdev->flags &= ~IFF_UP;
clear_bit(__IAVF_IN_CRITICAL_TASK, &adapter->crit_section);
......@@ -2046,8 +2046,6 @@ static void iavf_disable_vf(struct iavf_adapter *adapter)
dev_info(&adapter->pdev->dev, "Reset task did not complete, VF disabled\n");
}
#define IAVF_RESET_WAIT_MS 10
#define IAVF_RESET_WAIT_COUNT 500
/**
* iavf_reset_task - Call-back task to handle hardware reset
* @work: pointer to work_struct
......@@ -2101,20 +2099,20 @@ static void iavf_reset_task(struct work_struct *work)
adapter->flags |= IAVF_FLAG_RESET_PENDING;
/* poll until we see the reset actually happen */
for (i = 0; i < IAVF_RESET_WAIT_COUNT; i++) {
for (i = 0; i < IAVF_RESET_WAIT_DETECTED_COUNT; i++) {
reg_val = rd32(hw, IAVF_VF_ARQLEN1) &
IAVF_VF_ARQLEN1_ARQENABLE_MASK;
if (!reg_val)
break;
usleep_range(5000, 10000);
}
if (i == IAVF_RESET_WAIT_COUNT) {
if (i == IAVF_RESET_WAIT_DETECTED_COUNT) {
dev_info(&adapter->pdev->dev, "Never saw reset\n");
goto continue_reset; /* act like the reset happened */
}
/* wait until the reset is complete and the PF is responding to us */
for (i = 0; i < IAVF_RESET_WAIT_COUNT; i++) {
for (i = 0; i < IAVF_RESET_WAIT_COMPLETE_COUNT; i++) {
/* sleep first to make sure a minimum wait time is met */
msleep(IAVF_RESET_WAIT_MS);
......@@ -2126,7 +2124,7 @@ static void iavf_reset_task(struct work_struct *work)
pci_set_master(adapter->pdev);
if (i == IAVF_RESET_WAIT_COUNT) {
if (i == IAVF_RESET_WAIT_COMPLETE_COUNT) {
dev_err(&adapter->pdev->dev, "Reset never finished (%x)\n",
reg_val);
iavf_disable_vf(adapter);
......@@ -2487,29 +2485,46 @@ static int iavf_validate_tx_bandwidth(struct iavf_adapter *adapter,
{
int speed = 0, ret = 0;
if (ADV_LINK_SUPPORT(adapter)) {
if (adapter->link_speed_mbps < U32_MAX) {
speed = adapter->link_speed_mbps;
goto validate_bw;
} else {
dev_err(&adapter->pdev->dev, "Unknown link speed\n");
return -EINVAL;
}
}
switch (adapter->link_speed) {
case IAVF_LINK_SPEED_40GB:
speed = 40000;
case VIRTCHNL_LINK_SPEED_40GB:
speed = SPEED_40000;
break;
case VIRTCHNL_LINK_SPEED_25GB:
speed = SPEED_25000;
break;
case VIRTCHNL_LINK_SPEED_20GB:
speed = SPEED_20000;
break;
case IAVF_LINK_SPEED_25GB:
speed = 25000;
case VIRTCHNL_LINK_SPEED_10GB:
speed = SPEED_10000;
break;
case IAVF_LINK_SPEED_20GB:
speed = 20000;
case VIRTCHNL_LINK_SPEED_5GB:
speed = SPEED_5000;
break;
case IAVF_LINK_SPEED_10GB:
speed = 10000;
case VIRTCHNL_LINK_SPEED_2_5GB:
speed = SPEED_2500;
break;
case IAVF_LINK_SPEED_1GB:
speed = 1000;
case VIRTCHNL_LINK_SPEED_1GB:
speed = SPEED_1000;
break;
case IAVF_LINK_SPEED_100MB:
speed = 100;
case VIRTCHNL_LINK_SPEED_100MB:
speed = SPEED_100;
break;
default:
break;
}
validate_bw:
if (max_tx_rate > speed) {
dev_err(&adapter->pdev->dev,
"Invalid tx rate specified\n");
......@@ -3412,7 +3427,7 @@ static int iavf_check_reset_complete(struct iavf_hw *hw)
u32 rstat;
int i;
for (i = 0; i < 100; i++) {
for (i = 0; i < IAVF_RESET_WAIT_COMPLETE_COUNT; i++) {
rstat = rd32(hw, IAVF_VFGEN_RSTAT) &
IAVF_VFGEN_RSTAT_VFR_STATE_MASK;
if ((rstat == VIRTCHNL_VFR_VFACTIVE) ||
......
......@@ -379,19 +379,19 @@ static inline unsigned int iavf_itr_divisor(struct iavf_q_vector *q_vector)
unsigned int divisor;
switch (q_vector->adapter->link_speed) {
case IAVF_LINK_SPEED_40GB:
case VIRTCHNL_LINK_SPEED_40GB:
divisor = IAVF_ITR_ADAPTIVE_MIN_INC * 1024;
break;
case IAVF_LINK_SPEED_25GB:
case IAVF_LINK_SPEED_20GB:
case VIRTCHNL_LINK_SPEED_25GB:
case VIRTCHNL_LINK_SPEED_20GB:
divisor = IAVF_ITR_ADAPTIVE_MIN_INC * 512;
break;
default:
case IAVF_LINK_SPEED_10GB:
case VIRTCHNL_LINK_SPEED_10GB:
divisor = IAVF_ITR_ADAPTIVE_MIN_INC * 256;
break;
case IAVF_LINK_SPEED_1GB:
case IAVF_LINK_SPEED_100MB:
case VIRTCHNL_LINK_SPEED_1GB:
case VIRTCHNL_LINK_SPEED_100MB:
divisor = IAVF_ITR_ADAPTIVE_MIN_INC * 32;
break;
}
......
......@@ -139,7 +139,8 @@ int iavf_send_vf_config_msg(struct iavf_adapter *adapter)
VIRTCHNL_VF_OFFLOAD_ENCAP |
VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM |
VIRTCHNL_VF_OFFLOAD_REQ_QUEUES |
VIRTCHNL_VF_OFFLOAD_ADQ;
VIRTCHNL_VF_OFFLOAD_ADQ |
VIRTCHNL_VF_CAP_ADV_LINK_SPEED;
adapter->current_op = VIRTCHNL_OP_GET_VF_RESOURCES;
adapter->aq_required &= ~IAVF_FLAG_AQ_GET_CONFIG;
......@@ -891,6 +892,8 @@ void iavf_disable_vlan_stripping(struct iavf_adapter *adapter)
iavf_send_pf_msg(adapter, VIRTCHNL_OP_DISABLE_VLAN_STRIPPING, NULL, 0);
}
#define IAVF_MAX_SPEED_STRLEN 13
/**
* iavf_print_link_message - print link up or down
* @adapter: adapter structure
......@@ -900,37 +903,105 @@ void iavf_disable_vlan_stripping(struct iavf_adapter *adapter)
static void iavf_print_link_message(struct iavf_adapter *adapter)
{
struct net_device *netdev = adapter->netdev;
char *speed = "Unknown ";
int link_speed_mbps;
char *speed;
if (!adapter->link_up) {
netdev_info(netdev, "NIC Link is Down\n");
return;
}
speed = kcalloc(1, IAVF_MAX_SPEED_STRLEN, GFP_KERNEL);
if (!speed)
return;
if (ADV_LINK_SUPPORT(adapter)) {
link_speed_mbps = adapter->link_speed_mbps;
goto print_link_msg;
}
switch (adapter->link_speed) {
case IAVF_LINK_SPEED_40GB:
speed = "40 G";
case VIRTCHNL_LINK_SPEED_40GB:
link_speed_mbps = SPEED_40000;
break;
case VIRTCHNL_LINK_SPEED_25GB:
link_speed_mbps = SPEED_25000;
break;
case VIRTCHNL_LINK_SPEED_20GB:
link_speed_mbps = SPEED_20000;
break;
case IAVF_LINK_SPEED_25GB:
speed = "25 G";
case VIRTCHNL_LINK_SPEED_10GB:
link_speed_mbps = SPEED_10000;
break;
case IAVF_LINK_SPEED_20GB:
speed = "20 G";
case VIRTCHNL_LINK_SPEED_5GB:
link_speed_mbps = SPEED_5000;
break;
case IAVF_LINK_SPEED_10GB:
speed = "10 G";
case VIRTCHNL_LINK_SPEED_2_5GB:
link_speed_mbps = SPEED_2500;
break;
case IAVF_LINK_SPEED_1GB:
speed = "1000 M";
case VIRTCHNL_LINK_SPEED_1GB:
link_speed_mbps = SPEED_1000;
break;
case IAVF_LINK_SPEED_100MB:
speed = "100 M";
case VIRTCHNL_LINK_SPEED_100MB:
link_speed_mbps = SPEED_100;
break;
default:
link_speed_mbps = SPEED_UNKNOWN;
break;
}
netdev_info(netdev, "NIC Link is Up %sbps Full Duplex\n", speed);
print_link_msg:
if (link_speed_mbps > SPEED_1000) {
if (link_speed_mbps == SPEED_2500)
snprintf(speed, IAVF_MAX_SPEED_STRLEN, "2.5 Gbps");
else
/* convert to Gbps inline */
snprintf(speed, IAVF_MAX_SPEED_STRLEN, "%d %s",
link_speed_mbps / 1000, "Gbps");
} else if (link_speed_mbps == SPEED_UNKNOWN) {
snprintf(speed, IAVF_MAX_SPEED_STRLEN, "%s", "Unknown Mbps");
} else {
snprintf(speed, IAVF_MAX_SPEED_STRLEN, "%u %s",
link_speed_mbps, "Mbps");
}
netdev_info(netdev, "NIC Link is Up Speed is %s Full Duplex\n", speed);
kfree(speed);
}
/**
* iavf_get_vpe_link_status
* @adapter: adapter structure
* @vpe: virtchnl_pf_event structure
*
* Helper function for determining the link status
**/
static bool
iavf_get_vpe_link_status(struct iavf_adapter *adapter,
struct virtchnl_pf_event *vpe)
{
if (ADV_LINK_SUPPORT(adapter))
return vpe->event_data.link_event_adv.link_status;
else
return vpe->event_data.link_event.link_status;
}
/**
* iavf_set_adapter_link_speed_from_vpe
* @adapter: adapter structure for which we are setting the link speed
* @vpe: virtchnl_pf_event structure that contains the link speed we are setting
*
* Helper function for setting iavf_adapter link speed
**/
static void
iavf_set_adapter_link_speed_from_vpe(struct iavf_adapter *adapter,
struct virtchnl_pf_event *vpe)
{
if (ADV_LINK_SUPPORT(adapter))
adapter->link_speed_mbps =
vpe->event_data.link_event_adv.link_speed;
else
adapter->link_speed = vpe->event_data.link_event.link_speed;
}
/**
......@@ -1160,12 +1231,11 @@ void iavf_virtchnl_completion(struct iavf_adapter *adapter,
if (v_opcode == VIRTCHNL_OP_EVENT) {
struct virtchnl_pf_event *vpe =
(struct virtchnl_pf_event *)msg;
bool link_up = vpe->event_data.link_event.link_status;
bool link_up = iavf_get_vpe_link_status(adapter, vpe);
switch (vpe->event) {
case VIRTCHNL_EVENT_LINK_CHANGE:
adapter->link_speed =
vpe->event_data.link_event.link_speed;
iavf_set_adapter_link_speed_from_vpe(adapter, vpe);
/* we've already got the right link status, bail */
if (adapter->link_up == link_up)
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment