Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

Pull networking fixes and cleanups from David Miller:

 1) Revert bogus nla_ok() change, from Alexey Dobriyan.

 2) Various bpf validator fixes from Daniel Borkmann.

 3) Add some necessary SET_NETDEV_DEV() calls to hsis_femac and hip04
    drivers, from Dongpo Li.

 4) Several ethtool ksettings conversions from Philippe Reynes.

 5) Fix bugs in inet port management wrt. soreuseport, from Tom Herbert.

 6) XDP support for virtio_net, from John Fastabend.

 7) Fix NAT handling within a vrf, from David Ahern.

 8) Endianness fixes in dpaa_eth driver, from Claudiu Manoil

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (63 commits)
  net: mv643xx_eth: fix build failure
  isdn: Constify some function parameters
  mlxsw: spectrum: Mark split ports as such
  cgroup: Fix CGROUP_BPF config
  qed: fix old-style function definition
  net: ipv6: check route protocol when deleting routes
  r6040: move spinlock in r6040_close as SOFTIRQ-unsafe lock order detected
  irda: w83977af_ir: cleanup an indent issue
  net: sfc: use new api ethtool_{get|set}_link_ksettings
  net: davicom: dm9000: use new api ethtool_{get|set}_link_ksettings
  net: cirrus: ep93xx: use new api ethtool_{get|set}_link_ksettings
  net: chelsio: cxgb3: use new api ethtool_{get|set}_link_ksettings
  net: chelsio: cxgb2: use new api ethtool_{get|set}_link_ksettings
  bpf: fix mark_reg_unknown_value for spilled regs on map value marking
  bpf: fix overflow in prog accounting
  bpf: dynamically allocate digest scratch buffer
  gtp: Fix initialization of Flags octet in GTPv1 header
  gtp: gtp_check_src_ms_ipv4() always return success
  net/x25: use designated initializers
  isdn: use designated initializers
  ...

31 files changed, 877 insertions, 246 deletions

diff --git a/drivers/net/dsa/mv88e6xxx/chip.c b/drivers/net/dsa/mv88e6xxx/chip.c
index 4da379f28d5d..f7222dc6581d 100644
--- a/drivers/net/dsa/mv88e6xxx/chip.c
+++ b/drivers/net/dsa/mv88e6xxx/chip.c
@@ -1775,6 +1775,9 @@ static int mv88e6xxx_port_check_hw_vlan(struct dsa_switch *ds, int port,
                         if (dsa_is_dsa_port(ds, i) || dsa_is_cpu_port(ds, i))
                                 continue;
 
+                        if (!ds->ports[port].netdev)
+                                continue;
+
                         if (vlan.data[i] ==
                             GLOBAL_VTU_DATA_MEMBER_TAG_NON_MEMBER)
                                 continue;
@@ -1783,6 +1786,9 @@ static int mv88e6xxx_port_check_hw_vlan(struct dsa_switch *ds, int port,
                             chip->ports[port].bridge_dev)
                                 break; /* same bridge, check next VLAN */
 
+                        if (!chip->ports[i].bridge_dev)
+                                continue;
+
                         netdev_warn(ds->ports[port].netdev,
                                     "hardware VLAN %d already used by %s\n",
                                     vlan.vid,
diff --git a/drivers/net/ethernet/3com/3c515.c b/drivers/net/ethernet/3com/3c515.c
index b9f4c463e516..be5b80103bec 100644
--- a/drivers/net/ethernet/3com/3c515.c
+++ b/drivers/net/ethernet/3com/3c515.c
@@ -627,6 +627,8 @@ static int corkscrew_setup(struct net_device *dev, int ioaddr,
 
         spin_lock_init(&vp->lock);
 
+        setup_timer(&vp->timer, corkscrew_timer, (unsigned long) dev);
+
         /* Read the station address from the EEPROM. */
         EL3WINDOW(0);
         for (i = 0; i < 0x18; i++) {
@@ -707,6 +709,7 @@ static int corkscrew_open(struct net_device *dev)
 {
         int ioaddr = dev->base_addr;
         struct corkscrew_private *vp = netdev_priv(dev);
+        bool armtimer = false;
         __u32 config;
         int i;
 
@@ -731,12 +734,7 @@ static int corkscrew_open(struct net_device *dev)
                 if (corkscrew_debug > 1)
                         pr_debug("%s: Initial media type %s.\n",
                                dev->name, media_tbl[dev->if_port].name);
-
-                init_timer(&vp->timer);
-                vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
-                vp->timer.data = (unsigned long) dev;
-                vp->timer.function = corkscrew_timer;   /* timer handler */
-                add_timer(&vp->timer);
+                armtimer = true;
         } else
                 dev->if_port = vp->default_media;
 
@@ -776,6 +774,9 @@ static int corkscrew_open(struct net_device *dev)
                 return -EAGAIN;
         }
 
+        if (armtimer)
+                mod_timer(&vp->timer, jiffies + media_tbl[dev->if_port].wait);
+
         if (corkscrew_debug > 1) {
                 EL3WINDOW(4);
                 pr_debug("%s: corkscrew_open() irq %d media status %4.4x.\n",
@@ -1426,7 +1427,7 @@ static int corkscrew_close(struct net_device *dev)
                         dev->name, rx_nocopy, rx_copy, queued_packet);
         }
 
-        del_timer(&vp->timer);
+        del_timer_sync(&vp->timer);
 
         /* Turn off statistics ASAP.  We update lp->stats below. */
         outw(StatsDisable, ioaddr + EL3_CMD);
diff --git a/drivers/net/ethernet/brocade/bna/bna_enet.c b/drivers/net/ethernet/brocade/bna/bna_enet.c
index 4e5c3874a50f..bba81735ce87 100644
--- a/drivers/net/ethernet/brocade/bna/bna_enet.c
+++ b/drivers/net/ethernet/brocade/bna/bna_enet.c
@@ -1676,10 +1676,10 @@ bna_cb_ioceth_reset(void *arg)
 }
 
 static struct bfa_ioc_cbfn bna_ioceth_cbfn = {
-        bna_cb_ioceth_enable,
-        bna_cb_ioceth_disable,
-        bna_cb_ioceth_hbfail,
-        bna_cb_ioceth_reset
+        .enable_cbfn = bna_cb_ioceth_enable,
+        .disable_cbfn = bna_cb_ioceth_disable,
+        .hbfail_cbfn = bna_cb_ioceth_hbfail,
+        .reset_cbfn = bna_cb_ioceth_reset
 };
 
 static void bna_attr_init(struct bna_ioceth *ioceth)
diff --git a/drivers/net/ethernet/cadence/Kconfig b/drivers/net/ethernet/cadence/Kconfig
index f0bcb15d3fec..608bea171956 100644
--- a/drivers/net/ethernet/cadence/Kconfig
+++ b/drivers/net/ethernet/cadence/Kconfig
@@ -31,4 +31,13 @@ config MACB
           To compile this driver as a module, choose M here: the module
           will be called macb.
 
+config MACB_PCI
+        tristate "Cadence PCI MACB/GEM support"
+        depends on MACB && PCI && COMMON_CLK
+        ---help---
+          This is PCI wrapper for MACB driver.
+
+          To compile this driver as a module, choose M here: the module
+          will be called macb_pci.
+
 endif # NET_CADENCE
diff --git a/drivers/net/ethernet/cadence/Makefile b/drivers/net/ethernet/cadence/Makefile
index 91f79b1f0505..4ba75594d5c5 100644
--- a/drivers/net/ethernet/cadence/Makefile
+++ b/drivers/net/ethernet/cadence/Makefile
@@ -3,3 +3,4 @@
 #
 
 obj-$(CONFIG_MACB) += macb.o
+obj-$(CONFIG_MACB_PCI) += macb_pci.o
diff --git a/drivers/net/ethernet/cadence/macb.c b/drivers/net/ethernet/cadence/macb.c
index 538544a7c642..c0fb80acc2da 100644
--- a/drivers/net/ethernet/cadence/macb.c
+++ b/drivers/net/ethernet/cadence/macb.c
@@ -404,6 +404,8 @@ static int macb_mii_probe(struct net_device *dev)
                         phy_irq = gpio_to_irq(pdata->phy_irq_pin);
                         phydev->irq = (phy_irq < 0) ? PHY_POLL : phy_irq;
                 }
+        } else {
+                phydev->irq = PHY_POLL;
         }
 
         /* attach the mac to the phy */
@@ -482,6 +484,9 @@ static int macb_mii_init(struct macb *bp)
                                 goto err_out_unregister_bus;
                 }
         } else {
+                for (i = 0; i < PHY_MAX_ADDR; i++)
+                        bp->mii_bus->irq[i] = PHY_POLL;
+
                 if (pdata)
                         bp->mii_bus->phy_mask = pdata->phy_mask;
 
@@ -2523,16 +2528,24 @@ static int macb_clk_init(struct platform_device *pdev, struct clk **pclk,
                          struct clk **hclk, struct clk **tx_clk,
                          struct clk **rx_clk)
 {
+        struct macb_platform_data *pdata;
         int err;
 
-        *pclk = devm_clk_get(&pdev->dev, "pclk");
+        pdata = dev_get_platdata(&pdev->dev);
+        if (pdata) {
+                *pclk = pdata->pclk;
+                *hclk = pdata->hclk;
+        } else {
+                *pclk = devm_clk_get(&pdev->dev, "pclk");
+                *hclk = devm_clk_get(&pdev->dev, "hclk");
+        }
+
         if (IS_ERR(*pclk)) {
                 err = PTR_ERR(*pclk);
                 dev_err(&pdev->dev, "failed to get macb_clk (%u)\n", err);
                 return err;
         }
 
-        *hclk = devm_clk_get(&pdev->dev, "hclk");
         if (IS_ERR(*hclk)) {
                 err = PTR_ERR(*hclk);
                 dev_err(&pdev->dev, "failed to get hclk (%u)\n", err);
@@ -3107,15 +3120,23 @@ static const struct of_device_id macb_dt_ids[] = {
 MODULE_DEVICE_TABLE(of, macb_dt_ids);
 #endif /* CONFIG_OF */
 
+static const struct macb_config default_gem_config = {
+        .caps = MACB_CAPS_GIGABIT_MODE_AVAILABLE | MACB_CAPS_JUMBO,
+        .dma_burst_length = 16,
+        .clk_init = macb_clk_init,
+        .init = macb_init,
+        .jumbo_max_len = 10240,
+};
+
 static int macb_probe(struct platform_device *pdev)
 {
+        const struct macb_config *macb_config = &default_gem_config;
         int (*clk_init)(struct platform_device *, struct clk **,
                         struct clk **, struct clk **,  struct clk **)
-                                              = macb_clk_init;
-        int (*init)(struct platform_device *) = macb_init;
+                                              = macb_config->clk_init;
+        int (*init)(struct platform_device *) = macb_config->init;
         struct device_node *np = pdev->dev.of_node;
         struct device_node *phy_node;
-        const struct macb_config *macb_config = NULL;
         struct clk *pclk, *hclk = NULL, *tx_clk = NULL, *rx_clk = NULL;
         unsigned int queue_mask, num_queues;
         struct macb_platform_data *pdata;
diff --git a/drivers/net/ethernet/cadence/macb_pci.c b/drivers/net/ethernet/cadence/macb_pci.c
new file mode 100644
index 000000000000..92be2cd8f817
--- /dev/null
+++ b/drivers/net/ethernet/cadence/macb_pci.c
@@ -0,0 +1,153 @@
+/**
+ * macb_pci.c - Cadence GEM PCI wrapper.
+ *
+ * Copyright (C) 2016 Cadence Design Systems - http://www.cadence.com
+ *
+ * Authors: Rafal Ozieblo <rafalo@cadence.com>
+ *          Bartosz Folta <bfolta@cadence.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2  of
+ * the License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/clk.h>
+#include <linux/clk-provider.h>
+#include <linux/etherdevice.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/platform_data/macb.h>
+#include <linux/platform_device.h>
+#include "macb.h"
+
+#define PCI_DRIVER_NAME "macb_pci"
+#define PLAT_DRIVER_NAME "macb"
+
+#define CDNS_VENDOR_ID 0x17cd
+#define CDNS_DEVICE_ID 0xe007
+
+#define GEM_PCLK_RATE 50000000
+#define GEM_HCLK_RATE 50000000
+
+static int macb_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+{
+        int err;
+        struct platform_device *plat_dev;
+        struct platform_device_info plat_info;
+        struct macb_platform_data plat_data;
+        struct resource res[2];
+
+        /* sanity check */
+        if (!id)
+                return -EINVAL;
+
+        /* enable pci device */
+        err = pci_enable_device(pdev);
+        if (err < 0) {
+                dev_err(&pdev->dev, "Enabling PCI device has failed: 0x%04X",
+                        err);
+                return -EACCES;
+        }
+
+        pci_set_master(pdev);
+
+        /* set up resources */
+        memset(res, 0x00, sizeof(struct resource) * ARRAY_SIZE(res));
+        res[0].start = pdev->resource[0].start;
+        res[0].end = pdev->resource[0].end;
+        res[0].name = PCI_DRIVER_NAME;
+        res[0].flags = IORESOURCE_MEM;
+        res[1].start = pdev->irq;
+        res[1].name = PCI_DRIVER_NAME;
+        res[1].flags = IORESOURCE_IRQ;
+
+        dev_info(&pdev->dev, "EMAC physical base addr = 0x%p\n",
+                 (void *)(uintptr_t)pci_resource_start(pdev, 0));
+
+        /* set up macb platform data */
+        memset(&plat_data, 0, sizeof(plat_data));
+
+        /* initialize clocks */
+        plat_data.pclk = clk_register_fixed_rate(&pdev->dev, "pclk", NULL, 0,
+                                                 GEM_PCLK_RATE);
+        if (IS_ERR(plat_data.pclk)) {
+                err = PTR_ERR(plat_data.pclk);
+                goto err_pclk_register;
+        }
+
+        plat_data.hclk = clk_register_fixed_rate(&pdev->dev, "hclk", NULL, 0,
+                                                 GEM_HCLK_RATE);
+        if (IS_ERR(plat_data.hclk)) {
+                err = PTR_ERR(plat_data.hclk);
+                goto err_hclk_register;
+        }
+
+        /* set up platform device info */
+        memset(&plat_info, 0, sizeof(plat_info));
+        plat_info.parent = &pdev->dev;
+        plat_info.fwnode = pdev->dev.fwnode;
+        plat_info.name = PLAT_DRIVER_NAME;
+        plat_info.id = pdev->devfn;
+        plat_info.res = res;
+        plat_info.num_res = ARRAY_SIZE(res);
+        plat_info.data = &plat_data;
+        plat_info.size_data = sizeof(plat_data);
+        plat_info.dma_mask = DMA_BIT_MASK(32);
+
+        /* register platform device */
+        plat_dev = platform_device_register_full(&plat_info);
+        if (IS_ERR(plat_dev)) {
+                err = PTR_ERR(plat_dev);
+                goto err_plat_dev_register;
+        }
+
+        pci_set_drvdata(pdev, plat_dev);
+
+        return 0;
+
+err_plat_dev_register:
+        clk_unregister(plat_data.hclk);
+
+err_hclk_register:
+        clk_unregister(plat_data.pclk);
+
+err_pclk_register:
+        pci_disable_device(pdev);
+        return err;
+}
+
+static void macb_remove(struct pci_dev *pdev)
+{
+        struct platform_device *plat_dev = pci_get_drvdata(pdev);
+        struct macb_platform_data *plat_data = dev_get_platdata(&plat_dev->dev);
+
+        platform_device_unregister(plat_dev);
+        pci_disable_device(pdev);
+        clk_unregister(plat_data->pclk);
+        clk_unregister(plat_data->hclk);
+}
+
+static struct pci_device_id dev_id_table[] = {
+        { PCI_DEVICE(CDNS_VENDOR_ID, CDNS_DEVICE_ID), },
+        { 0, }
+};
+
+static struct pci_driver macb_pci_driver = {
+        .name     = PCI_DRIVER_NAME,
+        .id_table = dev_id_table,
+        .probe    = macb_probe,
+        .remove   = macb_remove,
+};
+
+module_pci_driver(macb_pci_driver);
+MODULE_DEVICE_TABLE(pci, dev_id_table);
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Cadence NIC PCI wrapper");
diff --git a/drivers/net/ethernet/chelsio/cxgb/cxgb2.c b/drivers/net/ethernet/chelsio/cxgb/cxgb2.c
index 81d1d0bc7553..3a05f9098e75 100644
--- a/drivers/net/ethernet/chelsio/cxgb/cxgb2.c
+++ b/drivers/net/ethernet/chelsio/cxgb/cxgb2.c
@@ -568,28 +568,33 @@ static void get_regs(struct net_device *dev, struct ethtool_regs *regs,
         reg_block_dump(ap, buf, A_MC5_CONFIG, A_MC5_MASK_WRITE_CMD);
 }
 
-static int get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+static int get_link_ksettings(struct net_device *dev,
+                              struct ethtool_link_ksettings *cmd)
 {
         struct adapter *adapter = dev->ml_priv;
         struct port_info *p = &adapter->port[dev->if_port];
+        u32 supported, advertising;
 
-        cmd->supported = p->link_config.supported;
-        cmd->advertising = p->link_config.advertising;
+        supported = p->link_config.supported;
+        advertising = p->link_config.advertising;
 
         if (netif_carrier_ok(dev)) {
-                ethtool_cmd_speed_set(cmd, p->link_config.speed);
-                cmd->duplex = p->link_config.duplex;
+                cmd->base.speed = p->link_config.speed;
+                cmd->base.duplex = p->link_config.duplex;
         } else {
-                ethtool_cmd_speed_set(cmd, SPEED_UNKNOWN);
-                cmd->duplex = DUPLEX_UNKNOWN;
+                cmd->base.speed = SPEED_UNKNOWN;
+                cmd->base.duplex = DUPLEX_UNKNOWN;
         }
 
-        cmd->port = (cmd->supported & SUPPORTED_TP) ? PORT_TP : PORT_FIBRE;
-        cmd->phy_address = p->phy->mdio.prtad;
-        cmd->transceiver = XCVR_EXTERNAL;
-        cmd->autoneg = p->link_config.autoneg;
-        cmd->maxtxpkt = 0;
-        cmd->maxrxpkt = 0;
+        cmd->base.port = (supported & SUPPORTED_TP) ? PORT_TP : PORT_FIBRE;
+        cmd->base.phy_address = p->phy->mdio.prtad;
+        cmd->base.autoneg = p->link_config.autoneg;
+
+        ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
+                                                supported);
+        ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
+                                                advertising);
+
         return 0;
 }
 
@@ -628,36 +633,41 @@ static int speed_duplex_to_caps(int speed, int duplex)
                       ADVERTISED_1000baseT_Half | ADVERTISED_1000baseT_Full | \
                       ADVERTISED_10000baseT_Full)
 
-static int set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+static int set_link_ksettings(struct net_device *dev,
+                              const struct ethtool_link_ksettings *cmd)
 {
         struct adapter *adapter = dev->ml_priv;
         struct port_info *p = &adapter->port[dev->if_port];
         struct link_config *lc = &p->link_config;
+        u32 advertising;
+
+        ethtool_convert_link_mode_to_legacy_u32(&advertising,
+                                                cmd->link_modes.advertising);
 
         if (!(lc->supported & SUPPORTED_Autoneg))
                 return -EOPNOTSUPP;             /* can't change speed/duplex */
 
-        if (cmd->autoneg == AUTONEG_DISABLE) {
-                u32 speed = ethtool_cmd_speed(cmd);
-                int cap = speed_duplex_to_caps(speed, cmd->duplex);
+        if (cmd->base.autoneg == AUTONEG_DISABLE) {
+                u32 speed = cmd->base.speed;
+                int cap = speed_duplex_to_caps(speed, cmd->base.duplex);
 
                 if (!(lc->supported & cap) || (speed == SPEED_1000))
                         return -EINVAL;
                 lc->requested_speed = speed;
-                lc->requested_duplex = cmd->duplex;
+                lc->requested_duplex = cmd->base.duplex;
                 lc->advertising = 0;
         } else {
-                cmd->advertising &= ADVERTISED_MASK;
-                if (cmd->advertising & (cmd->advertising - 1))
-                        cmd->advertising = lc->supported;
-                cmd->advertising &= lc->supported;
-                if (!cmd->advertising)
+                advertising &= ADVERTISED_MASK;
+                if (advertising & (advertising - 1))
+                        advertising = lc->supported;
+                advertising &= lc->supported;
+                if (!advertising)
                         return -EINVAL;
                 lc->requested_speed = SPEED_INVALID;
                 lc->requested_duplex = DUPLEX_INVALID;
-                lc->advertising = cmd->advertising | ADVERTISED_Autoneg;
+                lc->advertising = advertising | ADVERTISED_Autoneg;
         }
-        lc->autoneg = cmd->autoneg;
+        lc->autoneg = cmd->base.autoneg;
         if (netif_running(dev))
                 t1_link_start(p->phy, p->mac, lc);
         return 0;
@@ -788,8 +798,6 @@ static int get_eeprom(struct net_device *dev, struct ethtool_eeprom *e,
 }
 
 static const struct ethtool_ops t1_ethtool_ops = {
-        .get_settings      = get_settings,
-        .set_settings      = set_settings,
         .get_drvinfo       = get_drvinfo,
         .get_msglevel      = get_msglevel,
         .set_msglevel      = set_msglevel,
@@ -807,6 +815,8 @@ static const struct ethtool_ops t1_ethtool_ops = {
         .get_ethtool_stats = get_stats,
         .get_regs_len      = get_regs_len,
         .get_regs          = get_regs,
+        .get_link_ksettings = get_link_ksettings,
+        .set_link_ksettings = set_link_ksettings,
 };
 
 static int t1_ioctl(struct net_device *dev, struct ifreq *req, int cmd)
diff --git a/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c b/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c
index 092b3c16440b..7b2224ae72f2 100644
--- a/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c
@@ -1801,27 +1801,31 @@ static int set_phys_id(struct net_device *dev,
         return 0;
 }
 
-static int get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+static int get_link_ksettings(struct net_device *dev,
+                              struct ethtool_link_ksettings *cmd)
 {
         struct port_info *p = netdev_priv(dev);
+        u32 supported;
 
-        cmd->supported = p->link_config.supported;
-        cmd->advertising = p->link_config.advertising;
+        ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
+                                                p->link_config.supported);
+        ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
+                                                p->link_config.advertising);
 
         if (netif_carrier_ok(dev)) {
-                ethtool_cmd_speed_set(cmd, p->link_config.speed);
-                cmd->duplex = p->link_config.duplex;
+                cmd->base.speed = p->link_config.speed;
+                cmd->base.duplex = p->link_config.duplex;
         } else {
-                ethtool_cmd_speed_set(cmd, SPEED_UNKNOWN);
-                cmd->duplex = DUPLEX_UNKNOWN;
+                cmd->base.speed = SPEED_UNKNOWN;
+                cmd->base.duplex = DUPLEX_UNKNOWN;
         }
 
-        cmd->port = (cmd->supported & SUPPORTED_TP) ? PORT_TP : PORT_FIBRE;
-        cmd->phy_address = p->phy.mdio.prtad;
-        cmd->transceiver = XCVR_EXTERNAL;
-        cmd->autoneg = p->link_config.autoneg;
-        cmd->maxtxpkt = 0;
-        cmd->maxrxpkt = 0;
+        ethtool_convert_link_mode_to_legacy_u32(&supported,
+                                                cmd->link_modes.supported);
+
+        cmd->base.port = (supported & SUPPORTED_TP) ? PORT_TP : PORT_FIBRE;
+        cmd->base.phy_address = p->phy.mdio.prtad;
+        cmd->base.autoneg = p->link_config.autoneg;
         return 0;
 }
 
@@ -1860,44 +1864,49 @@ static int speed_duplex_to_caps(int speed, int duplex)
                       ADVERTISED_1000baseT_Half | ADVERTISED_1000baseT_Full | \
                       ADVERTISED_10000baseT_Full)
 
-static int set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+static int set_link_ksettings(struct net_device *dev,
+                              const struct ethtool_link_ksettings *cmd)
 {
         struct port_info *p = netdev_priv(dev);
         struct link_config *lc = &p->link_config;
+        u32 advertising;
+
+        ethtool_convert_link_mode_to_legacy_u32(&advertising,
+                                                cmd->link_modes.advertising);
 
         if (!(lc->supported & SUPPORTED_Autoneg)) {
                 /*
                  * PHY offers a single speed/duplex.  See if that's what's
                  * being requested.
                  */
-                if (cmd->autoneg == AUTONEG_DISABLE) {
-                        u32 speed = ethtool_cmd_speed(cmd);
-                        int cap = speed_duplex_to_caps(speed, cmd->duplex);
+                if (cmd->base.autoneg == AUTONEG_DISABLE) {
+                        u32 speed = cmd->base.speed;
+                        int cap = speed_duplex_to_caps(speed, cmd->base.duplex);
                         if (lc->supported & cap)
                                 return 0;
                 }
                 return -EINVAL;
         }
 
-        if (cmd->autoneg == AUTONEG_DISABLE) {
-                u32 speed = ethtool_cmd_speed(cmd);
-                int cap = speed_duplex_to_caps(speed, cmd->duplex);
+        if (cmd->base.autoneg == AUTONEG_DISABLE) {
+                u32 speed = cmd->base.speed;
+                int cap = speed_duplex_to_caps(speed, cmd->base.duplex);
 
                 if (!(lc->supported & cap) || (speed == SPEED_1000))
                         return -EINVAL;
                 lc->requested_speed = speed;
-                lc->requested_duplex = cmd->duplex;
+                lc->requested_duplex = cmd->base.duplex;
                 lc->advertising = 0;
         } else {
-                cmd->advertising &= ADVERTISED_MASK;
-                cmd->advertising &= lc->supported;
-                if (!cmd->advertising)
+                advertising &= ADVERTISED_MASK;
+                advertising &= lc->supported;
+                if (!advertising)
                         return -EINVAL;
                 lc->requested_speed = SPEED_INVALID;
                 lc->requested_duplex = DUPLEX_INVALID;
-                lc->advertising = cmd->advertising | ADVERTISED_Autoneg;
+                lc->advertising = advertising | ADVERTISED_Autoneg;
         }
-        lc->autoneg = cmd->autoneg;
+        lc->autoneg = cmd->base.autoneg;
         if (netif_running(dev))
                 t3_link_start(&p->phy, &p->mac, lc);
         return 0;
@@ -2097,8 +2106,6 @@ static void get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
 }
 
 static const struct ethtool_ops cxgb_ethtool_ops = {
-        .get_settings = get_settings,
-        .set_settings = set_settings,
         .get_drvinfo = get_drvinfo,
         .get_msglevel = get_msglevel,
         .set_msglevel = set_msglevel,
@@ -2120,6 +2127,8 @@ static const struct ethtool_ops cxgb_ethtool_ops = {
         .get_regs_len = get_regs_len,
         .get_regs = get_regs,
         .get_wol = get_wol,
+        .get_link_ksettings = get_link_ksettings,
+        .set_link_ksettings = set_link_ksettings,
 };
 
 static int in_range(int val, int lo, int hi)
diff --git a/drivers/net/ethernet/cirrus/ep93xx_eth.c b/drivers/net/ethernet/cirrus/ep93xx_eth.c
index a1de0d12927d..396c88678eab 100644
--- a/drivers/net/ethernet/cirrus/ep93xx_eth.c
+++ b/drivers/net/ethernet/cirrus/ep93xx_eth.c
@@ -715,16 +715,18 @@ static void ep93xx_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *i
         strlcpy(info->version, DRV_MODULE_VERSION, sizeof(info->version));
 }
 
-static int ep93xx_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+static int ep93xx_get_link_ksettings(struct net_device *dev,
+                                     struct ethtool_link_ksettings *cmd)
 {
         struct ep93xx_priv *ep = netdev_priv(dev);
-        return mii_ethtool_gset(&ep->mii, cmd);
+        return mii_ethtool_get_link_ksettings(&ep->mii, cmd);
 }
 
-static int ep93xx_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+static int ep93xx_set_link_ksettings(struct net_device *dev,
+                                     const struct ethtool_link_ksettings *cmd)
 {
         struct ep93xx_priv *ep = netdev_priv(dev);
-        return mii_ethtool_sset(&ep->mii, cmd);
+        return mii_ethtool_set_link_ksettings(&ep->mii, cmd);
 }
 
 static int ep93xx_nway_reset(struct net_device *dev)
@@ -741,10 +743,10 @@ static u32 ep93xx_get_link(struct net_device *dev)
 
 static const struct ethtool_ops ep93xx_ethtool_ops = {
         .get_drvinfo            = ep93xx_get_drvinfo,
-        .get_settings           = ep93xx_get_settings,
-        .set_settings           = ep93xx_set_settings,
         .nway_reset             = ep93xx_nway_reset,
         .get_link               = ep93xx_get_link,
+        .get_link_ksettings     = ep93xx_get_link_ksettings,
+        .set_link_ksettings     = ep93xx_set_link_ksettings,
 };
 
 static const struct net_device_ops ep93xx_netdev_ops = {
diff --git a/drivers/net/ethernet/davicom/dm9000.c b/drivers/net/ethernet/davicom/dm9000.c
index f1a81c52afe3..008dc8161775 100644
--- a/drivers/net/ethernet/davicom/dm9000.c
+++ b/drivers/net/ethernet/davicom/dm9000.c
@@ -570,19 +570,21 @@ static void dm9000_set_msglevel(struct net_device *dev, u32 value)
         dm->msg_enable = value;
 }
 
-static int dm9000_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+static int dm9000_get_link_ksettings(struct net_device *dev,
+                                     struct ethtool_link_ksettings *cmd)
 {
         struct board_info *dm = to_dm9000_board(dev);
 
-        mii_ethtool_gset(&dm->mii, cmd);
+        mii_ethtool_get_link_ksettings(&dm->mii, cmd);
         return 0;
 }
 
-static int dm9000_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+static int dm9000_set_link_ksettings(struct net_device *dev,
+                                     const struct ethtool_link_ksettings *cmd)
 {
         struct board_info *dm = to_dm9000_board(dev);
 
-        return mii_ethtool_sset(&dm->mii, cmd);
+        return mii_ethtool_set_link_ksettings(&dm->mii, cmd);
 }
 
 static int dm9000_nway_reset(struct net_device *dev)
@@ -741,8 +743,6 @@ static int dm9000_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)
 
 static const struct ethtool_ops dm9000_ethtool_ops = {
         .get_drvinfo            = dm9000_get_drvinfo,
-        .get_settings           = dm9000_get_settings,
-        .set_settings           = dm9000_set_settings,
         .get_msglevel           = dm9000_get_msglevel,
         .set_msglevel           = dm9000_set_msglevel,
         .nway_reset             = dm9000_nway_reset,
@@ -752,6 +752,8 @@ static const struct ethtool_ops dm9000_ethtool_ops = {
         .get_eeprom_len         = dm9000_get_eeprom_len,
         .get_eeprom             = dm9000_get_eeprom,
         .set_eeprom             = dm9000_set_eeprom,
+        .get_link_ksettings     = dm9000_get_link_ksettings,
+        .set_link_ksettings     = dm9000_set_link_ksettings,
 };
 
 static void dm9000_show_carrier(struct board_info *db,
diff --git a/drivers/net/ethernet/freescale/dpaa/Kconfig b/drivers/net/ethernet/freescale/dpaa/Kconfig
index f3a3454805f9..a654736237a9 100644
--- a/drivers/net/ethernet/freescale/dpaa/Kconfig
+++ b/drivers/net/ethernet/freescale/dpaa/Kconfig
@@ -1,6 +1,6 @@
 menuconfig FSL_DPAA_ETH
         tristate "DPAA Ethernet"
-        depends on FSL_SOC && FSL_DPAA && FSL_FMAN
+        depends on FSL_DPAA && FSL_FMAN
         select PHYLIB
         select FSL_FMAN_MAC
         ---help---
diff --git a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c
index 3c48a84dec86..624ba9058dc4 100644
--- a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c
+++ b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c
@@ -733,7 +733,7 @@ static int dpaa_eth_cgr_init(struct dpaa_priv *priv)
         priv->cgr_data.cgr.cb = dpaa_eth_cgscn;
 
         /* Enable Congestion State Change Notifications and CS taildrop */
-        initcgr.we_mask = QM_CGR_WE_CSCN_EN | QM_CGR_WE_CS_THRES;
+        initcgr.we_mask = cpu_to_be16(QM_CGR_WE_CSCN_EN | QM_CGR_WE_CS_THRES);
         initcgr.cgr.cscn_en = QM_CGR_EN;
 
         /* Set different thresholds based on the MAC speed.
@@ -747,7 +747,7 @@ static int dpaa_eth_cgr_init(struct dpaa_priv *priv)
                 cs_th = DPAA_CS_THRESHOLD_1G;
         qm_cgr_cs_thres_set64(&initcgr.cgr.cs_thres, cs_th, 1);
 
-        initcgr.we_mask |= QM_CGR_WE_CSTD_EN;
+        initcgr.we_mask |= cpu_to_be16(QM_CGR_WE_CSTD_EN);
         initcgr.cgr.cstd_en = QM_CGR_EN;
 
         err = qman_create_cgr(&priv->cgr_data.cgr, QMAN_CGR_FLAG_USE_INIT,
@@ -896,18 +896,18 @@ static int dpaa_fq_init(struct dpaa_fq *dpaa_fq, bool td_enable)
         if (dpaa_fq->init) {
                 memset(&initfq, 0, sizeof(initfq));
 
-                initfq.we_mask = QM_INITFQ_WE_FQCTRL;
+                initfq.we_mask = cpu_to_be16(QM_INITFQ_WE_FQCTRL);
                 /* Note: we may get to keep an empty FQ in cache */
-                initfq.fqd.fq_ctrl = QM_FQCTRL_PREFERINCACHE;
+                initfq.fqd.fq_ctrl = cpu_to_be16(QM_FQCTRL_PREFERINCACHE);
 
                 /* Try to reduce the number of portal interrupts for
                  * Tx Confirmation FQs.
                  */
                 if (dpaa_fq->fq_type == FQ_TYPE_TX_CONFIRM)
-                        initfq.fqd.fq_ctrl |= QM_FQCTRL_HOLDACTIVE;
+                        initfq.fqd.fq_ctrl |= cpu_to_be16(QM_FQCTRL_HOLDACTIVE);
 
                 /* FQ placement */
-                initfq.we_mask |= QM_INITFQ_WE_DESTWQ;
+                initfq.we_mask |= cpu_to_be16(QM_INITFQ_WE_DESTWQ);
 
                 qm_fqd_set_destwq(&initfq.fqd, dpaa_fq->channel, dpaa_fq->wq);
 
@@ -920,8 +920,8 @@ static int dpaa_fq_init(struct dpaa_fq *dpaa_fq, bool td_enable)
                 if (dpaa_fq->fq_type == FQ_TYPE_TX ||
                     dpaa_fq->fq_type == FQ_TYPE_TX_CONFIRM ||
                     dpaa_fq->fq_type == FQ_TYPE_TX_CONF_MQ) {
-                        initfq.we_mask |= QM_INITFQ_WE_CGID;
-                        initfq.fqd.fq_ctrl |= QM_FQCTRL_CGE;
+                        initfq.we_mask |= cpu_to_be16(QM_INITFQ_WE_CGID);
+                        initfq.fqd.fq_ctrl |= cpu_to_be16(QM_FQCTRL_CGE);
                         initfq.fqd.cgid = (u8)priv->cgr_data.cgr.cgrid;
                         /* Set a fixed overhead accounting, in an attempt to
                          * reduce the impact of fixed-size skb shells and the
@@ -932,7 +932,7 @@ static int dpaa_fq_init(struct dpaa_fq *dpaa_fq, bool td_enable)
                          * insufficient value, but even that is better than
                          * no overhead accounting at all.
                          */
-                        initfq.we_mask |= QM_INITFQ_WE_OAC;
+                        initfq.we_mask |= cpu_to_be16(QM_INITFQ_WE_OAC);
                         qm_fqd_set_oac(&initfq.fqd, QM_OAC_CG);
                         qm_fqd_set_oal(&initfq.fqd,
                                        min(sizeof(struct sk_buff) +
@@ -941,9 +941,9 @@ static int dpaa_fq_init(struct dpaa_fq *dpaa_fq, bool td_enable)
                 }
 
                 if (td_enable) {
-                        initfq.we_mask |= QM_INITFQ_WE_TDTHRESH;
+                        initfq.we_mask |= cpu_to_be16(QM_INITFQ_WE_TDTHRESH);
                         qm_fqd_set_taildrop(&initfq.fqd, DPAA_FQ_TD, 1);
-                        initfq.fqd.fq_ctrl = QM_FQCTRL_TDE;
+                        initfq.fqd.fq_ctrl = cpu_to_be16(QM_FQCTRL_TDE);
                 }
 
                 if (dpaa_fq->fq_type == FQ_TYPE_TX) {
@@ -951,7 +951,8 @@ static int dpaa_fq_init(struct dpaa_fq *dpaa_fq, bool td_enable)
                         if (queue_id >= 0)
                                 confq = priv->conf_fqs[queue_id];
                         if (confq) {
-                                initfq.we_mask |= QM_INITFQ_WE_CONTEXTA;
+                                initfq.we_mask |=
+                                        cpu_to_be16(QM_INITFQ_WE_CONTEXTA);
                         /* ContextA: OVOM=1(use contextA2 bits instead of ICAD)
                          *           A2V=1 (contextA A2 field is valid)
                          *           A0V=1 (contextA A0 field is valid)
@@ -959,8 +960,8 @@ static int dpaa_fq_init(struct dpaa_fq *dpaa_fq, bool td_enable)
                          * ContextA A2: EBD=1 (deallocate buffers inside FMan)
                          * ContextB B0(ASPID): 0 (absolute Virtual Storage ID)
                          */
-                                initfq.fqd.context_a.hi = 0x1e000000;
-                                initfq.fqd.context_a.lo = 0x80000000;
+                                qm_fqd_context_a_set64(&initfq.fqd,
+                                                       0x1e00000080000000ULL);
                         }
                 }
 
@@ -968,13 +969,13 @@ static int dpaa_fq_init(struct dpaa_fq *dpaa_fq, bool td_enable)
                 if (priv->use_ingress_cgr &&
                     (dpaa_fq->fq_type == FQ_TYPE_RX_DEFAULT ||
                      dpaa_fq->fq_type == FQ_TYPE_RX_ERROR)) {
-                        initfq.we_mask |= QM_INITFQ_WE_CGID;
-                        initfq.fqd.fq_ctrl |= QM_FQCTRL_CGE;
+                        initfq.we_mask |= cpu_to_be16(QM_INITFQ_WE_CGID);
+                        initfq.fqd.fq_ctrl |= cpu_to_be16(QM_FQCTRL_CGE);
                         initfq.fqd.cgid = (u8)priv->ingress_cgr.cgrid;
                         /* Set a fixed overhead accounting, just like for the
                          * egress CGR.
                          */
-                        initfq.we_mask |= QM_INITFQ_WE_OAC;
+                        initfq.we_mask |= cpu_to_be16(QM_INITFQ_WE_OAC);
                         qm_fqd_set_oac(&initfq.fqd, QM_OAC_CG);
                         qm_fqd_set_oal(&initfq.fqd,
                                        min(sizeof(struct sk_buff) +
@@ -984,9 +985,8 @@ static int dpaa_fq_init(struct dpaa_fq *dpaa_fq, bool td_enable)
 
                 /* Initialization common to all ingress queues */
                 if (dpaa_fq->flags & QMAN_FQ_FLAG_NO_ENQUEUE) {
-                        initfq.we_mask |= QM_INITFQ_WE_CONTEXTA;
-                        initfq.fqd.fq_ctrl |=
-                                QM_FQCTRL_HOLDACTIVE;
+                        initfq.we_mask |= cpu_to_be16(QM_INITFQ_WE_CONTEXTA);
+                        initfq.fqd.fq_ctrl |= cpu_to_be16(QM_FQCTRL_HOLDACTIVE);
                         initfq.fqd.context_a.stashing.exclusive =
                                 QM_STASHING_EXCL_DATA | QM_STASHING_EXCL_CTX |
                                 QM_STASHING_EXCL_ANNOTATION;
@@ -1350,7 +1350,7 @@ static int dpaa_enable_tx_csum(struct dpaa_priv *priv,
         parse_result->l4_off = (u8)skb_transport_offset(skb);
 
         /* Enable L3 (and L4, if TCP or UDP) HW checksum. */
-        fd->cmd |= FM_FD_CMD_RPD | FM_FD_CMD_DTC;
+        fd->cmd |= cpu_to_be32(FM_FD_CMD_RPD | FM_FD_CMD_DTC);
 
         /* On P1023 and similar platforms fd->cmd interpretation could
          * be disabled by setting CONTEXT_A bit ICMD; currently this bit
@@ -1732,7 +1732,7 @@ static int skb_to_contig_fd(struct dpaa_priv *priv,
 
         /* Fill in the rest of the FD fields */
         qm_fd_set_contig(fd, priv->tx_headroom, skb->len);
-        fd->cmd |= FM_FD_CMD_FCO;
+        fd->cmd |= cpu_to_be32(FM_FD_CMD_FCO);
 
         /* Map the entire buffer size that may be seen by FMan, but no more */
         addr = dma_map_single(dev, skbh,
@@ -1840,7 +1840,7 @@ static int skb_to_sg_fd(struct dpaa_priv *priv,
         }
 
         fd->bpid = FSL_DPAA_BPID_INV;
-        fd->cmd |= FM_FD_CMD_FCO;
+        fd->cmd |= cpu_to_be32(FM_FD_CMD_FCO);
         qm_fd_addr_set64(fd, addr);
 
         return 0;
@@ -1867,7 +1867,7 @@ static inline int dpaa_xmit(struct dpaa_priv *priv,
 
         egress_fq = priv->egress_fqs[queue];
         if (fd->bpid == FSL_DPAA_BPID_INV)
-                fd->cmd |= qman_fq_fqid(priv->conf_fqs[queue]);
+                fd->cmd |= cpu_to_be32(qman_fq_fqid(priv->conf_fqs[queue]));
 
         /* Trace this Tx fd */
         trace_dpaa_tx_fd(priv->net_dev, egress_fq, fd);
@@ -1960,17 +1960,17 @@ static void dpaa_rx_error(struct net_device *net_dev,
 {
         if (net_ratelimit())
                 netif_err(priv, hw, net_dev, "Err FD status = 0x%08x\n",
-                          fd->status & FM_FD_STAT_RX_ERRORS);
+                          be32_to_cpu(fd->status) & FM_FD_STAT_RX_ERRORS);
 
         percpu_priv->stats.rx_errors++;
 
-        if (fd->status & FM_FD_ERR_DMA)
+        if (be32_to_cpu(fd->status) & FM_FD_ERR_DMA)
                 percpu_priv->rx_errors.dme++;
-        if (fd->status & FM_FD_ERR_PHYSICAL)
+        if (be32_to_cpu(fd->status) & FM_FD_ERR_PHYSICAL)
                 percpu_priv->rx_errors.fpe++;
-        if (fd->status & FM_FD_ERR_SIZE)
+        if (be32_to_cpu(fd->status) & FM_FD_ERR_SIZE)
                 percpu_priv->rx_errors.fse++;
-        if (fd->status & FM_FD_ERR_PRS_HDR_ERR)
+        if (be32_to_cpu(fd->status) & FM_FD_ERR_PRS_HDR_ERR)
                 percpu_priv->rx_errors.phe++;
 
         dpaa_fd_release(net_dev, fd);
@@ -1986,7 +1986,7 @@ static void dpaa_tx_error(struct net_device *net_dev,
 
         if (net_ratelimit())
                 netif_warn(priv, hw, net_dev, "FD status = 0x%08x\n",
-                           fd->status & FM_FD_STAT_TX_ERRORS);
+                           be32_to_cpu(fd->status) & FM_FD_STAT_TX_ERRORS);
 
         percpu_priv->stats.tx_errors++;
 
@@ -2020,10 +2020,11 @@ static void dpaa_tx_conf(struct net_device *net_dev,
 {
         struct sk_buff  *skb;
 
-        if (unlikely(fd->status & FM_FD_STAT_TX_ERRORS) != 0) {
+        if (unlikely(be32_to_cpu(fd->status) & FM_FD_STAT_TX_ERRORS)) {
                 if (net_ratelimit())
                         netif_warn(priv, hw, net_dev, "FD status = 0x%08x\n",
-                                   fd->status & FM_FD_STAT_TX_ERRORS);
+                                   be32_to_cpu(fd->status) &
+                                   FM_FD_STAT_TX_ERRORS);
 
                 percpu_priv->stats.tx_errors++;
         }
@@ -2100,6 +2101,8 @@ static enum qman_cb_dqrr_result rx_default_dqrr(struct qman_portal *portal,
         struct sk_buff *skb;
         int *count_ptr;
 
+        fd_status = be32_to_cpu(fd->status);
+        fd_format = qm_fd_get_format(fd);
         net_dev = ((struct dpaa_fq *)fq)->net_dev;
         priv = netdev_priv(net_dev);
         dpaa_bp = dpaa_bpid2pool(dq->fd.bpid);
@@ -2417,12 +2420,12 @@ static int dpaa_ingress_cgr_init(struct dpaa_priv *priv)
         }
 
         /* Enable CS TD, but disable Congestion State Change Notifications. */
-        initcgr.we_mask = QM_CGR_WE_CS_THRES;
+        initcgr.we_mask = cpu_to_be16(QM_CGR_WE_CS_THRES);
         initcgr.cgr.cscn_en = QM_CGR_EN;
         cs_th = DPAA_INGRESS_CS_THRESHOLD;
         qm_cgr_cs_thres_set64(&initcgr.cgr.cs_thres, cs_th, 1);
 
-        initcgr.we_mask |= QM_CGR_WE_CSTD_EN;
+        initcgr.we_mask |= cpu_to_be16(QM_CGR_WE_CSTD_EN);
         initcgr.cgr.cstd_en = QM_CGR_EN;
 
         /* This CGR will be associated with the SWP affined to the current CPU.
diff --git a/drivers/net/ethernet/hisilicon/hip04_eth.c b/drivers/net/ethernet/hisilicon/hip04_eth.c
index 854befde0a08..97b184774784 100644
--- a/drivers/net/ethernet/hisilicon/hip04_eth.c
+++ b/drivers/net/ethernet/hisilicon/hip04_eth.c
@@ -828,6 +828,7 @@ static int hip04_mac_probe(struct platform_device *pdev)
         priv = netdev_priv(ndev);
         priv->ndev = ndev;
         platform_set_drvdata(pdev, ndev);
+        SET_NETDEV_DEV(ndev, &pdev->dev);
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         priv->base = devm_ioremap_resource(d, res);
@@ -903,7 +904,6 @@ static int hip04_mac_probe(struct platform_device *pdev)
         ndev->priv_flags |= IFF_UNICAST_FLT;
         ndev->irq = irq;
         netif_napi_add(ndev, &priv->napi, hip04_rx_poll, NAPI_POLL_WEIGHT);
-        SET_NETDEV_DEV(ndev, &pdev->dev);
 
         hip04_reset_ppe(priv);
         if (priv->phy_mode == PHY_INTERFACE_MODE_MII)
diff --git a/drivers/net/ethernet/hisilicon/hisi_femac.c b/drivers/net/ethernet/hisilicon/hisi_femac.c
index 49863068c59e..979852d56f31 100644
--- a/drivers/net/ethernet/hisilicon/hisi_femac.c
+++ b/drivers/net/ethernet/hisilicon/hisi_femac.c
@@ -805,6 +805,7 @@ static int hisi_femac_drv_probe(struct platform_device *pdev)
                 return -ENOMEM;
 
         platform_set_drvdata(pdev, ndev);
+        SET_NETDEV_DEV(ndev, &pdev->dev);
 
         priv = netdev_priv(ndev);
         priv->dev = dev;
@@ -882,7 +883,6 @@ static int hisi_femac_drv_probe(struct platform_device *pdev)
         ndev->netdev_ops = &hisi_femac_netdev_ops;
         ndev->ethtool_ops = &hisi_femac_ethtools_ops;
         netif_napi_add(ndev, &priv->napi, hisi_femac_poll, FEMAC_POLL_WEIGHT);
-        SET_NETDEV_DEV(ndev, &pdev->dev);
 
         hisi_femac_port_init(priv);
 
diff --git a/drivers/net/ethernet/ibm/ibmveth.c b/drivers/net/ethernet/ibm/ibmveth.c
index fbece63395a8..a831f947ca8c 100644
--- a/drivers/net/ethernet/ibm/ibmveth.c
+++ b/drivers/net/ethernet/ibm/ibmveth.c
@@ -1181,7 +1181,9 @@ map_failed:
 
 static void ibmveth_rx_mss_helper(struct sk_buff *skb, u16 mss, int lrg_pkt)
 {
+        struct tcphdr *tcph;
         int offset = 0;
+        int hdr_len;
 
         /* only TCP packets will be aggregated */
         if (skb->protocol == htons(ETH_P_IP)) {
@@ -1208,14 +1210,20 @@ static void ibmveth_rx_mss_helper(struct sk_buff *skb, u16 mss, int lrg_pkt)
         /* if mss is not set through Large Packet bit/mss in rx buffer,
          * expect that the mss will be written to the tcp header checksum.
          */
+        tcph = (struct tcphdr *)(skb->data + offset);
         if (lrg_pkt) {
                 skb_shinfo(skb)->gso_size = mss;
         } else if (offset) {
-                struct tcphdr *tcph = (struct tcphdr *)(skb->data + offset);
-
                 skb_shinfo(skb)->gso_size = ntohs(tcph->check);
                 tcph->check = 0;
         }
+
+        if (skb_shinfo(skb)->gso_size) {
+                hdr_len = offset + tcph->doff * 4;
+                skb_shinfo(skb)->gso_segs =
+                                DIV_ROUND_UP(skb->len - hdr_len,
+                                             skb_shinfo(skb)->gso_size);
+        }
 }
 
 static int ibmveth_poll(struct napi_struct *napi, int budget)
diff --git a/drivers/net/ethernet/marvell/mv643xx_eth.c b/drivers/net/ethernet/marvell/mv643xx_eth.c
index 5f62c3d70df9..1fa7c03edec2 100644
--- a/drivers/net/ethernet/marvell/mv643xx_eth.c
+++ b/drivers/net/ethernet/marvell/mv643xx_eth.c
@@ -2713,7 +2713,7 @@ static const struct of_device_id mv643xx_eth_shared_ids[] = {
 MODULE_DEVICE_TABLE(of, mv643xx_eth_shared_ids);
 #endif
 
-#if defined(CONFIG_OF) && !defined(CONFIG_MV64X60)
+#if defined(CONFIG_OF_IRQ) && !defined(CONFIG_MV64X60)
 #define mv643xx_eth_property(_np, _name, _v)                            \
         do {                                                            \
                 u32 tmp;                                                \
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
index fece974b4edd..d768c7b6c6d6 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
@@ -2404,7 +2404,7 @@ static int mlxsw_sp_port_create(struct mlxsw_sp *mlxsw_sp, u8 local_port,
                         local_port);
                 return err;
         }
-        err = __mlxsw_sp_port_create(mlxsw_sp, local_port, false,
+        err = __mlxsw_sp_port_create(mlxsw_sp, local_port, split,
                                      module, width, lane);
         if (err)
                 goto err_port_create;
diff --git a/drivers/net/ethernet/microchip/encx24j600-regmap.c b/drivers/net/ethernet/microchip/encx24j600-regmap.c
index f3bb9055a292..44bb04d4d21b 100644
--- a/drivers/net/ethernet/microchip/encx24j600-regmap.c
+++ b/drivers/net/ethernet/microchip/encx24j600-regmap.c
@@ -26,11 +26,11 @@ static inline bool is_bits_set(int value, int mask)
 }
 
 static int encx24j600_switch_bank(struct encx24j600_context *ctx,
-                                         int bank)
+                                  int bank)
 {
         int ret = 0;
-
         int bank_opcode = BANK_SELECT(bank);
+
         ret = spi_write(ctx->spi, &bank_opcode, 1);
         if (ret == 0)
                 ctx->bank = bank;
@@ -39,7 +39,7 @@ static int encx24j600_switch_bank(struct encx24j600_context *ctx,
 }
 
 static int encx24j600_cmdn(struct encx24j600_context *ctx, u8 opcode,
-                            const void *buf, size_t len)
+                           const void *buf, size_t len)
 {
         struct spi_message m;
         struct spi_transfer t[2] = { { .tx_buf = &opcode, .len = 1, },
@@ -54,12 +54,14 @@ static int encx24j600_cmdn(struct encx24j600_context *ctx, u8 opcode,
 static void regmap_lock_mutex(void *context)
 {
         struct encx24j600_context *ctx = context;
+
         mutex_lock(&ctx->mutex);
 }
 
 static void regmap_unlock_mutex(void *context)
 {
         struct encx24j600_context *ctx = context;
+
         mutex_unlock(&ctx->mutex);
 }
 
@@ -128,6 +130,7 @@ static int regmap_encx24j600_sfr_update(struct encx24j600_context *ctx,
 
         if (reg < 0x80) {
                 int ret = 0;
+
                 cmd = banked_code | banked_reg;
                 if ((banked_reg < 0x16) && (ctx->bank != bank))
                         ret = encx24j600_switch_bank(ctx, bank);
@@ -174,6 +177,7 @@ static int regmap_encx24j600_sfr_write(void *context, u8 reg, u8 *val,
                                        size_t len)
 {
         struct encx24j600_context *ctx = context;
+
         return regmap_encx24j600_sfr_update(ctx, reg, val, len, WCRU, WCRCODE);
 }
 
@@ -228,9 +232,9 @@ int regmap_encx24j600_spi_write(void *context, u8 reg, const u8 *data,
 
         if (reg < 0xc0)
                 return encx24j600_cmdn(ctx, reg, data, count);
-        else
-                /* SPI 1-byte command. Ignore data */
-                return spi_write(ctx->spi, &reg, 1);
+
+        /* SPI 1-byte command. Ignore data */
+        return spi_write(ctx->spi, &reg, 1);
 }
 EXPORT_SYMBOL_GPL(regmap_encx24j600_spi_write);
 
@@ -495,6 +499,7 @@ static struct regmap_config phycfg = {
         .writeable_reg = encx24j600_phymap_writeable,
         .volatile_reg = encx24j600_phymap_volatile,
 };
+
 static struct regmap_bus phymap_encx24j600 = {
         .reg_write = regmap_encx24j600_phy_reg_write,
         .reg_read = regmap_encx24j600_phy_reg_read,
diff --git a/drivers/net/ethernet/microchip/encx24j600.c b/drivers/net/ethernet/microchip/encx24j600.c
index b14f0305aa31..fbce6166504e 100644
--- a/drivers/net/ethernet/microchip/encx24j600.c
+++ b/drivers/net/ethernet/microchip/encx24j600.c
@@ -30,7 +30,7 @@
 
 #define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK)
 static int debug = -1;
-module_param(debug, int, 0);
+module_param(debug, int, 0000);
 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
 
 /* SRAM memory layout:
@@ -105,6 +105,7 @@ static u16 encx24j600_read_reg(struct encx24j600_priv *priv, u8 reg)
         struct net_device *dev = priv->ndev;
         unsigned int val = 0;
         int ret = regmap_read(priv->ctx.regmap, reg, &val);
+
         if (unlikely(ret))
                 netif_err(priv, drv, dev, "%s: error %d reading reg %02x\n",
                           __func__, ret, reg);
@@ -115,6 +116,7 @@ static void encx24j600_write_reg(struct encx24j600_priv *priv, u8 reg, u16 val)
 {
         struct net_device *dev = priv->ndev;
         int ret = regmap_write(priv->ctx.regmap, reg, val);
+
         if (unlikely(ret))
                 netif_err(priv, drv, dev, "%s: error %d writing reg %02x=%04x\n",
                           __func__, ret, reg, val);
@@ -125,6 +127,7 @@ static void encx24j600_update_reg(struct encx24j600_priv *priv, u8 reg,
 {
         struct net_device *dev = priv->ndev;
         int ret = regmap_update_bits(priv->ctx.regmap, reg, mask, val);
+
         if (unlikely(ret))
                 netif_err(priv, drv, dev, "%s: error %d updating reg %02x=%04x~%04x\n",
                           __func__, ret, reg, val, mask);
@@ -135,6 +138,7 @@ static u16 encx24j600_read_phy(struct encx24j600_priv *priv, u8 reg)
         struct net_device *dev = priv->ndev;
         unsigned int val = 0;
         int ret = regmap_read(priv->ctx.phymap, reg, &val);
+
         if (unlikely(ret))
                 netif_err(priv, drv, dev, "%s: error %d reading %02x\n",
                           __func__, ret, reg);
@@ -145,6 +149,7 @@ static void encx24j600_write_phy(struct encx24j600_priv *priv, u8 reg, u16 val)
 {
         struct net_device *dev = priv->ndev;
         int ret = regmap_write(priv->ctx.phymap, reg, val);
+
         if (unlikely(ret))
                 netif_err(priv, drv, dev, "%s: error %d writing reg %02x=%04x\n",
                           __func__, ret, reg, val);
@@ -164,6 +169,7 @@ static void encx24j600_cmd(struct encx24j600_priv *priv, u8 cmd)
 {
         struct net_device *dev = priv->ndev;
         int ret = regmap_write(priv->ctx.regmap, cmd, 0);
+
         if (unlikely(ret))
                 netif_err(priv, drv, dev, "%s: error %d with cmd %02x\n",
                           __func__, ret, cmd);
@@ -173,6 +179,7 @@ static int encx24j600_raw_read(struct encx24j600_priv *priv, u8 reg, u8 *data,
                                size_t count)
 {
         int ret;
+
         mutex_lock(&priv->ctx.mutex);
         ret = regmap_encx24j600_spi_read(&priv->ctx, reg, data, count);
         mutex_unlock(&priv->ctx.mutex);
@@ -184,6 +191,7 @@ static int encx24j600_raw_write(struct encx24j600_priv *priv, u8 reg,
                                 const u8 *data, size_t count)
 {
         int ret;
+
         mutex_lock(&priv->ctx.mutex);
         ret = regmap_encx24j600_spi_write(&priv->ctx, reg, data, count);
         mutex_unlock(&priv->ctx.mutex);
@@ -194,6 +202,7 @@ static int encx24j600_raw_write(struct encx24j600_priv *priv, u8 reg,
 static void encx24j600_update_phcon1(struct encx24j600_priv *priv)
 {
         u16 phcon1 = encx24j600_read_phy(priv, PHCON1);
+
         if (priv->autoneg == AUTONEG_ENABLE) {
                 phcon1 |= ANEN | RENEG;
         } else {
@@ -328,6 +337,7 @@ static int encx24j600_receive_packet(struct encx24j600_priv *priv,
 {
         struct net_device *dev = priv->ndev;
         struct sk_buff *skb = netdev_alloc_skb(dev, rsv->len + NET_IP_ALIGN);
+
         if (!skb) {
                 pr_err_ratelimited("RX: OOM: packet dropped\n");
                 dev->stats.rx_dropped++;
@@ -346,7 +356,6 @@ static int encx24j600_receive_packet(struct encx24j600_priv *priv,
         /* Maintain stats */
         dev->stats.rx_packets++;
         dev->stats.rx_bytes += rsv->len;
-        priv->next_packet = rsv->next_packet;
 
         netif_rx(skb);
 
@@ -383,6 +392,8 @@ static void encx24j600_rx_packets(struct encx24j600_priv *priv, u8 packet_count)
                         encx24j600_receive_packet(priv, &rsv);
                 }
 
+                priv->next_packet = rsv.next_packet;
+
                 newrxtail = priv->next_packet - 2;
                 if (newrxtail == ENC_RX_BUF_START)
                         newrxtail = SRAM_SIZE - 2;
@@ -827,6 +838,7 @@ static void encx24j600_set_multicast_list(struct net_device *dev)
 static void encx24j600_hw_tx(struct encx24j600_priv *priv)
 {
         struct net_device *dev = priv->ndev;
+
         netif_info(priv, tx_queued, dev, "TX Packet Len:%d\n",
                    priv->tx_skb->len);
 
@@ -894,7 +906,6 @@ static void encx24j600_tx_timeout(struct net_device *dev)
 
         dev->stats.tx_errors++;
         netif_wake_queue(dev);
-        return;
 }
 
 static int encx24j600_get_regs_len(struct net_device *dev)
@@ -957,12 +968,14 @@ static int encx24j600_set_settings(struct net_device *dev,
 static u32 encx24j600_get_msglevel(struct net_device *dev)
 {
         struct encx24j600_priv *priv = netdev_priv(dev);
+
         return priv->msg_enable;
 }
 
 static void encx24j600_set_msglevel(struct net_device *dev, u32 val)
 {
         struct encx24j600_priv *priv = netdev_priv(dev);
+
         priv->msg_enable = val;
 }
 
diff --git a/drivers/net/ethernet/qlogic/qed/qed_iscsi.c b/drivers/net/ethernet/qlogic/qed/qed_iscsi.c
index 00efb1c4c57e..17a70122df05 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_iscsi.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_iscsi.c
@@ -1265,7 +1265,7 @@ static const struct qed_iscsi_ops qed_iscsi_ops_pass = {
         .get_stats = &qed_iscsi_stats,
 };
 
-const struct qed_iscsi_ops *qed_get_iscsi_ops()
+const struct qed_iscsi_ops *qed_get_iscsi_ops(void)
 {
         return &qed_iscsi_ops_pass;
 }
diff --git a/drivers/net/ethernet/qualcomm/emac/emac.c b/drivers/net/ethernet/qualcomm/emac/emac.c
index ae32f855e31b..422289c232bc 100644
--- a/drivers/net/ethernet/qualcomm/emac/emac.c
+++ b/drivers/net/ethernet/qualcomm/emac/emac.c
@@ -460,6 +460,12 @@ static int emac_clks_phase1_init(struct platform_device *pdev,
 {
         int ret;
 
+        /* On ACPI platforms, clocks are controlled by firmware and/or
+         * ACPI, not by drivers.
+         */
+        if (has_acpi_companion(&pdev->dev))
+                return 0;
+
         ret = emac_clks_get(pdev, adpt);
         if (ret)
                 return ret;
@@ -485,6 +491,9 @@ static int emac_clks_phase2_init(struct platform_device *pdev,
 {
         int ret;
 
+        if (has_acpi_companion(&pdev->dev))
+                return 0;
+
         ret = clk_set_rate(adpt->clk[EMAC_CLK_TX], 125000000);
         if (ret)
                 return ret;
diff --git a/drivers/net/ethernet/rdc/r6040.c b/drivers/net/ethernet/rdc/r6040.c
index 4ff4e0491406..aa11b70b9ca4 100644
--- a/drivers/net/ethernet/rdc/r6040.c
+++ b/drivers/net/ethernet/rdc/r6040.c
@@ -472,8 +472,6 @@ static void r6040_down(struct net_device *dev)
         iowrite16(adrp[0], ioaddr + MID_0L);
         iowrite16(adrp[1], ioaddr + MID_0M);
         iowrite16(adrp[2], ioaddr + MID_0H);
-
-        phy_stop(dev->phydev);
 }
 
 static int r6040_close(struct net_device *dev)
@@ -481,12 +479,12 @@ static int r6040_close(struct net_device *dev)
         struct r6040_private *lp = netdev_priv(dev);
         struct pci_dev *pdev = lp->pdev;
 
-        spin_lock_irq(&lp->lock);
+        phy_stop(dev->phydev);
         napi_disable(&lp->napi);
         netif_stop_queue(dev);
-        r6040_down(dev);
 
-        free_irq(dev->irq, dev);
+        spin_lock_irq(&lp->lock);
+        r6040_down(dev);
 
         /* Free RX buffer */
         r6040_free_rxbufs(dev);
@@ -496,6 +494,8 @@ static int r6040_close(struct net_device *dev)
 
         spin_unlock_irq(&lp->lock);
 
+        free_irq(dev->irq, dev);
+
         /* Free Descriptor memory */
         if (lp->rx_ring) {
                 pci_free_consistent(pdev,
diff --git a/drivers/net/ethernet/sfc/ethtool.c b/drivers/net/ethernet/sfc/ethtool.c
index f644216eda1b..87bdc56b4e3a 100644
--- a/drivers/net/ethernet/sfc/ethtool.c
+++ b/drivers/net/ethernet/sfc/ethtool.c
@@ -120,44 +120,53 @@ static int efx_ethtool_phys_id(struct net_device *net_dev,
 }
 
 /* This must be called with rtnl_lock held. */
-static int efx_ethtool_get_settings(struct net_device *net_dev,
-                                    struct ethtool_cmd *ecmd)
+static int
+efx_ethtool_get_link_ksettings(struct net_device *net_dev,
+                               struct ethtool_link_ksettings *cmd)
 {
         struct efx_nic *efx = netdev_priv(net_dev);
         struct efx_link_state *link_state = &efx->link_state;
+        u32 supported;
 
         mutex_lock(&efx->mac_lock);
-        efx->phy_op->get_settings(efx, ecmd);
+        efx->phy_op->get_link_ksettings(efx, cmd);
         mutex_unlock(&efx->mac_lock);
 
         /* Both MACs support pause frames (bidirectional and respond-only) */
-        ecmd->supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
+        ethtool_convert_link_mode_to_legacy_u32(&supported,
+                                                cmd->link_modes.supported);
+
+        supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
+
+        ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
+                                                supported);
 
         if (LOOPBACK_INTERNAL(efx)) {
-                ethtool_cmd_speed_set(ecmd, link_state->speed);
-                ecmd->duplex = link_state->fd ? DUPLEX_FULL : DUPLEX_HALF;
+                cmd->base.speed = link_state->speed;
+                cmd->base.duplex = link_state->fd ? DUPLEX_FULL : DUPLEX_HALF;
         }
 
         return 0;
 }
 
 /* This must be called with rtnl_lock held. */
-static int efx_ethtool_set_settings(struct net_device *net_dev,
-                                    struct ethtool_cmd *ecmd)
+static int
+efx_ethtool_set_link_ksettings(struct net_device *net_dev,
+                               const struct ethtool_link_ksettings *cmd)
 {
         struct efx_nic *efx = netdev_priv(net_dev);
         int rc;
 
         /* GMAC does not support 1000Mbps HD */
-        if ((ethtool_cmd_speed(ecmd) == SPEED_1000) &&
-            (ecmd->duplex != DUPLEX_FULL)) {
+        if ((cmd->base.speed == SPEED_1000) &&
+            (cmd->base.duplex != DUPLEX_FULL)) {
                 netif_dbg(efx, drv, efx->net_dev,
                           "rejecting unsupported 1000Mbps HD setting\n");
                 return -EINVAL;
         }
 
         mutex_lock(&efx->mac_lock);
-        rc = efx->phy_op->set_settings(efx, ecmd);
+        rc = efx->phy_op->set_link_ksettings(efx, cmd);
         mutex_unlock(&efx->mac_lock);
         return rc;
 }
@@ -1342,8 +1351,6 @@ static int efx_ethtool_get_module_info(struct net_device *net_dev,
 }
 
 const struct ethtool_ops efx_ethtool_ops = {
-        .get_settings           = efx_ethtool_get_settings,
-        .set_settings           = efx_ethtool_set_settings,
         .get_drvinfo            = efx_ethtool_get_drvinfo,
         .get_regs_len           = efx_ethtool_get_regs_len,
         .get_regs               = efx_ethtool_get_regs,
@@ -1373,4 +1380,6 @@ const struct ethtool_ops efx_ethtool_ops = {
         .get_ts_info            = efx_ethtool_get_ts_info,
         .get_module_info        = efx_ethtool_get_module_info,
         .get_module_eeprom      = efx_ethtool_get_module_eeprom,
+        .get_link_ksettings     = efx_ethtool_get_link_ksettings,
+        .set_link_ksettings     = efx_ethtool_set_link_ksettings,
 };
diff --git a/drivers/net/ethernet/sfc/mcdi_port.c b/drivers/net/ethernet/sfc/mcdi_port.c
index 9dcd396784ae..c905971c5f3a 100644
--- a/drivers/net/ethernet/sfc/mcdi_port.c
+++ b/drivers/net/ethernet/sfc/mcdi_port.c
@@ -503,45 +503,59 @@ static void efx_mcdi_phy_remove(struct efx_nic *efx)
         kfree(phy_data);
 }
 
-static void efx_mcdi_phy_get_settings(struct efx_nic *efx, struct ethtool_cmd *ecmd)
+static void efx_mcdi_phy_get_link_ksettings(struct efx_nic *efx,
+                                            struct ethtool_link_ksettings *cmd)
 {
         struct efx_mcdi_phy_data *phy_cfg = efx->phy_data;
         MCDI_DECLARE_BUF(outbuf, MC_CMD_GET_LINK_OUT_LEN);
         int rc;
-
-        ecmd->supported =
-                mcdi_to_ethtool_cap(phy_cfg->media, phy_cfg->supported_cap);
-        ecmd->advertising = efx->link_advertising;
-        ethtool_cmd_speed_set(ecmd, efx->link_state.speed);
-        ecmd->duplex = efx->link_state.fd;
-        ecmd->port = mcdi_to_ethtool_media(phy_cfg->media);
-        ecmd->phy_address = phy_cfg->port;
-        ecmd->transceiver = XCVR_INTERNAL;
-        ecmd->autoneg = !!(efx->link_advertising & ADVERTISED_Autoneg);
-        ecmd->mdio_support = (efx->mdio.mode_support &
+        u32 supported, advertising, lp_advertising;
+
+        supported = mcdi_to_ethtool_cap(phy_cfg->media, phy_cfg->supported_cap);
+        advertising = efx->link_advertising;
+        cmd->base.speed = efx->link_state.speed;
+        cmd->base.duplex = efx->link_state.fd;
+        cmd->base.port = mcdi_to_ethtool_media(phy_cfg->media);
+        cmd->base.phy_address = phy_cfg->port;
+        cmd->base.autoneg = !!(efx->link_advertising & ADVERTISED_Autoneg);
+        cmd->base.mdio_support = (efx->mdio.mode_support &
                               (MDIO_SUPPORTS_C45 | MDIO_SUPPORTS_C22));
 
+        ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
+                                                supported);
+        ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
+                                                advertising);
+
         BUILD_BUG_ON(MC_CMD_GET_LINK_IN_LEN != 0);
         rc = efx_mcdi_rpc(efx, MC_CMD_GET_LINK, NULL, 0,
                           outbuf, sizeof(outbuf), NULL);
         if (rc)
                 return;
-        ecmd->lp_advertising =
+        lp_advertising =
                 mcdi_to_ethtool_cap(phy_cfg->media,
                                     MCDI_DWORD(outbuf, GET_LINK_OUT_LP_CAP));
+
+        ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.lp_advertising,
+                                                lp_advertising);
 }
 
-static int efx_mcdi_phy_set_settings(struct efx_nic *efx, struct ethtool_cmd *ecmd)
+static int
+efx_mcdi_phy_set_link_ksettings(struct efx_nic *efx,
+                                const struct ethtool_link_ksettings *cmd)
 {
         struct efx_mcdi_phy_data *phy_cfg = efx->phy_data;
         u32 caps;
         int rc;
+        u32 advertising;
+
+        ethtool_convert_link_mode_to_legacy_u32(&advertising,
+                                                cmd->link_modes.advertising);
 
-        if (ecmd->autoneg) {
-                caps = (ethtool_to_mcdi_cap(ecmd->advertising) |
+        if (cmd->base.autoneg) {
+                caps = (ethtool_to_mcdi_cap(advertising) |
                          1 << MC_CMD_PHY_CAP_AN_LBN);
-        } else if (ecmd->duplex) {
-                switch (ethtool_cmd_speed(ecmd)) {
+        } else if (cmd->base.duplex) {
+                switch (cmd->base.speed) {
                 case 10:    caps = 1 << MC_CMD_PHY_CAP_10FDX_LBN;    break;
                 case 100:   caps = 1 << MC_CMD_PHY_CAP_100FDX_LBN;   break;
                 case 1000:  caps = 1 << MC_CMD_PHY_CAP_1000FDX_LBN;  break;
@@ -550,7 +564,7 @@ static int efx_mcdi_phy_set_settings(struct efx_nic *efx, struct ethtool_cmd *ec
                 default:    return -EINVAL;
                 }
         } else {
-                switch (ethtool_cmd_speed(ecmd)) {
+                switch (cmd->base.speed) {
                 case 10:    caps = 1 << MC_CMD_PHY_CAP_10HDX_LBN;    break;
                 case 100:   caps = 1 << MC_CMD_PHY_CAP_100HDX_LBN;   break;
                 case 1000:  caps = 1 << MC_CMD_PHY_CAP_1000HDX_LBN;  break;
@@ -563,9 +577,9 @@ static int efx_mcdi_phy_set_settings(struct efx_nic *efx, struct ethtool_cmd *ec
         if (rc)
                 return rc;
 
-        if (ecmd->autoneg) {
+        if (cmd->base.autoneg) {
                 efx_link_set_advertising(
-                        efx, ecmd->advertising | ADVERTISED_Autoneg);
+                        efx, advertising | ADVERTISED_Autoneg);
                 phy_cfg->forced_cap = 0;
         } else {
                 efx_link_set_advertising(efx, 0);
@@ -812,8 +826,8 @@ static const struct efx_phy_operations efx_mcdi_phy_ops = {
         .poll           = efx_mcdi_phy_poll,
         .fini           = efx_port_dummy_op_void,
         .remove         = efx_mcdi_phy_remove,
-        .get_settings   = efx_mcdi_phy_get_settings,
-        .set_settings   = efx_mcdi_phy_set_settings,
+        .get_link_ksettings = efx_mcdi_phy_get_link_ksettings,
+        .set_link_ksettings = efx_mcdi_phy_set_link_ksettings,
         .test_alive     = efx_mcdi_phy_test_alive,
         .run_tests      = efx_mcdi_phy_run_tests,
         .test_name      = efx_mcdi_phy_test_name,
diff --git a/drivers/net/ethernet/sfc/net_driver.h b/drivers/net/ethernet/sfc/net_driver.h
index 8692e829b40f..1a635ced62d0 100644
--- a/drivers/net/ethernet/sfc/net_driver.h
+++ b/drivers/net/ethernet/sfc/net_driver.h
@@ -720,8 +720,8 @@ static inline bool efx_link_state_equal(const struct efx_link_state *left,
  * @reconfigure: Reconfigure PHY (e.g. for new link parameters)
  * @poll: Update @link_state and report whether it changed.
  *      Serialised by the mac_lock.
- * @get_settings: Get ethtool settings. Serialised by the mac_lock.
- * @set_settings: Set ethtool settings. Serialised by the mac_lock.
+ * @get_link_ksettings: Get ethtool settings. Serialised by the mac_lock.
+ * @set_link_ksettings: Set ethtool settings. Serialised by the mac_lock.
  * @set_npage_adv: Set abilities advertised in (Extended) Next Page
  *      (only needed where AN bit is set in mmds)
  * @test_alive: Test that PHY is 'alive' (online)
@@ -736,10 +736,10 @@ struct efx_phy_operations {
         void (*remove) (struct efx_nic *efx);
         int (*reconfigure) (struct efx_nic *efx);
         bool (*poll) (struct efx_nic *efx);
-        void (*get_settings) (struct efx_nic *efx,
-                              struct ethtool_cmd *ecmd);
-        int (*set_settings) (struct efx_nic *efx,
-                             struct ethtool_cmd *ecmd);
+        void (*get_link_ksettings)(struct efx_nic *efx,
+                                   struct ethtool_link_ksettings *cmd);
+        int (*set_link_ksettings)(struct efx_nic *efx,
+                                  const struct ethtool_link_ksettings *cmd);
         void (*set_npage_adv) (struct efx_nic *efx, u32);
         int (*test_alive) (struct efx_nic *efx);
         const char *(*test_name) (struct efx_nic *efx, unsigned int index);
diff --git a/drivers/net/gtp.c b/drivers/net/gtp.c
index 98f10c216521..8b6810bad54b 100644
--- a/drivers/net/gtp.c
+++ b/drivers/net/gtp.c
@@ -158,9 +158,9 @@ static bool gtp_check_src_ms_ipv4(struct sk_buff *skb, struct pdp_ctx *pctx,
         if (!pskb_may_pull(skb, hdrlen + sizeof(struct iphdr)))
                 return false;
 
-        iph = (struct iphdr *)(skb->data + hdrlen + sizeof(struct iphdr));
+        iph = (struct iphdr *)(skb->data + hdrlen);
 
-        return iph->saddr != pctx->ms_addr_ip4.s_addr;
+        return iph->saddr == pctx->ms_addr_ip4.s_addr;
 }
 
 /* Check if the inner IP source address in this packet is assigned to any
@@ -423,11 +423,11 @@ static inline void gtp1_push_header(struct sk_buff *skb, struct pdp_ctx *pctx)
 
         /* Bits    8  7  6  5  4  3  2  1
          *        +--+--+--+--+--+--+--+--+
-         *        |version |PT| 1| E| S|PN|
+         *        |version |PT| 0| E| S|PN|
          *        +--+--+--+--+--+--+--+--+
          *          0  0  1  1  1  0  0  0
          */
-        gtp1->flags     = 0x38; /* v1, GTP-non-prime. */
+        gtp1->flags     = 0x30; /* v1, GTP-non-prime. */
         gtp1->type      = GTP_TPDU;
         gtp1->length    = htons(payload_len);
         gtp1->tid       = htonl(pctx->u.v1.o_tei);
diff --git a/drivers/net/irda/w83977af_ir.c b/drivers/net/irda/w83977af_ir.c
index f293d33fb28f..8d5b903d1d9d 100644
--- a/drivers/net/irda/w83977af_ir.c
+++ b/drivers/net/irda/w83977af_ir.c
@@ -517,9 +517,9 @@ static netdev_tx_t w83977af_hard_xmit(struct sk_buff *skb,
 
                 mtt = irda_get_mtt(skb);
                 pr_debug("%s: %ld, mtt=%d\n", __func__, jiffies, mtt);
-                        if (mtt > 1000)
-                                mdelay(mtt / 1000);
-                        else if (mtt)
+                if (mtt > 1000)
+                        mdelay(mtt / 1000);
+                else if (mtt)
                         udelay(mtt);
 
                 /* Enable DMA interrupt */
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index b425fa1013af..08327e005ccc 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -22,6 +22,7 @@
 #include <linux/module.h>
 #include <linux/virtio.h>
 #include <linux/virtio_net.h>
+#include <linux/bpf.h>
 #include <linux/scatterlist.h>
 #include <linux/if_vlan.h>
 #include <linux/slab.h>
@@ -81,6 +82,8 @@ struct receive_queue {
 
         struct napi_struct napi;
 
+        struct bpf_prog __rcu *xdp_prog;
+
         /* Chain pages by the private ptr. */
         struct page *pages;
 
@@ -111,6 +114,9 @@ struct virtnet_info {
         /* # of queue pairs currently used by the driver */
         u16 curr_queue_pairs;
 
+        /* # of XDP queue pairs currently used by the driver */
+        u16 xdp_queue_pairs;
+
         /* I like... big packets and I cannot lie! */
         bool big_packets;
 
@@ -324,6 +330,90 @@ static struct sk_buff *page_to_skb(struct virtnet_info *vi,
         return skb;
 }
 
+static void virtnet_xdp_xmit(struct virtnet_info *vi,
+                             struct receive_queue *rq,
+                             struct send_queue *sq,
+                             struct xdp_buff *xdp)
+{
+        struct page *page = virt_to_head_page(xdp->data);
+        struct virtio_net_hdr_mrg_rxbuf *hdr;
+        unsigned int num_sg, len;
+        void *xdp_sent;
+        int err;
+
+        /* Free up any pending old buffers before queueing new ones. */
+        while ((xdp_sent = virtqueue_get_buf(sq->vq, &len)) != NULL) {
+                struct page *sent_page = virt_to_head_page(xdp_sent);
+
+                if (vi->mergeable_rx_bufs)
+                        put_page(sent_page);
+                else
+                        give_pages(rq, sent_page);
+        }
+
+        /* Zero header and leave csum up to XDP layers */
+        hdr = xdp->data;
+        memset(hdr, 0, vi->hdr_len);
+
+        num_sg = 1;
+        sg_init_one(sq->sg, xdp->data, xdp->data_end - xdp->data);
+        err = virtqueue_add_outbuf(sq->vq, sq->sg, num_sg,
+                                   xdp->data, GFP_ATOMIC);
+        if (unlikely(err)) {
+                if (vi->mergeable_rx_bufs)
+                        put_page(page);
+                else
+                        give_pages(rq, page);
+                return; // On error abort to avoid unnecessary kick
+        } else if (!vi->mergeable_rx_bufs) {
+                /* If not mergeable bufs must be big packets so cleanup pages */
+                give_pages(rq, (struct page *)page->private);
+                page->private = 0;
+        }
+
+        virtqueue_kick(sq->vq);
+}
+
+static u32 do_xdp_prog(struct virtnet_info *vi,
+                       struct receive_queue *rq,
+                       struct bpf_prog *xdp_prog,
+                       struct page *page, int offset, int len)
+{
+        int hdr_padded_len;
+        struct xdp_buff xdp;
+        unsigned int qp;
+        u32 act;
+        u8 *buf;
+
+        buf = page_address(page) + offset;
+
+        if (vi->mergeable_rx_bufs)
+                hdr_padded_len = sizeof(struct virtio_net_hdr_mrg_rxbuf);
+        else
+                hdr_padded_len = sizeof(struct padded_vnet_hdr);
+
+        xdp.data = buf + hdr_padded_len;
+        xdp.data_end = xdp.data + (len - vi->hdr_len);
+
+        act = bpf_prog_run_xdp(xdp_prog, &xdp);
+        switch (act) {
+        case XDP_PASS:
+                return XDP_PASS;
+        case XDP_TX:
+                qp = vi->curr_queue_pairs -
+                        vi->xdp_queue_pairs +
+                        smp_processor_id();
+                xdp.data = buf + (vi->mergeable_rx_bufs ? 0 : 4);
+                virtnet_xdp_xmit(vi, rq, &vi->sq[qp], &xdp);
+                return XDP_TX;
+        default:
+                bpf_warn_invalid_xdp_action(act);
+        case XDP_ABORTED:
+        case XDP_DROP:
+                return XDP_DROP;
+        }
+}
+
 static struct sk_buff *receive_small(struct virtnet_info *vi, void *buf, unsigned int len)
 {
         struct sk_buff * skb = buf;
@@ -340,17 +430,102 @@ static struct sk_buff *receive_big(struct net_device *dev,
                                    void *buf,
                                    unsigned int len)
 {
+        struct bpf_prog *xdp_prog;
         struct page *page = buf;
-        struct sk_buff *skb = page_to_skb(vi, rq, page, 0, len, PAGE_SIZE);
+        struct sk_buff *skb;
 
+        rcu_read_lock();
+        xdp_prog = rcu_dereference(rq->xdp_prog);
+        if (xdp_prog) {
+                struct virtio_net_hdr_mrg_rxbuf *hdr = buf;
+                u32 act;
+
+                if (unlikely(hdr->hdr.gso_type || hdr->hdr.flags))
+                        goto err_xdp;
+                act = do_xdp_prog(vi, rq, xdp_prog, page, 0, len);
+                switch (act) {
+                case XDP_PASS:
+                        break;
+                case XDP_TX:
+                        rcu_read_unlock();
+                        goto xdp_xmit;
+                case XDP_DROP:
+                default:
+                        goto err_xdp;
+                }
+        }
+        rcu_read_unlock();
+
+        skb = page_to_skb(vi, rq, page, 0, len, PAGE_SIZE);
         if (unlikely(!skb))
                 goto err;
 
         return skb;
 
+err_xdp:
+        rcu_read_unlock();
 err:
         dev->stats.rx_dropped++;
         give_pages(rq, page);
+xdp_xmit:
+        return NULL;
+}
+
+/* The conditions to enable XDP should preclude the underlying device from
+ * sending packets across multiple buffers (num_buf > 1). However per spec
+ * it does not appear to be illegal to do so but rather just against convention.
+ * So in order to avoid making a system unresponsive the packets are pushed
+ * into a page and the XDP program is run. This will be extremely slow and we
+ * push a warning to the user to fix this as soon as possible. Fixing this may
+ * require resolving the underlying hardware to determine why multiple buffers
+ * are being received or simply loading the XDP program in the ingress stack
+ * after the skb is built because there is no advantage to running it here
+ * anymore.
+ */
+static struct page *xdp_linearize_page(struct receive_queue *rq,
+                                       u16 num_buf,
+                                       struct page *p,
+                                       int offset,
+                                       unsigned int *len)
+{
+        struct page *page = alloc_page(GFP_ATOMIC);
+        unsigned int page_off = 0;
+
+        if (!page)
+                return NULL;
+
+        memcpy(page_address(page) + page_off, page_address(p) + offset, *len);
+        page_off += *len;
+
+        while (--num_buf) {
+                unsigned int buflen;
+                unsigned long ctx;
+                void *buf;
+                int off;
+
+                ctx = (unsigned long)virtqueue_get_buf(rq->vq, &buflen);
+                if (unlikely(!ctx))
+                        goto err_buf;
+
+                /* guard against a misconfigured or uncooperative backend that
+                 * is sending packet larger than the MTU.
+                 */
+                if ((page_off + buflen) > PAGE_SIZE)
+                        goto err_buf;
+
+                buf = mergeable_ctx_to_buf_address(ctx);
+                p = virt_to_head_page(buf);
+                off = buf - page_address(p);
+
+                memcpy(page_address(page) + page_off,
+                       page_address(p) + off, buflen);
+                page_off += buflen;
+        }
+
+        *len = page_off;
+        return page;
+err_buf:
+        __free_pages(page, 0);
         return NULL;
 }
 
@@ -365,11 +540,67 @@ static struct sk_buff *receive_mergeable(struct net_device *dev,
         u16 num_buf = virtio16_to_cpu(vi->vdev, hdr->num_buffers);
         struct page *page = virt_to_head_page(buf);
         int offset = buf - page_address(page);
-        unsigned int truesize = max(len, mergeable_ctx_to_buf_truesize(ctx));
+        struct sk_buff *head_skb, *curr_skb;
+        struct bpf_prog *xdp_prog;
+        unsigned int truesize;
+
+        head_skb = NULL;
+
+        rcu_read_lock();
+        xdp_prog = rcu_dereference(rq->xdp_prog);
+        if (xdp_prog) {
+                struct page *xdp_page;
+                u32 act;
+
+                /* No known backend devices should send packets with
+                 * more than a single buffer when XDP conditions are
+                 * met. However it is not strictly illegal so the case
+                 * is handled as an exception and a warning is thrown.
+                 */
+                if (unlikely(num_buf > 1)) {
+                        bpf_warn_invalid_xdp_buffer();
+
+                        /* linearize data for XDP */
+                        xdp_page = xdp_linearize_page(rq, num_buf,
+                                                      page, offset, &len);
+                        if (!xdp_page)
+                                goto err_xdp;
+                        offset = 0;
+                } else {
+                        xdp_page = page;
+                }
+
+                /* Transient failure which in theory could occur if
+                 * in-flight packets from before XDP was enabled reach
+                 * the receive path after XDP is loaded. In practice I
+                 * was not able to create this condition.
+                 */
+                if (unlikely(hdr->hdr.gso_type || hdr->hdr.flags))
+                        goto err_xdp;
+
+                act = do_xdp_prog(vi, rq, xdp_prog, page, offset, len);
+                switch (act) {
+                case XDP_PASS:
+                        if (unlikely(xdp_page != page))
+                                __free_pages(xdp_page, 0);
+                        break;
+                case XDP_TX:
+                        if (unlikely(xdp_page != page))
+                                goto err_xdp;
+                        rcu_read_unlock();
+                        goto xdp_xmit;
+                case XDP_DROP:
+                default:
+                        if (unlikely(xdp_page != page))
+                                __free_pages(xdp_page, 0);
+                        goto err_xdp;
+                }
+        }
+        rcu_read_unlock();
 
-        struct sk_buff *head_skb = page_to_skb(vi, rq, page, offset, len,
-                                               truesize);
-        struct sk_buff *curr_skb = head_skb;
+        truesize = max(len, mergeable_ctx_to_buf_truesize(ctx));
+        head_skb = page_to_skb(vi, rq, page, offset, len, truesize);
+        curr_skb = head_skb;
 
         if (unlikely(!curr_skb))
                 goto err_skb;
@@ -423,6 +654,8 @@ static struct sk_buff *receive_mergeable(struct net_device *dev,
         ewma_pkt_len_add(&rq->mrg_avg_pkt_len, head_skb->len);
         return head_skb;
 
+err_xdp:
+        rcu_read_unlock();
 err_skb:
         put_page(page);
         while (--num_buf) {
@@ -439,6 +672,7 @@ err_skb:
 err_buf:
         dev->stats.rx_dropped++;
         dev_kfree_skb(head_skb);
+xdp_xmit:
         return NULL;
 }
 
@@ -1337,6 +1571,13 @@ static int virtnet_set_channels(struct net_device *dev,
         if (queue_pairs > vi->max_queue_pairs || queue_pairs == 0)
                 return -EINVAL;
 
+        /* For now we don't support modifying channels while XDP is loaded
+         * also when XDP is loaded all RX queues have XDP programs so we only
+         * need to check a single RX queue.
+         */
+        if (vi->rq[0].xdp_prog)
+                return -EINVAL;
+
         get_online_cpus();
         err = virtnet_set_queues(vi, queue_pairs);
         if (!err) {
@@ -1428,6 +1669,93 @@ static const struct ethtool_ops virtnet_ethtool_ops = {
         .set_settings = virtnet_set_settings,
 };
 
+static int virtnet_xdp_set(struct net_device *dev, struct bpf_prog *prog)
+{
+        unsigned long int max_sz = PAGE_SIZE - sizeof(struct padded_vnet_hdr);
+        struct virtnet_info *vi = netdev_priv(dev);
+        struct bpf_prog *old_prog;
+        u16 xdp_qp = 0, curr_qp;
+        int i, err;
+
+        if (virtio_has_feature(vi->vdev, VIRTIO_NET_F_GUEST_TSO4) ||
+            virtio_has_feature(vi->vdev, VIRTIO_NET_F_GUEST_TSO6)) {
+                netdev_warn(dev, "can't set XDP while host is implementing LRO, disable LRO first\n");
+                return -EOPNOTSUPP;
+        }
+
+        if (vi->mergeable_rx_bufs && !vi->any_header_sg) {
+                netdev_warn(dev, "XDP expects header/data in single page, any_header_sg required\n");
+                return -EINVAL;
+        }
+
+        if (dev->mtu > max_sz) {
+                netdev_warn(dev, "XDP requires MTU less than %lu\n", max_sz);
+                return -EINVAL;
+        }
+
+        curr_qp = vi->curr_queue_pairs - vi->xdp_queue_pairs;
+        if (prog)
+                xdp_qp = nr_cpu_ids;
+
+        /* XDP requires extra queues for XDP_TX */
+        if (curr_qp + xdp_qp > vi->max_queue_pairs) {
+                netdev_warn(dev, "request %i queues but max is %i\n",
+                            curr_qp + xdp_qp, vi->max_queue_pairs);
+                return -ENOMEM;
+        }
+
+        err = virtnet_set_queues(vi, curr_qp + xdp_qp);
+        if (err) {
+                dev_warn(&dev->dev, "XDP Device queue allocation failure.\n");
+                return err;
+        }
+
+        if (prog) {
+                prog = bpf_prog_add(prog, vi->max_queue_pairs - 1);
+                if (IS_ERR(prog)) {
+                        virtnet_set_queues(vi, curr_qp);
+                        return PTR_ERR(prog);
+                }
+        }
+
+        vi->xdp_queue_pairs = xdp_qp;
+        netif_set_real_num_rx_queues(dev, curr_qp + xdp_qp);
+
+        for (i = 0; i < vi->max_queue_pairs; i++) {
+                old_prog = rtnl_dereference(vi->rq[i].xdp_prog);
+                rcu_assign_pointer(vi->rq[i].xdp_prog, prog);
+                if (old_prog)
+                        bpf_prog_put(old_prog);
+        }
+
+        return 0;
+}
+
+static bool virtnet_xdp_query(struct net_device *dev)
+{
+        struct virtnet_info *vi = netdev_priv(dev);
+        int i;
+
+        for (i = 0; i < vi->max_queue_pairs; i++) {
+                if (vi->rq[i].xdp_prog)
+                        return true;
+        }
+        return false;
+}
+
+static int virtnet_xdp(struct net_device *dev, struct netdev_xdp *xdp)
+{
+        switch (xdp->command) {
+        case XDP_SETUP_PROG:
+                return virtnet_xdp_set(dev, xdp->prog);
+        case XDP_QUERY_PROG:
+                xdp->prog_attached = virtnet_xdp_query(dev);
+                return 0;
+        default:
+                return -EINVAL;
+        }
+}
+
 static const struct net_device_ops virtnet_netdev = {
         .ndo_open            = virtnet_open,
         .ndo_stop            = virtnet_close,
@@ -1444,6 +1772,7 @@ static const struct net_device_ops virtnet_netdev = {
 #ifdef CONFIG_NET_RX_BUSY_POLL
         .ndo_busy_poll          = virtnet_busy_poll,
 #endif
+        .ndo_xdp                = virtnet_xdp,
 };
 
 static void virtnet_config_changed_work(struct work_struct *work)
@@ -1505,12 +1834,20 @@ static void virtnet_free_queues(struct virtnet_info *vi)
 
 static void free_receive_bufs(struct virtnet_info *vi)
 {
+        struct bpf_prog *old_prog;
         int i;
 
+        rtnl_lock();
         for (i = 0; i < vi->max_queue_pairs; i++) {
                 while (vi->rq[i].pages)
                         __free_pages(get_a_page(&vi->rq[i], GFP_KERNEL), 0);
+
+                old_prog = rtnl_dereference(vi->rq[i].xdp_prog);
+                RCU_INIT_POINTER(vi->rq[i].xdp_prog, NULL);
+                if (old_prog)
+                        bpf_prog_put(old_prog);
         }
+        rtnl_unlock();
 }
 
 static void free_receive_page_frags(struct virtnet_info *vi)
@@ -1521,6 +1858,16 @@ static void free_receive_page_frags(struct virtnet_info *vi)
                         put_page(vi->rq[i].alloc_frag.page);
 }
 
+static bool is_xdp_queue(struct virtnet_info *vi, int q)
+{
+        if (q < (vi->curr_queue_pairs - vi->xdp_queue_pairs))
+                return false;
+        else if (q < vi->curr_queue_pairs)
+                return true;
+        else
+                return false;
+}
+
 static void free_unused_bufs(struct virtnet_info *vi)
 {
         void *buf;
@@ -1528,8 +1875,12 @@ static void free_unused_bufs(struct virtnet_info *vi)
 
         for (i = 0; i < vi->max_queue_pairs; i++) {
                 struct virtqueue *vq = vi->sq[i].vq;
-                while ((buf = virtqueue_detach_unused_buf(vq)) != NULL)
-                        dev_kfree_skb(buf);
+                while ((buf = virtqueue_detach_unused_buf(vq)) != NULL) {
+                        if (!is_xdp_queue(vi, i))
+                                dev_kfree_skb(buf);
+                        else
+                                put_page(virt_to_head_page(buf));
+                }
         }
 
         for (i = 0; i < vi->max_queue_pairs; i++) {
@@ -1930,7 +2281,9 @@ static int virtnet_probe(struct virtio_device *vdev)
                 goto free_unregister_netdev;
         }
 
-        virtnet_set_affinity(vi);
+        rtnl_lock();
+        virtnet_set_queues(vi, vi->curr_queue_pairs);
+        rtnl_unlock();
 
         /* Assume link up if device can't report link status,
            otherwise get link status from config. */
diff --git a/drivers/net/vrf.c b/drivers/net/vrf.c
index 3bca24651dc0..7532646c3b7b 100644
--- a/drivers/net/vrf.c
+++ b/drivers/net/vrf.c
@@ -366,6 +366,8 @@ static int vrf_finish_output6(struct net *net, struct sock *sk,
         struct in6_addr *nexthop;
         int ret;
 
+        nf_reset(skb);
+
         skb->protocol = htons(ETH_P_IPV6);
         skb->dev = dev;
 
@@ -547,6 +549,8 @@ static int vrf_finish_output(struct net *net, struct sock *sk, struct sk_buff *s
         u32 nexthop;
         int ret = -EINVAL;
 
+        nf_reset(skb);
+
         /* Be paranoid, rather than too clever. */
         if (unlikely(skb_headroom(skb) < hh_len && dev->header_ops)) {
                 struct sk_buff *skb2;
@@ -849,8 +853,6 @@ static struct sk_buff *vrf_rcv_nfhook(u8 pf, unsigned int hook,
 {
         struct net *net = dev_net(dev);
 
-        nf_reset(skb);
-
         if (NF_HOOK(pf, hook, net, NULL, skb, dev, NULL, vrf_rcv_finish) < 0)
                 skb = NULL;    /* kfree_skb(skb) handled by nf code */
 
diff --git a/drivers/net/wan/lmc/lmc_media.c b/drivers/net/wan/lmc/lmc_media.c
index 5920c996fcdf..ff2e4a5654c7 100644
--- a/drivers/net/wan/lmc/lmc_media.c
+++ b/drivers/net/wan/lmc/lmc_media.c
@@ -95,62 +95,63 @@ static inline void write_av9110_bit (lmc_softc_t *, int);
 static void write_av9110(lmc_softc_t *, u32, u32, u32, u32, u32);
 
 lmc_media_t lmc_ds3_media = {
-  lmc_ds3_init,                 /* special media init stuff */
-  lmc_ds3_default,              /* reset to default state */
-  lmc_ds3_set_status,           /* reset status to state provided */
-  lmc_dummy_set_1,              /* set clock source */
-  lmc_dummy_set2_1,             /* set line speed */
-  lmc_ds3_set_100ft,            /* set cable length */
-  lmc_ds3_set_scram,            /* set scrambler */
-  lmc_ds3_get_link_status,      /* get link status */
-  lmc_dummy_set_1,              /* set link status */
-  lmc_ds3_set_crc_length,       /* set CRC length */
-  lmc_dummy_set_1,              /* set T1 or E1 circuit type */
-  lmc_ds3_watchdog
+  .init = lmc_ds3_init,                         /* special media init stuff */
+  .defaults = lmc_ds3_default,                  /* reset to default state */
+  .set_status = lmc_ds3_set_status,             /* reset status to state provided */
+  .set_clock_source = lmc_dummy_set_1,          /* set clock source */
+  .set_speed = lmc_dummy_set2_1,                /* set line speed */
+  .set_cable_length = lmc_ds3_set_100ft,        /* set cable length */
+  .set_scrambler = lmc_ds3_set_scram,           /* set scrambler */
+  .get_link_status = lmc_ds3_get_link_status,   /* get link status */
+  .set_link_status = lmc_dummy_set_1,           /* set link status */
+  .set_crc_length = lmc_ds3_set_crc_length,     /* set CRC length */
+  .set_circuit_type = lmc_dummy_set_1,          /* set T1 or E1 circuit type */
+  .watchdog = lmc_ds3_watchdog
 };
 
 lmc_media_t lmc_hssi_media = {
-  lmc_hssi_init,                /* special media init stuff */
-  lmc_hssi_default,             /* reset to default state */
-  lmc_hssi_set_status,          /* reset status to state provided */
-  lmc_hssi_set_clock,           /* set clock source */
-  lmc_dummy_set2_1,             /* set line speed */
-  lmc_dummy_set_1,              /* set cable length */
-  lmc_dummy_set_1,              /* set scrambler */
-  lmc_hssi_get_link_status,     /* get link status */
-  lmc_hssi_set_link_status,     /* set link status */
-  lmc_hssi_set_crc_length,      /* set CRC length */
-  lmc_dummy_set_1,              /* set T1 or E1 circuit type */
-  lmc_hssi_watchdog
+  .init = lmc_hssi_init,                        /* special media init stuff */
+  .defaults = lmc_hssi_default,                 /* reset to default state */
+  .set_status = lmc_hssi_set_status,            /* reset status to state provided */
+  .set_clock_source = lmc_hssi_set_clock,       /* set clock source */
+  .set_speed = lmc_dummy_set2_1,                /* set line speed */
+  .set_cable_length = lmc_dummy_set_1,          /* set cable length */
+  .set_scrambler = lmc_dummy_set_1,             /* set scrambler */
+  .get_link_status = lmc_hssi_get_link_status,  /* get link status */
+  .set_link_status = lmc_hssi_set_link_status,  /* set link status */
+  .set_crc_length = lmc_hssi_set_crc_length,    /* set CRC length */
+  .set_circuit_type = lmc_dummy_set_1,          /* set T1 or E1 circuit type */
+  .watchdog = lmc_hssi_watchdog
 };
 
-lmc_media_t lmc_ssi_media = { lmc_ssi_init,     /* special media init stuff */
-  lmc_ssi_default,              /* reset to default state */
-  lmc_ssi_set_status,           /* reset status to state provided */
-  lmc_ssi_set_clock,            /* set clock source */
-  lmc_ssi_set_speed,            /* set line speed */
-  lmc_dummy_set_1,              /* set cable length */
-  lmc_dummy_set_1,              /* set scrambler */
-  lmc_ssi_get_link_status,      /* get link status */
-  lmc_ssi_set_link_status,      /* set link status */
-  lmc_ssi_set_crc_length,       /* set CRC length */
-  lmc_dummy_set_1,              /* set T1 or E1 circuit type */
-  lmc_ssi_watchdog
+lmc_media_t lmc_ssi_media = {
+  .init = lmc_ssi_init,                         /* special media init stuff */
+  .defaults = lmc_ssi_default,                  /* reset to default state */
+  .set_status = lmc_ssi_set_status,             /* reset status to state provided */
+  .set_clock_source = lmc_ssi_set_clock,        /* set clock source */
+  .set_speed = lmc_ssi_set_speed,               /* set line speed */
+  .set_cable_length = lmc_dummy_set_1,          /* set cable length */
+  .set_scrambler = lmc_dummy_set_1,             /* set scrambler */
+  .get_link_status = lmc_ssi_get_link_status,   /* get link status */
+  .set_link_status = lmc_ssi_set_link_status,   /* set link status */
+  .set_crc_length = lmc_ssi_set_crc_length,     /* set CRC length */
+  .set_circuit_type = lmc_dummy_set_1,          /* set T1 or E1 circuit type */
+  .watchdog = lmc_ssi_watchdog
 };
 
 lmc_media_t lmc_t1_media = {
-  lmc_t1_init,                  /* special media init stuff */
-  lmc_t1_default,               /* reset to default state */
-  lmc_t1_set_status,            /* reset status to state provided */
-  lmc_t1_set_clock,             /* set clock source */
-  lmc_dummy_set2_1,             /* set line speed */
-  lmc_dummy_set_1,              /* set cable length */
-  lmc_dummy_set_1,              /* set scrambler */
-  lmc_t1_get_link_status,       /* get link status */
-  lmc_dummy_set_1,              /* set link status */
-  lmc_t1_set_crc_length,        /* set CRC length */
-  lmc_t1_set_circuit_type,      /* set T1 or E1 circuit type */
-  lmc_t1_watchdog
+  .init = lmc_t1_init,                          /* special media init stuff */
+  .defaults = lmc_t1_default,                   /* reset to default state */
+  .set_status = lmc_t1_set_status,              /* reset status to state provided */
+  .set_clock_source = lmc_t1_set_clock,         /* set clock source */
+  .set_speed = lmc_dummy_set2_1,                /* set line speed */
+  .set_cable_length = lmc_dummy_set_1,          /* set cable length */
+  .set_scrambler = lmc_dummy_set_1,             /* set scrambler */
+  .get_link_status = lmc_t1_get_link_status,    /* get link status */
+  .set_link_status = lmc_dummy_set_1,           /* set link status */
+  .set_crc_length = lmc_t1_set_crc_length,      /* set CRC length */
+  .set_circuit_type = lmc_t1_set_circuit_type,  /* set T1 or E1 circuit type */
+  .watchdog = lmc_t1_watchdog
 };
 
 static void