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
  ...

25 files changed, 450 insertions, 181 deletions

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);