23 files changed, 293 insertions, 116 deletions

diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index fc63992ab0e0..c99dc59d729b 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -4289,7 +4289,7 @@ static int bond_check_params(struct bond_params *params)
         int bond_mode   = BOND_MODE_ROUNDROBIN;
         int xmit_hashtype = BOND_XMIT_POLICY_LAYER2;
         int lacp_fast = 0;
-        int tlb_dynamic_lb = 0;
+        int tlb_dynamic_lb;
 
         /* Convert string parameters. */
         if (mode) {
@@ -4601,16 +4601,13 @@ static int bond_check_params(struct bond_params *params)
         }
         ad_user_port_key = valptr->value;
 
-        if ((bond_mode == BOND_MODE_TLB) || (bond_mode == BOND_MODE_ALB)) {
-                bond_opt_initstr(&newval, "default");
-                valptr = bond_opt_parse(bond_opt_get(BOND_OPT_TLB_DYNAMIC_LB),
-                                        &newval);
-                if (!valptr) {
-                        pr_err("Error: No tlb_dynamic_lb default value");
-                        return -EINVAL;
-                }
-                tlb_dynamic_lb = valptr->value;
+        bond_opt_initstr(&newval, "default");
+        valptr = bond_opt_parse(bond_opt_get(BOND_OPT_TLB_DYNAMIC_LB), &newval);
+        if (!valptr) {
+                pr_err("Error: No tlb_dynamic_lb default value");
+                return -EINVAL;
         }
+        tlb_dynamic_lb = valptr->value;
 
         if (lp_interval == 0) {
                 pr_warn("Warning: ip_interval must be between 1 and %d, so it was reset to %d\n",
diff --git a/drivers/net/bonding/bond_options.c b/drivers/net/bonding/bond_options.c
index a12d603d41c6..5931aa2fe997 100644
--- a/drivers/net/bonding/bond_options.c
+++ b/drivers/net/bonding/bond_options.c
@@ -754,6 +754,9 @@ static int bond_option_mode_set(struct bonding *bond,
                            bond->params.miimon);
         }
 
+        if (newval->value == BOND_MODE_ALB)
+                bond->params.tlb_dynamic_lb = 1;
+
         /* don't cache arp_validate between modes */
         bond->params.arp_validate = BOND_ARP_VALIDATE_NONE;
         bond->params.mode = newval->value;
diff --git a/drivers/net/ethernet/broadcom/bcmsysport.c b/drivers/net/ethernet/broadcom/bcmsysport.c
index a6572b51435a..c3c53f6cd9e6 100644
--- a/drivers/net/ethernet/broadcom/bcmsysport.c
+++ b/drivers/net/ethernet/broadcom/bcmsysport.c
@@ -1735,11 +1735,8 @@ static void bcm_sysport_get_stats64(struct net_device *dev,
                 stats->tx_packets += tx_packets;
         }
 
-        /* lockless update tx_bytes and tx_packets */
-        u64_stats_update_begin(&priv->syncp);
         stats64->tx_bytes = stats->tx_bytes;
         stats64->tx_packets = stats->tx_packets;
-        u64_stats_update_end(&priv->syncp);
 
         do {
                 start = u64_stats_fetch_begin_irq(&priv->syncp);
diff --git a/drivers/net/ethernet/broadcom/tg3.c b/drivers/net/ethernet/broadcom/tg3.c
index af33dc15c55f..656e6af70f0a 100644
--- a/drivers/net/ethernet/broadcom/tg3.c
+++ b/drivers/net/ethernet/broadcom/tg3.c
@@ -11536,11 +11536,11 @@ static int tg3_start(struct tg3 *tp, bool reset_phy, bool test_irq,
         tg3_napi_enable(tp);
 
         for (i = 0; i < tp->irq_cnt; i++) {
-                struct tg3_napi *tnapi = &tp->napi[i];
                 err = tg3_request_irq(tp, i);
                 if (err) {
                         for (i--; i >= 0; i--) {
-                                tnapi = &tp->napi[i];
+                                struct tg3_napi *tnapi = &tp->napi[i];
+
                                 free_irq(tnapi->irq_vec, tnapi);
                         }
                         goto out_napi_fini;
diff --git a/drivers/net/ethernet/emulex/benet/be.h b/drivers/net/ethernet/emulex/benet/be.h
index 674cf9d13b98..8984c4938881 100644
--- a/drivers/net/ethernet/emulex/benet/be.h
+++ b/drivers/net/ethernet/emulex/benet/be.h
@@ -930,6 +930,14 @@ static inline bool is_ipv4_pkt(struct sk_buff *skb)
         return skb->protocol == htons(ETH_P_IP) && ip_hdr(skb)->version == 4;
 }
 
+static inline bool is_ipv6_ext_hdr(struct sk_buff *skb)
+{
+        if (ip_hdr(skb)->version == 6)
+                return ipv6_ext_hdr(ipv6_hdr(skb)->nexthdr);
+        else
+                return false;
+}
+
 #define be_error_recovering(adapter)    \
                 (adapter->flags & BE_FLAGS_TRY_RECOVERY)
 
diff --git a/drivers/net/ethernet/emulex/benet/be_main.c b/drivers/net/ethernet/emulex/benet/be_main.c
index 319eee36649b..0e3d9f39a807 100644
--- a/drivers/net/ethernet/emulex/benet/be_main.c
+++ b/drivers/net/ethernet/emulex/benet/be_main.c
@@ -5089,6 +5089,20 @@ static netdev_features_t be_features_check(struct sk_buff *skb,
         struct be_adapter *adapter = netdev_priv(dev);
         u8 l4_hdr = 0;
 
+        if (skb_is_gso(skb)) {
+                /* IPv6 TSO requests with extension hdrs are a problem
+                 * to Lancer and BE3 HW. Disable TSO6 feature.
+                 */
+                if (!skyhawk_chip(adapter) && is_ipv6_ext_hdr(skb))
+                        features &= ~NETIF_F_TSO6;
+
+                /* Lancer cannot handle the packet with MSS less than 256.
+                 * Disable the GSO support in such cases
+                 */
+                if (lancer_chip(adapter) && skb_shinfo(skb)->gso_size < 256)
+                        features &= ~NETIF_F_GSO_MASK;
+        }
+
         /* The code below restricts offload features for some tunneled and
          * Q-in-Q packets.
          * Offload features for normal (non tunnel) packets are unchanged.
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
index ed7cd6c48019..696b99e65a5a 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
@@ -575,15 +575,14 @@ static void mlxsw_sp_span_entry_destroy(struct mlxsw_sp *mlxsw_sp,
 }
 
 static struct mlxsw_sp_span_entry *
-mlxsw_sp_span_entry_find(struct mlxsw_sp_port *port)
+mlxsw_sp_span_entry_find(struct mlxsw_sp *mlxsw_sp, u8 local_port)
 {
-        struct mlxsw_sp *mlxsw_sp = port->mlxsw_sp;
         int i;
 
         for (i = 0; i < mlxsw_sp->span.entries_count; i++) {
                 struct mlxsw_sp_span_entry *curr = &mlxsw_sp->span.entries[i];
 
-                if (curr->used && curr->local_port == port->local_port)
+                if (curr->used && curr->local_port == local_port)
                         return curr;
         }
         return NULL;
@@ -594,7 +593,8 @@ static struct mlxsw_sp_span_entry
 {
         struct mlxsw_sp_span_entry *span_entry;
 
-        span_entry = mlxsw_sp_span_entry_find(port);
+        span_entry = mlxsw_sp_span_entry_find(port->mlxsw_sp,
+                                              port->local_port);
         if (span_entry) {
                 /* Already exists, just take a reference */
                 span_entry->ref_count++;
@@ -783,12 +783,13 @@ err_port_bind:
 }
 
 static void mlxsw_sp_span_mirror_remove(struct mlxsw_sp_port *from,
-                                        struct mlxsw_sp_port *to,
+                                        u8 destination_port,
                                         enum mlxsw_sp_span_type type)
 {
         struct mlxsw_sp_span_entry *span_entry;
 
-        span_entry = mlxsw_sp_span_entry_find(to);
+        span_entry = mlxsw_sp_span_entry_find(from->mlxsw_sp,
+                                              destination_port);
         if (!span_entry) {
                 netdev_err(from->dev, "no span entry found\n");
                 return;
@@ -1563,14 +1564,12 @@ static void
 mlxsw_sp_port_del_cls_matchall_mirror(struct mlxsw_sp_port *mlxsw_sp_port,
                                       struct mlxsw_sp_port_mall_mirror_tc_entry *mirror)
 {
-        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
         enum mlxsw_sp_span_type span_type;
-        struct mlxsw_sp_port *to_port;
 
-        to_port = mlxsw_sp->ports[mirror->to_local_port];
         span_type = mirror->ingress ?
                         MLXSW_SP_SPAN_INGRESS : MLXSW_SP_SPAN_EGRESS;
-        mlxsw_sp_span_mirror_remove(mlxsw_sp_port, to_port, span_type);
+        mlxsw_sp_span_mirror_remove(mlxsw_sp_port, mirror->to_local_port,
+                                    span_type);
 }
 
 static int
@@ -2545,7 +2544,9 @@ out:
         return err;
 }
 
-#define MLXSW_SP_QSFP_I2C_ADDR 0x50
+#define MLXSW_SP_I2C_ADDR_LOW 0x50
+#define MLXSW_SP_I2C_ADDR_HIGH 0x51
+#define MLXSW_SP_EEPROM_PAGE_LENGTH 256
 
 static int mlxsw_sp_query_module_eeprom(struct mlxsw_sp_port *mlxsw_sp_port,
                                         u16 offset, u16 size, void *data,
@@ -2554,12 +2555,25 @@ static int mlxsw_sp_query_module_eeprom(struct mlxsw_sp_port *mlxsw_sp_port,
         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
         char eeprom_tmp[MLXSW_SP_REG_MCIA_EEPROM_SIZE];
         char mcia_pl[MLXSW_REG_MCIA_LEN];
+        u16 i2c_addr;
         int status;
         int err;
 
         size = min_t(u16, size, MLXSW_SP_REG_MCIA_EEPROM_SIZE);
+
+        if (offset < MLXSW_SP_EEPROM_PAGE_LENGTH &&
+            offset + size > MLXSW_SP_EEPROM_PAGE_LENGTH)
+                /* Cross pages read, read until offset 256 in low page */
+                size = MLXSW_SP_EEPROM_PAGE_LENGTH - offset;
+
+        i2c_addr = MLXSW_SP_I2C_ADDR_LOW;
+        if (offset >= MLXSW_SP_EEPROM_PAGE_LENGTH) {
+                i2c_addr = MLXSW_SP_I2C_ADDR_HIGH;
+                offset -= MLXSW_SP_EEPROM_PAGE_LENGTH;
+        }
+
         mlxsw_reg_mcia_pack(mcia_pl, mlxsw_sp_port->mapping.module,
-                            0, 0, offset, size, MLXSW_SP_QSFP_I2C_ADDR);
+                            0, 0, offset, size, i2c_addr);
 
         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(mcia), mcia_pl);
         if (err)
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c
index f0fb898533fb..2cfb3f5d092d 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c
@@ -4868,7 +4868,8 @@ static int mlxsw_sp_router_fib_event(struct notifier_block *nb,
         struct fib_notifier_info *info = ptr;
         struct mlxsw_sp_router *router;
 
-        if (!net_eq(info->net, &init_net))
+        if (!net_eq(info->net, &init_net) ||
+            (info->family != AF_INET && info->family != AF_INET6))
                 return NOTIFY_DONE;
 
         fib_work = kzalloc(sizeof(*fib_work), GFP_ATOMIC);
diff --git a/drivers/net/ethernet/netronome/nfp/flower/offload.c b/drivers/net/ethernet/netronome/nfp/flower/offload.c
index d396183108f7..a18b4d2b1d3e 100644
--- a/drivers/net/ethernet/netronome/nfp/flower/offload.c
+++ b/drivers/net/ethernet/netronome/nfp/flower/offload.c
@@ -44,6 +44,16 @@
 #include "../nfp_net.h"
 #include "../nfp_port.h"
 
+#define NFP_FLOWER_WHITELIST_DISSECTOR \
+        (BIT(FLOW_DISSECTOR_KEY_CONTROL) | \
+         BIT(FLOW_DISSECTOR_KEY_BASIC) | \
+         BIT(FLOW_DISSECTOR_KEY_IPV4_ADDRS) | \
+         BIT(FLOW_DISSECTOR_KEY_IPV6_ADDRS) | \
+         BIT(FLOW_DISSECTOR_KEY_PORTS) | \
+         BIT(FLOW_DISSECTOR_KEY_ETH_ADDRS) | \
+         BIT(FLOW_DISSECTOR_KEY_VLAN) | \
+         BIT(FLOW_DISSECTOR_KEY_IP))
+
 static int
 nfp_flower_xmit_flow(struct net_device *netdev,
                      struct nfp_fl_payload *nfp_flow, u8 mtype)
@@ -112,6 +122,9 @@ nfp_flower_calculate_key_layers(struct nfp_fl_key_ls *ret_key_ls,
         u8 key_layer;
         int key_size;
 
+        if (flow->dissector->used_keys & ~NFP_FLOWER_WHITELIST_DISSECTOR)
+                return -EOPNOTSUPP;
+
         if (dissector_uses_key(flow->dissector,
                                FLOW_DISSECTOR_KEY_ENC_CONTROL)) {
                 struct flow_dissector_key_control *mask_enc_ctl =
diff --git a/drivers/net/ethernet/netronome/nfp/nfp_main.c b/drivers/net/ethernet/netronome/nfp/nfp_main.c
index f055b1774d65..f8fa63b66739 100644
--- a/drivers/net/ethernet/netronome/nfp/nfp_main.c
+++ b/drivers/net/ethernet/netronome/nfp/nfp_main.c
@@ -74,6 +74,45 @@ static const struct pci_device_id nfp_pci_device_ids[] = {
 };
 MODULE_DEVICE_TABLE(pci, nfp_pci_device_ids);
 
+static bool nfp_board_ready(struct nfp_pf *pf)
+{
+        const char *cp;
+        long state;
+        int err;
+
+        cp = nfp_hwinfo_lookup(pf->hwinfo, "board.state");
+        if (!cp)
+                return false;
+
+        err = kstrtol(cp, 0, &state);
+        if (err < 0)
+                return false;
+
+        return state == 15;
+}
+
+static int nfp_pf_board_state_wait(struct nfp_pf *pf)
+{
+        const unsigned long wait_until = jiffies + 10 * HZ;
+
+        while (!nfp_board_ready(pf)) {
+                if (time_is_before_eq_jiffies(wait_until)) {
+                        nfp_err(pf->cpp, "NFP board initialization timeout\n");
+                        return -EINVAL;
+                }
+
+                nfp_info(pf->cpp, "waiting for board initialization\n");
+                if (msleep_interruptible(500))
+                        return -ERESTARTSYS;
+
+                /* Refresh cached information */
+                kfree(pf->hwinfo);
+                pf->hwinfo = nfp_hwinfo_read(pf->cpp);
+        }
+
+        return 0;
+}
+
 static int nfp_pcie_sriov_read_nfd_limit(struct nfp_pf *pf)
 {
         int err;
@@ -312,6 +351,10 @@ static int nfp_nsp_init(struct pci_dev *pdev, struct nfp_pf *pf)
         struct nfp_nsp *nsp;
         int err;
 
+        err = nfp_resource_wait(pf->cpp, NFP_RESOURCE_NSP, 30);
+        if (err)
+                return err;
+
         nsp = nfp_nsp_open(pf->cpp);
         if (IS_ERR(nsp)) {
                 err = PTR_ERR(nsp);
@@ -425,6 +468,10 @@ static int nfp_pci_probe(struct pci_dev *pdev,
                  nfp_hwinfo_lookup(pf->hwinfo, "assembly.revision"),
                  nfp_hwinfo_lookup(pf->hwinfo, "cpld.version"));
 
+        err = nfp_pf_board_state_wait(pf);
+        if (err)
+                goto err_hwinfo_free;
+
         err = devlink_register(devlink, &pdev->dev);
         if (err)
                 goto err_hwinfo_free;
diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net_main.c b/drivers/net/ethernet/netronome/nfp/nfp_net_main.c
index 5abb9ba31e7d..ff373acd28f3 100644
--- a/drivers/net/ethernet/netronome/nfp/nfp_net_main.c
+++ b/drivers/net/ethernet/netronome/nfp/nfp_net_main.c
@@ -64,23 +64,6 @@
 
 #define NFP_PF_CSR_SLICE_SIZE   (32 * 1024)
 
-static int nfp_is_ready(struct nfp_pf *pf)
-{
-        const char *cp;
-        long state;
-        int err;
-
-        cp = nfp_hwinfo_lookup(pf->hwinfo, "board.state");
-        if (!cp)
-                return 0;
-
-        err = kstrtol(cp, 0, &state);
-        if (err < 0)
-                return 0;
-
-        return state == 15;
-}
-
 /**
  * nfp_net_get_mac_addr() - Get the MAC address.
  * @pf:       NFP PF handle
@@ -725,12 +708,6 @@ int nfp_net_pci_probe(struct nfp_pf *pf)
 
         INIT_WORK(&pf->port_refresh_work, nfp_net_refresh_vnics);
 
-        /* Verify that the board has completed initialization */
-        if (!nfp_is_ready(pf)) {
-                nfp_err(pf->cpp, "NFP is not ready for NIC operation.\n");
-                return -EINVAL;
-        }
-
         if (!pf->rtbl) {
                 nfp_err(pf->cpp, "No %s, giving up.\n",
                         pf->fw_loaded ? "symbol table" : "firmware found");
diff --git a/drivers/net/ethernet/netronome/nfp/nfpcore/nfp.h b/drivers/net/ethernet/netronome/nfp/nfpcore/nfp.h
index 1a8d04a1e113..3ce51f03126f 100644
--- a/drivers/net/ethernet/netronome/nfp/nfpcore/nfp.h
+++ b/drivers/net/ethernet/netronome/nfp/nfpcore/nfp.h
@@ -97,6 +97,8 @@ nfp_resource_acquire(struct nfp_cpp *cpp, const char *name);
 
 void nfp_resource_release(struct nfp_resource *res);
 
+int nfp_resource_wait(struct nfp_cpp *cpp, const char *name, unsigned int secs);
+
 u32 nfp_resource_cpp_id(struct nfp_resource *res);
 
 const char *nfp_resource_name(struct nfp_resource *res);
diff --git a/drivers/net/ethernet/netronome/nfp/nfpcore/nfp_resource.c b/drivers/net/ethernet/netronome/nfp/nfpcore/nfp_resource.c
index 072612263dab..b1dd13ff282b 100644
--- a/drivers/net/ethernet/netronome/nfp/nfpcore/nfp_resource.c
+++ b/drivers/net/ethernet/netronome/nfp/nfpcore/nfp_resource.c
@@ -250,6 +250,51 @@ void nfp_resource_release(struct nfp_resource *res)
 }
 
 /**
+ * nfp_resource_wait() - Wait for resource to appear
+ * @cpp:        NFP CPP handle
+ * @name:       Name of the resource
+ * @secs:       Number of seconds to wait
+ *
+ * Wait for resource to appear in the resource table, grab and release
+ * its lock.  The wait is jiffies-based, don't expect fine granularity.
+ *
+ * Return: 0 on success, errno otherwise.
+ */
+int nfp_resource_wait(struct nfp_cpp *cpp, const char *name, unsigned int secs)
+{
+        unsigned long warn_at = jiffies + NFP_MUTEX_WAIT_FIRST_WARN * HZ;
+        unsigned long err_at = jiffies + secs * HZ;
+        struct nfp_resource *res;
+
+        while (true) {
+                res = nfp_resource_acquire(cpp, name);
+                if (!IS_ERR(res)) {
+                        nfp_resource_release(res);
+                        return 0;
+                }
+
+                if (PTR_ERR(res) != -ENOENT) {
+                        nfp_err(cpp, "error waiting for resource %s: %ld\n",
+                                name, PTR_ERR(res));
+                        return PTR_ERR(res);
+                }
+                if (time_is_before_eq_jiffies(err_at)) {
+                        nfp_err(cpp, "timeout waiting for resource %s\n", name);
+                        return -ETIMEDOUT;
+                }
+                if (time_is_before_eq_jiffies(warn_at)) {
+                        warn_at = jiffies + NFP_MUTEX_WAIT_NEXT_WARN * HZ;
+                        nfp_info(cpp, "waiting for NFP resource %s\n", name);
+                }
+                if (msleep_interruptible(10)) {
+                        nfp_err(cpp, "wait for resource %s interrupted\n",
+                                name);
+                        return -ERESTARTSYS;
+                }
+        }
+}
+
+/**
  * nfp_resource_cpp_id() - Return the cpp_id of a resource handle
  * @res:        NFP Resource handle
  *
diff --git a/drivers/net/ethernet/nuvoton/w90p910_ether.c b/drivers/net/ethernet/nuvoton/w90p910_ether.c
index 89ab786da25f..4a67c55aa9f1 100644
--- a/drivers/net/ethernet/nuvoton/w90p910_ether.c
+++ b/drivers/net/ethernet/nuvoton/w90p910_ether.c
@@ -11,6 +11,7 @@
 
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/interrupt.h>
 #include <linux/mii.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
diff --git a/drivers/net/ethernet/qlogic/qed/qed_dcbx.c b/drivers/net/ethernet/qlogic/qed/qed_dcbx.c
index eaca4578435d..8f6ccc0c39e5 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_dcbx.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_dcbx.c
@@ -1244,7 +1244,6 @@ int qed_dcbx_get_config_params(struct qed_hwfn *p_hwfn,
         if (!dcbx_info)
                 return -ENOMEM;
 
-        memset(dcbx_info, 0, sizeof(*dcbx_info));
         rc = qed_dcbx_query_params(p_hwfn, dcbx_info, QED_DCBX_OPERATIONAL_MIB);
         if (rc) {
                 kfree(dcbx_info);
diff --git a/drivers/net/ethernet/qualcomm/rmnet/rmnet_map_data.c b/drivers/net/ethernet/qualcomm/rmnet/rmnet_map_data.c
index 557c9bf1a469..86b8c758f94e 100644
--- a/drivers/net/ethernet/qualcomm/rmnet/rmnet_map_data.c
+++ b/drivers/net/ethernet/qualcomm/rmnet/rmnet_map_data.c
@@ -84,6 +84,10 @@ struct sk_buff *rmnet_map_deaggregate(struct sk_buff *skb)
         if (((int)skb->len - (int)packet_len) < 0)
                 return NULL;
 
+        /* Some hardware can send us empty frames. Catch them */
+        if (ntohs(maph->pkt_len) == 0)
+                return NULL;
+
         skbn = alloc_skb(packet_len + RMNET_MAP_DEAGGR_SPACING, GFP_ATOMIC);
         if (!skbn)
                 return NULL;
@@ -94,11 +98,5 @@ struct sk_buff *rmnet_map_deaggregate(struct sk_buff *skb)
         memcpy(skbn->data, skb->data, packet_len);
         skb_pull(skb, packet_len);
 
-        /* Some hardware can send us empty frames. Catch them */
-        if (ntohs(maph->pkt_len) == 0) {
-                kfree_skb(skb);
-                return NULL;
-        }
-
         return skbn;
 }
diff --git a/drivers/net/ethernet/smsc/smsc911x.c b/drivers/net/ethernet/smsc/smsc911x.c
index 0b6a39b003a4..012fb66eed8d 100644
--- a/drivers/net/ethernet/smsc/smsc911x.c
+++ b/drivers/net/ethernet/smsc/smsc911x.c
@@ -2595,6 +2595,11 @@ static int smsc911x_suspend(struct device *dev)
         struct net_device *ndev = dev_get_drvdata(dev);
         struct smsc911x_data *pdata = netdev_priv(ndev);
 
+        if (netif_running(ndev)) {
+                netif_stop_queue(ndev);
+                netif_device_detach(ndev);
+        }
+
         /* enable wake on LAN, energy detection and the external PME
          * signal. */
         smsc911x_reg_write(pdata, PMT_CTRL,
@@ -2628,7 +2633,15 @@ static int smsc911x_resume(struct device *dev)
         while (!(smsc911x_reg_read(pdata, PMT_CTRL) & PMT_CTRL_READY_) && --to)
                 udelay(1000);
 
-        return (to == 0) ? -EIO : 0;
+        if (to == 0)
+                return -EIO;
+
+        if (netif_running(ndev)) {
+                netif_device_attach(ndev);
+                netif_start_queue(ndev);
+        }
+
+        return 0;
 }
 
 static const struct dev_pm_ops smsc911x_pm_ops = {
diff --git a/drivers/net/hyperv/hyperv_net.h b/drivers/net/hyperv/hyperv_net.h
index ec546da86683..d98cdfb1536b 100644
--- a/drivers/net/hyperv/hyperv_net.h
+++ b/drivers/net/hyperv/hyperv_net.h
@@ -204,6 +204,8 @@ int netvsc_recv_callback(struct net_device *net,
                          const struct ndis_pkt_8021q_info *vlan);
 void netvsc_channel_cb(void *context);
 int netvsc_poll(struct napi_struct *napi, int budget);
+
+void rndis_set_subchannel(struct work_struct *w);
 bool rndis_filter_opened(const struct netvsc_device *nvdev);
 int rndis_filter_open(struct netvsc_device *nvdev);
 int rndis_filter_close(struct netvsc_device *nvdev);
@@ -782,6 +784,7 @@ struct netvsc_device {
         u32 num_chn;
 
         atomic_t open_chn;
+        struct work_struct subchan_work;
         wait_queue_head_t subchan_open;
 
         struct rndis_device *extension;
diff --git a/drivers/net/hyperv/netvsc.c b/drivers/net/hyperv/netvsc.c
index 0062b802676f..a5511b7326af 100644
--- a/drivers/net/hyperv/netvsc.c
+++ b/drivers/net/hyperv/netvsc.c
@@ -81,6 +81,7 @@ static struct netvsc_device *alloc_net_device(void)
 
         init_completion(&net_device->channel_init_wait);
         init_waitqueue_head(&net_device->subchan_open);
+        INIT_WORK(&net_device->subchan_work, rndis_set_subchannel);
 
         return net_device;
 }
@@ -557,6 +558,8 @@ void netvsc_device_remove(struct hv_device *device)
                 = rtnl_dereference(net_device_ctx->nvdev);
         int i;
 
+        cancel_work_sync(&net_device->subchan_work);
+
         netvsc_disconnect_vsp(device);
 
         RCU_INIT_POINTER(net_device_ctx->nvdev, NULL);
diff --git a/drivers/net/hyperv/netvsc_drv.c b/drivers/net/hyperv/netvsc_drv.c
index 165ba4b3b423..d4902ee5f260 100644
--- a/drivers/net/hyperv/netvsc_drv.c
+++ b/drivers/net/hyperv/netvsc_drv.c
@@ -49,7 +49,7 @@
 #define NETVSC_MIN_TX_SECTIONS  10
 #define NETVSC_DEFAULT_TX       192     /* ~1M */
 #define NETVSC_MIN_RX_SECTIONS  10      /* ~64K */
-#define NETVSC_DEFAULT_RX       2048    /* ~4M */
+#define NETVSC_DEFAULT_RX       10485   /* Max ~16M */
 
 #define LINKCHANGE_INT (2 * HZ)
 #define VF_TAKEOVER_INT (HZ / 10)
@@ -853,10 +853,7 @@ static int netvsc_set_channels(struct net_device *net,
         rndis_filter_device_remove(dev, nvdev);
 
         nvdev = rndis_filter_device_add(dev, &device_info);
-        if (!IS_ERR(nvdev)) {
-                netif_set_real_num_tx_queues(net, nvdev->num_chn);
-                netif_set_real_num_rx_queues(net, nvdev->num_chn);
-        } else {
+        if (IS_ERR(nvdev)) {
                 ret = PTR_ERR(nvdev);
                 device_info.num_chn = orig;
                 nvdev = rndis_filter_device_add(dev, &device_info);
@@ -1954,9 +1951,6 @@ static int netvsc_probe(struct hv_device *dev,
                 NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX;
         net->vlan_features = net->features;
 
-        netif_set_real_num_tx_queues(net, nvdev->num_chn);
-        netif_set_real_num_rx_queues(net, nvdev->num_chn);
-
         netdev_lockdep_set_classes(net);
 
         /* MTU range: 68 - 1500 or 65521 */
@@ -2012,9 +2006,10 @@ static int netvsc_remove(struct hv_device *dev)
         if (vf_netdev)
                 netvsc_unregister_vf(vf_netdev);
 
+        unregister_netdevice(net);
+
         rndis_filter_device_remove(dev,
                                    rtnl_dereference(ndev_ctx->nvdev));
-        unregister_netdevice(net);
         rtnl_unlock();
 
         hv_set_drvdata(dev, NULL);
diff --git a/drivers/net/hyperv/rndis_filter.c b/drivers/net/hyperv/rndis_filter.c
index 69c40b8fccc3..065b204d8e17 100644
--- a/drivers/net/hyperv/rndis_filter.c
+++ b/drivers/net/hyperv/rndis_filter.c
@@ -1039,8 +1039,6 @@ static void netvsc_sc_open(struct vmbus_channel *new_sc)
 
         /* Set the channel before opening.*/
         nvchan->channel = new_sc;
-        netif_napi_add(ndev, &nvchan->napi,
-                       netvsc_poll, NAPI_POLL_WEIGHT);
 
         ret = vmbus_open(new_sc, nvscdev->ring_size * PAGE_SIZE,
                          nvscdev->ring_size * PAGE_SIZE, NULL, 0,
@@ -1048,10 +1046,86 @@ static void netvsc_sc_open(struct vmbus_channel *new_sc)
         if (ret == 0)
                 napi_enable(&nvchan->napi);
         else
-                netif_napi_del(&nvchan->napi);
+                netdev_notice(ndev, "sub channel open failed: %d\n", ret);
 
-        atomic_inc(&nvscdev->open_chn);
-        wake_up(&nvscdev->subchan_open);
+        if (atomic_inc_return(&nvscdev->open_chn) == nvscdev->num_chn)
+                wake_up(&nvscdev->subchan_open);
+}
+
+/* Open sub-channels after completing the handling of the device probe.
+ * This breaks overlap of processing the host message for the
+ * new primary channel with the initialization of sub-channels.
+ */
+void rndis_set_subchannel(struct work_struct *w)
+{
+        struct netvsc_device *nvdev
+                = container_of(w, struct netvsc_device, subchan_work);
+        struct nvsp_message *init_packet = &nvdev->channel_init_pkt;
+        struct net_device_context *ndev_ctx;
+        struct rndis_device *rdev;
+        struct net_device *ndev;
+        struct hv_device *hv_dev;
+        int i, ret;
+
+        if (!rtnl_trylock()) {
+                schedule_work(w);
+                return;
+        }
+
+        rdev = nvdev->extension;
+        if (!rdev)
+                goto unlock;    /* device was removed */
+
+        ndev = rdev->ndev;
+        ndev_ctx = netdev_priv(ndev);
+        hv_dev = ndev_ctx->device_ctx;
+
+        memset(init_packet, 0, sizeof(struct nvsp_message));
+        init_packet->hdr.msg_type = NVSP_MSG5_TYPE_SUBCHANNEL;
+        init_packet->msg.v5_msg.subchn_req.op = NVSP_SUBCHANNEL_ALLOCATE;
+        init_packet->msg.v5_msg.subchn_req.num_subchannels =
+                                                nvdev->num_chn - 1;
+        ret = vmbus_sendpacket(hv_dev->channel, init_packet,
+                               sizeof(struct nvsp_message),
+                               (unsigned long)init_packet,
+                               VM_PKT_DATA_INBAND,
+                               VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
+        if (ret) {
+                netdev_err(ndev, "sub channel allocate send failed: %d\n", ret);
+                goto failed;
+        }
+
+        wait_for_completion(&nvdev->channel_init_wait);
+        if (init_packet->msg.v5_msg.subchn_comp.status != NVSP_STAT_SUCCESS) {
+                netdev_err(ndev, "sub channel request failed\n");
+                goto failed;
+        }
+
+        nvdev->num_chn = 1 +
+                init_packet->msg.v5_msg.subchn_comp.num_subchannels;
+
+        /* wait for all sub channels to open */
+        wait_event(nvdev->subchan_open,
+                   atomic_read(&nvdev->open_chn) == nvdev->num_chn);
+
+        /* ignore failues from setting rss parameters, still have channels */
+        rndis_filter_set_rss_param(rdev, netvsc_hash_key);
+
+        netif_set_real_num_tx_queues(ndev, nvdev->num_chn);
+        netif_set_real_num_rx_queues(ndev, nvdev->num_chn);
+
+        rtnl_unlock();
+        return;
+
+failed:
+        /* fallback to only primary channel */
+        for (i = 1; i < nvdev->num_chn; i++)
+                netif_napi_del(&nvdev->chan_table[i].napi);
+
+        nvdev->max_chn = 1;
+        nvdev->num_chn = 1;
+unlock:
+        rtnl_unlock();
 }
 
 struct netvsc_device *rndis_filter_device_add(struct hv_device *dev,
@@ -1063,7 +1137,6 @@ struct netvsc_device *rndis_filter_device_add(struct hv_device *dev,
         struct rndis_device *rndis_device;
         struct ndis_offload hwcaps;
         struct ndis_offload_params offloads;
-        struct nvsp_message *init_packet;
         struct ndis_recv_scale_cap rsscap;
         u32 rsscap_size = sizeof(struct ndis_recv_scale_cap);
         unsigned int gso_max_size = GSO_MAX_SIZE;
@@ -1215,9 +1288,7 @@ struct netvsc_device *rndis_filter_device_add(struct hv_device *dev,
                                                         net_device->num_chn);
 
         atomic_set(&net_device->open_chn, 1);
-
-        if (net_device->num_chn == 1)
-                return net_device;
+        vmbus_set_sc_create_callback(dev->channel, netvsc_sc_open);
 
         for (i = 1; i < net_device->num_chn; i++) {
                 ret = netvsc_alloc_recv_comp_ring(net_device, i);
@@ -1228,38 +1299,15 @@ struct netvsc_device *rndis_filter_device_add(struct hv_device *dev,
                 }
         }
 
-        vmbus_set_sc_create_callback(dev->channel, netvsc_sc_open);
+        for (i = 1; i < net_device->num_chn; i++)
+                netif_napi_add(net, &net_device->chan_table[i].napi,
+                               netvsc_poll, NAPI_POLL_WEIGHT);
 
-        init_packet = &net_device->channel_init_pkt;
-        memset(init_packet, 0, sizeof(struct nvsp_message));
-        init_packet->hdr.msg_type = NVSP_MSG5_TYPE_SUBCHANNEL;
-        init_packet->msg.v5_msg.subchn_req.op = NVSP_SUBCHANNEL_ALLOCATE;
-        init_packet->msg.v5_msg.subchn_req.num_subchannels =
-                                                net_device->num_chn - 1;
-        ret = vmbus_sendpacket(dev->channel, init_packet,
-                               sizeof(struct nvsp_message),
-                               (unsigned long)init_packet,
-                               VM_PKT_DATA_INBAND,
-                               VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
-        if (ret)
-                goto out;
-
-        wait_for_completion(&net_device->channel_init_wait);
-        if (init_packet->msg.v5_msg.subchn_comp.status != NVSP_STAT_SUCCESS) {
-                ret = -ENODEV;
-                goto out;
-        }
+        if (net_device->num_chn > 1)
+                schedule_work(&net_device->subchan_work);
 
-        net_device->num_chn = 1 +
-                init_packet->msg.v5_msg.subchn_comp.num_subchannels;
-
-        /* wait for all sub channels to open */
-        wait_event(net_device->subchan_open,
-                   atomic_read(&net_device->open_chn) == net_device->num_chn);
-
-        /* ignore failues from setting rss parameters, still have channels */
-        rndis_filter_set_rss_param(rndis_device, netvsc_hash_key);
 out:
+        /* if unavailable, just proceed with one queue */
         if (ret) {
                 net_device->max_chn = 1;
                 net_device->num_chn = 1;
@@ -1280,10 +1328,10 @@ void rndis_filter_device_remove(struct hv_device *dev,
         /* Halt and release the rndis device */
         rndis_filter_halt_device(rndis_dev);
 
-        kfree(rndis_dev);
         net_dev->extension = NULL;
 
         netvsc_device_remove(dev);
+        kfree(rndis_dev);
 }
 
 int rndis_filter_open(struct netvsc_device *nvdev)
diff --git a/drivers/net/usb/smsc95xx.c b/drivers/net/usb/smsc95xx.c
index 340c13484e5c..309b88acd3d0 100644
--- a/drivers/net/usb/smsc95xx.c
+++ b/drivers/net/usb/smsc95xx.c
@@ -526,7 +526,7 @@ static void smsc95xx_set_multicast(struct net_device *netdev)
 static int smsc95xx_phy_update_flowcontrol(struct usbnet *dev, u8 duplex,
                                            u16 lcladv, u16 rmtadv)
 {
-        u32 flow, afc_cfg = 0;
+        u32 flow = 0, afc_cfg;
 
         int ret = smsc95xx_read_reg(dev, AFC_CFG, &afc_cfg);
         if (ret < 0)
@@ -537,20 +537,19 @@ static int smsc95xx_phy_update_flowcontrol(struct usbnet *dev, u8 duplex,
 
                 if (cap & FLOW_CTRL_RX)
                         flow = 0xFFFF0002;
-                else
-                        flow = 0;
 
-                if (cap & FLOW_CTRL_TX)
+                if (cap & FLOW_CTRL_TX) {
                         afc_cfg |= 0xF;
-                else
+                        flow |= 0xFFFF0000;
+                } else {
                         afc_cfg &= ~0xF;
+                }
 
                 netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s\n",
                                    cap & FLOW_CTRL_RX ? "enabled" : "disabled",
                                    cap & FLOW_CTRL_TX ? "enabled" : "disabled");
         } else {
                 netif_dbg(dev, link, dev->net, "half duplex\n");
-                flow = 0;
                 afc_cfg |= 0xF;
         }
 
diff --git a/drivers/net/vrf.c b/drivers/net/vrf.c
index 7e19051f3230..9b243e6f3008 100644
--- a/drivers/net/vrf.c
+++ b/drivers/net/vrf.c
@@ -957,12 +957,12 @@ static void vrf_ip6_input_dst(struct sk_buff *skb, struct net_device *vrf_dev,
 {
         const struct ipv6hdr *iph = ipv6_hdr(skb);
         struct flowi6 fl6 = {
+                .flowi6_iif     = ifindex,
+                .flowi6_mark    = skb->mark,
+                .flowi6_proto   = iph->nexthdr,
                 .daddr          = iph->daddr,
                 .saddr          = iph->saddr,
                 .flowlabel      = ip6_flowinfo(iph),
-                .flowi6_mark    = skb->mark,
-                .flowi6_proto   = iph->nexthdr,
-                .flowi6_iif     = ifindex,
         };
         struct net *net = dev_net(vrf_dev);
         struct rt6_info *rt6;