138 files changed, 6012 insertions, 3279 deletions

diff --git a/Documentation/devicetree/bindings/net/dsa/dsa.txt b/Documentation/devicetree/bindings/net/dsa/dsa.txt
index a62c889aafca..e124847443f8 100644
--- a/Documentation/devicetree/bindings/net/dsa/dsa.txt
+++ b/Documentation/devicetree/bindings/net/dsa/dsa.txt
@@ -10,7 +10,7 @@ Required properties:
 - dsa,ethernet          : Should be a phandle to a valid Ethernet device node
 - dsa,mii-bus           : Should be a phandle to a valid MDIO bus device node
 
-Optionnal properties:
+Optional properties:
 - interrupts            : property with a value describing the switch
                           interrupt number (not supported by the driver)
 
@@ -23,6 +23,13 @@ Each of these switch child nodes should have the following required properties:
 - #address-cells        : Must be 1
 - #size-cells           : Must be 0
 
+A switch child node has the following optional property:
+
+- eeprom-length         : Set to the length of an EEPROM connected to the
+                          switch. Must be set if the switch can not detect
+                          the presence and/or size of a connected EEPROM,
+                          otherwise optional.
+
 A switch may have multiple "port" children nodes
 
 Each port children node must have the following mandatory properties:
diff --git a/Documentation/networking/bonding.txt b/Documentation/networking/bonding.txt
index eeb5b2e97bed..83bf4986baea 100644
--- a/Documentation/networking/bonding.txt
+++ b/Documentation/networking/bonding.txt
@@ -2230,11 +2230,8 @@ balance-rr: This mode is the only mode that will permit a single
 
         It is possible to adjust TCP/IP's congestion limits by
         altering the net.ipv4.tcp_reordering sysctl parameter.  The
-        usual default value is 3, and the maximum useful value is 127.
-        For a four interface balance-rr bond, expect that a single
-        TCP/IP stream will utilize no more than approximately 2.3
-        interface's worth of throughput, even after adjusting
-        tcp_reordering.
+        usual default value is 3. But keep in mind TCP stack is able
+        to automatically increase this when it detects reorders.
 
         Note that the fraction of packets that will be delivered out of
         order is highly variable, and is unlikely to be zero.  The level
diff --git a/Documentation/networking/ip-sysctl.txt b/Documentation/networking/ip-sysctl.txt
index 0307e2875f21..368e3251c553 100644
--- a/Documentation/networking/ip-sysctl.txt
+++ b/Documentation/networking/ip-sysctl.txt
@@ -376,9 +376,17 @@ tcp_orphan_retries - INTEGER
         may consume significant resources. Cf. tcp_max_orphans.
 
 tcp_reordering - INTEGER
-        Maximal reordering of packets in a TCP stream.
+        Initial reordering level of packets in a TCP stream.
+        TCP stack can then dynamically adjust flow reordering level
+        between this initial value and tcp_max_reordering
         Default: 3
 
+tcp_max_reordering - INTEGER
+        Maximal reordering level of packets in a TCP stream.
+        300 is a fairly conservative value, but you might increase it
+        if paths are using per packet load balancing (like bonding rr mode)
+        Default: 300
+
 tcp_retrans_collapse - BOOLEAN
         Bug-to-bug compatibility with some broken printers.
         On retransmit try to send bigger packets to work around bugs in
@@ -1452,6 +1460,19 @@ suppress_frag_ndisc - INTEGER
         1 - (default) discard fragmented neighbor discovery packets
         0 - allow fragmented neighbor discovery packets
 
+optimistic_dad - BOOLEAN
+        Whether to perform Optimistic Duplicate Address Detection (RFC 4429).
+                0: disabled (default)
+                1: enabled
+
+use_optimistic - BOOLEAN
+        If enabled, do not classify optimistic addresses as deprecated during
+        source address selection.  Preferred addresses will still be chosen
+        before optimistic addresses, subject to other ranking in the source
+        address selection algorithm.
+                0: disabled (default)
+                1: enabled
+
 icmp/*:
 ratelimit - INTEGER
         Limit the maximal rates for sending ICMPv6 packets.
diff --git a/MAINTAINERS b/MAINTAINERS
index 1cfabdd1d23f..3a41fb0db2bd 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -5860,6 +5860,11 @@ M:	Russell King <rmk+kernel@arm.linux.org.uk>
 S:      Maintained
 F:      drivers/gpu/drm/armada/
 
+MARVELL 88E6352 DSA support
+M:      Guenter Roeck <linux@roeck-us.net>
+S:      Maintained
+F:      drivers/net/dsa/mv88e6352.c
+
 MARVELL GIGABIT ETHERNET DRIVERS (skge/sky2)
 M:      Mirko Lindner <mlindner@marvell.com>
 M:      Stephen Hemminger <stephen@networkplumber.org>
diff --git a/arch/arm/mach-mmp/gplugd.c b/arch/arm/mach-mmp/gplugd.c
index d81b2475e67e..22762a1f9f72 100644
--- a/arch/arm/mach-mmp/gplugd.c
+++ b/arch/arm/mach-mmp/gplugd.c
@@ -158,6 +158,7 @@ struct pxa168_eth_platform_data gplugd_eth_platform_data = {
         .port_number = 0,
         .phy_addr    = 0,
         .speed       = 0, /* Autonagotiation */
+        .intf        = PHY_INTERFACE_MODE_RMII,
         .init        = gplugd_eth_init,
 };
 
diff --git a/drivers/net/bonding/bond_alb.c b/drivers/net/bonding/bond_alb.c
index d2eadab787c5..baa58e79256a 100644
--- a/drivers/net/bonding/bond_alb.c
+++ b/drivers/net/bonding/bond_alb.c
@@ -1326,7 +1326,7 @@ static int bond_do_alb_xmit(struct sk_buff *skb, struct bonding *bond,
         }
 
         /* no suitable interface, frame not sent */
-        dev_kfree_skb_any(skb);
+        bond_tx_drop(bond->dev, skb);
 out:
         return NETDEV_TX_OK;
 }
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index c9ac06cfe6b7..c7520082fb0d 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -3522,7 +3522,7 @@ static void bond_xmit_slave_id(struct bonding *bond, struct sk_buff *skb, int sl
                 }
         }
         /* no slave that can tx has been found */
-        dev_kfree_skb_any(skb);
+        bond_tx_drop(bond->dev, skb);
 }
 
 /**
@@ -3584,7 +3584,7 @@ static int bond_xmit_roundrobin(struct sk_buff *skb, struct net_device *bond_dev
                         slave_id = bond_rr_gen_slave_id(bond);
                         bond_xmit_slave_id(bond, skb, slave_id % slave_cnt);
                 } else {
-                        dev_kfree_skb_any(skb);
+                        bond_tx_drop(bond_dev, skb);
                 }
         }
 
@@ -3603,7 +3603,7 @@ static int bond_xmit_activebackup(struct sk_buff *skb, struct net_device *bond_d
         if (slave)
                 bond_dev_queue_xmit(bond, skb, slave->dev);
         else
-                dev_kfree_skb_any(skb);
+                bond_tx_drop(bond_dev, skb);
 
         return NETDEV_TX_OK;
 }
@@ -3747,8 +3747,7 @@ int bond_3ad_xor_xmit(struct sk_buff *skb, struct net_device *dev)
                 slave = slaves->arr[bond_xmit_hash(bond, skb) % count];
                 bond_dev_queue_xmit(bond, skb, slave->dev);
         } else {
-                dev_kfree_skb_any(skb);
-                atomic_long_inc(&dev->tx_dropped);
+                bond_tx_drop(dev, skb);
         }
 
         return NETDEV_TX_OK;
@@ -3778,7 +3777,7 @@ static int bond_xmit_broadcast(struct sk_buff *skb, struct net_device *bond_dev)
         if (slave && bond_slave_is_up(slave) && slave->link == BOND_LINK_UP)
                 bond_dev_queue_xmit(bond, skb, slave->dev);
         else
-                dev_kfree_skb_any(skb);
+                bond_tx_drop(bond_dev, skb);
 
         return NETDEV_TX_OK;
 }
@@ -3858,7 +3857,7 @@ static netdev_tx_t __bond_start_xmit(struct sk_buff *skb, struct net_device *dev
                 /* Should never happen, mode already checked */
                 netdev_err(dev, "Unknown bonding mode %d\n", BOND_MODE(bond));
                 WARN_ON_ONCE(1);
-                dev_kfree_skb_any(skb);
+                bond_tx_drop(dev, skb);
                 return NETDEV_TX_OK;
         }
 }
@@ -3878,7 +3877,7 @@ static netdev_tx_t bond_start_xmit(struct sk_buff *skb, struct net_device *dev)
         if (bond_has_slaves(bond))
                 ret = __bond_start_xmit(skb, dev);
         else
-                dev_kfree_skb_any(skb);
+                bond_tx_drop(dev, skb);
         rcu_read_unlock();
 
         return ret;
diff --git a/drivers/net/bonding/bonding.h b/drivers/net/bonding/bonding.h
index 10920f0686e2..bfb0b51c081a 100644
--- a/drivers/net/bonding/bonding.h
+++ b/drivers/net/bonding/bonding.h
@@ -645,4 +645,10 @@ extern struct bond_parm_tbl ad_select_tbl[];
 /* exported from bond_netlink.c */
 extern struct rtnl_link_ops bond_link_ops;
 
+static inline void bond_tx_drop(struct net_device *dev, struct sk_buff *skb)
+{
+        atomic_long_inc(&dev->tx_dropped);
+        dev_kfree_skb_any(skb);
+}
+
 #endif /* _LINUX_BONDING_H */
diff --git a/drivers/net/dsa/Kconfig b/drivers/net/dsa/Kconfig
index 9234d808cbb3..2d1a55e980da 100644
--- a/drivers/net/dsa/Kconfig
+++ b/drivers/net/dsa/Kconfig
@@ -45,6 +45,15 @@ config NET_DSA_MV88E6171
           This enables support for the Marvell 88E6171 ethernet switch
           chip.
 
+config NET_DSA_MV88E6352
+        tristate "Marvell 88E6176/88E6352 ethernet switch chip support"
+        select NET_DSA
+        select NET_DSA_MV88E6XXX
+        select NET_DSA_TAG_EDSA
+        ---help---
+          This enables support for the Marvell 88E6176 and 88E6352 ethernet
+          switch chips.
+
 config NET_DSA_BCM_SF2
         tristate "Broadcom Starfighter 2 Ethernet switch support"
         depends on HAS_IOMEM
diff --git a/drivers/net/dsa/Makefile b/drivers/net/dsa/Makefile
index 23a90de9830e..e2d51c4b9382 100644
--- a/drivers/net/dsa/Makefile
+++ b/drivers/net/dsa/Makefile
@@ -7,6 +7,9 @@ endif
 ifdef CONFIG_NET_DSA_MV88E6131
 mv88e6xxx_drv-y += mv88e6131.o
 endif
+ifdef CONFIG_NET_DSA_MV88E6352
+mv88e6xxx_drv-y += mv88e6352.o
+endif
 ifdef CONFIG_NET_DSA_MV88E6171
 mv88e6xxx_drv-y += mv88e6171.o
 endif
diff --git a/drivers/net/dsa/mv88e6060.c b/drivers/net/dsa/mv88e6060.c
index 05b0ca3bf71d..c29aebe1e62b 100644
--- a/drivers/net/dsa/mv88e6060.c
+++ b/drivers/net/dsa/mv88e6060.c
@@ -69,8 +69,11 @@ static char *mv88e6060_probe(struct device *host_dev, int sw_addr)
 
         ret = mdiobus_read(bus, sw_addr + REG_PORT(0), 0x03);
         if (ret >= 0) {
-                ret &= 0xfff0;
                 if (ret == 0x0600)
+                        return "Marvell 88E6060 (A0)";
+                if (ret == 0x0601 || ret == 0x0602)
+                        return "Marvell 88E6060 (B0)";
+                if ((ret & 0xfff0) == 0x0600)
                         return "Marvell 88E6060";
         }
 
diff --git a/drivers/net/dsa/mv88e6123_61_65.c b/drivers/net/dsa/mv88e6123_61_65.c
index a332c53ff955..9a3f9e0b0532 100644
--- a/drivers/net/dsa/mv88e6123_61_65.c
+++ b/drivers/net/dsa/mv88e6123_61_65.c
@@ -291,6 +291,54 @@ static int mv88e6123_61_65_setup_port(struct dsa_switch *ds, int p)
         return 0;
 }
 
+#ifdef CONFIG_NET_DSA_HWMON
+
+static int  mv88e6123_61_65_get_temp(struct dsa_switch *ds, int *temp)
+{
+        struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
+        int ret;
+        int val;
+
+        *temp = 0;
+
+        mutex_lock(&ps->phy_mutex);
+
+        ret = mv88e6xxx_phy_write(ds, 0x0, 0x16, 0x6);
+        if (ret < 0)
+                goto error;
+
+        /* Enable temperature sensor */
+        ret = mv88e6xxx_phy_read(ds, 0x0, 0x1a);
+        if (ret < 0)
+                goto error;
+
+        ret = mv88e6xxx_phy_write(ds, 0x0, 0x1a, ret | (1 << 5));
+        if (ret < 0)
+                goto error;
+
+        /* Wait for temperature to stabilize */
+        usleep_range(10000, 12000);
+
+        val = mv88e6xxx_phy_read(ds, 0x0, 0x1a);
+        if (val < 0) {
+                ret = val;
+                goto error;
+        }
+
+        /* Disable temperature sensor */
+        ret = mv88e6xxx_phy_write(ds, 0x0, 0x1a, ret & ~(1 << 5));
+        if (ret < 0)
+                goto error;
+
+        *temp = ((val & 0x1f) - 5) * 5;
+
+error:
+        mv88e6xxx_phy_write(ds, 0x0, 0x16, 0x0);
+        mutex_unlock(&ps->phy_mutex);
+        return ret;
+}
+#endif /* CONFIG_NET_DSA_HWMON */
+
 static int mv88e6123_61_65_setup(struct dsa_switch *ds)
 {
         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
@@ -299,6 +347,7 @@ static int mv88e6123_61_65_setup(struct dsa_switch *ds)
 
         mutex_init(&ps->smi_mutex);
         mutex_init(&ps->stats_mutex);
+        mutex_init(&ps->phy_mutex);
 
         ret = mv88e6123_61_65_switch_reset(ds);
         if (ret < 0)
@@ -329,16 +378,28 @@ static int mv88e6123_61_65_port_to_phy_addr(int port)
 static int
 mv88e6123_61_65_phy_read(struct dsa_switch *ds, int port, int regnum)
 {
+        struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
         int addr = mv88e6123_61_65_port_to_phy_addr(port);
-        return mv88e6xxx_phy_read(ds, addr, regnum);
+        int ret;
+
+        mutex_lock(&ps->phy_mutex);
+        ret = mv88e6xxx_phy_read(ds, addr, regnum);
+        mutex_unlock(&ps->phy_mutex);
+        return ret;
 }
 
 static int
 mv88e6123_61_65_phy_write(struct dsa_switch *ds,
                               int port, int regnum, u16 val)
 {
+        struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
         int addr = mv88e6123_61_65_port_to_phy_addr(port);
-        return mv88e6xxx_phy_write(ds, addr, regnum, val);
+        int ret;
+
+        mutex_lock(&ps->phy_mutex);
+        ret = mv88e6xxx_phy_write(ds, addr, regnum, val);
+        mutex_unlock(&ps->phy_mutex);
+        return ret;
 }
 
 static struct mv88e6xxx_hw_stat mv88e6123_61_65_hw_stats[] = {
@@ -372,6 +433,9 @@ static struct mv88e6xxx_hw_stat mv88e6123_61_65_hw_stats[] = {
         { "hist_256_511bytes", 4, 0x0b, },
         { "hist_512_1023bytes", 4, 0x0c, },
         { "hist_1024_max_bytes", 4, 0x0d, },
+        { "sw_in_discards", 4, 0x110, },
+        { "sw_in_filtered", 2, 0x112, },
+        { "sw_out_filtered", 2, 0x113, },
 };
 
 static void
@@ -406,6 +470,11 @@ struct dsa_switch_driver mv88e6123_61_65_switch_driver = {
         .get_strings            = mv88e6123_61_65_get_strings,
         .get_ethtool_stats      = mv88e6123_61_65_get_ethtool_stats,
         .get_sset_count         = mv88e6123_61_65_get_sset_count,
+#ifdef CONFIG_NET_DSA_HWMON
+        .get_temp               = mv88e6123_61_65_get_temp,
+#endif
+        .get_regs_len           = mv88e6xxx_get_regs_len,
+        .get_regs               = mv88e6xxx_get_regs,
 };
 
 MODULE_ALIAS("platform:mv88e6123");
diff --git a/drivers/net/dsa/mv88e6131.c b/drivers/net/dsa/mv88e6131.c
index 244c735014fa..1230f52aa70e 100644
--- a/drivers/net/dsa/mv88e6131.c
+++ b/drivers/net/dsa/mv88e6131.c
@@ -21,6 +21,7 @@
 #define ID_6085         0x04a0
 #define ID_6095         0x0950
 #define ID_6131         0x1060
+#define ID_6131_B2      0x1066
 
 static char *mv88e6131_probe(struct device *host_dev, int sw_addr)
 {
@@ -32,12 +33,15 @@ static char *mv88e6131_probe(struct device *host_dev, int sw_addr)
 
         ret = __mv88e6xxx_reg_read(bus, sw_addr, REG_PORT(0), 0x03);
         if (ret >= 0) {
-                ret &= 0xfff0;
-                if (ret == ID_6085)
+                int ret_masked = ret & 0xfff0;
+
+                if (ret_masked == ID_6085)
                         return "Marvell 88E6085";
-                if (ret == ID_6095)
+                if (ret_masked == ID_6095)
                         return "Marvell 88E6095/88E6095F";
-                if (ret == ID_6131)
+                if (ret == ID_6131_B2)
+                        return "Marvell 88E6131 (B2)";
+                if (ret_masked == ID_6131)
                         return "Marvell 88E6131";
         }
 
diff --git a/drivers/net/dsa/mv88e6352.c b/drivers/net/dsa/mv88e6352.c
new file mode 100644
index 000000000000..258d9ef5ef25
--- /dev/null
+++ b/drivers/net/dsa/mv88e6352.c
@@ -0,0 +1,788 @@
+/*
+ * net/dsa/mv88e6352.c - Marvell 88e6352 switch chip support
+ *
+ * Copyright (c) 2014 Guenter Roeck
+ *
+ * Derived from mv88e6123_61_65.c
+ * Copyright (c) 2008-2009 Marvell Semiconductor
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/delay.h>
+#include <linux/jiffies.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/netdevice.h>
+#include <linux/platform_device.h>
+#include <linux/phy.h>
+#include <net/dsa.h>
+#include "mv88e6xxx.h"
+
+static int mv88e6352_wait(struct dsa_switch *ds, int reg, u16 mask)
+{
+        unsigned long timeout = jiffies + HZ / 10;
+
+        while (time_before(jiffies, timeout)) {
+                int ret;
+
+                ret = REG_READ(REG_GLOBAL2, reg);
+                if (ret < 0)
+                        return ret;
+
+                if (!(ret & mask))
+                        return 0;
+
+                usleep_range(1000, 2000);
+        }
+        return -ETIMEDOUT;
+}
+
+static inline int mv88e6352_phy_wait(struct dsa_switch *ds)
+{
+        return mv88e6352_wait(ds, 0x18, 0x8000);
+}
+
+static inline int mv88e6352_eeprom_load_wait(struct dsa_switch *ds)
+{
+        return mv88e6352_wait(ds, 0x14, 0x0800);
+}
+
+static inline int mv88e6352_eeprom_busy_wait(struct dsa_switch *ds)
+{
+        return mv88e6352_wait(ds, 0x14, 0x8000);
+}
+
+static int __mv88e6352_phy_read(struct dsa_switch *ds, int addr, int regnum)
+{
+        int ret;
+
+        REG_WRITE(REG_GLOBAL2, 0x18, 0x9800 | (addr << 5) | regnum);
+
+        ret = mv88e6352_phy_wait(ds);
+        if (ret < 0)
+                return ret;
+
+        return REG_READ(REG_GLOBAL2, 0x19);
+}
+
+static int __mv88e6352_phy_write(struct dsa_switch *ds, int addr, int regnum,
+                                 u16 val)
+{
+        REG_WRITE(REG_GLOBAL2, 0x19, val);
+        REG_WRITE(REG_GLOBAL2, 0x18, 0x9400 | (addr << 5) | regnum);
+
+        return mv88e6352_phy_wait(ds);
+}
+
+static char *mv88e6352_probe(struct device *host_dev, int sw_addr)
+{
+        struct mii_bus *bus = dsa_host_dev_to_mii_bus(host_dev);
+        int ret;
+
+        if (bus == NULL)
+                return NULL;
+
+        ret = __mv88e6xxx_reg_read(bus, sw_addr, REG_PORT(0), 0x03);
+        if (ret >= 0) {
+                if ((ret & 0xfff0) == 0x1760)
+                        return "Marvell 88E6176";
+                if (ret == 0x3521)
+                        return "Marvell 88E6352 (A0)";
+                if (ret == 0x3522)
+                        return "Marvell 88E6352 (A1)";
+                if ((ret & 0xfff0) == 0x3520)
+                        return "Marvell 88E6352";
+        }
+
+        return NULL;
+}
+
+static int mv88e6352_switch_reset(struct dsa_switch *ds)
+{
+        unsigned long timeout;
+        int ret;
+        int i;
+
+        /* Set all ports to the disabled state. */
+        for (i = 0; i < 7; i++) {
+                ret = REG_READ(REG_PORT(i), 0x04);
+                REG_WRITE(REG_PORT(i), 0x04, ret & 0xfffc);
+        }
+
+        /* Wait for transmit queues to drain. */
+        usleep_range(2000, 4000);
+
+        /* Reset the switch. Keep PPU active (bit 14, undocumented).
+         * The PPU needs to be active to support indirect phy register
+         * accesses through global registers 0x18 and 0x19.
+         */
+        REG_WRITE(REG_GLOBAL, 0x04, 0xc000);
+
+        /* Wait up to one second for reset to complete. */
+        timeout = jiffies + 1 * HZ;
+        while (time_before(jiffies, timeout)) {
+                ret = REG_READ(REG_GLOBAL, 0x00);
+                if ((ret & 0x8800) == 0x8800)
+                        break;
+                usleep_range(1000, 2000);
+        }
+        if (time_after(jiffies, timeout))
+                return -ETIMEDOUT;
+
+        return 0;
+}
+
+static int mv88e6352_setup_global(struct dsa_switch *ds)
+{
+        int ret;
+        int i;
+
+        /* Discard packets with excessive collisions,
+         * mask all interrupt sources, enable PPU (bit 14, undocumented).
+         */
+        REG_WRITE(REG_GLOBAL, 0x04, 0x6000);
+
+        /* Set the default address aging time to 5 minutes, and
+         * enable address learn messages to be sent to all message
+         * ports.
+         */
+        REG_WRITE(REG_GLOBAL, 0x0a, 0x0148);
+
+        /* Configure the priority mapping registers. */
+        ret = mv88e6xxx_config_prio(ds);
+        if (ret < 0)
+                return ret;
+
+        /* Configure the upstream port, and configure the upstream
+         * port as the port to which ingress and egress monitor frames
+         * are to be sent.
+         */
+        REG_WRITE(REG_GLOBAL, 0x1a, (dsa_upstream_port(ds) * 0x1110));
+
+        /* Disable remote management for now, and set the switch's
+         * DSA device number.
+         */
+        REG_WRITE(REG_GLOBAL, 0x1c, ds->index & 0x1f);
+
+        /* Send all frames with destination addresses matching
+         * 01:80:c2:00:00:2x to the CPU port.
+         */
+        REG_WRITE(REG_GLOBAL2, 0x02, 0xffff);
+
+        /* Send all frames with destination addresses matching
+         * 01:80:c2:00:00:0x to the CPU port.
+         */
+        REG_WRITE(REG_GLOBAL2, 0x03, 0xffff);
+
+        /* Disable the loopback filter, disable flow control
+         * messages, disable flood broadcast override, disable
+         * removing of provider tags, disable ATU age violation
+         * interrupts, disable tag flow control, force flow
+         * control priority to the highest, and send all special
+         * multicast frames to the CPU at the highest priority.
+         */
+        REG_WRITE(REG_GLOBAL2, 0x05, 0x00ff);
+
+        /* Program the DSA routing table. */
+        for (i = 0; i < 32; i++) {
+                int nexthop = 0x1f;
+
+                if (i != ds->index && i < ds->dst->pd->nr_chips)
+                        nexthop = ds->pd->rtable[i] & 0x1f;
+
+                REG_WRITE(REG_GLOBAL2, 0x06, 0x8000 | (i << 8) | nexthop);
+        }
+
+        /* Clear all trunk masks. */
+        for (i = 0; i < 8; i++)
+                REG_WRITE(REG_GLOBAL2, 0x07, 0x8000 | (i << 12) | 0x7f);
+
+        /* Clear all trunk mappings. */
+        for (i = 0; i < 16; i++)
+                REG_WRITE(REG_GLOBAL2, 0x08, 0x8000 | (i << 11));
+
+        /* Disable ingress rate limiting by resetting all ingress
+         * rate limit registers to their initial state.
+         */
+        for (i = 0; i < 7; i++)
+                REG_WRITE(REG_GLOBAL2, 0x09, 0x9000 | (i << 8));
+
+        /* Initialise cross-chip port VLAN table to reset defaults. */
+        REG_WRITE(REG_GLOBAL2, 0x0b, 0x9000);
+
+        /* Clear the priority override table. */
+        for (i = 0; i < 16; i++)
+                REG_WRITE(REG_GLOBAL2, 0x0f, 0x8000 | (i << 8));
+
+        /* @@@ initialise AVB (22/23) watchdog (27) sdet (29) registers */
+
+        return 0;
+}
+
+static int mv88e6352_setup_port(struct dsa_switch *ds, int p)
+{
+        int addr = REG_PORT(p);
+        u16 val;
+
+        /* MAC Forcing register: don't force link, speed, duplex
+         * or flow control state to any particular values on physical
+         * ports, but force the CPU port and all DSA ports to 1000 Mb/s
+         * full duplex.
+         */
+        if (dsa_is_cpu_port(ds, p) || ds->dsa_port_mask & (1 << p))
+                REG_WRITE(addr, 0x01, 0x003e);
+        else
+                REG_WRITE(addr, 0x01, 0x0003);
+
+        /* Do not limit the period of time that this port can be
+         * paused for by the remote end or the period of time that
+         * this port can pause the remote end.
+         */
+        REG_WRITE(addr, 0x02, 0x0000);
+
+        /* Port Control: disable Drop-on-Unlock, disable Drop-on-Lock,
+         * disable Header mode, enable IGMP/MLD snooping, disable VLAN
+         * tunneling, determine priority by looking at 802.1p and IP
+         * priority fields (IP prio has precedence), and set STP state
+         * to Forwarding.
+         *
+         * If this is the CPU link, use DSA or EDSA tagging depending
+         * on which tagging mode was configured.
+         *
+         * If this is a link to another switch, use DSA tagging mode.
+         *
+         * If this is the upstream port for this switch, enable
+         * forwarding of unknown unicasts and multicasts.
+         */
+        val = 0x0433;
+        if (dsa_is_cpu_port(ds, p)) {
+                if (ds->dst->tag_protocol == DSA_TAG_PROTO_EDSA)
+                        val |= 0x3300;
+                else
+                        val |= 0x0100;
+        }
+        if (ds->dsa_port_mask & (1 << p))
+                val |= 0x0100;
+        if (p == dsa_upstream_port(ds))
+                val |= 0x000c;
+        REG_WRITE(addr, 0x04, val);
+
+        /* Port Control 1: disable trunking.  Also, if this is the
+         * CPU port, enable learn messages to be sent to this port.
+         */
+        REG_WRITE(addr, 0x05, dsa_is_cpu_port(ds, p) ? 0x8000 : 0x0000);
+
+        /* Port based VLAN map: give each port its own address
+         * database, allow the CPU port to talk to each of the 'real'
+         * ports, and allow each of the 'real' ports to only talk to
+         * the upstream port.
+         */
+        val = (p & 0xf) << 12;
+        if (dsa_is_cpu_port(ds, p))
+                val |= ds->phys_port_mask;
+        else
+                val |= 1 << dsa_upstream_port(ds);
+        REG_WRITE(addr, 0x06, val);
+
+        /* Default VLAN ID and priority: don't set a default VLAN
+         * ID, and set the default packet priority to zero.
+         */
+        REG_WRITE(addr, 0x07, 0x0000);
+
+        /* Port Control 2: don't force a good FCS, set the maximum
+         * frame size to 10240 bytes, don't let the switch add or
+         * strip 802.1q tags, don't discard tagged or untagged frames
+         * on this port, do a destination address lookup on all
+         * received packets as usual, disable ARP mirroring and don't
+         * send a copy of all transmitted/received frames on this port
+         * to the CPU.
+         */
+        REG_WRITE(addr, 0x08, 0x2080);
+
+        /* Egress rate control: disable egress rate control. */
+        REG_WRITE(addr, 0x09, 0x0001);
+
+        /* Egress rate control 2: disable egress rate control. */
+        REG_WRITE(addr, 0x0a, 0x0000);
+
+        /* Port Association Vector: when learning source addresses
+         * of packets, add the address to the address database using
+         * a port bitmap that has only the bit for this port set and
+         * the other bits clear.
+         */
+        REG_WRITE(addr, 0x0b, 1 << p);
+
+        /* Port ATU control: disable limiting the number of address
+         * database entries that this port is allowed to use.
+         */
+        REG_WRITE(addr, 0x0c, 0x0000);
+
+        /* Priority Override: disable DA, SA and VTU priority override. */
+        REG_WRITE(addr, 0x0d, 0x0000);
+
+        /* Port Ethertype: use the Ethertype DSA Ethertype value. */
+        REG_WRITE(addr, 0x0f, ETH_P_EDSA);
+
+        /* Tag Remap: use an identity 802.1p prio -> switch prio
+         * mapping.
+         */
+        REG_WRITE(addr, 0x18, 0x3210);
+
+        /* Tag Remap 2: use an identity 802.1p prio -> switch prio
+         * mapping.
+         */
+        REG_WRITE(addr, 0x19, 0x7654);
+
+        return 0;
+}
+
+#ifdef CONFIG_NET_DSA_HWMON
+
+static int mv88e6352_phy_page_read(struct dsa_switch *ds,
+                                   int port, int page, int reg)
+{
+        struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
+        int ret;
+
+        mutex_lock(&ps->phy_mutex);
+        ret = __mv88e6352_phy_write(ds, port, 0x16, page);
+        if (ret < 0)
+                goto error;
+        ret = __mv88e6352_phy_read(ds, port, reg);
+error:
+        __mv88e6352_phy_write(ds, port, 0x16, 0x0);
+        mutex_unlock(&ps->phy_mutex);
+        return ret;
+}
+
+static int mv88e6352_phy_page_write(struct dsa_switch *ds,
+                                    int port, int page, int reg, int val)
+{
+        struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
+        int ret;
+
+        mutex_lock(&ps->phy_mutex);
+        ret = __mv88e6352_phy_write(ds, port, 0x16, page);
+        if (ret < 0)
+                goto error;
+
+        ret = __mv88e6352_phy_write(ds, port, reg, val);
+error:
+        __mv88e6352_phy_write(ds, port, 0x16, 0x0);
+        mutex_unlock(&ps->phy_mutex);
+        return ret;
+}
+
+static int mv88e6352_get_temp(struct dsa_switch *ds, int *temp)
+{
+        int ret;
+
+        *temp = 0;
+
+        ret = mv88e6352_phy_page_read(ds, 0, 6, 27);
+        if (ret < 0)
+                return ret;
+
+        *temp = (ret & 0xff) - 25;
+
+        return 0;
+}
+
+static int mv88e6352_get_temp_limit(struct dsa_switch *ds, int *temp)
+{
+        int ret;
+
+        *temp = 0;
+
+        ret = mv88e6352_phy_page_read(ds, 0, 6, 26);
+        if (ret < 0)
+                return ret;
+
+        *temp = (((ret >> 8) & 0x1f) * 5) - 25;
+
+        return 0;
+}
+
+static int mv88e6352_set_temp_limit(struct dsa_switch *ds, int temp)
+{
+        int ret;
+
+        ret = mv88e6352_phy_page_read(ds, 0, 6, 26);
+        if (ret < 0)
+                return ret;
+        temp = clamp_val(DIV_ROUND_CLOSEST(temp, 5) + 5, 0, 0x1f);
+        return mv88e6352_phy_page_write(ds, 0, 6, 26,
+                                        (ret & 0xe0ff) | (temp << 8));
+}
+
+static int mv88e6352_get_temp_alarm(struct dsa_switch *ds, bool *alarm)
+{
+        int ret;
+
+        *alarm = false;
+
+        ret = mv88e6352_phy_page_read(ds, 0, 6, 26);
+        if (ret < 0)
+                return ret;
+
+        *alarm = !!(ret & 0x40);
+
+        return 0;
+}
+#endif /* CONFIG_NET_DSA_HWMON */
+
+static int mv88e6352_setup(struct dsa_switch *ds)
+{
+        struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
+        int ret;
+        int i;
+
+        mutex_init(&ps->smi_mutex);
+        mutex_init(&ps->stats_mutex);
+        mutex_init(&ps->phy_mutex);
+        mutex_init(&ps->eeprom_mutex);
+
+        ps->id = REG_READ(REG_PORT(0), 0x03) & 0xfff0;
+
+        ret = mv88e6352_switch_reset(ds);
+        if (ret < 0)
+                return ret;
+
+        /* @@@ initialise vtu and atu */
+
+        ret = mv88e6352_setup_global(ds);
+        if (ret < 0)
+                return ret;
+
+        for (i = 0; i < 7; i++) {
+                ret = mv88e6352_setup_port(ds, i);
+                if (ret < 0)
+                        return ret;
+        }
+
+        return 0;
+}
+
+static int mv88e6352_port_to_phy_addr(int port)
+{
+        if (port >= 0 && port <= 4)
+                return port;
+        return -EINVAL;
+}
+
+static int
+mv88e6352_phy_read(struct dsa_switch *ds, int port, int regnum)
+{
+        struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
+        int addr = mv88e6352_port_to_phy_addr(port);
+        int ret;
+
+        if (addr < 0)
+                return addr;
+
+        mutex_lock(&ps->phy_mutex);
+        ret = __mv88e6352_phy_read(ds, addr, regnum);
+        mutex_unlock(&ps->phy_mutex);
+
+        return ret;
+}
+
+static int
+mv88e6352_phy_write(struct dsa_switch *ds, int port, int regnum, u16 val)
+{
+        struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
+        int addr = mv88e6352_port_to_phy_addr(port);
+        int ret;
+
+        if (addr < 0)
+                return addr;
+
+        mutex_lock(&ps->phy_mutex);
+        ret = __mv88e6352_phy_write(ds, addr, regnum, val);
+        mutex_unlock(&ps->phy_mutex);
+
+        return ret;
+}
+
+static struct mv88e6xxx_hw_stat mv88e6352_hw_stats[] = {
+        { "in_good_octets", 8, 0x00, },
+        { "in_bad_octets", 4, 0x02, },
+        { "in_unicast", 4, 0x04, },
+        { "in_broadcasts", 4, 0x06, },
+        { "in_multicasts", 4, 0x07, },
+        { "in_pause", 4, 0x16, },
+        { "in_undersize", 4, 0x18, },
+        { "in_fragments", 4, 0x19, },
+        { "in_oversize", 4, 0x1a, },
+        { "in_jabber", 4, 0x1b, },
+        { "in_rx_error", 4, 0x1c, },
+        { "in_fcs_error", 4, 0x1d, },
+        { "out_octets", 8, 0x0e, },
+        { "out_unicast", 4, 0x10, },
+        { "out_broadcasts", 4, 0x13, },
+        { "out_multicasts", 4, 0x12, },
+        { "out_pause", 4, 0x15, },
+        { "excessive", 4, 0x11, },
+        { "collisions", 4, 0x1e, },
+        { "deferred", 4, 0x05, },
+        { "single", 4, 0x14, },
+        { "multiple", 4, 0x17, },
+        { "out_fcs_error", 4, 0x03, },
+        { "late", 4, 0x1f, },
+        { "hist_64bytes", 4, 0x08, },
+        { "hist_65_127bytes", 4, 0x09, },
+        { "hist_128_255bytes", 4, 0x0a, },
+        { "hist_256_511bytes", 4, 0x0b, },
+        { "hist_512_1023bytes", 4, 0x0c, },
+        { "hist_1024_max_bytes", 4, 0x0d, },
+        { "sw_in_discards", 4, 0x110, },
+        { "sw_in_filtered", 2, 0x112, },
+        { "sw_out_filtered", 2, 0x113, },
+};
+
+static int mv88e6352_read_eeprom_word(struct dsa_switch *ds, int addr)
+{
+        struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
+        int ret;
+
+        mutex_lock(&ps->eeprom_mutex);
+
+        ret = mv88e6xxx_reg_write(ds, REG_GLOBAL2, 0x14,
+                                  0xc000 | (addr & 0xff));
+        if (ret < 0)
+                goto error;
+
+        ret = mv88e6352_eeprom_busy_wait(ds);
+        if (ret < 0)
+                goto error;
+
+        ret = mv88e6xxx_reg_read(ds, REG_GLOBAL2, 0x15);
+error:
+        mutex_unlock(&ps->eeprom_mutex);
+        return ret;
+}
+
+static int mv88e6352_get_eeprom(struct dsa_switch *ds,
+                                struct ethtool_eeprom *eeprom, u8 *data)
+{
+        int offset;
+        int len;
+        int ret;
+
+        offset = eeprom->offset;
+        len = eeprom->len;
+        eeprom->len = 0;
+
+        eeprom->magic = 0xc3ec4951;
+
+        ret = mv88e6352_eeprom_load_wait(ds);
+        if (ret < 0)
+                return ret;
+
+        if (offset & 1) {
+                int word;
+
+                word = mv88e6352_read_eeprom_word(ds, offset >> 1);
+                if (word < 0)
+                        return word;
+
+                *data++ = (word >> 8) & 0xff;
+
+                offset++;
+                len--;
+                eeprom->len++;
+        }
+
+        while (len >= 2) {
+                int word;
+
+                word = mv88e6352_read_eeprom_word(ds, offset >> 1);
+                if (word < 0)
+                        return word;
+
+                *data++ = word & 0xff;
+                *data++ = (word >> 8) & 0xff;
+
+                offset += 2;
+                len -= 2;
+                eeprom->len += 2;
+        }
+
+        if (len) {
+                int word;
+
+                word = mv88e6352_read_eeprom_word(ds, offset >> 1);
+                if (word < 0)
+                        return word;
+
+                *data++ = word & 0xff;
+
+                offset++;
+                len--;
+                eeprom->len++;
+        }
+
+        return 0;
+}
+
+static int mv88e6352_eeprom_is_readonly(struct dsa_switch *ds)
+{
+        int ret;
+
+        ret = mv88e6xxx_reg_read(ds, REG_GLOBAL2, 0x14);
+        if (ret < 0)
+                return ret;
+
+        if (!(ret & 0x0400))
+                return -EROFS;
+
+        return 0;
+}
+
+static int mv88e6352_write_eeprom_word(struct dsa_switch *ds, int addr,
+                                       u16 data)
+{
+        struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
+        int ret;
+
+        mutex_lock(&ps->eeprom_mutex);
+
+        ret = mv88e6xxx_reg_write(ds, REG_GLOBAL2, 0x15, data);
+        if (ret < 0)
+                goto error;
+
+        ret = mv88e6xxx_reg_write(ds, REG_GLOBAL2, 0x14,
+                                  0xb000 | (addr & 0xff));
+        if (ret < 0)
+                goto error;
+
+        ret = mv88e6352_eeprom_busy_wait(ds);
+error:
+        mutex_unlock(&ps->eeprom_mutex);
+        return ret;
+}
+
+static int mv88e6352_set_eeprom(struct dsa_switch *ds,
+                                struct ethtool_eeprom *eeprom, u8 *data)
+{
+        int offset;
+        int ret;
+        int len;
+
+        if (eeprom->magic != 0xc3ec4951)
+                return -EINVAL;
+
+        ret = mv88e6352_eeprom_is_readonly(ds);
+        if (ret)
+                return ret;
+
+        offset = eeprom->offset;
+        len = eeprom->len;
+        eeprom->len = 0;
+
+        ret = mv88e6352_eeprom_load_wait(ds);
+        if (ret < 0)
+                return ret;
+
+        if (offset & 1) {
+                int word;
+
+                word = mv88e6352_read_eeprom_word(ds, offset >> 1);
+                if (word < 0)
+                        return word;
+
+                word = (*data++ << 8) | (word & 0xff);
+
+                ret = mv88e6352_write_eeprom_word(ds, offset >> 1, word);
+                if (ret < 0)
+                        return ret;
+
+                offset++;
+                len--;
+                eeprom->len++;
+        }
+
+        while (len >= 2) {
+                int word;
+
+                word = *data++;
+                word |= *data++ << 8;
+
+                ret = mv88e6352_write_eeprom_word(ds, offset >> 1, word);
+                if (ret < 0)
+                        return ret;
+
+                offset += 2;
+                len -= 2;
+                eeprom->len += 2;
+        }
+
+        if (len) {
+                int word;
+
+                word = mv88e6352_read_eeprom_word(ds, offset >> 1);
+                if (word < 0)
+                        return word;
+
+                word = (word & 0xff00) | *data++;
+
+                ret = mv88e6352_write_eeprom_word(ds, offset >> 1, word);
+                if (ret < 0)
+                        return ret;
+
+                offset++;
+                len--;
+                eeprom->len++;
+        }
+
+        return 0;
+}
+
+static void
+mv88e6352_get_strings(struct dsa_switch *ds, int port, uint8_t *data)
+{
+        mv88e6xxx_get_strings(ds, ARRAY_SIZE(mv88e6352_hw_stats),
+                              mv88e6352_hw_stats, port, data);
+}
+
+static void
+mv88e6352_get_ethtool_stats(struct dsa_switch *ds, int port, uint64_t *data)
+{
+        mv88e6xxx_get_ethtool_stats(ds, ARRAY_SIZE(mv88e6352_hw_stats),
+                                    mv88e6352_hw_stats, port, data);
+}
+
+static int mv88e6352_get_sset_count(struct dsa_switch *ds)
+{
+        return ARRAY_SIZE(mv88e6352_hw_stats);
+}
+
+struct dsa_switch_driver mv88e6352_switch_driver = {
+        .tag_protocol           = DSA_TAG_PROTO_EDSA,
+        .priv_size              = sizeof(struct mv88e6xxx_priv_state),
+        .probe                  = mv88e6352_probe,
+        .setup                  = mv88e6352_setup,
+        .set_addr               = mv88e6xxx_set_addr_indirect,
+        .phy_read               = mv88e6352_phy_read,
+        .phy_write              = mv88e6352_phy_write,
+        .poll_link              = mv88e6xxx_poll_link,
+        .get_strings            = mv88e6352_get_strings,
+        .get_ethtool_stats      = mv88e6352_get_ethtool_stats,
+        .get_sset_count         = mv88e6352_get_sset_count,
+#ifdef CONFIG_NET_DSA_HWMON
+        .get_temp               = mv88e6352_get_temp,
+        .get_temp_limit         = mv88e6352_get_temp_limit,
+        .set_temp_limit         = mv88e6352_set_temp_limit,
+        .get_temp_alarm         = mv88e6352_get_temp_alarm,
+#endif
+        .get_eeprom             = mv88e6352_get_eeprom,
+        .set_eeprom             = mv88e6352_set_eeprom,
+        .get_regs_len           = mv88e6xxx_get_regs_len,
+        .get_regs               = mv88e6xxx_get_regs,
+};
+
+MODULE_ALIAS("platform:mv88e6352");
diff --git a/drivers/net/dsa/mv88e6xxx.c b/drivers/net/dsa/mv88e6xxx.c
index a6c90cf5634d..da558d887dad 100644
--- a/drivers/net/dsa/mv88e6xxx.c
+++ b/drivers/net/dsa/mv88e6xxx.c
@@ -485,20 +485,60 @@ void mv88e6xxx_get_ethtool_stats(struct dsa_switch *ds,
         for (i = 0; i < nr_stats; i++) {
                 struct mv88e6xxx_hw_stat *s = stats + i;
                 u32 low;
-                u32 high;
-
+                u32 high = 0;
+
+                if (s->reg >= 0x100) {
+                        int ret;
+
+                        ret = mv88e6xxx_reg_read(ds, REG_PORT(port),
+                                                 s->reg - 0x100);
+                        if (ret < 0)
+                                goto error;
+                        low = ret;
+                        if (s->sizeof_stat == 4) {
+                                ret = mv88e6xxx_reg_read(ds, REG_PORT(port),
+                                                         s->reg - 0x100 + 1);
+                                if (ret < 0)
+                                        goto error;
+                                high = ret;
+                        }
+                        data[i] = (((u64)high) << 16) | low;
+                        continue;
+                }
                 mv88e6xxx_stats_read(ds, s->reg, &low);
                 if (s->sizeof_stat == 8)
                         mv88e6xxx_stats_read(ds, s->reg + 1, &high);
-                else
-                        high = 0;
 
                 data[i] = (((u64)high) << 32) | low;
         }
-
+error:
         mutex_unlock(&ps->stats_mutex);
 }
 
+int mv88e6xxx_get_regs_len(struct dsa_switch *ds, int port)
+{
+        return 32 * sizeof(u16);
+}
+
+void mv88e6xxx_get_regs(struct dsa_switch *ds, int port,
+                        struct ethtool_regs *regs, void *_p)
+{
+        u16 *p = _p;
+        int i;
+
+        regs->version = 0;
+
+        memset(p, 0xff, 32 * sizeof(u16));
+
+        for (i = 0; i < 32; i++) {
+                int ret;
+
+                ret = mv88e6xxx_reg_read(ds, REG_PORT(port), i);
+                if (ret >= 0)
+                        p[i] = ret;
+        }
+}
+
 static int __init mv88e6xxx_init(void)
 {
 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6131)
@@ -507,6 +547,9 @@ static int __init mv88e6xxx_init(void)
 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6123_61_65)
         register_switch_driver(&mv88e6123_61_65_switch_driver);
 #endif
+#if IS_ENABLED(CONFIG_NET_DSA_MV88E6352)
+        register_switch_driver(&mv88e6352_switch_driver);
+#endif
 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6171)
         register_switch_driver(&mv88e6171_switch_driver);
 #endif
diff --git a/drivers/net/dsa/mv88e6xxx.h b/drivers/net/dsa/mv88e6xxx.h
index 5e5145ad9525..a0780b08bb4c 100644
--- a/drivers/net/dsa/mv88e6xxx.h
+++ b/drivers/net/dsa/mv88e6xxx.h
@@ -37,6 +37,17 @@ struct mv88e6xxx_priv_state {
          */
         struct mutex    stats_mutex;
 
+        /* This mutex serializes phy access for chips with
+         * indirect phy addressing. It is unused for chips
+         * with direct phy access.
+         */
+        struct mutex    phy_mutex;
+
+        /* This mutex serializes eeprom access for chips with
+         * eeprom support.
+         */
+        struct mutex eeprom_mutex;
+
         int             id; /* switch product id */
 };
 
@@ -67,9 +78,13 @@ void mv88e6xxx_get_strings(struct dsa_switch *ds,
 void mv88e6xxx_get_ethtool_stats(struct dsa_switch *ds,
                                  int nr_stats, struct mv88e6xxx_hw_stat *stats,
                                  int port, uint64_t *data);
+int mv88e6xxx_get_regs_len(struct dsa_switch *ds, int port);
+void mv88e6xxx_get_regs(struct dsa_switch *ds, int port,
+                        struct ethtool_regs *regs, void *_p);
 
 extern struct dsa_switch_driver mv88e6131_switch_driver;
 extern struct dsa_switch_driver mv88e6123_61_65_switch_driver;
+extern struct dsa_switch_driver mv88e6352_switch_driver;
 extern struct dsa_switch_driver mv88e6171_switch_driver;
 
 #define REG_READ(addr, reg)                                             \
diff --git a/drivers/net/ethernet/3com/typhoon.c b/drivers/net/ethernet/3com/typhoon.c
index 48775b88bac7..dede43f4ce09 100644
--- a/drivers/net/ethernet/3com/typhoon.c
+++ b/drivers/net/ethernet/3com/typhoon.c
@@ -1285,7 +1285,7 @@ typhoon_request_firmware(struct typhoon *tp)
                 return err;
         }
 
-        image_data = (u8 *) typhoon_fw->data;
+        image_data = typhoon_fw->data;
         remaining = typhoon_fw->size;
         if (remaining < sizeof(struct typhoon_file_header))
                 goto invalid_fw;
@@ -1343,7 +1343,7 @@ typhoon_download_firmware(struct typhoon *tp)
         int i;
         int err;
 
-        image_data = (u8 *) typhoon_fw->data;
+        image_data = typhoon_fw->data;
         fHdr = (struct typhoon_file_header *) image_data;
 
         /* Cannot just map the firmware image using pci_map_single() as
diff --git a/drivers/net/ethernet/apm/xgene/xgene_enet_main.c b/drivers/net/ethernet/apm/xgene/xgene_enet_main.c
index 3c208cc6f6bb..f22659438436 100644
--- a/drivers/net/ethernet/apm/xgene/xgene_enet_main.c
+++ b/drivers/net/ethernet/apm/xgene/xgene_enet_main.c
@@ -761,10 +761,6 @@ static int xgene_enet_get_resources(struct xgene_enet_pdata *pdata)
         ndev = pdata->ndev;
 
         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "enet_csr");
-        if (!res) {
-                dev_err(dev, "Resource enet_csr not defined\n");
-                return -ENODEV;
-        }
         pdata->base_addr = devm_ioremap_resource(dev, res);
         if (IS_ERR(pdata->base_addr)) {
                 dev_err(dev, "Unable to retrieve ENET Port CSR region\n");
@@ -772,10 +768,6 @@ static int xgene_enet_get_resources(struct xgene_enet_pdata *pdata)
         }
 
         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ring_csr");
-        if (!res) {
-                dev_err(dev, "Resource ring_csr not defined\n");
-                return -ENODEV;
-        }
         pdata->ring_csr_addr = devm_ioremap_resource(dev, res);
         if (IS_ERR(pdata->ring_csr_addr)) {
                 dev_err(dev, "Unable to retrieve ENET Ring CSR region\n");
@@ -783,10 +775,6 @@ static int xgene_enet_get_resources(struct xgene_enet_pdata *pdata)
         }
 
         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ring_cmd");
-        if (!res) {
-                dev_err(dev, "Resource ring_cmd not defined\n");
-                return -ENODEV;
-        }
         pdata->ring_cmd_addr = devm_ioremap_resource(dev, res);
         if (IS_ERR(pdata->ring_cmd_addr)) {
                 dev_err(dev, "Unable to retrieve ENET Ring command region\n");
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
index 40beef5bca88..e9af4af5edba 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
@@ -1139,7 +1139,7 @@ static irqreturn_t bnx2x_msix_fp_int(int irq, void *fp_cookie)
                 prefetch(fp->txdata_ptr[cos]->tx_cons_sb);
 
         prefetch(&fp->sb_running_index[SM_RX_ID]);
-        napi_schedule(&bnx2x_fp(bp, fp->index, napi));
+        napi_schedule_irqoff(&bnx2x_fp(bp, fp->index, napi));
 
         return IRQ_HANDLED;
 }
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
index 74fbf9ea7bd8..c4bd025c74c9 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
@@ -1931,7 +1931,7 @@ irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
                         for_each_cos_in_tx_queue(fp, cos)
                                 prefetch(fp->txdata_ptr[cos]->tx_cons_sb);
                         prefetch(&fp->sb_running_index[SM_RX_ID]);
-                        napi_schedule(&bnx2x_fp(bp, fp->index, napi));
+                        napi_schedule_irqoff(&bnx2x_fp(bp, fp->index, napi));
                         status &= ~mask;
                 }
         }
diff --git a/drivers/net/ethernet/cirrus/mac89x0.c b/drivers/net/ethernet/cirrus/mac89x0.c
index e285f384b096..07719676c305 100644
--- a/drivers/net/ethernet/cirrus/mac89x0.c
+++ b/drivers/net/ethernet/cirrus/mac89x0.c
@@ -216,14 +216,10 @@ struct net_device * __init mac89x0_probe(int unit)
         ioaddr = (unsigned long)
                 nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
         {
-                unsigned long flags;
                 int card_present;
 
-                local_irq_save(flags);
-                card_present = (hwreg_present((void*) ioaddr+4) &&
-                                hwreg_present((void*) ioaddr + DATA_PORT));
-                local_irq_restore(flags);
-
+                card_present = (hwreg_present((void *)ioaddr + 4) &&
+                                hwreg_present((void *)ioaddr + DATA_PORT));
                 if (!card_present)
                         goto out;
         }
diff --git a/drivers/net/ethernet/freescale/gianfar.c b/drivers/net/ethernet/freescale/gianfar.c
index 4fdf0aa16978..86dccb26fecc 100644
--- a/drivers/net/ethernet/freescale/gianfar.c
+++ b/drivers/net/ethernet/freescale/gianfar.c
@@ -173,10 +173,12 @@ static void gfar_init_rxbdp(struct gfar_priv_rx_q *rx_queue, struct rxbd8 *bdp,
 static int gfar_init_bds(struct net_device *ndev)
 {
         struct gfar_private *priv = netdev_priv(ndev);
+        struct gfar __iomem *regs = priv->gfargrp[0].regs;
         struct gfar_priv_tx_q *tx_queue = NULL;
         struct gfar_priv_rx_q *rx_queue = NULL;
         struct txbd8 *txbdp;
         struct rxbd8 *rxbdp;
+        u32 *rfbptr;
         int i, j;
 
         for (i = 0; i < priv->num_tx_queues; i++) {
@@ -201,6 +203,7 @@ static int gfar_init_bds(struct net_device *ndev)
                 txbdp->status |= TXBD_WRAP;
         }
 
+        rfbptr = &regs->rfbptr0;
         for (i = 0; i < priv->num_rx_queues; i++) {
                 rx_queue = priv->rx_queue[i];
                 rx_queue->cur_rx = rx_queue->rx_bd_base;
@@ -227,6 +230,8 @@ static int gfar_init_bds(struct net_device *ndev)
                         rxbdp++;
                 }
 
+                rx_queue->rfbptr = rfbptr;
+                rfbptr += 2;
         }
 
         return 0;
@@ -336,6 +341,20 @@ static void gfar_init_tx_rx_base(struct gfar_private *priv)
         }
 }
 
+static void gfar_init_rqprm(struct gfar_private *priv)
+{
+        struct gfar __iomem *regs = priv->gfargrp[0].regs;
+        u32 __iomem *baddr;
+        int i;
+
+        baddr = &regs->rqprm0;
+        for (i = 0; i < priv->num_rx_queues; i++) {
+                gfar_write(baddr, priv->rx_queue[i]->rx_ring_size |
+                           (DEFAULT_RX_LFC_THR << FBTHR_SHIFT));
+                baddr++;
+        }
+}
+
 static void gfar_rx_buff_size_config(struct gfar_private *priv)
 {
         int frame_size = priv->ndev->mtu + ETH_HLEN + ETH_FCS_LEN;
@@ -396,6 +415,13 @@ static void gfar_mac_rx_config(struct gfar_private *priv)
         if (priv->ndev->features & NETIF_F_HW_VLAN_CTAG_RX)
                 rctrl |= RCTRL_VLEX | RCTRL_PRSDEP_INIT;
 
+        /* Clear the LFC bit */
+        gfar_write(&regs->rctrl, rctrl);
+        /* Init flow control threshold values */
+        gfar_init_rqprm(priv);
+        gfar_write(&regs->ptv, DEFAULT_LFC_PTVVAL);
+        rctrl |= RCTRL_LFC;
+
         /* Init rctrl based on our settings */
         gfar_write(&regs->rctrl, rctrl);
 }
@@ -1687,6 +1713,9 @@ static int init_phy(struct net_device *dev)
         priv->phydev->supported &= (GFAR_SUPPORTED | gigabit_support);
         priv->phydev->advertising = priv->phydev->supported;
 
+        /* Add support for flow control, but don't advertise it by default */
+        priv->phydev->supported |= (SUPPORTED_Pause | SUPPORTED_Asym_Pause);
+
         return 0;
 }
 
@@ -2856,6 +2885,10 @@ int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit)
                 /* Setup the new bdp */
                 gfar_new_rxbdp(rx_queue, bdp, newskb);
 
+                /* Update Last Free RxBD pointer for LFC */
+                if (unlikely(rx_queue->rfbptr && priv->tx_actual_en))
+                        gfar_write(rx_queue->rfbptr, (u32)bdp);
+
                 /* Update to the next pointer */
                 bdp = next_bd(bdp, base, rx_queue->rx_ring_size);
 
@@ -3370,7 +3403,11 @@ static u32 gfar_get_flowctrl_cfg(struct gfar_private *priv)
                 if (phydev->asym_pause)
                         rmt_adv |= LPA_PAUSE_ASYM;
 
-                lcl_adv = mii_advertise_flowctrl(phydev->advertising);
+                lcl_adv = 0;
+                if (phydev->advertising & ADVERTISED_Pause)
+                        lcl_adv |= ADVERTISE_PAUSE_CAP;
+                if (phydev->advertising & ADVERTISED_Asym_Pause)
+                        lcl_adv |= ADVERTISE_PAUSE_ASYM;
 
                 flowctrl = mii_resolve_flowctrl_fdx(lcl_adv, rmt_adv);
                 if (flowctrl & FLOW_CTRL_TX)
@@ -3386,6 +3423,9 @@ static noinline void gfar_update_link_state(struct gfar_private *priv)
 {
         struct gfar __iomem *regs = priv->gfargrp[0].regs;
         struct phy_device *phydev = priv->phydev;
+        struct gfar_priv_rx_q *rx_queue = NULL;
+        int i;
+        struct rxbd8 *bdp;
 
         if (unlikely(test_bit(GFAR_RESETTING, &priv->state)))
                 return;
@@ -3394,6 +3434,7 @@ static noinline void gfar_update_link_state(struct gfar_private *priv)
                 u32 tempval1 = gfar_read(&regs->maccfg1);
                 u32 tempval = gfar_read(&regs->maccfg2);
                 u32 ecntrl = gfar_read(&regs->ecntrl);
+                u32 tx_flow_oldval = (tempval & MACCFG1_TX_FLOW);
 
                 if (phydev->duplex != priv->oldduplex) {
                         if (!(phydev->duplex))
@@ -3438,6 +3479,26 @@ static noinline void gfar_update_link_state(struct gfar_private *priv)
                 tempval1 &= ~(MACCFG1_TX_FLOW | MACCFG1_RX_FLOW);
                 tempval1 |= gfar_get_flowctrl_cfg(priv);
 
+                /* Turn last free buffer recording on */
+                if ((tempval1 & MACCFG1_TX_FLOW) && !tx_flow_oldval) {
+                        for (i = 0; i < priv->num_rx_queues; i++) {
+                                rx_queue = priv->rx_queue[i];
+                                bdp = rx_queue->cur_rx;
+                                /* skip to previous bd */
+                                bdp = skip_bd(bdp, rx_queue->rx_ring_size - 1,
+                                              rx_queue->rx_bd_base,
+                                              rx_queue->rx_ring_size);
+
+                                if (rx_queue->rfbptr)
+                                        gfar_write(rx_queue->rfbptr, (u32)bdp);
+                        }
+
+                        priv->tx_actual_en = 1;
+                }
+
+                if (unlikely(!(tempval1 & MACCFG1_TX_FLOW) && tx_flow_oldval))
+                        priv->tx_actual_en = 0;
+
                 gfar_write(&regs->maccfg1, tempval1);
                 gfar_write(&regs->maccfg2, tempval);
                 gfar_write(&regs->ecntrl, ecntrl);
diff --git a/drivers/net/ethernet/freescale/gianfar.h b/drivers/net/ethernet/freescale/gianfar.h
index 2805cfbf1765..b581b8823a2a 100644
--- a/drivers/net/ethernet/freescale/gianfar.h
+++ b/drivers/net/ethernet/freescale/gianfar.h
@@ -99,6 +99,10 @@ extern const char gfar_driver_version[];
 #define GFAR_MAX_FIFO_STARVE    511
 #define GFAR_MAX_FIFO_STARVE_OFF 511
 
+#define FBTHR_SHIFT        24
+#define DEFAULT_RX_LFC_THR  16
+#define DEFAULT_LFC_PTVVAL  4
+
 #define DEFAULT_RX_BUFFER_SIZE  1536
 #define TX_RING_MOD_MASK(size) (size-1)
 #define RX_RING_MOD_MASK(size) (size-1)
@@ -145,9 +149,7 @@ extern const char gfar_driver_version[];
                 | SUPPORTED_Autoneg \
                 | SUPPORTED_MII)
 
-#define GFAR_SUPPORTED_GBIT (SUPPORTED_1000baseT_Full \
-                | SUPPORTED_Pause \
-                | SUPPORTED_Asym_Pause)
+#define GFAR_SUPPORTED_GBIT SUPPORTED_1000baseT_Full
 
 /* TBI register addresses */
 #define MII_TBICON              0x11
@@ -275,6 +277,7 @@ extern const char gfar_driver_version[];
 
 #define RCTRL_TS_ENABLE         0x01000000
 #define RCTRL_PAL_MASK          0x001f0000
+#define RCTRL_LFC               0x00004000
 #define RCTRL_VLEX              0x00002000
 #define RCTRL_FILREN            0x00001000
 #define RCTRL_GHTX              0x00000400
@@ -851,7 +854,32 @@ struct gfar {
         u8      res23c[248];
         u32     attr;           /* 0x.bf8 - Attributes Register */
         u32     attreli;        /* 0x.bfc - Attributes Extract Length and Extract Index Register */
-        u8      res24[688];
+        u32     rqprm0; /* 0x.c00 - Receive queue parameters register 0 */
+        u32     rqprm1; /* 0x.c04 - Receive queue parameters register 1 */
+        u32     rqprm2; /* 0x.c08 - Receive queue parameters register 2 */
+        u32     rqprm3; /* 0x.c0c - Receive queue parameters register 3 */
+        u32     rqprm4; /* 0x.c10 - Receive queue parameters register 4 */
+        u32     rqprm5; /* 0x.c14 - Receive queue parameters register 5 */
+        u32     rqprm6; /* 0x.c18 - Receive queue parameters register 6 */
+        u32     rqprm7; /* 0x.c1c - Receive queue parameters register 7 */
+        u8      res24[36];
+        u32     rfbptr0; /* 0x.c44 - Last free RxBD pointer for ring 0 */
+        u8      res24a[4];
+        u32     rfbptr1; /* 0x.c4c - Last free RxBD pointer for ring 1 */
+        u8      res24b[4];
+        u32     rfbptr2; /* 0x.c54 - Last free RxBD pointer for ring 2 */
+        u8      res24c[4];
+        u32     rfbptr3; /* 0x.c5c - Last free RxBD pointer for ring 3 */
+        u8      res24d[4];
+        u32     rfbptr4; /* 0x.c64 - Last free RxBD pointer for ring 4 */
+        u8      res24e[4];
+        u32     rfbptr5; /* 0x.c6c - Last free RxBD pointer for ring 5 */
+        u8      res24f[4];
+        u32     rfbptr6; /* 0x.c74 - Last free RxBD pointer for ring 6 */
+        u8      res24g[4];
+        u32     rfbptr7; /* 0x.c7c - Last free RxBD pointer for ring 7 */
+        u8      res24h[4];
+        u8      res24x[556];
         u32     isrg0;          /* 0x.eb0 - Interrupt steering group 0 register */
         u32     isrg1;          /* 0x.eb4 - Interrupt steering group 1 register */
         u32     isrg2;          /* 0x.eb8 - Interrupt steering group 2 register */
@@ -1011,6 +1039,7 @@ struct gfar_priv_rx_q {
         /* RX Coalescing values */
         unsigned char rxcoalescing;
         unsigned long rxic;
+        u32 *rfbptr;
 };
 
 enum gfar_irqinfo_id {
@@ -1101,6 +1130,7 @@ struct gfar_private {
         unsigned int num_tx_queues;
         unsigned int num_rx_queues;
         unsigned int num_grps;
+        int tx_actual_en;
 
         /* Network Statistics */
         struct gfar_extra_stats extra_stats;
diff --git a/drivers/net/ethernet/freescale/gianfar_ethtool.c b/drivers/net/ethernet/freescale/gianfar_ethtool.c
index 76d70708f864..3e1a9c1a67a9 100644
--- a/drivers/net/ethernet/freescale/gianfar_ethtool.c
+++ b/drivers/net/ethernet/freescale/gianfar_ethtool.c
@@ -579,8 +579,13 @@ static int gfar_spauseparam(struct net_device *dev,
                         u32 tempval;
                         tempval = gfar_read(&regs->maccfg1);
                         tempval &= ~(MACCFG1_TX_FLOW | MACCFG1_RX_FLOW);
-                        if (priv->tx_pause_en)
+
+                        priv->tx_actual_en = 0;
+                        if (priv->tx_pause_en) {
+                                priv->tx_actual_en = 1;
                                 tempval |= MACCFG1_TX_FLOW;
+                        }
+
                         if (priv->rx_pause_en)
                                 tempval |= MACCFG1_RX_FLOW;
                         gfar_write(&regs->maccfg1, tempval);
diff --git a/drivers/net/ethernet/intel/i40e/i40e_adminq_cmd.h b/drivers/net/ethernet/intel/i40e/i40e_adminq_cmd.h
index 15f289f2917f..a65bc4398971 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_adminq_cmd.h
+++ b/drivers/net/ethernet/intel/i40e/i40e_adminq_cmd.h
@@ -33,8 +33,8 @@
  * This file needs to comply with the Linux Kernel coding style.
  */
 
-#define I40E_FW_API_VERSION_MAJOR  0x0001
-#define I40E_FW_API_VERSION_MINOR  0x0002
+#define I40E_FW_API_VERSION_MAJOR       0x0001
+#define I40E_FW_API_VERSION_MINOR       0x0002
 
 struct i40e_aq_desc {
         __le16 flags;
@@ -66,216 +66,216 @@ struct i40e_aq_desc {
  */
 
 /* command flags and offsets*/
-#define I40E_AQ_FLAG_DD_SHIFT  0
-#define I40E_AQ_FLAG_CMP_SHIFT 1
-#define I40E_AQ_FLAG_ERR_SHIFT 2
-#define I40E_AQ_FLAG_VFE_SHIFT 3
-#define I40E_AQ_FLAG_LB_SHIFT  9
-#define I40E_AQ_FLAG_RD_SHIFT  10
-#define I40E_AQ_FLAG_VFC_SHIFT 11
-#define I40E_AQ_FLAG_BUF_SHIFT 12
-#define I40E_AQ_FLAG_SI_SHIFT  13
-#define I40E_AQ_FLAG_EI_SHIFT  14
-#define I40E_AQ_FLAG_FE_SHIFT  15
-
-#define I40E_AQ_FLAG_DD  (1 << I40E_AQ_FLAG_DD_SHIFT)  /* 0x1    */
-#define I40E_AQ_FLAG_CMP (1 << I40E_AQ_FLAG_CMP_SHIFT) /* 0x2    */
-#define I40E_AQ_FLAG_ERR (1 << I40E_AQ_FLAG_ERR_SHIFT) /* 0x4    */
-#define I40E_AQ_FLAG_VFE (1 << I40E_AQ_FLAG_VFE_SHIFT) /* 0x8    */
-#define I40E_AQ_FLAG_LB  (1 << I40E_AQ_FLAG_LB_SHIFT)  /* 0x200  */
-#define I40E_AQ_FLAG_RD  (1 << I40E_AQ_FLAG_RD_SHIFT)  /* 0x400  */
-#define I40E_AQ_FLAG_VFC (1 << I40E_AQ_FLAG_VFC_SHIFT) /* 0x800  */
-#define I40E_AQ_FLAG_BUF (1 << I40E_AQ_FLAG_BUF_SHIFT) /* 0x1000 */
-#define I40E_AQ_FLAG_SI  (1 << I40E_AQ_FLAG_SI_SHIFT)  /* 0x2000 */
-#define I40E_AQ_FLAG_EI  (1 << I40E_AQ_FLAG_EI_SHIFT)  /* 0x4000 */
-#define I40E_AQ_FLAG_FE  (1 << I40E_AQ_FLAG_FE_SHIFT)  /* 0x8000 */
+#define I40E_AQ_FLAG_DD_SHIFT   0
+#define I40E_AQ_FLAG_CMP_SHIFT  1
+#define I40E_AQ_FLAG_ERR_SHIFT  2
+#define I40E_AQ_FLAG_VFE_SHIFT  3
+#define I40E_AQ_FLAG_LB_SHIFT   9
+#define I40E_AQ_FLAG_RD_SHIFT   10
+#define I40E_AQ_FLAG_VFC_SHIFT  11
+#define I40E_AQ_FLAG_BUF_SHIFT  12
+#define I40E_AQ_FLAG_SI_SHIFT   13
+#define I40E_AQ_FLAG_EI_SHIFT   14
+#define I40E_AQ_FLAG_FE_SHIFT   15
+
+#define I40E_AQ_FLAG_DD         (1 << I40E_AQ_FLAG_DD_SHIFT)  /* 0x1    */
+#define I40E_AQ_FLAG_CMP        (1 << I40E_AQ_FLAG_CMP_SHIFT) /* 0x2    */
+#define I40E_AQ_FLAG_ERR        (1 << I40E_AQ_FLAG_ERR_SHIFT) /* 0x4    */
+#define I40E_AQ_FLAG_VFE        (1 << I40E_AQ_FLAG_VFE_SHIFT) /* 0x8    */
+#define I40E_AQ_FLAG_LB         (1 << I40E_AQ_FLAG_LB_SHIFT)  /* 0x200  */
+#define I40E_AQ_FLAG_RD         (1 << I40E_AQ_FLAG_RD_SHIFT)  /* 0x400  */
+#define I40E_AQ_FLAG_VFC        (1 << I40E_AQ_FLAG_VFC_SHIFT) /* 0x800  */
+#define I40E_AQ_FLAG_BUF        (1 << I40E_AQ_FLAG_BUF_SHIFT) /* 0x1000 */
+#define I40E_AQ_FLAG_SI         (1 << I40E_AQ_FLAG_SI_SHIFT)  /* 0x2000 */
+#define I40E_AQ_FLAG_EI         (1 << I40E_AQ_FLAG_EI_SHIFT)  /* 0x4000 */
+#define I40E_AQ_FLAG_FE         (1 << I40E_AQ_FLAG_FE_SHIFT)  /* 0x8000 */
 
 /* error codes */
 enum i40e_admin_queue_err {
-        I40E_AQ_RC_OK       = 0,    /* success */
-        I40E_AQ_RC_EPERM    = 1,    /* Operation not permitted */
-        I40E_AQ_RC_ENOENT   = 2,    /* No such element */
-        I40E_AQ_RC_ESRCH    = 3,    /* Bad opcode */
-        I40E_AQ_RC_EINTR    = 4,    /* operation interrupted */
-        I40E_AQ_RC_EIO      = 5,    /* I/O error */
-        I40E_AQ_RC_ENXIO    = 6,    /* No such resource */
-        I40E_AQ_RC_E2BIG    = 7,    /* Arg too long */
-        I40E_AQ_RC_EAGAIN   = 8,    /* Try again */
-        I40E_AQ_RC_ENOMEM   = 9,    /* Out of memory */
-        I40E_AQ_RC_EACCES   = 10,   /* Permission denied */
-        I40E_AQ_RC_EFAULT   = 11,   /* Bad address */
-        I40E_AQ_RC_EBUSY    = 12,   /* Device or resource busy */
-        I40E_AQ_RC_EEXIST   = 13,   /* object already exists */
-        I40E_AQ_RC_EINVAL   = 14,   /* Invalid argument */
-        I40E_AQ_RC_ENOTTY   = 15,   /* Not a typewriter */
-        I40E_AQ_RC_ENOSPC   = 16,   /* No space left or alloc failure */
-        I40E_AQ_RC_ENOSYS   = 17,   /* Function not implemented */
-        I40E_AQ_RC_ERANGE   = 18,   /* Parameter out of range */
-        I40E_AQ_RC_EFLUSHED = 19,   /* Cmd flushed because of prev cmd error */
-        I40E_AQ_RC_BAD_ADDR = 20,   /* Descriptor contains a bad pointer */
-        I40E_AQ_RC_EMODE    = 21,   /* Op not allowed in current dev mode */
-        I40E_AQ_RC_EFBIG    = 22,   /* File too large */
+        I40E_AQ_RC_OK           = 0,  /* success */
+        I40E_AQ_RC_EPERM        = 1,  /* Operation not permitted */
+        I40E_AQ_RC_ENOENT       = 2,  /* No such element */
+        I40E_AQ_RC_ESRCH        = 3,  /* Bad opcode */
+        I40E_AQ_RC_EINTR        = 4,  /* operation interrupted */
+        I40E_AQ_RC_EIO          = 5,  /* I/O error */
+        I40E_AQ_RC_ENXIO        = 6,  /* No such resource */
+        I40E_AQ_RC_E2BIG        = 7,  /* Arg too long */
+        I40E_AQ_RC_EAGAIN       = 8,  /* Try again */
+        I40E_AQ_RC_ENOMEM       = 9,  /* Out of memory */
+        I40E_AQ_RC_EACCES       = 10, /* Permission denied */
+        I40E_AQ_RC_EFAULT       = 11, /* Bad address */
+        I40E_AQ_RC_EBUSY        = 12, /* Device or resource busy */
+        I40E_AQ_RC_EEXIST       = 13, /* object already exists */
+        I40E_AQ_RC_EINVAL       = 14, /* Invalid argument */
+        I40E_AQ_RC_ENOTTY       = 15, /* Not a typewriter */
+        I40E_AQ_RC_ENOSPC       = 16, /* No space left or alloc failure */
+        I40E_AQ_RC_ENOSYS       = 17, /* Function not implemented */
+        I40E_AQ_RC_ERANGE       = 18, /* Parameter out of range */
+        I40E_AQ_RC_EFLUSHED     = 19, /* Cmd flushed due to prev cmd error */
+        I40E_AQ_RC_BAD_ADDR     = 20, /* Descriptor contains a bad pointer */
+        I40E_AQ_RC_EMODE        = 21, /* Op not allowed in current dev mode */
+        I40E_AQ_RC_EFBIG        = 22, /* File too large */
 };
 
 /* Admin Queue command opcodes */
 enum i40e_admin_queue_opc {
         /* aq commands */
-        i40e_aqc_opc_get_version      = 0x0001,
-        i40e_aqc_opc_driver_version   = 0x0002,
-        i40e_aqc_opc_queue_shutdown   = 0x0003,
-        i40e_aqc_opc_set_pf_context   = 0x0004,
+        i40e_aqc_opc_get_version        = 0x0001,
+        i40e_aqc_opc_driver_version     = 0x0002,
+        i40e_aqc_opc_queue_shutdown     = 0x0003,
+        i40e_aqc_opc_set_pf_context     = 0x0004,
 
         /* resource ownership */
-        i40e_aqc_opc_request_resource = 0x0008,
-        i40e_aqc_opc_release_resource = 0x0009,
+        i40e_aqc_opc_request_resource   = 0x0008,
+        i40e_aqc_opc_release_resource   = 0x0009,
 
-        i40e_aqc_opc_list_func_capabilities = 0x000A,
-        i40e_aqc_opc_list_dev_capabilities  = 0x000B,
+        i40e_aqc_opc_list_func_capabilities     = 0x000A,
+        i40e_aqc_opc_list_dev_capabilities      = 0x000B,
 
-        i40e_aqc_opc_set_cppm_configuration = 0x0103,
-        i40e_aqc_opc_set_arp_proxy_entry    = 0x0104,
-        i40e_aqc_opc_set_ns_proxy_entry     = 0x0105,
+        i40e_aqc_opc_set_cppm_configuration     = 0x0103,
+        i40e_aqc_opc_set_arp_proxy_entry        = 0x0104,
+        i40e_aqc_opc_set_ns_proxy_entry         = 0x0105,
 
         /* LAA */
-        i40e_aqc_opc_mng_laa                = 0x0106,   /* AQ obsolete */
-        i40e_aqc_opc_mac_address_read       = 0x0107,
-        i40e_aqc_opc_mac_address_write      = 0x0108,
+        i40e_aqc_opc_mng_laa            = 0x0106,   /* AQ obsolete */
+        i40e_aqc_opc_mac_address_read   = 0x0107,
+        i40e_aqc_opc_mac_address_write  = 0x0108,
 
         /* PXE */
-        i40e_aqc_opc_clear_pxe_mode         = 0x0110,
+        i40e_aqc_opc_clear_pxe_mode     = 0x0110,
 
         /* internal switch commands */
-        i40e_aqc_opc_get_switch_config         = 0x0200,
-        i40e_aqc_opc_add_statistics            = 0x0201,
-        i40e_aqc_opc_remove_statistics         = 0x0202,
-        i40e_aqc_opc_set_port_parameters       = 0x0203,
-        i40e_aqc_opc_get_switch_resource_alloc = 0x0204,
-
-        i40e_aqc_opc_add_vsi                = 0x0210,
-        i40e_aqc_opc_update_vsi_parameters  = 0x0211,
-        i40e_aqc_opc_get_vsi_parameters     = 0x0212,
-
-        i40e_aqc_opc_add_pv                = 0x0220,
-        i40e_aqc_opc_update_pv_parameters  = 0x0221,
-        i40e_aqc_opc_get_pv_parameters     = 0x0222,
-
-        i40e_aqc_opc_add_veb               = 0x0230,
-        i40e_aqc_opc_update_veb_parameters = 0x0231,
-        i40e_aqc_opc_get_veb_parameters    = 0x0232,
-
-        i40e_aqc_opc_delete_element  = 0x0243,
-
-        i40e_aqc_opc_add_macvlan                  = 0x0250,
-        i40e_aqc_opc_remove_macvlan               = 0x0251,
-        i40e_aqc_opc_add_vlan                     = 0x0252,
-        i40e_aqc_opc_remove_vlan                  = 0x0253,
-        i40e_aqc_opc_set_vsi_promiscuous_modes    = 0x0254,
-        i40e_aqc_opc_add_tag                      = 0x0255,
-        i40e_aqc_opc_remove_tag                   = 0x0256,
-        i40e_aqc_opc_add_multicast_etag           = 0x0257,
-        i40e_aqc_opc_remove_multicast_etag        = 0x0258,
-        i40e_aqc_opc_update_tag                   = 0x0259,
-        i40e_aqc_opc_add_control_packet_filter    = 0x025A,
-        i40e_aqc_opc_remove_control_packet_filter = 0x025B,
-        i40e_aqc_opc_add_cloud_filters            = 0x025C,
-        i40e_aqc_opc_remove_cloud_filters         = 0x025D,
-
-        i40e_aqc_opc_add_mirror_rule    = 0x0260,
-        i40e_aqc_opc_delete_mirror_rule = 0x0261,
+        i40e_aqc_opc_get_switch_config          = 0x0200,
+        i40e_aqc_opc_add_statistics             = 0x0201,
+        i40e_aqc_opc_remove_statistics          = 0x0202,
+        i40e_aqc_opc_set_port_parameters        = 0x0203,
+        i40e_aqc_opc_get_switch_resource_alloc  = 0x0204,
+
+        i40e_aqc_opc_add_vsi                    = 0x0210,
+        i40e_aqc_opc_update_vsi_parameters      = 0x0211,
+        i40e_aqc_opc_get_vsi_parameters         = 0x0212,
+
+        i40e_aqc_opc_add_pv                     = 0x0220,
+        i40e_aqc_opc_update_pv_parameters       = 0x0221,
+        i40e_aqc_opc_get_pv_parameters          = 0x0222,
+
+        i40e_aqc_opc_add_veb                    = 0x0230,
+        i40e_aqc_opc_update_veb_parameters      = 0x0231,
+        i40e_aqc_opc_get_veb_parameters         = 0x0232,
+
+        i40e_aqc_opc_delete_element             = 0x0243,
+
+        i40e_aqc_opc_add_macvlan                = 0x0250,
+        i40e_aqc_opc_remove_macvlan             = 0x0251,
+        i40e_aqc_opc_add_vlan                   = 0x0252,
+        i40e_aqc_opc_remove_vlan                = 0x0253,
+        i40e_aqc_opc_set_vsi_promiscuous_modes  = 0x0254,
+        i40e_aqc_opc_add_tag                    = 0x0255,
+        i40e_aqc_opc_remove_tag                 = 0x0256,
+        i40e_aqc_opc_add_multicast_etag         = 0x0257,
+        i40e_aqc_opc_remove_multicast_etag      = 0x0258,
+        i40e_aqc_opc_update_tag                 = 0x0259,
+        i40e_aqc_opc_add_control_packet_filter  = 0x025A,
+        i40e_aqc_opc_remove_control_packet_filter       = 0x025B,
+        i40e_aqc_opc_add_cloud_filters          = 0x025C,
+        i40e_aqc_opc_remove_cloud_filters       = 0x025D,
+
+        i40e_aqc_opc_add_mirror_rule    = 0x0260,
+        i40e_aqc_opc_delete_mirror_rule = 0x0261,
 
         /* DCB commands */
-        i40e_aqc_opc_dcb_ignore_pfc = 0x0301,
-        i40e_aqc_opc_dcb_updated    = 0x0302,
+        i40e_aqc_opc_dcb_ignore_pfc     = 0x0301,
+        i40e_aqc_opc_dcb_updated        = 0x0302,
 
         /* TX scheduler */
-        i40e_aqc_opc_configure_vsi_bw_limit            = 0x0400,
-        i40e_aqc_opc_configure_vsi_ets_sla_bw_limit    = 0x0406,
-        i40e_aqc_opc_configure_vsi_tc_bw               = 0x0407,
-        i40e_aqc_opc_query_vsi_bw_config               = 0x0408,
-        i40e_aqc_opc_query_vsi_ets_sla_config          = 0x040A,
-        i40e_aqc_opc_configure_switching_comp_bw_limit = 0x0410,
-
-        i40e_aqc_opc_enable_switching_comp_ets             = 0x0413,
-        i40e_aqc_opc_modify_switching_comp_ets             = 0x0414,
-        i40e_aqc_opc_disable_switching_comp_ets            = 0x0415,
-        i40e_aqc_opc_configure_switching_comp_ets_bw_limit = 0x0416,
-        i40e_aqc_opc_configure_switching_comp_bw_config    = 0x0417,
-        i40e_aqc_opc_query_switching_comp_ets_config       = 0x0418,
-        i40e_aqc_opc_query_port_ets_config                 = 0x0419,
-        i40e_aqc_opc_query_switching_comp_bw_config        = 0x041A,
-        i40e_aqc_opc_suspend_port_tx                       = 0x041B,
-        i40e_aqc_opc_resume_port_tx                        = 0x041C,
-        i40e_aqc_opc_configure_partition_bw                = 0x041D,
+        i40e_aqc_opc_configure_vsi_bw_limit             = 0x0400,
+        i40e_aqc_opc_configure_vsi_ets_sla_bw_limit     = 0x0406,
+        i40e_aqc_opc_configure_vsi_tc_bw                = 0x0407,
+        i40e_aqc_opc_query_vsi_bw_config                = 0x0408,
+        i40e_aqc_opc_query_vsi_ets_sla_config           = 0x040A,
+        i40e_aqc_opc_configure_switching_comp_bw_limit  = 0x0410,
+
+        i40e_aqc_opc_enable_switching_comp_ets                  = 0x0413,
+        i40e_aqc_opc_modify_switching_comp_ets                  = 0x0414,
+        i40e_aqc_opc_disable_switching_comp_ets                 = 0x0415,
+        i40e_aqc_opc_configure_switching_comp_ets_bw_limit      = 0x0416,
+        i40e_aqc_opc_configure_switching_comp_bw_config         = 0x0417,
+        i40e_aqc_opc_query_switching_comp_ets_config            = 0x0418,
+        i40e_aqc_opc_query_port_ets_config                      = 0x0419,
+        i40e_aqc_opc_query_switching_comp_bw_config             = 0x041A,
+        i40e_aqc_opc_suspend_port_tx                            = 0x041B,
+        i40e_aqc_opc_resume_port_tx                             = 0x041C,
+        i40e_aqc_opc_configure_partition_bw                     = 0x041D,
 
         /* hmc */
-        i40e_aqc_opc_query_hmc_resource_profile = 0x0500,
-        i40e_aqc_opc_set_hmc_resource_profile   = 0x0501,
+        i40e_aqc_opc_query_hmc_resource_profile = 0x0500,
+        i40e_aqc_opc_set_hmc_resource_profile   = 0x0501,
 
         /* phy commands*/
-        i40e_aqc_opc_get_phy_abilities   = 0x0600,
-        i40e_aqc_opc_set_phy_config      = 0x0601,
-        i40e_aqc_opc_set_mac_config      = 0x0603,
-        i40e_aqc_opc_set_link_restart_an = 0x0605,
-        i40e_aqc_opc_get_link_status     = 0x0607,
-        i40e_aqc_opc_set_phy_int_mask    = 0x0613,
-        i40e_aqc_opc_get_local_advt_reg  = 0x0614,
-        i40e_aqc_opc_set_local_advt_reg  = 0x0615,
-        i40e_aqc_opc_get_partner_advt    = 0x0616,
-        i40e_aqc_opc_set_lb_modes        = 0x0618,
-        i40e_aqc_opc_get_phy_wol_caps    = 0x0621,
-        i40e_aqc_opc_set_phy_debug       = 0x0622,
-        i40e_aqc_opc_upload_ext_phy_fm   = 0x0625,
+        i40e_aqc_opc_get_phy_abilities          = 0x0600,
+        i40e_aqc_opc_set_phy_config             = 0x0601,
+        i40e_aqc_opc_set_mac_config             = 0x0603,
+        i40e_aqc_opc_set_link_restart_an        = 0x0605,
+        i40e_aqc_opc_get_link_status            = 0x0607,
+        i40e_aqc_opc_set_phy_int_mask           = 0x0613,
+        i40e_aqc_opc_get_local_advt_reg         = 0x0614,
+        i40e_aqc_opc_set_local_advt_reg         = 0x0615,
+        i40e_aqc_opc_get_partner_advt           = 0x0616,
+        i40e_aqc_opc_set_lb_modes               = 0x0618,
+        i40e_aqc_opc_get_phy_wol_caps           = 0x0621,
+        i40e_aqc_opc_set_phy_debug              = 0x0622,
+        i40e_aqc_opc_upload_ext_phy_fm          = 0x0625,
 
         /* NVM commands */
-        i40e_aqc_opc_nvm_read         = 0x0701,
-        i40e_aqc_opc_nvm_erase        = 0x0702,
-        i40e_aqc_opc_nvm_update       = 0x0703,
-        i40e_aqc_opc_nvm_config_read  = 0x0704,
-        i40e_aqc_opc_nvm_config_write = 0x0705,
+        i40e_aqc_opc_nvm_read                   = 0x0701,
+        i40e_aqc_opc_nvm_erase                  = 0x0702,
+        i40e_aqc_opc_nvm_update                 = 0x0703,
+        i40e_aqc_opc_nvm_config_read            = 0x0704,
+        i40e_aqc_opc_nvm_config_write           = 0x0705,
 
         /* virtualization commands */
-        i40e_aqc_opc_send_msg_to_pf   = 0x0801,
-        i40e_aqc_opc_send_msg_to_vf   = 0x0802,
-        i40e_aqc_opc_send_msg_to_peer = 0x0803,
+        i40e_aqc_opc_send_msg_to_pf             = 0x0801,
+        i40e_aqc_opc_send_msg_to_vf             = 0x0802,
+        i40e_aqc_opc_send_msg_to_peer           = 0x0803,
 
         /* alternate structure */
-        i40e_aqc_opc_alternate_write          = 0x0900,
-        i40e_aqc_opc_alternate_write_indirect = 0x0901,
-        i40e_aqc_opc_alternate_read           = 0x0902,
-        i40e_aqc_opc_alternate_read_indirect  = 0x0903,
-        i40e_aqc_opc_alternate_write_done     = 0x0904,
-        i40e_aqc_opc_alternate_set_mode       = 0x0905,
-        i40e_aqc_opc_alternate_clear_port     = 0x0906,
+        i40e_aqc_opc_alternate_write            = 0x0900,
+        i40e_aqc_opc_alternate_write_indirect   = 0x0901,
+        i40e_aqc_opc_alternate_read             = 0x0902,
+        i40e_aqc_opc_alternate_read_indirect    = 0x0903,
+        i40e_aqc_opc_alternate_write_done       = 0x0904,
+        i40e_aqc_opc_alternate_set_mode         = 0x0905,
+        i40e_aqc_opc_alternate_clear_port       = 0x0906,
 
         /* LLDP commands */
-        i40e_aqc_opc_lldp_get_mib    = 0x0A00,
-        i40e_aqc_opc_lldp_update_mib = 0x0A01,
-        i40e_aqc_opc_lldp_add_tlv    = 0x0A02,
-        i40e_aqc_opc_lldp_update_tlv = 0x0A03,
-        i40e_aqc_opc_lldp_delete_tlv = 0x0A04,
-        i40e_aqc_opc_lldp_stop       = 0x0A05,
-        i40e_aqc_opc_lldp_start      = 0x0A06,
+        i40e_aqc_opc_lldp_get_mib       = 0x0A00,
+        i40e_aqc_opc_lldp_update_mib    = 0x0A01,
+        i40e_aqc_opc_lldp_add_tlv       = 0x0A02,
+        i40e_aqc_opc_lldp_update_tlv    = 0x0A03,
+        i40e_aqc_opc_lldp_delete_tlv    = 0x0A04,
+        i40e_aqc_opc_lldp_stop          = 0x0A05,
+        i40e_aqc_opc_lldp_start         = 0x0A06,
 
         /* Tunnel commands */
-        i40e_aqc_opc_add_udp_tunnel       = 0x0B00,
-        i40e_aqc_opc_del_udp_tunnel       = 0x0B01,
-        i40e_aqc_opc_tunnel_key_structure = 0x0B10,
+        i40e_aqc_opc_add_udp_tunnel     = 0x0B00,
+        i40e_aqc_opc_del_udp_tunnel     = 0x0B01,
+        i40e_aqc_opc_tunnel_key_structure       = 0x0B10,
 
         /* Async Events */
-        i40e_aqc_opc_event_lan_overflow = 0x1001,
+        i40e_aqc_opc_event_lan_overflow         = 0x1001,
 
         /* OEM commands */
-        i40e_aqc_opc_oem_parameter_change     = 0xFE00,
-        i40e_aqc_opc_oem_device_status_change = 0xFE01,
+        i40e_aqc_opc_oem_parameter_change       = 0xFE00,
+        i40e_aqc_opc_oem_device_status_change   = 0xFE01,
 
         /* debug commands */
-        i40e_aqc_opc_debug_get_deviceid     = 0xFF00,
-        i40e_aqc_opc_debug_set_mode         = 0xFF01,
-        i40e_aqc_opc_debug_read_reg         = 0xFF03,
-        i40e_aqc_opc_debug_write_reg        = 0xFF04,
-        i40e_aqc_opc_debug_modify_reg       = 0xFF07,
-        i40e_aqc_opc_debug_dump_internals   = 0xFF08,
-        i40e_aqc_opc_debug_modify_internals = 0xFF09,
+        i40e_aqc_opc_debug_get_deviceid         = 0xFF00,
+        i40e_aqc_opc_debug_set_mode             = 0xFF01,
+        i40e_aqc_opc_debug_read_reg             = 0xFF03,
+        i40e_aqc_opc_debug_write_reg            = 0xFF04,
+        i40e_aqc_opc_debug_modify_reg           = 0xFF07,
+        i40e_aqc_opc_debug_dump_internals       = 0xFF08,
+        i40e_aqc_opc_debug_modify_internals     = 0xFF09,
 };
 
 /* command structures and indirect data structures */
@@ -302,7 +302,7 @@ enum i40e_admin_queue_opc {
 /* This macro is used extensively to ensure that command structures are 16
  * bytes in length as they have to map to the raw array of that size.
  */
-#define I40E_CHECK_CMD_LENGTH(X) I40E_CHECK_STRUCT_LEN(16, X)
+#define I40E_CHECK_CMD_LENGTH(X)        I40E_CHECK_STRUCT_LEN(16, X)
 
 /* internal (0x00XX) commands */
 
@@ -320,22 +320,22 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_get_version);
 
 /* Send driver version (indirect 0x0002) */
 struct i40e_aqc_driver_version {
-        u8     driver_major_ver;
-        u8     driver_minor_ver;
-        u8     driver_build_ver;
-        u8     driver_subbuild_ver;
-        u8     reserved[4];
-        __le32 address_high;
-        __le32 address_low;
+        u8      driver_major_ver;
+        u8      driver_minor_ver;
+        u8      driver_build_ver;
+        u8      driver_subbuild_ver;
+        u8      reserved[4];
+        __le32  address_high;
+        __le32  address_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_driver_version);
 
 /* Queue Shutdown (direct 0x0003) */
 struct i40e_aqc_queue_shutdown {
-        __le32     driver_unloading;
-#define I40E_AQ_DRIVER_UNLOADING    0x1
-        u8     reserved[12];
+        __le32  driver_unloading;
+#define I40E_AQ_DRIVER_UNLOADING        0x1
+        u8      reserved[12];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_queue_shutdown);
@@ -351,19 +351,19 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_set_pf_context);
 /* Request resource ownership (direct 0x0008)
  * Release resource ownership (direct 0x0009)
  */
-#define I40E_AQ_RESOURCE_NVM               1
-#define I40E_AQ_RESOURCE_SDP               2
-#define I40E_AQ_RESOURCE_ACCESS_READ       1
-#define I40E_AQ_RESOURCE_ACCESS_WRITE      2
-#define I40E_AQ_RESOURCE_NVM_READ_TIMEOUT  3000
-#define I40E_AQ_RESOURCE_NVM_WRITE_TIMEOUT 180000
+#define I40E_AQ_RESOURCE_NVM                    1
+#define I40E_AQ_RESOURCE_SDP                    2
+#define I40E_AQ_RESOURCE_ACCESS_READ            1
+#define I40E_AQ_RESOURCE_ACCESS_WRITE           2
+#define I40E_AQ_RESOURCE_NVM_READ_TIMEOUT       3000
+#define I40E_AQ_RESOURCE_NVM_WRITE_TIMEOUT      180000
 
 struct i40e_aqc_request_resource {
-        __le16 resource_id;
-        __le16 access_type;
-        __le32 timeout;
-        __le32 resource_number;
-        u8     reserved[4];
+        __le16  resource_id;
+        __le16  access_type;
+        __le32  timeout;
+        __le32  resource_number;
+        u8      reserved[4];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_request_resource);
@@ -373,7 +373,7 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_request_resource);
  */
 struct i40e_aqc_list_capabilites {
         u8 command_flags;
-#define I40E_AQ_LIST_CAP_PF_INDEX_EN     1
+#define I40E_AQ_LIST_CAP_PF_INDEX_EN    1
         u8 pf_index;
         u8 reserved[2];
         __le32 count;
@@ -384,123 +384,123 @@ struct i40e_aqc_list_capabilites {
 I40E_CHECK_CMD_LENGTH(i40e_aqc_list_capabilites);
 
 struct i40e_aqc_list_capabilities_element_resp {
-        __le16 id;
-        u8     major_rev;
-        u8     minor_rev;
-        __le32 number;
-        __le32 logical_id;
-        __le32 phys_id;
-        u8     reserved[16];
+        __le16  id;
+        u8      major_rev;
+        u8      minor_rev;
+        __le32  number;
+        __le32  logical_id;
+        __le32  phys_id;
+        u8      reserved[16];
 };
 
 /* list of caps */
 
-#define I40E_AQ_CAP_ID_SWITCH_MODE      0x0001
-#define I40E_AQ_CAP_ID_MNG_MODE         0x0002
-#define I40E_AQ_CAP_ID_NPAR_ACTIVE      0x0003
-#define I40E_AQ_CAP_ID_OS2BMC_CAP       0x0004
-#define I40E_AQ_CAP_ID_FUNCTIONS_VALID  0x0005
-#define I40E_AQ_CAP_ID_ALTERNATE_RAM    0x0006
-#define I40E_AQ_CAP_ID_SRIOV            0x0012
-#define I40E_AQ_CAP_ID_VF               0x0013
-#define I40E_AQ_CAP_ID_VMDQ             0x0014
-#define I40E_AQ_CAP_ID_8021QBG          0x0015
-#define I40E_AQ_CAP_ID_8021QBR          0x0016
-#define I40E_AQ_CAP_ID_VSI              0x0017
-#define I40E_AQ_CAP_ID_DCB              0x0018
-#define I40E_AQ_CAP_ID_FCOE             0x0021
-#define I40E_AQ_CAP_ID_RSS              0x0040
-#define I40E_AQ_CAP_ID_RXQ              0x0041
-#define I40E_AQ_CAP_ID_TXQ              0x0042
-#define I40E_AQ_CAP_ID_MSIX             0x0043
-#define I40E_AQ_CAP_ID_VF_MSIX          0x0044
-#define I40E_AQ_CAP_ID_FLOW_DIRECTOR    0x0045
-#define I40E_AQ_CAP_ID_1588             0x0046
-#define I40E_AQ_CAP_ID_IWARP            0x0051
-#define I40E_AQ_CAP_ID_LED              0x0061
-#define I40E_AQ_CAP_ID_SDP              0x0062
-#define I40E_AQ_CAP_ID_MDIO             0x0063
-#define I40E_AQ_CAP_ID_FLEX10           0x00F1
-#define I40E_AQ_CAP_ID_CEM              0x00F2
+#define I40E_AQ_CAP_ID_SWITCH_MODE      0x0001
+#define I40E_AQ_CAP_ID_MNG_MODE         0x0002
+#define I40E_AQ_CAP_ID_NPAR_ACTIVE      0x0003
+#define I40E_AQ_CAP_ID_OS2BMC_CAP       0x0004
+#define I40E_AQ_CAP_ID_FUNCTIONS_VALID  0x0005
+#define I40E_AQ_CAP_ID_ALTERNATE_RAM    0x0006
+#define I40E_AQ_CAP_ID_SRIOV            0x0012
+#define I40E_AQ_CAP_ID_VF               0x0013
+#define I40E_AQ_CAP_ID_VMDQ             0x0014
+#define I40E_AQ_CAP_ID_8021QBG          0x0015
+#define I40E_AQ_CAP_ID_8021QBR          0x0016
+#define I40E_AQ_CAP_ID_VSI              0x0017
+#define I40E_AQ_CAP_ID_DCB              0x0018
+#define I40E_AQ_CAP_ID_FCOE             0x0021
+#define I40E_AQ_CAP_ID_RSS              0x0040
+#define I40E_AQ_CAP_ID_RXQ              0x0041
+#define I40E_AQ_CAP_ID_TXQ              0x0042
+#define I40E_AQ_CAP_ID_MSIX             0x0043
+#define I40E_AQ_CAP_ID_VF_MSIX          0x0044
+#define I40E_AQ_CAP_ID_FLOW_DIRECTOR    0x0045
+#define I40E_AQ_CAP_ID_1588             0x0046
+#define I40E_AQ_CAP_ID_IWARP            0x0051
+#define I40E_AQ_CAP_ID_LED              0x0061
+#define I40E_AQ_CAP_ID_SDP              0x0062
+#define I40E_AQ_CAP_ID_MDIO             0x0063
+#define I40E_AQ_CAP_ID_FLEX10           0x00F1
+#define I40E_AQ_CAP_ID_CEM              0x00F2
 
 /* Set CPPM Configuration (direct 0x0103) */
 struct i40e_aqc_cppm_configuration {
-        __le16 command_flags;
-#define I40E_AQ_CPPM_EN_LTRC    0x0800
-#define I40E_AQ_CPPM_EN_DMCTH   0x1000
-#define I40E_AQ_CPPM_EN_DMCTLX  0x2000
-#define I40E_AQ_CPPM_EN_HPTC    0x4000
-#define I40E_AQ_CPPM_EN_DMARC   0x8000
-        __le16 ttlx;
-        __le32 dmacr;
-        __le16 dmcth;
-        u8     hptc;
-        u8     reserved;
-        __le32 pfltrc;
+        __le16  command_flags;
+#define I40E_AQ_CPPM_EN_LTRC    0x0800
+#define I40E_AQ_CPPM_EN_DMCTH   0x1000
+#define I40E_AQ_CPPM_EN_DMCTLX  0x2000
+#define I40E_AQ_CPPM_EN_HPTC    0x4000
+#define I40E_AQ_CPPM_EN_DMARC   0x8000
+        __le16  ttlx;
+        __le32  dmacr;
+        __le16  dmcth;
+        u8      hptc;
+        u8      reserved;
+        __le32  pfltrc;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_cppm_configuration);
 
 /* Set ARP Proxy command / response (indirect 0x0104) */
 struct i40e_aqc_arp_proxy_data {
-        __le16 command_flags;
-#define I40E_AQ_ARP_INIT_IPV4           0x0008
-#define I40E_AQ_ARP_UNSUP_CTL           0x0010
-#define I40E_AQ_ARP_ENA                 0x0020
-#define I40E_AQ_ARP_ADD_IPV4            0x0040
-#define I40E_AQ_ARP_DEL_IPV4            0x0080
-        __le16 table_id;
-        __le32 pfpm_proxyfc;
-        __le32 ip_addr;
-        u8     mac_addr[6];
+        __le16  command_flags;
+#define I40E_AQ_ARP_INIT_IPV4   0x0008
+#define I40E_AQ_ARP_UNSUP_CTL   0x0010
+#define I40E_AQ_ARP_ENA         0x0020
+#define I40E_AQ_ARP_ADD_IPV4    0x0040
+#define I40E_AQ_ARP_DEL_IPV4    0x0080
+        __le16  table_id;
+        __le32  pfpm_proxyfc;
+        __le32  ip_addr;
+        u8      mac_addr[6];
 };
 
 /* Set NS Proxy Table Entry Command (indirect 0x0105) */
 struct i40e_aqc_ns_proxy_data {
-        __le16 table_idx_mac_addr_0;
-        __le16 table_idx_mac_addr_1;
-        __le16 table_idx_ipv6_0;
-        __le16 table_idx_ipv6_1;
-        __le16 control;
-#define I40E_AQ_NS_PROXY_ADD_0             0x0100
-#define I40E_AQ_NS_PROXY_DEL_0             0x0200
-#define I40E_AQ_NS_PROXY_ADD_1             0x0400
-#define I40E_AQ_NS_PROXY_DEL_1             0x0800
-#define I40E_AQ_NS_PROXY_ADD_IPV6_0        0x1000
-#define I40E_AQ_NS_PROXY_DEL_IPV6_0        0x2000
-#define I40E_AQ_NS_PROXY_ADD_IPV6_1        0x4000
-#define I40E_AQ_NS_PROXY_DEL_IPV6_1        0x8000
-#define I40E_AQ_NS_PROXY_COMMAND_SEQ       0x0001
-#define I40E_AQ_NS_PROXY_INIT_IPV6_TBL     0x0002
-#define I40E_AQ_NS_PROXY_INIT_MAC_TBL      0x0004
-        u8     mac_addr_0[6];
-        u8     mac_addr_1[6];
-        u8     local_mac_addr[6];
-        u8     ipv6_addr_0[16]; /* Warning! spec specifies BE byte order */
-        u8     ipv6_addr_1[16];
+        __le16  table_idx_mac_addr_0;
+        __le16  table_idx_mac_addr_1;
+        __le16  table_idx_ipv6_0;
+        __le16  table_idx_ipv6_1;
+        __le16  control;
+#define I40E_AQ_NS_PROXY_ADD_0          0x0100
+#define I40E_AQ_NS_PROXY_DEL_0          0x0200
+#define I40E_AQ_NS_PROXY_ADD_1          0x0400
+#define I40E_AQ_NS_PROXY_DEL_1          0x0800
+#define I40E_AQ_NS_PROXY_ADD_IPV6_0     0x1000
+#define I40E_AQ_NS_PROXY_DEL_IPV6_0     0x2000
+#define I40E_AQ_NS_PROXY_ADD_IPV6_1     0x4000
+#define I40E_AQ_NS_PROXY_DEL_IPV6_1     0x8000
+#define I40E_AQ_NS_PROXY_COMMAND_SEQ    0x0001
+#define I40E_AQ_NS_PROXY_INIT_IPV6_TBL  0x0002
+#define I40E_AQ_NS_PROXY_INIT_MAC_TBL   0x0004
+        u8      mac_addr_0[6];
+        u8      mac_addr_1[6];
+        u8      local_mac_addr[6];
+        u8      ipv6_addr_0[16]; /* Warning! spec specifies BE byte order */
+        u8      ipv6_addr_1[16];
 };
 
 /* Manage LAA Command (0x0106) - obsolete */
 struct i40e_aqc_mng_laa {
         __le16  command_flags;
-#define I40E_AQ_LAA_FLAG_WR   0x8000
-        u8     reserved[2];
-        __le32 sal;
-        __le16 sah;
-        u8     reserved2[6];
+#define I40E_AQ_LAA_FLAG_WR     0x8000
+        u8      reserved[2];
+        __le32  sal;
+        __le16  sah;
+        u8      reserved2[6];
 };
 
 /* Manage MAC Address Read Command (indirect 0x0107) */
 struct i40e_aqc_mac_address_read {
         __le16  command_flags;
-#define I40E_AQC_LAN_ADDR_VALID   0x10
-#define I40E_AQC_SAN_ADDR_VALID   0x20
-#define I40E_AQC_PORT_ADDR_VALID  0x40
-#define I40E_AQC_WOL_ADDR_VALID   0x80
-#define I40E_AQC_ADDR_VALID_MASK  0xf0
-        u8     reserved[6];
-        __le32 addr_high;
-        __le32 addr_low;
+#define I40E_AQC_LAN_ADDR_VALID         0x10
+#define I40E_AQC_SAN_ADDR_VALID         0x20
+#define I40E_AQC_PORT_ADDR_VALID        0x40
+#define I40E_AQC_WOL_ADDR_VALID         0x80
+#define I40E_AQC_ADDR_VALID_MASK        0xf0
+        u8      reserved[6];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_mac_address_read);
@@ -516,14 +516,14 @@ I40E_CHECK_STRUCT_LEN(24, i40e_aqc_mac_address_read_data);
 
 /* Manage MAC Address Write Command (0x0108) */
 struct i40e_aqc_mac_address_write {
-        __le16 command_flags;
-#define I40E_AQC_WRITE_TYPE_LAA_ONLY    0x0000
-#define I40E_AQC_WRITE_TYPE_LAA_WOL     0x4000
-#define I40E_AQC_WRITE_TYPE_PORT        0x8000
-#define I40E_AQC_WRITE_TYPE_MASK        0xc000
-        __le16 mac_sah;
-        __le32 mac_sal;
-        u8     reserved[8];
+        __le16  command_flags;
+#define I40E_AQC_WRITE_TYPE_LAA_ONLY    0x0000
+#define I40E_AQC_WRITE_TYPE_LAA_WOL     0x4000
+#define I40E_AQC_WRITE_TYPE_PORT        0x8000
+#define I40E_AQC_WRITE_TYPE_MASK        0xc000
+        __le16  mac_sah;
+        __le32  mac_sal;
+        u8      reserved[8];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_mac_address_write);
@@ -544,10 +544,10 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_clear_pxe);
  * command
  */
 struct i40e_aqc_switch_seid {
-        __le16 seid;
-        u8     reserved[6];
-        __le32 addr_high;
-        __le32 addr_low;
+        __le16  seid;
+        u8      reserved[6];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_switch_seid);
@@ -556,34 +556,34 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_switch_seid);
  * uses i40e_aqc_switch_seid for the descriptor
  */
 struct i40e_aqc_get_switch_config_header_resp {
-        __le16 num_reported;
-        __le16 num_total;
-        u8     reserved[12];
+        __le16  num_reported;
+        __le16  num_total;
+        u8      reserved[12];
 };
 
 struct i40e_aqc_switch_config_element_resp {
-        u8     element_type;
-#define I40E_AQ_SW_ELEM_TYPE_MAC        1
-#define I40E_AQ_SW_ELEM_TYPE_PF         2
-#define I40E_AQ_SW_ELEM_TYPE_VF         3
-#define I40E_AQ_SW_ELEM_TYPE_EMP        4
-#define I40E_AQ_SW_ELEM_TYPE_BMC        5
-#define I40E_AQ_SW_ELEM_TYPE_PV         16
-#define I40E_AQ_SW_ELEM_TYPE_VEB        17
-#define I40E_AQ_SW_ELEM_TYPE_PA         18
-#define I40E_AQ_SW_ELEM_TYPE_VSI        19
-        u8     revision;
-#define I40E_AQ_SW_ELEM_REV_1           1
-        __le16 seid;
-        __le16 uplink_seid;
-        __le16 downlink_seid;
-        u8     reserved[3];
-        u8     connection_type;
-#define I40E_AQ_CONN_TYPE_REGULAR       0x1
-#define I40E_AQ_CONN_TYPE_DEFAULT       0x2
-#define I40E_AQ_CONN_TYPE_CASCADED      0x3
-        __le16 scheduler_id;
-        __le16 element_info;
+        u8      element_type;
+#define I40E_AQ_SW_ELEM_TYPE_MAC        1
+#define I40E_AQ_SW_ELEM_TYPE_PF         2
+#define I40E_AQ_SW_ELEM_TYPE_VF         3
+#define I40E_AQ_SW_ELEM_TYPE_EMP        4
+#define I40E_AQ_SW_ELEM_TYPE_BMC        5
+#define I40E_AQ_SW_ELEM_TYPE_PV         16
+#define I40E_AQ_SW_ELEM_TYPE_VEB        17
+#define I40E_AQ_SW_ELEM_TYPE_PA         18
+#define I40E_AQ_SW_ELEM_TYPE_VSI        19
+        u8      revision;
+#define I40E_AQ_SW_ELEM_REV_1           1
+        __le16  seid;
+        __le16  uplink_seid;
+        __le16  downlink_seid;
+        u8      reserved[3];
+        u8      connection_type;
+#define I40E_AQ_CONN_TYPE_REGULAR       0x1
+#define I40E_AQ_CONN_TYPE_DEFAULT       0x2
+#define I40E_AQ_CONN_TYPE_CASCADED      0x3
+        __le16  scheduler_id;
+        __le16  element_info;
 };
 
 /* Get Switch Configuration (indirect 0x0200)
@@ -591,73 +591,73 @@ struct i40e_aqc_switch_config_element_resp {
  *    the first in the array is the header, remainder are elements
  */
 struct i40e_aqc_get_switch_config_resp {
-        struct i40e_aqc_get_switch_config_header_resp header;
-        struct i40e_aqc_switch_config_element_resp    element[1];
+        struct i40e_aqc_get_switch_config_header_resp   header;
+        struct i40e_aqc_switch_config_element_resp      element[1];
 };
 
 /* Add Statistics (direct 0x0201)
  * Remove Statistics (direct 0x0202)
  */
 struct i40e_aqc_add_remove_statistics {
-        __le16 seid;
-        __le16 vlan;
-        __le16 stat_index;
-        u8     reserved[10];
+        __le16  seid;
+        __le16  vlan;
+        __le16  stat_index;
+        u8      reserved[10];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_statistics);
 
 /* Set Port Parameters command (direct 0x0203) */
 struct i40e_aqc_set_port_parameters {
-        __le16 command_flags;
-#define I40E_AQ_SET_P_PARAMS_SAVE_BAD_PACKETS   1
-#define I40E_AQ_SET_P_PARAMS_PAD_SHORT_PACKETS  2 /* must set! */
-#define I40E_AQ_SET_P_PARAMS_DOUBLE_VLAN_ENA    4
-        __le16 bad_frame_vsi;
-        __le16 default_seid;        /* reserved for command */
-        u8     reserved[10];
+        __le16  command_flags;
+#define I40E_AQ_SET_P_PARAMS_SAVE_BAD_PACKETS   1
+#define I40E_AQ_SET_P_PARAMS_PAD_SHORT_PACKETS  2 /* must set! */
+#define I40E_AQ_SET_P_PARAMS_DOUBLE_VLAN_ENA    4
+        __le16  bad_frame_vsi;
+        __le16  default_seid;        /* reserved for command */
+        u8      reserved[10];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_set_port_parameters);
 
 /* Get Switch Resource Allocation (indirect 0x0204) */
 struct i40e_aqc_get_switch_resource_alloc {
-        u8     num_entries;         /* reserved for command */
-        u8     reserved[7];
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      num_entries;         /* reserved for command */
+        u8      reserved[7];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_get_switch_resource_alloc);
 
 /* expect an array of these structs in the response buffer */
 struct i40e_aqc_switch_resource_alloc_element_resp {
-        u8     resource_type;
-#define I40E_AQ_RESOURCE_TYPE_VEB                 0x0
-#define I40E_AQ_RESOURCE_TYPE_VSI                 0x1
-#define I40E_AQ_RESOURCE_TYPE_MACADDR             0x2
-#define I40E_AQ_RESOURCE_TYPE_STAG                0x3
-#define I40E_AQ_RESOURCE_TYPE_ETAG                0x4
-#define I40E_AQ_RESOURCE_TYPE_MULTICAST_HASH      0x5
-#define I40E_AQ_RESOURCE_TYPE_UNICAST_HASH        0x6
-#define I40E_AQ_RESOURCE_TYPE_VLAN                0x7
-#define I40E_AQ_RESOURCE_TYPE_VSI_LIST_ENTRY      0x8
-#define I40E_AQ_RESOURCE_TYPE_ETAG_LIST_ENTRY     0x9
-#define I40E_AQ_RESOURCE_TYPE_VLAN_STAT_POOL      0xA
-#define I40E_AQ_RESOURCE_TYPE_MIRROR_RULE         0xB
-#define I40E_AQ_RESOURCE_TYPE_QUEUE_SETS          0xC
-#define I40E_AQ_RESOURCE_TYPE_VLAN_FILTERS        0xD
-#define I40E_AQ_RESOURCE_TYPE_INNER_MAC_FILTERS   0xF
-#define I40E_AQ_RESOURCE_TYPE_IP_FILTERS          0x10
-#define I40E_AQ_RESOURCE_TYPE_GRE_VN_KEYS         0x11
-#define I40E_AQ_RESOURCE_TYPE_VN2_KEYS            0x12
-#define I40E_AQ_RESOURCE_TYPE_TUNNEL_PORTS        0x13
-        u8     reserved1;
-        __le16 guaranteed;
-        __le16 total;
-        __le16 used;
-        __le16 total_unalloced;
-        u8     reserved2[6];
+        u8      resource_type;
+#define I40E_AQ_RESOURCE_TYPE_VEB               0x0
+#define I40E_AQ_RESOURCE_TYPE_VSI               0x1
+#define I40E_AQ_RESOURCE_TYPE_MACADDR           0x2
+#define I40E_AQ_RESOURCE_TYPE_STAG              0x3
+#define I40E_AQ_RESOURCE_TYPE_ETAG              0x4
+#define I40E_AQ_RESOURCE_TYPE_MULTICAST_HASH    0x5
+#define I40E_AQ_RESOURCE_TYPE_UNICAST_HASH      0x6
+#define I40E_AQ_RESOURCE_TYPE_VLAN              0x7
+#define I40E_AQ_RESOURCE_TYPE_VSI_LIST_ENTRY    0x8
+#define I40E_AQ_RESOURCE_TYPE_ETAG_LIST_ENTRY   0x9
+#define I40E_AQ_RESOURCE_TYPE_VLAN_STAT_POOL    0xA
+#define I40E_AQ_RESOURCE_TYPE_MIRROR_RULE       0xB
+#define I40E_AQ_RESOURCE_TYPE_QUEUE_SETS        0xC
+#define I40E_AQ_RESOURCE_TYPE_VLAN_FILTERS      0xD
+#define I40E_AQ_RESOURCE_TYPE_INNER_MAC_FILTERS 0xF
+#define I40E_AQ_RESOURCE_TYPE_IP_FILTERS        0x10
+#define I40E_AQ_RESOURCE_TYPE_GRE_VN_KEYS       0x11
+#define I40E_AQ_RESOURCE_TYPE_VN2_KEYS          0x12
+#define I40E_AQ_RESOURCE_TYPE_TUNNEL_PORTS      0x13
+        u8      reserved1;
+        __le16  guaranteed;
+        __le16  total;
+        __le16  used;
+        __le16  total_unalloced;
+        u8      reserved2[6];
 };
 
 /* Add VSI (indirect 0x0210)
@@ -671,24 +671,24 @@ struct i40e_aqc_switch_resource_alloc_element_resp {
  *     uses the same completion and data structure as Add VSI
  */
 struct i40e_aqc_add_get_update_vsi {
-        __le16 uplink_seid;
-        u8     connection_type;
-#define I40E_AQ_VSI_CONN_TYPE_NORMAL            0x1
-#define I40E_AQ_VSI_CONN_TYPE_DEFAULT           0x2
-#define I40E_AQ_VSI_CONN_TYPE_CASCADED          0x3
-        u8     reserved1;
-        u8     vf_id;
-        u8     reserved2;
-        __le16 vsi_flags;
-#define I40E_AQ_VSI_TYPE_SHIFT          0x0
-#define I40E_AQ_VSI_TYPE_MASK           (0x3 << I40E_AQ_VSI_TYPE_SHIFT)
-#define I40E_AQ_VSI_TYPE_VF             0x0
-#define I40E_AQ_VSI_TYPE_VMDQ2          0x1
-#define I40E_AQ_VSI_TYPE_PF             0x2
-#define I40E_AQ_VSI_TYPE_EMP_MNG        0x3
-#define I40E_AQ_VSI_FLAG_CASCADED_PV    0x4
-        __le32 addr_high;
-        __le32 addr_low;
+        __le16  uplink_seid;
+        u8      connection_type;
+#define I40E_AQ_VSI_CONN_TYPE_NORMAL    0x1
+#define I40E_AQ_VSI_CONN_TYPE_DEFAULT   0x2
+#define I40E_AQ_VSI_CONN_TYPE_CASCADED  0x3
+        u8      reserved1;
+        u8      vf_id;
+        u8      reserved2;
+        __le16  vsi_flags;
+#define I40E_AQ_VSI_TYPE_SHIFT          0x0
+#define I40E_AQ_VSI_TYPE_MASK           (0x3 << I40E_AQ_VSI_TYPE_SHIFT)
+#define I40E_AQ_VSI_TYPE_VF             0x0
+#define I40E_AQ_VSI_TYPE_VMDQ2          0x1
+#define I40E_AQ_VSI_TYPE_PF             0x2
+#define I40E_AQ_VSI_TYPE_EMP_MNG        0x3
+#define I40E_AQ_VSI_FLAG_CASCADED_PV    0x4
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_get_update_vsi);
@@ -706,121 +706,121 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_add_get_update_vsi_completion);
 
 struct i40e_aqc_vsi_properties_data {
         /* first 96 byte are written by SW */
-        __le16 valid_sections;
-#define I40E_AQ_VSI_PROP_SWITCH_VALID       0x0001
-#define I40E_AQ_VSI_PROP_SECURITY_VALID     0x0002
-#define I40E_AQ_VSI_PROP_VLAN_VALID         0x0004
-#define I40E_AQ_VSI_PROP_CAS_PV_VALID       0x0008
-#define I40E_AQ_VSI_PROP_INGRESS_UP_VALID   0x0010
-#define I40E_AQ_VSI_PROP_EGRESS_UP_VALID    0x0020
-#define I40E_AQ_VSI_PROP_QUEUE_MAP_VALID    0x0040
-#define I40E_AQ_VSI_PROP_QUEUE_OPT_VALID    0x0080
-#define I40E_AQ_VSI_PROP_OUTER_UP_VALID     0x0100
-#define I40E_AQ_VSI_PROP_SCHED_VALID        0x0200
+        __le16  valid_sections;
+#define I40E_AQ_VSI_PROP_SWITCH_VALID           0x0001
+#define I40E_AQ_VSI_PROP_SECURITY_VALID         0x0002
+#define I40E_AQ_VSI_PROP_VLAN_VALID             0x0004
+#define I40E_AQ_VSI_PROP_CAS_PV_VALID           0x0008
+#define I40E_AQ_VSI_PROP_INGRESS_UP_VALID       0x0010
+#define I40E_AQ_VSI_PROP_EGRESS_UP_VALID        0x0020
+#define I40E_AQ_VSI_PROP_QUEUE_MAP_VALID        0x0040
+#define I40E_AQ_VSI_PROP_QUEUE_OPT_VALID        0x0080
+#define I40E_AQ_VSI_PROP_OUTER_UP_VALID         0x0100
+#define I40E_AQ_VSI_PROP_SCHED_VALID            0x0200
         /* switch section */
-        __le16 switch_id; /* 12bit id combined with flags below */
-#define I40E_AQ_VSI_SW_ID_SHIFT             0x0000
-#define I40E_AQ_VSI_SW_ID_MASK              (0xFFF << I40E_AQ_VSI_SW_ID_SHIFT)
-#define I40E_AQ_VSI_SW_ID_FLAG_NOT_STAG     0x1000
-#define I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB     0x2000
-#define I40E_AQ_VSI_SW_ID_FLAG_LOCAL_LB     0x4000
-        u8     sw_reserved[2];
+        __le16  switch_id; /* 12bit id combined with flags below */
+#define I40E_AQ_VSI_SW_ID_SHIFT         0x0000
+#define I40E_AQ_VSI_SW_ID_MASK          (0xFFF << I40E_AQ_VSI_SW_ID_SHIFT)
+#define I40E_AQ_VSI_SW_ID_FLAG_NOT_STAG 0x1000
+#define I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB 0x2000
+#define I40E_AQ_VSI_SW_ID_FLAG_LOCAL_LB 0x4000
+        u8      sw_reserved[2];
         /* security section */
-        u8     sec_flags;
-#define I40E_AQ_VSI_SEC_FLAG_ALLOW_DEST_OVRD    0x01
-#define I40E_AQ_VSI_SEC_FLAG_ENABLE_VLAN_CHK    0x02
-#define I40E_AQ_VSI_SEC_FLAG_ENABLE_MAC_CHK     0x04
-        u8     sec_reserved;
+        u8      sec_flags;
+#define I40E_AQ_VSI_SEC_FLAG_ALLOW_DEST_OVRD    0x01
+#define I40E_AQ_VSI_SEC_FLAG_ENABLE_VLAN_CHK    0x02
+#define I40E_AQ_VSI_SEC_FLAG_ENABLE_MAC_CHK     0x04
+        u8      sec_reserved;
         /* VLAN section */
-        __le16 pvid; /* VLANS include priority bits */
-        __le16 fcoe_pvid;
-        u8     port_vlan_flags;
-#define I40E_AQ_VSI_PVLAN_MODE_SHIFT        0x00
-#define I40E_AQ_VSI_PVLAN_MODE_MASK         (0x03 << \
-                                                I40E_AQ_VSI_PVLAN_MODE_SHIFT)
-#define I40E_AQ_VSI_PVLAN_MODE_TAGGED       0x01
-#define I40E_AQ_VSI_PVLAN_MODE_UNTAGGED     0x02
-#define I40E_AQ_VSI_PVLAN_MODE_ALL          0x03
-#define I40E_AQ_VSI_PVLAN_INSERT_PVID       0x04
-#define I40E_AQ_VSI_PVLAN_EMOD_SHIFT        0x03
-#define I40E_AQ_VSI_PVLAN_EMOD_MASK         (0x3 << \
-                                        I40E_AQ_VSI_PVLAN_EMOD_SHIFT)
-#define I40E_AQ_VSI_PVLAN_EMOD_STR_BOTH     0x0
-#define I40E_AQ_VSI_PVLAN_EMOD_STR_UP       0x08
-#define I40E_AQ_VSI_PVLAN_EMOD_STR          0x10
-#define I40E_AQ_VSI_PVLAN_EMOD_NOTHING      0x18
-        u8     pvlan_reserved[3];
+        __le16  pvid; /* VLANS include priority bits */
+        __le16  fcoe_pvid;
+        u8      port_vlan_flags;
+#define I40E_AQ_VSI_PVLAN_MODE_SHIFT    0x00
+#define I40E_AQ_VSI_PVLAN_MODE_MASK     (0x03 << \
+                                         I40E_AQ_VSI_PVLAN_MODE_SHIFT)
+#define I40E_AQ_VSI_PVLAN_MODE_TAGGED   0x01
+#define I40E_AQ_VSI_PVLAN_MODE_UNTAGGED 0x02
+#define I40E_AQ_VSI_PVLAN_MODE_ALL      0x03
+#define I40E_AQ_VSI_PVLAN_INSERT_PVID   0x04
+#define I40E_AQ_VSI_PVLAN_EMOD_SHIFT    0x03
+#define I40E_AQ_VSI_PVLAN_EMOD_MASK     (0x3 << \
+                                         I40E_AQ_VSI_PVLAN_EMOD_SHIFT)
+#define I40E_AQ_VSI_PVLAN_EMOD_STR_BOTH 0x0
+#define I40E_AQ_VSI_PVLAN_EMOD_STR_UP   0x08
+#define I40E_AQ_VSI_PVLAN_EMOD_STR      0x10
+#define I40E_AQ_VSI_PVLAN_EMOD_NOTHING  0x18
+        u8      pvlan_reserved[3];
         /* ingress egress up sections */
-        __le32 ingress_table; /* bitmap, 3 bits per up */
-#define I40E_AQ_VSI_UP_TABLE_UP0_SHIFT      0
-#define I40E_AQ_VSI_UP_TABLE_UP0_MASK       (0x7 << \
-                                        I40E_AQ_VSI_UP_TABLE_UP0_SHIFT)
-#define I40E_AQ_VSI_UP_TABLE_UP1_SHIFT      3
-#define I40E_AQ_VSI_UP_TABLE_UP1_MASK       (0x7 << \
-                                        I40E_AQ_VSI_UP_TABLE_UP1_SHIFT)
-#define I40E_AQ_VSI_UP_TABLE_UP2_SHIFT      6
-#define I40E_AQ_VSI_UP_TABLE_UP2_MASK       (0x7 << \
-                                        I40E_AQ_VSI_UP_TABLE_UP2_SHIFT)
-#define I40E_AQ_VSI_UP_TABLE_UP3_SHIFT      9
-#define I40E_AQ_VSI_UP_TABLE_UP3_MASK       (0x7 << \
-                                        I40E_AQ_VSI_UP_TABLE_UP3_SHIFT)
-#define I40E_AQ_VSI_UP_TABLE_UP4_SHIFT      12
-#define I40E_AQ_VSI_UP_TABLE_UP4_MASK       (0x7 << \
-                                        I40E_AQ_VSI_UP_TABLE_UP4_SHIFT)
-#define I40E_AQ_VSI_UP_TABLE_UP5_SHIFT      15
-#define I40E_AQ_VSI_UP_TABLE_UP5_MASK       (0x7 << \
-                                        I40E_AQ_VSI_UP_TABLE_UP5_SHIFT)
-#define I40E_AQ_VSI_UP_TABLE_UP6_SHIFT      18
-#define I40E_AQ_VSI_UP_TABLE_UP6_MASK       (0x7 << \
-                                        I40E_AQ_VSI_UP_TABLE_UP6_SHIFT)
-#define I40E_AQ_VSI_UP_TABLE_UP7_SHIFT      21
-#define I40E_AQ_VSI_UP_TABLE_UP7_MASK       (0x7 << \
-                                        I40E_AQ_VSI_UP_TABLE_UP7_SHIFT)
-        __le32 egress_table;   /* same defines as for ingress table */
+        __le32  ingress_table; /* bitmap, 3 bits per up */
+#define I40E_AQ_VSI_UP_TABLE_UP0_SHIFT  0
+#define I40E_AQ_VSI_UP_TABLE_UP0_MASK   (0x7 << \
+                                         I40E_AQ_VSI_UP_TABLE_UP0_SHIFT)
+#define I40E_AQ_VSI_UP_TABLE_UP1_SHIFT  3
+#define I40E_AQ_VSI_UP_TABLE_UP1_MASK   (0x7 << \
+                                         I40E_AQ_VSI_UP_TABLE_UP1_SHIFT)
+#define I40E_AQ_VSI_UP_TABLE_UP2_SHIFT  6
+#define I40E_AQ_VSI_UP_TABLE_UP2_MASK   (0x7 << \
+                                         I40E_AQ_VSI_UP_TABLE_UP2_SHIFT)
+#define I40E_AQ_VSI_UP_TABLE_UP3_SHIFT  9
+#define I40E_AQ_VSI_UP_TABLE_UP3_MASK   (0x7 << \
+                                         I40E_AQ_VSI_UP_TABLE_UP3_SHIFT)
+#define I40E_AQ_VSI_UP_TABLE_UP4_SHIFT  12
+#define I40E_AQ_VSI_UP_TABLE_UP4_MASK   (0x7 << \
+                                         I40E_AQ_VSI_UP_TABLE_UP4_SHIFT)
+#define I40E_AQ_VSI_UP_TABLE_UP5_SHIFT  15
+#define I40E_AQ_VSI_UP_TABLE_UP5_MASK   (0x7 << \
+                                         I40E_AQ_VSI_UP_TABLE_UP5_SHIFT)
+#define I40E_AQ_VSI_UP_TABLE_UP6_SHIFT  18
+#define I40E_AQ_VSI_UP_TABLE_UP6_MASK   (0x7 << \
+                                         I40E_AQ_VSI_UP_TABLE_UP6_SHIFT)
+#define I40E_AQ_VSI_UP_TABLE_UP7_SHIFT  21
+#define I40E_AQ_VSI_UP_TABLE_UP7_MASK   (0x7 << \
+                                         I40E_AQ_VSI_UP_TABLE_UP7_SHIFT)
+        __le32  egress_table;   /* same defines as for ingress table */
         /* cascaded PV section */
-        __le16 cas_pv_tag;
-        u8     cas_pv_flags;
-#define I40E_AQ_VSI_CAS_PV_TAGX_SHIFT      0x00
-#define I40E_AQ_VSI_CAS_PV_TAGX_MASK       (0x03 << \
-                                                I40E_AQ_VSI_CAS_PV_TAGX_SHIFT)
-#define I40E_AQ_VSI_CAS_PV_TAGX_LEAVE      0x00
-#define I40E_AQ_VSI_CAS_PV_TAGX_REMOVE     0x01
-#define I40E_AQ_VSI_CAS_PV_TAGX_COPY       0x02
-#define I40E_AQ_VSI_CAS_PV_INSERT_TAG      0x10
-#define I40E_AQ_VSI_CAS_PV_ETAG_PRUNE      0x20
-#define I40E_AQ_VSI_CAS_PV_ACCEPT_HOST_TAG 0x40
-        u8     cas_pv_reserved;
+        __le16  cas_pv_tag;
+        u8      cas_pv_flags;
+#define I40E_AQ_VSI_CAS_PV_TAGX_SHIFT           0x00
+#define I40E_AQ_VSI_CAS_PV_TAGX_MASK            (0x03 << \
+                                                 I40E_AQ_VSI_CAS_PV_TAGX_SHIFT)
+#define I40E_AQ_VSI_CAS_PV_TAGX_LEAVE           0x00
+#define I40E_AQ_VSI_CAS_PV_TAGX_REMOVE          0x01
+#define I40E_AQ_VSI_CAS_PV_TAGX_COPY            0x02
+#define I40E_AQ_VSI_CAS_PV_INSERT_TAG           0x10
+#define I40E_AQ_VSI_CAS_PV_ETAG_PRUNE           0x20
+#define I40E_AQ_VSI_CAS_PV_ACCEPT_HOST_TAG      0x40
+        u8      cas_pv_reserved;
         /* queue mapping section */
-        __le16 mapping_flags;
-#define I40E_AQ_VSI_QUE_MAP_CONTIG          0x0
-#define I40E_AQ_VSI_QUE_MAP_NONCONTIG       0x1
-        __le16 queue_mapping[16];
-#define I40E_AQ_VSI_QUEUE_SHIFT             0x0
-#define I40E_AQ_VSI_QUEUE_MASK              (0x7FF << I40E_AQ_VSI_QUEUE_SHIFT)
-        __le16 tc_mapping[8];
-#define I40E_AQ_VSI_TC_QUE_OFFSET_SHIFT     0
-#define I40E_AQ_VSI_TC_QUE_OFFSET_MASK      (0x1FF << \
-                                                I40E_AQ_VSI_TC_QUE_OFFSET_SHIFT)
-#define I40E_AQ_VSI_TC_QUE_NUMBER_SHIFT     9
-#define I40E_AQ_VSI_TC_QUE_NUMBER_MASK      (0x7 << \
-                                                I40E_AQ_VSI_TC_QUE_NUMBER_SHIFT)
+        __le16  mapping_flags;
+#define I40E_AQ_VSI_QUE_MAP_CONTIG      0x0
+#define I40E_AQ_VSI_QUE_MAP_NONCONTIG   0x1
+        __le16  queue_mapping[16];
+#define I40E_AQ_VSI_QUEUE_SHIFT         0x0
+#define I40E_AQ_VSI_QUEUE_MASK          (0x7FF << I40E_AQ_VSI_QUEUE_SHIFT)
+        __le16  tc_mapping[8];
+#define I40E_AQ_VSI_TC_QUE_OFFSET_SHIFT 0
+#define I40E_AQ_VSI_TC_QUE_OFFSET_MASK  (0x1FF << \
+                                         I40E_AQ_VSI_TC_QUE_OFFSET_SHIFT)
+#define I40E_AQ_VSI_TC_QUE_NUMBER_SHIFT 9
+#define I40E_AQ_VSI_TC_QUE_NUMBER_MASK  (0x7 << \
+                                         I40E_AQ_VSI_TC_QUE_NUMBER_SHIFT)
         /* queueing option section */
-        u8     queueing_opt_flags;
-#define I40E_AQ_VSI_QUE_OPT_TCP_ENA         0x10
-#define I40E_AQ_VSI_QUE_OPT_FCOE_ENA        0x20
-        u8     queueing_opt_reserved[3];
+        u8      queueing_opt_flags;
+#define I40E_AQ_VSI_QUE_OPT_TCP_ENA     0x10
+#define I40E_AQ_VSI_QUE_OPT_FCOE_ENA    0x20
+        u8      queueing_opt_reserved[3];
         /* scheduler section */
-        u8     up_enable_bits;
-        u8     sched_reserved;
+        u8      up_enable_bits;
+        u8      sched_reserved;
         /* outer up section */
-        __le32 outer_up_table; /* same structure and defines as ingress table */
-        u8     cmd_reserved[8];
+        __le32  outer_up_table; /* same structure and defines as ingress tbl */
+        u8      cmd_reserved[8];
         /* last 32 bytes are written by FW */
-        __le16 qs_handle[8];
+        __le16  qs_handle[8];
 #define I40E_AQ_VSI_QS_HANDLE_INVALID   0xFFFF
-        __le16 stat_counter_idx;
-        __le16 sched_id;
-        u8     resp_reserved[12];
+        __le16  stat_counter_idx;
+        __le16  sched_id;
+        u8      resp_reserved[12];
 };
 
 I40E_CHECK_STRUCT_LEN(128, i40e_aqc_vsi_properties_data);
@@ -830,26 +830,26 @@ I40E_CHECK_STRUCT_LEN(128, i40e_aqc_vsi_properties_data);
  * (IS_CTRL_PORT only works on add PV)
  */
 struct i40e_aqc_add_update_pv {
-        __le16 command_flags;
-#define I40E_AQC_PV_FLAG_PV_TYPE                0x1
-#define I40E_AQC_PV_FLAG_FWD_UNKNOWN_STAG_EN    0x2
-#define I40E_AQC_PV_FLAG_FWD_UNKNOWN_ETAG_EN    0x4
-#define I40E_AQC_PV_FLAG_IS_CTRL_PORT           0x8
-        __le16 uplink_seid;
-        __le16 connected_seid;
-        u8     reserved[10];
+        __le16  command_flags;
+#define I40E_AQC_PV_FLAG_PV_TYPE                0x1
+#define I40E_AQC_PV_FLAG_FWD_UNKNOWN_STAG_EN    0x2
+#define I40E_AQC_PV_FLAG_FWD_UNKNOWN_ETAG_EN    0x4
+#define I40E_AQC_PV_FLAG_IS_CTRL_PORT           0x8
+        __le16  uplink_seid;
+        __le16  connected_seid;
+        u8      reserved[10];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_update_pv);
 
 struct i40e_aqc_add_update_pv_completion {
         /* reserved for update; for add also encodes error if rc == ENOSPC */
-        __le16 pv_seid;
-#define I40E_AQC_PV_ERR_FLAG_NO_PV               0x1
-#define I40E_AQC_PV_ERR_FLAG_NO_SCHED            0x2
-#define I40E_AQC_PV_ERR_FLAG_NO_COUNTER          0x4
-#define I40E_AQC_PV_ERR_FLAG_NO_ENTRY            0x8
-        u8     reserved[14];
+        __le16  pv_seid;
+#define I40E_AQC_PV_ERR_FLAG_NO_PV      0x1
+#define I40E_AQC_PV_ERR_FLAG_NO_SCHED   0x2
+#define I40E_AQC_PV_ERR_FLAG_NO_COUNTER 0x4
+#define I40E_AQC_PV_ERR_FLAG_NO_ENTRY   0x8
+        u8      reserved[14];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_update_pv_completion);
@@ -859,48 +859,48 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_add_update_pv_completion);
  */
 
 struct i40e_aqc_get_pv_params_completion {
-        __le16 seid;
-        __le16 default_stag;
-        __le16 pv_flags; /* same flags as add_pv */
-#define I40E_AQC_GET_PV_PV_TYPE            0x1
-#define I40E_AQC_GET_PV_FRWD_UNKNOWN_STAG  0x2
-#define I40E_AQC_GET_PV_FRWD_UNKNOWN_ETAG  0x4
-        u8     reserved[8];
-        __le16 default_port_seid;
+        __le16  seid;
+        __le16  default_stag;
+        __le16  pv_flags; /* same flags as add_pv */
+#define I40E_AQC_GET_PV_PV_TYPE                 0x1
+#define I40E_AQC_GET_PV_FRWD_UNKNOWN_STAG       0x2
+#define I40E_AQC_GET_PV_FRWD_UNKNOWN_ETAG       0x4
+        u8      reserved[8];
+        __le16  default_port_seid;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_get_pv_params_completion);
 
 /* Add VEB (direct 0x0230) */
 struct i40e_aqc_add_veb {
-        __le16 uplink_seid;
-        __le16 downlink_seid;
-        __le16 veb_flags;
-#define I40E_AQC_ADD_VEB_FLOATING           0x1
-#define I40E_AQC_ADD_VEB_PORT_TYPE_SHIFT    1
-#define I40E_AQC_ADD_VEB_PORT_TYPE_MASK     (0x3 << \
+        __le16  uplink_seid;
+        __le16  downlink_seid;
+        __le16  veb_flags;
+#define I40E_AQC_ADD_VEB_FLOATING               0x1
+#define I40E_AQC_ADD_VEB_PORT_TYPE_SHIFT        1
+#define I40E_AQC_ADD_VEB_PORT_TYPE_MASK         (0x3 << \
                                         I40E_AQC_ADD_VEB_PORT_TYPE_SHIFT)
-#define I40E_AQC_ADD_VEB_PORT_TYPE_DEFAULT  0x2
-#define I40E_AQC_ADD_VEB_PORT_TYPE_DATA     0x4
-#define I40E_AQC_ADD_VEB_ENABLE_L2_FILTER   0x8
-        u8     enable_tcs;
-        u8     reserved[9];
+#define I40E_AQC_ADD_VEB_PORT_TYPE_DEFAULT      0x2
+#define I40E_AQC_ADD_VEB_PORT_TYPE_DATA         0x4
+#define I40E_AQC_ADD_VEB_ENABLE_L2_FILTER       0x8
+        u8      enable_tcs;
+        u8      reserved[9];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_veb);
 
 struct i40e_aqc_add_veb_completion {
-        u8     reserved[6];
-        __le16 switch_seid;
+        u8      reserved[6];
+        __le16  switch_seid;
         /* also encodes error if rc == ENOSPC; codes are the same as add_pv */
-        __le16 veb_seid;
-#define I40E_AQC_VEB_ERR_FLAG_NO_VEB              0x1
-#define I40E_AQC_VEB_ERR_FLAG_NO_SCHED            0x2
-#define I40E_AQC_VEB_ERR_FLAG_NO_COUNTER          0x4
-#define I40E_AQC_VEB_ERR_FLAG_NO_ENTRY            0x8
-        __le16 statistic_index;
-        __le16 vebs_used;
-        __le16 vebs_free;
+        __le16  veb_seid;
+#define I40E_AQC_VEB_ERR_FLAG_NO_VEB            0x1
+#define I40E_AQC_VEB_ERR_FLAG_NO_SCHED          0x2
+#define I40E_AQC_VEB_ERR_FLAG_NO_COUNTER        0x4
+#define I40E_AQC_VEB_ERR_FLAG_NO_ENTRY          0x8
+        __le16  statistic_index;
+        __le16  vebs_used;
+        __le16  vebs_free;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_veb_completion);
@@ -909,13 +909,13 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_add_veb_completion);
  * uses i40e_aqc_switch_seid for the descriptor
  */
 struct i40e_aqc_get_veb_parameters_completion {
-        __le16 seid;
-        __le16 switch_id;
-        __le16 veb_flags; /* only the first/last flags from 0x0230 is valid */
-        __le16 statistic_index;
-        __le16 vebs_used;
-        __le16 vebs_free;
-        u8     reserved[4];
+        __le16  seid;
+        __le16  switch_id;
+        __le16  veb_flags; /* only the first/last flags from 0x0230 is valid */
+        __le16  statistic_index;
+        __le16  vebs_used;
+        __le16  vebs_free;
+        u8      reserved[4];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_get_veb_parameters_completion);
@@ -928,37 +928,37 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_get_veb_parameters_completion);
 
 /* used for the command for most vlan commands */
 struct i40e_aqc_macvlan {
-        __le16 num_addresses;
-        __le16 seid[3];
-#define I40E_AQC_MACVLAN_CMD_SEID_NUM_SHIFT  0
-#define I40E_AQC_MACVLAN_CMD_SEID_NUM_MASK   (0x3FF << \
+        __le16  num_addresses;
+        __le16  seid[3];
+#define I40E_AQC_MACVLAN_CMD_SEID_NUM_SHIFT     0
+#define I40E_AQC_MACVLAN_CMD_SEID_NUM_MASK      (0x3FF << \
                                         I40E_AQC_MACVLAN_CMD_SEID_NUM_SHIFT)
-#define I40E_AQC_MACVLAN_CMD_SEID_VALID      0x8000
-        __le32 addr_high;
-        __le32 addr_low;
+#define I40E_AQC_MACVLAN_CMD_SEID_VALID         0x8000
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_macvlan);
 
 /* indirect data for command and response */
 struct i40e_aqc_add_macvlan_element_data {
-        u8     mac_addr[6];
-        __le16 vlan_tag;
-        __le16 flags;
-#define I40E_AQC_MACVLAN_ADD_PERFECT_MATCH     0x0001
-#define I40E_AQC_MACVLAN_ADD_HASH_MATCH        0x0002
-#define I40E_AQC_MACVLAN_ADD_IGNORE_VLAN       0x0004
-#define I40E_AQC_MACVLAN_ADD_TO_QUEUE          0x0008
-        __le16 queue_number;
-#define I40E_AQC_MACVLAN_CMD_QUEUE_SHIFT  0
-#define I40E_AQC_MACVLAN_CMD_QUEUE_MASK   (0x7FF << \
+        u8      mac_addr[6];
+        __le16  vlan_tag;
+        __le16  flags;
+#define I40E_AQC_MACVLAN_ADD_PERFECT_MATCH      0x0001
+#define I40E_AQC_MACVLAN_ADD_HASH_MATCH         0x0002
+#define I40E_AQC_MACVLAN_ADD_IGNORE_VLAN        0x0004
+#define I40E_AQC_MACVLAN_ADD_TO_QUEUE           0x0008
+        __le16  queue_number;
+#define I40E_AQC_MACVLAN_CMD_QUEUE_SHIFT        0
+#define I40E_AQC_MACVLAN_CMD_QUEUE_MASK         (0x7FF << \
                                         I40E_AQC_MACVLAN_CMD_SEID_NUM_SHIFT)
         /* response section */
-        u8     match_method;
-#define I40E_AQC_MM_PERFECT_MATCH             0x01
-#define I40E_AQC_MM_HASH_MATCH                0x02
-#define I40E_AQC_MM_ERR_NO_RES                0xFF
-        u8     reserved1[3];
+        u8      match_method;
+#define I40E_AQC_MM_PERFECT_MATCH       0x01
+#define I40E_AQC_MM_HASH_MATCH          0x02
+#define I40E_AQC_MM_ERR_NO_RES          0xFF
+        u8      reserved1[3];
 };
 
 struct i40e_aqc_add_remove_macvlan_completion {
@@ -978,19 +978,19 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_macvlan_completion);
  */
 
 struct i40e_aqc_remove_macvlan_element_data {
-        u8     mac_addr[6];
-        __le16 vlan_tag;
-        u8     flags;
-#define I40E_AQC_MACVLAN_DEL_PERFECT_MATCH      0x01
-#define I40E_AQC_MACVLAN_DEL_HASH_MATCH         0x02
-#define I40E_AQC_MACVLAN_DEL_IGNORE_VLAN        0x08
-#define I40E_AQC_MACVLAN_DEL_ALL_VSIS           0x10
-        u8     reserved[3];
+        u8      mac_addr[6];
+        __le16  vlan_tag;
+        u8      flags;
+#define I40E_AQC_MACVLAN_DEL_PERFECT_MATCH      0x01
+#define I40E_AQC_MACVLAN_DEL_HASH_MATCH         0x02
+#define I40E_AQC_MACVLAN_DEL_IGNORE_VLAN        0x08
+#define I40E_AQC_MACVLAN_DEL_ALL_VSIS           0x10
+        u8      reserved[3];
         /* reply section */
-        u8     error_code;
-#define I40E_AQC_REMOVE_MACVLAN_SUCCESS         0x0
-#define I40E_AQC_REMOVE_MACVLAN_FAIL            0xFF
-        u8     reply_reserved[3];
+        u8      error_code;
+#define I40E_AQC_REMOVE_MACVLAN_SUCCESS         0x0
+#define I40E_AQC_REMOVE_MACVLAN_FAIL            0xFF
+        u8      reply_reserved[3];
 };
 
 /* Add VLAN (indirect 0x0252)
@@ -998,59 +998,58 @@ struct i40e_aqc_remove_macvlan_element_data {
  * use the generic i40e_aqc_macvlan for the command
  */
 struct i40e_aqc_add_remove_vlan_element_data {
-        __le16 vlan_tag;
-        u8     vlan_flags;
+        __le16  vlan_tag;
+        u8      vlan_flags;
 /* flags for add VLAN */
-#define I40E_AQC_ADD_VLAN_LOCAL             0x1
-#define I40E_AQC_ADD_PVLAN_TYPE_SHIFT       1
-#define I40E_AQC_ADD_PVLAN_TYPE_MASK        (0x3 << \
-                                                I40E_AQC_ADD_PVLAN_TYPE_SHIFT)
-#define I40E_AQC_ADD_PVLAN_TYPE_REGULAR     0x0
-#define I40E_AQC_ADD_PVLAN_TYPE_PRIMARY     0x2
-#define I40E_AQC_ADD_PVLAN_TYPE_SECONDARY   0x4
-#define I40E_AQC_VLAN_PTYPE_SHIFT           3
-#define I40E_AQC_VLAN_PTYPE_MASK            (0x3 << I40E_AQC_VLAN_PTYPE_SHIFT)
-#define I40E_AQC_VLAN_PTYPE_REGULAR_VSI     0x0
-#define I40E_AQC_VLAN_PTYPE_PROMISC_VSI     0x8
-#define I40E_AQC_VLAN_PTYPE_COMMUNITY_VSI   0x10
-#define I40E_AQC_VLAN_PTYPE_ISOLATED_VSI    0x18
+#define I40E_AQC_ADD_VLAN_LOCAL                 0x1
+#define I40E_AQC_ADD_PVLAN_TYPE_SHIFT           1
+#define I40E_AQC_ADD_PVLAN_TYPE_MASK    (0x3 << I40E_AQC_ADD_PVLAN_TYPE_SHIFT)
+#define I40E_AQC_ADD_PVLAN_TYPE_REGULAR         0x0
+#define I40E_AQC_ADD_PVLAN_TYPE_PRIMARY         0x2
+#define I40E_AQC_ADD_PVLAN_TYPE_SECONDARY       0x4
+#define I40E_AQC_VLAN_PTYPE_SHIFT               3
+#define I40E_AQC_VLAN_PTYPE_MASK        (0x3 << I40E_AQC_VLAN_PTYPE_SHIFT)
+#define I40E_AQC_VLAN_PTYPE_REGULAR_VSI         0x0
+#define I40E_AQC_VLAN_PTYPE_PROMISC_VSI         0x8
+#define I40E_AQC_VLAN_PTYPE_COMMUNITY_VSI       0x10
+#define I40E_AQC_VLAN_PTYPE_ISOLATED_VSI        0x18
 /* flags for remove VLAN */
-#define I40E_AQC_REMOVE_VLAN_ALL            0x1
-        u8     reserved;
-        u8     result;
+#define I40E_AQC_REMOVE_VLAN_ALL        0x1
+        u8      reserved;
+        u8      result;
 /* flags for add VLAN */
-#define I40E_AQC_ADD_VLAN_SUCCESS       0x0
-#define I40E_AQC_ADD_VLAN_FAIL_REQUEST  0xFE
-#define I40E_AQC_ADD_VLAN_FAIL_RESOURCE 0xFF
+#define I40E_AQC_ADD_VLAN_SUCCESS       0x0
+#define I40E_AQC_ADD_VLAN_FAIL_REQUEST  0xFE
+#define I40E_AQC_ADD_VLAN_FAIL_RESOURCE 0xFF
 /* flags for remove VLAN */
-#define I40E_AQC_REMOVE_VLAN_SUCCESS    0x0
-#define I40E_AQC_REMOVE_VLAN_FAIL       0xFF
-        u8     reserved1[3];
+#define I40E_AQC_REMOVE_VLAN_SUCCESS    0x0
+#define I40E_AQC_REMOVE_VLAN_FAIL       0xFF
+        u8      reserved1[3];
 };
 
 struct i40e_aqc_add_remove_vlan_completion {
-        u8     reserved[4];
-        __le16 vlans_used;
-        __le16 vlans_free;
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      reserved[4];
+        __le16  vlans_used;
+        __le16  vlans_free;
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 /* Set VSI Promiscuous Modes (direct 0x0254) */
 struct i40e_aqc_set_vsi_promiscuous_modes {
-        __le16 promiscuous_flags;
-        __le16 valid_flags;
+        __le16  promiscuous_flags;
+        __le16  valid_flags;
 /* flags used for both fields above */
-#define I40E_AQC_SET_VSI_PROMISC_UNICAST     0x01
-#define I40E_AQC_SET_VSI_PROMISC_MULTICAST   0x02
-#define I40E_AQC_SET_VSI_PROMISC_BROADCAST   0x04
-#define I40E_AQC_SET_VSI_DEFAULT             0x08
-#define I40E_AQC_SET_VSI_PROMISC_VLAN        0x10
-        __le16 seid;
-#define I40E_AQC_VSI_PROM_CMD_SEID_MASK      0x3FF
-        __le16 vlan_tag;
-#define I40E_AQC_SET_VSI_VLAN_VALID          0x8000
-        u8     reserved[8];
+#define I40E_AQC_SET_VSI_PROMISC_UNICAST        0x01
+#define I40E_AQC_SET_VSI_PROMISC_MULTICAST      0x02
+#define I40E_AQC_SET_VSI_PROMISC_BROADCAST      0x04
+#define I40E_AQC_SET_VSI_DEFAULT                0x08
+#define I40E_AQC_SET_VSI_PROMISC_VLAN           0x10
+        __le16  seid;
+#define I40E_AQC_VSI_PROM_CMD_SEID_MASK         0x3FF
+        __le16  vlan_tag;
+#define I40E_AQC_SET_VSI_VLAN_VALID             0x8000
+        u8      reserved[8];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_set_vsi_promiscuous_modes);
@@ -1059,23 +1058,23 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_set_vsi_promiscuous_modes);
  * Uses generic i40e_aqc_add_remove_tag_completion for completion
  */
 struct i40e_aqc_add_tag {
-        __le16 flags;
-#define I40E_AQC_ADD_TAG_FLAG_TO_QUEUE     0x0001
-        __le16 seid;
-#define I40E_AQC_ADD_TAG_CMD_SEID_NUM_SHIFT  0
-#define I40E_AQC_ADD_TAG_CMD_SEID_NUM_MASK   (0x3FF << \
+        __le16  flags;
+#define I40E_AQC_ADD_TAG_FLAG_TO_QUEUE          0x0001
+        __le16  seid;
+#define I40E_AQC_ADD_TAG_CMD_SEID_NUM_SHIFT     0
+#define I40E_AQC_ADD_TAG_CMD_SEID_NUM_MASK      (0x3FF << \
                                         I40E_AQC_ADD_TAG_CMD_SEID_NUM_SHIFT)
-        __le16 tag;
-        __le16 queue_number;
-        u8     reserved[8];
+        __le16  tag;
+        __le16  queue_number;
+        u8      reserved[8];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_tag);
 
 struct i40e_aqc_add_remove_tag_completion {
-        u8     reserved[12];
-        __le16 tags_used;
-        __le16 tags_free;
+        u8      reserved[12];
+        __le16  tags_used;
+        __le16  tags_free;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_tag_completion);
@@ -1084,12 +1083,12 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_tag_completion);
  * Uses generic i40e_aqc_add_remove_tag_completion for completion
  */
 struct i40e_aqc_remove_tag {
-        __le16 seid;
-#define I40E_AQC_REMOVE_TAG_CMD_SEID_NUM_SHIFT  0
-#define I40E_AQC_REMOVE_TAG_CMD_SEID_NUM_MASK   (0x3FF << \
+        __le16  seid;
+#define I40E_AQC_REMOVE_TAG_CMD_SEID_NUM_SHIFT  0
+#define I40E_AQC_REMOVE_TAG_CMD_SEID_NUM_MASK   (0x3FF << \
                                         I40E_AQC_REMOVE_TAG_CMD_SEID_NUM_SHIFT)
-        __le16 tag;
-        u8     reserved[12];
+        __le16  tag;
+        u8      reserved[12];
 };
 
 /* Add multicast E-Tag (direct 0x0257)
@@ -1097,22 +1096,22 @@ struct i40e_aqc_remove_tag {
  * and no external data
  */
 struct i40e_aqc_add_remove_mcast_etag {
-        __le16 pv_seid;
-        __le16 etag;
-        u8     num_unicast_etags;
-        u8     reserved[3];
-        __le32 addr_high;          /* address of array of 2-byte s-tags */
-        __le32 addr_low;
+        __le16  pv_seid;
+        __le16  etag;
+        u8      num_unicast_etags;
+        u8      reserved[3];
+        __le32  addr_high;          /* address of array of 2-byte s-tags */
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_mcast_etag);
 
 struct i40e_aqc_add_remove_mcast_etag_completion {
-        u8     reserved[4];
-        __le16 mcast_etags_used;
-        __le16 mcast_etags_free;
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      reserved[4];
+        __le16  mcast_etags_used;
+        __le16  mcast_etags_free;
+        __le32  addr_high;
+        __le32  addr_low;
 
 };
 
@@ -1120,21 +1119,21 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_mcast_etag_completion);
 
 /* Update S/E-Tag (direct 0x0259) */
 struct i40e_aqc_update_tag {
-        __le16 seid;
-#define I40E_AQC_UPDATE_TAG_CMD_SEID_NUM_SHIFT  0
-#define I40E_AQC_UPDATE_TAG_CMD_SEID_NUM_MASK   (0x3FF << \
+        __le16  seid;
+#define I40E_AQC_UPDATE_TAG_CMD_SEID_NUM_SHIFT  0
+#define I40E_AQC_UPDATE_TAG_CMD_SEID_NUM_MASK   (0x3FF << \
                                         I40E_AQC_UPDATE_TAG_CMD_SEID_NUM_SHIFT)
-        __le16 old_tag;
-        __le16 new_tag;
-        u8     reserved[10];
+        __le16  old_tag;
+        __le16  new_tag;
+        u8      reserved[10];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_update_tag);
 
 struct i40e_aqc_update_tag_completion {
-        u8     reserved[12];
-        __le16 tags_used;
-        __le16 tags_free;
+        u8      reserved[12];
+        __le16  tags_used;
+        __le16  tags_free;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_update_tag_completion);
@@ -1145,30 +1144,30 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_update_tag_completion);
  * and the generic direct completion structure
  */
 struct i40e_aqc_add_remove_control_packet_filter {
-        u8     mac[6];
-        __le16 etype;
-        __le16 flags;
-#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_IGNORE_MAC    0x0001
-#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_DROP          0x0002
-#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_TO_QUEUE      0x0004
-#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_TX            0x0008
-#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_RX            0x0000
-        __le16 seid;
-#define I40E_AQC_ADD_CONTROL_PACKET_CMD_SEID_NUM_SHIFT  0
-#define I40E_AQC_ADD_CONTROL_PACKET_CMD_SEID_NUM_MASK   (0x3FF << \
+        u8      mac[6];
+        __le16  etype;
+        __le16  flags;
+#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_IGNORE_MAC    0x0001
+#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_DROP          0x0002
+#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_TO_QUEUE      0x0004
+#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_TX            0x0008
+#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_RX            0x0000
+        __le16  seid;
+#define I40E_AQC_ADD_CONTROL_PACKET_CMD_SEID_NUM_SHIFT  0
+#define I40E_AQC_ADD_CONTROL_PACKET_CMD_SEID_NUM_MASK   (0x3FF << \
                                 I40E_AQC_ADD_CONTROL_PACKET_CMD_SEID_NUM_SHIFT)
-        __le16 queue;
-        u8     reserved[2];
+        __le16  queue;
+        u8      reserved[2];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_control_packet_filter);
 
 struct i40e_aqc_add_remove_control_packet_filter_completion {
-        __le16 mac_etype_used;
-        __le16 etype_used;
-        __le16 mac_etype_free;
-        __le16 etype_free;
-        u8     reserved[8];
+        __le16  mac_etype_used;
+        __le16  etype_used;
+        __le16  mac_etype_free;
+        __le16  etype_free;
+        u8      reserved[8];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_control_packet_filter_completion);
@@ -1179,23 +1178,23 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_control_packet_filter_completion);
  * and the generic indirect completion structure
  */
 struct i40e_aqc_add_remove_cloud_filters {
-        u8     num_filters;
-        u8     reserved;
-        __le16 seid;
-#define I40E_AQC_ADD_CLOUD_CMD_SEID_NUM_SHIFT  0
-#define I40E_AQC_ADD_CLOUD_CMD_SEID_NUM_MASK   (0x3FF << \
+        u8      num_filters;
+        u8      reserved;
+        __le16  seid;
+#define I40E_AQC_ADD_CLOUD_CMD_SEID_NUM_SHIFT   0
+#define I40E_AQC_ADD_CLOUD_CMD_SEID_NUM_MASK    (0x3FF << \
                                         I40E_AQC_ADD_CLOUD_CMD_SEID_NUM_SHIFT)
-        u8     reserved2[4];
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      reserved2[4];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_cloud_filters);
 
 struct i40e_aqc_add_remove_cloud_filters_element_data {
-        u8     outer_mac[6];
-        u8     inner_mac[6];
-        __le16 inner_vlan;
+        u8      outer_mac[6];
+        u8      inner_mac[6];
+        __le16  inner_vlan;
         union {
                 struct {
                         u8 reserved[12];
@@ -1205,49 +1204,49 @@ struct i40e_aqc_add_remove_cloud_filters_element_data {
                         u8 data[16];
                 } v6;
         } ipaddr;
-        __le16 flags;
-#define I40E_AQC_ADD_CLOUD_FILTER_SHIFT                 0
-#define I40E_AQC_ADD_CLOUD_FILTER_MASK                  (0x3F << \
+        __le16  flags;
+#define I40E_AQC_ADD_CLOUD_FILTER_SHIFT                 0
+#define I40E_AQC_ADD_CLOUD_FILTER_MASK                  (0x3F << \
                                         I40E_AQC_ADD_CLOUD_FILTER_SHIFT)
 /* 0x0000 reserved */
-#define I40E_AQC_ADD_CLOUD_FILTER_OIP                   0x0001
+#define I40E_AQC_ADD_CLOUD_FILTER_OIP                   0x0001
 /* 0x0002 reserved */
-#define I40E_AQC_ADD_CLOUD_FILTER_IMAC_IVLAN            0x0003
-#define I40E_AQC_ADD_CLOUD_FILTER_IMAC_IVLAN_TEN_ID     0x0004
+#define I40E_AQC_ADD_CLOUD_FILTER_IMAC_IVLAN            0x0003
+#define I40E_AQC_ADD_CLOUD_FILTER_IMAC_IVLAN_TEN_ID     0x0004
 /* 0x0005 reserved */
-#define I40E_AQC_ADD_CLOUD_FILTER_IMAC_TEN_ID           0x0006
+#define I40E_AQC_ADD_CLOUD_FILTER_IMAC_TEN_ID           0x0006
 /* 0x0007 reserved */
 /* 0x0008 reserved */
-#define I40E_AQC_ADD_CLOUD_FILTER_OMAC                  0x0009
-#define I40E_AQC_ADD_CLOUD_FILTER_IMAC                  0x000A
-#define I40E_AQC_ADD_CLOUD_FILTER_OMAC_TEN_ID_IMAC      0x000B
-#define I40E_AQC_ADD_CLOUD_FILTER_IIP                   0x000C
-
-#define I40E_AQC_ADD_CLOUD_FLAGS_TO_QUEUE               0x0080
-#define I40E_AQC_ADD_CLOUD_VNK_SHIFT                    6
-#define I40E_AQC_ADD_CLOUD_VNK_MASK                     0x00C0
-#define I40E_AQC_ADD_CLOUD_FLAGS_IPV4                   0
-#define I40E_AQC_ADD_CLOUD_FLAGS_IPV6                   0x0100
-
-#define I40E_AQC_ADD_CLOUD_TNL_TYPE_SHIFT               9
-#define I40E_AQC_ADD_CLOUD_TNL_TYPE_MASK                0x1E00
-#define I40E_AQC_ADD_CLOUD_TNL_TYPE_XVLAN               0
-#define I40E_AQC_ADD_CLOUD_TNL_TYPE_NVGRE_OMAC          1
-#define I40E_AQC_ADD_CLOUD_TNL_TYPE_NGE                 2
-#define I40E_AQC_ADD_CLOUD_TNL_TYPE_IP                  3
-
-        __le32 tenant_id;
-        u8     reserved[4];
-        __le16 queue_number;
-#define I40E_AQC_ADD_CLOUD_QUEUE_SHIFT                  0
-#define I40E_AQC_ADD_CLOUD_QUEUE_MASK                   (0x3F << \
-                                        I40E_AQC_ADD_CLOUD_QUEUE_SHIFT)
-        u8     reserved2[14];
+#define I40E_AQC_ADD_CLOUD_FILTER_OMAC                  0x0009
+#define I40E_AQC_ADD_CLOUD_FILTER_IMAC                  0x000A
+#define I40E_AQC_ADD_CLOUD_FILTER_OMAC_TEN_ID_IMAC      0x000B
+#define I40E_AQC_ADD_CLOUD_FILTER_IIP                   0x000C
+
+#define I40E_AQC_ADD_CLOUD_FLAGS_TO_QUEUE               0x0080
+#define I40E_AQC_ADD_CLOUD_VNK_SHIFT                    6
+#define I40E_AQC_ADD_CLOUD_VNK_MASK                     0x00C0
+#define I40E_AQC_ADD_CLOUD_FLAGS_IPV4                   0
+#define I40E_AQC_ADD_CLOUD_FLAGS_IPV6                   0x0100
+
+#define I40E_AQC_ADD_CLOUD_TNL_TYPE_SHIFT               9
+#define I40E_AQC_ADD_CLOUD_TNL_TYPE_MASK                0x1E00
+#define I40E_AQC_ADD_CLOUD_TNL_TYPE_XVLAN               0
+#define I40E_AQC_ADD_CLOUD_TNL_TYPE_NVGRE_OMAC          1
+#define I40E_AQC_ADD_CLOUD_TNL_TYPE_NGE                 2
+#define I40E_AQC_ADD_CLOUD_TNL_TYPE_IP                  3
+
+        __le32  tenant_id;
+        u8      reserved[4];
+        __le16  queue_number;
+#define I40E_AQC_ADD_CLOUD_QUEUE_SHIFT          0
+#define I40E_AQC_ADD_CLOUD_QUEUE_MASK           (0x3F << \
+                                                 I40E_AQC_ADD_CLOUD_QUEUE_SHIFT)
+        u8      reserved2[14];
         /* response section */
-        u8     allocation_result;
-#define I40E_AQC_ADD_CLOUD_FILTER_SUCCESS         0x0
-#define I40E_AQC_ADD_CLOUD_FILTER_FAIL            0xFF
-        u8     response_reserved[7];
+        u8      allocation_result;
+#define I40E_AQC_ADD_CLOUD_FILTER_SUCCESS       0x0
+#define I40E_AQC_ADD_CLOUD_FILTER_FAIL          0xFF
+        u8      response_reserved[7];
 };
 
 struct i40e_aqc_remove_cloud_filters_completion {
@@ -1269,14 +1268,14 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_remove_cloud_filters_completion);
 struct i40e_aqc_add_delete_mirror_rule {
         __le16 seid;
         __le16 rule_type;
-#define I40E_AQC_MIRROR_RULE_TYPE_SHIFT            0
-#define I40E_AQC_MIRROR_RULE_TYPE_MASK             (0x7 << \
+#define I40E_AQC_MIRROR_RULE_TYPE_SHIFT         0
+#define I40E_AQC_MIRROR_RULE_TYPE_MASK          (0x7 << \
                                                 I40E_AQC_MIRROR_RULE_TYPE_SHIFT)
-#define I40E_AQC_MIRROR_RULE_TYPE_VPORT_INGRESS    1
-#define I40E_AQC_MIRROR_RULE_TYPE_VPORT_EGRESS     2
-#define I40E_AQC_MIRROR_RULE_TYPE_VLAN             3
-#define I40E_AQC_MIRROR_RULE_TYPE_ALL_INGRESS      4
-#define I40E_AQC_MIRROR_RULE_TYPE_ALL_EGRESS       5
+#define I40E_AQC_MIRROR_RULE_TYPE_VPORT_INGRESS 1
+#define I40E_AQC_MIRROR_RULE_TYPE_VPORT_EGRESS  2
+#define I40E_AQC_MIRROR_RULE_TYPE_VLAN          3
+#define I40E_AQC_MIRROR_RULE_TYPE_ALL_INGRESS   4
+#define I40E_AQC_MIRROR_RULE_TYPE_ALL_EGRESS    5
         __le16 num_entries;
         __le16 destination;  /* VSI for add, rule id for delete */
         __le32 addr_high;    /* address of array of 2-byte VSI or VLAN ids */
@@ -1286,12 +1285,12 @@ struct i40e_aqc_add_delete_mirror_rule {
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_delete_mirror_rule);
 
 struct i40e_aqc_add_delete_mirror_rule_completion {
-        u8     reserved[2];
-        __le16 rule_id;  /* only used on add */
-        __le16 mirror_rules_used;
-        __le16 mirror_rules_free;
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      reserved[2];
+        __le16  rule_id;  /* only used on add */
+        __le16  mirror_rules_used;
+        __le16  mirror_rules_free;
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_delete_mirror_rule_completion);
@@ -1302,11 +1301,11 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_add_delete_mirror_rule_completion);
  *    the command and response use the same descriptor structure
  */
 struct i40e_aqc_pfc_ignore {
-        u8     tc_bitmap;
-        u8     command_flags; /* unused on response */
-#define I40E_AQC_PFC_IGNORE_SET    0x80
-#define I40E_AQC_PFC_IGNORE_CLEAR  0x0
-        u8     reserved[14];
+        u8      tc_bitmap;
+        u8      command_flags; /* unused on response */
+#define I40E_AQC_PFC_IGNORE_SET         0x80
+#define I40E_AQC_PFC_IGNORE_CLEAR       0x0
+        u8      reserved[14];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_pfc_ignore);
@@ -1321,10 +1320,10 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_pfc_ignore);
  * this generic struct to pass the SEID in param0
  */
 struct i40e_aqc_tx_sched_ind {
-        __le16 vsi_seid;
-        u8     reserved[6];
-        __le32 addr_high;
-        __le32 addr_low;
+        __le16  vsi_seid;
+        u8      reserved[6];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_tx_sched_ind);
@@ -1336,12 +1335,12 @@ struct i40e_aqc_qs_handles_resp {
 
 /* Configure VSI BW limits (direct 0x0400) */
 struct i40e_aqc_configure_vsi_bw_limit {
-        __le16 vsi_seid;
-        u8     reserved[2];
-        __le16 credit;
-        u8     reserved1[2];
-        u8     max_credit; /* 0-3, limit = 2^max */
-        u8     reserved2[7];
+        __le16  vsi_seid;
+        u8      reserved[2];
+        __le16  credit;
+        u8      reserved1[2];
+        u8      max_credit; /* 0-3, limit = 2^max */
+        u8      reserved2[7];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_configure_vsi_bw_limit);
@@ -1350,58 +1349,58 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_configure_vsi_bw_limit);
  *    responds with i40e_aqc_qs_handles_resp
  */
 struct i40e_aqc_configure_vsi_ets_sla_bw_data {
-        u8     tc_valid_bits;
-        u8     reserved[15];
-        __le16 tc_bw_credits[8]; /* FW writesback QS handles here */
+        u8      tc_valid_bits;
+        u8      reserved[15];
+        __le16  tc_bw_credits[8]; /* FW writesback QS handles here */
 
         /* 4 bits per tc 0-7, 4th bit is reserved, limit = 2^max */
-        __le16 tc_bw_max[2];
-        u8     reserved1[28];
+        __le16  tc_bw_max[2];
+        u8      reserved1[28];
 };
 
 /* Configure VSI Bandwidth Allocation per Traffic Type (indirect 0x0407)
  *    responds with i40e_aqc_qs_handles_resp
  */
 struct i40e_aqc_configure_vsi_tc_bw_data {
-        u8     tc_valid_bits;
-        u8     reserved[3];
-        u8     tc_bw_credits[8];
-        u8     reserved1[4];
-        __le16 qs_handles[8];
+        u8      tc_valid_bits;
+        u8      reserved[3];
+        u8      tc_bw_credits[8];
+        u8      reserved1[4];
+        __le16  qs_handles[8];
 };
 
 /* Query vsi bw configuration (indirect 0x0408) */
 struct i40e_aqc_query_vsi_bw_config_resp {
-        u8     tc_valid_bits;
-        u8     tc_suspended_bits;
-        u8     reserved[14];
-        __le16 qs_handles[8];
-        u8     reserved1[4];
-        __le16 port_bw_limit;
-        u8     reserved2[2];
-        u8     max_bw; /* 0-3, limit = 2^max */
-        u8     reserved3[23];
+        u8      tc_valid_bits;
+        u8      tc_suspended_bits;
+        u8      reserved[14];
+        __le16  qs_handles[8];
+        u8      reserved1[4];
+        __le16  port_bw_limit;
+        u8      reserved2[2];
+        u8      max_bw; /* 0-3, limit = 2^max */
+        u8      reserved3[23];
 };
 
 /* Query VSI Bandwidth Allocation per Traffic Type (indirect 0x040A) */
 struct i40e_aqc_query_vsi_ets_sla_config_resp {
-        u8     tc_valid_bits;
-        u8     reserved[3];
-        u8     share_credits[8];
-        __le16 credits[8];
+        u8      tc_valid_bits;
+        u8      reserved[3];
+        u8      share_credits[8];
+        __le16  credits[8];
 
         /* 4 bits per tc 0-7, 4th bit is reserved, limit = 2^max */
-        __le16 tc_bw_max[2];
+        __le16  tc_bw_max[2];
 };
 
 /* Configure Switching Component Bandwidth Limit (direct 0x0410) */
 struct i40e_aqc_configure_switching_comp_bw_limit {
-        __le16 seid;
-        u8     reserved[2];
-        __le16 credit;
-        u8     reserved1[2];
-        u8     max_bw; /* 0-3, limit = 2^max */
-        u8     reserved2[7];
+        __le16  seid;
+        u8      reserved[2];
+        __le16  credit;
+        u8      reserved1[2];
+        u8      max_bw; /* 0-3, limit = 2^max */
+        u8      reserved2[7];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_configure_switching_comp_bw_limit);
@@ -1411,75 +1410,75 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_configure_switching_comp_bw_limit);
  * Disable Physical Port ETS (indirect 0x0415)
  */
 struct i40e_aqc_configure_switching_comp_ets_data {
-        u8     reserved[4];
-        u8     tc_valid_bits;
-        u8     seepage;
-#define I40E_AQ_ETS_SEEPAGE_EN_MASK     0x1
-        u8     tc_strict_priority_flags;
-        u8     reserved1[17];
-        u8     tc_bw_share_credits[8];
-        u8     reserved2[96];
+        u8      reserved[4];
+        u8      tc_valid_bits;
+        u8      seepage;
+#define I40E_AQ_ETS_SEEPAGE_EN_MASK     0x1
+        u8      tc_strict_priority_flags;
+        u8      reserved1[17];
+        u8      tc_bw_share_credits[8];
+        u8      reserved2[96];
 };
 
 /* Configure Switching Component Bandwidth Limits per Tc (indirect 0x0416) */
 struct i40e_aqc_configure_switching_comp_ets_bw_limit_data {
-        u8     tc_valid_bits;
-        u8     reserved[15];
-        __le16 tc_bw_credit[8];
+        u8      tc_valid_bits;
+        u8      reserved[15];
+        __le16  tc_bw_credit[8];
 
         /* 4 bits per tc 0-7, 4th bit is reserved, limit = 2^max */
-        __le16 tc_bw_max[2];
-        u8     reserved1[28];
+        __le16  tc_bw_max[2];
+        u8      reserved1[28];
 };
 
 /* Configure Switching Component Bandwidth Allocation per Tc
  * (indirect 0x0417)
  */
 struct i40e_aqc_configure_switching_comp_bw_config_data {
-        u8     tc_valid_bits;
-        u8     reserved[2];
-        u8     absolute_credits; /* bool */
-        u8     tc_bw_share_credits[8];
-        u8     reserved1[20];
+        u8      tc_valid_bits;
+        u8      reserved[2];
+        u8      absolute_credits; /* bool */
+        u8      tc_bw_share_credits[8];
+        u8      reserved1[20];
 };
 
 /* Query Switching Component Configuration (indirect 0x0418) */
 struct i40e_aqc_query_switching_comp_ets_config_resp {
-        u8     tc_valid_bits;
-        u8     reserved[35];
-        __le16 port_bw_limit;
-        u8     reserved1[2];
-        u8     tc_bw_max; /* 0-3, limit = 2^max */
-        u8     reserved2[23];
+        u8      tc_valid_bits;
+        u8      reserved[35];
+        __le16  port_bw_limit;
+        u8      reserved1[2];
+        u8      tc_bw_max; /* 0-3, limit = 2^max */
+        u8      reserved2[23];
 };
 
 /* Query PhysicalPort ETS Configuration (indirect 0x0419) */
 struct i40e_aqc_query_port_ets_config_resp {
-        u8     reserved[4];
-        u8     tc_valid_bits;
-        u8     reserved1;
-        u8     tc_strict_priority_bits;
-        u8     reserved2;
-        u8     tc_bw_share_credits[8];
-        __le16 tc_bw_limits[8];
+        u8      reserved[4];
+        u8      tc_valid_bits;
+        u8      reserved1;
+        u8      tc_strict_priority_bits;
+        u8      reserved2;
+        u8      tc_bw_share_credits[8];
+        __le16  tc_bw_limits[8];
 
         /* 4 bits per tc 0-7, 4th bit reserved, limit = 2^max */
-        __le16 tc_bw_max[2];
-        u8     reserved3[32];
+        __le16  tc_bw_max[2];
+        u8      reserved3[32];
 };
 
 /* Query Switching Component Bandwidth Allocation per Traffic Type
  * (indirect 0x041A)
  */
 struct i40e_aqc_query_switching_comp_bw_config_resp {
-        u8     tc_valid_bits;
-        u8     reserved[2];
-        u8     absolute_credits_enable; /* bool */
-        u8     tc_bw_share_credits[8];
-        __le16 tc_bw_limits[8];
+        u8      tc_valid_bits;
+        u8      reserved[2];
+        u8      absolute_credits_enable; /* bool */
+        u8      tc_bw_share_credits[8];
+        __le16  tc_bw_limits[8];
 
         /* 4 bits per tc 0-7, 4th bit is reserved, limit = 2^max */
-        __le16 tc_bw_max[2];
+        __le16  tc_bw_max[2];
 };
 
 /* Suspend/resume port TX traffic
@@ -1490,37 +1489,37 @@ struct i40e_aqc_query_switching_comp_bw_config_resp {
  * (indirect 0x041D)
  */
 struct i40e_aqc_configure_partition_bw_data {
-        __le16 pf_valid_bits;
-        u8     min_bw[16];      /* guaranteed bandwidth */
-        u8     max_bw[16];      /* bandwidth limit */
+        __le16  pf_valid_bits;
+        u8      min_bw[16];      /* guaranteed bandwidth */
+        u8      max_bw[16];      /* bandwidth limit */
 };
 
 /* Get and set the active HMC resource profile and status.
  * (direct 0x0500) and (direct 0x0501)
  */
 struct i40e_aq_get_set_hmc_resource_profile {
-        u8     pm_profile;
-        u8     pe_vf_enabled;
-        u8     reserved[14];
+        u8      pm_profile;
+        u8      pe_vf_enabled;
+        u8      reserved[14];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aq_get_set_hmc_resource_profile);
 
 enum i40e_aq_hmc_profile {
         /* I40E_HMC_PROFILE_NO_CHANGE    = 0, reserved */
-        I40E_HMC_PROFILE_DEFAULT     = 1,
-        I40E_HMC_PROFILE_FAVOR_VF    = 2,
-        I40E_HMC_PROFILE_EQUAL       = 3,
+        I40E_HMC_PROFILE_DEFAULT        = 1,
+        I40E_HMC_PROFILE_FAVOR_VF       = 2,
+        I40E_HMC_PROFILE_EQUAL          = 3,
 };
 
-#define I40E_AQ_GET_HMC_RESOURCE_PROFILE_PM_MASK       0xF
-#define I40E_AQ_GET_HMC_RESOURCE_PROFILE_COUNT_MASK    0x3F
+#define I40E_AQ_GET_HMC_RESOURCE_PROFILE_PM_MASK        0xF
+#define I40E_AQ_GET_HMC_RESOURCE_PROFILE_COUNT_MASK     0x3F
 
 /* Get PHY Abilities (indirect 0x0600) uses the generic indirect struct */
 
 /* set in param0 for get phy abilities to report qualified modules */
-#define I40E_AQ_PHY_REPORT_QUALIFIED_MODULES  0x0001
-#define I40E_AQ_PHY_REPORT_INITIAL_VALUES     0x0002
+#define I40E_AQ_PHY_REPORT_QUALIFIED_MODULES    0x0001
+#define I40E_AQ_PHY_REPORT_INITIAL_VALUES       0x0002
 
 enum i40e_aq_phy_type {
         I40E_PHY_TYPE_SGMII                     = 0x0,
@@ -1578,147 +1577,147 @@ struct i40e_aqc_module_desc {
 };
 
 struct i40e_aq_get_phy_abilities_resp {
-        __le32 phy_type;       /* bitmap using the above enum for offsets */
-        u8     link_speed;     /* bitmap using the above enum bit patterns */
-        u8     abilities;
-#define I40E_AQ_PHY_FLAG_PAUSE_TX         0x01
-#define I40E_AQ_PHY_FLAG_PAUSE_RX         0x02
-#define I40E_AQ_PHY_FLAG_LOW_POWER        0x04
-#define I40E_AQ_PHY_LINK_ENABLED                  0x08
-#define I40E_AQ_PHY_AN_ENABLED                    0x10
-#define I40E_AQ_PHY_FLAG_MODULE_QUAL      0x20
-        __le16 eee_capability;
-#define I40E_AQ_EEE_100BASE_TX       0x0002
-#define I40E_AQ_EEE_1000BASE_T       0x0004
-#define I40E_AQ_EEE_10GBASE_T        0x0008
-#define I40E_AQ_EEE_1000BASE_KX      0x0010
-#define I40E_AQ_EEE_10GBASE_KX4      0x0020
-#define I40E_AQ_EEE_10GBASE_KR       0x0040
-        __le32 eeer_val;
-        u8     d3_lpan;
-#define I40E_AQ_SET_PHY_D3_LPAN_ENA  0x01
-        u8     reserved[3];
-        u8     phy_id[4];
-        u8     module_type[3];
-        u8     qualified_module_count;
-#define I40E_AQ_PHY_MAX_QMS          16
-        struct i40e_aqc_module_desc  qualified_module[I40E_AQ_PHY_MAX_QMS];
+        __le32  phy_type;       /* bitmap using the above enum for offsets */
+        u8      link_speed;     /* bitmap using the above enum bit patterns */
+        u8      abilities;
+#define I40E_AQ_PHY_FLAG_PAUSE_TX       0x01
+#define I40E_AQ_PHY_FLAG_PAUSE_RX       0x02
+#define I40E_AQ_PHY_FLAG_LOW_POWER      0x04
+#define I40E_AQ_PHY_LINK_ENABLED        0x08
+#define I40E_AQ_PHY_AN_ENABLED          0x10
+#define I40E_AQ_PHY_FLAG_MODULE_QUAL    0x20
+        __le16  eee_capability;
+#define I40E_AQ_EEE_100BASE_TX          0x0002
+#define I40E_AQ_EEE_1000BASE_T          0x0004
+#define I40E_AQ_EEE_10GBASE_T           0x0008
+#define I40E_AQ_EEE_1000BASE_KX         0x0010
+#define I40E_AQ_EEE_10GBASE_KX4         0x0020
+#define I40E_AQ_EEE_10GBASE_KR          0x0040
+        __le32  eeer_val;
+        u8      d3_lpan;
+#define I40E_AQ_SET_PHY_D3_LPAN_ENA     0x01
+        u8      reserved[3];
+        u8      phy_id[4];
+        u8      module_type[3];
+        u8      qualified_module_count;
+#define I40E_AQ_PHY_MAX_QMS             16
+        struct i40e_aqc_module_desc     qualified_module[I40E_AQ_PHY_MAX_QMS];
 };
 
 /* Set PHY Config (direct 0x0601) */
 struct i40e_aq_set_phy_config { /* same bits as above in all */
-        __le32 phy_type;
-        u8     link_speed;
-        u8     abilities;
+        __le32  phy_type;
+        u8      link_speed;
+        u8      abilities;
 /* bits 0-2 use the values from get_phy_abilities_resp */
 #define I40E_AQ_PHY_ENABLE_LINK         0x08
 #define I40E_AQ_PHY_ENABLE_AN           0x10
 #define I40E_AQ_PHY_ENABLE_ATOMIC_LINK  0x20
-        __le16 eee_capability;
-        __le32 eeer;
-        u8     low_power_ctrl;
-        u8     reserved[3];
+        __le16  eee_capability;
+        __le32  eeer;
+        u8      low_power_ctrl;
+        u8      reserved[3];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aq_set_phy_config);
 
 /* Set MAC Config command data structure (direct 0x0603) */
 struct i40e_aq_set_mac_config {
-        __le16 max_frame_size;
-        u8     params;
-#define I40E_AQ_SET_MAC_CONFIG_CRC_EN           0x04
-#define I40E_AQ_SET_MAC_CONFIG_PACING_MASK      0x78
-#define I40E_AQ_SET_MAC_CONFIG_PACING_SHIFT     3
-#define I40E_AQ_SET_MAC_CONFIG_PACING_NONE      0x0
-#define I40E_AQ_SET_MAC_CONFIG_PACING_1B_13TX   0xF
-#define I40E_AQ_SET_MAC_CONFIG_PACING_1DW_9TX   0x9
-#define I40E_AQ_SET_MAC_CONFIG_PACING_1DW_4TX   0x8
-#define I40E_AQ_SET_MAC_CONFIG_PACING_3DW_7TX   0x7
-#define I40E_AQ_SET_MAC_CONFIG_PACING_2DW_3TX   0x6
-#define I40E_AQ_SET_MAC_CONFIG_PACING_1DW_1TX   0x5
-#define I40E_AQ_SET_MAC_CONFIG_PACING_3DW_2TX   0x4
-#define I40E_AQ_SET_MAC_CONFIG_PACING_7DW_3TX   0x3
-#define I40E_AQ_SET_MAC_CONFIG_PACING_4DW_1TX   0x2
-#define I40E_AQ_SET_MAC_CONFIG_PACING_9DW_1TX   0x1
-        u8     tx_timer_priority; /* bitmap */
-        __le16 tx_timer_value;
-        __le16 fc_refresh_threshold;
-        u8     reserved[8];
+        __le16  max_frame_size;
+        u8      params;
+#define I40E_AQ_SET_MAC_CONFIG_CRC_EN           0x04
+#define I40E_AQ_SET_MAC_CONFIG_PACING_MASK      0x78
+#define I40E_AQ_SET_MAC_CONFIG_PACING_SHIFT     3
+#define I40E_AQ_SET_MAC_CONFIG_PACING_NONE      0x0
+#define I40E_AQ_SET_MAC_CONFIG_PACING_1B_13TX   0xF
+#define I40E_AQ_SET_MAC_CONFIG_PACING_1DW_9TX   0x9
+#define I40E_AQ_SET_MAC_CONFIG_PACING_1DW_4TX   0x8
+#define I40E_AQ_SET_MAC_CONFIG_PACING_3DW_7TX   0x7
+#define I40E_AQ_SET_MAC_CONFIG_PACING_2DW_3TX   0x6
+#define I40E_AQ_SET_MAC_CONFIG_PACING_1DW_1TX   0x5
+#define I40E_AQ_SET_MAC_CONFIG_PACING_3DW_2TX   0x4
+#define I40E_AQ_SET_MAC_CONFIG_PACING_7DW_3TX   0x3
+#define I40E_AQ_SET_MAC_CONFIG_PACING_4DW_1TX   0x2
+#define I40E_AQ_SET_MAC_CONFIG_PACING_9DW_1TX   0x1
+        u8      tx_timer_priority; /* bitmap */
+        __le16  tx_timer_value;
+        __le16  fc_refresh_threshold;
+        u8      reserved[8];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aq_set_mac_config);
 
 /* Restart Auto-Negotiation (direct 0x605) */
 struct i40e_aqc_set_link_restart_an {
-        u8     command;
-#define I40E_AQ_PHY_RESTART_AN  0x02
-#define I40E_AQ_PHY_LINK_ENABLE 0x04
-        u8     reserved[15];
+        u8      command;
+#define I40E_AQ_PHY_RESTART_AN  0x02
+#define I40E_AQ_PHY_LINK_ENABLE 0x04
+        u8      reserved[15];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_set_link_restart_an);
 
 /* Get Link Status cmd & response data structure (direct 0x0607) */
 struct i40e_aqc_get_link_status {
-        __le16 command_flags; /* only field set on command */
-#define I40E_AQ_LSE_MASK             0x3
-#define I40E_AQ_LSE_NOP              0x0
-#define I40E_AQ_LSE_DISABLE          0x2
-#define I40E_AQ_LSE_ENABLE           0x3
+        __le16  command_flags; /* only field set on command */
+#define I40E_AQ_LSE_MASK                0x3
+#define I40E_AQ_LSE_NOP                 0x0
+#define I40E_AQ_LSE_DISABLE             0x2
+#define I40E_AQ_LSE_ENABLE              0x3
 /* only response uses this flag */
-#define I40E_AQ_LSE_IS_ENABLED       0x1
-        u8     phy_type;    /* i40e_aq_phy_type   */
-        u8     link_speed;  /* i40e_aq_link_speed */
-        u8     link_info;
-#define I40E_AQ_LINK_UP              0x01
-#define I40E_AQ_LINK_FAULT           0x02
-#define I40E_AQ_LINK_FAULT_TX        0x04
-#define I40E_AQ_LINK_FAULT_RX        0x08
-#define I40E_AQ_LINK_FAULT_REMOTE    0x10
-#define I40E_AQ_MEDIA_AVAILABLE      0x40
-#define I40E_AQ_SIGNAL_DETECT        0x80
-        u8     an_info;
-#define I40E_AQ_AN_COMPLETED         0x01
-#define I40E_AQ_LP_AN_ABILITY        0x02
-#define I40E_AQ_PD_FAULT             0x04
-#define I40E_AQ_FEC_EN               0x08
-#define I40E_AQ_PHY_LOW_POWER        0x10
-#define I40E_AQ_LINK_PAUSE_TX        0x20
-#define I40E_AQ_LINK_PAUSE_RX        0x40
-#define I40E_AQ_QUALIFIED_MODULE     0x80
-        u8     ext_info;
-#define I40E_AQ_LINK_PHY_TEMP_ALARM  0x01
-#define I40E_AQ_LINK_XCESSIVE_ERRORS 0x02
-#define I40E_AQ_LINK_TX_SHIFT        0x02
-#define I40E_AQ_LINK_TX_MASK         (0x03 << I40E_AQ_LINK_TX_SHIFT)
-#define I40E_AQ_LINK_TX_ACTIVE       0x00
-#define I40E_AQ_LINK_TX_DRAINED      0x01
-#define I40E_AQ_LINK_TX_FLUSHED      0x03
-#define I40E_AQ_LINK_FORCED_40G      0x10
-        u8     loopback;         /* use defines from i40e_aqc_set_lb_mode */
-        __le16 max_frame_size;
-        u8     config;
-#define I40E_AQ_CONFIG_CRC_ENA       0x04
-#define I40E_AQ_CONFIG_PACING_MASK   0x78
-        u8     reserved[5];
+#define I40E_AQ_LSE_IS_ENABLED          0x1
+        u8      phy_type;    /* i40e_aq_phy_type   */
+        u8      link_speed;  /* i40e_aq_link_speed */
+        u8      link_info;
+#define I40E_AQ_LINK_UP                 0x01
+#define I40E_AQ_LINK_FAULT              0x02
+#define I40E_AQ_LINK_FAULT_TX           0x04
+#define I40E_AQ_LINK_FAULT_RX           0x08
+#define I40E_AQ_LINK_FAULT_REMOTE       0x10
+#define I40E_AQ_MEDIA_AVAILABLE         0x40
+#define I40E_AQ_SIGNAL_DETECT           0x80
+        u8      an_info;
+#define I40E_AQ_AN_COMPLETED            0x01
+#define I40E_AQ_LP_AN_ABILITY           0x02
+#define I40E_AQ_PD_FAULT                0x04
+#define I40E_AQ_FEC_EN                  0x08
+#define I40E_AQ_PHY_LOW_POWER           0x10
+#define I40E_AQ_LINK_PAUSE_TX           0x20
+#define I40E_AQ_LINK_PAUSE_RX           0x40
+#define I40E_AQ_QUALIFIED_MODULE        0x80
+        u8      ext_info;
+#define I40E_AQ_LINK_PHY_TEMP_ALARM     0x01
+#define I40E_AQ_LINK_XCESSIVE_ERRORS    0x02
+#define I40E_AQ_LINK_TX_SHIFT           0x02
+#define I40E_AQ_LINK_TX_MASK            (0x03 << I40E_AQ_LINK_TX_SHIFT)
+#define I40E_AQ_LINK_TX_ACTIVE          0x00
+#define I40E_AQ_LINK_TX_DRAINED         0x01
+#define I40E_AQ_LINK_TX_FLUSHED         0x03
+#define I40E_AQ_LINK_FORCED_40G         0x10
+        u8      loopback; /* use defines from i40e_aqc_set_lb_mode */
+        __le16  max_frame_size;
+        u8      config;
+#define I40E_AQ_CONFIG_CRC_ENA          0x04
+#define I40E_AQ_CONFIG_PACING_MASK      0x78
+        u8      reserved[5];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_get_link_status);
 
 /* Set event mask command (direct 0x613) */
 struct i40e_aqc_set_phy_int_mask {
-        u8     reserved[8];
-        __le16 event_mask;
-#define I40E_AQ_EVENT_LINK_UPDOWN       0x0002
-#define I40E_AQ_EVENT_MEDIA_NA          0x0004
-#define I40E_AQ_EVENT_LINK_FAULT        0x0008
-#define I40E_AQ_EVENT_PHY_TEMP_ALARM    0x0010
-#define I40E_AQ_EVENT_EXCESSIVE_ERRORS  0x0020
-#define I40E_AQ_EVENT_SIGNAL_DETECT     0x0040
-#define I40E_AQ_EVENT_AN_COMPLETED      0x0080
-#define I40E_AQ_EVENT_MODULE_QUAL_FAIL  0x0100
-#define I40E_AQ_EVENT_PORT_TX_SUSPENDED 0x0200
-        u8     reserved1[6];
+        u8      reserved[8];
+        __le16  event_mask;
+#define I40E_AQ_EVENT_LINK_UPDOWN       0x0002
+#define I40E_AQ_EVENT_MEDIA_NA          0x0004
+#define I40E_AQ_EVENT_LINK_FAULT        0x0008
+#define I40E_AQ_EVENT_PHY_TEMP_ALARM    0x0010
+#define I40E_AQ_EVENT_EXCESSIVE_ERRORS  0x0020
+#define I40E_AQ_EVENT_SIGNAL_DETECT     0x0040
+#define I40E_AQ_EVENT_AN_COMPLETED      0x0080
+#define I40E_AQ_EVENT_MODULE_QUAL_FAIL  0x0100
+#define I40E_AQ_EVENT_PORT_TX_SUSPENDED 0x0200
+        u8      reserved1[6];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_set_phy_int_mask);
@@ -1728,27 +1727,27 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_set_phy_int_mask);
  * Get Link Partner AN advt register (direct 0x0616)
  */
 struct i40e_aqc_an_advt_reg {
-        __le32 local_an_reg0;
-        __le16 local_an_reg1;
-        u8     reserved[10];
+        __le32  local_an_reg0;
+        __le16  local_an_reg1;
+        u8      reserved[10];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_an_advt_reg);
 
 /* Set Loopback mode (0x0618) */
 struct i40e_aqc_set_lb_mode {
-        __le16 lb_mode;
-#define I40E_AQ_LB_PHY_LOCAL   0x01
-#define I40E_AQ_LB_PHY_REMOTE  0x02
-#define I40E_AQ_LB_MAC_LOCAL   0x04
-        u8     reserved[14];
+        __le16  lb_mode;
+#define I40E_AQ_LB_PHY_LOCAL    0x01
+#define I40E_AQ_LB_PHY_REMOTE   0x02
+#define I40E_AQ_LB_MAC_LOCAL    0x04
+        u8      reserved[14];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_set_lb_mode);
 
 /* Set PHY Debug command (0x0622) */
 struct i40e_aqc_set_phy_debug {
-        u8     command_flags;
+        u8      command_flags;
 #define I40E_AQ_PHY_DEBUG_RESET_INTERNAL        0x02
 #define I40E_AQ_PHY_DEBUG_RESET_EXTERNAL_SHIFT  2
 #define I40E_AQ_PHY_DEBUG_RESET_EXTERNAL_MASK   (0x03 << \
@@ -1757,15 +1756,15 @@ struct i40e_aqc_set_phy_debug {
 #define I40E_AQ_PHY_DEBUG_RESET_EXTERNAL_HARD   0x01
 #define I40E_AQ_PHY_DEBUG_RESET_EXTERNAL_SOFT   0x02
 #define I40E_AQ_PHY_DEBUG_DISABLE_LINK_FW       0x10
-        u8     reserved[15];
+        u8      reserved[15];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_set_phy_debug);
 
 enum i40e_aq_phy_reg_type {
-        I40E_AQC_PHY_REG_INTERNAL         = 0x1,
-        I40E_AQC_PHY_REG_EXERNAL_BASET    = 0x2,
-        I40E_AQC_PHY_REG_EXERNAL_MODULE   = 0x3
+        I40E_AQC_PHY_REG_INTERNAL       = 0x1,
+        I40E_AQC_PHY_REG_EXERNAL_BASET  = 0x2,
+        I40E_AQC_PHY_REG_EXERNAL_MODULE = 0x3
 };
 
 /* NVM Read command (indirect 0x0701)
@@ -1773,40 +1772,40 @@ enum i40e_aq_phy_reg_type {
  * NVM Update commands (indirect 0x0703)
  */
 struct i40e_aqc_nvm_update {
-        u8     command_flags;
-#define I40E_AQ_NVM_LAST_CMD    0x01
-#define I40E_AQ_NVM_FLASH_ONLY  0x80
-        u8     module_pointer;
-        __le16 length;
-        __le32 offset;
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      command_flags;
+#define I40E_AQ_NVM_LAST_CMD    0x01
+#define I40E_AQ_NVM_FLASH_ONLY  0x80
+        u8      module_pointer;
+        __le16  length;
+        __le32  offset;
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_nvm_update);
 
 /* NVM Config Read (indirect 0x0704) */
 struct i40e_aqc_nvm_config_read {
-        __le16 cmd_flags;
+        __le16  cmd_flags;
 #define ANVM_SINGLE_OR_MULTIPLE_FEATURES_MASK   1
 #define ANVM_READ_SINGLE_FEATURE                0
 #define ANVM_READ_MULTIPLE_FEATURES             1
-        __le16 element_count;
-        __le16 element_id;              /* Feature/field ID */
-        u8     reserved[2];
-        __le32 address_high;
-        __le32 address_low;
+        __le16  element_count;
+        __le16  element_id; /* Feature/field ID */
+        u8      reserved[2];
+        __le32  address_high;
+        __le32  address_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_nvm_config_read);
 
 /* NVM Config Write (indirect 0x0705) */
 struct i40e_aqc_nvm_config_write {
-        __le16 cmd_flags;
-        __le16 element_count;
-        u8     reserved[4];
-        __le32 address_high;
-        __le32 address_low;
+        __le16  cmd_flags;
+        __le16  element_count;
+        u8      reserved[4];
+        __le32  address_high;
+        __le32  address_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_nvm_config_write);
@@ -1831,10 +1830,10 @@ struct i40e_aqc_nvm_config_data_immediate_field {
  * Send to Peer PF command (indirect 0x0803)
  */
 struct i40e_aqc_pf_vf_message {
-        __le32 id;
-        u8     reserved[4];
-        __le32 addr_high;
-        __le32 addr_low;
+        __le32  id;
+        u8      reserved[4];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_pf_vf_message);
@@ -1870,22 +1869,22 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_alternate_ind_write);
  * uses i40e_aq_desc
  */
 struct i40e_aqc_alternate_write_done {
-        __le16 cmd_flags;
+        __le16  cmd_flags;
 #define I40E_AQ_ALTERNATE_MODE_BIOS_MASK        1
 #define I40E_AQ_ALTERNATE_MODE_BIOS_LEGACY      0
 #define I40E_AQ_ALTERNATE_MODE_BIOS_UEFI        1
 #define I40E_AQ_ALTERNATE_RESET_NEEDED          2
-        u8     reserved[14];
+        u8      reserved[14];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_alternate_write_done);
 
 /* Set OEM mode (direct 0x0905) */
 struct i40e_aqc_alternate_set_mode {
-        __le32 mode;
+        __le32  mode;
 #define I40E_AQ_ALTERNATE_MODE_NONE     0
 #define I40E_AQ_ALTERNATE_MODE_OEM      1
-        u8     reserved[12];
+        u8      reserved[12];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_alternate_set_mode);
@@ -1896,33 +1895,33 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_alternate_set_mode);
 
 /* Lan Queue Overflow Event (direct, 0x1001) */
 struct i40e_aqc_lan_overflow {
-        __le32 prtdcb_rupto;
-        __le32 otx_ctl;
-        u8     reserved[8];
+        __le32  prtdcb_rupto;
+        __le32  otx_ctl;
+        u8      reserved[8];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_lan_overflow);
 
 /* Get LLDP MIB (indirect 0x0A00) */
 struct i40e_aqc_lldp_get_mib {
-        u8     type;
-        u8     reserved1;
-#define I40E_AQ_LLDP_MIB_TYPE_MASK                      0x3
-#define I40E_AQ_LLDP_MIB_LOCAL                          0x0
-#define I40E_AQ_LLDP_MIB_REMOTE                         0x1
-#define I40E_AQ_LLDP_MIB_LOCAL_AND_REMOTE               0x2
-#define I40E_AQ_LLDP_BRIDGE_TYPE_MASK                   0xC
-#define I40E_AQ_LLDP_BRIDGE_TYPE_SHIFT                  0x2
-#define I40E_AQ_LLDP_BRIDGE_TYPE_NEAREST_BRIDGE         0x0
-#define I40E_AQ_LLDP_BRIDGE_TYPE_NON_TPMR               0x1
-#define I40E_AQ_LLDP_TX_SHIFT              0x4
-#define I40E_AQ_LLDP_TX_MASK               (0x03 << I40E_AQ_LLDP_TX_SHIFT)
+        u8      type;
+        u8      reserved1;
+#define I40E_AQ_LLDP_MIB_TYPE_MASK              0x3
+#define I40E_AQ_LLDP_MIB_LOCAL                  0x0
+#define I40E_AQ_LLDP_MIB_REMOTE                 0x1
+#define I40E_AQ_LLDP_MIB_LOCAL_AND_REMOTE       0x2
+#define I40E_AQ_LLDP_BRIDGE_TYPE_MASK           0xC
+#define I40E_AQ_LLDP_BRIDGE_TYPE_SHIFT          0x2
+#define I40E_AQ_LLDP_BRIDGE_TYPE_NEAREST_BRIDGE 0x0
+#define I40E_AQ_LLDP_BRIDGE_TYPE_NON_TPMR       0x1
+#define I40E_AQ_LLDP_TX_SHIFT                   0x4
+#define I40E_AQ_LLDP_TX_MASK                    (0x03 << I40E_AQ_LLDP_TX_SHIFT)
 /* TX pause flags use I40E_AQ_LINK_TX_* above */
-        __le16 local_len;
-        __le16 remote_len;
-        u8     reserved2[2];
-        __le32 addr_high;
-        __le32 addr_low;
+        __le16  local_len;
+        __le16  remote_len;
+        u8      reserved2[2];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_get_mib);
@@ -1931,12 +1930,12 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_get_mib);
  * also used for the event (with type in the command field)
  */
 struct i40e_aqc_lldp_update_mib {
-        u8     command;
-#define I40E_AQ_LLDP_MIB_UPDATE_ENABLE          0x0
-#define I40E_AQ_LLDP_MIB_UPDATE_DISABLE         0x1
-        u8     reserved[7];
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      command;
+#define I40E_AQ_LLDP_MIB_UPDATE_ENABLE  0x0
+#define I40E_AQ_LLDP_MIB_UPDATE_DISABLE 0x1
+        u8      reserved[7];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_update_mib);
@@ -1945,35 +1944,35 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_update_mib);
  * Delete LLDP TLV (indirect 0x0A04)
  */
 struct i40e_aqc_lldp_add_tlv {
-        u8     type; /* only nearest bridge and non-TPMR from 0x0A00 */
-        u8     reserved1[1];
-        __le16 len;
-        u8     reserved2[4];
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      type; /* only nearest bridge and non-TPMR from 0x0A00 */
+        u8      reserved1[1];
+        __le16  len;
+        u8      reserved2[4];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_add_tlv);
 
 /* Update LLDP TLV (indirect 0x0A03) */
 struct i40e_aqc_lldp_update_tlv {
-        u8     type; /* only nearest bridge and non-TPMR from 0x0A00 */
-        u8     reserved;
-        __le16 old_len;
-        __le16 new_offset;
-        __le16 new_len;
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      type; /* only nearest bridge and non-TPMR from 0x0A00 */
+        u8      reserved;
+        __le16  old_len;
+        __le16  new_offset;
+        __le16  new_len;
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_update_tlv);
 
 /* Stop LLDP (direct 0x0A05) */
 struct i40e_aqc_lldp_stop {
-        u8     command;
-#define I40E_AQ_LLDP_AGENT_STOP                 0x0
-#define I40E_AQ_LLDP_AGENT_SHUTDOWN             0x1
-        u8     reserved[15];
+        u8      command;
+#define I40E_AQ_LLDP_AGENT_STOP         0x0
+#define I40E_AQ_LLDP_AGENT_SHUTDOWN     0x1
+        u8      reserved[15];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_stop);
@@ -1981,9 +1980,9 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_stop);
 /* Start LLDP (direct 0x0A06) */
 
 struct i40e_aqc_lldp_start {
-        u8     command;
-#define I40E_AQ_LLDP_AGENT_START                0x1
-        u8     reserved[15];
+        u8      command;
+#define I40E_AQ_LLDP_AGENT_START        0x1
+        u8      reserved[15];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_start);
@@ -1994,44 +1993,44 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_start);
 
 /* Add Udp Tunnel command and completion (direct 0x0B00) */
 struct i40e_aqc_add_udp_tunnel {
-        __le16 udp_port;
-        u8     reserved0[3];
-        u8     protocol_type;
+        __le16  udp_port;
+        u8      reserved0[3];
+        u8      protocol_type;
 #define I40E_AQC_TUNNEL_TYPE_VXLAN      0x00
 #define I40E_AQC_TUNNEL_TYPE_NGE        0x01
 #define I40E_AQC_TUNNEL_TYPE_TEREDO     0x10
-        u8     reserved1[10];
+        u8      reserved1[10];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_udp_tunnel);
 
 struct i40e_aqc_add_udp_tunnel_completion {
-        __le16 udp_port;
-        u8     filter_entry_index;
-        u8     multiple_pfs;
-#define I40E_AQC_SINGLE_PF      0x0
-#define I40E_AQC_MULTIPLE_PFS   0x1
-        u8     total_filters;
-        u8     reserved[11];
+        __le16  udp_port;
+        u8      filter_entry_index;
+        u8      multiple_pfs;
+#define I40E_AQC_SINGLE_PF              0x0
+#define I40E_AQC_MULTIPLE_PFS           0x1
+        u8      total_filters;
+        u8      reserved[11];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_udp_tunnel_completion);
 
 /* remove UDP Tunnel command (0x0B01) */
 struct i40e_aqc_remove_udp_tunnel {
-        u8     reserved[2];
-        u8     index; /* 0 to 15 */
-        u8     reserved2[13];
+        u8      reserved[2];
+        u8      index; /* 0 to 15 */
+        u8      reserved2[13];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_remove_udp_tunnel);
 
 struct i40e_aqc_del_udp_tunnel_completion {
-        __le16 udp_port;
-        u8     index; /* 0 to 15 */
-        u8     multiple_pfs;
-        u8     total_filters_used;
-        u8     reserved1[11];
+        __le16  udp_port;
+        u8      index; /* 0 to 15 */
+        u8      multiple_pfs;
+        u8      total_filters_used;
+        u8      reserved1[11];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_del_udp_tunnel_completion);
@@ -2044,11 +2043,11 @@ struct i40e_aqc_tunnel_key_structure {
         u8      key1_len;  /* 0 to 15 */
         u8      key2_len;  /* 0 to 15 */
         u8      flags;
-#define I40E_AQC_TUNNEL_KEY_STRUCT_OVERRIDE 0x01
+#define I40E_AQC_TUNNEL_KEY_STRUCT_OVERRIDE     0x01
 /* response flags */
-#define I40E_AQC_TUNNEL_KEY_STRUCT_SUCCESS    0x01
-#define I40E_AQC_TUNNEL_KEY_STRUCT_MODIFIED   0x02
-#define I40E_AQC_TUNNEL_KEY_STRUCT_OVERRIDDEN 0x03
+#define I40E_AQC_TUNNEL_KEY_STRUCT_SUCCESS      0x01
+#define I40E_AQC_TUNNEL_KEY_STRUCT_MODIFIED     0x02
+#define I40E_AQC_TUNNEL_KEY_STRUCT_OVERRIDDEN   0x03
         u8      network_key_index;
 #define I40E_AQC_NETWORK_KEY_INDEX_VXLAN                0x0
 #define I40E_AQC_NETWORK_KEY_INDEX_NGE                  0x1
@@ -2061,21 +2060,21 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_tunnel_key_structure);
 
 /* OEM mode commands (direct 0xFE0x) */
 struct i40e_aqc_oem_param_change {
-        __le32 param_type;
-#define I40E_AQ_OEM_PARAM_TYPE_PF_CTL   0
-#define I40E_AQ_OEM_PARAM_TYPE_BW_CTL   1
-#define I40E_AQ_OEM_PARAM_MAC           2
-        __le32 param_value1;
-        u8     param_value2[8];
+        __le32  param_type;
+#define I40E_AQ_OEM_PARAM_TYPE_PF_CTL   0
+#define I40E_AQ_OEM_PARAM_TYPE_BW_CTL   1
+#define I40E_AQ_OEM_PARAM_MAC           2
+        __le32  param_value1;
+        u8      param_value2[8];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_oem_param_change);
 
 struct i40e_aqc_oem_state_change {
-        __le32 state;
-#define I40E_AQ_OEM_STATE_LINK_DOWN  0x0
-#define I40E_AQ_OEM_STATE_LINK_UP    0x1
-        u8     reserved[12];
+        __le32  state;
+#define I40E_AQ_OEM_STATE_LINK_DOWN     0x0
+#define I40E_AQ_OEM_STATE_LINK_UP       0x1
+        u8      reserved[12];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_oem_state_change);
@@ -2087,18 +2086,18 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_oem_state_change);
 /* set test more (0xFF01, internal) */
 
 struct i40e_acq_set_test_mode {
-        u8     mode;
-#define I40E_AQ_TEST_PARTIAL    0
-#define I40E_AQ_TEST_FULL       1
-#define I40E_AQ_TEST_NVM        2
-        u8     reserved[3];
-        u8     command;
-#define I40E_AQ_TEST_OPEN        0
-#define I40E_AQ_TEST_CLOSE       1
-#define I40E_AQ_TEST_INC         2
-        u8     reserved2[3];
-        __le32 address_high;
-        __le32 address_low;
+        u8      mode;
+#define I40E_AQ_TEST_PARTIAL    0
+#define I40E_AQ_TEST_FULL       1
+#define I40E_AQ_TEST_NVM        2
+        u8      reserved[3];
+        u8      command;
+#define I40E_AQ_TEST_OPEN       0
+#define I40E_AQ_TEST_CLOSE      1
+#define I40E_AQ_TEST_INC        2
+        u8      reserved2[3];
+        __le32  address_high;
+        __le32  address_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_acq_set_test_mode);
@@ -2151,21 +2150,21 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_debug_modify_reg);
 #define I40E_AQ_CLUSTER_ID_ALTRAM       11
 
 struct i40e_aqc_debug_dump_internals {
-        u8     cluster_id;
-        u8     table_id;
-        __le16 data_size;
-        __le32 idx;
-        __le32 address_high;
-        __le32 address_low;
+        u8      cluster_id;
+        u8      table_id;
+        __le16  data_size;
+        __le32  idx;
+        __le32  address_high;
+        __le32  address_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_debug_dump_internals);
 
 struct i40e_aqc_debug_modify_internals {
-        u8     cluster_id;
-        u8     cluster_specific_params[7];
-        __le32 address_high;
-        __le32 address_low;
+        u8      cluster_id;
+        u8      cluster_specific_params[7];
+        __le32  address_high;
+        __le32  address_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_debug_modify_internals);
diff --git a/drivers/net/ethernet/intel/i40e/i40e_common.c b/drivers/net/ethernet/intel/i40e/i40e_common.c
index 30056b25d94e..c49416cfe616 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_common.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_common.c
@@ -50,6 +50,7 @@ static i40e_status i40e_set_mac_type(struct i40e_hw *hw)
                 case I40E_DEV_ID_QSFP_A:
                 case I40E_DEV_ID_QSFP_B:
                 case I40E_DEV_ID_QSFP_C:
+                case I40E_DEV_ID_10G_BASE_T:
                         hw->mac.type = I40E_MAC_XL710;
                         break;
                 case I40E_DEV_ID_VF:
@@ -1420,6 +1421,33 @@ i40e_status i40e_update_link_info(struct i40e_hw *hw, bool enable_lse)
 }
 
 /**
+ * i40e_aq_set_phy_int_mask
+ * @hw: pointer to the hw struct
+ * @mask: interrupt mask to be set
+ * @cmd_details: pointer to command details structure or NULL
+ *
+ * Set link interrupt mask.
+ **/
+i40e_status i40e_aq_set_phy_int_mask(struct i40e_hw *hw,
+                                     u16 mask,
+                                     struct i40e_asq_cmd_details *cmd_details)
+{
+        struct i40e_aq_desc desc;
+        struct i40e_aqc_set_phy_int_mask *cmd =
+                (struct i40e_aqc_set_phy_int_mask *)&desc.params.raw;
+        i40e_status status;
+
+        i40e_fill_default_direct_cmd_desc(&desc,
+                                          i40e_aqc_opc_set_phy_int_mask);
+
+        cmd->event_mask = cpu_to_le16(mask);
+
+        status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
+
+        return status;
+}
+
+/**
  * i40e_aq_add_vsi
  * @hw: pointer to the hw struct
  * @vsi_ctx: pointer to a vsi context struct
diff --git a/drivers/net/ethernet/intel/i40e/i40e_ethtool.c b/drivers/net/ethernet/intel/i40e/i40e_ethtool.c
index 1dda467ae1ac..12adc08c54dc 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_ethtool.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_ethtool.c
@@ -264,6 +264,14 @@ static int i40e_get_settings(struct net_device *netdev,
                         ecmd->supported = SUPPORTED_10000baseKR_Full;
                         ecmd->advertising = ADVERTISED_10000baseKR_Full;
                         break;
+                case I40E_DEV_ID_10G_BASE_T:
+                        ecmd->supported = SUPPORTED_10000baseT_Full |
+                                          SUPPORTED_1000baseT_Full |
+                                          SUPPORTED_100baseT_Full;
+                        ecmd->advertising = ADVERTISED_10000baseT_Full |
+                                            ADVERTISED_1000baseT_Full |
+                                            ADVERTISED_100baseT_Full;
+                        break;
                 default:
                         /* all the rest are 10G/1G */
                         ecmd->supported = SUPPORTED_10000baseT_Full |
@@ -322,9 +330,13 @@ static int i40e_get_settings(struct net_device *netdev,
         case I40E_PHY_TYPE_10GBASE_CR1:
         case I40E_PHY_TYPE_10GBASE_T:
                 ecmd->supported = SUPPORTED_Autoneg |
-                                  SUPPORTED_10000baseT_Full;
+                                  SUPPORTED_10000baseT_Full |
+                                  SUPPORTED_1000baseT_Full |
+                                  SUPPORTED_100baseT_Full;
                 ecmd->advertising = ADVERTISED_Autoneg |
-                                    ADVERTISED_10000baseT_Full;
+                                    ADVERTISED_10000baseT_Full |
+                                    ADVERTISED_1000baseT_Full |
+                                    ADVERTISED_100baseT_Full;
                 break;
         case I40E_PHY_TYPE_XAUI:
         case I40E_PHY_TYPE_XFI:
@@ -335,14 +347,22 @@ static int i40e_get_settings(struct net_device *netdev,
         case I40E_PHY_TYPE_1000BASE_KX:
         case I40E_PHY_TYPE_1000BASE_T:
                 ecmd->supported = SUPPORTED_Autoneg |
-                                  SUPPORTED_1000baseT_Full;
+                                  SUPPORTED_10000baseT_Full |
+                                  SUPPORTED_1000baseT_Full |
+                                  SUPPORTED_100baseT_Full;
                 ecmd->advertising = ADVERTISED_Autoneg |
-                                    ADVERTISED_1000baseT_Full;
+                                    ADVERTISED_10000baseT_Full |
+                                    ADVERTISED_1000baseT_Full |
+                                    ADVERTISED_100baseT_Full;
                 break;
         case I40E_PHY_TYPE_100BASE_TX:
                 ecmd->supported = SUPPORTED_Autoneg |
+                                  SUPPORTED_10000baseT_Full |
+                                  SUPPORTED_1000baseT_Full |
                                   SUPPORTED_100baseT_Full;
                 ecmd->advertising = ADVERTISED_Autoneg |
+                                    ADVERTISED_10000baseT_Full |
+                                    ADVERTISED_1000baseT_Full |
                                     ADVERTISED_100baseT_Full;
                 break;
         case I40E_PHY_TYPE_SGMII:
@@ -426,6 +446,9 @@ no_valid_phy_type:
                 case I40E_LINK_SPEED_1GB:
                         ethtool_cmd_speed_set(ecmd, SPEED_1000);
                         break;
+                case I40E_LINK_SPEED_100MB:
+                        ethtool_cmd_speed_set(ecmd, SPEED_100);
+                        break;
                 default:
                         break;
                 }
@@ -528,7 +551,7 @@ static int i40e_set_settings(struct net_device *netdev,
                 }
                 /* If autoneg is currently enabled */
                 if (hw->phy.link_info.an_info & I40E_AQ_AN_COMPLETED) {
-                        config.abilities = abilities.abilities |
+                        config.abilities = abilities.abilities &
                                            ~I40E_AQ_PHY_ENABLE_AN;
                         change = true;
                 }
diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c
index c3a7f4a4b775..834c9ffc6267 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_main.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_main.c
@@ -39,7 +39,7 @@ static const char i40e_driver_string[] =
 
 #define DRV_VERSION_MAJOR 1
 #define DRV_VERSION_MINOR 0
-#define DRV_VERSION_BUILD 11
+#define DRV_VERSION_BUILD 21
 #define DRV_VERSION __stringify(DRV_VERSION_MAJOR) "." \
              __stringify(DRV_VERSION_MINOR) "." \
              __stringify(DRV_VERSION_BUILD)    DRV_KERN
@@ -74,6 +74,7 @@ static const struct pci_device_id i40e_pci_tbl[] = {
         {PCI_VDEVICE(INTEL, I40E_DEV_ID_QSFP_A), 0},
         {PCI_VDEVICE(INTEL, I40E_DEV_ID_QSFP_B), 0},
         {PCI_VDEVICE(INTEL, I40E_DEV_ID_QSFP_C), 0},
+        {PCI_VDEVICE(INTEL, I40E_DEV_ID_10G_BASE_T), 0},
         /* required last entry */
         {0, }
 };
@@ -812,7 +813,10 @@ static void i40e_update_vsi_stats(struct i40e_vsi *vsi)
         struct i40e_eth_stats *oes;
         struct i40e_eth_stats *es;     /* device's eth stats */
         u32 tx_restart, tx_busy;
+        struct i40e_ring *p;
         u32 rx_page, rx_buf;
+        u64 bytes, packets;
+        unsigned int start;
         u64 rx_p, rx_b;
         u64 tx_p, tx_b;
         u16 q;
@@ -836,10 +840,6 @@ static void i40e_update_vsi_stats(struct i40e_vsi *vsi)
         rx_buf = 0;
         rcu_read_lock();
         for (q = 0; q < vsi->num_queue_pairs; q++) {
-                struct i40e_ring *p;
-                u64 bytes, packets;
-                unsigned int start;
-
                 /* locate Tx ring */
                 p = ACCESS_ONCE(vsi->tx_rings[q]);
 
@@ -3440,7 +3440,7 @@ static int i40e_pf_txq_wait(struct i40e_pf *pf, int pf_q, bool enable)
                 if (enable == !!(tx_reg & I40E_QTX_ENA_QENA_STAT_MASK))
                         break;
 
-                udelay(10);
+                usleep_range(10, 20);
         }
         if (i >= I40E_QUEUE_WAIT_RETRY_LIMIT)
                 return -ETIMEDOUT;
@@ -3466,7 +3466,7 @@ static int i40e_vsi_control_tx(struct i40e_vsi *vsi, bool enable)
                 /* warn the TX unit of coming changes */
                 i40e_pre_tx_queue_cfg(&pf->hw, pf_q, enable);
                 if (!enable)
-                        udelay(10);
+                        usleep_range(10, 20);
 
                 for (j = 0; j < 50; j++) {
                         tx_reg = rd32(hw, I40E_QTX_ENA(pf_q));
@@ -3526,7 +3526,7 @@ static int i40e_pf_rxq_wait(struct i40e_pf *pf, int pf_q, bool enable)
                 if (enable == !!(rx_reg & I40E_QRX_ENA_QENA_STAT_MASK))
                         break;
 
-                udelay(10);
+                usleep_range(10, 20);
         }
         if (i >= I40E_QUEUE_WAIT_RETRY_LIMIT)
                 return -ETIMEDOUT;
@@ -4449,6 +4449,9 @@ static void i40e_print_link_message(struct i40e_vsi *vsi, bool isup)
         case I40E_LINK_SPEED_1GB:
                 strlcpy(speed, "1000 Mbps", SPEED_SIZE);
                 break;
+        case I40E_LINK_SPEED_100MB:
+                strncpy(speed, "100 Mbps", SPEED_SIZE);
+                break;
         default:
                 break;
         }
@@ -4479,12 +4482,8 @@ static void i40e_print_link_message(struct i40e_vsi *vsi, bool isup)
 static int i40e_up_complete(struct i40e_vsi *vsi)
 {
         struct i40e_pf *pf = vsi->back;
-        u8 set_fc_aq_fail = 0;
         int err;
 
-        /* force flow control off */
-        i40e_set_fc(&pf->hw, &set_fc_aq_fail, true);
-
         if (pf->flags & I40E_FLAG_MSIX_ENABLED)
                 i40e_vsi_configure_msix(vsi);
         else
@@ -5354,10 +5353,14 @@ static void i40e_link_event(struct i40e_pf *pf)
 {
         bool new_link, old_link;
 
-        new_link = (pf->hw.phy.link_info.link_info & I40E_AQ_LINK_UP);
+        /* set this to force the get_link_status call to refresh state */
+        pf->hw.phy.get_link_info = true;
+
         old_link = (pf->hw.phy.link_info_old.link_info & I40E_AQ_LINK_UP);
+        new_link = i40e_get_link_status(&pf->hw);
 
-        if (new_link == old_link)
+        if (new_link == old_link &&
+            new_link == netif_carrier_ok(pf->vsi[pf->lan_vsi]->netdev))
                 return;
         if (!test_bit(__I40E_DOWN, &pf->vsi[pf->lan_vsi]->state))
                 i40e_print_link_message(pf->vsi[pf->lan_vsi], new_link);
@@ -5525,33 +5528,20 @@ static void i40e_handle_link_event(struct i40e_pf *pf,
         memcpy(&pf->hw.phy.link_info_old, hw_link_info,
                sizeof(pf->hw.phy.link_info_old));
 
+        /* Do a new status request to re-enable LSE reporting
+         * and load new status information into the hw struct
+         * This completely ignores any state information
+         * in the ARQ event info, instead choosing to always
+         * issue the AQ update link status command.
+         */
+        i40e_link_event(pf);
+
         /* check for unqualified module, if link is down */
         if ((status->link_info & I40E_AQ_MEDIA_AVAILABLE) &&
             (!(status->an_info & I40E_AQ_QUALIFIED_MODULE)) &&
             (!(status->link_info & I40E_AQ_LINK_UP)))
                 dev_err(&pf->pdev->dev,
                         "The driver failed to link because an unqualified module was detected.\n");
-
-        /* update link status */
-        hw_link_info->phy_type = (enum i40e_aq_phy_type)status->phy_type;
-        hw_link_info->link_speed = (enum i40e_aq_link_speed)status->link_speed;
-        hw_link_info->link_info = status->link_info;
-        hw_link_info->an_info = status->an_info;
-        hw_link_info->ext_info = status->ext_info;
-        hw_link_info->lse_enable =
-                le16_to_cpu(status->command_flags) &
-                            I40E_AQ_LSE_ENABLE;
-
-        /* process the event */
-        i40e_link_event(pf);
-
-        /* Do a new status request to re-enable LSE reporting
-         * and load new status information into the hw struct,
-         * then see if the status changed while processing the
-         * initial event.
-         */
-        i40e_update_link_info(&pf->hw, true);
-        i40e_link_event(pf);
 }
 
 /**
@@ -5967,6 +5957,7 @@ static void i40e_send_version(struct i40e_pf *pf)
 static void i40e_reset_and_rebuild(struct i40e_pf *pf, bool reinit)
 {
         struct i40e_hw *hw = &pf->hw;
+        u8 set_fc_aq_fail = 0;
         i40e_status ret;
         u32 v;
 
@@ -6038,6 +6029,20 @@ static void i40e_reset_and_rebuild(struct i40e_pf *pf, bool reinit)
         if (ret)
                 goto end_core_reset;
 
+        /* driver is only interested in link up/down and module qualification
+         * reports from firmware
+         */
+        ret = i40e_aq_set_phy_int_mask(&pf->hw,
+                                       I40E_AQ_EVENT_LINK_UPDOWN |
+                                       I40E_AQ_EVENT_MODULE_QUAL_FAIL, NULL);
+        if (ret)
+                dev_info(&pf->pdev->dev, "set phy mask fail, aq_err %d\n", ret);
+
+        /* make sure our flow control settings are restored */
+        ret = i40e_set_fc(&pf->hw, &set_fc_aq_fail, true);
+        if (ret)
+                dev_info(&pf->pdev->dev, "set fc fail, aq_err %d\n", ret);
+
         /* Rebuild the VSIs and VEBs that existed before reset.
          * They are still in our local switch element arrays, so only
          * need to rebuild the switch model in the HW.
@@ -6092,6 +6097,13 @@ static void i40e_reset_and_rebuild(struct i40e_pf *pf, bool reinit)
                 }
         }
 
+        msleep(75);
+        ret = i40e_aq_set_link_restart_an(&pf->hw, true, NULL);
+        if (ret) {
+                dev_info(&pf->pdev->dev, "link restart failed, aq_err=%d\n",
+                         pf->hw.aq.asq_last_status);
+        }
+
         /* reinit the misc interrupt */
         if (pf->flags & I40E_FLAG_MSIX_ENABLED)
                 ret = i40e_setup_misc_vector(pf);
@@ -6305,6 +6317,8 @@ static void i40e_service_task(struct work_struct *work)
 #endif
         i40e_clean_adminq_subtask(pf);
 
+        i40e_link_event(pf);
+
         i40e_service_event_complete(pf);
 
         /* If the tasks have taken longer than one timer cycle or there
@@ -8719,6 +8733,14 @@ static int i40e_setup_pf_switch(struct i40e_pf *pf, bool reinit)
         pf->fc_autoneg_status = ((pf->hw.phy.link_info.an_info &
                                   I40E_AQ_AN_COMPLETED) ? true : false);
 
+        /* fill in link information and enable LSE reporting */
+        i40e_update_link_info(&pf->hw, true);
+        i40e_link_event(pf);
+
+        /* Initialize user-specific link properties */
+        pf->fc_autoneg_status = ((pf->hw.phy.link_info.an_info &
+                                  I40E_AQ_AN_COMPLETED) ? true : false);
+
         i40e_ptp_init(pf);
 
         return ret;
@@ -9158,6 +9180,22 @@ static int i40e_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 }
         }
 
+        /* driver is only interested in link up/down and module qualification
+         * reports from firmware
+         */
+        err = i40e_aq_set_phy_int_mask(&pf->hw,
+                                       I40E_AQ_EVENT_LINK_UPDOWN |
+                                       I40E_AQ_EVENT_MODULE_QUAL_FAIL, NULL);
+        if (err)
+                dev_info(&pf->pdev->dev, "set phy mask fail, aq_err %d\n", err);
+
+        msleep(75);
+        err = i40e_aq_set_link_restart_an(&pf->hw, true, NULL);
+        if (err) {
+                dev_info(&pf->pdev->dev, "link restart failed, aq_err=%d\n",
+                         pf->hw.aq.asq_last_status);
+        }
+
         /* The main driver is (mostly) up and happy. We need to set this state
          * before setting up the misc vector or we get a race and the vector
          * ends up disabled forever.
diff --git a/drivers/net/ethernet/intel/i40e/i40e_prototype.h b/drivers/net/ethernet/intel/i40e/i40e_prototype.h
index 0988b5c1fe87..246c27869a63 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_prototype.h
+++ b/drivers/net/ethernet/intel/i40e/i40e_prototype.h
@@ -84,6 +84,8 @@ enum i40e_status_code i40e_aq_set_phy_config(struct i40e_hw *hw,
                                 struct i40e_asq_cmd_details *cmd_details);
 enum i40e_status_code i40e_set_fc(struct i40e_hw *hw, u8 *aq_failures,
                                   bool atomic_reset);
+i40e_status i40e_aq_set_phy_int_mask(struct i40e_hw *hw, u16 mask,
+                                     struct i40e_asq_cmd_details *cmd_details);
 i40e_status i40e_aq_clear_pxe_mode(struct i40e_hw *hw,
                                 struct i40e_asq_cmd_details *cmd_details);
 i40e_status i40e_aq_set_link_restart_an(struct i40e_hw *hw,
diff --git a/drivers/net/ethernet/intel/i40e/i40e_type.h b/drivers/net/ethernet/intel/i40e/i40e_type.h
index ce04d9093db6..3a237c3d0dcb 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_type.h
+++ b/drivers/net/ethernet/intel/i40e/i40e_type.h
@@ -43,6 +43,7 @@
 #define I40E_DEV_ID_QSFP_A              0x1583
 #define I40E_DEV_ID_QSFP_B              0x1584
 #define I40E_DEV_ID_QSFP_C              0x1585
+#define I40E_DEV_ID_10G_BASE_T          0x1586
 #define I40E_DEV_ID_VF                  0x154C
 #define I40E_DEV_ID_VF_HV               0x1571
 
diff --git a/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c b/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c
index 4eeed267e4b7..fff3c276736b 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c
@@ -674,7 +674,7 @@ void i40e_reset_vf(struct i40e_vf *vf, bool flr)
                  * that the requested op was completed
                  * successfully
                  */
-                udelay(10);
+                usleep_range(10, 20);
                 reg = rd32(hw, I40E_VPGEN_VFRSTAT(vf->vf_id));
                 if (reg & I40E_VPGEN_VFRSTAT_VFRD_MASK) {
                         rsd = true;
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_adminq_cmd.h b/drivers/net/ethernet/intel/i40evf/i40e_adminq_cmd.h
index e656ea7a7920..ff1b16370da9 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_adminq_cmd.h
+++ b/drivers/net/ethernet/intel/i40evf/i40e_adminq_cmd.h
@@ -33,8 +33,8 @@
  * This file needs to comply with the Linux Kernel coding style.
  */
 
-#define I40E_FW_API_VERSION_MAJOR  0x0001
-#define I40E_FW_API_VERSION_MINOR  0x0002
+#define I40E_FW_API_VERSION_MAJOR       0x0001
+#define I40E_FW_API_VERSION_MINOR       0x0002
 #define I40E_FW_API_VERSION_A0_MINOR  0x0000
 
 struct i40e_aq_desc {
@@ -67,216 +67,216 @@ struct i40e_aq_desc {
  */
 
 /* command flags and offsets*/
-#define I40E_AQ_FLAG_DD_SHIFT  0
-#define I40E_AQ_FLAG_CMP_SHIFT 1
-#define I40E_AQ_FLAG_ERR_SHIFT 2
-#define I40E_AQ_FLAG_VFE_SHIFT 3
-#define I40E_AQ_FLAG_LB_SHIFT  9
-#define I40E_AQ_FLAG_RD_SHIFT  10
-#define I40E_AQ_FLAG_VFC_SHIFT 11
-#define I40E_AQ_FLAG_BUF_SHIFT 12
-#define I40E_AQ_FLAG_SI_SHIFT  13
-#define I40E_AQ_FLAG_EI_SHIFT  14
-#define I40E_AQ_FLAG_FE_SHIFT  15
-
-#define I40E_AQ_FLAG_DD  (1 << I40E_AQ_FLAG_DD_SHIFT)  /* 0x1    */
-#define I40E_AQ_FLAG_CMP (1 << I40E_AQ_FLAG_CMP_SHIFT) /* 0x2    */
-#define I40E_AQ_FLAG_ERR (1 << I40E_AQ_FLAG_ERR_SHIFT) /* 0x4    */
-#define I40E_AQ_FLAG_VFE (1 << I40E_AQ_FLAG_VFE_SHIFT) /* 0x8    */
-#define I40E_AQ_FLAG_LB  (1 << I40E_AQ_FLAG_LB_SHIFT)  /* 0x200  */
-#define I40E_AQ_FLAG_RD  (1 << I40E_AQ_FLAG_RD_SHIFT)  /* 0x400  */
-#define I40E_AQ_FLAG_VFC (1 << I40E_AQ_FLAG_VFC_SHIFT) /* 0x800  */
-#define I40E_AQ_FLAG_BUF (1 << I40E_AQ_FLAG_BUF_SHIFT) /* 0x1000 */
-#define I40E_AQ_FLAG_SI  (1 << I40E_AQ_FLAG_SI_SHIFT)  /* 0x2000 */
-#define I40E_AQ_FLAG_EI  (1 << I40E_AQ_FLAG_EI_SHIFT)  /* 0x4000 */
-#define I40E_AQ_FLAG_FE  (1 << I40E_AQ_FLAG_FE_SHIFT)  /* 0x8000 */
+#define I40E_AQ_FLAG_DD_SHIFT   0
+#define I40E_AQ_FLAG_CMP_SHIFT  1
+#define I40E_AQ_FLAG_ERR_SHIFT  2
+#define I40E_AQ_FLAG_VFE_SHIFT  3
+#define I40E_AQ_FLAG_LB_SHIFT   9
+#define I40E_AQ_FLAG_RD_SHIFT   10
+#define I40E_AQ_FLAG_VFC_SHIFT  11
+#define I40E_AQ_FLAG_BUF_SHIFT  12
+#define I40E_AQ_FLAG_SI_SHIFT   13
+#define I40E_AQ_FLAG_EI_SHIFT   14
+#define I40E_AQ_FLAG_FE_SHIFT   15
+
+#define I40E_AQ_FLAG_DD         (1 << I40E_AQ_FLAG_DD_SHIFT)  /* 0x1    */
+#define I40E_AQ_FLAG_CMP        (1 << I40E_AQ_FLAG_CMP_SHIFT) /* 0x2    */
+#define I40E_AQ_FLAG_ERR        (1 << I40E_AQ_FLAG_ERR_SHIFT) /* 0x4    */
+#define I40E_AQ_FLAG_VFE        (1 << I40E_AQ_FLAG_VFE_SHIFT) /* 0x8    */
+#define I40E_AQ_FLAG_LB         (1 << I40E_AQ_FLAG_LB_SHIFT)  /* 0x200  */
+#define I40E_AQ_FLAG_RD         (1 << I40E_AQ_FLAG_RD_SHIFT)  /* 0x400  */
+#define I40E_AQ_FLAG_VFC        (1 << I40E_AQ_FLAG_VFC_SHIFT) /* 0x800  */
+#define I40E_AQ_FLAG_BUF        (1 << I40E_AQ_FLAG_BUF_SHIFT) /* 0x1000 */
+#define I40E_AQ_FLAG_SI         (1 << I40E_AQ_FLAG_SI_SHIFT)  /* 0x2000 */
+#define I40E_AQ_FLAG_EI         (1 << I40E_AQ_FLAG_EI_SHIFT)  /* 0x4000 */
+#define I40E_AQ_FLAG_FE         (1 << I40E_AQ_FLAG_FE_SHIFT)  /* 0x8000 */
 
 /* error codes */
 enum i40e_admin_queue_err {
-        I40E_AQ_RC_OK       = 0,    /* success */
-        I40E_AQ_RC_EPERM    = 1,    /* Operation not permitted */
-        I40E_AQ_RC_ENOENT   = 2,    /* No such element */
-        I40E_AQ_RC_ESRCH    = 3,    /* Bad opcode */
-        I40E_AQ_RC_EINTR    = 4,    /* operation interrupted */
-        I40E_AQ_RC_EIO      = 5,    /* I/O error */
-        I40E_AQ_RC_ENXIO    = 6,    /* No such resource */
-        I40E_AQ_RC_E2BIG    = 7,    /* Arg too long */
-        I40E_AQ_RC_EAGAIN   = 8,    /* Try again */
-        I40E_AQ_RC_ENOMEM   = 9,    /* Out of memory */
-        I40E_AQ_RC_EACCES   = 10,   /* Permission denied */
-        I40E_AQ_RC_EFAULT   = 11,   /* Bad address */
-        I40E_AQ_RC_EBUSY    = 12,   /* Device or resource busy */
-        I40E_AQ_RC_EEXIST   = 13,   /* object already exists */
-        I40E_AQ_RC_EINVAL   = 14,   /* Invalid argument */
-        I40E_AQ_RC_ENOTTY   = 15,   /* Not a typewriter */
-        I40E_AQ_RC_ENOSPC   = 16,   /* No space left or alloc failure */
-        I40E_AQ_RC_ENOSYS   = 17,   /* Function not implemented */
-        I40E_AQ_RC_ERANGE   = 18,   /* Parameter out of range */
-        I40E_AQ_RC_EFLUSHED = 19,   /* Cmd flushed because of prev cmd error */
-        I40E_AQ_RC_BAD_ADDR = 20,   /* Descriptor contains a bad pointer */
-        I40E_AQ_RC_EMODE    = 21,   /* Op not allowed in current dev mode */
-        I40E_AQ_RC_EFBIG    = 22,   /* File too large */
+        I40E_AQ_RC_OK           = 0,  /* success */
+        I40E_AQ_RC_EPERM        = 1,  /* Operation not permitted */
+        I40E_AQ_RC_ENOENT       = 2,  /* No such element */
+        I40E_AQ_RC_ESRCH        = 3,  /* Bad opcode */
+        I40E_AQ_RC_EINTR        = 4,  /* operation interrupted */
+        I40E_AQ_RC_EIO          = 5,  /* I/O error */
+        I40E_AQ_RC_ENXIO        = 6,  /* No such resource */
+        I40E_AQ_RC_E2BIG        = 7,  /* Arg too long */
+        I40E_AQ_RC_EAGAIN       = 8,  /* Try again */
+        I40E_AQ_RC_ENOMEM       = 9,  /* Out of memory */
+        I40E_AQ_RC_EACCES       = 10, /* Permission denied */
+        I40E_AQ_RC_EFAULT       = 11, /* Bad address */
+        I40E_AQ_RC_EBUSY        = 12, /* Device or resource busy */
+        I40E_AQ_RC_EEXIST       = 13, /* object already exists */
+        I40E_AQ_RC_EINVAL       = 14, /* Invalid argument */
+        I40E_AQ_RC_ENOTTY       = 15, /* Not a typewriter */
+        I40E_AQ_RC_ENOSPC       = 16, /* No space left or alloc failure */
+        I40E_AQ_RC_ENOSYS       = 17, /* Function not implemented */
+        I40E_AQ_RC_ERANGE       = 18, /* Parameter out of range */
+        I40E_AQ_RC_EFLUSHED     = 19, /* Cmd flushed due to prev cmd error */
+        I40E_AQ_RC_BAD_ADDR     = 20, /* Descriptor contains a bad pointer */
+        I40E_AQ_RC_EMODE        = 21, /* Op not allowed in current dev mode */
+        I40E_AQ_RC_EFBIG        = 22, /* File too large */
 };
 
 /* Admin Queue command opcodes */
 enum i40e_admin_queue_opc {
         /* aq commands */
-        i40e_aqc_opc_get_version      = 0x0001,
-        i40e_aqc_opc_driver_version   = 0x0002,
-        i40e_aqc_opc_queue_shutdown   = 0x0003,
-        i40e_aqc_opc_set_pf_context   = 0x0004,
+        i40e_aqc_opc_get_version        = 0x0001,
+        i40e_aqc_opc_driver_version     = 0x0002,
+        i40e_aqc_opc_queue_shutdown     = 0x0003,
+        i40e_aqc_opc_set_pf_context     = 0x0004,
 
         /* resource ownership */
-        i40e_aqc_opc_request_resource = 0x0008,
-        i40e_aqc_opc_release_resource = 0x0009,
+        i40e_aqc_opc_request_resource   = 0x0008,
+        i40e_aqc_opc_release_resource   = 0x0009,
 
-        i40e_aqc_opc_list_func_capabilities = 0x000A,
-        i40e_aqc_opc_list_dev_capabilities  = 0x000B,
+        i40e_aqc_opc_list_func_capabilities     = 0x000A,
+        i40e_aqc_opc_list_dev_capabilities      = 0x000B,
 
-        i40e_aqc_opc_set_cppm_configuration = 0x0103,
-        i40e_aqc_opc_set_arp_proxy_entry    = 0x0104,
-        i40e_aqc_opc_set_ns_proxy_entry     = 0x0105,
+        i40e_aqc_opc_set_cppm_configuration     = 0x0103,
+        i40e_aqc_opc_set_arp_proxy_entry        = 0x0104,
+        i40e_aqc_opc_set_ns_proxy_entry         = 0x0105,
 
         /* LAA */
-        i40e_aqc_opc_mng_laa                = 0x0106,   /* AQ obsolete */
-        i40e_aqc_opc_mac_address_read       = 0x0107,
-        i40e_aqc_opc_mac_address_write      = 0x0108,
+        i40e_aqc_opc_mng_laa            = 0x0106,   /* AQ obsolete */
+        i40e_aqc_opc_mac_address_read   = 0x0107,
+        i40e_aqc_opc_mac_address_write  = 0x0108,
 
         /* PXE */
-        i40e_aqc_opc_clear_pxe_mode         = 0x0110,
+        i40e_aqc_opc_clear_pxe_mode     = 0x0110,
 
         /* internal switch commands */
-        i40e_aqc_opc_get_switch_config         = 0x0200,
-        i40e_aqc_opc_add_statistics            = 0x0201,
-        i40e_aqc_opc_remove_statistics         = 0x0202,
-        i40e_aqc_opc_set_port_parameters       = 0x0203,
-        i40e_aqc_opc_get_switch_resource_alloc = 0x0204,
-
-        i40e_aqc_opc_add_vsi                = 0x0210,
-        i40e_aqc_opc_update_vsi_parameters  = 0x0211,
-        i40e_aqc_opc_get_vsi_parameters     = 0x0212,
-
-        i40e_aqc_opc_add_pv                = 0x0220,
-        i40e_aqc_opc_update_pv_parameters  = 0x0221,
-        i40e_aqc_opc_get_pv_parameters     = 0x0222,
-
-        i40e_aqc_opc_add_veb               = 0x0230,
-        i40e_aqc_opc_update_veb_parameters = 0x0231,
-        i40e_aqc_opc_get_veb_parameters    = 0x0232,
-
-        i40e_aqc_opc_delete_element  = 0x0243,
-
-        i40e_aqc_opc_add_macvlan                  = 0x0250,
-        i40e_aqc_opc_remove_macvlan               = 0x0251,
-        i40e_aqc_opc_add_vlan                     = 0x0252,
-        i40e_aqc_opc_remove_vlan                  = 0x0253,
-        i40e_aqc_opc_set_vsi_promiscuous_modes    = 0x0254,
-        i40e_aqc_opc_add_tag                      = 0x0255,
-        i40e_aqc_opc_remove_tag                   = 0x0256,
-        i40e_aqc_opc_add_multicast_etag           = 0x0257,
-        i40e_aqc_opc_remove_multicast_etag        = 0x0258,
-        i40e_aqc_opc_update_tag                   = 0x0259,
-        i40e_aqc_opc_add_control_packet_filter    = 0x025A,
-        i40e_aqc_opc_remove_control_packet_filter = 0x025B,
-        i40e_aqc_opc_add_cloud_filters            = 0x025C,
-        i40e_aqc_opc_remove_cloud_filters         = 0x025D,
-
-        i40e_aqc_opc_add_mirror_rule    = 0x0260,
-        i40e_aqc_opc_delete_mirror_rule = 0x0261,
+        i40e_aqc_opc_get_switch_config          = 0x0200,
+        i40e_aqc_opc_add_statistics             = 0x0201,
+        i40e_aqc_opc_remove_statistics          = 0x0202,
+        i40e_aqc_opc_set_port_parameters        = 0x0203,
+        i40e_aqc_opc_get_switch_resource_alloc  = 0x0204,
+
+        i40e_aqc_opc_add_vsi                    = 0x0210,
+        i40e_aqc_opc_update_vsi_parameters      = 0x0211,
+        i40e_aqc_opc_get_vsi_parameters         = 0x0212,
+
+        i40e_aqc_opc_add_pv                     = 0x0220,
+        i40e_aqc_opc_update_pv_parameters       = 0x0221,
+        i40e_aqc_opc_get_pv_parameters          = 0x0222,
+
+        i40e_aqc_opc_add_veb                    = 0x0230,
+        i40e_aqc_opc_update_veb_parameters      = 0x0231,
+        i40e_aqc_opc_get_veb_parameters         = 0x0232,
+
+        i40e_aqc_opc_delete_element             = 0x0243,
+
+        i40e_aqc_opc_add_macvlan                = 0x0250,
+        i40e_aqc_opc_remove_macvlan             = 0x0251,
+        i40e_aqc_opc_add_vlan                   = 0x0252,
+        i40e_aqc_opc_remove_vlan                = 0x0253,
+        i40e_aqc_opc_set_vsi_promiscuous_modes  = 0x0254,
+        i40e_aqc_opc_add_tag                    = 0x0255,
+        i40e_aqc_opc_remove_tag                 = 0x0256,
+        i40e_aqc_opc_add_multicast_etag         = 0x0257,
+        i40e_aqc_opc_remove_multicast_etag      = 0x0258,
+        i40e_aqc_opc_update_tag                 = 0x0259,
+        i40e_aqc_opc_add_control_packet_filter  = 0x025A,
+        i40e_aqc_opc_remove_control_packet_filter       = 0x025B,
+        i40e_aqc_opc_add_cloud_filters          = 0x025C,
+        i40e_aqc_opc_remove_cloud_filters       = 0x025D,
+
+        i40e_aqc_opc_add_mirror_rule    = 0x0260,
+        i40e_aqc_opc_delete_mirror_rule = 0x0261,
 
         /* DCB commands */
-        i40e_aqc_opc_dcb_ignore_pfc = 0x0301,
-        i40e_aqc_opc_dcb_updated    = 0x0302,
+        i40e_aqc_opc_dcb_ignore_pfc     = 0x0301,
+        i40e_aqc_opc_dcb_updated        = 0x0302,
 
         /* TX scheduler */
-        i40e_aqc_opc_configure_vsi_bw_limit            = 0x0400,
-        i40e_aqc_opc_configure_vsi_ets_sla_bw_limit    = 0x0406,
-        i40e_aqc_opc_configure_vsi_tc_bw               = 0x0407,
-        i40e_aqc_opc_query_vsi_bw_config               = 0x0408,
-        i40e_aqc_opc_query_vsi_ets_sla_config          = 0x040A,
-        i40e_aqc_opc_configure_switching_comp_bw_limit = 0x0410,
-
-        i40e_aqc_opc_enable_switching_comp_ets             = 0x0413,
-        i40e_aqc_opc_modify_switching_comp_ets             = 0x0414,
-        i40e_aqc_opc_disable_switching_comp_ets            = 0x0415,
-        i40e_aqc_opc_configure_switching_comp_ets_bw_limit = 0x0416,
-        i40e_aqc_opc_configure_switching_comp_bw_config    = 0x0417,
-        i40e_aqc_opc_query_switching_comp_ets_config       = 0x0418,
-        i40e_aqc_opc_query_port_ets_config                 = 0x0419,
-        i40e_aqc_opc_query_switching_comp_bw_config        = 0x041A,
-        i40e_aqc_opc_suspend_port_tx                       = 0x041B,
-        i40e_aqc_opc_resume_port_tx                        = 0x041C,
-        i40e_aqc_opc_configure_partition_bw                = 0x041D,
+        i40e_aqc_opc_configure_vsi_bw_limit             = 0x0400,
+        i40e_aqc_opc_configure_vsi_ets_sla_bw_limit     = 0x0406,
+        i40e_aqc_opc_configure_vsi_tc_bw                = 0x0407,
+        i40e_aqc_opc_query_vsi_bw_config                = 0x0408,
+        i40e_aqc_opc_query_vsi_ets_sla_config           = 0x040A,
+        i40e_aqc_opc_configure_switching_comp_bw_limit  = 0x0410,
+
+        i40e_aqc_opc_enable_switching_comp_ets                  = 0x0413,
+        i40e_aqc_opc_modify_switching_comp_ets                  = 0x0414,
+        i40e_aqc_opc_disable_switching_comp_ets                 = 0x0415,
+        i40e_aqc_opc_configure_switching_comp_ets_bw_limit      = 0x0416,
+        i40e_aqc_opc_configure_switching_comp_bw_config         = 0x0417,
+        i40e_aqc_opc_query_switching_comp_ets_config            = 0x0418,
+        i40e_aqc_opc_query_port_ets_config                      = 0x0419,
+        i40e_aqc_opc_query_switching_comp_bw_config             = 0x041A,
+        i40e_aqc_opc_suspend_port_tx                            = 0x041B,
+        i40e_aqc_opc_resume_port_tx                             = 0x041C,
+        i40e_aqc_opc_configure_partition_bw                     = 0x041D,
 
         /* hmc */
-        i40e_aqc_opc_query_hmc_resource_profile = 0x0500,
-        i40e_aqc_opc_set_hmc_resource_profile   = 0x0501,
+        i40e_aqc_opc_query_hmc_resource_profile = 0x0500,
+        i40e_aqc_opc_set_hmc_resource_profile   = 0x0501,
 
         /* phy commands*/
-        i40e_aqc_opc_get_phy_abilities   = 0x0600,
-        i40e_aqc_opc_set_phy_config      = 0x0601,
-        i40e_aqc_opc_set_mac_config      = 0x0603,
-        i40e_aqc_opc_set_link_restart_an = 0x0605,
-        i40e_aqc_opc_get_link_status     = 0x0607,
-        i40e_aqc_opc_set_phy_int_mask    = 0x0613,
-        i40e_aqc_opc_get_local_advt_reg  = 0x0614,
-        i40e_aqc_opc_set_local_advt_reg  = 0x0615,
-        i40e_aqc_opc_get_partner_advt    = 0x0616,
-        i40e_aqc_opc_set_lb_modes        = 0x0618,
-        i40e_aqc_opc_get_phy_wol_caps    = 0x0621,
-        i40e_aqc_opc_set_phy_debug       = 0x0622,
-        i40e_aqc_opc_upload_ext_phy_fm   = 0x0625,
+        i40e_aqc_opc_get_phy_abilities          = 0x0600,
+        i40e_aqc_opc_set_phy_config             = 0x0601,
+        i40e_aqc_opc_set_mac_config             = 0x0603,
+        i40e_aqc_opc_set_link_restart_an        = 0x0605,
+        i40e_aqc_opc_get_link_status            = 0x0607,
+        i40e_aqc_opc_set_phy_int_mask           = 0x0613,
+        i40e_aqc_opc_get_local_advt_reg         = 0x0614,
+        i40e_aqc_opc_set_local_advt_reg         = 0x0615,
+        i40e_aqc_opc_get_partner_advt           = 0x0616,
+        i40e_aqc_opc_set_lb_modes               = 0x0618,
+        i40e_aqc_opc_get_phy_wol_caps           = 0x0621,
+        i40e_aqc_opc_set_phy_debug              = 0x0622,
+        i40e_aqc_opc_upload_ext_phy_fm          = 0x0625,
 
         /* NVM commands */
-        i40e_aqc_opc_nvm_read         = 0x0701,
-        i40e_aqc_opc_nvm_erase        = 0x0702,
-        i40e_aqc_opc_nvm_update       = 0x0703,
-        i40e_aqc_opc_nvm_config_read  = 0x0704,
-        i40e_aqc_opc_nvm_config_write = 0x0705,
+        i40e_aqc_opc_nvm_read                   = 0x0701,
+        i40e_aqc_opc_nvm_erase                  = 0x0702,
+        i40e_aqc_opc_nvm_update                 = 0x0703,
+        i40e_aqc_opc_nvm_config_read            = 0x0704,
+        i40e_aqc_opc_nvm_config_write           = 0x0705,
 
         /* virtualization commands */
-        i40e_aqc_opc_send_msg_to_pf   = 0x0801,
-        i40e_aqc_opc_send_msg_to_vf   = 0x0802,
-        i40e_aqc_opc_send_msg_to_peer = 0x0803,
+        i40e_aqc_opc_send_msg_to_pf             = 0x0801,
+        i40e_aqc_opc_send_msg_to_vf             = 0x0802,
+        i40e_aqc_opc_send_msg_to_peer           = 0x0803,
 
         /* alternate structure */
-        i40e_aqc_opc_alternate_write          = 0x0900,
-        i40e_aqc_opc_alternate_write_indirect = 0x0901,
-        i40e_aqc_opc_alternate_read           = 0x0902,
-        i40e_aqc_opc_alternate_read_indirect  = 0x0903,
-        i40e_aqc_opc_alternate_write_done     = 0x0904,
-        i40e_aqc_opc_alternate_set_mode       = 0x0905,
-        i40e_aqc_opc_alternate_clear_port     = 0x0906,
+        i40e_aqc_opc_alternate_write            = 0x0900,
+        i40e_aqc_opc_alternate_write_indirect   = 0x0901,
+        i40e_aqc_opc_alternate_read             = 0x0902,
+        i40e_aqc_opc_alternate_read_indirect    = 0x0903,
+        i40e_aqc_opc_alternate_write_done       = 0x0904,
+        i40e_aqc_opc_alternate_set_mode         = 0x0905,
+        i40e_aqc_opc_alternate_clear_port       = 0x0906,
 
         /* LLDP commands */
-        i40e_aqc_opc_lldp_get_mib    = 0x0A00,
-        i40e_aqc_opc_lldp_update_mib = 0x0A01,
-        i40e_aqc_opc_lldp_add_tlv    = 0x0A02,
-        i40e_aqc_opc_lldp_update_tlv = 0x0A03,
-        i40e_aqc_opc_lldp_delete_tlv = 0x0A04,
-        i40e_aqc_opc_lldp_stop       = 0x0A05,
-        i40e_aqc_opc_lldp_start      = 0x0A06,
+        i40e_aqc_opc_lldp_get_mib       = 0x0A00,
+        i40e_aqc_opc_lldp_update_mib    = 0x0A01,
+        i40e_aqc_opc_lldp_add_tlv       = 0x0A02,
+        i40e_aqc_opc_lldp_update_tlv    = 0x0A03,
+        i40e_aqc_opc_lldp_delete_tlv    = 0x0A04,
+        i40e_aqc_opc_lldp_stop          = 0x0A05,
+        i40e_aqc_opc_lldp_start         = 0x0A06,
 
         /* Tunnel commands */
-        i40e_aqc_opc_add_udp_tunnel       = 0x0B00,
-        i40e_aqc_opc_del_udp_tunnel       = 0x0B01,
-        i40e_aqc_opc_tunnel_key_structure = 0x0B10,
+        i40e_aqc_opc_add_udp_tunnel     = 0x0B00,
+        i40e_aqc_opc_del_udp_tunnel     = 0x0B01,
+        i40e_aqc_opc_tunnel_key_structure       = 0x0B10,
 
         /* Async Events */
-        i40e_aqc_opc_event_lan_overflow = 0x1001,
+        i40e_aqc_opc_event_lan_overflow         = 0x1001,
 
         /* OEM commands */
-        i40e_aqc_opc_oem_parameter_change     = 0xFE00,
-        i40e_aqc_opc_oem_device_status_change = 0xFE01,
+        i40e_aqc_opc_oem_parameter_change       = 0xFE00,
+        i40e_aqc_opc_oem_device_status_change   = 0xFE01,
 
         /* debug commands */
-        i40e_aqc_opc_debug_get_deviceid     = 0xFF00,
-        i40e_aqc_opc_debug_set_mode         = 0xFF01,
-        i40e_aqc_opc_debug_read_reg         = 0xFF03,
-        i40e_aqc_opc_debug_write_reg        = 0xFF04,
-        i40e_aqc_opc_debug_modify_reg       = 0xFF07,
-        i40e_aqc_opc_debug_dump_internals   = 0xFF08,
-        i40e_aqc_opc_debug_modify_internals = 0xFF09,
+        i40e_aqc_opc_debug_get_deviceid         = 0xFF00,
+        i40e_aqc_opc_debug_set_mode             = 0xFF01,
+        i40e_aqc_opc_debug_read_reg             = 0xFF03,
+        i40e_aqc_opc_debug_write_reg            = 0xFF04,
+        i40e_aqc_opc_debug_modify_reg           = 0xFF07,
+        i40e_aqc_opc_debug_dump_internals       = 0xFF08,
+        i40e_aqc_opc_debug_modify_internals     = 0xFF09,
 };
 
 /* command structures and indirect data structures */
@@ -303,7 +303,7 @@ enum i40e_admin_queue_opc {
 /* This macro is used extensively to ensure that command structures are 16
  * bytes in length as they have to map to the raw array of that size.
  */
-#define I40E_CHECK_CMD_LENGTH(X) I40E_CHECK_STRUCT_LEN(16, X)
+#define I40E_CHECK_CMD_LENGTH(X)        I40E_CHECK_STRUCT_LEN(16, X)
 
 /* internal (0x00XX) commands */
 
@@ -321,22 +321,22 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_get_version);
 
 /* Send driver version (indirect 0x0002) */
 struct i40e_aqc_driver_version {
-        u8     driver_major_ver;
-        u8     driver_minor_ver;
-        u8     driver_build_ver;
-        u8     driver_subbuild_ver;
-        u8     reserved[4];
-        __le32 address_high;
-        __le32 address_low;
+        u8      driver_major_ver;
+        u8      driver_minor_ver;
+        u8      driver_build_ver;
+        u8      driver_subbuild_ver;
+        u8      reserved[4];
+        __le32  address_high;
+        __le32  address_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_driver_version);
 
 /* Queue Shutdown (direct 0x0003) */
 struct i40e_aqc_queue_shutdown {
-        __le32     driver_unloading;
-#define I40E_AQ_DRIVER_UNLOADING    0x1
-        u8     reserved[12];
+        __le32  driver_unloading;
+#define I40E_AQ_DRIVER_UNLOADING        0x1
+        u8      reserved[12];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_queue_shutdown);
@@ -352,19 +352,19 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_set_pf_context);
 /* Request resource ownership (direct 0x0008)
  * Release resource ownership (direct 0x0009)
  */
-#define I40E_AQ_RESOURCE_NVM               1
-#define I40E_AQ_RESOURCE_SDP               2
-#define I40E_AQ_RESOURCE_ACCESS_READ       1
-#define I40E_AQ_RESOURCE_ACCESS_WRITE      2
-#define I40E_AQ_RESOURCE_NVM_READ_TIMEOUT  3000
-#define I40E_AQ_RESOURCE_NVM_WRITE_TIMEOUT 180000
+#define I40E_AQ_RESOURCE_NVM                    1
+#define I40E_AQ_RESOURCE_SDP                    2
+#define I40E_AQ_RESOURCE_ACCESS_READ            1
+#define I40E_AQ_RESOURCE_ACCESS_WRITE           2
+#define I40E_AQ_RESOURCE_NVM_READ_TIMEOUT       3000
+#define I40E_AQ_RESOURCE_NVM_WRITE_TIMEOUT      180000
 
 struct i40e_aqc_request_resource {
-        __le16 resource_id;
-        __le16 access_type;
-        __le32 timeout;
-        __le32 resource_number;
-        u8     reserved[4];
+        __le16  resource_id;
+        __le16  access_type;
+        __le32  timeout;
+        __le32  resource_number;
+        u8      reserved[4];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_request_resource);
@@ -374,7 +374,7 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_request_resource);
  */
 struct i40e_aqc_list_capabilites {
         u8 command_flags;
-#define I40E_AQ_LIST_CAP_PF_INDEX_EN     1
+#define I40E_AQ_LIST_CAP_PF_INDEX_EN    1
         u8 pf_index;
         u8 reserved[2];
         __le32 count;
@@ -385,123 +385,123 @@ struct i40e_aqc_list_capabilites {
 I40E_CHECK_CMD_LENGTH(i40e_aqc_list_capabilites);
 
 struct i40e_aqc_list_capabilities_element_resp {
-        __le16 id;
-        u8     major_rev;
-        u8     minor_rev;
-        __le32 number;
-        __le32 logical_id;
-        __le32 phys_id;
-        u8     reserved[16];
+        __le16  id;
+        u8      major_rev;
+        u8      minor_rev;
+        __le32  number;
+        __le32  logical_id;
+        __le32  phys_id;
+        u8      reserved[16];
 };
 
 /* list of caps */
 
-#define I40E_AQ_CAP_ID_SWITCH_MODE      0x0001
-#define I40E_AQ_CAP_ID_MNG_MODE         0x0002
-#define I40E_AQ_CAP_ID_NPAR_ACTIVE      0x0003
-#define I40E_AQ_CAP_ID_OS2BMC_CAP       0x0004
-#define I40E_AQ_CAP_ID_FUNCTIONS_VALID  0x0005
-#define I40E_AQ_CAP_ID_ALTERNATE_RAM    0x0006
-#define I40E_AQ_CAP_ID_SRIOV            0x0012
-#define I40E_AQ_CAP_ID_VF               0x0013
-#define I40E_AQ_CAP_ID_VMDQ             0x0014
-#define I40E_AQ_CAP_ID_8021QBG          0x0015
-#define I40E_AQ_CAP_ID_8021QBR          0x0016
-#define I40E_AQ_CAP_ID_VSI              0x0017
-#define I40E_AQ_CAP_ID_DCB              0x0018
-#define I40E_AQ_CAP_ID_FCOE             0x0021
-#define I40E_AQ_CAP_ID_RSS              0x0040
-#define I40E_AQ_CAP_ID_RXQ              0x0041
-#define I40E_AQ_CAP_ID_TXQ              0x0042
-#define I40E_AQ_CAP_ID_MSIX             0x0043
-#define I40E_AQ_CAP_ID_VF_MSIX          0x0044
-#define I40E_AQ_CAP_ID_FLOW_DIRECTOR    0x0045
-#define I40E_AQ_CAP_ID_1588             0x0046
-#define I40E_AQ_CAP_ID_IWARP            0x0051
-#define I40E_AQ_CAP_ID_LED              0x0061
-#define I40E_AQ_CAP_ID_SDP              0x0062
-#define I40E_AQ_CAP_ID_MDIO             0x0063
-#define I40E_AQ_CAP_ID_FLEX10           0x00F1
-#define I40E_AQ_CAP_ID_CEM              0x00F2
+#define I40E_AQ_CAP_ID_SWITCH_MODE      0x0001
+#define I40E_AQ_CAP_ID_MNG_MODE         0x0002
+#define I40E_AQ_CAP_ID_NPAR_ACTIVE      0x0003
+#define I40E_AQ_CAP_ID_OS2BMC_CAP       0x0004
+#define I40E_AQ_CAP_ID_FUNCTIONS_VALID  0x0005
+#define I40E_AQ_CAP_ID_ALTERNATE_RAM    0x0006
+#define I40E_AQ_CAP_ID_SRIOV            0x0012
+#define I40E_AQ_CAP_ID_VF               0x0013
+#define I40E_AQ_CAP_ID_VMDQ             0x0014
+#define I40E_AQ_CAP_ID_8021QBG          0x0015
+#define I40E_AQ_CAP_ID_8021QBR          0x0016
+#define I40E_AQ_CAP_ID_VSI              0x0017
+#define I40E_AQ_CAP_ID_DCB              0x0018
+#define I40E_AQ_CAP_ID_FCOE             0x0021
+#define I40E_AQ_CAP_ID_RSS              0x0040
+#define I40E_AQ_CAP_ID_RXQ              0x0041
+#define I40E_AQ_CAP_ID_TXQ              0x0042
+#define I40E_AQ_CAP_ID_MSIX             0x0043
+#define I40E_AQ_CAP_ID_VF_MSIX          0x0044
+#define I40E_AQ_CAP_ID_FLOW_DIRECTOR    0x0045
+#define I40E_AQ_CAP_ID_1588             0x0046
+#define I40E_AQ_CAP_ID_IWARP            0x0051
+#define I40E_AQ_CAP_ID_LED              0x0061
+#define I40E_AQ_CAP_ID_SDP              0x0062
+#define I40E_AQ_CAP_ID_MDIO             0x0063
+#define I40E_AQ_CAP_ID_FLEX10           0x00F1
+#define I40E_AQ_CAP_ID_CEM              0x00F2
 
 /* Set CPPM Configuration (direct 0x0103) */
 struct i40e_aqc_cppm_configuration {
-        __le16 command_flags;
-#define I40E_AQ_CPPM_EN_LTRC    0x0800
-#define I40E_AQ_CPPM_EN_DMCTH   0x1000
-#define I40E_AQ_CPPM_EN_DMCTLX  0x2000
-#define I40E_AQ_CPPM_EN_HPTC    0x4000
-#define I40E_AQ_CPPM_EN_DMARC   0x8000
-        __le16 ttlx;
-        __le32 dmacr;
-        __le16 dmcth;
-        u8     hptc;
-        u8     reserved;
-        __le32 pfltrc;
+        __le16  command_flags;
+#define I40E_AQ_CPPM_EN_LTRC    0x0800
+#define I40E_AQ_CPPM_EN_DMCTH   0x1000
+#define I40E_AQ_CPPM_EN_DMCTLX  0x2000
+#define I40E_AQ_CPPM_EN_HPTC    0x4000
+#define I40E_AQ_CPPM_EN_DMARC   0x8000
+        __le16  ttlx;
+        __le32  dmacr;
+        __le16  dmcth;
+        u8      hptc;
+        u8      reserved;
+        __le32  pfltrc;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_cppm_configuration);
 
 /* Set ARP Proxy command / response (indirect 0x0104) */
 struct i40e_aqc_arp_proxy_data {
-        __le16 command_flags;
-#define I40E_AQ_ARP_INIT_IPV4           0x0008
-#define I40E_AQ_ARP_UNSUP_CTL           0x0010
-#define I40E_AQ_ARP_ENA                 0x0020
-#define I40E_AQ_ARP_ADD_IPV4            0x0040
-#define I40E_AQ_ARP_DEL_IPV4            0x0080
-        __le16 table_id;
-        __le32 pfpm_proxyfc;
-        __le32 ip_addr;
-        u8     mac_addr[6];
+        __le16  command_flags;
+#define I40E_AQ_ARP_INIT_IPV4   0x0008
+#define I40E_AQ_ARP_UNSUP_CTL   0x0010
+#define I40E_AQ_ARP_ENA         0x0020
+#define I40E_AQ_ARP_ADD_IPV4    0x0040
+#define I40E_AQ_ARP_DEL_IPV4    0x0080
+        __le16  table_id;
+        __le32  pfpm_proxyfc;
+        __le32  ip_addr;
+        u8      mac_addr[6];
 };
 
 /* Set NS Proxy Table Entry Command (indirect 0x0105) */
 struct i40e_aqc_ns_proxy_data {
-        __le16 table_idx_mac_addr_0;
-        __le16 table_idx_mac_addr_1;
-        __le16 table_idx_ipv6_0;
-        __le16 table_idx_ipv6_1;
-        __le16 control;
-#define I40E_AQ_NS_PROXY_ADD_0             0x0100
-#define I40E_AQ_NS_PROXY_DEL_0             0x0200
-#define I40E_AQ_NS_PROXY_ADD_1             0x0400
-#define I40E_AQ_NS_PROXY_DEL_1             0x0800
-#define I40E_AQ_NS_PROXY_ADD_IPV6_0        0x1000
-#define I40E_AQ_NS_PROXY_DEL_IPV6_0        0x2000
-#define I40E_AQ_NS_PROXY_ADD_IPV6_1        0x4000
-#define I40E_AQ_NS_PROXY_DEL_IPV6_1        0x8000
-#define I40E_AQ_NS_PROXY_COMMAND_SEQ       0x0001
-#define I40E_AQ_NS_PROXY_INIT_IPV6_TBL     0x0002
-#define I40E_AQ_NS_PROXY_INIT_MAC_TBL      0x0004
-        u8     mac_addr_0[6];
-        u8     mac_addr_1[6];
-        u8     local_mac_addr[6];
-        u8     ipv6_addr_0[16]; /* Warning! spec specifies BE byte order */
-        u8     ipv6_addr_1[16];
+        __le16  table_idx_mac_addr_0;
+        __le16  table_idx_mac_addr_1;
+        __le16  table_idx_ipv6_0;
+        __le16  table_idx_ipv6_1;
+        __le16  control;
+#define I40E_AQ_NS_PROXY_ADD_0          0x0100
+#define I40E_AQ_NS_PROXY_DEL_0          0x0200
+#define I40E_AQ_NS_PROXY_ADD_1          0x0400
+#define I40E_AQ_NS_PROXY_DEL_1          0x0800
+#define I40E_AQ_NS_PROXY_ADD_IPV6_0     0x1000
+#define I40E_AQ_NS_PROXY_DEL_IPV6_0     0x2000
+#define I40E_AQ_NS_PROXY_ADD_IPV6_1     0x4000
+#define I40E_AQ_NS_PROXY_DEL_IPV6_1     0x8000
+#define I40E_AQ_NS_PROXY_COMMAND_SEQ    0x0001
+#define I40E_AQ_NS_PROXY_INIT_IPV6_TBL  0x0002
+#define I40E_AQ_NS_PROXY_INIT_MAC_TBL   0x0004
+        u8      mac_addr_0[6];
+        u8      mac_addr_1[6];
+        u8      local_mac_addr[6];
+        u8      ipv6_addr_0[16]; /* Warning! spec specifies BE byte order */
+        u8      ipv6_addr_1[16];
 };
 
 /* Manage LAA Command (0x0106) - obsolete */
 struct i40e_aqc_mng_laa {
         __le16  command_flags;
-#define I40E_AQ_LAA_FLAG_WR   0x8000
-        u8     reserved[2];
-        __le32 sal;
-        __le16 sah;
-        u8     reserved2[6];
+#define I40E_AQ_LAA_FLAG_WR     0x8000
+        u8      reserved[2];
+        __le32  sal;
+        __le16  sah;
+        u8      reserved2[6];
 };
 
 /* Manage MAC Address Read Command (indirect 0x0107) */
 struct i40e_aqc_mac_address_read {
         __le16  command_flags;
-#define I40E_AQC_LAN_ADDR_VALID   0x10
-#define I40E_AQC_SAN_ADDR_VALID   0x20
-#define I40E_AQC_PORT_ADDR_VALID  0x40
-#define I40E_AQC_WOL_ADDR_VALID   0x80
-#define I40E_AQC_ADDR_VALID_MASK  0xf0
-        u8     reserved[6];
-        __le32 addr_high;
-        __le32 addr_low;
+#define I40E_AQC_LAN_ADDR_VALID         0x10
+#define I40E_AQC_SAN_ADDR_VALID         0x20
+#define I40E_AQC_PORT_ADDR_VALID        0x40
+#define I40E_AQC_WOL_ADDR_VALID         0x80
+#define I40E_AQC_ADDR_VALID_MASK        0xf0
+        u8      reserved[6];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_mac_address_read);
@@ -517,14 +517,14 @@ I40E_CHECK_STRUCT_LEN(24, i40e_aqc_mac_address_read_data);
 
 /* Manage MAC Address Write Command (0x0108) */
 struct i40e_aqc_mac_address_write {
-        __le16 command_flags;
-#define I40E_AQC_WRITE_TYPE_LAA_ONLY    0x0000
-#define I40E_AQC_WRITE_TYPE_LAA_WOL     0x4000
-#define I40E_AQC_WRITE_TYPE_PORT        0x8000
-#define I40E_AQC_WRITE_TYPE_MASK        0xc000
-        __le16 mac_sah;
-        __le32 mac_sal;
-        u8     reserved[8];
+        __le16  command_flags;
+#define I40E_AQC_WRITE_TYPE_LAA_ONLY    0x0000
+#define I40E_AQC_WRITE_TYPE_LAA_WOL     0x4000
+#define I40E_AQC_WRITE_TYPE_PORT        0x8000
+#define I40E_AQC_WRITE_TYPE_MASK        0xc000
+        __le16  mac_sah;
+        __le32  mac_sal;
+        u8      reserved[8];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_mac_address_write);
@@ -545,10 +545,10 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_clear_pxe);
  * command
  */
 struct i40e_aqc_switch_seid {
-        __le16 seid;
-        u8     reserved[6];
-        __le32 addr_high;
-        __le32 addr_low;
+        __le16  seid;
+        u8      reserved[6];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_switch_seid);
@@ -557,34 +557,34 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_switch_seid);
  * uses i40e_aqc_switch_seid for the descriptor
  */
 struct i40e_aqc_get_switch_config_header_resp {
-        __le16 num_reported;
-        __le16 num_total;
-        u8     reserved[12];
+        __le16  num_reported;
+        __le16  num_total;
+        u8      reserved[12];
 };
 
 struct i40e_aqc_switch_config_element_resp {
-        u8     element_type;
-#define I40E_AQ_SW_ELEM_TYPE_MAC        1
-#define I40E_AQ_SW_ELEM_TYPE_PF         2
-#define I40E_AQ_SW_ELEM_TYPE_VF         3
-#define I40E_AQ_SW_ELEM_TYPE_EMP        4
-#define I40E_AQ_SW_ELEM_TYPE_BMC        5
-#define I40E_AQ_SW_ELEM_TYPE_PV         16
-#define I40E_AQ_SW_ELEM_TYPE_VEB        17
-#define I40E_AQ_SW_ELEM_TYPE_PA         18
-#define I40E_AQ_SW_ELEM_TYPE_VSI        19
-        u8     revision;
-#define I40E_AQ_SW_ELEM_REV_1           1
-        __le16 seid;
-        __le16 uplink_seid;
-        __le16 downlink_seid;
-        u8     reserved[3];
-        u8     connection_type;
-#define I40E_AQ_CONN_TYPE_REGULAR       0x1
-#define I40E_AQ_CONN_TYPE_DEFAULT       0x2
-#define I40E_AQ_CONN_TYPE_CASCADED      0x3
-        __le16 scheduler_id;
-        __le16 element_info;
+        u8      element_type;
+#define I40E_AQ_SW_ELEM_TYPE_MAC        1
+#define I40E_AQ_SW_ELEM_TYPE_PF         2
+#define I40E_AQ_SW_ELEM_TYPE_VF         3
+#define I40E_AQ_SW_ELEM_TYPE_EMP        4
+#define I40E_AQ_SW_ELEM_TYPE_BMC        5
+#define I40E_AQ_SW_ELEM_TYPE_PV         16
+#define I40E_AQ_SW_ELEM_TYPE_VEB        17
+#define I40E_AQ_SW_ELEM_TYPE_PA         18
+#define I40E_AQ_SW_ELEM_TYPE_VSI        19
+        u8      revision;
+#define I40E_AQ_SW_ELEM_REV_1           1
+        __le16  seid;
+        __le16  uplink_seid;
+        __le16  downlink_seid;
+        u8      reserved[3];
+        u8      connection_type;
+#define I40E_AQ_CONN_TYPE_REGULAR       0x1
+#define I40E_AQ_CONN_TYPE_DEFAULT       0x2
+#define I40E_AQ_CONN_TYPE_CASCADED      0x3
+        __le16  scheduler_id;
+        __le16  element_info;
 };
 
 /* Get Switch Configuration (indirect 0x0200)
@@ -592,73 +592,73 @@ struct i40e_aqc_switch_config_element_resp {
  *    the first in the array is the header, remainder are elements
  */
 struct i40e_aqc_get_switch_config_resp {
-        struct i40e_aqc_get_switch_config_header_resp header;
-        struct i40e_aqc_switch_config_element_resp    element[1];
+        struct i40e_aqc_get_switch_config_header_resp   header;
+        struct i40e_aqc_switch_config_element_resp      element[1];
 };
 
 /* Add Statistics (direct 0x0201)
  * Remove Statistics (direct 0x0202)
  */
 struct i40e_aqc_add_remove_statistics {
-        __le16 seid;
-        __le16 vlan;
-        __le16 stat_index;
-        u8     reserved[10];
+        __le16  seid;
+        __le16  vlan;
+        __le16  stat_index;
+        u8      reserved[10];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_statistics);
 
 /* Set Port Parameters command (direct 0x0203) */
 struct i40e_aqc_set_port_parameters {
-        __le16 command_flags;
-#define I40E_AQ_SET_P_PARAMS_SAVE_BAD_PACKETS   1
-#define I40E_AQ_SET_P_PARAMS_PAD_SHORT_PACKETS  2 /* must set! */
-#define I40E_AQ_SET_P_PARAMS_DOUBLE_VLAN_ENA    4
-        __le16 bad_frame_vsi;
-        __le16 default_seid;        /* reserved for command */
-        u8     reserved[10];
+        __le16  command_flags;
+#define I40E_AQ_SET_P_PARAMS_SAVE_BAD_PACKETS   1
+#define I40E_AQ_SET_P_PARAMS_PAD_SHORT_PACKETS  2 /* must set! */
+#define I40E_AQ_SET_P_PARAMS_DOUBLE_VLAN_ENA    4
+        __le16  bad_frame_vsi;
+        __le16  default_seid;        /* reserved for command */
+        u8      reserved[10];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_set_port_parameters);
 
 /* Get Switch Resource Allocation (indirect 0x0204) */
 struct i40e_aqc_get_switch_resource_alloc {
-        u8     num_entries;         /* reserved for command */
-        u8     reserved[7];
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      num_entries;         /* reserved for command */
+        u8      reserved[7];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_get_switch_resource_alloc);
 
 /* expect an array of these structs in the response buffer */
 struct i40e_aqc_switch_resource_alloc_element_resp {
-        u8     resource_type;
-#define I40E_AQ_RESOURCE_TYPE_VEB                 0x0
-#define I40E_AQ_RESOURCE_TYPE_VSI                 0x1
-#define I40E_AQ_RESOURCE_TYPE_MACADDR             0x2
-#define I40E_AQ_RESOURCE_TYPE_STAG                0x3
-#define I40E_AQ_RESOURCE_TYPE_ETAG                0x4
-#define I40E_AQ_RESOURCE_TYPE_MULTICAST_HASH      0x5
-#define I40E_AQ_RESOURCE_TYPE_UNICAST_HASH        0x6
-#define I40E_AQ_RESOURCE_TYPE_VLAN                0x7
-#define I40E_AQ_RESOURCE_TYPE_VSI_LIST_ENTRY      0x8
-#define I40E_AQ_RESOURCE_TYPE_ETAG_LIST_ENTRY     0x9
-#define I40E_AQ_RESOURCE_TYPE_VLAN_STAT_POOL      0xA
-#define I40E_AQ_RESOURCE_TYPE_MIRROR_RULE         0xB
-#define I40E_AQ_RESOURCE_TYPE_QUEUE_SETS          0xC
-#define I40E_AQ_RESOURCE_TYPE_VLAN_FILTERS        0xD
-#define I40E_AQ_RESOURCE_TYPE_INNER_MAC_FILTERS   0xF
-#define I40E_AQ_RESOURCE_TYPE_IP_FILTERS          0x10
-#define I40E_AQ_RESOURCE_TYPE_GRE_VN_KEYS         0x11
-#define I40E_AQ_RESOURCE_TYPE_VN2_KEYS            0x12
-#define I40E_AQ_RESOURCE_TYPE_TUNNEL_PORTS        0x13
-        u8     reserved1;
-        __le16 guaranteed;
-        __le16 total;
-        __le16 used;
-        __le16 total_unalloced;
-        u8     reserved2[6];
+        u8      resource_type;
+#define I40E_AQ_RESOURCE_TYPE_VEB               0x0
+#define I40E_AQ_RESOURCE_TYPE_VSI               0x1
+#define I40E_AQ_RESOURCE_TYPE_MACADDR           0x2
+#define I40E_AQ_RESOURCE_TYPE_STAG              0x3
+#define I40E_AQ_RESOURCE_TYPE_ETAG              0x4
+#define I40E_AQ_RESOURCE_TYPE_MULTICAST_HASH    0x5
+#define I40E_AQ_RESOURCE_TYPE_UNICAST_HASH      0x6
+#define I40E_AQ_RESOURCE_TYPE_VLAN              0x7
+#define I40E_AQ_RESOURCE_TYPE_VSI_LIST_ENTRY    0x8
+#define I40E_AQ_RESOURCE_TYPE_ETAG_LIST_ENTRY   0x9
+#define I40E_AQ_RESOURCE_TYPE_VLAN_STAT_POOL    0xA
+#define I40E_AQ_RESOURCE_TYPE_MIRROR_RULE       0xB
+#define I40E_AQ_RESOURCE_TYPE_QUEUE_SETS        0xC
+#define I40E_AQ_RESOURCE_TYPE_VLAN_FILTERS      0xD
+#define I40E_AQ_RESOURCE_TYPE_INNER_MAC_FILTERS 0xF
+#define I40E_AQ_RESOURCE_TYPE_IP_FILTERS        0x10
+#define I40E_AQ_RESOURCE_TYPE_GRE_VN_KEYS       0x11
+#define I40E_AQ_RESOURCE_TYPE_VN2_KEYS          0x12
+#define I40E_AQ_RESOURCE_TYPE_TUNNEL_PORTS      0x13
+        u8      reserved1;
+        __le16  guaranteed;
+        __le16  total;
+        __le16  used;
+        __le16  total_unalloced;
+        u8      reserved2[6];
 };
 
 /* Add VSI (indirect 0x0210)
@@ -672,24 +672,24 @@ struct i40e_aqc_switch_resource_alloc_element_resp {
  *     uses the same completion and data structure as Add VSI
  */
 struct i40e_aqc_add_get_update_vsi {
-        __le16 uplink_seid;
-        u8     connection_type;
-#define I40E_AQ_VSI_CONN_TYPE_NORMAL            0x1
-#define I40E_AQ_VSI_CONN_TYPE_DEFAULT           0x2
-#define I40E_AQ_VSI_CONN_TYPE_CASCADED          0x3
-        u8     reserved1;
-        u8     vf_id;
-        u8     reserved2;
-        __le16 vsi_flags;
-#define I40E_AQ_VSI_TYPE_SHIFT          0x0
-#define I40E_AQ_VSI_TYPE_MASK           (0x3 << I40E_AQ_VSI_TYPE_SHIFT)
-#define I40E_AQ_VSI_TYPE_VF             0x0
-#define I40E_AQ_VSI_TYPE_VMDQ2          0x1
-#define I40E_AQ_VSI_TYPE_PF             0x2
-#define I40E_AQ_VSI_TYPE_EMP_MNG        0x3
-#define I40E_AQ_VSI_FLAG_CASCADED_PV    0x4
-        __le32 addr_high;
-        __le32 addr_low;
+        __le16  uplink_seid;
+        u8      connection_type;
+#define I40E_AQ_VSI_CONN_TYPE_NORMAL    0x1
+#define I40E_AQ_VSI_CONN_TYPE_DEFAULT   0x2
+#define I40E_AQ_VSI_CONN_TYPE_CASCADED  0x3
+        u8      reserved1;
+        u8      vf_id;
+        u8      reserved2;
+        __le16  vsi_flags;
+#define I40E_AQ_VSI_TYPE_SHIFT          0x0
+#define I40E_AQ_VSI_TYPE_MASK           (0x3 << I40E_AQ_VSI_TYPE_SHIFT)
+#define I40E_AQ_VSI_TYPE_VF             0x0
+#define I40E_AQ_VSI_TYPE_VMDQ2          0x1
+#define I40E_AQ_VSI_TYPE_PF             0x2
+#define I40E_AQ_VSI_TYPE_EMP_MNG        0x3
+#define I40E_AQ_VSI_FLAG_CASCADED_PV    0x4
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_get_update_vsi);
@@ -707,121 +707,121 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_add_get_update_vsi_completion);
 
 struct i40e_aqc_vsi_properties_data {
         /* first 96 byte are written by SW */
-        __le16 valid_sections;
-#define I40E_AQ_VSI_PROP_SWITCH_VALID       0x0001
-#define I40E_AQ_VSI_PROP_SECURITY_VALID     0x0002
-#define I40E_AQ_VSI_PROP_VLAN_VALID         0x0004
-#define I40E_AQ_VSI_PROP_CAS_PV_VALID       0x0008
-#define I40E_AQ_VSI_PROP_INGRESS_UP_VALID   0x0010
-#define I40E_AQ_VSI_PROP_EGRESS_UP_VALID    0x0020
-#define I40E_AQ_VSI_PROP_QUEUE_MAP_VALID    0x0040
-#define I40E_AQ_VSI_PROP_QUEUE_OPT_VALID    0x0080
-#define I40E_AQ_VSI_PROP_OUTER_UP_VALID     0x0100
-#define I40E_AQ_VSI_PROP_SCHED_VALID        0x0200
+        __le16  valid_sections;
+#define I40E_AQ_VSI_PROP_SWITCH_VALID           0x0001
+#define I40E_AQ_VSI_PROP_SECURITY_VALID         0x0002
+#define I40E_AQ_VSI_PROP_VLAN_VALID             0x0004
+#define I40E_AQ_VSI_PROP_CAS_PV_VALID           0x0008
+#define I40E_AQ_VSI_PROP_INGRESS_UP_VALID       0x0010
+#define I40E_AQ_VSI_PROP_EGRESS_UP_VALID        0x0020
+#define I40E_AQ_VSI_PROP_QUEUE_MAP_VALID        0x0040
+#define I40E_AQ_VSI_PROP_QUEUE_OPT_VALID        0x0080
+#define I40E_AQ_VSI_PROP_OUTER_UP_VALID         0x0100
+#define I40E_AQ_VSI_PROP_SCHED_VALID            0x0200
         /* switch section */
-        __le16 switch_id; /* 12bit id combined with flags below */
-#define I40E_AQ_VSI_SW_ID_SHIFT             0x0000
-#define I40E_AQ_VSI_SW_ID_MASK              (0xFFF << I40E_AQ_VSI_SW_ID_SHIFT)
-#define I40E_AQ_VSI_SW_ID_FLAG_NOT_STAG     0x1000
-#define I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB     0x2000
-#define I40E_AQ_VSI_SW_ID_FLAG_LOCAL_LB     0x4000
-        u8     sw_reserved[2];
+        __le16  switch_id; /* 12bit id combined with flags below */
+#define I40E_AQ_VSI_SW_ID_SHIFT         0x0000
+#define I40E_AQ_VSI_SW_ID_MASK          (0xFFF << I40E_AQ_VSI_SW_ID_SHIFT)
+#define I40E_AQ_VSI_SW_ID_FLAG_NOT_STAG 0x1000
+#define I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB 0x2000
+#define I40E_AQ_VSI_SW_ID_FLAG_LOCAL_LB 0x4000
+        u8      sw_reserved[2];
         /* security section */
-        u8     sec_flags;
-#define I40E_AQ_VSI_SEC_FLAG_ALLOW_DEST_OVRD    0x01
-#define I40E_AQ_VSI_SEC_FLAG_ENABLE_VLAN_CHK    0x02
-#define I40E_AQ_VSI_SEC_FLAG_ENABLE_MAC_CHK     0x04
-        u8     sec_reserved;
+        u8      sec_flags;
+#define I40E_AQ_VSI_SEC_FLAG_ALLOW_DEST_OVRD    0x01
+#define I40E_AQ_VSI_SEC_FLAG_ENABLE_VLAN_CHK    0x02
+#define I40E_AQ_VSI_SEC_FLAG_ENABLE_MAC_CHK     0x04
+        u8      sec_reserved;
         /* VLAN section */
-        __le16 pvid; /* VLANS include priority bits */
-        __le16 fcoe_pvid;
-        u8     port_vlan_flags;
-#define I40E_AQ_VSI_PVLAN_MODE_SHIFT        0x00
-#define I40E_AQ_VSI_PVLAN_MODE_MASK         (0x03 << \
-                                                I40E_AQ_VSI_PVLAN_MODE_SHIFT)
-#define I40E_AQ_VSI_PVLAN_MODE_TAGGED       0x01
-#define I40E_AQ_VSI_PVLAN_MODE_UNTAGGED     0x02
-#define I40E_AQ_VSI_PVLAN_MODE_ALL          0x03
-#define I40E_AQ_VSI_PVLAN_INSERT_PVID       0x04
-#define I40E_AQ_VSI_PVLAN_EMOD_SHIFT        0x03
-#define I40E_AQ_VSI_PVLAN_EMOD_MASK         (0x3 << \
-                                        I40E_AQ_VSI_PVLAN_EMOD_SHIFT)
-#define I40E_AQ_VSI_PVLAN_EMOD_STR_BOTH     0x0
-#define I40E_AQ_VSI_PVLAN_EMOD_STR_UP       0x08
-#define I40E_AQ_VSI_PVLAN_EMOD_STR          0x10
-#define I40E_AQ_VSI_PVLAN_EMOD_NOTHING      0x18
-        u8     pvlan_reserved[3];
+        __le16  pvid; /* VLANS include priority bits */
+        __le16  fcoe_pvid;
+        u8      port_vlan_flags;
+#define I40E_AQ_VSI_PVLAN_MODE_SHIFT    0x00
+#define I40E_AQ_VSI_PVLAN_MODE_MASK     (0x03 << \
+                                         I40E_AQ_VSI_PVLAN_MODE_SHIFT)
+#define I40E_AQ_VSI_PVLAN_MODE_TAGGED   0x01
+#define I40E_AQ_VSI_PVLAN_MODE_UNTAGGED 0x02
+#define I40E_AQ_VSI_PVLAN_MODE_ALL      0x03
+#define I40E_AQ_VSI_PVLAN_INSERT_PVID   0x04
+#define I40E_AQ_VSI_PVLAN_EMOD_SHIFT    0x03
+#define I40E_AQ_VSI_PVLAN_EMOD_MASK     (0x3 << \
+                                         I40E_AQ_VSI_PVLAN_EMOD_SHIFT)
+#define I40E_AQ_VSI_PVLAN_EMOD_STR_BOTH 0x0
+#define I40E_AQ_VSI_PVLAN_EMOD_STR_UP   0x08
+#define I40E_AQ_VSI_PVLAN_EMOD_STR      0x10
+#define I40E_AQ_VSI_PVLAN_EMOD_NOTHING  0x18
+        u8      pvlan_reserved[3];
         /* ingress egress up sections */
-        __le32 ingress_table; /* bitmap, 3 bits per up */
-#define I40E_AQ_VSI_UP_TABLE_UP0_SHIFT      0
-#define I40E_AQ_VSI_UP_TABLE_UP0_MASK       (0x7 << \
-                                        I40E_AQ_VSI_UP_TABLE_UP0_SHIFT)
-#define I40E_AQ_VSI_UP_TABLE_UP1_SHIFT      3
-#define I40E_AQ_VSI_UP_TABLE_UP1_MASK       (0x7 << \
-                                        I40E_AQ_VSI_UP_TABLE_UP1_SHIFT)
-#define I40E_AQ_VSI_UP_TABLE_UP2_SHIFT      6
-#define I40E_AQ_VSI_UP_TABLE_UP2_MASK       (0x7 << \
-                                        I40E_AQ_VSI_UP_TABLE_UP2_SHIFT)
-#define I40E_AQ_VSI_UP_TABLE_UP3_SHIFT      9
-#define I40E_AQ_VSI_UP_TABLE_UP3_MASK       (0x7 << \
-                                        I40E_AQ_VSI_UP_TABLE_UP3_SHIFT)
-#define I40E_AQ_VSI_UP_TABLE_UP4_SHIFT      12
-#define I40E_AQ_VSI_UP_TABLE_UP4_MASK       (0x7 << \
-                                        I40E_AQ_VSI_UP_TABLE_UP4_SHIFT)
-#define I40E_AQ_VSI_UP_TABLE_UP5_SHIFT      15
-#define I40E_AQ_VSI_UP_TABLE_UP5_MASK       (0x7 << \
-                                        I40E_AQ_VSI_UP_TABLE_UP5_SHIFT)
-#define I40E_AQ_VSI_UP_TABLE_UP6_SHIFT      18
-#define I40E_AQ_VSI_UP_TABLE_UP6_MASK       (0x7 << \
-                                        I40E_AQ_VSI_UP_TABLE_UP6_SHIFT)
-#define I40E_AQ_VSI_UP_TABLE_UP7_SHIFT      21
-#define I40E_AQ_VSI_UP_TABLE_UP7_MASK       (0x7 << \
-                                        I40E_AQ_VSI_UP_TABLE_UP7_SHIFT)
-        __le32 egress_table;   /* same defines as for ingress table */
+        __le32  ingress_table; /* bitmap, 3 bits per up */
+#define I40E_AQ_VSI_UP_TABLE_UP0_SHIFT  0
+#define I40E_AQ_VSI_UP_TABLE_UP0_MASK   (0x7 << \
+                                         I40E_AQ_VSI_UP_TABLE_UP0_SHIFT)
+#define I40E_AQ_VSI_UP_TABLE_UP1_SHIFT  3
+#define I40E_AQ_VSI_UP_TABLE_UP1_MASK   (0x7 << \
+                                         I40E_AQ_VSI_UP_TABLE_UP1_SHIFT)
+#define I40E_AQ_VSI_UP_TABLE_UP2_SHIFT  6
+#define I40E_AQ_VSI_UP_TABLE_UP2_MASK   (0x7 << \
+                                         I40E_AQ_VSI_UP_TABLE_UP2_SHIFT)
+#define I40E_AQ_VSI_UP_TABLE_UP3_SHIFT  9
+#define I40E_AQ_VSI_UP_TABLE_UP3_MASK   (0x7 << \
+                                         I40E_AQ_VSI_UP_TABLE_UP3_SHIFT)
+#define I40E_AQ_VSI_UP_TABLE_UP4_SHIFT  12
+#define I40E_AQ_VSI_UP_TABLE_UP4_MASK   (0x7 << \
+                                         I40E_AQ_VSI_UP_TABLE_UP4_SHIFT)
+#define I40E_AQ_VSI_UP_TABLE_UP5_SHIFT  15
+#define I40E_AQ_VSI_UP_TABLE_UP5_MASK   (0x7 << \
+                                         I40E_AQ_VSI_UP_TABLE_UP5_SHIFT)
+#define I40E_AQ_VSI_UP_TABLE_UP6_SHIFT  18
+#define I40E_AQ_VSI_UP_TABLE_UP6_MASK   (0x7 << \
+                                         I40E_AQ_VSI_UP_TABLE_UP6_SHIFT)
+#define I40E_AQ_VSI_UP_TABLE_UP7_SHIFT  21
+#define I40E_AQ_VSI_UP_TABLE_UP7_MASK   (0x7 << \
+                                         I40E_AQ_VSI_UP_TABLE_UP7_SHIFT)
+        __le32  egress_table;   /* same defines as for ingress table */
         /* cascaded PV section */
-        __le16 cas_pv_tag;
-        u8     cas_pv_flags;
-#define I40E_AQ_VSI_CAS_PV_TAGX_SHIFT      0x00
-#define I40E_AQ_VSI_CAS_PV_TAGX_MASK       (0x03 << \
-                                                I40E_AQ_VSI_CAS_PV_TAGX_SHIFT)
-#define I40E_AQ_VSI_CAS_PV_TAGX_LEAVE      0x00
-#define I40E_AQ_VSI_CAS_PV_TAGX_REMOVE     0x01
-#define I40E_AQ_VSI_CAS_PV_TAGX_COPY       0x02
-#define I40E_AQ_VSI_CAS_PV_INSERT_TAG      0x10
-#define I40E_AQ_VSI_CAS_PV_ETAG_PRUNE      0x20
-#define I40E_AQ_VSI_CAS_PV_ACCEPT_HOST_TAG 0x40
-        u8     cas_pv_reserved;
+        __le16  cas_pv_tag;
+        u8      cas_pv_flags;
+#define I40E_AQ_VSI_CAS_PV_TAGX_SHIFT           0x00
+#define I40E_AQ_VSI_CAS_PV_TAGX_MASK            (0x03 << \
+                                                 I40E_AQ_VSI_CAS_PV_TAGX_SHIFT)
+#define I40E_AQ_VSI_CAS_PV_TAGX_LEAVE           0x00
+#define I40E_AQ_VSI_CAS_PV_TAGX_REMOVE          0x01
+#define I40E_AQ_VSI_CAS_PV_TAGX_COPY            0x02
+#define I40E_AQ_VSI_CAS_PV_INSERT_TAG           0x10
+#define I40E_AQ_VSI_CAS_PV_ETAG_PRUNE           0x20
+#define I40E_AQ_VSI_CAS_PV_ACCEPT_HOST_TAG      0x40
+        u8      cas_pv_reserved;
         /* queue mapping section */
-        __le16 mapping_flags;
-#define I40E_AQ_VSI_QUE_MAP_CONTIG          0x0
-#define I40E_AQ_VSI_QUE_MAP_NONCONTIG       0x1
-        __le16 queue_mapping[16];
-#define I40E_AQ_VSI_QUEUE_SHIFT             0x0
-#define I40E_AQ_VSI_QUEUE_MASK              (0x7FF << I40E_AQ_VSI_QUEUE_SHIFT)
-        __le16 tc_mapping[8];
-#define I40E_AQ_VSI_TC_QUE_OFFSET_SHIFT     0
-#define I40E_AQ_VSI_TC_QUE_OFFSET_MASK      (0x1FF << \
-                                                I40E_AQ_VSI_TC_QUE_OFFSET_SHIFT)
-#define I40E_AQ_VSI_TC_QUE_NUMBER_SHIFT     9
-#define I40E_AQ_VSI_TC_QUE_NUMBER_MASK      (0x7 << \
-                                                I40E_AQ_VSI_TC_QUE_NUMBER_SHIFT)
+        __le16  mapping_flags;
+#define I40E_AQ_VSI_QUE_MAP_CONTIG      0x0
+#define I40E_AQ_VSI_QUE_MAP_NONCONTIG   0x1
+        __le16  queue_mapping[16];
+#define I40E_AQ_VSI_QUEUE_SHIFT         0x0
+#define I40E_AQ_VSI_QUEUE_MASK          (0x7FF << I40E_AQ_VSI_QUEUE_SHIFT)
+        __le16  tc_mapping[8];
+#define I40E_AQ_VSI_TC_QUE_OFFSET_SHIFT 0
+#define I40E_AQ_VSI_TC_QUE_OFFSET_MASK  (0x1FF << \
+                                         I40E_AQ_VSI_TC_QUE_OFFSET_SHIFT)
+#define I40E_AQ_VSI_TC_QUE_NUMBER_SHIFT 9
+#define I40E_AQ_VSI_TC_QUE_NUMBER_MASK  (0x7 << \
+                                         I40E_AQ_VSI_TC_QUE_NUMBER_SHIFT)
         /* queueing option section */
-        u8     queueing_opt_flags;
-#define I40E_AQ_VSI_QUE_OPT_TCP_ENA         0x10
-#define I40E_AQ_VSI_QUE_OPT_FCOE_ENA        0x20
-        u8     queueing_opt_reserved[3];
+        u8      queueing_opt_flags;
+#define I40E_AQ_VSI_QUE_OPT_TCP_ENA     0x10
+#define I40E_AQ_VSI_QUE_OPT_FCOE_ENA    0x20
+        u8      queueing_opt_reserved[3];
         /* scheduler section */
-        u8     up_enable_bits;
-        u8     sched_reserved;
+        u8      up_enable_bits;
+        u8      sched_reserved;
         /* outer up section */
-        __le32 outer_up_table; /* same structure and defines as ingress table */
-        u8     cmd_reserved[8];
+        __le32  outer_up_table; /* same structure and defines as ingress tbl */
+        u8      cmd_reserved[8];
         /* last 32 bytes are written by FW */
-        __le16 qs_handle[8];
+        __le16  qs_handle[8];
 #define I40E_AQ_VSI_QS_HANDLE_INVALID   0xFFFF
-        __le16 stat_counter_idx;
-        __le16 sched_id;
-        u8     resp_reserved[12];
+        __le16  stat_counter_idx;
+        __le16  sched_id;
+        u8      resp_reserved[12];
 };
 
 I40E_CHECK_STRUCT_LEN(128, i40e_aqc_vsi_properties_data);
@@ -831,26 +831,26 @@ I40E_CHECK_STRUCT_LEN(128, i40e_aqc_vsi_properties_data);
  * (IS_CTRL_PORT only works on add PV)
  */
 struct i40e_aqc_add_update_pv {
-        __le16 command_flags;
-#define I40E_AQC_PV_FLAG_PV_TYPE                0x1
-#define I40E_AQC_PV_FLAG_FWD_UNKNOWN_STAG_EN    0x2
-#define I40E_AQC_PV_FLAG_FWD_UNKNOWN_ETAG_EN    0x4
-#define I40E_AQC_PV_FLAG_IS_CTRL_PORT           0x8
-        __le16 uplink_seid;
-        __le16 connected_seid;
-        u8     reserved[10];
+        __le16  command_flags;
+#define I40E_AQC_PV_FLAG_PV_TYPE                0x1
+#define I40E_AQC_PV_FLAG_FWD_UNKNOWN_STAG_EN    0x2
+#define I40E_AQC_PV_FLAG_FWD_UNKNOWN_ETAG_EN    0x4
+#define I40E_AQC_PV_FLAG_IS_CTRL_PORT           0x8
+        __le16  uplink_seid;
+        __le16  connected_seid;
+        u8      reserved[10];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_update_pv);
 
 struct i40e_aqc_add_update_pv_completion {
         /* reserved for update; for add also encodes error if rc == ENOSPC */
-        __le16 pv_seid;
-#define I40E_AQC_PV_ERR_FLAG_NO_PV               0x1
-#define I40E_AQC_PV_ERR_FLAG_NO_SCHED            0x2
-#define I40E_AQC_PV_ERR_FLAG_NO_COUNTER          0x4
-#define I40E_AQC_PV_ERR_FLAG_NO_ENTRY            0x8
-        u8     reserved[14];
+        __le16  pv_seid;
+#define I40E_AQC_PV_ERR_FLAG_NO_PV      0x1
+#define I40E_AQC_PV_ERR_FLAG_NO_SCHED   0x2
+#define I40E_AQC_PV_ERR_FLAG_NO_COUNTER 0x4
+#define I40E_AQC_PV_ERR_FLAG_NO_ENTRY   0x8
+        u8      reserved[14];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_update_pv_completion);
@@ -860,48 +860,48 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_add_update_pv_completion);
  */
 
 struct i40e_aqc_get_pv_params_completion {
-        __le16 seid;
-        __le16 default_stag;
-        __le16 pv_flags; /* same flags as add_pv */
-#define I40E_AQC_GET_PV_PV_TYPE            0x1
-#define I40E_AQC_GET_PV_FRWD_UNKNOWN_STAG  0x2
-#define I40E_AQC_GET_PV_FRWD_UNKNOWN_ETAG  0x4
-        u8     reserved[8];
-        __le16 default_port_seid;
+        __le16  seid;
+        __le16  default_stag;
+        __le16  pv_flags; /* same flags as add_pv */
+#define I40E_AQC_GET_PV_PV_TYPE                 0x1
+#define I40E_AQC_GET_PV_FRWD_UNKNOWN_STAG       0x2
+#define I40E_AQC_GET_PV_FRWD_UNKNOWN_ETAG       0x4
+        u8      reserved[8];
+        __le16  default_port_seid;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_get_pv_params_completion);
 
 /* Add VEB (direct 0x0230) */
 struct i40e_aqc_add_veb {
-        __le16 uplink_seid;
-        __le16 downlink_seid;
-        __le16 veb_flags;
-#define I40E_AQC_ADD_VEB_FLOATING           0x1
-#define I40E_AQC_ADD_VEB_PORT_TYPE_SHIFT    1
-#define I40E_AQC_ADD_VEB_PORT_TYPE_MASK     (0x3 << \
+        __le16  uplink_seid;
+        __le16  downlink_seid;
+        __le16  veb_flags;
+#define I40E_AQC_ADD_VEB_FLOATING               0x1
+#define I40E_AQC_ADD_VEB_PORT_TYPE_SHIFT        1
+#define I40E_AQC_ADD_VEB_PORT_TYPE_MASK         (0x3 << \
                                         I40E_AQC_ADD_VEB_PORT_TYPE_SHIFT)
-#define I40E_AQC_ADD_VEB_PORT_TYPE_DEFAULT  0x2
-#define I40E_AQC_ADD_VEB_PORT_TYPE_DATA     0x4
-#define I40E_AQC_ADD_VEB_ENABLE_L2_FILTER   0x8
-        u8     enable_tcs;
-        u8     reserved[9];
+#define I40E_AQC_ADD_VEB_PORT_TYPE_DEFAULT      0x2
+#define I40E_AQC_ADD_VEB_PORT_TYPE_DATA         0x4
+#define I40E_AQC_ADD_VEB_ENABLE_L2_FILTER       0x8
+        u8      enable_tcs;
+        u8      reserved[9];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_veb);
 
 struct i40e_aqc_add_veb_completion {
-        u8     reserved[6];
-        __le16 switch_seid;
+        u8      reserved[6];
+        __le16  switch_seid;
         /* also encodes error if rc == ENOSPC; codes are the same as add_pv */
-        __le16 veb_seid;
-#define I40E_AQC_VEB_ERR_FLAG_NO_VEB              0x1
-#define I40E_AQC_VEB_ERR_FLAG_NO_SCHED            0x2
-#define I40E_AQC_VEB_ERR_FLAG_NO_COUNTER          0x4
-#define I40E_AQC_VEB_ERR_FLAG_NO_ENTRY            0x8
-        __le16 statistic_index;
-        __le16 vebs_used;
-        __le16 vebs_free;
+        __le16  veb_seid;
+#define I40E_AQC_VEB_ERR_FLAG_NO_VEB            0x1
+#define I40E_AQC_VEB_ERR_FLAG_NO_SCHED          0x2
+#define I40E_AQC_VEB_ERR_FLAG_NO_COUNTER        0x4
+#define I40E_AQC_VEB_ERR_FLAG_NO_ENTRY          0x8
+        __le16  statistic_index;
+        __le16  vebs_used;
+        __le16  vebs_free;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_veb_completion);
@@ -910,13 +910,13 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_add_veb_completion);
  * uses i40e_aqc_switch_seid for the descriptor
  */
 struct i40e_aqc_get_veb_parameters_completion {
-        __le16 seid;
-        __le16 switch_id;
-        __le16 veb_flags; /* only the first/last flags from 0x0230 is valid */
-        __le16 statistic_index;
-        __le16 vebs_used;
-        __le16 vebs_free;
-        u8     reserved[4];
+        __le16  seid;
+        __le16  switch_id;
+        __le16  veb_flags; /* only the first/last flags from 0x0230 is valid */
+        __le16  statistic_index;
+        __le16  vebs_used;
+        __le16  vebs_free;
+        u8      reserved[4];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_get_veb_parameters_completion);
@@ -929,37 +929,37 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_get_veb_parameters_completion);
 
 /* used for the command for most vlan commands */
 struct i40e_aqc_macvlan {
-        __le16 num_addresses;
-        __le16 seid[3];
-#define I40E_AQC_MACVLAN_CMD_SEID_NUM_SHIFT  0
-#define I40E_AQC_MACVLAN_CMD_SEID_NUM_MASK   (0x3FF << \
+        __le16  num_addresses;
+        __le16  seid[3];
+#define I40E_AQC_MACVLAN_CMD_SEID_NUM_SHIFT     0
+#define I40E_AQC_MACVLAN_CMD_SEID_NUM_MASK      (0x3FF << \
                                         I40E_AQC_MACVLAN_CMD_SEID_NUM_SHIFT)
-#define I40E_AQC_MACVLAN_CMD_SEID_VALID      0x8000
-        __le32 addr_high;
-        __le32 addr_low;
+#define I40E_AQC_MACVLAN_CMD_SEID_VALID         0x8000
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_macvlan);
 
 /* indirect data for command and response */
 struct i40e_aqc_add_macvlan_element_data {
-        u8     mac_addr[6];
-        __le16 vlan_tag;
-        __le16 flags;
-#define I40E_AQC_MACVLAN_ADD_PERFECT_MATCH     0x0001
-#define I40E_AQC_MACVLAN_ADD_HASH_MATCH        0x0002
-#define I40E_AQC_MACVLAN_ADD_IGNORE_VLAN       0x0004
-#define I40E_AQC_MACVLAN_ADD_TO_QUEUE          0x0008
-        __le16 queue_number;
-#define I40E_AQC_MACVLAN_CMD_QUEUE_SHIFT  0
-#define I40E_AQC_MACVLAN_CMD_QUEUE_MASK   (0x7FF << \
+        u8      mac_addr[6];
+        __le16  vlan_tag;
+        __le16  flags;
+#define I40E_AQC_MACVLAN_ADD_PERFECT_MATCH      0x0001
+#define I40E_AQC_MACVLAN_ADD_HASH_MATCH         0x0002
+#define I40E_AQC_MACVLAN_ADD_IGNORE_VLAN        0x0004
+#define I40E_AQC_MACVLAN_ADD_TO_QUEUE           0x0008
+        __le16  queue_number;
+#define I40E_AQC_MACVLAN_CMD_QUEUE_SHIFT        0
+#define I40E_AQC_MACVLAN_CMD_QUEUE_MASK         (0x7FF << \
                                         I40E_AQC_MACVLAN_CMD_SEID_NUM_SHIFT)
         /* response section */
-        u8     match_method;
-#define I40E_AQC_MM_PERFECT_MATCH             0x01
-#define I40E_AQC_MM_HASH_MATCH                0x02
-#define I40E_AQC_MM_ERR_NO_RES                0xFF
-        u8     reserved1[3];
+        u8      match_method;
+#define I40E_AQC_MM_PERFECT_MATCH       0x01
+#define I40E_AQC_MM_HASH_MATCH          0x02
+#define I40E_AQC_MM_ERR_NO_RES          0xFF
+        u8      reserved1[3];
 };
 
 struct i40e_aqc_add_remove_macvlan_completion {
@@ -979,19 +979,19 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_macvlan_completion);
  */
 
 struct i40e_aqc_remove_macvlan_element_data {
-        u8     mac_addr[6];
-        __le16 vlan_tag;
-        u8     flags;
-#define I40E_AQC_MACVLAN_DEL_PERFECT_MATCH      0x01
-#define I40E_AQC_MACVLAN_DEL_HASH_MATCH         0x02
-#define I40E_AQC_MACVLAN_DEL_IGNORE_VLAN        0x08
-#define I40E_AQC_MACVLAN_DEL_ALL_VSIS           0x10
-        u8     reserved[3];
+        u8      mac_addr[6];
+        __le16  vlan_tag;
+        u8      flags;
+#define I40E_AQC_MACVLAN_DEL_PERFECT_MATCH      0x01
+#define I40E_AQC_MACVLAN_DEL_HASH_MATCH         0x02
+#define I40E_AQC_MACVLAN_DEL_IGNORE_VLAN        0x08
+#define I40E_AQC_MACVLAN_DEL_ALL_VSIS           0x10
+        u8      reserved[3];
         /* reply section */
-        u8     error_code;
-#define I40E_AQC_REMOVE_MACVLAN_SUCCESS         0x0
-#define I40E_AQC_REMOVE_MACVLAN_FAIL            0xFF
-        u8     reply_reserved[3];
+        u8      error_code;
+#define I40E_AQC_REMOVE_MACVLAN_SUCCESS         0x0
+#define I40E_AQC_REMOVE_MACVLAN_FAIL            0xFF
+        u8      reply_reserved[3];
 };
 
 /* Add VLAN (indirect 0x0252)
@@ -999,59 +999,58 @@ struct i40e_aqc_remove_macvlan_element_data {
  * use the generic i40e_aqc_macvlan for the command
  */
 struct i40e_aqc_add_remove_vlan_element_data {
-        __le16 vlan_tag;
-        u8     vlan_flags;
+        __le16  vlan_tag;
+        u8      vlan_flags;
 /* flags for add VLAN */
-#define I40E_AQC_ADD_VLAN_LOCAL             0x1
-#define I40E_AQC_ADD_PVLAN_TYPE_SHIFT       1
-#define I40E_AQC_ADD_PVLAN_TYPE_MASK        (0x3 << \
-                                                I40E_AQC_ADD_PVLAN_TYPE_SHIFT)
-#define I40E_AQC_ADD_PVLAN_TYPE_REGULAR     0x0
-#define I40E_AQC_ADD_PVLAN_TYPE_PRIMARY     0x2
-#define I40E_AQC_ADD_PVLAN_TYPE_SECONDARY   0x4
-#define I40E_AQC_VLAN_PTYPE_SHIFT           3
-#define I40E_AQC_VLAN_PTYPE_MASK            (0x3 << I40E_AQC_VLAN_PTYPE_SHIFT)
-#define I40E_AQC_VLAN_PTYPE_REGULAR_VSI     0x0
-#define I40E_AQC_VLAN_PTYPE_PROMISC_VSI     0x8
-#define I40E_AQC_VLAN_PTYPE_COMMUNITY_VSI   0x10
-#define I40E_AQC_VLAN_PTYPE_ISOLATED_VSI    0x18
+#define I40E_AQC_ADD_VLAN_LOCAL                 0x1
+#define I40E_AQC_ADD_PVLAN_TYPE_SHIFT           1
+#define I40E_AQC_ADD_PVLAN_TYPE_MASK    (0x3 << I40E_AQC_ADD_PVLAN_TYPE_SHIFT)
+#define I40E_AQC_ADD_PVLAN_TYPE_REGULAR         0x0
+#define I40E_AQC_ADD_PVLAN_TYPE_PRIMARY         0x2
+#define I40E_AQC_ADD_PVLAN_TYPE_SECONDARY       0x4
+#define I40E_AQC_VLAN_PTYPE_SHIFT               3
+#define I40E_AQC_VLAN_PTYPE_MASK        (0x3 << I40E_AQC_VLAN_PTYPE_SHIFT)
+#define I40E_AQC_VLAN_PTYPE_REGULAR_VSI         0x0
+#define I40E_AQC_VLAN_PTYPE_PROMISC_VSI         0x8
+#define I40E_AQC_VLAN_PTYPE_COMMUNITY_VSI       0x10
+#define I40E_AQC_VLAN_PTYPE_ISOLATED_VSI        0x18
 /* flags for remove VLAN */
-#define I40E_AQC_REMOVE_VLAN_ALL            0x1
-        u8     reserved;
-        u8     result;
+#define I40E_AQC_REMOVE_VLAN_ALL        0x1
+        u8      reserved;
+        u8      result;
 /* flags for add VLAN */
-#define I40E_AQC_ADD_VLAN_SUCCESS       0x0
-#define I40E_AQC_ADD_VLAN_FAIL_REQUEST  0xFE
-#define I40E_AQC_ADD_VLAN_FAIL_RESOURCE 0xFF
+#define I40E_AQC_ADD_VLAN_SUCCESS       0x0
+#define I40E_AQC_ADD_VLAN_FAIL_REQUEST  0xFE
+#define I40E_AQC_ADD_VLAN_FAIL_RESOURCE 0xFF
 /* flags for remove VLAN */
-#define I40E_AQC_REMOVE_VLAN_SUCCESS    0x0
-#define I40E_AQC_REMOVE_VLAN_FAIL       0xFF
-        u8     reserved1[3];
+#define I40E_AQC_REMOVE_VLAN_SUCCESS    0x0
+#define I40E_AQC_REMOVE_VLAN_FAIL       0xFF
+        u8      reserved1[3];
 };
 
 struct i40e_aqc_add_remove_vlan_completion {
-        u8     reserved[4];
-        __le16 vlans_used;
-        __le16 vlans_free;
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      reserved[4];
+        __le16  vlans_used;
+        __le16  vlans_free;
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 /* Set VSI Promiscuous Modes (direct 0x0254) */
 struct i40e_aqc_set_vsi_promiscuous_modes {
-        __le16 promiscuous_flags;
-        __le16 valid_flags;
+        __le16  promiscuous_flags;
+        __le16  valid_flags;
 /* flags used for both fields above */
-#define I40E_AQC_SET_VSI_PROMISC_UNICAST     0x01
-#define I40E_AQC_SET_VSI_PROMISC_MULTICAST   0x02
-#define I40E_AQC_SET_VSI_PROMISC_BROADCAST   0x04
-#define I40E_AQC_SET_VSI_DEFAULT             0x08
-#define I40E_AQC_SET_VSI_PROMISC_VLAN        0x10
-        __le16 seid;
-#define I40E_AQC_VSI_PROM_CMD_SEID_MASK      0x3FF
-        __le16 vlan_tag;
-#define I40E_AQC_SET_VSI_VLAN_VALID          0x8000
-        u8     reserved[8];
+#define I40E_AQC_SET_VSI_PROMISC_UNICAST        0x01
+#define I40E_AQC_SET_VSI_PROMISC_MULTICAST      0x02
+#define I40E_AQC_SET_VSI_PROMISC_BROADCAST      0x04
+#define I40E_AQC_SET_VSI_DEFAULT                0x08
+#define I40E_AQC_SET_VSI_PROMISC_VLAN           0x10
+        __le16  seid;
+#define I40E_AQC_VSI_PROM_CMD_SEID_MASK         0x3FF
+        __le16  vlan_tag;
+#define I40E_AQC_SET_VSI_VLAN_VALID             0x8000
+        u8      reserved[8];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_set_vsi_promiscuous_modes);
@@ -1060,23 +1059,23 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_set_vsi_promiscuous_modes);
  * Uses generic i40e_aqc_add_remove_tag_completion for completion
  */
 struct i40e_aqc_add_tag {
-        __le16 flags;
-#define I40E_AQC_ADD_TAG_FLAG_TO_QUEUE     0x0001
-        __le16 seid;
-#define I40E_AQC_ADD_TAG_CMD_SEID_NUM_SHIFT  0
-#define I40E_AQC_ADD_TAG_CMD_SEID_NUM_MASK   (0x3FF << \
+        __le16  flags;
+#define I40E_AQC_ADD_TAG_FLAG_TO_QUEUE          0x0001
+        __le16  seid;
+#define I40E_AQC_ADD_TAG_CMD_SEID_NUM_SHIFT     0
+#define I40E_AQC_ADD_TAG_CMD_SEID_NUM_MASK      (0x3FF << \
                                         I40E_AQC_ADD_TAG_CMD_SEID_NUM_SHIFT)
-        __le16 tag;
-        __le16 queue_number;
-        u8     reserved[8];
+        __le16  tag;
+        __le16  queue_number;
+        u8      reserved[8];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_tag);
 
 struct i40e_aqc_add_remove_tag_completion {
-        u8     reserved[12];
-        __le16 tags_used;
-        __le16 tags_free;
+        u8      reserved[12];
+        __le16  tags_used;
+        __le16  tags_free;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_tag_completion);
@@ -1085,12 +1084,12 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_tag_completion);
  * Uses generic i40e_aqc_add_remove_tag_completion for completion
  */
 struct i40e_aqc_remove_tag {
-        __le16 seid;
-#define I40E_AQC_REMOVE_TAG_CMD_SEID_NUM_SHIFT  0
-#define I40E_AQC_REMOVE_TAG_CMD_SEID_NUM_MASK   (0x3FF << \
+        __le16  seid;
+#define I40E_AQC_REMOVE_TAG_CMD_SEID_NUM_SHIFT  0
+#define I40E_AQC_REMOVE_TAG_CMD_SEID_NUM_MASK   (0x3FF << \
                                         I40E_AQC_REMOVE_TAG_CMD_SEID_NUM_SHIFT)
-        __le16 tag;
-        u8     reserved[12];
+        __le16  tag;
+        u8      reserved[12];
 };
 
 /* Add multicast E-Tag (direct 0x0257)
@@ -1098,22 +1097,22 @@ struct i40e_aqc_remove_tag {
  * and no external data
  */
 struct i40e_aqc_add_remove_mcast_etag {
-        __le16 pv_seid;
-        __le16 etag;
-        u8     num_unicast_etags;
-        u8     reserved[3];
-        __le32 addr_high;          /* address of array of 2-byte s-tags */
-        __le32 addr_low;
+        __le16  pv_seid;
+        __le16  etag;
+        u8      num_unicast_etags;
+        u8      reserved[3];
+        __le32  addr_high;          /* address of array of 2-byte s-tags */
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_mcast_etag);
 
 struct i40e_aqc_add_remove_mcast_etag_completion {
-        u8     reserved[4];
-        __le16 mcast_etags_used;
-        __le16 mcast_etags_free;
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      reserved[4];
+        __le16  mcast_etags_used;
+        __le16  mcast_etags_free;
+        __le32  addr_high;
+        __le32  addr_low;
 
 };
 
@@ -1121,21 +1120,21 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_mcast_etag_completion);
 
 /* Update S/E-Tag (direct 0x0259) */
 struct i40e_aqc_update_tag {
-        __le16 seid;
-#define I40E_AQC_UPDATE_TAG_CMD_SEID_NUM_SHIFT  0
-#define I40E_AQC_UPDATE_TAG_CMD_SEID_NUM_MASK   (0x3FF << \
+        __le16  seid;
+#define I40E_AQC_UPDATE_TAG_CMD_SEID_NUM_SHIFT  0
+#define I40E_AQC_UPDATE_TAG_CMD_SEID_NUM_MASK   (0x3FF << \
                                         I40E_AQC_UPDATE_TAG_CMD_SEID_NUM_SHIFT)
-        __le16 old_tag;
-        __le16 new_tag;
-        u8     reserved[10];
+        __le16  old_tag;
+        __le16  new_tag;
+        u8      reserved[10];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_update_tag);
 
 struct i40e_aqc_update_tag_completion {
-        u8     reserved[12];
-        __le16 tags_used;
-        __le16 tags_free;
+        u8      reserved[12];
+        __le16  tags_used;
+        __le16  tags_free;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_update_tag_completion);
@@ -1146,30 +1145,30 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_update_tag_completion);
  * and the generic direct completion structure
  */
 struct i40e_aqc_add_remove_control_packet_filter {
-        u8     mac[6];
-        __le16 etype;
-        __le16 flags;
-#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_IGNORE_MAC    0x0001
-#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_DROP          0x0002
-#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_TO_QUEUE      0x0004
-#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_TX            0x0008
-#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_RX            0x0000
-        __le16 seid;
-#define I40E_AQC_ADD_CONTROL_PACKET_CMD_SEID_NUM_SHIFT  0
-#define I40E_AQC_ADD_CONTROL_PACKET_CMD_SEID_NUM_MASK   (0x3FF << \
+        u8      mac[6];
+        __le16  etype;
+        __le16  flags;
+#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_IGNORE_MAC    0x0001
+#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_DROP          0x0002
+#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_TO_QUEUE      0x0004
+#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_TX            0x0008
+#define I40E_AQC_ADD_CONTROL_PACKET_FLAGS_RX            0x0000
+        __le16  seid;
+#define I40E_AQC_ADD_CONTROL_PACKET_CMD_SEID_NUM_SHIFT  0
+#define I40E_AQC_ADD_CONTROL_PACKET_CMD_SEID_NUM_MASK   (0x3FF << \
                                 I40E_AQC_ADD_CONTROL_PACKET_CMD_SEID_NUM_SHIFT)
-        __le16 queue;
-        u8     reserved[2];
+        __le16  queue;
+        u8      reserved[2];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_control_packet_filter);
 
 struct i40e_aqc_add_remove_control_packet_filter_completion {
-        __le16 mac_etype_used;
-        __le16 etype_used;
-        __le16 mac_etype_free;
-        __le16 etype_free;
-        u8     reserved[8];
+        __le16  mac_etype_used;
+        __le16  etype_used;
+        __le16  mac_etype_free;
+        __le16  etype_free;
+        u8      reserved[8];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_control_packet_filter_completion);
@@ -1180,23 +1179,23 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_control_packet_filter_completion);
  * and the generic indirect completion structure
  */
 struct i40e_aqc_add_remove_cloud_filters {
-        u8     num_filters;
-        u8     reserved;
-        __le16 seid;
-#define I40E_AQC_ADD_CLOUD_CMD_SEID_NUM_SHIFT  0
-#define I40E_AQC_ADD_CLOUD_CMD_SEID_NUM_MASK   (0x3FF << \
+        u8      num_filters;
+        u8      reserved;
+        __le16  seid;
+#define I40E_AQC_ADD_CLOUD_CMD_SEID_NUM_SHIFT   0
+#define I40E_AQC_ADD_CLOUD_CMD_SEID_NUM_MASK    (0x3FF << \
                                         I40E_AQC_ADD_CLOUD_CMD_SEID_NUM_SHIFT)
-        u8     reserved2[4];
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      reserved2[4];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_remove_cloud_filters);
 
 struct i40e_aqc_add_remove_cloud_filters_element_data {
-        u8     outer_mac[6];
-        u8     inner_mac[6];
-        __le16 inner_vlan;
+        u8      outer_mac[6];
+        u8      inner_mac[6];
+        __le16  inner_vlan;
         union {
                 struct {
                         u8 reserved[12];
@@ -1206,52 +1205,49 @@ struct i40e_aqc_add_remove_cloud_filters_element_data {
                         u8 data[16];
                 } v6;
         } ipaddr;
-        __le16 flags;
-#define I40E_AQC_ADD_CLOUD_FILTER_SHIFT                 0
-#define I40E_AQC_ADD_CLOUD_FILTER_MASK                  (0x3F << \
+        __le16  flags;
+#define I40E_AQC_ADD_CLOUD_FILTER_SHIFT                 0
+#define I40E_AQC_ADD_CLOUD_FILTER_MASK                  (0x3F << \
                                         I40E_AQC_ADD_CLOUD_FILTER_SHIFT)
-#define I40E_AQC_ADD_CLOUD_FILTER_OIP_GRE               0x0002
-#define I40E_AQC_ADD_CLOUD_FILTER_IMAC_IVLAN_GRE        0x0004
-#define I40E_AQC_ADD_CLOUD_FILTER_IMAC_IVLAN_VNL        0x0007
 /* 0x0000 reserved */
-#define I40E_AQC_ADD_CLOUD_FILTER_OIP                   0x0001
+#define I40E_AQC_ADD_CLOUD_FILTER_OIP                   0x0001
 /* 0x0002 reserved */
-#define I40E_AQC_ADD_CLOUD_FILTER_IMAC_IVLAN            0x0003
-#define I40E_AQC_ADD_CLOUD_FILTER_IMAC_IVLAN_TEN_ID     0x0004
+#define I40E_AQC_ADD_CLOUD_FILTER_IMAC_IVLAN            0x0003
+#define I40E_AQC_ADD_CLOUD_FILTER_IMAC_IVLAN_TEN_ID     0x0004
 /* 0x0005 reserved */
-#define I40E_AQC_ADD_CLOUD_FILTER_IMAC_TEN_ID           0x0006
+#define I40E_AQC_ADD_CLOUD_FILTER_IMAC_TEN_ID           0x0006
 /* 0x0007 reserved */
 /* 0x0008 reserved */
-#define I40E_AQC_ADD_CLOUD_FILTER_OMAC                  0x0009
-#define I40E_AQC_ADD_CLOUD_FILTER_IMAC                  0x000A
-#define I40E_AQC_ADD_CLOUD_FILTER_OMAC_TEN_ID_IMAC      0x000B
-#define I40E_AQC_ADD_CLOUD_FILTER_IIP                   0x000C
-
-#define I40E_AQC_ADD_CLOUD_FLAGS_TO_QUEUE               0x0080
-#define I40E_AQC_ADD_CLOUD_VNK_SHIFT                    6
-#define I40E_AQC_ADD_CLOUD_VNK_MASK                     0x00C0
-#define I40E_AQC_ADD_CLOUD_FLAGS_IPV4                   0
-#define I40E_AQC_ADD_CLOUD_FLAGS_IPV6                   0x0100
-
-#define I40E_AQC_ADD_CLOUD_TNL_TYPE_SHIFT               9
-#define I40E_AQC_ADD_CLOUD_TNL_TYPE_MASK                0x1E00
-#define I40E_AQC_ADD_CLOUD_TNL_TYPE_XVLAN               0
-#define I40E_AQC_ADD_CLOUD_TNL_TYPE_NVGRE_OMAC          1
-#define I40E_AQC_ADD_CLOUD_TNL_TYPE_NGE                 2
-#define I40E_AQC_ADD_CLOUD_TNL_TYPE_IP                  3
-
-        __le32 tenant_id;
-        u8     reserved[4];
-        __le16 queue_number;
-#define I40E_AQC_ADD_CLOUD_QUEUE_SHIFT                  0
-#define I40E_AQC_ADD_CLOUD_QUEUE_MASK                   (0x3F << \
-                                        I40E_AQC_ADD_CLOUD_QUEUE_SHIFT)
-        u8     reserved2[14];
+#define I40E_AQC_ADD_CLOUD_FILTER_OMAC                  0x0009
+#define I40E_AQC_ADD_CLOUD_FILTER_IMAC                  0x000A
+#define I40E_AQC_ADD_CLOUD_FILTER_OMAC_TEN_ID_IMAC      0x000B
+#define I40E_AQC_ADD_CLOUD_FILTER_IIP                   0x000C
+
+#define I40E_AQC_ADD_CLOUD_FLAGS_TO_QUEUE               0x0080
+#define I40E_AQC_ADD_CLOUD_VNK_SHIFT                    6
+#define I40E_AQC_ADD_CLOUD_VNK_MASK                     0x00C0
+#define I40E_AQC_ADD_CLOUD_FLAGS_IPV4                   0
+#define I40E_AQC_ADD_CLOUD_FLAGS_IPV6                   0x0100
+
+#define I40E_AQC_ADD_CLOUD_TNL_TYPE_SHIFT               9
+#define I40E_AQC_ADD_CLOUD_TNL_TYPE_MASK                0x1E00
+#define I40E_AQC_ADD_CLOUD_TNL_TYPE_XVLAN               0
+#define I40E_AQC_ADD_CLOUD_TNL_TYPE_NVGRE_OMAC          1
+#define I40E_AQC_ADD_CLOUD_TNL_TYPE_NGE                 2
+#define I40E_AQC_ADD_CLOUD_TNL_TYPE_IP                  3
+
+        __le32  tenant_id;
+        u8      reserved[4];
+        __le16  queue_number;
+#define I40E_AQC_ADD_CLOUD_QUEUE_SHIFT          0
+#define I40E_AQC_ADD_CLOUD_QUEUE_MASK           (0x3F << \
+                                                 I40E_AQC_ADD_CLOUD_QUEUE_SHIFT)
+        u8      reserved2[14];
         /* response section */
-        u8     allocation_result;
-#define I40E_AQC_ADD_CLOUD_FILTER_SUCCESS         0x0
-#define I40E_AQC_ADD_CLOUD_FILTER_FAIL            0xFF
-        u8     response_reserved[7];
+        u8      allocation_result;
+#define I40E_AQC_ADD_CLOUD_FILTER_SUCCESS       0x0
+#define I40E_AQC_ADD_CLOUD_FILTER_FAIL          0xFF
+        u8      response_reserved[7];
 };
 
 struct i40e_aqc_remove_cloud_filters_completion {
@@ -1273,14 +1269,14 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_remove_cloud_filters_completion);
 struct i40e_aqc_add_delete_mirror_rule {
         __le16 seid;
         __le16 rule_type;
-#define I40E_AQC_MIRROR_RULE_TYPE_SHIFT            0
-#define I40E_AQC_MIRROR_RULE_TYPE_MASK             (0x7 << \
+#define I40E_AQC_MIRROR_RULE_TYPE_SHIFT         0
+#define I40E_AQC_MIRROR_RULE_TYPE_MASK          (0x7 << \
                                                 I40E_AQC_MIRROR_RULE_TYPE_SHIFT)
-#define I40E_AQC_MIRROR_RULE_TYPE_VPORT_INGRESS    1
-#define I40E_AQC_MIRROR_RULE_TYPE_VPORT_EGRESS     2
-#define I40E_AQC_MIRROR_RULE_TYPE_VLAN             3
-#define I40E_AQC_MIRROR_RULE_TYPE_ALL_INGRESS      4
-#define I40E_AQC_MIRROR_RULE_TYPE_ALL_EGRESS       5
+#define I40E_AQC_MIRROR_RULE_TYPE_VPORT_INGRESS 1
+#define I40E_AQC_MIRROR_RULE_TYPE_VPORT_EGRESS  2
+#define I40E_AQC_MIRROR_RULE_TYPE_VLAN          3
+#define I40E_AQC_MIRROR_RULE_TYPE_ALL_INGRESS   4
+#define I40E_AQC_MIRROR_RULE_TYPE_ALL_EGRESS    5
         __le16 num_entries;
         __le16 destination;  /* VSI for add, rule id for delete */
         __le32 addr_high;    /* address of array of 2-byte VSI or VLAN ids */
@@ -1290,12 +1286,12 @@ struct i40e_aqc_add_delete_mirror_rule {
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_delete_mirror_rule);
 
 struct i40e_aqc_add_delete_mirror_rule_completion {
-        u8     reserved[2];
-        __le16 rule_id;  /* only used on add */
-        __le16 mirror_rules_used;
-        __le16 mirror_rules_free;
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      reserved[2];
+        __le16  rule_id;  /* only used on add */
+        __le16  mirror_rules_used;
+        __le16  mirror_rules_free;
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_delete_mirror_rule_completion);
@@ -1306,11 +1302,11 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_add_delete_mirror_rule_completion);
  *    the command and response use the same descriptor structure
  */
 struct i40e_aqc_pfc_ignore {
-        u8     tc_bitmap;
-        u8     command_flags; /* unused on response */
-#define I40E_AQC_PFC_IGNORE_SET    0x80
-#define I40E_AQC_PFC_IGNORE_CLEAR  0x0
-        u8     reserved[14];
+        u8      tc_bitmap;
+        u8      command_flags; /* unused on response */
+#define I40E_AQC_PFC_IGNORE_SET         0x80
+#define I40E_AQC_PFC_IGNORE_CLEAR       0x0
+        u8      reserved[14];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_pfc_ignore);
@@ -1325,10 +1321,10 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_pfc_ignore);
  * this generic struct to pass the SEID in param0
  */
 struct i40e_aqc_tx_sched_ind {
-        __le16 vsi_seid;
-        u8     reserved[6];
-        __le32 addr_high;
-        __le32 addr_low;
+        __le16  vsi_seid;
+        u8      reserved[6];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_tx_sched_ind);
@@ -1340,12 +1336,12 @@ struct i40e_aqc_qs_handles_resp {
 
 /* Configure VSI BW limits (direct 0x0400) */
 struct i40e_aqc_configure_vsi_bw_limit {
-        __le16 vsi_seid;
-        u8     reserved[2];
-        __le16 credit;
-        u8     reserved1[2];
-        u8     max_credit; /* 0-3, limit = 2^max */
-        u8     reserved2[7];
+        __le16  vsi_seid;
+        u8      reserved[2];
+        __le16  credit;
+        u8      reserved1[2];
+        u8      max_credit; /* 0-3, limit = 2^max */
+        u8      reserved2[7];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_configure_vsi_bw_limit);
@@ -1354,58 +1350,58 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_configure_vsi_bw_limit);
  *    responds with i40e_aqc_qs_handles_resp
  */
 struct i40e_aqc_configure_vsi_ets_sla_bw_data {
-        u8     tc_valid_bits;
-        u8     reserved[15];
-        __le16 tc_bw_credits[8]; /* FW writesback QS handles here */
+        u8      tc_valid_bits;
+        u8      reserved[15];
+        __le16  tc_bw_credits[8]; /* FW writesback QS handles here */
 
         /* 4 bits per tc 0-7, 4th bit is reserved, limit = 2^max */
-        __le16 tc_bw_max[2];
-        u8     reserved1[28];
+        __le16  tc_bw_max[2];
+        u8      reserved1[28];
 };
 
 /* Configure VSI Bandwidth Allocation per Traffic Type (indirect 0x0407)
  *    responds with i40e_aqc_qs_handles_resp
  */
 struct i40e_aqc_configure_vsi_tc_bw_data {
-        u8     tc_valid_bits;
-        u8     reserved[3];
-        u8     tc_bw_credits[8];
-        u8     reserved1[4];
-        __le16 qs_handles[8];
+        u8      tc_valid_bits;
+        u8      reserved[3];
+        u8      tc_bw_credits[8];
+        u8      reserved1[4];
+        __le16  qs_handles[8];
 };
 
 /* Query vsi bw configuration (indirect 0x0408) */
 struct i40e_aqc_query_vsi_bw_config_resp {
-        u8     tc_valid_bits;
-        u8     tc_suspended_bits;
-        u8     reserved[14];
-        __le16 qs_handles[8];
-        u8     reserved1[4];
-        __le16 port_bw_limit;
-        u8     reserved2[2];
-        u8     max_bw; /* 0-3, limit = 2^max */
-        u8     reserved3[23];
+        u8      tc_valid_bits;
+        u8      tc_suspended_bits;
+        u8      reserved[14];
+        __le16  qs_handles[8];
+        u8      reserved1[4];
+        __le16  port_bw_limit;
+        u8      reserved2[2];
+        u8      max_bw; /* 0-3, limit = 2^max */
+        u8      reserved3[23];
 };
 
 /* Query VSI Bandwidth Allocation per Traffic Type (indirect 0x040A) */
 struct i40e_aqc_query_vsi_ets_sla_config_resp {
-        u8     tc_valid_bits;
-        u8     reserved[3];
-        u8     share_credits[8];
-        __le16 credits[8];
+        u8      tc_valid_bits;
+        u8      reserved[3];
+        u8      share_credits[8];
+        __le16  credits[8];
 
         /* 4 bits per tc 0-7, 4th bit is reserved, limit = 2^max */
-        __le16 tc_bw_max[2];
+        __le16  tc_bw_max[2];
 };
 
 /* Configure Switching Component Bandwidth Limit (direct 0x0410) */
 struct i40e_aqc_configure_switching_comp_bw_limit {
-        __le16 seid;
-        u8     reserved[2];
-        __le16 credit;
-        u8     reserved1[2];
-        u8     max_bw; /* 0-3, limit = 2^max */
-        u8     reserved2[7];
+        __le16  seid;
+        u8      reserved[2];
+        __le16  credit;
+        u8      reserved1[2];
+        u8      max_bw; /* 0-3, limit = 2^max */
+        u8      reserved2[7];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_configure_switching_comp_bw_limit);
@@ -1415,75 +1411,75 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_configure_switching_comp_bw_limit);
  * Disable Physical Port ETS (indirect 0x0415)
  */
 struct i40e_aqc_configure_switching_comp_ets_data {
-        u8     reserved[4];
-        u8     tc_valid_bits;
-        u8     seepage;
-#define I40E_AQ_ETS_SEEPAGE_EN_MASK     0x1
-        u8     tc_strict_priority_flags;
-        u8     reserved1[17];
-        u8     tc_bw_share_credits[8];
-        u8     reserved2[96];
+        u8      reserved[4];
+        u8      tc_valid_bits;
+        u8      seepage;
+#define I40E_AQ_ETS_SEEPAGE_EN_MASK     0x1
+        u8      tc_strict_priority_flags;
+        u8      reserved1[17];
+        u8      tc_bw_share_credits[8];
+        u8      reserved2[96];
 };
 
 /* Configure Switching Component Bandwidth Limits per Tc (indirect 0x0416) */
 struct i40e_aqc_configure_switching_comp_ets_bw_limit_data {
-        u8     tc_valid_bits;
-        u8     reserved[15];
-        __le16 tc_bw_credit[8];
+        u8      tc_valid_bits;
+        u8      reserved[15];
+        __le16  tc_bw_credit[8];
 
         /* 4 bits per tc 0-7, 4th bit is reserved, limit = 2^max */
-        __le16 tc_bw_max[2];
-        u8     reserved1[28];
+        __le16  tc_bw_max[2];
+        u8      reserved1[28];
 };
 
 /* Configure Switching Component Bandwidth Allocation per Tc
  * (indirect 0x0417)
  */
 struct i40e_aqc_configure_switching_comp_bw_config_data {
-        u8     tc_valid_bits;
-        u8     reserved[2];
-        u8     absolute_credits; /* bool */
-        u8     tc_bw_share_credits[8];
-        u8     reserved1[20];
+        u8      tc_valid_bits;
+        u8      reserved[2];
+        u8      absolute_credits; /* bool */
+        u8      tc_bw_share_credits[8];
+        u8      reserved1[20];
 };
 
 /* Query Switching Component Configuration (indirect 0x0418) */
 struct i40e_aqc_query_switching_comp_ets_config_resp {
-        u8     tc_valid_bits;
-        u8     reserved[35];
-        __le16 port_bw_limit;
-        u8     reserved1[2];
-        u8     tc_bw_max; /* 0-3, limit = 2^max */
-        u8     reserved2[23];
+        u8      tc_valid_bits;
+        u8      reserved[35];
+        __le16  port_bw_limit;
+        u8      reserved1[2];
+        u8      tc_bw_max; /* 0-3, limit = 2^max */
+        u8      reserved2[23];
 };
 
 /* Query PhysicalPort ETS Configuration (indirect 0x0419) */
 struct i40e_aqc_query_port_ets_config_resp {
-        u8     reserved[4];
-        u8     tc_valid_bits;
-        u8     reserved1;
-        u8     tc_strict_priority_bits;
-        u8     reserved2;
-        u8     tc_bw_share_credits[8];
-        __le16 tc_bw_limits[8];
+        u8      reserved[4];
+        u8      tc_valid_bits;
+        u8      reserved1;
+        u8      tc_strict_priority_bits;
+        u8      reserved2;
+        u8      tc_bw_share_credits[8];
+        __le16  tc_bw_limits[8];
 
         /* 4 bits per tc 0-7, 4th bit reserved, limit = 2^max */
-        __le16 tc_bw_max[2];
-        u8     reserved3[32];
+        __le16  tc_bw_max[2];
+        u8      reserved3[32];
 };
 
 /* Query Switching Component Bandwidth Allocation per Traffic Type
  * (indirect 0x041A)
  */
 struct i40e_aqc_query_switching_comp_bw_config_resp {
-        u8     tc_valid_bits;
-        u8     reserved[2];
-        u8     absolute_credits_enable; /* bool */
-        u8     tc_bw_share_credits[8];
-        __le16 tc_bw_limits[8];
+        u8      tc_valid_bits;
+        u8      reserved[2];
+        u8      absolute_credits_enable; /* bool */
+        u8      tc_bw_share_credits[8];
+        __le16  tc_bw_limits[8];
 
         /* 4 bits per tc 0-7, 4th bit is reserved, limit = 2^max */
-        __le16 tc_bw_max[2];
+        __le16  tc_bw_max[2];
 };
 
 /* Suspend/resume port TX traffic
@@ -1494,37 +1490,37 @@ struct i40e_aqc_query_switching_comp_bw_config_resp {
  * (indirect 0x041D)
  */
 struct i40e_aqc_configure_partition_bw_data {
-        __le16 pf_valid_bits;
-        u8     min_bw[16];      /* guaranteed bandwidth */
-        u8     max_bw[16];      /* bandwidth limit */
+        __le16  pf_valid_bits;
+        u8      min_bw[16];      /* guaranteed bandwidth */
+        u8      max_bw[16];      /* bandwidth limit */
 };
 
 /* Get and set the active HMC resource profile and status.
  * (direct 0x0500) and (direct 0x0501)
  */
 struct i40e_aq_get_set_hmc_resource_profile {
-        u8     pm_profile;
-        u8     pe_vf_enabled;
-        u8     reserved[14];
+        u8      pm_profile;
+        u8      pe_vf_enabled;
+        u8      reserved[14];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aq_get_set_hmc_resource_profile);
 
 enum i40e_aq_hmc_profile {
         /* I40E_HMC_PROFILE_NO_CHANGE    = 0, reserved */
-        I40E_HMC_PROFILE_DEFAULT     = 1,
-        I40E_HMC_PROFILE_FAVOR_VF    = 2,
-        I40E_HMC_PROFILE_EQUAL       = 3,
+        I40E_HMC_PROFILE_DEFAULT        = 1,
+        I40E_HMC_PROFILE_FAVOR_VF       = 2,
+        I40E_HMC_PROFILE_EQUAL          = 3,
 };
 
-#define I40E_AQ_GET_HMC_RESOURCE_PROFILE_PM_MASK       0xF
-#define I40E_AQ_GET_HMC_RESOURCE_PROFILE_COUNT_MASK    0x3F
+#define I40E_AQ_GET_HMC_RESOURCE_PROFILE_PM_MASK        0xF
+#define I40E_AQ_GET_HMC_RESOURCE_PROFILE_COUNT_MASK     0x3F
 
 /* Get PHY Abilities (indirect 0x0600) uses the generic indirect struct */
 
 /* set in param0 for get phy abilities to report qualified modules */
-#define I40E_AQ_PHY_REPORT_QUALIFIED_MODULES  0x0001
-#define I40E_AQ_PHY_REPORT_INITIAL_VALUES     0x0002
+#define I40E_AQ_PHY_REPORT_QUALIFIED_MODULES    0x0001
+#define I40E_AQ_PHY_REPORT_INITIAL_VALUES       0x0002
 
 enum i40e_aq_phy_type {
         I40E_PHY_TYPE_SGMII                     = 0x0,
@@ -1582,147 +1578,147 @@ struct i40e_aqc_module_desc {
 };
 
 struct i40e_aq_get_phy_abilities_resp {
-        __le32 phy_type;       /* bitmap using the above enum for offsets */
-        u8     link_speed;     /* bitmap using the above enum bit patterns */
-        u8     abilities;
-#define I40E_AQ_PHY_FLAG_PAUSE_TX         0x01
-#define I40E_AQ_PHY_FLAG_PAUSE_RX         0x02
-#define I40E_AQ_PHY_FLAG_LOW_POWER        0x04
-#define I40E_AQ_PHY_LINK_ENABLED                  0x08
-#define I40E_AQ_PHY_AN_ENABLED                    0x10
-#define I40E_AQ_PHY_FLAG_MODULE_QUAL      0x20
-        __le16 eee_capability;
-#define I40E_AQ_EEE_100BASE_TX       0x0002
-#define I40E_AQ_EEE_1000BASE_T       0x0004
-#define I40E_AQ_EEE_10GBASE_T        0x0008
-#define I40E_AQ_EEE_1000BASE_KX      0x0010
-#define I40E_AQ_EEE_10GBASE_KX4      0x0020
-#define I40E_AQ_EEE_10GBASE_KR       0x0040
-        __le32 eeer_val;
-        u8     d3_lpan;
-#define I40E_AQ_SET_PHY_D3_LPAN_ENA  0x01
-        u8     reserved[3];
-        u8     phy_id[4];
-        u8     module_type[3];
-        u8     qualified_module_count;
-#define I40E_AQ_PHY_MAX_QMS          16
-        struct i40e_aqc_module_desc  qualified_module[I40E_AQ_PHY_MAX_QMS];
+        __le32  phy_type;       /* bitmap using the above enum for offsets */
+        u8      link_speed;     /* bitmap using the above enum bit patterns */
+        u8      abilities;
+#define I40E_AQ_PHY_FLAG_PAUSE_TX       0x01
+#define I40E_AQ_PHY_FLAG_PAUSE_RX       0x02
+#define I40E_AQ_PHY_FLAG_LOW_POWER      0x04
+#define I40E_AQ_PHY_LINK_ENABLED        0x08
+#define I40E_AQ_PHY_AN_ENABLED          0x10
+#define I40E_AQ_PHY_FLAG_MODULE_QUAL    0x20
+        __le16  eee_capability;
+#define I40E_AQ_EEE_100BASE_TX          0x0002
+#define I40E_AQ_EEE_1000BASE_T          0x0004
+#define I40E_AQ_EEE_10GBASE_T           0x0008
+#define I40E_AQ_EEE_1000BASE_KX         0x0010
+#define I40E_AQ_EEE_10GBASE_KX4         0x0020
+#define I40E_AQ_EEE_10GBASE_KR          0x0040
+        __le32  eeer_val;
+        u8      d3_lpan;
+#define I40E_AQ_SET_PHY_D3_LPAN_ENA     0x01
+        u8      reserved[3];
+        u8      phy_id[4];
+        u8      module_type[3];
+        u8      qualified_module_count;
+#define I40E_AQ_PHY_MAX_QMS             16
+        struct i40e_aqc_module_desc     qualified_module[I40E_AQ_PHY_MAX_QMS];
 };
 
 /* Set PHY Config (direct 0x0601) */
 struct i40e_aq_set_phy_config { /* same bits as above in all */
-        __le32 phy_type;
-        u8     link_speed;
-        u8     abilities;
+        __le32  phy_type;
+        u8      link_speed;
+        u8      abilities;
 /* bits 0-2 use the values from get_phy_abilities_resp */
 #define I40E_AQ_PHY_ENABLE_LINK         0x08
 #define I40E_AQ_PHY_ENABLE_AN           0x10
 #define I40E_AQ_PHY_ENABLE_ATOMIC_LINK  0x20
-        __le16 eee_capability;
-        __le32 eeer;
-        u8     low_power_ctrl;
-        u8     reserved[3];
+        __le16  eee_capability;
+        __le32  eeer;
+        u8      low_power_ctrl;
+        u8      reserved[3];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aq_set_phy_config);
 
 /* Set MAC Config command data structure (direct 0x0603) */
 struct i40e_aq_set_mac_config {
-        __le16 max_frame_size;
-        u8     params;
-#define I40E_AQ_SET_MAC_CONFIG_CRC_EN           0x04
-#define I40E_AQ_SET_MAC_CONFIG_PACING_MASK      0x78
-#define I40E_AQ_SET_MAC_CONFIG_PACING_SHIFT     3
-#define I40E_AQ_SET_MAC_CONFIG_PACING_NONE      0x0
-#define I40E_AQ_SET_MAC_CONFIG_PACING_1B_13TX   0xF
-#define I40E_AQ_SET_MAC_CONFIG_PACING_1DW_9TX   0x9
-#define I40E_AQ_SET_MAC_CONFIG_PACING_1DW_4TX   0x8
-#define I40E_AQ_SET_MAC_CONFIG_PACING_3DW_7TX   0x7
-#define I40E_AQ_SET_MAC_CONFIG_PACING_2DW_3TX   0x6
-#define I40E_AQ_SET_MAC_CONFIG_PACING_1DW_1TX   0x5
-#define I40E_AQ_SET_MAC_CONFIG_PACING_3DW_2TX   0x4
-#define I40E_AQ_SET_MAC_CONFIG_PACING_7DW_3TX   0x3
-#define I40E_AQ_SET_MAC_CONFIG_PACING_4DW_1TX   0x2
-#define I40E_AQ_SET_MAC_CONFIG_PACING_9DW_1TX   0x1
-        u8     tx_timer_priority; /* bitmap */
-        __le16 tx_timer_value;
-        __le16 fc_refresh_threshold;
-        u8     reserved[8];
+        __le16  max_frame_size;
+        u8      params;
+#define I40E_AQ_SET_MAC_CONFIG_CRC_EN           0x04
+#define I40E_AQ_SET_MAC_CONFIG_PACING_MASK      0x78
+#define I40E_AQ_SET_MAC_CONFIG_PACING_SHIFT     3
+#define I40E_AQ_SET_MAC_CONFIG_PACING_NONE      0x0
+#define I40E_AQ_SET_MAC_CONFIG_PACING_1B_13TX   0xF
+#define I40E_AQ_SET_MAC_CONFIG_PACING_1DW_9TX   0x9
+#define I40E_AQ_SET_MAC_CONFIG_PACING_1DW_4TX   0x8
+#define I40E_AQ_SET_MAC_CONFIG_PACING_3DW_7TX   0x7
+#define I40E_AQ_SET_MAC_CONFIG_PACING_2DW_3TX   0x6
+#define I40E_AQ_SET_MAC_CONFIG_PACING_1DW_1TX   0x5
+#define I40E_AQ_SET_MAC_CONFIG_PACING_3DW_2TX   0x4
+#define I40E_AQ_SET_MAC_CONFIG_PACING_7DW_3TX   0x3
+#define I40E_AQ_SET_MAC_CONFIG_PACING_4DW_1TX   0x2
+#define I40E_AQ_SET_MAC_CONFIG_PACING_9DW_1TX   0x1
+        u8      tx_timer_priority; /* bitmap */
+        __le16  tx_timer_value;
+        __le16  fc_refresh_threshold;
+        u8      reserved[8];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aq_set_mac_config);
 
 /* Restart Auto-Negotiation (direct 0x605) */
 struct i40e_aqc_set_link_restart_an {
-        u8     command;
-#define I40E_AQ_PHY_RESTART_AN  0x02
-#define I40E_AQ_PHY_LINK_ENABLE 0x04
-        u8     reserved[15];
+        u8      command;
+#define I40E_AQ_PHY_RESTART_AN  0x02
+#define I40E_AQ_PHY_LINK_ENABLE 0x04
+        u8      reserved[15];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_set_link_restart_an);
 
 /* Get Link Status cmd & response data structure (direct 0x0607) */
 struct i40e_aqc_get_link_status {
-        __le16 command_flags; /* only field set on command */
-#define I40E_AQ_LSE_MASK             0x3
-#define I40E_AQ_LSE_NOP              0x0
-#define I40E_AQ_LSE_DISABLE          0x2
-#define I40E_AQ_LSE_ENABLE           0x3
+        __le16  command_flags; /* only field set on command */
+#define I40E_AQ_LSE_MASK                0x3
+#define I40E_AQ_LSE_NOP                 0x0
+#define I40E_AQ_LSE_DISABLE             0x2
+#define I40E_AQ_LSE_ENABLE              0x3
 /* only response uses this flag */
-#define I40E_AQ_LSE_IS_ENABLED       0x1
-        u8     phy_type;    /* i40e_aq_phy_type   */
-        u8     link_speed;  /* i40e_aq_link_speed */
-        u8     link_info;
-#define I40E_AQ_LINK_UP              0x01
-#define I40E_AQ_LINK_FAULT           0x02
-#define I40E_AQ_LINK_FAULT_TX        0x04
-#define I40E_AQ_LINK_FAULT_RX        0x08
-#define I40E_AQ_LINK_FAULT_REMOTE    0x10
-#define I40E_AQ_MEDIA_AVAILABLE      0x40
-#define I40E_AQ_SIGNAL_DETECT        0x80
-        u8     an_info;
-#define I40E_AQ_AN_COMPLETED         0x01
-#define I40E_AQ_LP_AN_ABILITY        0x02
-#define I40E_AQ_PD_FAULT             0x04
-#define I40E_AQ_FEC_EN               0x08
-#define I40E_AQ_PHY_LOW_POWER        0x10
-#define I40E_AQ_LINK_PAUSE_TX        0x20
-#define I40E_AQ_LINK_PAUSE_RX        0x40
-#define I40E_AQ_QUALIFIED_MODULE     0x80
-        u8     ext_info;
-#define I40E_AQ_LINK_PHY_TEMP_ALARM  0x01
-#define I40E_AQ_LINK_XCESSIVE_ERRORS 0x02
-#define I40E_AQ_LINK_TX_SHIFT        0x02
-#define I40E_AQ_LINK_TX_MASK         (0x03 << I40E_AQ_LINK_TX_SHIFT)
-#define I40E_AQ_LINK_TX_ACTIVE       0x00
-#define I40E_AQ_LINK_TX_DRAINED      0x01
-#define I40E_AQ_LINK_TX_FLUSHED      0x03
-#define I40E_AQ_LINK_FORCED_40G      0x10
-        u8     loopback;         /* use defines from i40e_aqc_set_lb_mode */
-        __le16 max_frame_size;
-        u8     config;
-#define I40E_AQ_CONFIG_CRC_ENA       0x04
-#define I40E_AQ_CONFIG_PACING_MASK   0x78
-        u8     reserved[5];
+#define I40E_AQ_LSE_IS_ENABLED          0x1
+        u8      phy_type;    /* i40e_aq_phy_type   */
+        u8      link_speed;  /* i40e_aq_link_speed */
+        u8      link_info;
+#define I40E_AQ_LINK_UP                 0x01
+#define I40E_AQ_LINK_FAULT              0x02
+#define I40E_AQ_LINK_FAULT_TX           0x04
+#define I40E_AQ_LINK_FAULT_RX           0x08
+#define I40E_AQ_LINK_FAULT_REMOTE       0x10
+#define I40E_AQ_MEDIA_AVAILABLE         0x40
+#define I40E_AQ_SIGNAL_DETECT           0x80
+        u8      an_info;
+#define I40E_AQ_AN_COMPLETED            0x01
+#define I40E_AQ_LP_AN_ABILITY           0x02
+#define I40E_AQ_PD_FAULT                0x04
+#define I40E_AQ_FEC_EN                  0x08
+#define I40E_AQ_PHY_LOW_POWER           0x10
+#define I40E_AQ_LINK_PAUSE_TX           0x20
+#define I40E_AQ_LINK_PAUSE_RX           0x40
+#define I40E_AQ_QUALIFIED_MODULE        0x80
+        u8      ext_info;
+#define I40E_AQ_LINK_PHY_TEMP_ALARM     0x01
+#define I40E_AQ_LINK_XCESSIVE_ERRORS    0x02
+#define I40E_AQ_LINK_TX_SHIFT           0x02
+#define I40E_AQ_LINK_TX_MASK            (0x03 << I40E_AQ_LINK_TX_SHIFT)
+#define I40E_AQ_LINK_TX_ACTIVE          0x00
+#define I40E_AQ_LINK_TX_DRAINED         0x01
+#define I40E_AQ_LINK_TX_FLUSHED         0x03
+#define I40E_AQ_LINK_FORCED_40G         0x10
+        u8      loopback; /* use defines from i40e_aqc_set_lb_mode */
+        __le16  max_frame_size;
+        u8      config;
+#define I40E_AQ_CONFIG_CRC_ENA          0x04
+#define I40E_AQ_CONFIG_PACING_MASK      0x78
+        u8      reserved[5];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_get_link_status);
 
 /* Set event mask command (direct 0x613) */
 struct i40e_aqc_set_phy_int_mask {
-        u8     reserved[8];
-        __le16 event_mask;
-#define I40E_AQ_EVENT_LINK_UPDOWN       0x0002
-#define I40E_AQ_EVENT_MEDIA_NA          0x0004
-#define I40E_AQ_EVENT_LINK_FAULT        0x0008
-#define I40E_AQ_EVENT_PHY_TEMP_ALARM    0x0010
-#define I40E_AQ_EVENT_EXCESSIVE_ERRORS  0x0020
-#define I40E_AQ_EVENT_SIGNAL_DETECT     0x0040
-#define I40E_AQ_EVENT_AN_COMPLETED      0x0080
-#define I40E_AQ_EVENT_MODULE_QUAL_FAIL  0x0100
-#define I40E_AQ_EVENT_PORT_TX_SUSPENDED 0x0200
-        u8     reserved1[6];
+        u8      reserved[8];
+        __le16  event_mask;
+#define I40E_AQ_EVENT_LINK_UPDOWN       0x0002
+#define I40E_AQ_EVENT_MEDIA_NA          0x0004
+#define I40E_AQ_EVENT_LINK_FAULT        0x0008
+#define I40E_AQ_EVENT_PHY_TEMP_ALARM    0x0010
+#define I40E_AQ_EVENT_EXCESSIVE_ERRORS  0x0020
+#define I40E_AQ_EVENT_SIGNAL_DETECT     0x0040
+#define I40E_AQ_EVENT_AN_COMPLETED      0x0080
+#define I40E_AQ_EVENT_MODULE_QUAL_FAIL  0x0100
+#define I40E_AQ_EVENT_PORT_TX_SUSPENDED 0x0200
+        u8      reserved1[6];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_set_phy_int_mask);
@@ -1732,27 +1728,27 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_set_phy_int_mask);
  * Get Link Partner AN advt register (direct 0x0616)
  */
 struct i40e_aqc_an_advt_reg {
-        __le32 local_an_reg0;
-        __le16 local_an_reg1;
-        u8     reserved[10];
+        __le32  local_an_reg0;
+        __le16  local_an_reg1;
+        u8      reserved[10];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_an_advt_reg);
 
 /* Set Loopback mode (0x0618) */
 struct i40e_aqc_set_lb_mode {
-        __le16 lb_mode;
-#define I40E_AQ_LB_PHY_LOCAL   0x01
-#define I40E_AQ_LB_PHY_REMOTE  0x02
-#define I40E_AQ_LB_MAC_LOCAL   0x04
-        u8     reserved[14];
+        __le16  lb_mode;
+#define I40E_AQ_LB_PHY_LOCAL    0x01
+#define I40E_AQ_LB_PHY_REMOTE   0x02
+#define I40E_AQ_LB_MAC_LOCAL    0x04
+        u8      reserved[14];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_set_lb_mode);
 
 /* Set PHY Debug command (0x0622) */
 struct i40e_aqc_set_phy_debug {
-        u8     command_flags;
+        u8      command_flags;
 #define I40E_AQ_PHY_DEBUG_RESET_INTERNAL        0x02
 #define I40E_AQ_PHY_DEBUG_RESET_EXTERNAL_SHIFT  2
 #define I40E_AQ_PHY_DEBUG_RESET_EXTERNAL_MASK   (0x03 << \
@@ -1761,15 +1757,15 @@ struct i40e_aqc_set_phy_debug {
 #define I40E_AQ_PHY_DEBUG_RESET_EXTERNAL_HARD   0x01
 #define I40E_AQ_PHY_DEBUG_RESET_EXTERNAL_SOFT   0x02
 #define I40E_AQ_PHY_DEBUG_DISABLE_LINK_FW       0x10
-        u8     reserved[15];
+        u8      reserved[15];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_set_phy_debug);
 
 enum i40e_aq_phy_reg_type {
-        I40E_AQC_PHY_REG_INTERNAL         = 0x1,
-        I40E_AQC_PHY_REG_EXERNAL_BASET    = 0x2,
-        I40E_AQC_PHY_REG_EXERNAL_MODULE   = 0x3
+        I40E_AQC_PHY_REG_INTERNAL       = 0x1,
+        I40E_AQC_PHY_REG_EXERNAL_BASET  = 0x2,
+        I40E_AQC_PHY_REG_EXERNAL_MODULE = 0x3
 };
 
 /* NVM Read command (indirect 0x0701)
@@ -1777,40 +1773,40 @@ enum i40e_aq_phy_reg_type {
  * NVM Update commands (indirect 0x0703)
  */
 struct i40e_aqc_nvm_update {
-        u8     command_flags;
-#define I40E_AQ_NVM_LAST_CMD    0x01
-#define I40E_AQ_NVM_FLASH_ONLY  0x80
-        u8     module_pointer;
-        __le16 length;
-        __le32 offset;
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      command_flags;
+#define I40E_AQ_NVM_LAST_CMD    0x01
+#define I40E_AQ_NVM_FLASH_ONLY  0x80
+        u8      module_pointer;
+        __le16  length;
+        __le32  offset;
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_nvm_update);
 
 /* NVM Config Read (indirect 0x0704) */
 struct i40e_aqc_nvm_config_read {
-        __le16 cmd_flags;
+        __le16  cmd_flags;
 #define ANVM_SINGLE_OR_MULTIPLE_FEATURES_MASK   1
 #define ANVM_READ_SINGLE_FEATURE                0
 #define ANVM_READ_MULTIPLE_FEATURES             1
-        __le16 element_count;
-        __le16 element_id;              /* Feature/field ID */
-        u8     reserved[2];
-        __le32 address_high;
-        __le32 address_low;
+        __le16  element_count;
+        __le16  element_id; /* Feature/field ID */
+        u8      reserved[2];
+        __le32  address_high;
+        __le32  address_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_nvm_config_read);
 
 /* NVM Config Write (indirect 0x0705) */
 struct i40e_aqc_nvm_config_write {
-        __le16 cmd_flags;
-        __le16 element_count;
-        u8     reserved[4];
-        __le32 address_high;
-        __le32 address_low;
+        __le16  cmd_flags;
+        __le16  element_count;
+        u8      reserved[4];
+        __le32  address_high;
+        __le32  address_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_nvm_config_write);
@@ -1835,10 +1831,10 @@ struct i40e_aqc_nvm_config_data_immediate_field {
  * Send to Peer PF command (indirect 0x0803)
  */
 struct i40e_aqc_pf_vf_message {
-        __le32 id;
-        u8     reserved[4];
-        __le32 addr_high;
-        __le32 addr_low;
+        __le32  id;
+        u8      reserved[4];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_pf_vf_message);
@@ -1874,22 +1870,22 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_alternate_ind_write);
  * uses i40e_aq_desc
  */
 struct i40e_aqc_alternate_write_done {
-        __le16 cmd_flags;
+        __le16  cmd_flags;
 #define I40E_AQ_ALTERNATE_MODE_BIOS_MASK        1
 #define I40E_AQ_ALTERNATE_MODE_BIOS_LEGACY      0
 #define I40E_AQ_ALTERNATE_MODE_BIOS_UEFI        1
 #define I40E_AQ_ALTERNATE_RESET_NEEDED          2
-        u8     reserved[14];
+        u8      reserved[14];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_alternate_write_done);
 
 /* Set OEM mode (direct 0x0905) */
 struct i40e_aqc_alternate_set_mode {
-        __le32 mode;
+        __le32  mode;
 #define I40E_AQ_ALTERNATE_MODE_NONE     0
 #define I40E_AQ_ALTERNATE_MODE_OEM      1
-        u8     reserved[12];
+        u8      reserved[12];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_alternate_set_mode);
@@ -1900,33 +1896,33 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_alternate_set_mode);
 
 /* Lan Queue Overflow Event (direct, 0x1001) */
 struct i40e_aqc_lan_overflow {
-        __le32 prtdcb_rupto;
-        __le32 otx_ctl;
-        u8     reserved[8];
+        __le32  prtdcb_rupto;
+        __le32  otx_ctl;
+        u8      reserved[8];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_lan_overflow);
 
 /* Get LLDP MIB (indirect 0x0A00) */
 struct i40e_aqc_lldp_get_mib {
-        u8     type;
-        u8     reserved1;
-#define I40E_AQ_LLDP_MIB_TYPE_MASK                      0x3
-#define I40E_AQ_LLDP_MIB_LOCAL                          0x0
-#define I40E_AQ_LLDP_MIB_REMOTE                         0x1
-#define I40E_AQ_LLDP_MIB_LOCAL_AND_REMOTE               0x2
-#define I40E_AQ_LLDP_BRIDGE_TYPE_MASK                   0xC
-#define I40E_AQ_LLDP_BRIDGE_TYPE_SHIFT                  0x2
-#define I40E_AQ_LLDP_BRIDGE_TYPE_NEAREST_BRIDGE         0x0
-#define I40E_AQ_LLDP_BRIDGE_TYPE_NON_TPMR               0x1
-#define I40E_AQ_LLDP_TX_SHIFT              0x4
-#define I40E_AQ_LLDP_TX_MASK               (0x03 << I40E_AQ_LLDP_TX_SHIFT)
+        u8      type;
+        u8      reserved1;
+#define I40E_AQ_LLDP_MIB_TYPE_MASK              0x3
+#define I40E_AQ_LLDP_MIB_LOCAL                  0x0
+#define I40E_AQ_LLDP_MIB_REMOTE                 0x1
+#define I40E_AQ_LLDP_MIB_LOCAL_AND_REMOTE       0x2
+#define I40E_AQ_LLDP_BRIDGE_TYPE_MASK           0xC
+#define I40E_AQ_LLDP_BRIDGE_TYPE_SHIFT          0x2
+#define I40E_AQ_LLDP_BRIDGE_TYPE_NEAREST_BRIDGE 0x0
+#define I40E_AQ_LLDP_BRIDGE_TYPE_NON_TPMR       0x1
+#define I40E_AQ_LLDP_TX_SHIFT                   0x4
+#define I40E_AQ_LLDP_TX_MASK                    (0x03 << I40E_AQ_LLDP_TX_SHIFT)
 /* TX pause flags use I40E_AQ_LINK_TX_* above */
-        __le16 local_len;
-        __le16 remote_len;
-        u8     reserved2[2];
-        __le32 addr_high;
-        __le32 addr_low;
+        __le16  local_len;
+        __le16  remote_len;
+        u8      reserved2[2];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_get_mib);
@@ -1935,12 +1931,12 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_get_mib);
  * also used for the event (with type in the command field)
  */
 struct i40e_aqc_lldp_update_mib {
-        u8     command;
-#define I40E_AQ_LLDP_MIB_UPDATE_ENABLE          0x0
-#define I40E_AQ_LLDP_MIB_UPDATE_DISABLE         0x1
-        u8     reserved[7];
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      command;
+#define I40E_AQ_LLDP_MIB_UPDATE_ENABLE  0x0
+#define I40E_AQ_LLDP_MIB_UPDATE_DISABLE 0x1
+        u8      reserved[7];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_update_mib);
@@ -1949,35 +1945,35 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_update_mib);
  * Delete LLDP TLV (indirect 0x0A04)
  */
 struct i40e_aqc_lldp_add_tlv {
-        u8     type; /* only nearest bridge and non-TPMR from 0x0A00 */
-        u8     reserved1[1];
-        __le16 len;
-        u8     reserved2[4];
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      type; /* only nearest bridge and non-TPMR from 0x0A00 */
+        u8      reserved1[1];
+        __le16  len;
+        u8      reserved2[4];
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_add_tlv);
 
 /* Update LLDP TLV (indirect 0x0A03) */
 struct i40e_aqc_lldp_update_tlv {
-        u8     type; /* only nearest bridge and non-TPMR from 0x0A00 */
-        u8     reserved;
-        __le16 old_len;
-        __le16 new_offset;
-        __le16 new_len;
-        __le32 addr_high;
-        __le32 addr_low;
+        u8      type; /* only nearest bridge and non-TPMR from 0x0A00 */
+        u8      reserved;
+        __le16  old_len;
+        __le16  new_offset;
+        __le16  new_len;
+        __le32  addr_high;
+        __le32  addr_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_update_tlv);
 
 /* Stop LLDP (direct 0x0A05) */
 struct i40e_aqc_lldp_stop {
-        u8     command;
-#define I40E_AQ_LLDP_AGENT_STOP                 0x0
-#define I40E_AQ_LLDP_AGENT_SHUTDOWN             0x1
-        u8     reserved[15];
+        u8      command;
+#define I40E_AQ_LLDP_AGENT_STOP         0x0
+#define I40E_AQ_LLDP_AGENT_SHUTDOWN     0x1
+        u8      reserved[15];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_stop);
@@ -1985,9 +1981,9 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_stop);
 /* Start LLDP (direct 0x0A06) */
 
 struct i40e_aqc_lldp_start {
-        u8     command;
-#define I40E_AQ_LLDP_AGENT_START                0x1
-        u8     reserved[15];
+        u8      command;
+#define I40E_AQ_LLDP_AGENT_START        0x1
+        u8      reserved[15];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_start);
@@ -1998,13 +1994,13 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_start);
 
 /* Add Udp Tunnel command and completion (direct 0x0B00) */
 struct i40e_aqc_add_udp_tunnel {
-        __le16 udp_port;
-        u8     reserved0[3];
-        u8     protocol_type;
+        __le16  udp_port;
+        u8      reserved0[3];
+        u8      protocol_type;
 #define I40E_AQC_TUNNEL_TYPE_VXLAN      0x00
 #define I40E_AQC_TUNNEL_TYPE_NGE        0x01
 #define I40E_AQC_TUNNEL_TYPE_TEREDO     0x10
-        u8     reserved1[10];
+        u8      reserved1[10];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_add_udp_tunnel);
@@ -2013,8 +2009,8 @@ struct i40e_aqc_add_udp_tunnel_completion {
         __le16 udp_port;
         u8      filter_entry_index;
         u8      multiple_pfs;
-#define I40E_AQC_SINGLE_PF                              0x0
-#define I40E_AQC_MULTIPLE_PFS                   0x1
+#define I40E_AQC_SINGLE_PF              0x0
+#define I40E_AQC_MULTIPLE_PFS           0x1
         u8      total_filters;
         u8      reserved[11];
 };
@@ -2023,23 +2019,19 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_add_udp_tunnel_completion);
 
 /* remove UDP Tunnel command (0x0B01) */
 struct i40e_aqc_remove_udp_tunnel {
-        u8     reserved[2];
-        u8     index; /* 0 to 15 */
-        u8     pf_filters;
-        u8     total_filters;
-        u8     reserved2[11];
+        u8      reserved[2];
+        u8      index; /* 0 to 15 */
+        u8      reserved2[13];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_remove_udp_tunnel);
 
 struct i40e_aqc_del_udp_tunnel_completion {
-        __le16 udp_port;
-        u8     index; /* 0 to 15 */
-        u8     multiple_pfs;
-        u8     total_filters_used;
-        u8     reserved;
-        u8     tunnels_free;
-        u8     reserved1[9];
+        __le16  udp_port;
+        u8      index; /* 0 to 15 */
+        u8      multiple_pfs;
+        u8      total_filters_used;
+        u8      reserved1[11];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_del_udp_tunnel_completion);
@@ -2068,11 +2060,11 @@ struct i40e_aqc_tunnel_key_structure {
         u8      key1_len;  /* 0 to 15 */
         u8      key2_len;  /* 0 to 15 */
         u8      flags;
-#define I40E_AQC_TUNNEL_KEY_STRUCT_OVERRIDE 0x01
+#define I40E_AQC_TUNNEL_KEY_STRUCT_OVERRIDE     0x01
 /* response flags */
-#define I40E_AQC_TUNNEL_KEY_STRUCT_SUCCESS    0x01
-#define I40E_AQC_TUNNEL_KEY_STRUCT_MODIFIED   0x02
-#define I40E_AQC_TUNNEL_KEY_STRUCT_OVERRIDDEN 0x03
+#define I40E_AQC_TUNNEL_KEY_STRUCT_SUCCESS      0x01
+#define I40E_AQC_TUNNEL_KEY_STRUCT_MODIFIED     0x02
+#define I40E_AQC_TUNNEL_KEY_STRUCT_OVERRIDDEN   0x03
         u8      network_key_index;
 #define I40E_AQC_NETWORK_KEY_INDEX_VXLAN                0x0
 #define I40E_AQC_NETWORK_KEY_INDEX_NGE                  0x1
@@ -2085,21 +2077,21 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_tunnel_key_structure);
 
 /* OEM mode commands (direct 0xFE0x) */
 struct i40e_aqc_oem_param_change {
-        __le32 param_type;
-#define I40E_AQ_OEM_PARAM_TYPE_PF_CTL   0
-#define I40E_AQ_OEM_PARAM_TYPE_BW_CTL   1
-#define I40E_AQ_OEM_PARAM_MAC           2
-        __le32 param_value1;
-        u8     param_value2[8];
+        __le32  param_type;
+#define I40E_AQ_OEM_PARAM_TYPE_PF_CTL   0
+#define I40E_AQ_OEM_PARAM_TYPE_BW_CTL   1
+#define I40E_AQ_OEM_PARAM_MAC           2
+        __le32  param_value1;
+        u8      param_value2[8];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_oem_param_change);
 
 struct i40e_aqc_oem_state_change {
-        __le32 state;
-#define I40E_AQ_OEM_STATE_LINK_DOWN  0x0
-#define I40E_AQ_OEM_STATE_LINK_UP    0x1
-        u8     reserved[12];
+        __le32  state;
+#define I40E_AQ_OEM_STATE_LINK_DOWN     0x0
+#define I40E_AQ_OEM_STATE_LINK_UP       0x1
+        u8      reserved[12];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_oem_state_change);
@@ -2111,18 +2103,18 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_oem_state_change);
 /* set test more (0xFF01, internal) */
 
 struct i40e_acq_set_test_mode {
-        u8     mode;
-#define I40E_AQ_TEST_PARTIAL    0
-#define I40E_AQ_TEST_FULL       1
-#define I40E_AQ_TEST_NVM        2
-        u8     reserved[3];
-        u8     command;
-#define I40E_AQ_TEST_OPEN        0
-#define I40E_AQ_TEST_CLOSE       1
-#define I40E_AQ_TEST_INC         2
-        u8     reserved2[3];
-        __le32 address_high;
-        __le32 address_low;
+        u8      mode;
+#define I40E_AQ_TEST_PARTIAL    0
+#define I40E_AQ_TEST_FULL       1
+#define I40E_AQ_TEST_NVM        2
+        u8      reserved[3];
+        u8      command;
+#define I40E_AQ_TEST_OPEN       0
+#define I40E_AQ_TEST_CLOSE      1
+#define I40E_AQ_TEST_INC        2
+        u8      reserved2[3];
+        __le32  address_high;
+        __le32  address_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_acq_set_test_mode);
@@ -2175,21 +2167,21 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_debug_modify_reg);
 #define I40E_AQ_CLUSTER_ID_ALTRAM       11
 
 struct i40e_aqc_debug_dump_internals {
-        u8     cluster_id;
-        u8     table_id;
-        __le16 data_size;
-        __le32 idx;
-        __le32 address_high;
-        __le32 address_low;
+        u8      cluster_id;
+        u8      table_id;
+        __le16  data_size;
+        __le32  idx;
+        __le32  address_high;
+        __le32  address_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_debug_dump_internals);
 
 struct i40e_aqc_debug_modify_internals {
-        u8     cluster_id;
-        u8     cluster_specific_params[7];
-        __le32 address_high;
-        __le32 address_low;
+        u8      cluster_id;
+        u8      cluster_specific_params[7];
+        __le32  address_high;
+        __le32  address_low;
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_debug_modify_internals);
diff --git a/drivers/net/ethernet/intel/i40evf/i40evf_main.c b/drivers/net/ethernet/intel/i40evf/i40evf_main.c
index c51bc7a33bc5..dabe6a4220c6 100644
--- a/drivers/net/ethernet/intel/i40evf/i40evf_main.c
+++ b/drivers/net/ethernet/intel/i40evf/i40evf_main.c
@@ -1494,7 +1494,7 @@ static void i40evf_reset_task(struct work_struct *work)
 
         while (test_and_set_bit(__I40EVF_IN_CRITICAL_TASK,
                                 &adapter->crit_section))
-                udelay(500);
+                usleep_range(500, 1000);
 
         if (adapter->flags & I40EVF_FLAG_RESET_NEEDED) {
                 dev_info(&adapter->pdev->dev, "Requesting reset from PF\n");
@@ -1980,7 +1980,7 @@ static int i40evf_check_reset_complete(struct i40e_hw *hw)
                 if ((rstat == I40E_VFR_VFACTIVE) ||
                     (rstat == I40E_VFR_COMPLETED))
                         return 0;
-                udelay(10);
+                usleep_range(10, 20);
         }
         return -EBUSY;
 }
diff --git a/drivers/net/ethernet/marvell/mvneta.c b/drivers/net/ethernet/marvell/mvneta.c
index ade067de1689..ccc3ce2e8c8c 100644
--- a/drivers/net/ethernet/marvell/mvneta.c
+++ b/drivers/net/ethernet/marvell/mvneta.c
@@ -2558,11 +2558,10 @@ static void mvneta_adjust_link(struct net_device *ndev)
                                 MVNETA_GMAC_FORCE_LINK_DOWN);
                         mvreg_write(pp, MVNETA_GMAC_AUTONEG_CONFIG, val);
                         mvneta_port_up(pp);
-                        netdev_info(pp->dev, "link up\n");
                 } else {
                         mvneta_port_down(pp);
-                        netdev_info(pp->dev, "link down\n");
                 }
+                phy_print_status(phydev);
         }
 }
 
diff --git a/drivers/net/ethernet/marvell/pxa168_eth.c b/drivers/net/ethernet/marvell/pxa168_eth.c
index c3b209cd0660..21ddecef151e 100644
--- a/drivers/net/ethernet/marvell/pxa168_eth.c
+++ b/drivers/net/ethernet/marvell/pxa168_eth.c
@@ -106,6 +106,7 @@
 #define SDMA_CMD_ERD            (1 << 7)
 
 /* Bit definitions of the Port Config Reg */
+#define PCR_DUPLEX_FULL         (1 << 15)
 #define PCR_HS                  (1 << 12)
 #define PCR_EN                  (1 << 7)
 #define PCR_PM                  (1 << 0)
@@ -113,11 +114,17 @@
 /* Bit definitions of the Port Config Extend Reg */
 #define PCXR_2BSM               (1 << 28)
 #define PCXR_DSCP_EN            (1 << 21)
+#define PCXR_RMII_EN            (1 << 20)
+#define PCXR_AN_SPEED_DIS       (1 << 19)
+#define PCXR_SPEED_100          (1 << 18)
 #define PCXR_MFL_1518           (0 << 14)
 #define PCXR_MFL_1536           (1 << 14)
 #define PCXR_MFL_2048           (2 << 14)
 #define PCXR_MFL_64K            (3 << 14)
+#define PCXR_FLOWCTL_DIS        (1 << 12)
 #define PCXR_FLP                (1 << 11)
+#define PCXR_AN_FLOWCTL_DIS     (1 << 10)
+#define PCXR_AN_DUPLEX_DIS      (1 << 9)
 #define PCXR_PRIO_TX_OFF        3
 #define PCXR_TX_HIGH_PRI        (7 << PCXR_PRIO_TX_OFF)
 
@@ -170,7 +177,6 @@
 #define LINK_UP                 (1 << 3)
 
 /* Bit definitions for work to be done */
-#define WORK_LINK               (1 << 0)
 #define WORK_TX_DONE            (1 << 1)
 
 /*
@@ -197,6 +203,9 @@ struct tx_desc {
 struct pxa168_eth_private {
         int port_num;           /* User Ethernet port number    */
         int phy_addr;
+        int phy_speed;
+        int phy_duplex;
+        phy_interface_t phy_intf;
 
         int rx_resource_err;    /* Rx ring resource error flag */
 
@@ -269,11 +278,11 @@ enum hash_table_entry {
 static int pxa168_get_settings(struct net_device *dev, struct ethtool_cmd *cmd);
 static int pxa168_set_settings(struct net_device *dev, struct ethtool_cmd *cmd);
 static int pxa168_init_hw(struct pxa168_eth_private *pep);
+static int pxa168_init_phy(struct net_device *dev);
 static void eth_port_reset(struct net_device *dev);
 static void eth_port_start(struct net_device *dev);
 static int pxa168_eth_open(struct net_device *dev);
 static int pxa168_eth_stop(struct net_device *dev);
-static int ethernet_phy_setup(struct net_device *dev);
 
 static inline u32 rdl(struct pxa168_eth_private *pep, int offset)
 {
@@ -305,26 +314,6 @@ static void abort_dma(struct pxa168_eth_private *pep)
                 netdev_err(pep->dev, "%s : DMA Stuck\n", __func__);
 }
 
-static int ethernet_phy_get(struct pxa168_eth_private *pep)
-{
-        unsigned int reg_data;
-
-        reg_data = rdl(pep, PHY_ADDRESS);
-
-        return (reg_data >> (5 * pep->port_num)) & 0x1f;
-}
-
-static void ethernet_phy_set_addr(struct pxa168_eth_private *pep, int phy_addr)
-{
-        u32 reg_data;
-        int addr_shift = 5 * pep->port_num;
-
-        reg_data = rdl(pep, PHY_ADDRESS);
-        reg_data &= ~(0x1f << addr_shift);
-        reg_data |= (phy_addr & 0x1f) << addr_shift;
-        wrl(pep, PHY_ADDRESS, reg_data);
-}
-
 static void rxq_refill(struct net_device *dev)
 {
         struct pxa168_eth_private *pep = netdev_priv(dev);
@@ -655,14 +644,7 @@ static void eth_port_start(struct net_device *dev)
         struct pxa168_eth_private *pep = netdev_priv(dev);
         int tx_curr_desc, rx_curr_desc;
 
-        /* Perform PHY reset, if there is a PHY. */
-        if (pep->phy != NULL) {
-                struct ethtool_cmd cmd;
-
-                pxa168_get_settings(pep->dev, &cmd);
-                phy_init_hw(pep->phy);
-                pxa168_set_settings(pep->dev, &cmd);
-        }
+        phy_start(pep->phy);
 
         /* Assignment of Tx CTRP of given queue */
         tx_curr_desc = pep->tx_curr_desc_q;
@@ -717,6 +699,8 @@ static void eth_port_reset(struct net_device *dev)
         val = rdl(pep, PORT_CONFIG);
         val &= ~PCR_EN;
         wrl(pep, PORT_CONFIG, val);
+
+        phy_stop(pep->phy);
 }
 
 /*
@@ -884,43 +868,9 @@ static int pxa168_eth_collect_events(struct pxa168_eth_private *pep,
         }
         if (icr & ICR_RXBUF)
                 ret = 1;
-        if (icr & ICR_MII_CH) {
-                pep->work_todo |= WORK_LINK;
-                ret = 1;
-        }
         return ret;
 }
 
-static void handle_link_event(struct pxa168_eth_private *pep)
-{
-        struct net_device *dev = pep->dev;
-        u32 port_status;
-        int speed;
-        int duplex;
-        int fc;
-
-        port_status = rdl(pep, PORT_STATUS);
-        if (!(port_status & LINK_UP)) {
-                if (netif_carrier_ok(dev)) {
-                        netdev_info(dev, "link down\n");
-                        netif_carrier_off(dev);
-                        txq_reclaim(dev, 1);
-                }
-                return;
-        }
-        if (port_status & PORT_SPEED_100)
-                speed = 100;
-        else
-                speed = 10;
-
-        duplex = (port_status & FULL_DUPLEX) ? 1 : 0;
-        fc = (port_status & FLOW_CONTROL_DISABLED) ? 0 : 1;
-        netdev_info(dev, "link up, %d Mb/s, %s duplex, flow control %sabled\n",
-                    speed, duplex ? "full" : "half", fc ? "en" : "dis");
-        if (!netif_carrier_ok(dev))
-                netif_carrier_on(dev);
-}
-
 static irqreturn_t pxa168_eth_int_handler(int irq, void *dev_id)
 {
         struct net_device *dev = (struct net_device *)dev_id;
@@ -978,8 +928,11 @@ static int set_port_config_ext(struct pxa168_eth_private *pep)
                 skb_size = PCXR_MFL_64K;
 
         /* Extended Port Configuration */
-        wrl(pep,
-            PORT_CONFIG_EXT, PCXR_2BSM | /* Two byte prefix aligns IP hdr */
+        wrl(pep, PORT_CONFIG_EXT,
+            PCXR_AN_SPEED_DIS |          /* Disable HW AN */
+            PCXR_AN_DUPLEX_DIS |
+            PCXR_AN_FLOWCTL_DIS |
+            PCXR_2BSM |                  /* Two byte prefix aligns IP hdr */
             PCXR_DSCP_EN |               /* Enable DSCP in IP */
             skb_size | PCXR_FLP |        /* do not force link pass */
             PCXR_TX_HIGH_PRI);           /* Transmit - high priority queue */
@@ -987,6 +940,69 @@ static int set_port_config_ext(struct pxa168_eth_private *pep)
         return 0;
 }
 
+static void pxa168_eth_adjust_link(struct net_device *dev)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+        struct phy_device *phy = pep->phy;
+        u32 cfg, cfg_o = rdl(pep, PORT_CONFIG);
+        u32 cfgext, cfgext_o = rdl(pep, PORT_CONFIG_EXT);
+
+        cfg = cfg_o & ~PCR_DUPLEX_FULL;
+        cfgext = cfgext_o & ~(PCXR_SPEED_100 | PCXR_FLOWCTL_DIS | PCXR_RMII_EN);
+
+        if (phy->interface == PHY_INTERFACE_MODE_RMII)
+                cfgext |= PCXR_RMII_EN;
+        if (phy->speed == SPEED_100)
+                cfgext |= PCXR_SPEED_100;
+        if (phy->duplex)
+                cfg |= PCR_DUPLEX_FULL;
+        if (!phy->pause)
+                cfgext |= PCXR_FLOWCTL_DIS;
+
+        /* Bail out if there has nothing changed */
+        if (cfg == cfg_o && cfgext == cfgext_o)
+                return;
+
+        wrl(pep, PORT_CONFIG, cfg);
+        wrl(pep, PORT_CONFIG_EXT, cfgext);
+
+        phy_print_status(phy);
+}
+
+static int pxa168_init_phy(struct net_device *dev)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+        struct ethtool_cmd cmd;
+        int err;
+
+        if (pep->phy)
+                return 0;
+
+        pep->phy = mdiobus_scan(pep->smi_bus, pep->phy_addr);
+        if (!pep->phy)
+                return -ENODEV;
+
+        err = phy_connect_direct(dev, pep->phy, pxa168_eth_adjust_link,
+                                 pep->phy_intf);
+        if (err)
+                return err;
+
+        err = pxa168_get_settings(dev, &cmd);
+        if (err)
+                return err;
+
+        cmd.phy_address = pep->phy_addr;
+        cmd.speed = pep->phy_speed;
+        cmd.duplex = pep->phy_duplex;
+        cmd.advertising = PHY_BASIC_FEATURES;
+        cmd.autoneg = AUTONEG_ENABLE;
+
+        if (cmd.speed != 0)
+                cmd.autoneg = AUTONEG_DISABLE;
+
+        return pxa168_set_settings(dev, &cmd);
+}
+
 static int pxa168_init_hw(struct pxa168_eth_private *pep)
 {
         int err = 0;
@@ -1133,6 +1149,10 @@ static int pxa168_eth_open(struct net_device *dev)
         struct pxa168_eth_private *pep = netdev_priv(dev);
         int err;
 
+        err = pxa168_init_phy(dev);
+        if (err)
+                return err;
+
         err = request_irq(dev->irq, pxa168_eth_int_handler, 0, dev->name, dev);
         if (err) {
                 dev_err(&dev->dev, "can't assign irq\n");
@@ -1231,10 +1251,6 @@ static int pxa168_rx_poll(struct napi_struct *napi, int budget)
         struct net_device *dev = pep->dev;
         int work_done = 0;
 
-        if (unlikely(pep->work_todo & WORK_LINK)) {
-                pep->work_todo &= ~(WORK_LINK);
-                handle_link_event(pep);
-        }
         /*
          * We call txq_reclaim every time since in NAPI interupts are disabled
          * and due to this we miss the TX_DONE interrupt,which is not updated in
@@ -1357,77 +1373,6 @@ static int pxa168_eth_do_ioctl(struct net_device *dev, struct ifreq *ifr,
         return -EOPNOTSUPP;
 }
 
-static struct phy_device *phy_scan(struct pxa168_eth_private *pep, int phy_addr)
-{
-        struct mii_bus *bus = pep->smi_bus;
-        struct phy_device *phydev;
-        int start;
-        int num;
-        int i;
-
-        if (phy_addr == PXA168_ETH_PHY_ADDR_DEFAULT) {
-                /* Scan entire range */
-                start = ethernet_phy_get(pep);
-                num = 32;
-        } else {
-                /* Use phy addr specific to platform */
-                start = phy_addr & 0x1f;
-                num = 1;
-        }
-        phydev = NULL;
-        for (i = 0; i < num; i++) {
-                int addr = (start + i) & 0x1f;
-                if (bus->phy_map[addr] == NULL)
-                        mdiobus_scan(bus, addr);
-
-                if (phydev == NULL) {
-                        phydev = bus->phy_map[addr];
-                        if (phydev != NULL)
-                                ethernet_phy_set_addr(pep, addr);
-                }
-        }
-
-        return phydev;
-}
-
-static void phy_init(struct pxa168_eth_private *pep)
-{
-        struct phy_device *phy = pep->phy;
-
-        phy_attach(pep->dev, dev_name(&phy->dev), PHY_INTERFACE_MODE_MII);
-
-        if (pep->pd && pep->pd->speed != 0) {
-                phy->autoneg = AUTONEG_DISABLE;
-                phy->advertising = 0;
-                phy->speed = pep->pd->speed;
-                phy->duplex = pep->pd->duplex;
-        } else {
-                phy->autoneg = AUTONEG_ENABLE;
-                phy->speed = 0;
-                phy->duplex = 0;
-                phy->supported &= PHY_BASIC_FEATURES;
-                phy->advertising = phy->supported | ADVERTISED_Autoneg;
-        }
-
-        phy_start_aneg(phy);
-}
-
-static int ethernet_phy_setup(struct net_device *dev)
-{
-        struct pxa168_eth_private *pep = netdev_priv(dev);
-
-        if (pep->pd && pep->pd->init)
-                pep->pd->init();
-
-        pep->phy = phy_scan(pep, pep->phy_addr & 0x1f);
-        if (pep->phy != NULL)
-                phy_init(pep);
-
-        update_hash_table_mac_address(pep, NULL, dev->dev_addr);
-
-        return 0;
-}
-
 static int pxa168_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
         struct pxa168_eth_private *pep = netdev_priv(dev);
@@ -1505,16 +1450,14 @@ static int pxa168_eth_probe(struct platform_device *pdev)
         pep = netdev_priv(dev);
         pep->dev = dev;
         pep->clk = clk;
+
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res == NULL) {
-                err = -ENODEV;
-                goto err_netdev;
-        }
         pep->base = devm_ioremap_resource(&pdev->dev, res);
         if (IS_ERR(pep->base)) {
                 err = -ENOMEM;
                 goto err_netdev;
         }
+
         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
         BUG_ON(!res);
         dev->irq = res->start;
@@ -1552,13 +1495,23 @@ static int pxa168_eth_probe(struct platform_device *pdev)
 
                 pep->port_num = pep->pd->port_number;
                 pep->phy_addr = pep->pd->phy_addr;
+                pep->phy_speed = pep->pd->speed;
+                pep->phy_duplex = pep->pd->duplex;
+                pep->phy_intf = pep->pd->intf;
+
+                if (pep->pd->init)
+                        pep->pd->init();
         } else if (pdev->dev.of_node) {
                 of_property_read_u32(pdev->dev.of_node, "port-id",
                                      &pep->port_num);
 
                 np = of_parse_phandle(pdev->dev.of_node, "phy-handle", 0);
-                if (np)
-                        of_property_read_u32(np, "reg", &pep->phy_addr);
+                if (!np) {
+                        dev_err(&pdev->dev, "missing phy-handle\n");
+                        return -EINVAL;
+                }
+                of_property_read_u32(np, "reg", &pep->phy_addr);
+                pep->phy_intf = of_get_phy_mode(pdev->dev.of_node);
         }
 
         /* Hardware supports only 3 ports */
@@ -1588,9 +1541,6 @@ static int pxa168_eth_probe(struct platform_device *pdev)
                 goto err_free_mdio;
 
         pxa168_init_hw(pep);
-        err = ethernet_phy_setup(dev);
-        if (err)
-                goto err_mdiobus;
         SET_NETDEV_DEV(dev, &pdev->dev);
         err = register_netdev(dev);
         if (err)
@@ -1621,13 +1571,13 @@ static int pxa168_eth_remove(struct platform_device *pdev)
                                   pep->htpr, pep->htpr_dma);
                 pep->htpr = NULL;
         }
+        if (pep->phy)
+                phy_disconnect(pep->phy);
         if (pep->clk) {
                 clk_disable(pep->clk);
                 clk_put(pep->clk);
                 pep->clk = NULL;
         }
-        if (pep->phy != NULL)
-                phy_detach(pep->phy);
 
         iounmap(pep->base);
         pep->base = NULL;
diff --git a/drivers/net/ethernet/mellanox/mlx4/cmd.c b/drivers/net/ethernet/mellanox/mlx4/cmd.c
index b16e1b95566f..916459effcfa 100644
--- a/drivers/net/ethernet/mellanox/mlx4/cmd.c
+++ b/drivers/net/ethernet/mellanox/mlx4/cmd.c
@@ -1338,6 +1338,15 @@ static struct mlx4_cmd_info cmd_info[] = {
                 .verify = NULL,
                 .wrapper = mlx4_QUERY_IF_STAT_wrapper
         },
+        {
+                .opcode = MLX4_CMD_ACCESS_REG,
+                .has_inbox = true,
+                .has_outbox = true,
+                .out_is_imm = false,
+                .encode_slave_id = false,
+                .verify = NULL,
+                .wrapper = NULL,
+        },
         /* Native multicast commands are not available for guests */
         {
                 .opcode = MLX4_CMD_QP_ATTACH,
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_clock.c b/drivers/net/ethernet/mellanox/mlx4/en_clock.c
index 57dda95b67d8..999014413b1a 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_clock.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_clock.c
@@ -35,52 +35,6 @@
 
 #include "mlx4_en.h"
 
-int mlx4_en_timestamp_config(struct net_device *dev, int tx_type, int rx_filter)
-{
-        struct mlx4_en_priv *priv = netdev_priv(dev);
-        struct mlx4_en_dev *mdev = priv->mdev;
-        int port_up = 0;
-        int err = 0;
-
-        if (priv->hwtstamp_config.tx_type == tx_type &&
-            priv->hwtstamp_config.rx_filter == rx_filter)
-                return 0;
-
-        mutex_lock(&mdev->state_lock);
-        if (priv->port_up) {
-                port_up = 1;
-                mlx4_en_stop_port(dev, 1);
-        }
-
-        mlx4_en_free_resources(priv);
-
-        en_warn(priv, "Changing Time Stamp configuration\n");
-
-        priv->hwtstamp_config.tx_type = tx_type;
-        priv->hwtstamp_config.rx_filter = rx_filter;
-
-        if (rx_filter != HWTSTAMP_FILTER_NONE)
-                dev->features &= ~NETIF_F_HW_VLAN_CTAG_RX;
-        else
-                dev->features |= NETIF_F_HW_VLAN_CTAG_RX;
-
-        err = mlx4_en_alloc_resources(priv);
-        if (err) {
-                en_err(priv, "Failed reallocating port resources\n");
-                goto out;
-        }
-        if (port_up) {
-                err = mlx4_en_start_port(dev);
-                if (err)
-                        en_err(priv, "Failed starting port\n");
-        }
-
-out:
-        mutex_unlock(&mdev->state_lock);
-        netdev_features_change(dev);
-        return err;
-}
-
 /* mlx4_en_read_clock - read raw cycle counter (to be used by time counter)
  */
 static cycle_t mlx4_en_read_clock(const struct cyclecounter *tc)
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c b/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c
index ae83da9cd18a..8ea4d5be7376 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c
@@ -35,6 +35,7 @@
 #include <linux/ethtool.h>
 #include <linux/netdevice.h>
 #include <linux/mlx4/driver.h>
+#include <linux/mlx4/device.h>
 #include <linux/in.h>
 #include <net/ip.h>
 
@@ -374,7 +375,302 @@ static void mlx4_en_get_strings(struct net_device *dev,
         }
 }
 
-static int mlx4_en_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+static u32 mlx4_en_autoneg_get(struct net_device *dev)
+{
+        struct mlx4_en_priv *priv = netdev_priv(dev);
+        struct mlx4_en_dev *mdev = priv->mdev;
+        u32 autoneg = AUTONEG_DISABLE;
+
+        if ((mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_ETH_BACKPL_AN_REP) &&
+            (priv->port_state.flags & MLX4_EN_PORT_ANE))
+                autoneg = AUTONEG_ENABLE;
+
+        return autoneg;
+}
+
+static u32 ptys_get_supported_port(struct mlx4_ptys_reg *ptys_reg)
+{
+        u32 eth_proto = be32_to_cpu(ptys_reg->eth_proto_cap);
+
+        if (eth_proto & (MLX4_PROT_MASK(MLX4_10GBASE_T)
+                         | MLX4_PROT_MASK(MLX4_1000BASE_T)
+                         | MLX4_PROT_MASK(MLX4_100BASE_TX))) {
+                        return SUPPORTED_TP;
+        }
+
+        if (eth_proto & (MLX4_PROT_MASK(MLX4_10GBASE_CR)
+                         | MLX4_PROT_MASK(MLX4_10GBASE_SR)
+                         | MLX4_PROT_MASK(MLX4_56GBASE_SR4)
+                         | MLX4_PROT_MASK(MLX4_40GBASE_CR4)
+                         | MLX4_PROT_MASK(MLX4_40GBASE_SR4)
+                         | MLX4_PROT_MASK(MLX4_1000BASE_CX_SGMII))) {
+                        return SUPPORTED_FIBRE;
+        }
+
+        if (eth_proto & (MLX4_PROT_MASK(MLX4_56GBASE_KR4)
+                         | MLX4_PROT_MASK(MLX4_40GBASE_KR4)
+                         | MLX4_PROT_MASK(MLX4_20GBASE_KR2)
+                         | MLX4_PROT_MASK(MLX4_10GBASE_KR)
+                         | MLX4_PROT_MASK(MLX4_10GBASE_KX4)
+                         | MLX4_PROT_MASK(MLX4_1000BASE_KX))) {
+                        return SUPPORTED_Backplane;
+        }
+        return 0;
+}
+
+static u32 ptys_get_active_port(struct mlx4_ptys_reg *ptys_reg)
+{
+        u32 eth_proto = be32_to_cpu(ptys_reg->eth_proto_oper);
+
+        if (!eth_proto) /* link down */
+                eth_proto = be32_to_cpu(ptys_reg->eth_proto_cap);
+
+        if (eth_proto & (MLX4_PROT_MASK(MLX4_10GBASE_T)
+                         | MLX4_PROT_MASK(MLX4_1000BASE_T)
+                         | MLX4_PROT_MASK(MLX4_100BASE_TX))) {
+                        return PORT_TP;
+        }
+
+        if (eth_proto & (MLX4_PROT_MASK(MLX4_10GBASE_SR)
+                         | MLX4_PROT_MASK(MLX4_56GBASE_SR4)
+                         | MLX4_PROT_MASK(MLX4_40GBASE_SR4)
+                         | MLX4_PROT_MASK(MLX4_1000BASE_CX_SGMII))) {
+                        return PORT_FIBRE;
+        }
+
+        if (eth_proto & (MLX4_PROT_MASK(MLX4_10GBASE_CR)
+                         | MLX4_PROT_MASK(MLX4_56GBASE_CR4)
+                         | MLX4_PROT_MASK(MLX4_40GBASE_CR4))) {
+                        return PORT_DA;
+        }
+
+        if (eth_proto & (MLX4_PROT_MASK(MLX4_56GBASE_KR4)
+                         | MLX4_PROT_MASK(MLX4_40GBASE_KR4)
+                         | MLX4_PROT_MASK(MLX4_20GBASE_KR2)
+                         | MLX4_PROT_MASK(MLX4_10GBASE_KR)
+                         | MLX4_PROT_MASK(MLX4_10GBASE_KX4)
+                         | MLX4_PROT_MASK(MLX4_1000BASE_KX))) {
+                        return PORT_NONE;
+        }
+        return PORT_OTHER;
+}
+
+#define MLX4_LINK_MODES_SZ \
+        (FIELD_SIZEOF(struct mlx4_ptys_reg, eth_proto_cap) * 8)
+
+enum ethtool_report {
+        SUPPORTED = 0,
+        ADVERTISED = 1,
+        SPEED = 2
+};
+
+/* Translates mlx4 link mode to equivalent ethtool Link modes/speed */
+static u32 ptys2ethtool_map[MLX4_LINK_MODES_SZ][3] = {
+        [MLX4_100BASE_TX] = {
+                SUPPORTED_100baseT_Full,
+                ADVERTISED_100baseT_Full,
+                SPEED_100
+                },
+
+        [MLX4_1000BASE_T] = {
+                SUPPORTED_1000baseT_Full,
+                ADVERTISED_1000baseT_Full,
+                SPEED_1000
+                },
+        [MLX4_1000BASE_CX_SGMII] = {
+                SUPPORTED_1000baseKX_Full,
+                ADVERTISED_1000baseKX_Full,
+                SPEED_1000
+                },
+        [MLX4_1000BASE_KX] = {
+                SUPPORTED_1000baseKX_Full,
+                ADVERTISED_1000baseKX_Full,
+                SPEED_1000
+                },
+
+        [MLX4_10GBASE_T] = {
+                SUPPORTED_10000baseT_Full,
+                ADVERTISED_10000baseT_Full,
+                SPEED_10000
+                },
+        [MLX4_10GBASE_CX4] = {
+                SUPPORTED_10000baseKX4_Full,
+                ADVERTISED_10000baseKX4_Full,
+                SPEED_10000
+                },
+        [MLX4_10GBASE_KX4] = {
+                SUPPORTED_10000baseKX4_Full,
+                ADVERTISED_10000baseKX4_Full,
+                SPEED_10000
+                },
+        [MLX4_10GBASE_KR] = {
+                SUPPORTED_10000baseKR_Full,
+                ADVERTISED_10000baseKR_Full,
+                SPEED_10000
+                },
+        [MLX4_10GBASE_CR] = {
+                SUPPORTED_10000baseKR_Full,
+                ADVERTISED_10000baseKR_Full,
+                SPEED_10000
+                },
+        [MLX4_10GBASE_SR] = {
+                SUPPORTED_10000baseKR_Full,
+                ADVERTISED_10000baseKR_Full,
+                SPEED_10000
+                },
+
+        [MLX4_20GBASE_KR2] = {
+                SUPPORTED_20000baseMLD2_Full | SUPPORTED_20000baseKR2_Full,
+                ADVERTISED_20000baseMLD2_Full | ADVERTISED_20000baseKR2_Full,
+                SPEED_20000
+                },
+
+        [MLX4_40GBASE_CR4] = {
+                SUPPORTED_40000baseCR4_Full,
+                ADVERTISED_40000baseCR4_Full,
+                SPEED_40000
+                },
+        [MLX4_40GBASE_KR4] = {
+                SUPPORTED_40000baseKR4_Full,
+                ADVERTISED_40000baseKR4_Full,
+                SPEED_40000
+                },
+        [MLX4_40GBASE_SR4] = {
+                SUPPORTED_40000baseSR4_Full,
+                ADVERTISED_40000baseSR4_Full,
+                SPEED_40000
+                },
+
+        [MLX4_56GBASE_KR4] = {
+                SUPPORTED_56000baseKR4_Full,
+                ADVERTISED_56000baseKR4_Full,
+                SPEED_56000
+                },
+        [MLX4_56GBASE_CR4] = {
+                SUPPORTED_56000baseCR4_Full,
+                ADVERTISED_56000baseCR4_Full,
+                SPEED_56000
+                },
+        [MLX4_56GBASE_SR4] = {
+                SUPPORTED_56000baseSR4_Full,
+                ADVERTISED_56000baseSR4_Full,
+                SPEED_56000
+                },
+};
+
+static u32 ptys2ethtool_link_modes(u32 eth_proto, enum ethtool_report report)
+{
+        int i;
+        u32 link_modes = 0;
+
+        for (i = 0; i < MLX4_LINK_MODES_SZ; i++) {
+                if (eth_proto & MLX4_PROT_MASK(i))
+                        link_modes |= ptys2ethtool_map[i][report];
+        }
+        return link_modes;
+}
+
+static u32 ethtool2ptys_link_modes(u32 link_modes, enum ethtool_report report)
+{
+        int i;
+        u32 ptys_modes = 0;
+
+        for (i = 0; i < MLX4_LINK_MODES_SZ; i++) {
+                if (ptys2ethtool_map[i][report] & link_modes)
+                        ptys_modes |= 1 << i;
+        }
+        return ptys_modes;
+}
+
+/* Convert actual speed (SPEED_XXX) to ptys link modes */
+static u32 speed2ptys_link_modes(u32 speed)
+{
+        int i;
+        u32 ptys_modes = 0;
+
+        for (i = 0; i < MLX4_LINK_MODES_SZ; i++) {
+                if (ptys2ethtool_map[i][SPEED] == speed)
+                        ptys_modes |= 1 << i;
+        }
+        return ptys_modes;
+}
+
+static int ethtool_get_ptys_settings(struct net_device *dev,
+                                     struct ethtool_cmd *cmd)
+{
+        struct mlx4_en_priv *priv = netdev_priv(dev);
+        struct mlx4_ptys_reg ptys_reg;
+        u32 eth_proto;
+        int ret;
+
+        memset(&ptys_reg, 0, sizeof(ptys_reg));
+        ptys_reg.local_port = priv->port;
+        ptys_reg.proto_mask = MLX4_PTYS_EN;
+        ret = mlx4_ACCESS_PTYS_REG(priv->mdev->dev,
+                                   MLX4_ACCESS_REG_QUERY, &ptys_reg);
+        if (ret) {
+                en_warn(priv, "Failed to run mlx4_ACCESS_PTYS_REG status(%x)",
+                        ret);
+                return ret;
+        }
+        en_dbg(DRV, priv, "ptys_reg.proto_mask       %x\n",
+               ptys_reg.proto_mask);
+        en_dbg(DRV, priv, "ptys_reg.eth_proto_cap    %x\n",
+               be32_to_cpu(ptys_reg.eth_proto_cap));
+        en_dbg(DRV, priv, "ptys_reg.eth_proto_admin  %x\n",
+               be32_to_cpu(ptys_reg.eth_proto_admin));
+        en_dbg(DRV, priv, "ptys_reg.eth_proto_oper   %x\n",
+               be32_to_cpu(ptys_reg.eth_proto_oper));
+        en_dbg(DRV, priv, "ptys_reg.eth_proto_lp_adv %x\n",
+               be32_to_cpu(ptys_reg.eth_proto_lp_adv));
+
+        cmd->supported = 0;
+        cmd->advertising = 0;
+
+        cmd->supported |= ptys_get_supported_port(&ptys_reg);
+
+        eth_proto = be32_to_cpu(ptys_reg.eth_proto_cap);
+        cmd->supported |= ptys2ethtool_link_modes(eth_proto, SUPPORTED);
+
+        eth_proto = be32_to_cpu(ptys_reg.eth_proto_admin);
+        cmd->advertising |= ptys2ethtool_link_modes(eth_proto, ADVERTISED);
+
+        cmd->supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
+        cmd->advertising |= (priv->prof->tx_pause) ? ADVERTISED_Pause : 0;
+
+        cmd->advertising |= (priv->prof->tx_pause ^ priv->prof->rx_pause) ?
+                ADVERTISED_Asym_Pause : 0;
+
+        cmd->port = ptys_get_active_port(&ptys_reg);
+        cmd->transceiver = (SUPPORTED_TP & cmd->supported) ?
+                XCVR_EXTERNAL : XCVR_INTERNAL;
+
+        if (mlx4_en_autoneg_get(dev)) {
+                cmd->supported |= SUPPORTED_Autoneg;
+                cmd->advertising |= ADVERTISED_Autoneg;
+        }
+
+        cmd->autoneg = (priv->port_state.flags & MLX4_EN_PORT_ANC) ?
+                AUTONEG_ENABLE : AUTONEG_DISABLE;
+
+        eth_proto = be32_to_cpu(ptys_reg.eth_proto_lp_adv);
+        cmd->lp_advertising = ptys2ethtool_link_modes(eth_proto, ADVERTISED);
+
+        cmd->lp_advertising |= (priv->port_state.flags & MLX4_EN_PORT_ANC) ?
+                        ADVERTISED_Autoneg : 0;
+
+        cmd->phy_address = 0;
+        cmd->mdio_support = 0;
+        cmd->maxtxpkt = 0;
+        cmd->maxrxpkt = 0;
+        cmd->eth_tp_mdix = ETH_TP_MDI_INVALID;
+        cmd->eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;
+
+        return ret;
+}
+
+static void ethtool_get_default_settings(struct net_device *dev,
+                                         struct ethtool_cmd *cmd)
 {
         struct mlx4_en_priv *priv = netdev_priv(dev);
         int trans_type;
@@ -382,18 +678,7 @@ static int mlx4_en_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
         cmd->autoneg = AUTONEG_DISABLE;
         cmd->supported = SUPPORTED_10000baseT_Full;
         cmd->advertising = ADVERTISED_10000baseT_Full;
-
-        if (mlx4_en_QUERY_PORT(priv->mdev, priv->port))
-                return -ENOMEM;
-
-        trans_type = priv->port_state.transciver;
-        if (netif_carrier_ok(dev)) {
-                ethtool_cmd_speed_set(cmd, priv->port_state.link_speed);
-                cmd->duplex = DUPLEX_FULL;
-        } else {
-                ethtool_cmd_speed_set(cmd, SPEED_UNKNOWN);
-                cmd->duplex = DUPLEX_UNKNOWN;
-        }
+        trans_type = priv->port_state.transceiver;
 
         if (trans_type > 0 && trans_type <= 0xC) {
                 cmd->port = PORT_FIBRE;
@@ -409,17 +694,118 @@ static int mlx4_en_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                 cmd->port = -1;
                 cmd->transceiver = -1;
         }
+}
+
+static int mlx4_en_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+{
+        struct mlx4_en_priv *priv = netdev_priv(dev);
+        int ret = -EINVAL;
+
+        if (mlx4_en_QUERY_PORT(priv->mdev, priv->port))
+                return -ENOMEM;
+
+        en_dbg(DRV, priv, "query port state.flags ANC(%x) ANE(%x)\n",
+               priv->port_state.flags & MLX4_EN_PORT_ANC,
+               priv->port_state.flags & MLX4_EN_PORT_ANE);
+
+        if (priv->mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_ETH_PROT_CTRL)
+                ret = ethtool_get_ptys_settings(dev, cmd);
+        if (ret) /* ETH PROT CRTL is not supported or PTYS CMD failed */
+                ethtool_get_default_settings(dev, cmd);
+
+        if (netif_carrier_ok(dev)) {
+                ethtool_cmd_speed_set(cmd, priv->port_state.link_speed);
+                cmd->duplex = DUPLEX_FULL;
+        } else {
+                ethtool_cmd_speed_set(cmd, SPEED_UNKNOWN);
+                cmd->duplex = DUPLEX_UNKNOWN;
+        }
         return 0;
 }
 
+/* Calculate PTYS admin according ethtool speed (SPEED_XXX) */
+static __be32 speed_set_ptys_admin(struct mlx4_en_priv *priv, u32 speed,
+                                   __be32 proto_cap)
+{
+        __be32 proto_admin = 0;
+
+        if (!speed) { /* Speed = 0 ==> Reset Link modes */
+                proto_admin = proto_cap;
+                en_info(priv, "Speed was set to 0, Reset advertised Link Modes to default (%x)\n",
+                        be32_to_cpu(proto_cap));
+        } else {
+                u32 ptys_link_modes = speed2ptys_link_modes(speed);
+
+                proto_admin = cpu_to_be32(ptys_link_modes) & proto_cap;
+                en_info(priv, "Setting Speed to %d\n", speed);
+        }
+        return proto_admin;
+}
+
 static int mlx4_en_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
-        if ((cmd->autoneg == AUTONEG_ENABLE) ||
-            (ethtool_cmd_speed(cmd) != SPEED_10000) ||
-            (cmd->duplex != DUPLEX_FULL))
+        struct mlx4_en_priv *priv = netdev_priv(dev);
+        struct mlx4_ptys_reg ptys_reg;
+        __be32 proto_admin;
+        int ret;
+
+        u32 ptys_adv = ethtool2ptys_link_modes(cmd->advertising, ADVERTISED);
+        int speed = ethtool_cmd_speed(cmd);
+
+        en_dbg(DRV, priv, "Set Speed=%d adv=0x%x autoneg=%d duplex=%d\n",
+               speed, cmd->advertising, cmd->autoneg, cmd->duplex);
+
+        if (!(priv->mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_ETH_PROT_CTRL) ||
+            (cmd->autoneg == AUTONEG_ENABLE) || (cmd->duplex == DUPLEX_HALF))
                 return -EINVAL;
 
-        /* Nothing to change */
+        memset(&ptys_reg, 0, sizeof(ptys_reg));
+        ptys_reg.local_port = priv->port;
+        ptys_reg.proto_mask = MLX4_PTYS_EN;
+        ret = mlx4_ACCESS_PTYS_REG(priv->mdev->dev,
+                                   MLX4_ACCESS_REG_QUERY, &ptys_reg);
+        if (ret) {
+                en_warn(priv, "Failed to QUERY mlx4_ACCESS_PTYS_REG status(%x)\n",
+                        ret);
+                return 0;
+        }
+
+        proto_admin = cpu_to_be32(ptys_adv);
+        if (speed >= 0 && speed != priv->port_state.link_speed)
+                /* If speed was set then speed decides :-) */
+                proto_admin = speed_set_ptys_admin(priv, speed,
+                                                   ptys_reg.eth_proto_cap);
+
+        proto_admin &= ptys_reg.eth_proto_cap;
+
+        if (proto_admin == ptys_reg.eth_proto_admin)
+                return 0; /* Nothing to change */
+
+        if (!proto_admin) {
+                en_warn(priv, "Not supported link mode(s) requested, check supported link modes.\n");
+                return -EINVAL; /* nothing to change due to bad input */
+        }
+
+        en_dbg(DRV, priv, "mlx4_ACCESS_PTYS_REG SET: ptys_reg.eth_proto_admin = 0x%x\n",
+               be32_to_cpu(proto_admin));
+
+        ptys_reg.eth_proto_admin = proto_admin;
+        ret = mlx4_ACCESS_PTYS_REG(priv->mdev->dev, MLX4_ACCESS_REG_WRITE,
+                                   &ptys_reg);
+        if (ret) {
+                en_warn(priv, "Failed to write mlx4_ACCESS_PTYS_REG eth_proto_admin(0x%x) status(0x%x)",
+                        be32_to_cpu(ptys_reg.eth_proto_admin), ret);
+                return ret;
+        }
+
+        en_warn(priv, "Port link mode changed, restarting port...\n");
+        mutex_lock(&priv->mdev->state_lock);
+        if (priv->port_up) {
+                mlx4_en_stop_port(dev, 1);
+                if (mlx4_en_start_port(dev))
+                        en_err(priv, "Failed restarting port %d\n", priv->port);
+        }
+        mutex_unlock(&priv->mdev->state_lock);
         return 0;
 }
 
@@ -596,6 +982,7 @@ static int mlx4_en_get_rxfh(struct net_device *dev, u32 *ring_index, u8 *key)
         int err = 0;
 
         rss_rings = priv->prof->rss_rings ?: priv->rx_ring_num;
+        rss_rings = 1 << ilog2(rss_rings);
 
         while (n--) {
                 ring_index[n] = rss_map->qps[n % rss_rings].qpn -
@@ -1309,6 +1696,86 @@ static int mlx4_en_set_tunable(struct net_device *dev,
         return ret;
 }
 
+static int mlx4_en_get_module_info(struct net_device *dev,
+                                   struct ethtool_modinfo *modinfo)
+{
+        struct mlx4_en_priv *priv = netdev_priv(dev);
+        struct mlx4_en_dev *mdev = priv->mdev;
+        int ret;
+        u8 data[4];
+
+        /* Read first 2 bytes to get Module & REV ID */
+        ret = mlx4_get_module_info(mdev->dev, priv->port,
+                                   0/*offset*/, 2/*size*/, data);
+        if (ret < 2)
+                return -EIO;
+
+        switch (data[0] /* identifier */) {
+        case MLX4_MODULE_ID_QSFP:
+                modinfo->type = ETH_MODULE_SFF_8436;
+                modinfo->eeprom_len = ETH_MODULE_SFF_8436_LEN;
+                break;
+        case MLX4_MODULE_ID_QSFP_PLUS:
+                if (data[1] >= 0x3) { /* revision id */
+                        modinfo->type = ETH_MODULE_SFF_8636;
+                        modinfo->eeprom_len = ETH_MODULE_SFF_8636_LEN;
+                } else {
+                        modinfo->type = ETH_MODULE_SFF_8436;
+                        modinfo->eeprom_len = ETH_MODULE_SFF_8436_LEN;
+                }
+                break;
+        case MLX4_MODULE_ID_QSFP28:
+                modinfo->type = ETH_MODULE_SFF_8636;
+                modinfo->eeprom_len = ETH_MODULE_SFF_8636_LEN;
+                break;
+        case MLX4_MODULE_ID_SFP:
+                modinfo->type = ETH_MODULE_SFF_8472;
+                modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;
+                break;
+        default:
+                return -ENOSYS;
+        }
+
+        return 0;
+}
+
+static int mlx4_en_get_module_eeprom(struct net_device *dev,
+                                     struct ethtool_eeprom *ee,
+                                     u8 *data)
+{
+        struct mlx4_en_priv *priv = netdev_priv(dev);
+        struct mlx4_en_dev *mdev = priv->mdev;
+        int offset = ee->offset;
+        int i = 0, ret;
+
+        if (ee->len == 0)
+                return -EINVAL;
+
+        memset(data, 0, ee->len);
+
+        while (i < ee->len) {
+                en_dbg(DRV, priv,
+                       "mlx4_get_module_info i(%d) offset(%d) len(%d)\n",
+                       i, offset, ee->len - i);
+
+                ret = mlx4_get_module_info(mdev->dev, priv->port,
+                                           offset, ee->len - i, data + i);
+
+                if (!ret) /* Done reading */
+                        return 0;
+
+                if (ret < 0) {
+                        en_err(priv,
+                               "mlx4_get_module_info i(%d) offset(%d) bytes_to_read(%d) - FAILED (0x%x)\n",
+                               i, offset, ee->len - i, ret);
+                        return 0;
+                }
+
+                i += ret;
+                offset += ret;
+        }
+        return 0;
+}
 
 const struct ethtool_ops mlx4_en_ethtool_ops = {
         .get_drvinfo = mlx4_en_get_drvinfo,
@@ -1341,6 +1808,8 @@ const struct ethtool_ops mlx4_en_ethtool_ops = {
         .get_priv_flags = mlx4_en_get_priv_flags,
         .get_tunable            = mlx4_en_get_tunable,
         .set_tunable            = mlx4_en_set_tunable,
+        .get_module_info = mlx4_en_get_module_info,
+        .get_module_eeprom = mlx4_en_get_module_eeprom
 };
 
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_main.c b/drivers/net/ethernet/mellanox/mlx4/en_main.c
index 2091ae88615d..9f16f754137b 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_main.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_main.c
@@ -221,15 +221,12 @@ static void *mlx4_en_add(struct mlx4_dev *dev)
 {
         struct mlx4_en_dev *mdev;
         int i;
-        int err;
 
         printk_once(KERN_INFO "%s", mlx4_en_version);
 
         mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
-        if (!mdev) {
-                err = -ENOMEM;
+        if (!mdev)
                 goto err_free_res;
-        }
 
         if (mlx4_pd_alloc(dev, &mdev->priv_pdn))
                 goto err_free_dev;
@@ -264,8 +261,7 @@ static void *mlx4_en_add(struct mlx4_dev *dev)
         }
 
         /* Build device profile according to supplied module parameters */
-        err = mlx4_en_get_profile(mdev);
-        if (err) {
+        if (mlx4_en_get_profile(mdev)) {
                 mlx4_err(mdev, "Bad module parameters, aborting\n");
                 goto err_mr;
         }
@@ -286,10 +282,8 @@ static void *mlx4_en_add(struct mlx4_dev *dev)
          * Note: we cannot use the shared workqueue because of deadlocks caused
          *       by the rtnl lock */
         mdev->workqueue = create_singlethread_workqueue("mlx4_en");
-        if (!mdev->workqueue) {
-                err = -ENOMEM;
+        if (!mdev->workqueue)
                 goto err_mr;
-        }
 
         /* At this stage all non-port specific tasks are complete:
          * mark the card state as up */
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c
index f3032fec8fce..0efbae90f1ba 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c
@@ -575,7 +575,7 @@ static int mlx4_en_get_qp(struct mlx4_en_priv *priv)
         struct mlx4_mac_entry *entry;
         int index = 0;
         int err = 0;
-        u64 reg_id;
+        u64 reg_id = 0;
         int *qpn = &priv->base_qpn;
         u64 mac = mlx4_mac_to_u64(priv->dev->dev_addr);
 
@@ -1843,8 +1843,7 @@ void mlx4_en_stop_port(struct net_device *dev, int detach)
                 }
                 local_bh_enable();
 
-                while (test_bit(NAPI_STATE_SCHED, &cq->napi.state))
-                        msleep(1);
+                napi_synchronize(&cq->napi);
                 mlx4_en_deactivate_rx_ring(priv, priv->rx_ring[i]);
                 mlx4_en_deactivate_cq(priv, cq);
 
@@ -2157,7 +2156,7 @@ static int mlx4_en_hwtstamp_set(struct net_device *dev, struct ifreq *ifr)
                 return -ERANGE;
         }
 
-        if (mlx4_en_timestamp_config(dev, config.tx_type, config.rx_filter)) {
+        if (mlx4_en_reset_config(dev, config, dev->features)) {
                 config.tx_type = HWTSTAMP_TX_OFF;
                 config.rx_filter = HWTSTAMP_FILTER_NONE;
         }
@@ -2190,6 +2189,16 @@ static int mlx4_en_set_features(struct net_device *netdev,
                 netdev_features_t features)
 {
         struct mlx4_en_priv *priv = netdev_priv(netdev);
+        int ret = 0;
+
+        if (DEV_FEATURE_CHANGED(netdev, features, NETIF_F_HW_VLAN_CTAG_RX)) {
+                en_info(priv, "Turn %s RX vlan strip offload\n",
+                        (features & NETIF_F_HW_VLAN_CTAG_RX) ? "ON" : "OFF");
+                ret = mlx4_en_reset_config(netdev, priv->hwtstamp_config,
+                                           features);
+                if (ret)
+                        return ret;
+        }
 
         if (features & NETIF_F_LOOPBACK)
                 priv->ctrl_flags |= cpu_to_be32(MLX4_WQE_CTRL_FORCE_LOOPBACK);
@@ -2431,6 +2440,21 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
 
         priv = netdev_priv(dev);
         memset(priv, 0, sizeof(struct mlx4_en_priv));
+        spin_lock_init(&priv->stats_lock);
+        INIT_WORK(&priv->rx_mode_task, mlx4_en_do_set_rx_mode);
+        INIT_WORK(&priv->watchdog_task, mlx4_en_restart);
+        INIT_WORK(&priv->linkstate_task, mlx4_en_linkstate);
+        INIT_DELAYED_WORK(&priv->stats_task, mlx4_en_do_get_stats);
+        INIT_DELAYED_WORK(&priv->service_task, mlx4_en_service_task);
+#ifdef CONFIG_MLX4_EN_VXLAN
+        INIT_WORK(&priv->vxlan_add_task, mlx4_en_add_vxlan_offloads);
+        INIT_WORK(&priv->vxlan_del_task, mlx4_en_del_vxlan_offloads);
+#endif
+#ifdef CONFIG_RFS_ACCEL
+        INIT_LIST_HEAD(&priv->filters);
+        spin_lock_init(&priv->filters_lock);
+#endif
+
         priv->dev = dev;
         priv->mdev = mdev;
         priv->ddev = &mdev->pdev->dev;
@@ -2462,16 +2486,6 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
         priv->cqe_size = mdev->dev->caps.cqe_size;
         priv->mac_index = -1;
         priv->msg_enable = MLX4_EN_MSG_LEVEL;
-        spin_lock_init(&priv->stats_lock);
-        INIT_WORK(&priv->rx_mode_task, mlx4_en_do_set_rx_mode);
-        INIT_WORK(&priv->watchdog_task, mlx4_en_restart);
-        INIT_WORK(&priv->linkstate_task, mlx4_en_linkstate);
-        INIT_DELAYED_WORK(&priv->stats_task, mlx4_en_do_get_stats);
-        INIT_DELAYED_WORK(&priv->service_task, mlx4_en_service_task);
-#ifdef CONFIG_MLX4_EN_VXLAN
-        INIT_WORK(&priv->vxlan_add_task, mlx4_en_add_vxlan_offloads);
-        INIT_WORK(&priv->vxlan_del_task, mlx4_en_del_vxlan_offloads);
-#endif
 #ifdef CONFIG_MLX4_EN_DCB
         if (!mlx4_is_slave(priv->mdev->dev)) {
                 if (mdev->dev->caps.flags & MLX4_DEV_CAP_FLAG_SET_ETH_SCHED) {
@@ -2514,11 +2528,6 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
         if (err)
                 goto out;
 
-#ifdef CONFIG_RFS_ACCEL
-        INIT_LIST_HEAD(&priv->filters);
-        spin_lock_init(&priv->filters_lock);
-#endif
-
         /* Initialize time stamping config */
         priv->hwtstamp_config.flags = 0;
         priv->hwtstamp_config.tx_type = HWTSTAMP_TX_OFF;
@@ -2559,7 +2568,8 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
         dev->features = dev->hw_features | NETIF_F_HIGHDMA |
                         NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX |
                         NETIF_F_HW_VLAN_CTAG_FILTER;
-        dev->hw_features |= NETIF_F_LOOPBACK;
+        dev->hw_features |= NETIF_F_LOOPBACK |
+                        NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX;
 
         if (mdev->dev->caps.steering_mode ==
             MLX4_STEERING_MODE_DEVICE_MANAGED)
@@ -2633,3 +2643,79 @@ out:
         return err;
 }
 
+int mlx4_en_reset_config(struct net_device *dev,
+                         struct hwtstamp_config ts_config,
+                         netdev_features_t features)
+{
+        struct mlx4_en_priv *priv = netdev_priv(dev);
+        struct mlx4_en_dev *mdev = priv->mdev;
+        int port_up = 0;
+        int err = 0;
+
+        if (priv->hwtstamp_config.tx_type == ts_config.tx_type &&
+            priv->hwtstamp_config.rx_filter == ts_config.rx_filter &&
+            !DEV_FEATURE_CHANGED(dev, features, NETIF_F_HW_VLAN_CTAG_RX))
+                return 0; /* Nothing to change */
+
+        if (DEV_FEATURE_CHANGED(dev, features, NETIF_F_HW_VLAN_CTAG_RX) &&
+            (features & NETIF_F_HW_VLAN_CTAG_RX) &&
+            (priv->hwtstamp_config.rx_filter != HWTSTAMP_FILTER_NONE)) {
+                en_warn(priv, "Can't turn ON rx vlan offload while time-stamping rx filter is ON\n");
+                return -EINVAL;
+        }
+
+        mutex_lock(&mdev->state_lock);
+        if (priv->port_up) {
+                port_up = 1;
+                mlx4_en_stop_port(dev, 1);
+        }
+
+        mlx4_en_free_resources(priv);
+
+        en_warn(priv, "Changing device configuration rx filter(%x) rx vlan(%x)\n",
+                ts_config.rx_filter, !!(features & NETIF_F_HW_VLAN_CTAG_RX));
+
+        priv->hwtstamp_config.tx_type = ts_config.tx_type;
+        priv->hwtstamp_config.rx_filter = ts_config.rx_filter;
+
+        if (DEV_FEATURE_CHANGED(dev, features, NETIF_F_HW_VLAN_CTAG_RX)) {
+                if (features & NETIF_F_HW_VLAN_CTAG_RX)
+                        dev->features |= NETIF_F_HW_VLAN_CTAG_RX;
+                else
+                        dev->features &= ~NETIF_F_HW_VLAN_CTAG_RX;
+        } else if (ts_config.rx_filter == HWTSTAMP_FILTER_NONE) {
+                /* RX time-stamping is OFF, update the RX vlan offload
+                 * to the latest wanted state
+                 */
+                if (dev->wanted_features & NETIF_F_HW_VLAN_CTAG_RX)
+                        dev->features |= NETIF_F_HW_VLAN_CTAG_RX;
+                else
+                        dev->features &= ~NETIF_F_HW_VLAN_CTAG_RX;
+        }
+
+        /* RX vlan offload and RX time-stamping can't co-exist !
+         * Regardless of the caller's choice,
+         * Turn Off RX vlan offload in case of time-stamping is ON
+         */
+        if (ts_config.rx_filter != HWTSTAMP_FILTER_NONE) {
+                if (dev->features & NETIF_F_HW_VLAN_CTAG_RX)
+                        en_warn(priv, "Turning off RX vlan offload since RX time-stamping is ON\n");
+                dev->features &= ~NETIF_F_HW_VLAN_CTAG_RX;
+        }
+
+        err = mlx4_en_alloc_resources(priv);
+        if (err) {
+                en_err(priv, "Failed reallocating port resources\n");
+                goto out;
+        }
+        if (port_up) {
+                err = mlx4_en_start_port(dev);
+                if (err)
+                        en_err(priv, "Failed starting port\n");
+        }
+
+out:
+        mutex_unlock(&mdev->state_lock);
+        netdev_features_change(dev);
+        return err;
+}
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_port.c b/drivers/net/ethernet/mellanox/mlx4/en_port.c
index 0a0261d128b9..134b12e17da5 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_port.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_port.c
@@ -91,21 +91,37 @@ int mlx4_en_QUERY_PORT(struct mlx4_en_dev *mdev, u8 port)
          * already synchronized, no need in locking */
         state->link_state = !!(qport_context->link_up & MLX4_EN_LINK_UP_MASK);
         switch (qport_context->link_speed & MLX4_EN_SPEED_MASK) {
+        case MLX4_EN_100M_SPEED:
+                state->link_speed = SPEED_100;
+                break;
         case MLX4_EN_1G_SPEED:
-                state->link_speed = 1000;
+                state->link_speed = SPEED_1000;
                 break;
         case MLX4_EN_10G_SPEED_XAUI:
         case MLX4_EN_10G_SPEED_XFI:
-                state->link_speed = 10000;
+                state->link_speed = SPEED_10000;
+                break;
+        case MLX4_EN_20G_SPEED:
+                state->link_speed = SPEED_20000;
                 break;
         case MLX4_EN_40G_SPEED:
-                state->link_speed = 40000;
+                state->link_speed = SPEED_40000;
+                break;
+        case MLX4_EN_56G_SPEED:
+                state->link_speed = SPEED_56000;
                 break;
         default:
                 state->link_speed = -1;
                 break;
         }
-        state->transciver = qport_context->transceiver;
+
+        state->transceiver = qport_context->transceiver;
+
+        state->flags = 0; /* Reset and recalculate the port flags */
+        state->flags |= (qport_context->link_up & MLX4_EN_ANC_MASK) ?
+                MLX4_EN_PORT_ANC : 0;
+        state->flags |= (qport_context->autoneg & MLX4_EN_AUTONEG_MASK) ?
+                MLX4_EN_PORT_ANE : 0;
 
 out:
         mlx4_free_cmd_mailbox(mdev->dev, mailbox);
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_port.h b/drivers/net/ethernet/mellanox/mlx4/en_port.h
index 745090b49d9e..040da4b16b1c 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_port.h
+++ b/drivers/net/ethernet/mellanox/mlx4/en_port.h
@@ -53,22 +53,49 @@ enum {
         MLX4_MCAST_ENABLE       = 2,
 };
 
+enum mlx4_link_mode {
+        MLX4_1000BASE_CX_SGMII   = 0,
+        MLX4_1000BASE_KX         = 1,
+        MLX4_10GBASE_CX4         = 2,
+        MLX4_10GBASE_KX4         = 3,
+        MLX4_10GBASE_KR          = 4,
+        MLX4_20GBASE_KR2         = 5,
+        MLX4_40GBASE_CR4         = 6,
+        MLX4_40GBASE_KR4         = 7,
+        MLX4_56GBASE_KR4         = 8,
+        MLX4_10GBASE_CR          = 12,
+        MLX4_10GBASE_SR          = 13,
+        MLX4_40GBASE_SR4         = 15,
+        MLX4_56GBASE_CR4         = 17,
+        MLX4_56GBASE_SR4         = 18,
+        MLX4_100BASE_TX          = 24,
+        MLX4_1000BASE_T          = 25,
+        MLX4_10GBASE_T           = 26,
+};
+
+#define MLX4_PROT_MASK(link_mode) (1<<link_mode)
+
 enum {
-        MLX4_EN_1G_SPEED        = 0x02,
-        MLX4_EN_10G_SPEED_XFI   = 0x01,
+        MLX4_EN_100M_SPEED      = 0x04,
         MLX4_EN_10G_SPEED_XAUI  = 0x00,
+        MLX4_EN_10G_SPEED_XFI   = 0x01,
+        MLX4_EN_1G_SPEED        = 0x02,
+        MLX4_EN_20G_SPEED       = 0x08,
         MLX4_EN_40G_SPEED       = 0x40,
+        MLX4_EN_56G_SPEED       = 0x20,
         MLX4_EN_OTHER_SPEED     = 0x0f,
 };
 
 struct mlx4_en_query_port_context {
         u8 link_up;
 #define MLX4_EN_LINK_UP_MASK    0x80
-        u8 reserved;
+#define MLX4_EN_ANC_MASK        0x40
+        u8 autoneg;
+#define MLX4_EN_AUTONEG_MASK    0x80
         __be16 mtu;
         u8 reserved2;
         u8 link_speed;
-#define MLX4_EN_SPEED_MASK      0x43
+#define MLX4_EN_SPEED_MASK      0x6f
         u16 reserved3[5];
         __be64 mac;
         u8 transceiver;
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_rx.c b/drivers/net/ethernet/mellanox/mlx4/en_rx.c
index 01660c595f5c..c562c1468944 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_rx.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_rx.c
@@ -119,7 +119,6 @@ static int mlx4_en_alloc_frags(struct mlx4_en_priv *priv,
 
 out:
         while (i--) {
-                frag_info = &priv->frag_info[i];
                 if (page_alloc[i].page != ring_alloc[i].page) {
                         dma_unmap_page(priv->ddev, page_alloc[i].dma,
                                 page_alloc[i].page_size, PCI_DMA_FROMDEVICE);
@@ -879,8 +878,8 @@ void mlx4_en_rx_irq(struct mlx4_cq *mcq)
         struct mlx4_en_cq *cq = container_of(mcq, struct mlx4_en_cq, mcq);
         struct mlx4_en_priv *priv = netdev_priv(cq->dev);
 
-        if (priv->port_up)
-                napi_schedule(&cq->napi);
+        if (likely(priv->port_up))
+                napi_schedule_irqoff(&cq->napi);
         else
                 mlx4_en_arm_cq(priv, cq);
 }
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_selftest.c b/drivers/net/ethernet/mellanox/mlx4/en_selftest.c
index 49d5afc7cfb8..2d8ee66138e8 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_selftest.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_selftest.c
@@ -129,11 +129,15 @@ static int mlx4_en_test_speed(struct mlx4_en_priv *priv)
         if (mlx4_en_QUERY_PORT(priv->mdev, priv->port))
                 return -ENOMEM;
 
-        /* The device supports 1G, 10G and 40G speeds */
-        if (priv->port_state.link_speed != 1000 &&
-            priv->port_state.link_speed != 10000 &&
-            priv->port_state.link_speed != 40000)
+        /* The device supports 100M, 1G, 10G, 20G, 40G and 56G speed */
+        if (priv->port_state.link_speed != SPEED_100 &&
+            priv->port_state.link_speed != SPEED_1000 &&
+            priv->port_state.link_speed != SPEED_10000 &&
+            priv->port_state.link_speed != SPEED_20000 &&
+            priv->port_state.link_speed != SPEED_40000 &&
+            priv->port_state.link_speed != SPEED_56000)
                 return priv->port_state.link_speed;
+
         return 0;
 }
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_tx.c b/drivers/net/ethernet/mellanox/mlx4/en_tx.c
index 454d9fea640e..d0cecbdd9ba8 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_tx.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_tx.c
@@ -479,8 +479,8 @@ void mlx4_en_tx_irq(struct mlx4_cq *mcq)
         struct mlx4_en_cq *cq = container_of(mcq, struct mlx4_en_cq, mcq);
         struct mlx4_en_priv *priv = netdev_priv(cq->dev);
 
-        if (priv->port_up)
-                napi_schedule(&cq->napi);
+        if (likely(priv->port_up))
+                napi_schedule_irqoff(&cq->napi);
         else
                 mlx4_en_arm_cq(priv, cq);
 }
diff --git a/drivers/net/ethernet/mellanox/mlx4/fw.c b/drivers/net/ethernet/mellanox/mlx4/fw.c
index 2e88a235e26b..72289ef5ebbe 100644
--- a/drivers/net/ethernet/mellanox/mlx4/fw.c
+++ b/drivers/net/ethernet/mellanox/mlx4/fw.c
@@ -139,7 +139,9 @@ static void dump_dev_cap_flags2(struct mlx4_dev *dev, u64 flags)
                 [10] = "TCP/IP offloads/flow-steering for VXLAN support",
                 [11] = "MAD DEMUX (Secure-Host) support",
                 [12] = "Large cache line (>64B) CQE stride support",
-                [13] = "Large cache line (>64B) EQE stride support"
+                [13] = "Large cache line (>64B) EQE stride support",
+                [14] = "Ethernet protocol control support",
+                [15] = "Ethernet Backplane autoneg support"
         };
         int i;
 
@@ -560,6 +562,7 @@ int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
 #define QUERY_DEV_CAP_FLOW_STEERING_RANGE_EN_OFFSET     0x76
 #define QUERY_DEV_CAP_FLOW_STEERING_MAX_QP_OFFSET       0x77
 #define QUERY_DEV_CAP_CQ_EQ_CACHE_LINE_STRIDE   0x7a
+#define QUERY_DEV_CAP_ETH_PROT_CTRL_OFFSET      0x7a
 #define QUERY_DEV_CAP_RDMARC_ENTRY_SZ_OFFSET    0x80
 #define QUERY_DEV_CAP_QPC_ENTRY_SZ_OFFSET       0x82
 #define QUERY_DEV_CAP_AUX_ENTRY_SZ_OFFSET       0x84
@@ -573,6 +576,7 @@ int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
 #define QUERY_DEV_CAP_BMME_FLAGS_OFFSET         0x94
 #define QUERY_DEV_CAP_RSVD_LKEY_OFFSET          0x98
 #define QUERY_DEV_CAP_MAX_ICM_SZ_OFFSET         0xa0
+#define QUERY_DEV_CAP_ETH_BACKPL_OFFSET         0x9c
 #define QUERY_DEV_CAP_FW_REASSIGN_MAC           0x9d
 #define QUERY_DEV_CAP_VXLAN                     0x9e
 #define QUERY_DEV_CAP_MAD_DEMUX_OFFSET          0xb0
@@ -737,15 +741,19 @@ int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
         MLX4_GET(size, outbox, QUERY_DEV_CAP_MAX_DESC_SZ_RQ_OFFSET);
         dev_cap->max_rq_desc_sz = size;
         MLX4_GET(field, outbox, QUERY_DEV_CAP_CQ_EQ_CACHE_LINE_STRIDE);
+        if (field & (1 << 5))
+                dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_ETH_PROT_CTRL;
         if (field & (1 << 6))
                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_CQE_STRIDE;
         if (field & (1 << 7))
                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_EQE_STRIDE;
-
         MLX4_GET(dev_cap->bmme_flags, outbox,
                  QUERY_DEV_CAP_BMME_FLAGS_OFFSET);
         MLX4_GET(dev_cap->reserved_lkey, outbox,
                  QUERY_DEV_CAP_RSVD_LKEY_OFFSET);
+        MLX4_GET(field32, outbox, QUERY_DEV_CAP_ETH_BACKPL_OFFSET);
+        if (field32 & (1 << 0))
+                dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_ETH_BACKPL_AN_REP;
         MLX4_GET(field, outbox, QUERY_DEV_CAP_FW_REASSIGN_MAC);
         if (field & 1<<6)
                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_REASSIGN_MAC_EN;
@@ -2144,3 +2152,114 @@ out:
         mlx4_free_cmd_mailbox(dev, mailbox);
         return err;
 }
+
+/* Access Reg commands */
+enum mlx4_access_reg_masks {
+        MLX4_ACCESS_REG_STATUS_MASK = 0x7f,
+        MLX4_ACCESS_REG_METHOD_MASK = 0x7f,
+        MLX4_ACCESS_REG_LEN_MASK = 0x7ff
+};
+
+struct mlx4_access_reg {
+        __be16 constant1;
+        u8 status;
+        u8 resrvd1;
+        __be16 reg_id;
+        u8 method;
+        u8 constant2;
+        __be32 resrvd2[2];
+        __be16 len_const;
+        __be16 resrvd3;
+#define MLX4_ACCESS_REG_HEADER_SIZE (20)
+        u8 reg_data[MLX4_MAILBOX_SIZE-MLX4_ACCESS_REG_HEADER_SIZE];
+} __attribute__((__packed__));
+
+/**
+ * mlx4_ACCESS_REG - Generic access reg command.
+ * @dev: mlx4_dev.
+ * @reg_id: register ID to access.
+ * @method: Access method Read/Write.
+ * @reg_len: register length to Read/Write in bytes.
+ * @reg_data: reg_data pointer to Read/Write From/To.
+ *
+ * Access ConnectX registers FW command.
+ * Returns 0 on success and copies outbox mlx4_access_reg data
+ * field into reg_data or a negative error code.
+ */
+static int mlx4_ACCESS_REG(struct mlx4_dev *dev, u16 reg_id,
+                           enum mlx4_access_reg_method method,
+                           u16 reg_len, void *reg_data)
+{
+        struct mlx4_cmd_mailbox *inbox, *outbox;
+        struct mlx4_access_reg *inbuf, *outbuf;
+        int err;
+
+        inbox = mlx4_alloc_cmd_mailbox(dev);
+        if (IS_ERR(inbox))
+                return PTR_ERR(inbox);
+
+        outbox = mlx4_alloc_cmd_mailbox(dev);
+        if (IS_ERR(outbox)) {
+                mlx4_free_cmd_mailbox(dev, inbox);
+                return PTR_ERR(outbox);
+        }
+
+        inbuf = inbox->buf;
+        outbuf = outbox->buf;
+
+        inbuf->constant1 = cpu_to_be16(0x1<<11 | 0x4);
+        inbuf->constant2 = 0x1;
+        inbuf->reg_id = cpu_to_be16(reg_id);
+        inbuf->method = method & MLX4_ACCESS_REG_METHOD_MASK;
+
+        reg_len = min(reg_len, (u16)(sizeof(inbuf->reg_data)));
+        inbuf->len_const =
+                cpu_to_be16(((reg_len/4 + 1) & MLX4_ACCESS_REG_LEN_MASK) |
+                            ((0x3) << 12));
+
+        memcpy(inbuf->reg_data, reg_data, reg_len);
+        err = mlx4_cmd_box(dev, inbox->dma, outbox->dma, 0, 0,
+                           MLX4_CMD_ACCESS_REG, MLX4_CMD_TIME_CLASS_C,
+                           MLX4_CMD_NATIVE);
+        if (err)
+                goto out;
+
+        if (outbuf->status & MLX4_ACCESS_REG_STATUS_MASK) {
+                err = outbuf->status & MLX4_ACCESS_REG_STATUS_MASK;
+                mlx4_err(dev,
+                         "MLX4_CMD_ACCESS_REG(%x) returned REG status (%x)\n",
+                         reg_id, err);
+                goto out;
+        }
+
+        memcpy(reg_data, outbuf->reg_data, reg_len);
+out:
+        mlx4_free_cmd_mailbox(dev, inbox);
+        mlx4_free_cmd_mailbox(dev, outbox);
+        return err;
+}
+
+/* ConnectX registers IDs */
+enum mlx4_reg_id {
+        MLX4_REG_ID_PTYS = 0x5004,
+};
+
+/**
+ * mlx4_ACCESS_PTYS_REG - Access PTYs (Port Type and Speed)
+ * register
+ * @dev: mlx4_dev.
+ * @method: Access method Read/Write.
+ * @ptys_reg: PTYS register data pointer.
+ *
+ * Access ConnectX PTYS register, to Read/Write Port Type/Speed
+ * configuration
+ * Returns 0 on success or a negative error code.
+ */
+int mlx4_ACCESS_PTYS_REG(struct mlx4_dev *dev,
+                         enum mlx4_access_reg_method method,
+                         struct mlx4_ptys_reg *ptys_reg)
+{
+        return mlx4_ACCESS_REG(dev, MLX4_REG_ID_PTYS,
+                               method, sizeof(*ptys_reg), ptys_reg);
+}
+EXPORT_SYMBOL_GPL(mlx4_ACCESS_PTYS_REG);
diff --git a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
index 8fef65840b3b..6beb4d34dce0 100644
--- a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
+++ b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
@@ -421,10 +421,16 @@ struct mlx4_en_rss_map {
         enum mlx4_qp_state indir_state;
 };
 
+enum mlx4_en_port_flag {
+        MLX4_EN_PORT_ANC = 1<<0, /* Auto-negotiation complete */
+        MLX4_EN_PORT_ANE = 1<<1, /* Auto-negotiation enabled */
+};
+
 struct mlx4_en_port_state {
         int link_state;
         int link_speed;
-        int transciver;
+        int transceiver;
+        u32 flags;
 };
 
 struct mlx4_en_pkt_stats {
@@ -829,6 +835,13 @@ void mlx4_en_cleanup_filters(struct mlx4_en_priv *priv);
 void mlx4_en_ex_selftest(struct net_device *dev, u32 *flags, u64 *buf);
 void mlx4_en_ptp_overflow_check(struct mlx4_en_dev *mdev);
 
+#define DEV_FEATURE_CHANGED(dev, new_features, feature) \
+        ((dev->features & feature) ^ (new_features & feature))
+
+int mlx4_en_reset_config(struct net_device *dev,
+                         struct hwtstamp_config ts_config,
+                         netdev_features_t new_features);
+
 /*
  * Functions for time stamping
  */
@@ -838,9 +851,6 @@ void mlx4_en_fill_hwtstamps(struct mlx4_en_dev *mdev,
                             u64 timestamp);
 void mlx4_en_init_timestamp(struct mlx4_en_dev *mdev);
 void mlx4_en_remove_timestamp(struct mlx4_en_dev *mdev);
-int mlx4_en_timestamp_config(struct net_device *dev,
-                             int tx_type,
-                             int rx_filter);
 
 /* Globals
  */
diff --git a/drivers/net/ethernet/mellanox/mlx4/port.c b/drivers/net/ethernet/mellanox/mlx4/port.c
index 94eeb2c7d7e4..30eb1ead0fe6 100644
--- a/drivers/net/ethernet/mellanox/mlx4/port.c
+++ b/drivers/net/ethernet/mellanox/mlx4/port.c
@@ -1311,3 +1311,159 @@ int mlx4_get_roce_gid_from_slave(struct mlx4_dev *dev, int port, int slave_id,
         return 0;
 }
 EXPORT_SYMBOL(mlx4_get_roce_gid_from_slave);
+
+/* Cable Module Info */
+#define MODULE_INFO_MAX_READ 48
+
+#define I2C_ADDR_LOW  0x50
+#define I2C_ADDR_HIGH 0x51
+#define I2C_PAGE_SIZE 256
+
+/* Module Info Data */
+struct mlx4_cable_info {
+        u8      i2c_addr;
+        u8      page_num;
+        __be16  dev_mem_address;
+        __be16  reserved1;
+        __be16  size;
+        __be32  reserved2[2];
+        u8      data[MODULE_INFO_MAX_READ];
+};
+
+enum cable_info_err {
+         CABLE_INF_INV_PORT      = 0x1,
+         CABLE_INF_OP_NOSUP      = 0x2,
+         CABLE_INF_NOT_CONN      = 0x3,
+         CABLE_INF_NO_EEPRM      = 0x4,
+         CABLE_INF_PAGE_ERR      = 0x5,
+         CABLE_INF_INV_ADDR      = 0x6,
+         CABLE_INF_I2C_ADDR      = 0x7,
+         CABLE_INF_QSFP_VIO      = 0x8,
+         CABLE_INF_I2C_BUSY      = 0x9,
+};
+
+#define MAD_STATUS_2_CABLE_ERR(mad_status) ((mad_status >> 8) & 0xFF)
+
+static inline const char *cable_info_mad_err_str(u16 mad_status)
+{
+        u8 err = MAD_STATUS_2_CABLE_ERR(mad_status);
+
+        switch (err) {
+        case CABLE_INF_INV_PORT:
+                return "invalid port selected";
+        case CABLE_INF_OP_NOSUP:
+                return "operation not supported for this port (the port is of type CX4 or internal)";
+        case CABLE_INF_NOT_CONN:
+                return "cable is not connected";
+        case CABLE_INF_NO_EEPRM:
+                return "the connected cable has no EPROM (passive copper cable)";
+        case CABLE_INF_PAGE_ERR:
+                return "page number is greater than 15";
+        case CABLE_INF_INV_ADDR:
+                return "invalid device_address or size (that is, size equals 0 or address+size is greater than 256)";
+        case CABLE_INF_I2C_ADDR:
+                return "invalid I2C slave address";
+        case CABLE_INF_QSFP_VIO:
+                return "at least one cable violates the QSFP specification and ignores the modsel signal";
+        case CABLE_INF_I2C_BUSY:
+                return "I2C bus is constantly busy";
+        }
+        return "Unknown Error";
+}
+
+/**
+ * mlx4_get_module_info - Read cable module eeprom data
+ * @dev: mlx4_dev.
+ * @port: port number.
+ * @offset: byte offset in eeprom to start reading data from.
+ * @size: num of bytes to read.
+ * @data: output buffer to put the requested data into.
+ *
+ * Reads cable module eeprom data, puts the outcome data into
+ * data pointer paramer.
+ * Returns num of read bytes on success or a negative error
+ * code.
+ */
+int mlx4_get_module_info(struct mlx4_dev *dev, u8 port,
+                         u16 offset, u16 size, u8 *data)
+{
+        struct mlx4_cmd_mailbox *inbox, *outbox;
+        struct mlx4_mad_ifc *inmad, *outmad;
+        struct mlx4_cable_info *cable_info;
+        u16 i2c_addr;
+        int ret;
+
+        if (size > MODULE_INFO_MAX_READ)
+                size = MODULE_INFO_MAX_READ;
+
+        inbox = mlx4_alloc_cmd_mailbox(dev);
+        if (IS_ERR(inbox))
+                return PTR_ERR(inbox);
+
+        outbox = mlx4_alloc_cmd_mailbox(dev);
+        if (IS_ERR(outbox)) {
+                mlx4_free_cmd_mailbox(dev, inbox);
+                return PTR_ERR(outbox);
+        }
+
+        inmad = (struct mlx4_mad_ifc *)(inbox->buf);
+        outmad = (struct mlx4_mad_ifc *)(outbox->buf);
+
+        inmad->method = 0x1; /* Get */
+        inmad->class_version = 0x1;
+        inmad->mgmt_class = 0x1;
+        inmad->base_version = 0x1;
+        inmad->attr_id = cpu_to_be16(0xFF60); /* Module Info */
+
+        if (offset < I2C_PAGE_SIZE && offset + size > I2C_PAGE_SIZE)
+                /* Cross pages reads are not allowed
+                 * read until offset 256 in low page
+                 */
+                size -= offset + size - I2C_PAGE_SIZE;
+
+        i2c_addr = I2C_ADDR_LOW;
+        if (offset >= I2C_PAGE_SIZE) {
+                /* Reset offset to high page */
+                i2c_addr = I2C_ADDR_HIGH;
+                offset -= I2C_PAGE_SIZE;
+        }
+
+        cable_info = (struct mlx4_cable_info *)inmad->data;
+        cable_info->dev_mem_address = cpu_to_be16(offset);
+        cable_info->page_num = 0;
+        cable_info->i2c_addr = i2c_addr;
+        cable_info->size = cpu_to_be16(size);
+
+        ret = mlx4_cmd_box(dev, inbox->dma, outbox->dma, port, 3,
+                           MLX4_CMD_MAD_IFC, MLX4_CMD_TIME_CLASS_C,
+                           MLX4_CMD_NATIVE);
+        if (ret)
+                goto out;
+
+        if (be16_to_cpu(outmad->status)) {
+                /* Mad returned with bad status */
+                ret = be16_to_cpu(outmad->status);
+                mlx4_warn(dev,
+                          "MLX4_CMD_MAD_IFC Get Module info attr(%x) port(%d) i2c_addr(%x) offset(%d) size(%d): Response Mad Status(%x) - %s\n",
+                          0xFF60, port, i2c_addr, offset, size,
+                          ret, cable_info_mad_err_str(ret));
+
+                if (i2c_addr == I2C_ADDR_HIGH &&
+                    MAD_STATUS_2_CABLE_ERR(ret) == CABLE_INF_I2C_ADDR)
+                        /* Some SFP cables do not support i2c slave
+                         * address 0x51 (high page), abort silently.
+                         */
+                        ret = 0;
+                else
+                        ret = -ret;
+                goto out;
+        }
+        cable_info = (struct mlx4_cable_info *)outmad->data;
+        memcpy(data, cable_info->data, size);
+        ret = size;
+out:
+        mlx4_free_cmd_mailbox(dev, inbox);
+        mlx4_free_cmd_mailbox(dev, outbox);
+        return ret;
+}
+EXPORT_SYMBOL(mlx4_get_module_info);
diff --git a/drivers/net/ethernet/natsemi/macsonic.c b/drivers/net/ethernet/natsemi/macsonic.c
index 9e4ddbba7036..66c2d50d5b8d 100644
--- a/drivers/net/ethernet/natsemi/macsonic.c
+++ b/drivers/net/ethernet/natsemi/macsonic.c
@@ -326,13 +326,9 @@ static int mac_onboard_sonic_probe(struct net_device *dev)
             macintosh_config->ident == MAC_MODEL_P588 ||
             macintosh_config->ident == MAC_MODEL_P575 ||
             macintosh_config->ident == MAC_MODEL_C610) {
-                unsigned long flags;
                 int card_present;
 
-                local_irq_save(flags);
                 card_present = hwreg_present((void*)ONBOARD_SONIC_REGISTERS);
-                local_irq_restore(flags);
-
                 if (!card_present) {
                         printk("none.\n");
                         return -ENODEV;
diff --git a/drivers/net/ethernet/realtek/atp.h b/drivers/net/ethernet/realtek/atp.h
index 040b13739947..32497f0e537c 100644
--- a/drivers/net/ethernet/realtek/atp.h
+++ b/drivers/net/ethernet/realtek/atp.h
@@ -6,10 +6,10 @@
 
 /* The header prepended to received packets. */
 struct rx_header {
-    ushort pad;                 /* Pad. */
-    ushort rx_count;
-    ushort rx_status;           /* Unknown bit assignments :-<.  */
-    ushort cur_addr;            /* Apparently the current buffer address(?) */
+        ushort pad;             /* Pad. */
+        ushort rx_count;
+        ushort rx_status;       /* Unknown bit assignments :-<.  */
+        ushort cur_addr;        /* Apparently the current buffer address(?) */
 };
 
 #define PAR_DATA        0
@@ -29,22 +29,25 @@ struct rx_header {
 #define RdAddr  0xC0
 #define HNib    0x10
 
-enum page0_regs
-{
-    /* The first six registers hold the ethernet physical station address. */
-    PAR0 = 0, PAR1 = 1, PAR2 = 2, PAR3 = 3, PAR4 = 4, PAR5 = 5,
-    TxCNT0 = 6, TxCNT1 = 7,             /* The transmit byte count. */
-    TxSTAT = 8, RxSTAT = 9,             /* Tx and Rx status. */
-    ISR = 10, IMR = 11,                 /* Interrupt status and mask. */
-    CMR1 = 12,                          /* Command register 1. */
-    CMR2 = 13,                          /* Command register 2. */
-    MODSEL = 14,                        /* Mode select register. */
-    MAR = 14,                           /* Memory address register (?). */
-    CMR2_h = 0x1d, };
-
-enum eepage_regs
-{ PROM_CMD = 6, PROM_DATA = 7 };        /* Note that PROM_CMD is in the "high" bits. */
+enum page0_regs {
+        /* The first six registers hold
+         * the ethernet physical station address.
+         */
+        PAR0 = 0, PAR1 = 1, PAR2 = 2, PAR3 = 3, PAR4 = 4, PAR5 = 5,
+        TxCNT0 = 6, TxCNT1 = 7,         /* The transmit byte count. */
+        TxSTAT = 8, RxSTAT = 9,         /* Tx and Rx status. */
+        ISR = 10, IMR = 11,             /* Interrupt status and mask. */
+        CMR1 = 12,                      /* Command register 1. */
+        CMR2 = 13,                      /* Command register 2. */
+        MODSEL = 14,            /* Mode select register. */
+        MAR = 14,                       /* Memory address register (?). */
+        CMR2_h = 0x1d,
+};
 
+enum eepage_regs {
+        PROM_CMD = 6,
+        PROM_DATA = 7   /* Note that PROM_CMD is in the "high" bits. */
+};
 
 #define ISR_TxOK        0x01
 #define ISR_RxOK        0x04
@@ -72,141 +75,146 @@ enum eepage_regs
 #define CMR2h_Normal    2       /* Accept physical and broadcast address. */
 #define CMR2h_PROMISC   3       /* Promiscuous mode. */
 
-/* An inline function used below: it differs from inb() by explicitly return an unsigned
-   char, saving a truncation. */
+/* An inline function used below: it differs from inb() by explicitly
+ * return an unsigned char, saving a truncation.
+ */
 static inline unsigned char inbyte(unsigned short port)
 {
-    unsigned char _v;
-    __asm__ __volatile__ ("inb %w1,%b0" :"=a" (_v):"d" (port));
-    return _v;
+        unsigned char _v;
+
+        __asm__ __volatile__ ("inb %w1,%b0" : "=a" (_v) : "d" (port));
+        return _v;
 }
 
 /* Read register OFFSET.
-   This command should always be terminated with read_end(). */
+ * This command should always be terminated with read_end().
+ */
 static inline unsigned char read_nibble(short port, unsigned char offset)
 {
-    unsigned char retval;
-    outb(EOC+offset, port + PAR_DATA);
-    outb(RdAddr+offset, port + PAR_DATA);
-    inbyte(port + PAR_STATUS);          /* Settling time delay */
-    retval = inbyte(port + PAR_STATUS);
-    outb(EOC+offset, port + PAR_DATA);
-
-    return retval;
+        unsigned char retval;
+
+        outb(EOC+offset, port + PAR_DATA);
+        outb(RdAddr+offset, port + PAR_DATA);
+        inbyte(port + PAR_STATUS);      /* Settling time delay */
+        retval = inbyte(port + PAR_STATUS);
+        outb(EOC+offset, port + PAR_DATA);
+
+        return retval;
 }
 
 /* Functions for bulk data read.  The interrupt line is always disabled. */
 /* Get a byte using read mode 0, reading data from the control lines. */
 static inline unsigned char read_byte_mode0(short ioaddr)
 {
-    unsigned char low_nib;
-
-    outb(Ctrl_LNibRead, ioaddr + PAR_CONTROL);
-    inbyte(ioaddr + PAR_STATUS);
-    low_nib = (inbyte(ioaddr + PAR_STATUS) >> 3) & 0x0f;
-    outb(Ctrl_HNibRead, ioaddr + PAR_CONTROL);
-    inbyte(ioaddr + PAR_STATUS);        /* Settling time delay -- needed!  */
-    inbyte(ioaddr + PAR_STATUS);        /* Settling time delay -- needed!  */
-    return low_nib | ((inbyte(ioaddr + PAR_STATUS) << 1) & 0xf0);
+        unsigned char low_nib;
+
+        outb(Ctrl_LNibRead, ioaddr + PAR_CONTROL);
+        inbyte(ioaddr + PAR_STATUS);
+        low_nib = (inbyte(ioaddr + PAR_STATUS) >> 3) & 0x0f;
+        outb(Ctrl_HNibRead, ioaddr + PAR_CONTROL);
+        inbyte(ioaddr + PAR_STATUS);    /* Settling time delay -- needed!  */
+        inbyte(ioaddr + PAR_STATUS);    /* Settling time delay -- needed!  */
+        return low_nib | ((inbyte(ioaddr + PAR_STATUS) << 1) & 0xf0);
 }
 
 /* The same as read_byte_mode0(), but does multiple inb()s for stability. */
 static inline unsigned char read_byte_mode2(short ioaddr)
 {
-    unsigned char low_nib;
-
-    outb(Ctrl_LNibRead, ioaddr + PAR_CONTROL);
-    inbyte(ioaddr + PAR_STATUS);
-    low_nib = (inbyte(ioaddr + PAR_STATUS) >> 3) & 0x0f;
-    outb(Ctrl_HNibRead, ioaddr + PAR_CONTROL);
-    inbyte(ioaddr + PAR_STATUS);        /* Settling time delay -- needed!  */
-    return low_nib | ((inbyte(ioaddr + PAR_STATUS) << 1) & 0xf0);
+        unsigned char low_nib;
+
+        outb(Ctrl_LNibRead, ioaddr + PAR_CONTROL);
+        inbyte(ioaddr + PAR_STATUS);
+        low_nib = (inbyte(ioaddr + PAR_STATUS) >> 3) & 0x0f;
+        outb(Ctrl_HNibRead, ioaddr + PAR_CONTROL);
+        inbyte(ioaddr + PAR_STATUS);    /* Settling time delay -- needed!  */
+        return low_nib | ((inbyte(ioaddr + PAR_STATUS) << 1) & 0xf0);
 }
 
 /* Read a byte through the data register. */
 static inline unsigned char read_byte_mode4(short ioaddr)
 {
-    unsigned char low_nib;
+        unsigned char low_nib;
 
-    outb(RdAddr | MAR, ioaddr + PAR_DATA);
-    low_nib = (inbyte(ioaddr + PAR_STATUS) >> 3) & 0x0f;
-    outb(RdAddr | HNib | MAR, ioaddr + PAR_DATA);
-    return low_nib | ((inbyte(ioaddr + PAR_STATUS) << 1) & 0xf0);
+        outb(RdAddr | MAR, ioaddr + PAR_DATA);
+        low_nib = (inbyte(ioaddr + PAR_STATUS) >> 3) & 0x0f;
+        outb(RdAddr | HNib | MAR, ioaddr + PAR_DATA);
+        return low_nib | ((inbyte(ioaddr + PAR_STATUS) << 1) & 0xf0);
 }
 
 /* Read a byte through the data register, double reading to allow settling. */
 static inline unsigned char read_byte_mode6(short ioaddr)
 {
-    unsigned char low_nib;
-
-    outb(RdAddr | MAR, ioaddr + PAR_DATA);
-    inbyte(ioaddr + PAR_STATUS);
-    low_nib = (inbyte(ioaddr + PAR_STATUS) >> 3) & 0x0f;
-    outb(RdAddr | HNib | MAR, ioaddr + PAR_DATA);
-    inbyte(ioaddr + PAR_STATUS);
-    return low_nib | ((inbyte(ioaddr + PAR_STATUS) << 1) & 0xf0);
+        unsigned char low_nib;
+
+        outb(RdAddr | MAR, ioaddr + PAR_DATA);
+        inbyte(ioaddr + PAR_STATUS);
+        low_nib = (inbyte(ioaddr + PAR_STATUS) >> 3) & 0x0f;
+        outb(RdAddr | HNib | MAR, ioaddr + PAR_DATA);
+        inbyte(ioaddr + PAR_STATUS);
+        return low_nib | ((inbyte(ioaddr + PAR_STATUS) << 1) & 0xf0);
 }
 
 static inline void
 write_reg(short port, unsigned char reg, unsigned char value)
 {
-    unsigned char outval;
-    outb(EOC | reg, port + PAR_DATA);
-    outval = WrAddr | reg;
-    outb(outval, port + PAR_DATA);
-    outb(outval, port + PAR_DATA);      /* Double write for PS/2. */
-
-    outval &= 0xf0;
-    outval |= value;
-    outb(outval, port + PAR_DATA);
-    outval &= 0x1f;
-    outb(outval, port + PAR_DATA);
-    outb(outval, port + PAR_DATA);
-
-    outb(EOC | outval, port + PAR_DATA);
+        unsigned char outval;
+
+        outb(EOC | reg, port + PAR_DATA);
+        outval = WrAddr | reg;
+        outb(outval, port + PAR_DATA);
+        outb(outval, port + PAR_DATA);  /* Double write for PS/2. */
+
+        outval &= 0xf0;
+        outval |= value;
+        outb(outval, port + PAR_DATA);
+        outval &= 0x1f;
+        outb(outval, port + PAR_DATA);
+        outb(outval, port + PAR_DATA);
+
+        outb(EOC | outval, port + PAR_DATA);
 }
 
 static inline void
 write_reg_high(short port, unsigned char reg, unsigned char value)
 {
-    unsigned char outval = EOC | HNib | reg;
+        unsigned char outval = EOC | HNib | reg;
 
-    outb(outval, port + PAR_DATA);
-    outval &= WrAddr | HNib | 0x0f;
-    outb(outval, port + PAR_DATA);
-    outb(outval, port + PAR_DATA);      /* Double write for PS/2. */
+        outb(outval, port + PAR_DATA);
+        outval &= WrAddr | HNib | 0x0f;
+        outb(outval, port + PAR_DATA);
+        outb(outval, port + PAR_DATA);  /* Double write for PS/2. */
 
-    outval = WrAddr | HNib | value;
-    outb(outval, port + PAR_DATA);
-    outval &= HNib | 0x0f;              /* HNib | value */
-    outb(outval, port + PAR_DATA);
-    outb(outval, port + PAR_DATA);
+        outval = WrAddr | HNib | value;
+        outb(outval, port + PAR_DATA);
+        outval &= HNib | 0x0f;          /* HNib | value */
+        outb(outval, port + PAR_DATA);
+        outb(outval, port + PAR_DATA);
 
-    outb(EOC | HNib | outval, port + PAR_DATA);
+        outb(EOC | HNib | outval, port + PAR_DATA);
 }
 
 /* Write a byte out using nibble mode.  The low nibble is written first. */
 static inline void
 write_reg_byte(short port, unsigned char reg, unsigned char value)
 {
-    unsigned char outval;
-    outb(EOC | reg, port + PAR_DATA);   /* Reset the address register. */
-    outval = WrAddr | reg;
-    outb(outval, port + PAR_DATA);
-    outb(outval, port + PAR_DATA);      /* Double write for PS/2. */
-
-    outb((outval & 0xf0) | (value & 0x0f), port + PAR_DATA);
-    outb(value & 0x0f, port + PAR_DATA);
-    value >>= 4;
-    outb(value, port + PAR_DATA);
-    outb(0x10 | value, port + PAR_DATA);
-    outb(0x10 | value, port + PAR_DATA);
-
-    outb(EOC  | value, port + PAR_DATA);        /* Reset the address register. */
+        unsigned char outval;
+
+        outb(EOC | reg, port + PAR_DATA); /* Reset the address register. */
+        outval = WrAddr | reg;
+        outb(outval, port + PAR_DATA);
+        outb(outval, port + PAR_DATA);  /* Double write for PS/2. */
+
+        outb((outval & 0xf0) | (value & 0x0f), port + PAR_DATA);
+        outb(value & 0x0f, port + PAR_DATA);
+        value >>= 4;
+        outb(value, port + PAR_DATA);
+        outb(0x10 | value, port + PAR_DATA);
+        outb(0x10 | value, port + PAR_DATA);
+
+        outb(EOC  | value, port + PAR_DATA); /* Reset the address register. */
 }
 
-/*
- * Bulk data writes to the packet buffer.  The interrupt line remains enabled.
+/* Bulk data writes to the packet buffer.  The interrupt line remains enabled.
  * The first, faster method uses only the dataport (data modes 0, 2 & 4).
  * The second (backup) method uses data and control regs (modes 1, 3 & 5).
  * It should only be needed when there is skew between the individual data
@@ -214,28 +222,28 @@ write_reg_byte(short port, unsigned char reg, unsigned char value)
  */
 static inline void write_byte_mode0(short ioaddr, unsigned char value)
 {
-    outb(value & 0x0f, ioaddr + PAR_DATA);
-    outb((value>>4) | 0x10, ioaddr + PAR_DATA);
+        outb(value & 0x0f, ioaddr + PAR_DATA);
+        outb((value>>4) | 0x10, ioaddr + PAR_DATA);
 }
 
 static inline void write_byte_mode1(short ioaddr, unsigned char value)
 {
-    outb(value & 0x0f, ioaddr + PAR_DATA);
-    outb(Ctrl_IRQEN | Ctrl_LNibWrite, ioaddr + PAR_CONTROL);
-    outb((value>>4) | 0x10, ioaddr + PAR_DATA);
-    outb(Ctrl_IRQEN | Ctrl_HNibWrite, ioaddr + PAR_CONTROL);
+        outb(value & 0x0f, ioaddr + PAR_DATA);
+        outb(Ctrl_IRQEN | Ctrl_LNibWrite, ioaddr + PAR_CONTROL);
+        outb((value>>4) | 0x10, ioaddr + PAR_DATA);
+        outb(Ctrl_IRQEN | Ctrl_HNibWrite, ioaddr + PAR_CONTROL);
 }
 
 /* Write 16bit VALUE to the packet buffer: the same as above just doubled. */
 static inline void write_word_mode0(short ioaddr, unsigned short value)
 {
-    outb(value & 0x0f, ioaddr + PAR_DATA);
-    value >>= 4;
-    outb((value & 0x0f) | 0x10, ioaddr + PAR_DATA);
-    value >>= 4;
-    outb(value & 0x0f, ioaddr + PAR_DATA);
-    value >>= 4;
-    outb((value & 0x0f) | 0x10, ioaddr + PAR_DATA);
+        outb(value & 0x0f, ioaddr + PAR_DATA);
+        value >>= 4;
+        outb((value & 0x0f) | 0x10, ioaddr + PAR_DATA);
+        value >>= 4;
+        outb(value & 0x0f, ioaddr + PAR_DATA);
+        value >>= 4;
+        outb((value & 0x0f) | 0x10, ioaddr + PAR_DATA);
 }
 
 /*  EEPROM_Ctrl bits. */
@@ -248,10 +256,10 @@ static inline void write_word_mode0(short ioaddr, unsigned short value)
 
 /* Delay between EEPROM clock transitions. */
 #define eeprom_delay(ticks) \
-do { int _i = 40; while (--_i > 0) { __SLOW_DOWN_IO; }} while (0)
+do { int _i = 40; while (--_i > 0) { __SLOW_DOWN_IO; } } while (0)
 
 /* The EEPROM commands include the alway-set leading bit. */
 #define EE_WRITE_CMD(offset)    (((5 << 6) + (offset)) << 17)
-#define EE_READ(offset)         (((6 << 6) + (offset)) << 17)
+#define EE_READ(offset)         (((6 << 6) + (offset)) << 17)
 #define EE_ERASE(offset)        (((7 << 6) + (offset)) << 17)
 #define EE_CMD_SIZE     27      /* The command+address+data size. */
diff --git a/drivers/net/ethernet/renesas/sh_eth.c b/drivers/net/ethernet/renesas/sh_eth.c
index 60e9c2cd051e..dbe860650bfe 100644
--- a/drivers/net/ethernet/renesas/sh_eth.c
+++ b/drivers/net/ethernet/renesas/sh_eth.c
@@ -2769,10 +2769,6 @@ static int sh_eth_drv_probe(struct platform_device *pdev)
 
         /* get base addr */
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (unlikely(res == NULL)) {
-                dev_err(&pdev->dev, "invalid resource\n");
-                return -EINVAL;
-        }
 
         ndev = alloc_etherdev(sizeof(struct sh_eth_private));
         if (!ndev)
@@ -2781,8 +2777,6 @@ static int sh_eth_drv_probe(struct platform_device *pdev)
         pm_runtime_enable(&pdev->dev);
         pm_runtime_get_sync(&pdev->dev);
 
-        /* The sh Ether-specific entries in the device structure. */
-        ndev->base_addr = res->start;
         devno = pdev->id;
         if (devno < 0)
                 devno = 0;
@@ -2806,6 +2800,8 @@ static int sh_eth_drv_probe(struct platform_device *pdev)
                 goto out_release;
         }
 
+        ndev->base_addr = res->start;
+
         spin_lock_init(&mdp->lock);
         mdp->pdev = pdev;
 
diff --git a/drivers/net/ethernet/samsung/sxgbe/sxgbe_platform.c b/drivers/net/ethernet/samsung/sxgbe/sxgbe_platform.c
index b147d469a799..7fd6e275d1c2 100644
--- a/drivers/net/ethernet/samsung/sxgbe/sxgbe_platform.c
+++ b/drivers/net/ethernet/samsung/sxgbe/sxgbe_platform.c
@@ -90,9 +90,6 @@ static int sxgbe_platform_probe(struct platform_device *pdev)
 
         /* Get memory resource */
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res)
-                goto err_out;
-
         addr = devm_ioremap_resource(dev, res);
         if (IS_ERR(addr))
                 return PTR_ERR(addr);
diff --git a/drivers/net/ethernet/sun/sunvnet.c b/drivers/net/ethernet/sun/sunvnet.c
index 3652afd3ec78..e7bb63b2d525 100644
--- a/drivers/net/ethernet/sun/sunvnet.c
+++ b/drivers/net/ethernet/sun/sunvnet.c
@@ -40,6 +40,8 @@ MODULE_DESCRIPTION("Sun LDOM virtual network driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_MODULE_VERSION);
 
+#define VNET_MAX_TXQS           16
+
 /* Heuristic for the number of times to exponentially backoff and
  * retry sending an LDC trigger when EAGAIN is encountered
  */
@@ -311,9 +313,7 @@ static int vnet_rx_one(struct vnet_port *port, unsigned int len,
 
         dev->stats.rx_packets++;
         dev->stats.rx_bytes += len;
-
-        netif_rx(skb);
-
+        napi_gro_receive(&port->napi, skb);
         return 0;
 
 out_free_skb:
@@ -430,6 +430,7 @@ static int vnet_walk_rx_one(struct vnet_port *port,
         struct vio_driver_state *vio = &port->vio;
         int err;
 
+        BUG_ON(desc == NULL);
         if (IS_ERR(desc))
                 return PTR_ERR(desc);
 
@@ -456,10 +457,11 @@ static int vnet_walk_rx_one(struct vnet_port *port,
 }
 
 static int vnet_walk_rx(struct vnet_port *port, struct vio_dring_state *dr,
-                        u32 start, u32 end)
+                        u32 start, u32 end, int *npkts, int budget)
 {
         struct vio_driver_state *vio = &port->vio;
         int ack_start = -1, ack_end = -1;
+        bool send_ack = true;
 
         end = (end == (u32) -1) ? prev_idx(start, dr) : next_idx(end, dr);
 
@@ -471,6 +473,7 @@ static int vnet_walk_rx(struct vnet_port *port, struct vio_dring_state *dr,
                         return err;
                 if (err != 0)
                         break;
+                (*npkts)++;
                 if (ack_start == -1)
                         ack_start = start;
                 ack_end = start;
@@ -482,13 +485,26 @@ static int vnet_walk_rx(struct vnet_port *port, struct vio_dring_state *dr,
                                 return err;
                         ack_start = -1;
                 }
+                if ((*npkts) >= budget) {
+                        send_ack = false;
+                        break;
+                }
         }
         if (unlikely(ack_start == -1))
                 ack_start = ack_end = prev_idx(start, dr);
-        return vnet_send_ack(port, dr, ack_start, ack_end, VIO_DRING_STOPPED);
+        if (send_ack) {
+                port->napi_resume = false;
+                return vnet_send_ack(port, dr, ack_start, ack_end,
+                                     VIO_DRING_STOPPED);
+        } else  {
+                port->napi_resume = true;
+                port->napi_stop_idx = ack_end;
+                return 1;
+        }
 }
 
-static int vnet_rx(struct vnet_port *port, void *msgbuf)
+static int vnet_rx(struct vnet_port *port, void *msgbuf, int *npkts,
+                   int budget)
 {
         struct vio_dring_data *pkt = msgbuf;
         struct vio_dring_state *dr = &port->vio.drings[VIO_DRIVER_RX_RING];
@@ -505,11 +521,13 @@ static int vnet_rx(struct vnet_port *port, void *msgbuf)
                 return 0;
         }
 
-        dr->rcv_nxt++;
+        if (!port->napi_resume)
+                dr->rcv_nxt++;
 
         /* XXX Validate pkt->start_idx and pkt->end_idx XXX */
 
-        return vnet_walk_rx(port, dr, pkt->start_idx, pkt->end_idx);
+        return vnet_walk_rx(port, dr, pkt->start_idx, pkt->end_idx,
+                            npkts, budget);
 }
 
 static int idx_is_pending(struct vio_dring_state *dr, u32 end)
@@ -535,6 +553,8 @@ static int vnet_ack(struct vnet_port *port, void *msgbuf)
         struct vnet *vp;
         u32 end;
         struct vio_net_desc *desc;
+        struct netdev_queue *txq;
+
         if (unlikely(pkt->tag.stype_env != VIO_DRING_DATA))
                 return 0;
 
@@ -542,9 +562,12 @@ static int vnet_ack(struct vnet_port *port, void *msgbuf)
         if (unlikely(!idx_is_pending(dr, end)))
                 return 0;
 
+        vp = port->vp;
+        dev = vp->dev;
         /* sync for race conditions with vnet_start_xmit() and tell xmit it
          * is time to send a trigger.
          */
+        netif_tx_lock(dev);
         dr->cons = next_idx(end, dr);
         desc = vio_dring_entry(dr, dr->cons);
         if (desc->hdr.state == VIO_DESC_READY && port->start_cons) {
@@ -559,11 +582,10 @@ static int vnet_ack(struct vnet_port *port, void *msgbuf)
         } else {
                 port->start_cons = true;
         }
+        netif_tx_unlock(dev);
 
-
-        vp = port->vp;
-        dev = vp->dev;
-        if (unlikely(netif_queue_stopped(dev) &&
+        txq = netdev_get_tx_queue(dev, port->q_index);
+        if (unlikely(netif_tx_queue_stopped(txq) &&
                      vnet_tx_dring_avail(dr) >= VNET_TX_WAKEUP_THRESH(dr)))
                 return 1;
 
@@ -591,58 +613,62 @@ static int handle_mcast(struct vnet_port *port, void *msgbuf)
         return 0;
 }
 
-static void maybe_tx_wakeup(unsigned long param)
+/* Got back a STOPPED LDC message on port. If the queue is stopped,
+ * wake it up so that we'll send out another START message at the
+ * next TX.
+ */
+static void maybe_tx_wakeup(struct vnet_port *port)
 {
-        struct vnet *vp = (struct vnet *)param;
-        struct net_device *dev = vp->dev;
+        struct netdev_queue *txq;
 
-        netif_tx_lock(dev);
-        if (likely(netif_queue_stopped(dev))) {
-                struct vnet_port *port;
-                int wake = 1;
-
-                list_for_each_entry(port, &vp->port_list, list) {
-                        struct vio_dring_state *dr;
+        txq = netdev_get_tx_queue(port->vp->dev, port->q_index);
+        __netif_tx_lock(txq, smp_processor_id());
+        if (likely(netif_tx_queue_stopped(txq))) {
+                struct vio_dring_state *dr;
 
-                        dr = &port->vio.drings[VIO_DRIVER_TX_RING];
-                        if (vnet_tx_dring_avail(dr) <
-                            VNET_TX_WAKEUP_THRESH(dr)) {
-                                wake = 0;
-                                break;
-                        }
-                }
-                if (wake)
-                        netif_wake_queue(dev);
+                dr = &port->vio.drings[VIO_DRIVER_TX_RING];
+                        netif_tx_wake_queue(txq);
         }
-        netif_tx_unlock(dev);
+        __netif_tx_unlock(txq);
 }
 
-static void vnet_event(void *arg, int event)
+static inline bool port_is_up(struct vnet_port *vnet)
+{
+        struct vio_driver_state *vio = &vnet->vio;
+
+        return !!(vio->hs_state & VIO_HS_COMPLETE);
+}
+
+static int vnet_event_napi(struct vnet_port *port, int budget)
 {
-        struct vnet_port *port = arg;
         struct vio_driver_state *vio = &port->vio;
-        unsigned long flags;
         int tx_wakeup, err;
+        int npkts = 0;
+        int event = (port->rx_event & LDC_EVENT_RESET);
 
-        spin_lock_irqsave(&vio->lock, flags);
-
+ldc_ctrl:
         if (unlikely(event == LDC_EVENT_RESET ||
                      event == LDC_EVENT_UP)) {
                 vio_link_state_change(vio, event);
-                spin_unlock_irqrestore(&vio->lock, flags);
 
                 if (event == LDC_EVENT_RESET) {
                         port->rmtu = 0;
                         vio_port_up(vio);
                 }
-                return;
+                port->rx_event = 0;
+                return 0;
         }
+        /* We may have multiple LDC events in rx_event. Unroll send_events() */
+        event = (port->rx_event & LDC_EVENT_UP);
+        port->rx_event &= ~(LDC_EVENT_RESET|LDC_EVENT_UP);
+        if (event == LDC_EVENT_UP)
+                goto ldc_ctrl;
+        event = port->rx_event;
+        if (!(event & LDC_EVENT_DATA_READY))
+                return 0;
 
-        if (unlikely(event != LDC_EVENT_DATA_READY)) {
-                pr_warn("Unexpected LDC event %d\n", event);
-                spin_unlock_irqrestore(&vio->lock, flags);
-                return;
-        }
+        /* we dont expect any other bits than RESET, UP, DATA_READY */
+        BUG_ON(event != LDC_EVENT_DATA_READY);
 
         tx_wakeup = err = 0;
         while (1) {
@@ -651,6 +677,21 @@ static void vnet_event(void *arg, int event)
                         u64 raw[8];
                 } msgbuf;
 
+                if (port->napi_resume) {
+                        struct vio_dring_data *pkt =
+                                (struct vio_dring_data *)&msgbuf;
+                        struct vio_dring_state *dr =
+                                &port->vio.drings[VIO_DRIVER_RX_RING];
+
+                        pkt->tag.type = VIO_TYPE_DATA;
+                        pkt->tag.stype = VIO_SUBTYPE_INFO;
+                        pkt->tag.stype_env = VIO_DRING_DATA;
+                        pkt->seq = dr->rcv_nxt;
+                        pkt->start_idx = next_idx(port->napi_stop_idx, dr);
+                        pkt->end_idx = -1;
+                        goto napi_resume;
+                }
+ldc_read:
                 err = ldc_read(vio->lp, &msgbuf, sizeof(msgbuf));
                 if (unlikely(err < 0)) {
                         if (err == -ECONNRESET)
@@ -667,10 +708,22 @@ static void vnet_event(void *arg, int event)
                 err = vio_validate_sid(vio, &msgbuf.tag);
                 if (err < 0)
                         break;
-
+napi_resume:
                 if (likely(msgbuf.tag.type == VIO_TYPE_DATA)) {
                         if (msgbuf.tag.stype == VIO_SUBTYPE_INFO) {
-                                err = vnet_rx(port, &msgbuf);
+                                if (!port_is_up(port)) {
+                                        /* failures like handshake_failure()
+                                         * may have cleaned up dring, but
+                                         * NAPI polling may bring us here.
+                                         */
+                                        err = -ECONNRESET;
+                                        break;
+                                }
+                                err = vnet_rx(port, &msgbuf, &npkts, budget);
+                                if (npkts >= budget)
+                                        break;
+                                if (npkts == 0 && err != -ECONNRESET)
+                                        goto ldc_read;
                         } else if (msgbuf.tag.stype == VIO_SUBTYPE_ACK) {
                                 err = vnet_ack(port, &msgbuf);
                                 if (err > 0)
@@ -691,15 +744,34 @@ static void vnet_event(void *arg, int event)
                 if (err == -ECONNRESET)
                         break;
         }
-        spin_unlock(&vio->lock);
-        /* Kick off a tasklet to wake the queue.  We cannot call
-         * maybe_tx_wakeup directly here because we could deadlock on
-         * netif_tx_lock() with dev_watchdog()
-         */
         if (unlikely(tx_wakeup && err != -ECONNRESET))
-                tasklet_schedule(&port->vp->vnet_tx_wakeup);
+                maybe_tx_wakeup(port);
+        return npkts;
+}
+
+static int vnet_poll(struct napi_struct *napi, int budget)
+{
+        struct vnet_port *port = container_of(napi, struct vnet_port, napi);
+        struct vio_driver_state *vio = &port->vio;
+        int processed = vnet_event_napi(port, budget);
+
+        if (processed < budget) {
+                napi_complete(napi);
+                port->rx_event &= ~LDC_EVENT_DATA_READY;
+                vio_set_intr(vio->vdev->rx_ino, HV_INTR_ENABLED);
+        }
+        return processed;
+}
+
+static void vnet_event(void *arg, int event)
+{
+        struct vnet_port *port = arg;
+        struct vio_driver_state *vio = &port->vio;
+
+        port->rx_event |= event;
+        vio_set_intr(vio->vdev->rx_ino, HV_INTR_DISABLED);
+        napi_schedule(&port->napi);
 
-        local_irq_restore(flags);
 }
 
 static int __vnet_tx_trigger(struct vnet_port *port, u32 start)
@@ -746,26 +818,19 @@ static int __vnet_tx_trigger(struct vnet_port *port, u32 start)
         return err;
 }
 
-static inline bool port_is_up(struct vnet_port *vnet)
-{
-        struct vio_driver_state *vio = &vnet->vio;
-
-        return !!(vio->hs_state & VIO_HS_COMPLETE);
-}
-
 struct vnet_port *__tx_port_find(struct vnet *vp, struct sk_buff *skb)
 {
         unsigned int hash = vnet_hashfn(skb->data);
         struct hlist_head *hp = &vp->port_hash[hash];
         struct vnet_port *port;
 
-        hlist_for_each_entry(port, hp, hash) {
+        hlist_for_each_entry_rcu(port, hp, hash) {
                 if (!port_is_up(port))
                         continue;
                 if (ether_addr_equal(port->raddr, skb->data))
                         return port;
         }
-        list_for_each_entry(port, &vp->port_list, list) {
+        list_for_each_entry_rcu(port, &vp->port_list, list) {
                 if (!port->switch_port)
                         continue;
                 if (!port_is_up(port))
@@ -775,18 +840,6 @@ struct vnet_port *__tx_port_find(struct vnet *vp, struct sk_buff *skb)
         return NULL;
 }
 
-struct vnet_port *tx_port_find(struct vnet *vp, struct sk_buff *skb)
-{
-        struct vnet_port *ret;
-        unsigned long flags;
-
-        spin_lock_irqsave(&vp->lock, flags);
-        ret = __tx_port_find(vp, skb);
-        spin_unlock_irqrestore(&vp->lock, flags);
-
-        return ret;
-}
-
 static struct sk_buff *vnet_clean_tx_ring(struct vnet_port *port,
                                           unsigned *pending)
 {
@@ -847,11 +900,10 @@ static void vnet_clean_timer_expire(unsigned long port0)
         struct vnet_port *port = (struct vnet_port *)port0;
         struct sk_buff *freeskbs;
         unsigned pending;
-        unsigned long flags;
 
-        spin_lock_irqsave(&port->vio.lock, flags);
+        netif_tx_lock(port->vp->dev);
         freeskbs = vnet_clean_tx_ring(port, &pending);
-        spin_unlock_irqrestore(&port->vio.lock, flags);
+        netif_tx_unlock(port->vp->dev);
 
         vnet_free_skbs(freeskbs);
 
@@ -898,28 +950,39 @@ static inline struct sk_buff *vnet_skb_shape(struct sk_buff *skb, void **pstart,
         return skb;
 }
 
+static u16
+vnet_select_queue(struct net_device *dev, struct sk_buff *skb,
+                  void *accel_priv, select_queue_fallback_t fallback)
+{
+        struct vnet *vp = netdev_priv(dev);
+        struct vnet_port *port = __tx_port_find(vp, skb);
+
+        return port->q_index;
+}
+
 static int vnet_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
         struct vnet *vp = netdev_priv(dev);
-        struct vnet_port *port = tx_port_find(vp, skb);
+        struct vnet_port *port = NULL;
         struct vio_dring_state *dr;
         struct vio_net_desc *d;
-        unsigned long flags;
         unsigned int len;
         struct sk_buff *freeskbs = NULL;
         int i, err, txi;
         void *start = NULL;
         int nlen = 0;
         unsigned pending = 0;
-
-        if (unlikely(!port))
-                goto out_dropped;
+        struct netdev_queue *txq;
 
         skb = vnet_skb_shape(skb, &start, &nlen);
-
         if (unlikely(!skb))
                 goto out_dropped;
 
+        rcu_read_lock();
+        port = __tx_port_find(vp, skb);
+        if (unlikely(!port))
+                goto out_dropped;
+
         if (skb->len > port->rmtu) {
                 unsigned long localmtu = port->rmtu - ETH_HLEN;
 
@@ -937,6 +1000,7 @@ static int vnet_start_xmit(struct sk_buff *skb, struct net_device *dev)
                         fl4.saddr = ip_hdr(skb)->saddr;
 
                         rt = ip_route_output_key(dev_net(dev), &fl4);
+                        rcu_read_unlock();
                         if (!IS_ERR(rt)) {
                                 skb_dst_set(skb, &rt->dst);
                                 icmp_send(skb, ICMP_DEST_UNREACH,
@@ -951,18 +1015,18 @@ static int vnet_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 goto out_dropped;
         }
 
-        spin_lock_irqsave(&port->vio.lock, flags);
-
         dr = &port->vio.drings[VIO_DRIVER_TX_RING];
+        i = skb_get_queue_mapping(skb);
+        txq = netdev_get_tx_queue(dev, i);
         if (unlikely(vnet_tx_dring_avail(dr) < 1)) {
-                if (!netif_queue_stopped(dev)) {
-                        netif_stop_queue(dev);
+                if (!netif_tx_queue_stopped(txq)) {
+                        netif_tx_stop_queue(txq);
 
                         /* This is a hard error, log it. */
                         netdev_err(dev, "BUG! Tx Ring full when queue awake!\n");
                         dev->stats.tx_errors++;
                 }
-                spin_unlock_irqrestore(&port->vio.lock, flags);
+                rcu_read_unlock();
                 return NETDEV_TX_BUSY;
         }
 
@@ -986,7 +1050,7 @@ static int vnet_start_xmit(struct sk_buff *skb, struct net_device *dev)
                              (LDC_MAP_SHADOW | LDC_MAP_DIRECT | LDC_MAP_RW));
         if (err < 0) {
                 netdev_info(dev, "tx buffer map error %d\n", err);
-                goto out_dropped_unlock;
+                goto out_dropped;
         }
         port->tx_bufs[txi].ncookies = err;
 
@@ -1039,7 +1103,7 @@ static int vnet_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 netdev_info(dev, "TX trigger error %d\n", err);
                 d->hdr.state = VIO_DESC_FREE;
                 dev->stats.tx_carrier_errors++;
-                goto out_dropped_unlock;
+                goto out_dropped;
         }
 
 ldc_start_done:
@@ -1050,31 +1114,29 @@ ldc_start_done:
 
         dr->prod = (dr->prod + 1) & (VNET_TX_RING_SIZE - 1);
         if (unlikely(vnet_tx_dring_avail(dr) < 1)) {
-                netif_stop_queue(dev);
+                netif_tx_stop_queue(txq);
                 if (vnet_tx_dring_avail(dr) > VNET_TX_WAKEUP_THRESH(dr))
-                        netif_wake_queue(dev);
+                        netif_tx_wake_queue(txq);
         }
 
-        spin_unlock_irqrestore(&port->vio.lock, flags);
+        (void)mod_timer(&port->clean_timer, jiffies + VNET_CLEAN_TIMEOUT);
+        rcu_read_unlock();
 
         vnet_free_skbs(freeskbs);
 
-        (void)mod_timer(&port->clean_timer, jiffies + VNET_CLEAN_TIMEOUT);
-
         return NETDEV_TX_OK;
 
-out_dropped_unlock:
-        spin_unlock_irqrestore(&port->vio.lock, flags);
-
 out_dropped:
-        if (skb)
-                dev_kfree_skb(skb);
-        vnet_free_skbs(freeskbs);
         if (pending)
                 (void)mod_timer(&port->clean_timer,
                                 jiffies + VNET_CLEAN_TIMEOUT);
         else if (port)
                 del_timer(&port->clean_timer);
+        if (port)
+                rcu_read_unlock();
+        if (skb)
+                dev_kfree_skb(skb);
+        vnet_free_skbs(freeskbs);
         dev->stats.tx_dropped++;
         return NETDEV_TX_OK;
 }
@@ -1087,14 +1149,14 @@ static void vnet_tx_timeout(struct net_device *dev)
 static int vnet_open(struct net_device *dev)
 {
         netif_carrier_on(dev);
-        netif_start_queue(dev);
+        netif_tx_start_all_queues(dev);
 
         return 0;
 }
 
 static int vnet_close(struct net_device *dev)
 {
-        netif_stop_queue(dev);
+        netif_tx_stop_all_queues(dev);
         netif_carrier_off(dev);
 
         return 0;
@@ -1204,18 +1266,17 @@ static void vnet_set_rx_mode(struct net_device *dev)
 {
         struct vnet *vp = netdev_priv(dev);
         struct vnet_port *port;
-        unsigned long flags;
 
-        spin_lock_irqsave(&vp->lock, flags);
-        if (!list_empty(&vp->port_list)) {
-                port = list_entry(vp->port_list.next, struct vnet_port, list);
+        rcu_read_lock();
+        list_for_each_entry_rcu(port, &vp->port_list, list) {
 
                 if (port->switch_port) {
                         __update_mc_list(vp, dev);
                         __send_mc_list(vp, port);
+                        break;
                 }
         }
-        spin_unlock_irqrestore(&vp->lock, flags);
+        rcu_read_unlock();
 }
 
 static int vnet_change_mtu(struct net_device *dev, int new_mtu)
@@ -1342,6 +1403,21 @@ err_out:
         return err;
 }
 
+#ifdef CONFIG_NET_POLL_CONTROLLER
+static void vnet_poll_controller(struct net_device *dev)
+{
+        struct vnet *vp = netdev_priv(dev);
+        struct vnet_port *port;
+        unsigned long flags;
+
+        spin_lock_irqsave(&vp->lock, flags);
+        if (!list_empty(&vp->port_list)) {
+                port = list_entry(vp->port_list.next, struct vnet_port, list);
+                napi_schedule(&port->napi);
+        }
+        spin_unlock_irqrestore(&vp->lock, flags);
+}
+#endif
 static LIST_HEAD(vnet_list);
 static DEFINE_MUTEX(vnet_list_mutex);
 
@@ -1354,6 +1430,10 @@ static const struct net_device_ops vnet_ops = {
         .ndo_tx_timeout         = vnet_tx_timeout,
         .ndo_change_mtu         = vnet_change_mtu,
         .ndo_start_xmit         = vnet_start_xmit,
+        .ndo_select_queue       = vnet_select_queue,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = vnet_poll_controller,
+#endif
 };
 
 static struct vnet *vnet_new(const u64 *local_mac)
@@ -1362,7 +1442,7 @@ static struct vnet *vnet_new(const u64 *local_mac)
         struct vnet *vp;
         int err, i;
 
-        dev = alloc_etherdev(sizeof(*vp));
+        dev = alloc_etherdev_mqs(sizeof(*vp), VNET_MAX_TXQS, 1);
         if (!dev)
                 return ERR_PTR(-ENOMEM);
         dev->needed_headroom = VNET_PACKET_SKIP + 8;
@@ -1374,7 +1454,6 @@ static struct vnet *vnet_new(const u64 *local_mac)
         vp = netdev_priv(dev);
 
         spin_lock_init(&vp->lock);
-        tasklet_init(&vp->vnet_tx_wakeup, maybe_tx_wakeup, (unsigned long)vp);
         vp->dev = dev;
 
         INIT_LIST_HEAD(&vp->port_list);
@@ -1434,7 +1513,6 @@ static void vnet_cleanup(void)
                 vp = list_first_entry(&vnet_list, struct vnet, list);
                 list_del(&vp->list);
                 dev = vp->dev;
-                tasklet_kill(&vp->vnet_tx_wakeup);
                 /* vio_unregister_driver() should have cleaned up port_list */
                 BUG_ON(!list_empty(&vp->port_list));
                 unregister_netdev(dev);
@@ -1489,6 +1567,25 @@ static void print_version(void)
 
 const char *remote_macaddr_prop = "remote-mac-address";
 
+static void
+vnet_port_add_txq(struct vnet_port *port)
+{
+        struct vnet *vp = port->vp;
+        int n;
+
+        n = vp->nports++;
+        n = n & (VNET_MAX_TXQS - 1);
+        port->q_index = n;
+        netif_tx_wake_queue(netdev_get_tx_queue(vp->dev, port->q_index));
+}
+
+static void
+vnet_port_rm_txq(struct vnet_port *port)
+{
+        port->vp->nports--;
+        netif_tx_stop_queue(netdev_get_tx_queue(port->vp->dev, port->q_index));
+}
+
 static int vnet_port_probe(struct vio_dev *vdev, const struct vio_device_id *id)
 {
         struct mdesc_handle *hp;
@@ -1536,6 +1633,8 @@ static int vnet_port_probe(struct vio_dev *vdev, const struct vio_device_id *id)
         if (err)
                 goto err_out_free_port;
 
+        netif_napi_add(port->vp->dev, &port->napi, vnet_poll, NAPI_POLL_WEIGHT);
+
         err = vnet_port_alloc_tx_bufs(port);
         if (err)
                 goto err_out_free_ldc;
@@ -1550,10 +1649,12 @@ static int vnet_port_probe(struct vio_dev *vdev, const struct vio_device_id *id)
 
         spin_lock_irqsave(&vp->lock, flags);
         if (switch_port)
-                list_add(&port->list, &vp->port_list);
+                list_add_rcu(&port->list, &vp->port_list);
         else
-                list_add_tail(&port->list, &vp->port_list);
-        hlist_add_head(&port->hash, &vp->port_hash[vnet_hashfn(port->raddr)]);
+                list_add_tail_rcu(&port->list, &vp->port_list);
+        hlist_add_head_rcu(&port->hash,
+                           &vp->port_hash[vnet_hashfn(port->raddr)]);
+        vnet_port_add_txq(port);
         spin_unlock_irqrestore(&vp->lock, flags);
 
         dev_set_drvdata(&vdev->dev, port);
@@ -1564,6 +1665,7 @@ static int vnet_port_probe(struct vio_dev *vdev, const struct vio_device_id *id)
         setup_timer(&port->clean_timer, vnet_clean_timer_expire,
                     (unsigned long)port);
 
+        napi_enable(&port->napi);
         vio_port_up(&port->vio);
 
         mdesc_release(hp);
@@ -1571,6 +1673,7 @@ static int vnet_port_probe(struct vio_dev *vdev, const struct vio_device_id *id)
         return 0;
 
 err_out_free_ldc:
+        netif_napi_del(&port->napi);
         vio_ldc_free(&port->vio);
 
 err_out_free_port:
@@ -1586,17 +1689,18 @@ static int vnet_port_remove(struct vio_dev *vdev)
         struct vnet_port *port = dev_get_drvdata(&vdev->dev);
 
         if (port) {
-                struct vnet *vp = port->vp;
-                unsigned long flags;
 
                 del_timer_sync(&port->vio.timer);
-                del_timer_sync(&port->clean_timer);
 
-                spin_lock_irqsave(&vp->lock, flags);
-                list_del(&port->list);
-                hlist_del(&port->hash);
-                spin_unlock_irqrestore(&vp->lock, flags);
+                napi_disable(&port->napi);
+
+                list_del_rcu(&port->list);
+                hlist_del_rcu(&port->hash);
 
+                synchronize_rcu();
+                del_timer_sync(&port->clean_timer);
+                vnet_port_rm_txq(port);
+                netif_napi_del(&port->napi);
                 vnet_port_free_tx_bufs(port);
                 vio_ldc_free(&port->vio);
 
diff --git a/drivers/net/ethernet/sun/sunvnet.h b/drivers/net/ethernet/sun/sunvnet.h
index c91104542619..cd5d343ea232 100644
--- a/drivers/net/ethernet/sun/sunvnet.h
+++ b/drivers/net/ethernet/sun/sunvnet.h
@@ -56,6 +56,12 @@ struct vnet_port {
         struct timer_list       clean_timer;
 
         u64                     rmtu;
+
+        struct napi_struct      napi;
+        u32                     napi_stop_idx;
+        bool                    napi_resume;
+        int                     rx_event;
+        u16                     q_index;
 };
 
 static inline struct vnet_port *to_vnet_port(struct vio_driver_state *vio)
@@ -97,7 +103,7 @@ struct vnet {
         struct list_head        list;
         u64                     local_mac;
 
-        struct tasklet_struct   vnet_tx_wakeup;
+        int                     nports;
 };
 
 #endif /* _SUNVNET_H */
diff --git a/drivers/net/ethernet/wiznet/w5100.c b/drivers/net/ethernet/wiznet/w5100.c
index 0f56b1c0e082..70a930ac4fa9 100644
--- a/drivers/net/ethernet/wiznet/w5100.c
+++ b/drivers/net/ethernet/wiznet/w5100.c
@@ -638,14 +638,12 @@ static int w5100_hw_probe(struct platform_device *pdev)
         }
 
         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!mem)
-                return -ENXIO;
-        mem_size = resource_size(mem);
-
         priv->base = devm_ioremap_resource(&pdev->dev, mem);
         if (IS_ERR(priv->base))
                 return PTR_ERR(priv->base);
 
+        mem_size = resource_size(mem);
+
         spin_lock_init(&priv->reg_lock);
         priv->indirect = mem_size < W5100_BUS_DIRECT_SIZE;
         if (priv->indirect) {
diff --git a/drivers/net/ethernet/wiznet/w5300.c b/drivers/net/ethernet/wiznet/w5300.c
index f961f14a0473..7974b7d90fcc 100644
--- a/drivers/net/ethernet/wiznet/w5300.c
+++ b/drivers/net/ethernet/wiznet/w5300.c
@@ -558,14 +558,12 @@ static int w5300_hw_probe(struct platform_device *pdev)
         }
 
         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!mem)
-                return -ENXIO;
-        mem_size = resource_size(mem);
-
         priv->base = devm_ioremap_resource(&pdev->dev, mem);
         if (IS_ERR(priv->base))
                 return PTR_ERR(priv->base);
 
+        mem_size = resource_size(mem);
+
         spin_lock_init(&priv->reg_lock);
         priv->indirect = mem_size < W5300_BUS_DIRECT_SIZE;
         if (priv->indirect) {
diff --git a/drivers/net/hyperv/netvsc_drv.c b/drivers/net/hyperv/netvsc_drv.c
index 78ec33f5100b..3295e4ee9dbb 100644
--- a/drivers/net/hyperv/netvsc_drv.c
+++ b/drivers/net/hyperv/netvsc_drv.c
@@ -193,7 +193,9 @@ static bool netvsc_set_hash(u32 *hash, struct sk_buff *skb)
         struct flow_keys flow;
         int data_len;
 
-        if (!skb_flow_dissect(skb, &flow) || flow.n_proto != htons(ETH_P_IP))
+        if (!skb_flow_dissect(skb, &flow) ||
+            !(flow.n_proto == htons(ETH_P_IP) ||
+              flow.n_proto == htons(ETH_P_IPV6)))
                 return false;
 
         if (flow.ip_proto == IPPROTO_TCP)
diff --git a/drivers/net/hyperv/rndis_filter.c b/drivers/net/hyperv/rndis_filter.c
index 2b86f0b6f6d1..ccce6f24b009 100644
--- a/drivers/net/hyperv/rndis_filter.c
+++ b/drivers/net/hyperv/rndis_filter.c
@@ -728,7 +728,8 @@ int rndis_filter_set_rss_param(struct rndis_device *rdev, int num_queue)
         rssp->hdr.size = sizeof(struct ndis_recv_scale_param);
         rssp->flag = 0;
         rssp->hashinfo = NDIS_HASH_FUNC_TOEPLITZ | NDIS_HASH_IPV4 |
-                         NDIS_HASH_TCP_IPV4;
+                         NDIS_HASH_TCP_IPV4 | NDIS_HASH_IPV6 |
+                         NDIS_HASH_TCP_IPV6;
         rssp->indirect_tabsize = 4*ITAB_NUM;
         rssp->indirect_taboffset = sizeof(struct ndis_recv_scale_param);
         rssp->hashkey_size = HASH_KEYLEN;
diff --git a/drivers/net/phy/marvell.c b/drivers/net/phy/marvell.c
index 225c033b08f3..bb4d780c0838 100644
--- a/drivers/net/phy/marvell.c
+++ b/drivers/net/phy/marvell.c
@@ -54,6 +54,9 @@
 #define MII_M1145_PHY_EXT_CR            0x14
 #define MII_M1145_RGMII_RX_DELAY        0x0080
 #define MII_M1145_RGMII_TX_DELAY        0x0002
+#define MII_M1145_HWCFG_MODE_SGMII_NO_CLK       0x4
+#define MII_M1145_HWCFG_MODE_MASK               0xf
+#define MII_M1145_HWCFG_FIBER_COPPER_AUTO       0x8000
 
 #define MII_M1145_HWCFG_MODE_SGMII_NO_CLK       0x4
 #define MII_M1145_HWCFG_MODE_MASK               0xf
@@ -123,6 +126,9 @@
 
 #define MII_M1116R_CONTROL_REG_MAC      21
 
+#define MII_88E3016_PHY_SPEC_CTRL       0x10
+#define MII_88E3016_DISABLE_SCRAMBLER   0x0200
+#define MII_88E3016_AUTO_MDIX_CROSSOVER 0x0030
 
 MODULE_DESCRIPTION("Marvell PHY driver");
 MODULE_AUTHOR("Andy Fleming");
@@ -439,6 +445,25 @@ static int m88e1116r_config_init(struct phy_device *phydev)
         return 0;
 }
 
+static int m88e3016_config_init(struct phy_device *phydev)
+{
+        int reg;
+
+        /* Enable Scrambler and Auto-Crossover */
+        reg = phy_read(phydev, MII_88E3016_PHY_SPEC_CTRL);
+        if (reg < 0)
+                return reg;
+
+        reg &= ~MII_88E3016_DISABLE_SCRAMBLER;
+        reg |= MII_88E3016_AUTO_MDIX_CROSSOVER;
+
+        reg = phy_write(phydev, MII_88E3016_PHY_SPEC_CTRL, reg);
+        if (reg < 0)
+                return reg;
+
+        return 0;
+}
+
 static int m88e1111_config_init(struct phy_device *phydev)
 {
         int err;
@@ -625,6 +650,7 @@ static int m88e1149_config_init(struct phy_device *phydev)
 static int m88e1145_config_init(struct phy_device *phydev)
 {
         int err;
+        int temp;
 
         /* Take care of errata E0 & E1 */
         err = phy_write(phydev, 0x1d, 0x001b);
@@ -682,7 +708,7 @@ static int m88e1145_config_init(struct phy_device *phydev)
         }
 
         if (phydev->interface == PHY_INTERFACE_MODE_SGMII) {
-                int temp = phy_read(phydev, MII_M1145_PHY_EXT_SR);
+                temp = phy_read(phydev, MII_M1145_PHY_EXT_SR);
                 if (temp < 0)
                         return temp;
 
@@ -789,6 +815,12 @@ static int marvell_read_status(struct phy_device *phydev)
         return 0;
 }
 
+static int marvell_aneg_done(struct phy_device *phydev)
+{
+        int retval = phy_read(phydev, MII_M1011_PHY_STATUS);
+        return (retval < 0) ? retval : (retval & MII_M1011_PHY_STATUS_RESOLVED);
+}
+
 static int m88e1121_did_interrupt(struct phy_device *phydev)
 {
         int imask;
@@ -1069,6 +1101,23 @@ static struct phy_driver marvell_drivers[] = {
                 .suspend = &genphy_suspend,
                 .driver = { .owner = THIS_MODULE },
         },
+        {
+                .phy_id = MARVELL_PHY_ID_88E3016,
+                .phy_id_mask = MARVELL_PHY_ID_MASK,
+                .name = "Marvell 88E3016",
+                .features = PHY_BASIC_FEATURES,
+                .flags = PHY_HAS_INTERRUPT,
+                .config_aneg = &genphy_config_aneg,
+                .config_init = &m88e3016_config_init,
+                .aneg_done = &marvell_aneg_done,
+                .read_status = &marvell_read_status,
+                .ack_interrupt = &marvell_ack_interrupt,
+                .config_intr = &marvell_config_intr,
+                .did_interrupt = &m88e1121_did_interrupt,
+                .resume = &genphy_resume,
+                .suspend = &genphy_suspend,
+                .driver = { .owner = THIS_MODULE },
+        },
 };
 
 static int __init marvell_init(void)
@@ -1098,6 +1147,7 @@ static struct mdio_device_id __maybe_unused marvell_tbl[] = {
         { MARVELL_PHY_ID_88E1318S, MARVELL_PHY_ID_MASK },
         { MARVELL_PHY_ID_88E1116R, MARVELL_PHY_ID_MASK },
         { MARVELL_PHY_ID_88E1510, MARVELL_PHY_ID_MASK },
+        { MARVELL_PHY_ID_88E3016, MARVELL_PHY_ID_MASK },
         { }
 };
 
diff --git a/drivers/net/usb/r8152.c b/drivers/net/usb/r8152.c
index c6554c7a8147..8ded08e027fb 100644
--- a/drivers/net/usb/r8152.c
+++ b/drivers/net/usb/r8152.c
@@ -486,7 +486,7 @@ struct tally_counter {
         __le64  rx_broadcast;
         __le32  rx_multicast;
         __le16  tx_aborted;
-        __le16  tx_underun;
+        __le16  tx_underrun;
 };
 
 struct rx_desc {
@@ -690,6 +690,9 @@ static int generic_ocp_read(struct r8152 *tp, u16 index, u16 size,
                 }
         }
 
+        if (ret == -ENODEV)
+                set_bit(RTL8152_UNPLUG, &tp->flags);
+
         return ret;
 }
 
@@ -757,6 +760,9 @@ static int generic_ocp_write(struct r8152 *tp, u16 index, u16 byteen,
         }
 
 error1:
+        if (ret == -ENODEV)
+                set_bit(RTL8152_UNPLUG, &tp->flags);
+
         return ret;
 }
 
@@ -1083,6 +1089,7 @@ static void read_bulk_callback(struct urb *urb)
 
         result = r8152_submit_rx(tp, agg, GFP_ATOMIC);
         if (result == -ENODEV) {
+                set_bit(RTL8152_UNPLUG, &tp->flags);
                 netif_device_detach(tp->netdev);
         } else if (result) {
                 spin_lock(&tp->rx_lock);
@@ -1190,11 +1197,13 @@ static void intr_callback(struct urb *urb)
 
 resubmit:
         res = usb_submit_urb(urb, GFP_ATOMIC);
-        if (res == -ENODEV)
+        if (res == -ENODEV) {
+                set_bit(RTL8152_UNPLUG, &tp->flags);
                 netif_device_detach(tp->netdev);
-        else if (res)
+        } else if (res) {
                 netif_err(tp, intr, tp->netdev,
                           "can't resubmit intr, status %d\n", res);
+        }
 }
 
 static inline void *rx_agg_align(void *data)
@@ -1758,6 +1767,7 @@ static void tx_bottom(struct r8152 *tp)
                         struct net_device *netdev = tp->netdev;
 
                         if (res == -ENODEV) {
+                                set_bit(RTL8152_UNPLUG, &tp->flags);
                                 netif_device_detach(netdev);
                         } else {
                                 struct net_device_stats *stats = &netdev->stats;
@@ -3427,7 +3437,7 @@ static void rtl8152_get_ethtool_stats(struct net_device *dev,
         data[9] = le64_to_cpu(tally.rx_broadcast);
         data[10] = le32_to_cpu(tally.rx_multicast);
         data[11] = le16_to_cpu(tally.tx_aborted);
-        data[12] = le16_to_cpu(tally.tx_underun);
+        data[12] = le16_to_cpu(tally.tx_underrun);
 }
 
 static void rtl8152_get_strings(struct net_device *dev, u32 stringset, u8 *data)
@@ -3565,11 +3575,33 @@ out:
         return ret;
 }
 
+static int rtl8152_nway_reset(struct net_device *dev)
+{
+        struct r8152 *tp = netdev_priv(dev);
+        int ret;
+
+        ret = usb_autopm_get_interface(tp->intf);
+        if (ret < 0)
+                goto out;
+
+        mutex_lock(&tp->control);
+
+        ret = mii_nway_restart(&tp->mii);
+
+        mutex_unlock(&tp->control);
+
+        usb_autopm_put_interface(tp->intf);
+
+out:
+        return ret;
+}
+
 static struct ethtool_ops ops = {
         .get_drvinfo = rtl8152_get_drvinfo,
         .get_settings = rtl8152_get_settings,
         .set_settings = rtl8152_set_settings,
         .get_link = ethtool_op_get_link,
+        .nway_reset = rtl8152_nway_reset,
         .get_msglevel = rtl8152_get_msglevel,
         .set_msglevel = rtl8152_set_msglevel,
         .get_wol = rtl8152_get_wol,
diff --git a/drivers/net/xen-netback/interface.c b/drivers/net/xen-netback/interface.c
index 895fe84011e7..a6a32d337bbb 100644
--- a/drivers/net/xen-netback/interface.c
+++ b/drivers/net/xen-netback/interface.c
@@ -235,10 +235,10 @@ static void xenvif_down(struct xenvif *vif)
 
         for (queue_index = 0; queue_index < num_queues; ++queue_index) {
                 queue = &vif->queues[queue_index];
-                napi_disable(&queue->napi);
                 disable_irq(queue->tx_irq);
                 if (queue->tx_irq != queue->rx_irq)
                         disable_irq(queue->rx_irq);
+                napi_disable(&queue->napi);
                 del_timer_sync(&queue->credit_timeout);
         }
 }
diff --git a/drivers/net/xen-netback/netback.c b/drivers/net/xen-netback/netback.c
index 6563f0713fc0..45755f9aa3f9 100644
--- a/drivers/net/xen-netback/netback.c
+++ b/drivers/net/xen-netback/netback.c
@@ -1550,7 +1550,7 @@ static int xenvif_handle_frag_list(struct xenvif_queue *queue, struct sk_buff *s
                 unsigned int len;
 
                 BUG_ON(i >= MAX_SKB_FRAGS);
-                page = alloc_page(GFP_ATOMIC|__GFP_COLD);
+                page = alloc_page(GFP_ATOMIC);
                 if (!page) {
                         int j;
                         skb->truesize += skb->data_len;
diff --git a/drivers/net/xen-netfront.c b/drivers/net/xen-netfront.c
index cca871346a0f..88a70f5ed594 100644
--- a/drivers/net/xen-netfront.c
+++ b/drivers/net/xen-netfront.c
@@ -77,7 +77,9 @@ struct netfront_cb {
 
 #define NET_TX_RING_SIZE __CONST_RING_SIZE(xen_netif_tx, PAGE_SIZE)
 #define NET_RX_RING_SIZE __CONST_RING_SIZE(xen_netif_rx, PAGE_SIZE)
-#define TX_MAX_TARGET min_t(int, NET_TX_RING_SIZE, 256)
+
+/* Minimum number of Rx slots (includes slot for GSO metadata). */
+#define NET_RX_SLOTS_MIN (XEN_NETIF_NR_SLOTS_MIN + 1)
 
 /* Queue name is interface name with "-qNNN" appended */
 #define QUEUE_NAME_SIZE (IFNAMSIZ + 6)
@@ -137,13 +139,6 @@ struct netfront_queue {
         struct xen_netif_rx_front_ring rx;
         int rx_ring_ref;
 
-        /* Receive-ring batched refills. */
-#define RX_MIN_TARGET 8
-#define RX_DFL_MIN_TARGET 64
-#define RX_MAX_TARGET min_t(int, NET_RX_RING_SIZE, 256)
-        unsigned rx_min_target, rx_max_target, rx_target;
-        struct sk_buff_head rx_batch;
-
         struct timer_list rx_refill_timer;
 
         struct sk_buff *rx_skbs[NET_RX_RING_SIZE];
@@ -251,7 +246,7 @@ static void rx_refill_timeout(unsigned long data)
 static int netfront_tx_slot_available(struct netfront_queue *queue)
 {
         return (queue->tx.req_prod_pvt - queue->tx.rsp_cons) <
-                (TX_MAX_TARGET - MAX_SKB_FRAGS - 2);
+                (NET_TX_RING_SIZE - MAX_SKB_FRAGS - 2);
 }
 
 static void xennet_maybe_wake_tx(struct netfront_queue *queue)
@@ -265,77 +260,55 @@ static void xennet_maybe_wake_tx(struct netfront_queue *queue)
                 netif_tx_wake_queue(netdev_get_tx_queue(dev, queue->id));
 }
 
-static void xennet_alloc_rx_buffers(struct netfront_queue *queue)
+
+static struct sk_buff *xennet_alloc_one_rx_buffer(struct netfront_queue *queue)
 {
-        unsigned short id;
         struct sk_buff *skb;
         struct page *page;
-        int i, batch_target, notify;
-        RING_IDX req_prod = queue->rx.req_prod_pvt;
-        grant_ref_t ref;
-        unsigned long pfn;
-        void *vaddr;
-        struct xen_netif_rx_request *req;
 
-        if (unlikely(!netif_carrier_ok(queue->info->netdev)))
-                return;
+        skb = __netdev_alloc_skb(queue->info->netdev,
+                                 RX_COPY_THRESHOLD + NET_IP_ALIGN,
+                                 GFP_ATOMIC | __GFP_NOWARN);
+        if (unlikely(!skb))
+                return NULL;
 
-        /*
-         * Allocate skbuffs greedily, even though we batch updates to the
-         * receive ring. This creates a less bursty demand on the memory
-         * allocator, so should reduce the chance of failed allocation requests
-         * both for ourself and for other kernel subsystems.
-         */
-        batch_target = queue->rx_target - (req_prod - queue->rx.rsp_cons);
-        for (i = skb_queue_len(&queue->rx_batch); i < batch_target; i++) {
-                skb = __netdev_alloc_skb(queue->info->netdev,
-                                         RX_COPY_THRESHOLD + NET_IP_ALIGN,
-                                         GFP_ATOMIC | __GFP_NOWARN);
-                if (unlikely(!skb))
-                        goto no_skb;
-
-                /* Align ip header to a 16 bytes boundary */
-                skb_reserve(skb, NET_IP_ALIGN);
-
-                page = alloc_page(GFP_ATOMIC | __GFP_NOWARN);
-                if (!page) {
-                        kfree_skb(skb);
-no_skb:
-                        /* Could not allocate any skbuffs. Try again later. */
-                        mod_timer(&queue->rx_refill_timer,
-                                  jiffies + (HZ/10));
-
-                        /* Any skbuffs queued for refill? Force them out. */
-                        if (i != 0)
-                                goto refill;
-                        break;
-                }
-
-                skb_add_rx_frag(skb, 0, page, 0, 0, PAGE_SIZE);
-                __skb_queue_tail(&queue->rx_batch, skb);
+        page = alloc_page(GFP_ATOMIC | __GFP_NOWARN);
+        if (!page) {
+                kfree_skb(skb);
+                return NULL;
         }
+        skb_add_rx_frag(skb, 0, page, 0, 0, PAGE_SIZE);
+
+        /* Align ip header to a 16 bytes boundary */
+        skb_reserve(skb, NET_IP_ALIGN);
+        skb->dev = queue->info->netdev;
+
+        return skb;
+}
+
 
-        /* Is the batch large enough to be worthwhile? */
-        if (i < (queue->rx_target/2)) {
-                if (req_prod > queue->rx.sring->req_prod)
-                        goto push;
+static void xennet_alloc_rx_buffers(struct netfront_queue *queue)
+{
+        RING_IDX req_prod = queue->rx.req_prod_pvt;
+        int notify;
+
+        if (unlikely(!netif_carrier_ok(queue->info->netdev)))
                 return;
-        }
 
-        /* Adjust our fill target if we risked running out of buffers. */
-        if (((req_prod - queue->rx.sring->rsp_prod) < (queue->rx_target / 4)) &&
-            ((queue->rx_target *= 2) > queue->rx_max_target))
-                queue->rx_target = queue->rx_max_target;
+        for (req_prod = queue->rx.req_prod_pvt;
+             req_prod - queue->rx.rsp_cons < NET_RX_RING_SIZE;
+             req_prod++) {
+                struct sk_buff *skb;
+                unsigned short id;
+                grant_ref_t ref;
+                unsigned long pfn;
+                struct xen_netif_rx_request *req;
 
- refill:
-        for (i = 0; ; i++) {
-                skb = __skb_dequeue(&queue->rx_batch);
-                if (skb == NULL)
+                skb = xennet_alloc_one_rx_buffer(queue);
+                if (!skb)
                         break;
 
-                skb->dev = queue->info->netdev;
-
-                id = xennet_rxidx(req_prod + i);
+                id = xennet_rxidx(req_prod);
 
                 BUG_ON(queue->rx_skbs[id]);
                 queue->rx_skbs[id] = skb;
@@ -345,9 +318,8 @@ no_skb:
                 queue->grant_rx_ref[id] = ref;
 
                 pfn = page_to_pfn(skb_frag_page(&skb_shinfo(skb)->frags[0]));
-                vaddr = page_address(skb_frag_page(&skb_shinfo(skb)->frags[0]));
 
-                req = RING_GET_REQUEST(&queue->rx, req_prod + i);
+                req = RING_GET_REQUEST(&queue->rx, req_prod);
                 gnttab_grant_foreign_access_ref(ref,
                                                 queue->info->xbdev->otherend_id,
                                                 pfn_to_mfn(pfn),
@@ -357,11 +329,16 @@ no_skb:
                 req->gref = ref;
         }
 
+        queue->rx.req_prod_pvt = req_prod;
+
+        /* Not enough requests? Try again later. */
+        if (req_prod - queue->rx.rsp_cons < NET_RX_SLOTS_MIN) {
+                mod_timer(&queue->rx_refill_timer, jiffies + (HZ/10));
+                return;
+        }
+
         wmb();          /* barrier so backend seens requests */
 
-        /* Above is a suitable barrier to ensure backend will see requests. */
-        queue->rx.req_prod_pvt = req_prod + i;
- push:
         RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&queue->rx, notify);
         if (notify)
                 notify_remote_via_irq(queue->rx_irq);
@@ -1070,13 +1047,6 @@ err:
 
         work_done -= handle_incoming_queue(queue, &rxq);
 
-        /* If we get a callback with very few responses, reduce fill target. */
-        /* NB. Note exponential increase, linear decrease. */
-        if (((queue->rx.req_prod_pvt - queue->rx.sring->rsp_prod) >
-             ((3*queue->rx_target) / 4)) &&
-            (--queue->rx_target < queue->rx_min_target))
-                queue->rx_target = queue->rx_min_target;
-
         xennet_alloc_rx_buffers(queue);
 
         if (work_done < budget) {
@@ -1643,11 +1613,6 @@ static int xennet_init_queue(struct netfront_queue *queue)
         spin_lock_init(&queue->tx_lock);
         spin_lock_init(&queue->rx_lock);
 
-        skb_queue_head_init(&queue->rx_batch);
-        queue->rx_target     = RX_DFL_MIN_TARGET;
-        queue->rx_min_target = RX_DFL_MIN_TARGET;
-        queue->rx_max_target = RX_MAX_TARGET;
-
         init_timer(&queue->rx_refill_timer);
         queue->rx_refill_timer.data = (unsigned long)queue;
         queue->rx_refill_timer.function = rx_refill_timeout;
@@ -1670,7 +1635,7 @@ static int xennet_init_queue(struct netfront_queue *queue)
         }
 
         /* A grant for every tx ring slot */
-        if (gnttab_alloc_grant_references(TX_MAX_TARGET,
+        if (gnttab_alloc_grant_references(NET_TX_RING_SIZE,
                                           &queue->gref_tx_head) < 0) {
                 pr_alert("can't alloc tx grant refs\n");
                 err = -ENOMEM;
@@ -1678,7 +1643,7 @@ static int xennet_init_queue(struct netfront_queue *queue)
         }
 
         /* A grant for every rx ring slot */
-        if (gnttab_alloc_grant_references(RX_MAX_TARGET,
+        if (gnttab_alloc_grant_references(NET_RX_RING_SIZE,
                                           &queue->gref_rx_head) < 0) {
                 pr_alert("can't alloc rx grant refs\n");
                 err = -ENOMEM;
@@ -2146,83 +2111,18 @@ static const struct ethtool_ops xennet_ethtool_ops =
 };
 
 #ifdef CONFIG_SYSFS
-static ssize_t show_rxbuf_min(struct device *dev,
-                              struct device_attribute *attr, char *buf)
-{
-        struct net_device *netdev = to_net_dev(dev);
-        struct netfront_info *info = netdev_priv(netdev);
-        unsigned int num_queues = netdev->real_num_tx_queues;
-
-        if (num_queues)
-                return sprintf(buf, "%u\n", info->queues[0].rx_min_target);
-        else
-                return sprintf(buf, "%u\n", RX_MIN_TARGET);
-}
-
-static ssize_t store_rxbuf_min(struct device *dev,
-                               struct device_attribute *attr,
-                               const char *buf, size_t len)
+static ssize_t show_rxbuf(struct device *dev,
+                          struct device_attribute *attr, char *buf)
 {
-        struct net_device *netdev = to_net_dev(dev);
-        struct netfront_info *np = netdev_priv(netdev);
-        unsigned int num_queues = netdev->real_num_tx_queues;
-        char *endp;
-        unsigned long target;
-        unsigned int i;
-        struct netfront_queue *queue;
-
-        if (!capable(CAP_NET_ADMIN))
-                return -EPERM;
-
-        target = simple_strtoul(buf, &endp, 0);
-        if (endp == buf)
-                return -EBADMSG;
-
-        if (target < RX_MIN_TARGET)
-                target = RX_MIN_TARGET;
-        if (target > RX_MAX_TARGET)
-                target = RX_MAX_TARGET;
-
-        for (i = 0; i < num_queues; ++i) {
-                queue = &np->queues[i];
-                spin_lock_bh(&queue->rx_lock);
-                if (target > queue->rx_max_target)
-                        queue->rx_max_target = target;
-                queue->rx_min_target = target;
-                if (target > queue->rx_target)
-                        queue->rx_target = target;
-
-                xennet_alloc_rx_buffers(queue);
-
-                spin_unlock_bh(&queue->rx_lock);
-        }
-        return len;
-}
-
-static ssize_t show_rxbuf_max(struct device *dev,
-                              struct device_attribute *attr, char *buf)
-{
-        struct net_device *netdev = to_net_dev(dev);
-        struct netfront_info *info = netdev_priv(netdev);
-        unsigned int num_queues = netdev->real_num_tx_queues;
-
-        if (num_queues)
-                return sprintf(buf, "%u\n", info->queues[0].rx_max_target);
-        else
-                return sprintf(buf, "%u\n", RX_MAX_TARGET);
+        return sprintf(buf, "%lu\n", NET_RX_RING_SIZE);
 }
 
-static ssize_t store_rxbuf_max(struct device *dev,
-                               struct device_attribute *attr,
-                               const char *buf, size_t len)
+static ssize_t store_rxbuf(struct device *dev,
+                           struct device_attribute *attr,
+                           const char *buf, size_t len)
 {
-        struct net_device *netdev = to_net_dev(dev);
-        struct netfront_info *np = netdev_priv(netdev);
-        unsigned int num_queues = netdev->real_num_tx_queues;
         char *endp;
         unsigned long target;
-        unsigned int i = 0;
-        struct netfront_queue *queue = NULL;
 
         if (!capable(CAP_NET_ADMIN))
                 return -EPERM;
@@ -2231,44 +2131,15 @@ static ssize_t store_rxbuf_max(struct device *dev,
         if (endp == buf)
                 return -EBADMSG;
 
-        if (target < RX_MIN_TARGET)
-                target = RX_MIN_TARGET;
-        if (target > RX_MAX_TARGET)
-                target = RX_MAX_TARGET;
-
-        for (i = 0; i < num_queues; ++i) {
-                queue = &np->queues[i];
-                spin_lock_bh(&queue->rx_lock);
-                if (target < queue->rx_min_target)
-                        queue->rx_min_target = target;
-                queue->rx_max_target = target;
-                if (target < queue->rx_target)
-                        queue->rx_target = target;
-
-                xennet_alloc_rx_buffers(queue);
+        /* rxbuf_min and rxbuf_max are no longer configurable. */
 
-                spin_unlock_bh(&queue->rx_lock);
-        }
         return len;
 }
 
-static ssize_t show_rxbuf_cur(struct device *dev,
-                              struct device_attribute *attr, char *buf)
-{
-        struct net_device *netdev = to_net_dev(dev);
-        struct netfront_info *info = netdev_priv(netdev);
-        unsigned int num_queues = netdev->real_num_tx_queues;
-
-        if (num_queues)
-                return sprintf(buf, "%u\n", info->queues[0].rx_target);
-        else
-                return sprintf(buf, "0\n");
-}
-
 static struct device_attribute xennet_attrs[] = {
-        __ATTR(rxbuf_min, S_IRUGO|S_IWUSR, show_rxbuf_min, store_rxbuf_min),
-        __ATTR(rxbuf_max, S_IRUGO|S_IWUSR, show_rxbuf_max, store_rxbuf_max),
-        __ATTR(rxbuf_cur, S_IRUGO, show_rxbuf_cur, NULL),
+        __ATTR(rxbuf_min, S_IRUGO|S_IWUSR, show_rxbuf, store_rxbuf),
+        __ATTR(rxbuf_max, S_IRUGO|S_IWUSR, show_rxbuf, store_rxbuf),
+        __ATTR(rxbuf_cur, S_IRUGO, show_rxbuf, NULL),
 };
 
 static int xennet_sysfs_addif(struct net_device *netdev)
diff --git a/drivers/s390/net/Kconfig b/drivers/s390/net/Kconfig
index 8b3f55991805..f1b5111bbaba 100644
--- a/drivers/s390/net/Kconfig
+++ b/drivers/s390/net/Kconfig
@@ -71,7 +71,7 @@ config CLAW
 config QETH
         def_tristate y
         prompt "Gigabit Ethernet device support"
-        depends on CCW && NETDEVICES && IP_MULTICAST && QDIO
+        depends on CCW && NETDEVICES && IP_MULTICAST && QDIO && ETHERNET
         help
           This driver supports the IBM System z OSA Express adapters
           in QDIO mode (all media types), HiperSockets interfaces and z/VM
diff --git a/drivers/s390/net/ctcm_sysfs.c b/drivers/s390/net/ctcm_sysfs.c
index 6bcfbbb20f04..47773c4d235a 100644
--- a/drivers/s390/net/ctcm_sysfs.c
+++ b/drivers/s390/net/ctcm_sysfs.c
@@ -44,8 +44,8 @@ static ssize_t ctcm_buffer_write(struct device *dev,
                 return -ENODEV;
         }
 
-        rc = sscanf(buf, "%u", &bs1);
-        if (rc != 1)
+        rc = kstrtouint(buf, 0, &bs1);
+        if (rc)
                 goto einval;
         if (bs1 > CTCM_BUFSIZE_LIMIT)
                                         goto einval;
@@ -151,8 +151,8 @@ static ssize_t ctcm_proto_store(struct device *dev,
 
         if (!priv)
                 return -ENODEV;
-        rc = sscanf(buf, "%d", &value);
-        if ((rc != 1) ||
+        rc = kstrtoint(buf, 0, &value);
+        if (rc ||
             !((value == CTCM_PROTO_S390)  ||
               (value == CTCM_PROTO_LINUX) ||
               (value == CTCM_PROTO_MPC) ||
diff --git a/drivers/s390/net/lcs.c b/drivers/s390/net/lcs.c
index 0a7d87c372b8..92190aa20b9f 100644
--- a/drivers/s390/net/lcs.c
+++ b/drivers/s390/net/lcs.c
@@ -1943,15 +1943,16 @@ static ssize_t
 lcs_portno_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
         struct lcs_card *card;
-        int value, rc;
+        int rc;
+        s16 value;
 
         card = dev_get_drvdata(dev);
 
         if (!card)
                 return 0;
 
-        rc = sscanf(buf, "%d", &value);
-        if (rc != 1)
+        rc = kstrtos16(buf, 0, &value);
+        if (rc)
                 return -EINVAL;
         /* TODO: sanity checks */
         card->portno = value;
@@ -2007,8 +2008,8 @@ lcs_timeout_store (struct device *dev, struct device_attribute *attr, const char
         if (!card)
                 return 0;
 
-        rc = sscanf(buf, "%u", &value);
-        if (rc != 1)
+        rc = kstrtouint(buf, 0, &value);
+        if (rc)
                 return -EINVAL;
         /* TODO: sanity checks */
         card->lancmd_timeout = value;
diff --git a/drivers/s390/net/qeth_core.h b/drivers/s390/net/qeth_core.h
index e7646ce3d659..7a8bb9f78e76 100644
--- a/drivers/s390/net/qeth_core.h
+++ b/drivers/s390/net/qeth_core.h
@@ -380,11 +380,6 @@ enum qeth_header_ids {
 #define QETH_HDR_EXT_CSUM_TRANSP_REQ  0x20
 #define QETH_HDR_EXT_UDP              0x40 /*bit off for TCP*/
 
-static inline int qeth_is_last_sbale(struct qdio_buffer_element *sbale)
-{
-        return (sbale->eflags & SBAL_EFLAGS_LAST_ENTRY);
-}
-
 enum qeth_qdio_buffer_states {
         /*
          * inbound: read out by driver; owned by hardware in order to be filled
@@ -843,13 +838,6 @@ struct qeth_trap_id {
 /*some helper functions*/
 #define QETH_CARD_IFNAME(card) (((card)->dev)? (card)->dev->name : "")
 
-static inline struct qeth_card *CARD_FROM_CDEV(struct ccw_device *cdev)
-{
-        struct qeth_card *card = dev_get_drvdata(&((struct ccwgroup_device *)
-                dev_get_drvdata(&cdev->dev))->dev);
-        return card;
-}
-
 static inline int qeth_get_micros(void)
 {
         return (int) (get_tod_clock() >> 12);
@@ -894,7 +882,6 @@ const char *qeth_get_cardname_short(struct qeth_card *);
 int qeth_realloc_buffer_pool(struct qeth_card *, int);
 int qeth_core_load_discipline(struct qeth_card *, enum qeth_discipline_id);
 void qeth_core_free_discipline(struct qeth_card *);
-void qeth_buffer_reclaim_work(struct work_struct *);
 
 /* exports for qeth discipline device drivers */
 extern struct qeth_card_list_struct qeth_core_card_list;
@@ -913,7 +900,6 @@ int qeth_core_hardsetup_card(struct qeth_card *);
 void qeth_print_status_message(struct qeth_card *);
 int qeth_init_qdio_queues(struct qeth_card *);
 int qeth_send_startlan(struct qeth_card *);
-int qeth_send_stoplan(struct qeth_card *);
 int qeth_send_ipa_cmd(struct qeth_card *, struct qeth_cmd_buffer *,
                   int (*reply_cb)
                   (struct qeth_card *, struct qeth_reply *, unsigned long),
@@ -954,8 +940,6 @@ int qeth_snmp_command(struct qeth_card *, char __user *);
 int qeth_query_oat_command(struct qeth_card *, char __user *);
 int qeth_query_switch_attributes(struct qeth_card *card,
                                   struct qeth_switch_info *sw_info);
-int qeth_query_card_info(struct qeth_card *card,
-        struct carrier_info *carrier_info);
 int qeth_send_control_data(struct qeth_card *, int, struct qeth_cmd_buffer *,
         int (*reply_cb)(struct qeth_card *, struct qeth_reply*, unsigned long),
         void *reply_param);
diff --git a/drivers/s390/net/qeth_core_main.c b/drivers/s390/net/qeth_core_main.c
index fd22c811cbe1..f407e3763432 100644
--- a/drivers/s390/net/qeth_core_main.c
+++ b/drivers/s390/net/qeth_core_main.c
@@ -718,6 +718,13 @@ static int qeth_check_idx_response(struct qeth_card *card,
         return 0;
 }
 
+static struct qeth_card *CARD_FROM_CDEV(struct ccw_device *cdev)
+{
+        struct qeth_card *card = dev_get_drvdata(&((struct ccwgroup_device *)
+                dev_get_drvdata(&cdev->dev))->dev);
+        return card;
+}
+
 static void qeth_setup_ccw(struct qeth_channel *channel, unsigned char *iob,
                 __u32 len)
 {
@@ -1431,6 +1438,7 @@ static void qeth_start_kernel_thread(struct work_struct *work)
         }
 }
 
+static void qeth_buffer_reclaim_work(struct work_struct *);
 static int qeth_setup_card(struct qeth_card *card)
 {
 
@@ -3232,7 +3240,7 @@ int qeth_check_qdio_errors(struct qeth_card *card, struct qdio_buffer *buf,
 }
 EXPORT_SYMBOL_GPL(qeth_check_qdio_errors);
 
-void qeth_buffer_reclaim_work(struct work_struct *work)
+static void qeth_buffer_reclaim_work(struct work_struct *work)
 {
         struct qeth_card *card = container_of(work, struct qeth_card,
                 buffer_reclaim_work.work);
@@ -4126,7 +4134,7 @@ static int qeth_setadp_promisc_mode_cb(struct qeth_card *card,
 
         qeth_default_setadapterparms_cb(card, reply, (unsigned long)cmd);
         if (cmd->hdr.return_code) {
-                QETH_CARD_TEXT_(card, 4, "prmrc%2.2x", cmd->hdr.return_code);
+                QETH_CARD_TEXT_(card, 4, "prmrc%x", cmd->hdr.return_code);
                 setparms->data.mode = SET_PROMISC_MODE_OFF;
         }
         card->info.promisc_mode = setparms->data.mode;
@@ -4493,13 +4501,13 @@ static int qeth_snmp_command_cb(struct qeth_card *card,
         snmp = &cmd->data.setadapterparms.data.snmp;
 
         if (cmd->hdr.return_code) {
-                QETH_CARD_TEXT_(card, 4, "scer1%i", cmd->hdr.return_code);
+                QETH_CARD_TEXT_(card, 4, "scer1%x", cmd->hdr.return_code);
                 return 0;
         }
         if (cmd->data.setadapterparms.hdr.return_code) {
                 cmd->hdr.return_code =
                         cmd->data.setadapterparms.hdr.return_code;
-                QETH_CARD_TEXT_(card, 4, "scer2%i", cmd->hdr.return_code);
+                QETH_CARD_TEXT_(card, 4, "scer2%x", cmd->hdr.return_code);
                 return 0;
         }
         data_len = *((__u16 *)QETH_IPA_PDU_LEN_PDU1(data));
@@ -4717,7 +4725,7 @@ static int qeth_query_card_info_cb(struct qeth_card *card,
         return 0;
 }
 
-int qeth_query_card_info(struct qeth_card *card,
+static int qeth_query_card_info(struct qeth_card *card,
                                 struct carrier_info *carrier_info)
 {
         struct qeth_cmd_buffer *iob;
@@ -4730,7 +4738,6 @@ int qeth_query_card_info(struct qeth_card *card,
         return qeth_send_ipa_cmd(card, iob, qeth_query_card_info_cb,
                                         (void *)carrier_info);
 }
-EXPORT_SYMBOL_GPL(qeth_query_card_info);
 
 static inline int qeth_get_qdio_q_format(struct qeth_card *card)
 {
@@ -5113,6 +5120,11 @@ static inline int qeth_create_skb_frag(struct qeth_qdio_buffer *qethbuffer,
         return 0;
 }
 
+static inline int qeth_is_last_sbale(struct qdio_buffer_element *sbale)
+{
+        return (sbale->eflags & SBAL_EFLAGS_LAST_ENTRY);
+}
+
 struct sk_buff *qeth_core_get_next_skb(struct qeth_card *card,
                 struct qeth_qdio_buffer *qethbuffer,
                 struct qdio_buffer_element **__element, int *__offset,
diff --git a/drivers/s390/net/qeth_l2_main.c b/drivers/s390/net/qeth_l2_main.c
index c2679bfe7f66..d02cd1a67943 100644
--- a/drivers/s390/net/qeth_l2_main.c
+++ b/drivers/s390/net/qeth_l2_main.c
@@ -1512,7 +1512,7 @@ static void qeth_bridge_state_change(struct qeth_card *card,
 
         QETH_CARD_TEXT(card, 2, "brstchng");
         if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) {
-                QETH_CARD_TEXT_(card, 2, "BPsz%.8d", qports->entry_length);
+                QETH_CARD_TEXT_(card, 2, "BPsz%04x", qports->entry_length);
                 return;
         }
         extrasize = sizeof(struct qeth_sbp_port_entry) * qports->num_entries;
diff --git a/drivers/s390/net/qeth_l3.h b/drivers/s390/net/qeth_l3.h
index 29c1c00e3a0f..551a4b4c03fd 100644
--- a/drivers/s390/net/qeth_l3.h
+++ b/drivers/s390/net/qeth_l3.h
@@ -42,10 +42,6 @@ struct qeth_ipato_entry {
 };
 
 
-void qeth_l3_ipaddr4_to_string(const __u8 *, char *);
-int qeth_l3_string_to_ipaddr4(const char *, __u8 *);
-void qeth_l3_ipaddr6_to_string(const __u8 *, char *);
-int qeth_l3_string_to_ipaddr6(const char *, __u8 *);
 void qeth_l3_ipaddr_to_string(enum qeth_prot_versions, const __u8 *, char *);
 int qeth_l3_string_to_ipaddr(const char *, enum qeth_prot_versions, __u8 *);
 int qeth_l3_create_device_attributes(struct device *);
diff --git a/drivers/s390/net/qeth_l3_main.c b/drivers/s390/net/qeth_l3_main.c
index afebb9709763..625227ad16ee 100644
--- a/drivers/s390/net/qeth_l3_main.c
+++ b/drivers/s390/net/qeth_l3_main.c
@@ -55,12 +55,12 @@ static int qeth_l3_isxdigit(char *buf)
         return 1;
 }
 
-void qeth_l3_ipaddr4_to_string(const __u8 *addr, char *buf)
+static void qeth_l3_ipaddr4_to_string(const __u8 *addr, char *buf)
 {
         sprintf(buf, "%i.%i.%i.%i", addr[0], addr[1], addr[2], addr[3]);
 }
 
-int qeth_l3_string_to_ipaddr4(const char *buf, __u8 *addr)
+static int qeth_l3_string_to_ipaddr4(const char *buf, __u8 *addr)
 {
         int count = 0, rc = 0;
         unsigned int in[4];
@@ -78,12 +78,12 @@ int qeth_l3_string_to_ipaddr4(const char *buf, __u8 *addr)
         return 0;
 }
 
-void qeth_l3_ipaddr6_to_string(const __u8 *addr, char *buf)
+static void qeth_l3_ipaddr6_to_string(const __u8 *addr, char *buf)
 {
         sprintf(buf, "%pI6", addr);
 }
 
-int qeth_l3_string_to_ipaddr6(const char *buf, __u8 *addr)
+static int qeth_l3_string_to_ipaddr6(const char *buf, __u8 *addr)
 {
         const char *end, *end_tmp, *start;
         __u16 *in;
@@ -2502,7 +2502,7 @@ static int qeth_l3_arp_query(struct qeth_card *card, char __user *udata)
                         rc = -EFAULT;
                         goto free_and_out;
                 }
-                QETH_CARD_TEXT_(card, 4, "qacts");
+                QETH_CARD_TEXT(card, 4, "qacts");
         }
 free_and_out:
         kfree(qinfo.udata);
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index ff560537dd61..7121a2e97ce2 100644
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -42,6 +42,7 @@ struct ipv6_devconf {
         __s32           accept_ra_from_local;
 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
         __s32           optimistic_dad;
+        __s32           use_optimistic;
 #endif
 #ifdef CONFIG_IPV6_MROUTE
         __s32           mc_forwarding;
diff --git a/include/linux/marvell_phy.h b/include/linux/marvell_phy.h
index 8e9a029e093d..e6982ac3200d 100644
--- a/include/linux/marvell_phy.h
+++ b/include/linux/marvell_phy.h
@@ -16,6 +16,7 @@
 #define MARVELL_PHY_ID_88E1318S         0x01410e90
 #define MARVELL_PHY_ID_88E1116R         0x01410e40
 #define MARVELL_PHY_ID_88E1510          0x01410dd0
+#define MARVELL_PHY_ID_88E3016          0x01410e60
 
 /* struct phy_device dev_flags definitions */
 #define MARVELL_PHY_M1145_FLAGS_RESISTANCE      0x00000001
diff --git a/include/linux/mlx4/cmd.h b/include/linux/mlx4/cmd.h
index 379c02648ab3..ff5f5deb3dcf 100644
--- a/include/linux/mlx4/cmd.h
+++ b/include/linux/mlx4/cmd.h
@@ -67,6 +67,8 @@ enum {
         MLX4_CMD_MAP_ICM_AUX     = 0xffc,
         MLX4_CMD_UNMAP_ICM_AUX   = 0xffb,
         MLX4_CMD_SET_ICM_SIZE    = 0xffd,
+        MLX4_CMD_ACCESS_REG      = 0x3b,
+
         /*master notify fw on finish for slave's flr*/
         MLX4_CMD_INFORM_FLR_DONE = 0x5b,
         MLX4_CMD_GET_OP_REQ      = 0x59,
diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index 37e4404d0227..e4c136ebe79b 100644
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -186,7 +186,9 @@ enum {
         MLX4_DEV_CAP_FLAG2_VXLAN_OFFLOADS       = 1LL <<  10,
         MLX4_DEV_CAP_FLAG2_MAD_DEMUX            = 1LL <<  11,
         MLX4_DEV_CAP_FLAG2_CQE_STRIDE           = 1LL <<  12,
-        MLX4_DEV_CAP_FLAG2_EQE_STRIDE           = 1LL <<  13
+        MLX4_DEV_CAP_FLAG2_EQE_STRIDE           = 1LL <<  13,
+        MLX4_DEV_CAP_FLAG2_ETH_PROT_CTRL        = 1LL <<  14,
+        MLX4_DEV_CAP_FLAG2_ETH_BACKPL_AN_REP    = 1LL <<  15
 };
 
 enum {
@@ -379,6 +381,13 @@ enum {
 #define MSTR_SM_CHANGE_MASK (MLX4_EQ_PORT_INFO_MSTR_SM_SL_CHANGE_MASK | \
                              MLX4_EQ_PORT_INFO_MSTR_SM_LID_CHANGE_MASK)
 
+enum mlx4_module_id {
+        MLX4_MODULE_ID_SFP              = 0x3,
+        MLX4_MODULE_ID_QSFP             = 0xC,
+        MLX4_MODULE_ID_QSFP_PLUS        = 0xD,
+        MLX4_MODULE_ID_QSFP28           = 0x11,
+};
+
 static inline u64 mlx4_fw_ver(u64 major, u64 minor, u64 subminor)
 {
         return (major << 32) | (minor << 16) | subminor;
@@ -799,6 +808,26 @@ struct mlx4_init_port_param {
         u64                     si_guid;
 };
 
+#define MAD_IFC_DATA_SZ 192
+/* MAD IFC Mailbox */
+struct mlx4_mad_ifc {
+        u8      base_version;
+        u8      mgmt_class;
+        u8      class_version;
+        u8      method;
+        __be16  status;
+        __be16  class_specific;
+        __be64  tid;
+        __be16  attr_id;
+        __be16  resv;
+        __be32  attr_mod;
+        __be64  mkey;
+        __be16  dr_slid;
+        __be16  dr_dlid;
+        u8      reserved[28];
+        u8      data[MAD_IFC_DATA_SZ];
+} __packed;
+
 #define mlx4_foreach_port(port, dev, type)                              \
         for ((port) = 1; (port) <= (dev)->caps.num_ports; (port)++)     \
                 if ((type) == (dev)->caps.port_mask[(port)])
@@ -1283,10 +1312,50 @@ int mlx4_mr_rereg_mem_write(struct mlx4_dev *dev, struct mlx4_mr *mr,
                             u64 iova, u64 size, int npages,
                             int page_shift, struct mlx4_mpt_entry *mpt_entry);
 
+int mlx4_get_module_info(struct mlx4_dev *dev, u8 port,
+                         u16 offset, u16 size, u8 *data);
+
 /* Returns true if running in low memory profile (kdump kernel) */
 static inline bool mlx4_low_memory_profile(void)
 {
         return is_kdump_kernel();
 }
 
+/* ACCESS REG commands */
+enum mlx4_access_reg_method {
+        MLX4_ACCESS_REG_QUERY = 0x1,
+        MLX4_ACCESS_REG_WRITE = 0x2,
+};
+
+/* ACCESS PTYS Reg command */
+enum mlx4_ptys_proto {
+        MLX4_PTYS_IB = 1<<0,
+        MLX4_PTYS_EN = 1<<2,
+};
+
+struct mlx4_ptys_reg {
+        u8 resrvd1;
+        u8 local_port;
+        u8 resrvd2;
+        u8 proto_mask;
+        __be32 resrvd3[2];
+        __be32 eth_proto_cap;
+        __be16 ib_width_cap;
+        __be16 ib_speed_cap;
+        __be32 resrvd4;
+        __be32 eth_proto_admin;
+        __be16 ib_width_admin;
+        __be16 ib_speed_admin;
+        __be32 resrvd5;
+        __be32 eth_proto_oper;
+        __be16 ib_width_oper;
+        __be16 ib_speed_oper;
+        __be32 resrvd6;
+        __be32 eth_proto_lp_adv;
+} __packed;
+
+int mlx4_ACCESS_PTYS_REG(struct mlx4_dev *dev,
+                         enum mlx4_access_reg_method method,
+                         struct mlx4_ptys_reg *ptys_reg);
+
 #endif /* MLX4_DEVICE_H */
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 74fd5d37f15a..c85e06512246 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -386,6 +386,7 @@ typedef enum rx_handler_result rx_handler_result_t;
 typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb);
 
 void __napi_schedule(struct napi_struct *n);
+void __napi_schedule_irqoff(struct napi_struct *n);
 
 static inline bool napi_disable_pending(struct napi_struct *n)
 {
@@ -420,6 +421,18 @@ static inline void napi_schedule(struct napi_struct *n)
                 __napi_schedule(n);
 }
 
+/**
+ *      napi_schedule_irqoff - schedule NAPI poll
+ *      @n: napi context
+ *
+ * Variant of napi_schedule(), assuming hard irqs are masked.
+ */
+static inline void napi_schedule_irqoff(struct napi_struct *n)
+{
+        if (napi_schedule_prep(n))
+                __napi_schedule_irqoff(n);
+}
+
 /* Try to reschedule poll. Called by dev->poll() after napi_complete().  */
 static inline bool napi_reschedule(struct napi_struct *napi)
 {
diff --git a/include/linux/pxa168_eth.h b/include/linux/pxa168_eth.h
index 18d75e795606..e1ab6e86cdb3 100644
--- a/include/linux/pxa168_eth.h
+++ b/include/linux/pxa168_eth.h
@@ -4,6 +4,8 @@
 #ifndef __LINUX_PXA168_ETH_H
 #define __LINUX_PXA168_ETH_H
 
+#include <linux/phy.h>
+
 struct pxa168_eth_platform_data {
         int     port_number;
         int     phy_addr;
@@ -13,6 +15,7 @@ struct pxa168_eth_platform_data {
          */
         int     speed;          /* 0, SPEED_10, SPEED_100 */
         int     duplex;         /* DUPLEX_HALF or DUPLEX_FULL */
+        phy_interface_t intf;
 
         /*
          * Override default RX/TX queue sizes if nonzero.
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index c2dee7deefa8..f566b8567892 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -204,10 +204,10 @@ struct tcp_sock {
 
         u16     urg_data;       /* Saved octet of OOB data and control flags */
         u8      ecn_flags;      /* ECN status bits.                     */
-        u8      reordering;     /* Packet reordering metric.            */
+        u8      keepalive_probes; /* num of allowed keep alive probes   */
+        u32     reordering;     /* Packet reordering metric.            */
         u32     snd_up;         /* Urgent pointer               */
 
-        u8      keepalive_probes; /* num of allowed keep alive probes   */
 /*
  *      Options received (usually on last packet, some only on SYN packets).
  */
diff --git a/include/net/dsa.h b/include/net/dsa.h
index b76559293535..ed3c34bbb67a 100644
--- a/include/net/dsa.h
+++ b/include/net/dsa.h
@@ -38,6 +38,9 @@ struct dsa_chip_data {
         struct device   *host_dev;
         int             sw_addr;
 
+        /* set to size of eeprom if supported by the switch */
+        int             eeprom_len;
+
         /* Device tree node pointer for this specific switch chip
          * used during switch setup in case additional properties
          * and resources needs to be used
@@ -139,6 +142,14 @@ struct dsa_switch {
          */
         struct device           *master_dev;
 
+#ifdef CONFIG_NET_DSA_HWMON
+        /*
+         * Hardware monitoring information
+         */
+        char                    hwmon_name[IFNAMSIZ + 8];
+        struct device           *hwmon_dev;
+#endif
+
         /*
          * Slave mii_bus and devices for the individual ports.
          */
@@ -242,6 +253,28 @@ struct dsa_switch_driver {
                            struct ethtool_eee *e);
         int     (*get_eee)(struct dsa_switch *ds, int port,
                            struct ethtool_eee *e);
+
+#ifdef CONFIG_NET_DSA_HWMON
+        /* Hardware monitoring */
+        int     (*get_temp)(struct dsa_switch *ds, int *temp);
+        int     (*get_temp_limit)(struct dsa_switch *ds, int *temp);
+        int     (*set_temp_limit)(struct dsa_switch *ds, int temp);
+        int     (*get_temp_alarm)(struct dsa_switch *ds, bool *alarm);
+#endif
+
+        /* EEPROM access */
+        int     (*get_eeprom_len)(struct dsa_switch *ds);
+        int     (*get_eeprom)(struct dsa_switch *ds,
+                              struct ethtool_eeprom *eeprom, u8 *data);
+        int     (*set_eeprom)(struct dsa_switch *ds,
+                              struct ethtool_eeprom *eeprom, u8 *data);
+
+        /*
+         * Register access.
+         */
+        int     (*get_regs_len)(struct dsa_switch *ds, int port);
+        void    (*get_regs)(struct dsa_switch *ds, int port,
+                            struct ethtool_regs *regs, void *p);
 };
 
 void register_switch_driver(struct dsa_switch_driver *type);
diff --git a/include/net/ipx.h b/include/net/ipx.h
index 0143180fecc9..320f47b64a7a 100644
--- a/include/net/ipx.h
+++ b/include/net/ipx.h
@@ -42,6 +42,9 @@ struct ipxhdr {
         struct ipx_address      ipx_source __packed;
 };
 
+/* From af_ipx.c */
+extern int sysctl_ipx_pprop_broadcasting;
+
 static __inline__ struct ipxhdr *ipx_hdr(struct sk_buff *skb)
 {
         return (struct ipxhdr *)skb_transport_header(skb);
diff --git a/include/net/neighbour.h b/include/net/neighbour.h
index f60558d0254c..dedfb188b1a7 100644
--- a/include/net/neighbour.h
+++ b/include/net/neighbour.h
@@ -69,7 +69,7 @@ struct neigh_parms {
         struct net *net;
 #endif
         struct net_device *dev;
-        struct neigh_parms *next;
+        struct list_head list;
         int     (*neigh_setup)(struct neighbour *);
         void    (*neigh_cleanup)(struct neighbour *);
         struct neigh_table *tbl;
@@ -203,6 +203,7 @@ struct neigh_table {
         void                    (*proxy_redo)(struct sk_buff *skb);
         char                    *id;
         struct neigh_parms      parms;
+        struct list_head        parms_list;
         int                     gc_interval;
         int                     gc_thresh1;
         int                     gc_thresh2;
diff --git a/include/net/netlink.h b/include/net/netlink.h
index 7b903e1bdbbb..64158353ecb2 100644
--- a/include/net/netlink.h
+++ b/include/net/netlink.h
@@ -1185,4 +1185,14 @@ static inline int nla_validate_nested(const struct nlattr *start, int maxtype,
 #define nla_for_each_nested(pos, nla, rem) \
         nla_for_each_attr(pos, nla_data(nla), nla_len(nla), rem)
 
+/**
+ * nla_is_last - Test if attribute is last in stream
+ * @nla: attribute to test
+ * @rem: bytes remaining in stream
+ */
+static inline bool nla_is_last(const struct nlattr *nla, int rem)
+{
+        return nla->nla_len == rem;
+}
+
 #endif
diff --git a/include/net/sctp/structs.h b/include/net/sctp/structs.h
index 4ff3f67be62c..806e3b5b3351 100644
--- a/include/net/sctp/structs.h
+++ b/include/net/sctp/structs.h
@@ -1116,7 +1116,6 @@ int sctp_raw_to_bind_addrs(struct sctp_bind_addr *bp, __u8 *raw, int len,
 sctp_scope_t sctp_scope(const union sctp_addr *);
 int sctp_in_scope(struct net *net, const union sctp_addr *addr, const sctp_scope_t scope);
 int sctp_is_any(struct sock *sk, const union sctp_addr *addr);
-int sctp_addr_is_valid(const union sctp_addr *addr);
 int sctp_is_ep_boundall(struct sock *sk);
 
 
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 4062b4f0d121..3a35b1500359 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -55,9 +55,9 @@ void tcp_time_wait(struct sock *sk, int state, int timeo);
 #define MAX_TCP_HEADER  (128 + MAX_HEADER)
 #define MAX_TCP_OPTION_SPACE 40
 
-/* 
+/*
  * Never offer a window over 32767 without using window scaling. Some
- * poor stacks do signed 16bit maths! 
+ * poor stacks do signed 16bit maths!
  */
 #define MAX_TCP_WINDOW          32767U
 
@@ -70,9 +70,6 @@ void tcp_time_wait(struct sock *sk, int state, int timeo);
 /* After receiving this amount of duplicate ACKs fast retransmit starts. */
 #define TCP_FASTRETRANS_THRESH 3
 
-/* Maximal reordering. */
-#define TCP_MAX_REORDERING      127
-
 /* Maximal number of ACKs sent quickly to accelerate slow-start. */
 #define TCP_MAX_QUICKACKS       16U
 
@@ -167,7 +164,7 @@ void tcp_time_wait(struct sock *sk, int state, int timeo);
 /*
  *      TCP option
  */
- 
+
 #define TCPOPT_NOP              1       /* Padding */
 #define TCPOPT_EOL              0       /* End of options */
 #define TCPOPT_MSS              2       /* Segment size negotiating */
@@ -252,6 +249,7 @@ extern int sysctl_tcp_abort_on_overflow;
 extern int sysctl_tcp_max_orphans;
 extern int sysctl_tcp_fack;
 extern int sysctl_tcp_reordering;
+extern int sysctl_tcp_max_reordering;
 extern int sysctl_tcp_dsack;
 extern long sysctl_tcp_mem[3];
 extern int sysctl_tcp_wmem[3];
@@ -1104,16 +1102,16 @@ static inline int tcp_win_from_space(int space)
                 space - (space>>sysctl_tcp_adv_win_scale);
 }
 
-/* Note: caller must be prepared to deal with negative returns */ 
+/* Note: caller must be prepared to deal with negative returns */
 static inline int tcp_space(const struct sock *sk)
 {
         return tcp_win_from_space(sk->sk_rcvbuf -
                                   atomic_read(&sk->sk_rmem_alloc));
-} 
+}
 
 static inline int tcp_full_space(const struct sock *sk)
 {
-        return tcp_win_from_space(sk->sk_rcvbuf); 
+        return tcp_win_from_space(sk->sk_rcvbuf);
 }
 
 static inline void tcp_openreq_init(struct request_sock *req,
diff --git a/include/uapi/linux/ethtool.h b/include/uapi/linux/ethtool.h
index 99b43056a6fe..eb2095b42fbb 100644
--- a/include/uapi/linux/ethtool.h
+++ b/include/uapi/linux/ethtool.h
@@ -1213,6 +1213,10 @@ enum ethtool_sfeatures_retval_bits {
 #define SUPPORTED_40000baseCR4_Full     (1 << 24)
 #define SUPPORTED_40000baseSR4_Full     (1 << 25)
 #define SUPPORTED_40000baseLR4_Full     (1 << 26)
+#define SUPPORTED_56000baseKR4_Full     (1 << 27)
+#define SUPPORTED_56000baseCR4_Full     (1 << 28)
+#define SUPPORTED_56000baseSR4_Full     (1 << 29)
+#define SUPPORTED_56000baseLR4_Full     (1 << 30)
 
 #define ADVERTISED_10baseT_Half         (1 << 0)
 #define ADVERTISED_10baseT_Full         (1 << 1)
@@ -1241,6 +1245,10 @@ enum ethtool_sfeatures_retval_bits {
 #define ADVERTISED_40000baseCR4_Full    (1 << 24)
 #define ADVERTISED_40000baseSR4_Full    (1 << 25)
 #define ADVERTISED_40000baseLR4_Full    (1 << 26)
+#define ADVERTISED_56000baseKR4_Full    (1 << 27)
+#define ADVERTISED_56000baseCR4_Full    (1 << 28)
+#define ADVERTISED_56000baseSR4_Full    (1 << 29)
+#define ADVERTISED_56000baseLR4_Full    (1 << 30)
 
 /* The following are all involved in forcing a particular link
  * mode for the device for setting things.  When getting the
@@ -1248,12 +1256,16 @@ enum ethtool_sfeatures_retval_bits {
  * it was forced up into this mode or autonegotiated.
  */
 
-/* The forced speed, 10Mb, 100Mb, gigabit, 2.5Gb, 10GbE. */
+/* The forced speed, 10Mb, 100Mb, gigabit, [2.5|10|20|40|56]GbE. */
 #define SPEED_10                10
 #define SPEED_100               100
 #define SPEED_1000              1000
 #define SPEED_2500              2500
 #define SPEED_10000             10000
+#define SPEED_20000             20000
+#define SPEED_40000             40000
+#define SPEED_56000             56000
+
 #define SPEED_UNKNOWN           -1
 
 /* Duplex, half or full. */
@@ -1343,6 +1355,10 @@ enum ethtool_sfeatures_retval_bits {
 #define ETH_MODULE_SFF_8079_LEN         256
 #define ETH_MODULE_SFF_8472             0x2
 #define ETH_MODULE_SFF_8472_LEN         512
+#define ETH_MODULE_SFF_8636             0x3
+#define ETH_MODULE_SFF_8636_LEN         256
+#define ETH_MODULE_SFF_8436             0x4
+#define ETH_MODULE_SFF_8436_LEN         256
 
 /* Reset flags */
 /* The reset() operation must clear the flags for the components which
diff --git a/include/uapi/linux/if_link.h b/include/uapi/linux/if_link.h
index 0bdb77e16875..7072d8325016 100644
--- a/include/uapi/linux/if_link.h
+++ b/include/uapi/linux/if_link.h
@@ -243,6 +243,7 @@ enum {
         IFLA_BRPORT_FAST_LEAVE, /* multicast fast leave    */
         IFLA_BRPORT_LEARNING,   /* mac learning */
         IFLA_BRPORT_UNICAST_FLOOD, /* flood unicast traffic */
+        IFLA_BRPORT_PROXYARP,   /* proxy ARP */
         __IFLA_BRPORT_MAX
 };
 #define IFLA_BRPORT_MAX (__IFLA_BRPORT_MAX - 1)
diff --git a/include/uapi/linux/ipv6.h b/include/uapi/linux/ipv6.h
index efa2666f4b8a..e863d088b9a5 100644
--- a/include/uapi/linux/ipv6.h
+++ b/include/uapi/linux/ipv6.h
@@ -164,6 +164,7 @@ enum {
         DEVCONF_MLDV2_UNSOLICITED_REPORT_INTERVAL,
         DEVCONF_SUPPRESS_FRAG_NDISC,
         DEVCONF_ACCEPT_RA_FROM_LOCAL,
+        DEVCONF_USE_OPTIMISTIC,
         DEVCONF_MAX
 };
 
diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index 9f81818f2941..b6a1f7c14a67 100644
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -153,22 +153,19 @@ struct reg_state {
 
 enum bpf_stack_slot_type {
         STACK_INVALID,    /* nothing was stored in this stack slot */
-        STACK_SPILL,      /* 1st byte of register spilled into stack */
-        STACK_SPILL_PART, /* other 7 bytes of register spill */
+        STACK_SPILL,      /* register spilled into stack */
         STACK_MISC        /* BPF program wrote some data into this slot */
 };
 
-struct bpf_stack_slot {
-        enum bpf_stack_slot_type stype;
-        struct reg_state reg_st;
-};
+#define BPF_REG_SIZE 8  /* size of eBPF register in bytes */
 
 /* state of the program:
  * type of all registers and stack info
  */
 struct verifier_state {
         struct reg_state regs[MAX_BPF_REG];
-        struct bpf_stack_slot stack[MAX_BPF_STACK];
+        u8 stack_slot_type[MAX_BPF_STACK];
+        struct reg_state spilled_regs[MAX_BPF_STACK / BPF_REG_SIZE];
 };
 
 /* linked list of verifier states used to prune search */
@@ -259,10 +256,10 @@ static void print_verifier_state(struct verifier_env *env)
                                 env->cur_state.regs[i].map_ptr->key_size,
                                 env->cur_state.regs[i].map_ptr->value_size);
         }
-        for (i = 0; i < MAX_BPF_STACK; i++) {
-                if (env->cur_state.stack[i].stype == STACK_SPILL)
+        for (i = 0; i < MAX_BPF_STACK; i += BPF_REG_SIZE) {
+                if (env->cur_state.stack_slot_type[i] == STACK_SPILL)
                         verbose(" fp%d=%s", -MAX_BPF_STACK + i,
-                                reg_type_str[env->cur_state.stack[i].reg_st.type]);
+                                reg_type_str[env->cur_state.spilled_regs[i / BPF_REG_SIZE].type]);
         }
         verbose("\n");
 }
@@ -539,8 +536,10 @@ static int bpf_size_to_bytes(int bpf_size)
 static int check_stack_write(struct verifier_state *state, int off, int size,
                              int value_regno)
 {
-        struct bpf_stack_slot *slot;
         int i;
+        /* caller checked that off % size == 0 and -MAX_BPF_STACK <= off < 0,
+         * so it's aligned access and [off, off + size) are within stack limits
+         */
 
         if (value_regno >= 0 &&
             (state->regs[value_regno].type == PTR_TO_MAP_VALUE ||
@@ -548,30 +547,24 @@ static int check_stack_write(struct verifier_state *state, int off, int size,
              state->regs[value_regno].type == PTR_TO_CTX)) {
 
                 /* register containing pointer is being spilled into stack */
-                if (size != 8) {
+                if (size != BPF_REG_SIZE) {
                         verbose("invalid size of register spill\n");
                         return -EACCES;
                 }
 
-                slot = &state->stack[MAX_BPF_STACK + off];
-                slot->stype = STACK_SPILL;
                 /* save register state */
-                slot->reg_st = state->regs[value_regno];
-                for (i = 1; i < 8; i++) {
-                        slot = &state->stack[MAX_BPF_STACK + off + i];
-                        slot->stype = STACK_SPILL_PART;
-                        slot->reg_st.type = UNKNOWN_VALUE;
-                        slot->reg_st.map_ptr = NULL;
-                }
-        } else {
+                state->spilled_regs[(MAX_BPF_STACK + off) / BPF_REG_SIZE] =
+                        state->regs[value_regno];
 
+                for (i = 0; i < BPF_REG_SIZE; i++)
+                        state->stack_slot_type[MAX_BPF_STACK + off + i] = STACK_SPILL;
+        } else {
                 /* regular write of data into stack */
-                for (i = 0; i < size; i++) {
-                        slot = &state->stack[MAX_BPF_STACK + off + i];
-                        slot->stype = STACK_MISC;
-                        slot->reg_st.type = UNKNOWN_VALUE;
-                        slot->reg_st.map_ptr = NULL;
-                }
+                state->spilled_regs[(MAX_BPF_STACK + off) / BPF_REG_SIZE] =
+                        (struct reg_state) {};
+
+                for (i = 0; i < size; i++)
+                        state->stack_slot_type[MAX_BPF_STACK + off + i] = STACK_MISC;
         }
         return 0;
 }
@@ -579,19 +572,18 @@ static int check_stack_write(struct verifier_state *state, int off, int size,
 static int check_stack_read(struct verifier_state *state, int off, int size,
                             int value_regno)
 {
+        u8 *slot_type;
         int i;
-        struct bpf_stack_slot *slot;
 
-        slot = &state->stack[MAX_BPF_STACK + off];
+        slot_type = &state->stack_slot_type[MAX_BPF_STACK + off];
 
-        if (slot->stype == STACK_SPILL) {
-                if (size != 8) {
+        if (slot_type[0] == STACK_SPILL) {
+                if (size != BPF_REG_SIZE) {
                         verbose("invalid size of register spill\n");
                         return -EACCES;
                 }
-                for (i = 1; i < 8; i++) {
-                        if (state->stack[MAX_BPF_STACK + off + i].stype !=
-                            STACK_SPILL_PART) {
+                for (i = 1; i < BPF_REG_SIZE; i++) {
+                        if (slot_type[i] != STACK_SPILL) {
                                 verbose("corrupted spill memory\n");
                                 return -EACCES;
                         }
@@ -599,12 +591,12 @@ static int check_stack_read(struct verifier_state *state, int off, int size,
 
                 if (value_regno >= 0)
                         /* restore register state from stack */
-                        state->regs[value_regno] = slot->reg_st;
+                        state->regs[value_regno] =
+                                state->spilled_regs[(MAX_BPF_STACK + off) / BPF_REG_SIZE];
                 return 0;
         } else {
                 for (i = 0; i < size; i++) {
-                        if (state->stack[MAX_BPF_STACK + off + i].stype !=
-                            STACK_MISC) {
+                        if (slot_type[i] != STACK_MISC) {
                                 verbose("invalid read from stack off %d+%d size %d\n",
                                         off, i, size);
                                 return -EACCES;
@@ -747,7 +739,7 @@ static int check_stack_boundary(struct verifier_env *env,
         }
 
         for (i = 0; i < access_size; i++) {
-                if (state->stack[MAX_BPF_STACK + off + i].stype != STACK_MISC) {
+                if (state->stack_slot_type[MAX_BPF_STACK + off + i] != STACK_MISC) {
                         verbose("invalid indirect read from stack off %d+%d size %d\n",
                                 off, i, access_size);
                         return -EACCES;
@@ -1417,12 +1409,33 @@ static bool states_equal(struct verifier_state *old, struct verifier_state *cur)
         }
 
         for (i = 0; i < MAX_BPF_STACK; i++) {
-                if (memcmp(&old->stack[i], &cur->stack[i],
-                           sizeof(old->stack[0])) != 0) {
-                        if (old->stack[i].stype == STACK_INVALID)
-                                continue;
+                if (old->stack_slot_type[i] == STACK_INVALID)
+                        continue;
+                if (old->stack_slot_type[i] != cur->stack_slot_type[i])
+                        /* Ex: old explored (safe) state has STACK_SPILL in
+                         * this stack slot, but current has has STACK_MISC ->
+                         * this verifier states are not equivalent,
+                         * return false to continue verification of this path
+                         */
                         return false;
-                }
+                if (i % BPF_REG_SIZE)
+                        continue;
+                if (memcmp(&old->spilled_regs[i / BPF_REG_SIZE],
+                           &cur->spilled_regs[i / BPF_REG_SIZE],
+                           sizeof(old->spilled_regs[0])))
+                        /* when explored and current stack slot types are
+                         * the same, check that stored pointers types
+                         * are the same as well.
+                         * Ex: explored safe path could have stored
+                         * (struct reg_state) {.type = PTR_TO_STACK, .imm = -8}
+                         * but current path has stored:
+                         * (struct reg_state) {.type = PTR_TO_STACK, .imm = -16}
+                         * such verifier states are not equivalent.
+                         * return false to continue verification of this path
+                         */
+                        return false;
+                else
+                        continue;
         }
         return true;
 }
diff --git a/lib/test_bpf.c b/lib/test_bpf.c
index 23e070bcf72d..3f167d2eeb94 100644
--- a/lib/test_bpf.c
+++ b/lib/test_bpf.c
@@ -1756,6 +1756,49 @@ static struct bpf_test tests[] = {
                 { },
                 { { 0, 1 } }
         },
+        {
+                "nmap reduced",
+                .u.insns_int = {
+                        BPF_MOV64_REG(R6, R1),
+                        BPF_LD_ABS(BPF_H, 12),
+                        BPF_JMP_IMM(BPF_JNE, R0, 0x806, 28),
+                        BPF_LD_ABS(BPF_H, 12),
+                        BPF_JMP_IMM(BPF_JNE, R0, 0x806, 26),
+                        BPF_MOV32_IMM(R0, 18),
+                        BPF_STX_MEM(BPF_W, R10, R0, -64),
+                        BPF_LDX_MEM(BPF_W, R7, R10, -64),
+                        BPF_LD_IND(BPF_W, R7, 14),
+                        BPF_STX_MEM(BPF_W, R10, R0, -60),
+                        BPF_MOV32_IMM(R0, 280971478),
+                        BPF_STX_MEM(BPF_W, R10, R0, -56),
+                        BPF_LDX_MEM(BPF_W, R7, R10, -56),
+                        BPF_LDX_MEM(BPF_W, R0, R10, -60),
+                        BPF_ALU32_REG(BPF_SUB, R0, R7),
+                        BPF_JMP_IMM(BPF_JNE, R0, 0, 15),
+                        BPF_LD_ABS(BPF_H, 12),
+                        BPF_JMP_IMM(BPF_JNE, R0, 0x806, 13),
+                        BPF_MOV32_IMM(R0, 22),
+                        BPF_STX_MEM(BPF_W, R10, R0, -56),
+                        BPF_LDX_MEM(BPF_W, R7, R10, -56),
+                        BPF_LD_IND(BPF_H, R7, 14),
+                        BPF_STX_MEM(BPF_W, R10, R0, -52),
+                        BPF_MOV32_IMM(R0, 17366),
+                        BPF_STX_MEM(BPF_W, R10, R0, -48),
+                        BPF_LDX_MEM(BPF_W, R7, R10, -48),
+                        BPF_LDX_MEM(BPF_W, R0, R10, -52),
+                        BPF_ALU32_REG(BPF_SUB, R0, R7),
+                        BPF_JMP_IMM(BPF_JNE, R0, 0, 2),
+                        BPF_MOV32_IMM(R0, 256),
+                        BPF_EXIT_INSN(),
+                        BPF_MOV32_IMM(R0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                INTERNAL,
+                { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x06, 0, 0,
+                  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                  0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6},
+                { { 38, 256 } }
+        },
 };
 
 static struct net_device dev;
diff --git a/net/bridge/br_forward.c b/net/bridge/br_forward.c
index 44cb786b925a..f96933a823e3 100644
--- a/net/bridge/br_forward.c
+++ b/net/bridge/br_forward.c
@@ -184,6 +184,11 @@ static void br_flood(struct net_bridge *br, struct sk_buff *skb,
                 /* Do not flood unicast traffic to ports that turn it off */
                 if (unicast && !(p->flags & BR_FLOOD))
                         continue;
+
+                /* Do not flood to ports that enable proxy ARP */
+                if (p->flags & BR_PROXYARP)
+                        continue;
+
                 prev = maybe_deliver(prev, p, skb, __packet_hook);
                 if (IS_ERR(prev))
                         goto out;
diff --git a/net/bridge/br_input.c b/net/bridge/br_input.c
index 6fd5522df696..1f1de715197c 100644
--- a/net/bridge/br_input.c
+++ b/net/bridge/br_input.c
@@ -16,6 +16,8 @@
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
 #include <linux/netfilter_bridge.h>
+#include <linux/neighbour.h>
+#include <net/arp.h>
 #include <linux/export.h>
 #include <linux/rculist.h>
 #include "br_private.h"
@@ -57,6 +59,60 @@ static int br_pass_frame_up(struct sk_buff *skb)
                        netif_receive_skb);
 }
 
+static void br_do_proxy_arp(struct sk_buff *skb, struct net_bridge *br,
+                            u16 vid)
+{
+        struct net_device *dev = br->dev;
+        struct neighbour *n;
+        struct arphdr *parp;
+        u8 *arpptr, *sha;
+        __be32 sip, tip;
+
+        if (dev->flags & IFF_NOARP)
+                return;
+
+        if (!pskb_may_pull(skb, arp_hdr_len(dev))) {
+                dev->stats.tx_dropped++;
+                return;
+        }
+        parp = arp_hdr(skb);
+
+        if (parp->ar_pro != htons(ETH_P_IP) ||
+            parp->ar_op != htons(ARPOP_REQUEST) ||
+            parp->ar_hln != dev->addr_len ||
+            parp->ar_pln != 4)
+                return;
+
+        arpptr = (u8 *)parp + sizeof(struct arphdr);
+        sha = arpptr;
+        arpptr += dev->addr_len;        /* sha */
+        memcpy(&sip, arpptr, sizeof(sip));
+        arpptr += sizeof(sip);
+        arpptr += dev->addr_len;        /* tha */
+        memcpy(&tip, arpptr, sizeof(tip));
+
+        if (ipv4_is_loopback(tip) ||
+            ipv4_is_multicast(tip))
+                return;
+
+        n = neigh_lookup(&arp_tbl, &tip, dev);
+        if (n) {
+                struct net_bridge_fdb_entry *f;
+
+                if (!(n->nud_state & NUD_VALID)) {
+                        neigh_release(n);
+                        return;
+                }
+
+                f = __br_fdb_get(br, n->ha, vid);
+                if (f)
+                        arp_send(ARPOP_REPLY, ETH_P_ARP, sip, skb->dev, tip,
+                                 sha, n->ha, sha);
+
+                neigh_release(n);
+        }
+}
+
 /* note: already called with rcu_read_lock */
 int br_handle_frame_finish(struct sk_buff *skb)
 {
@@ -98,6 +154,10 @@ int br_handle_frame_finish(struct sk_buff *skb)
         dst = NULL;
 
         if (is_broadcast_ether_addr(dest)) {
+                if (p->flags & BR_PROXYARP &&
+                    skb->protocol == htons(ETH_P_ARP))
+                        br_do_proxy_arp(skb, br, vid);
+
                 skb2 = skb;
                 unicast = false;
         } else if (is_multicast_ether_addr(dest)) {
diff --git a/net/bridge/br_netlink.c b/net/bridge/br_netlink.c
index 2ff9706647f2..86c239b06f6e 100644
--- a/net/bridge/br_netlink.c
+++ b/net/bridge/br_netlink.c
@@ -60,7 +60,8 @@ static int br_port_fill_attrs(struct sk_buff *skb,
             nla_put_u8(skb, IFLA_BRPORT_PROTECT, !!(p->flags & BR_ROOT_BLOCK)) ||
             nla_put_u8(skb, IFLA_BRPORT_FAST_LEAVE, !!(p->flags & BR_MULTICAST_FAST_LEAVE)) ||
             nla_put_u8(skb, IFLA_BRPORT_LEARNING, !!(p->flags & BR_LEARNING)) ||
-            nla_put_u8(skb, IFLA_BRPORT_UNICAST_FLOOD, !!(p->flags & BR_FLOOD)))
+            nla_put_u8(skb, IFLA_BRPORT_UNICAST_FLOOD, !!(p->flags & BR_FLOOD)) ||
+            nla_put_u8(skb, IFLA_BRPORT_PROXYARP, !!(p->flags & BR_PROXYARP)))
                 return -EMSGSIZE;
 
         return 0;
@@ -332,6 +333,7 @@ static int br_setport(struct net_bridge_port *p, struct nlattr *tb[])
         br_set_port_flag(p, tb, IFLA_BRPORT_PROTECT, BR_ROOT_BLOCK);
         br_set_port_flag(p, tb, IFLA_BRPORT_LEARNING, BR_LEARNING);
         br_set_port_flag(p, tb, IFLA_BRPORT_UNICAST_FLOOD, BR_FLOOD);
+        br_set_port_flag(p, tb, IFLA_BRPORT_PROXYARP, BR_PROXYARP);
 
         if (tb[IFLA_BRPORT_COST]) {
                 err = br_stp_set_path_cost(p, nla_get_u32(tb[IFLA_BRPORT_COST]));
diff --git a/net/bridge/br_private.h b/net/bridge/br_private.h
index 4d783d071305..8f3f08140258 100644
--- a/net/bridge/br_private.h
+++ b/net/bridge/br_private.h
@@ -172,6 +172,7 @@ struct net_bridge_port
 #define BR_FLOOD                0x00000040
 #define BR_AUTO_MASK (BR_FLOOD | BR_LEARNING)
 #define BR_PROMISC              0x00000080
+#define BR_PROXYARP             0x00000100
 
 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
         struct bridge_mcast_own_query   ip4_own_query;
diff --git a/net/bridge/br_sysfs_if.c b/net/bridge/br_sysfs_if.c
index e561cd59b8a6..2de5d91199e8 100644
--- a/net/bridge/br_sysfs_if.c
+++ b/net/bridge/br_sysfs_if.c
@@ -170,6 +170,7 @@ BRPORT_ATTR_FLAG(bpdu_guard, BR_BPDU_GUARD);
 BRPORT_ATTR_FLAG(root_block, BR_ROOT_BLOCK);
 BRPORT_ATTR_FLAG(learning, BR_LEARNING);
 BRPORT_ATTR_FLAG(unicast_flood, BR_FLOOD);
+BRPORT_ATTR_FLAG(proxyarp, BR_PROXYARP);
 
 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
 static ssize_t show_multicast_router(struct net_bridge_port *p, char *buf)
@@ -213,6 +214,7 @@ static const struct brport_attribute *brport_attrs[] = {
         &brport_attr_multicast_router,
         &brport_attr_multicast_fast_leave,
 #endif
+        &brport_attr_proxyarp,
         NULL
 };
 
diff --git a/net/core/dev.c b/net/core/dev.c
index 945bbd001359..ebf778df58cd 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -4376,7 +4376,8 @@ static int process_backlog(struct napi_struct *napi, int quota)
  * __napi_schedule - schedule for receive
  * @n: entry to schedule
  *
- * The entry's receive function will be scheduled to run
+ * The entry's receive function will be scheduled to run.
+ * Consider using __napi_schedule_irqoff() if hard irqs are masked.
  */
 void __napi_schedule(struct napi_struct *n)
 {
@@ -4388,6 +4389,18 @@ void __napi_schedule(struct napi_struct *n)
 }
 EXPORT_SYMBOL(__napi_schedule);
 
+/**
+ * __napi_schedule_irqoff - schedule for receive
+ * @n: entry to schedule
+ *
+ * Variant of __napi_schedule() assuming hard irqs are masked
+ */
+void __napi_schedule_irqoff(struct napi_struct *n)
+{
+        ____napi_schedule(this_cpu_ptr(&softnet_data), n);
+}
+EXPORT_SYMBOL(__napi_schedule_irqoff);
+
 void __napi_complete(struct napi_struct *n)
 {
         BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
diff --git a/net/core/neighbour.c b/net/core/neighbour.c
index ef31fef25e5a..edd04116ecb7 100644
--- a/net/core/neighbour.c
+++ b/net/core/neighbour.c
@@ -773,7 +773,7 @@ static void neigh_periodic_work(struct work_struct *work)
         if (time_after(jiffies, tbl->last_rand + 300 * HZ)) {
                 struct neigh_parms *p;
                 tbl->last_rand = jiffies;
-                for (p = &tbl->parms; p; p = p->next)
+                list_for_each_entry(p, &tbl->parms_list, list)
                         p->reachable_time =
                                 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
         }
@@ -1446,7 +1446,7 @@ static inline struct neigh_parms *lookup_neigh_parms(struct neigh_table *tbl,
 {
         struct neigh_parms *p;
 
-        for (p = &tbl->parms; p; p = p->next) {
+        list_for_each_entry(p, &tbl->parms_list, list) {
                 if ((p->dev && p->dev->ifindex == ifindex && net_eq(neigh_parms_net(p), net)) ||
                     (!p->dev && !ifindex && net_eq(net, &init_net)))
                         return p;
@@ -1481,8 +1481,7 @@ struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
                 }
 
                 write_lock_bh(&tbl->lock);
-                p->next         = tbl->parms.next;
-                tbl->parms.next = p;
+                list_add(&p->list, &tbl->parms.list);
                 write_unlock_bh(&tbl->lock);
 
                 neigh_parms_data_state_cleanall(p);
@@ -1501,24 +1500,15 @@ static void neigh_rcu_free_parms(struct rcu_head *head)
 
 void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms)
 {
-        struct neigh_parms **p;
-
         if (!parms || parms == &tbl->parms)
                 return;
         write_lock_bh(&tbl->lock);
-        for (p = &tbl->parms.next; *p; p = &(*p)->next) {
-                if (*p == parms) {
-                        *p = parms->next;
-                        parms->dead = 1;
-                        write_unlock_bh(&tbl->lock);
-                        if (parms->dev)
-                                dev_put(parms->dev);
-                        call_rcu(&parms->rcu_head, neigh_rcu_free_parms);
-                        return;
-                }
-        }
+        list_del(&parms->list);
+        parms->dead = 1;
         write_unlock_bh(&tbl->lock);
-        neigh_dbg(1, "%s: not found\n", __func__);
+        if (parms->dev)
+                dev_put(parms->dev);
+        call_rcu(&parms->rcu_head, neigh_rcu_free_parms);
 }
 EXPORT_SYMBOL(neigh_parms_release);
 
@@ -1535,6 +1525,8 @@ static void neigh_table_init_no_netlink(struct neigh_table *tbl)
         unsigned long now = jiffies;
         unsigned long phsize;
 
+        INIT_LIST_HEAD(&tbl->parms_list);
+        list_add(&tbl->parms.list, &tbl->parms_list);
         write_pnet(&tbl->parms.net, &init_net);
         atomic_set(&tbl->parms.refcnt, 1);
         tbl->parms.reachable_time =
@@ -2154,7 +2146,9 @@ static int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
                                        NLM_F_MULTI) <= 0)
                         break;
 
-                for (nidx = 0, p = tbl->parms.next; p; p = p->next) {
+                nidx = 0;
+                p = list_next_entry(&tbl->parms, list);
+                list_for_each_entry_from(p, &tbl->parms_list, list) {
                         if (!net_eq(neigh_parms_net(p), net))
                                 continue;
 
diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index c16615bfb61e..e48e5c02e877 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -3099,6 +3099,16 @@ perform_csum_check:
          * (see validate_xmit_skb_list() for example)
          */
         segs->prev = tail;
+
+        /* Following permits correct backpressure, for protocols
+         * using skb_set_owner_w().
+         * Idea is to tranfert ownership from head_skb to last segment.
+         */
+        if (head_skb->destructor == sock_wfree) {
+                swap(tail->truesize, head_skb->truesize);
+                swap(tail->destructor, head_skb->destructor);
+                swap(tail->sk, head_skb->sk);
+        }
         return segs;
 
 err:
diff --git a/net/dsa/Kconfig b/net/dsa/Kconfig
index a585fd6352eb..5f8ac404535b 100644
--- a/net/dsa/Kconfig
+++ b/net/dsa/Kconfig
@@ -11,6 +11,17 @@ config NET_DSA
 
 if NET_DSA
 
+config NET_DSA_HWMON
+        bool "Distributed Switch Architecture HWMON support"
+        default y
+        depends on HWMON && !(NET_DSA=y && HWMON=m)
+        ---help---
+          Say Y if you want to expose thermal sensor data on switches supported
+          by the Distributed Switch Architecture.
+
+          Some of those switches contain thermal sensors. This data is available
+          via the hwmon sysfs interface and exposes the onboard sensors.
+
 # tagging formats
 config NET_DSA_TAG_BRCM
         bool
diff --git a/net/dsa/dsa.c b/net/dsa/dsa.c
index 6317b41c99b0..dd646a8025cb 100644
--- a/net/dsa/dsa.c
+++ b/net/dsa/dsa.c
@@ -9,6 +9,9 @@
  * (at your option) any later version.
  */
 
+#include <linux/ctype.h>
+#include <linux/device.h>
+#include <linux/hwmon.h>
 #include <linux/list.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
@@ -17,6 +20,7 @@
 #include <linux/of.h>
 #include <linux/of_mdio.h>
 #include <linux/of_platform.h>
+#include <linux/sysfs.h>
 #include "dsa_priv.h"
 
 char dsa_driver_version[] = "0.1";
@@ -71,6 +75,104 @@ dsa_switch_probe(struct device *host_dev, int sw_addr, char **_name)
         return ret;
 }
 
+/* hwmon support ************************************************************/
+
+#ifdef CONFIG_NET_DSA_HWMON
+
+static ssize_t temp1_input_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct dsa_switch *ds = dev_get_drvdata(dev);
+        int temp, ret;
+
+        ret = ds->drv->get_temp(ds, &temp);
+        if (ret < 0)
+                return ret;
+
+        return sprintf(buf, "%d\n", temp * 1000);
+}
+static DEVICE_ATTR_RO(temp1_input);
+
+static ssize_t temp1_max_show(struct device *dev,
+                              struct device_attribute *attr, char *buf)
+{
+        struct dsa_switch *ds = dev_get_drvdata(dev);
+        int temp, ret;
+
+        ret = ds->drv->get_temp_limit(ds, &temp);
+        if (ret < 0)
+                return ret;
+
+        return sprintf(buf, "%d\n", temp * 1000);
+}
+
+static ssize_t temp1_max_store(struct device *dev,
+                               struct device_attribute *attr, const char *buf,
+                               size_t count)
+{
+        struct dsa_switch *ds = dev_get_drvdata(dev);
+        int temp, ret;
+
+        ret = kstrtoint(buf, 0, &temp);
+        if (ret < 0)
+                return ret;
+
+        ret = ds->drv->set_temp_limit(ds, DIV_ROUND_CLOSEST(temp, 1000));
+        if (ret < 0)
+                return ret;
+
+        return count;
+}
+static DEVICE_ATTR(temp1_max, S_IRUGO, temp1_max_show, temp1_max_store);
+
+static ssize_t temp1_max_alarm_show(struct device *dev,
+                                    struct device_attribute *attr, char *buf)
+{
+        struct dsa_switch *ds = dev_get_drvdata(dev);
+        bool alarm;
+        int ret;
+
+        ret = ds->drv->get_temp_alarm(ds, &alarm);
+        if (ret < 0)
+                return ret;
+
+        return sprintf(buf, "%d\n", alarm);
+}
+static DEVICE_ATTR_RO(temp1_max_alarm);
+
+static struct attribute *dsa_hwmon_attrs[] = {
+        &dev_attr_temp1_input.attr,     /* 0 */
+        &dev_attr_temp1_max.attr,       /* 1 */
+        &dev_attr_temp1_max_alarm.attr, /* 2 */
+        NULL
+};
+
+static umode_t dsa_hwmon_attrs_visible(struct kobject *kobj,
+                                       struct attribute *attr, int index)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct dsa_switch *ds = dev_get_drvdata(dev);
+        struct dsa_switch_driver *drv = ds->drv;
+        umode_t mode = attr->mode;
+
+        if (index == 1) {
+                if (!drv->get_temp_limit)
+                        mode = 0;
+                else if (drv->set_temp_limit)
+                        mode |= S_IWUSR;
+        } else if (index == 2 && !drv->get_temp_alarm) {
+                mode = 0;
+        }
+        return mode;
+}
+
+static const struct attribute_group dsa_hwmon_group = {
+        .attrs = dsa_hwmon_attrs,
+        .is_visible = dsa_hwmon_attrs_visible,
+};
+__ATTRIBUTE_GROUPS(dsa_hwmon);
+
+#endif /* CONFIG_NET_DSA_HWMON */
 
 /* basic switch operations **************************************************/
 static struct dsa_switch *
@@ -228,6 +330,31 @@ dsa_switch_setup(struct dsa_switch_tree *dst, int index,
                 ds->ports[i] = slave_dev;
         }
 
+#ifdef CONFIG_NET_DSA_HWMON
+        /* If the switch provides a temperature sensor,
+         * register with hardware monitoring subsystem.
+         * Treat registration error as non-fatal and ignore it.
+         */
+        if (drv->get_temp) {
+                const char *netname = netdev_name(dst->master_netdev);
+                char hname[IFNAMSIZ + 1];
+                int i, j;
+
+                /* Create valid hwmon 'name' attribute */
+                for (i = j = 0; i < IFNAMSIZ && netname[i]; i++) {
+                        if (isalnum(netname[i]))
+                                hname[j++] = netname[i];
+                }
+                hname[j] = '\0';
+                scnprintf(ds->hwmon_name, sizeof(ds->hwmon_name), "%s_dsa%d",
+                          hname, index);
+                ds->hwmon_dev = hwmon_device_register_with_groups(NULL,
+                                        ds->hwmon_name, ds, dsa_hwmon_groups);
+                if (IS_ERR(ds->hwmon_dev))
+                        ds->hwmon_dev = NULL;
+        }
+#endif /* CONFIG_NET_DSA_HWMON */
+
         return ds;
 
 out_free:
@@ -239,6 +366,10 @@ out:
 
 static void dsa_switch_destroy(struct dsa_switch *ds)
 {
+#ifdef CONFIG_NET_DSA_HWMON
+        if (ds->hwmon_dev)
+                hwmon_device_unregister(ds->hwmon_dev);
+#endif
 }
 
 #ifdef CONFIG_PM_SLEEP
@@ -447,6 +578,7 @@ static int dsa_of_probe(struct platform_device *pdev)
         const char *port_name;
         int chip_index, port_index;
         const unsigned int *sw_addr, *port_reg;
+        u32 eeprom_len;
         int ret;
 
         mdio = of_parse_phandle(np, "dsa,mii-bus", 0);
@@ -498,6 +630,9 @@ static int dsa_of_probe(struct platform_device *pdev)
                 if (cd->sw_addr > PHY_MAX_ADDR)
                         continue;
 
+                if (!of_property_read_u32(np, "eeprom-length", &eeprom_len))
+                        cd->eeprom_len = eeprom_len;
+
                 for_each_available_child_of_node(child, port) {
                         port_reg = of_get_property(port, "reg", NULL);
                         if (!port_reg)
diff --git a/net/dsa/slave.c b/net/dsa/slave.c
index 6d1817449c36..474f2962590a 100644
--- a/net/dsa/slave.c
+++ b/net/dsa/slave.c
@@ -249,6 +249,27 @@ static void dsa_slave_get_drvinfo(struct net_device *dev,
         strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info));
 }
 
+static int dsa_slave_get_regs_len(struct net_device *dev)
+{
+        struct dsa_slave_priv *p = netdev_priv(dev);
+        struct dsa_switch *ds = p->parent;
+
+        if (ds->drv->get_regs_len)
+                return ds->drv->get_regs_len(ds, p->port);
+
+        return -EOPNOTSUPP;
+}
+
+static void
+dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
+{
+        struct dsa_slave_priv *p = netdev_priv(dev);
+        struct dsa_switch *ds = p->parent;
+
+        if (ds->drv->get_regs)
+                ds->drv->get_regs(ds, p->port, regs, _p);
+}
+
 static int dsa_slave_nway_reset(struct net_device *dev)
 {
         struct dsa_slave_priv *p = netdev_priv(dev);
@@ -271,6 +292,44 @@ static u32 dsa_slave_get_link(struct net_device *dev)
         return -EOPNOTSUPP;
 }
 
+static int dsa_slave_get_eeprom_len(struct net_device *dev)
+{
+        struct dsa_slave_priv *p = netdev_priv(dev);
+        struct dsa_switch *ds = p->parent;
+
+        if (ds->pd->eeprom_len)
+                return ds->pd->eeprom_len;
+
+        if (ds->drv->get_eeprom_len)
+                return ds->drv->get_eeprom_len(ds);
+
+        return 0;
+}
+
+static int dsa_slave_get_eeprom(struct net_device *dev,
+                                struct ethtool_eeprom *eeprom, u8 *data)
+{
+        struct dsa_slave_priv *p = netdev_priv(dev);
+        struct dsa_switch *ds = p->parent;
+
+        if (ds->drv->get_eeprom)
+                return ds->drv->get_eeprom(ds, eeprom, data);
+
+        return -EOPNOTSUPP;
+}
+
+static int dsa_slave_set_eeprom(struct net_device *dev,
+                                struct ethtool_eeprom *eeprom, u8 *data)
+{
+        struct dsa_slave_priv *p = netdev_priv(dev);
+        struct dsa_switch *ds = p->parent;
+
+        if (ds->drv->set_eeprom)
+                return ds->drv->set_eeprom(ds, eeprom, data);
+
+        return -EOPNOTSUPP;
+}
+
 static void dsa_slave_get_strings(struct net_device *dev,
                                   uint32_t stringset, uint8_t *data)
 {
@@ -385,8 +444,13 @@ static const struct ethtool_ops dsa_slave_ethtool_ops = {
         .get_settings           = dsa_slave_get_settings,
         .set_settings           = dsa_slave_set_settings,
         .get_drvinfo            = dsa_slave_get_drvinfo,
+        .get_regs_len           = dsa_slave_get_regs_len,
+        .get_regs               = dsa_slave_get_regs,
         .nway_reset             = dsa_slave_nway_reset,
         .get_link               = dsa_slave_get_link,
+        .get_eeprom_len         = dsa_slave_get_eeprom_len,
+        .get_eeprom             = dsa_slave_get_eeprom,
+        .set_eeprom             = dsa_slave_set_eeprom,
         .get_strings            = dsa_slave_get_strings,
         .get_ethtool_stats      = dsa_slave_get_ethtool_stats,
         .get_sset_count         = dsa_slave_get_sset_count,
diff --git a/net/dsa/tag_dsa.c b/net/dsa/tag_dsa.c
index ce90c8bdc658..2dab27063273 100644
--- a/net/dsa/tag_dsa.c
+++ b/net/dsa/tag_dsa.c
@@ -63,8 +63,6 @@ static netdev_tx_t dsa_xmit(struct sk_buff *skb, struct net_device *dev)
                 dsa_header[3] = 0x00;
         }
 
-        skb->protocol = htons(ETH_P_DSA);
-
         skb->dev = p->parent->dst->master_netdev;
         dev_queue_xmit(skb);
 
diff --git a/net/dsa/tag_edsa.c b/net/dsa/tag_edsa.c
index 94fcce778679..9aeda596f7ec 100644
--- a/net/dsa/tag_edsa.c
+++ b/net/dsa/tag_edsa.c
@@ -76,8 +76,6 @@ static netdev_tx_t edsa_xmit(struct sk_buff *skb, struct net_device *dev)
                 edsa_header[7] = 0x00;
         }
 
-        skb->protocol = htons(ETH_P_EDSA);
-
         skb->dev = p->parent->dst->master_netdev;
         dev_queue_xmit(skb);
 
diff --git a/net/dsa/tag_trailer.c b/net/dsa/tag_trailer.c
index 115fdca34077..e268f9db8893 100644
--- a/net/dsa/tag_trailer.c
+++ b/net/dsa/tag_trailer.c
@@ -57,8 +57,6 @@ static netdev_tx_t trailer_xmit(struct sk_buff *skb, struct net_device *dev)
         trailer[2] = 0x10;
         trailer[3] = 0x00;
 
-        nskb->protocol = htons(ETH_P_TRAILER);
-
         nskb->dev = p->parent->dst->master_netdev;
         dev_queue_xmit(nskb);
 
diff --git a/net/ipv4/geneve.c b/net/ipv4/geneve.c
index 065cd94c640c..91861fe77ed1 100644
--- a/net/ipv4/geneve.c
+++ b/net/ipv4/geneve.c
@@ -104,7 +104,7 @@ static void geneve_build_header(struct genevehdr *geneveh,
         memcpy(geneveh->options, options, options_len);
 }
 
-/* Transmit a fully formated Geneve frame.
+/* Transmit a fully formatted Geneve frame.
  *
  * When calling this function. The skb->data should point
  * to the geneve header which is fully formed.
diff --git a/net/ipv4/ipconfig.c b/net/ipv4/ipconfig.c
index 648fa1490ea7..a896da50f398 100644
--- a/net/ipv4/ipconfig.c
+++ b/net/ipv4/ipconfig.c
@@ -498,7 +498,7 @@ ic_rarp_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt
         struct arphdr *rarp;
         unsigned char *rarp_ptr;
         __be32 sip, tip;
-        unsigned char *sha, *tha;               /* s for "source", t for "target" */
+        unsigned char *tha;             /* t for "target" */
         struct ic_device *d;
 
         if (!net_eq(dev_net(dev), &init_net))
@@ -549,7 +549,6 @@ ic_rarp_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt
                 goto drop_unlock;       /* should never happen */
 
         /* Extract variable-width fields */
-        sha = rarp_ptr;
         rarp_ptr += dev->addr_len;
         memcpy(&sip, rarp_ptr, 4);
         rarp_ptr += 4;
diff --git a/net/ipv4/syncookies.c b/net/ipv4/syncookies.c
index 32b98d0207b4..4ac7bcaf2f46 100644
--- a/net/ipv4/syncookies.c
+++ b/net/ipv4/syncookies.c
@@ -275,8 +275,11 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb)
         if (!sysctl_tcp_syncookies || !th->ack || th->rst)
                 goto out;
 
-        if (tcp_synq_no_recent_overflow(sk) ||
-            (mss = __cookie_v4_check(ip_hdr(skb), th, cookie)) == 0) {
+        if (tcp_synq_no_recent_overflow(sk))
+                goto out;
+
+        mss = __cookie_v4_check(ip_hdr(skb), th, cookie);
+        if (mss == 0) {
                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SYNCOOKIESFAILED);
                 goto out;
         }
diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
index b3c53c8b331e..e0ee384a448f 100644
--- a/net/ipv4/sysctl_net_ipv4.c
+++ b/net/ipv4/sysctl_net_ipv4.c
@@ -496,6 +496,13 @@ static struct ctl_table ipv4_table[] = {
                 .proc_handler   = proc_dointvec
         },
         {
+                .procname       = "tcp_max_reordering",
+                .data           = &sysctl_tcp_max_reordering,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = proc_dointvec
+        },
+        {
                 .procname       = "tcp_dsack",
                 .data           = &sysctl_tcp_dsack,
                 .maxlen         = sizeof(int),
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index a12b455928e5..4e4617e90417 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -81,6 +81,7 @@ int sysctl_tcp_window_scaling __read_mostly = 1;
 int sysctl_tcp_sack __read_mostly = 1;
 int sysctl_tcp_fack __read_mostly = 1;
 int sysctl_tcp_reordering __read_mostly = TCP_FASTRETRANS_THRESH;
+int sysctl_tcp_max_reordering __read_mostly = 300;
 EXPORT_SYMBOL(sysctl_tcp_reordering);
 int sysctl_tcp_dsack __read_mostly = 1;
 int sysctl_tcp_app_win __read_mostly = 31;
@@ -833,7 +834,7 @@ static void tcp_update_reordering(struct sock *sk, const int metric,
         if (metric > tp->reordering) {
                 int mib_idx;
 
-                tp->reordering = min(TCP_MAX_REORDERING, metric);
+                tp->reordering = min(sysctl_tcp_max_reordering, metric);
 
                 /* This exciting event is worth to be remembered. 8) */
                 if (ts)
@@ -5028,7 +5029,7 @@ static bool tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,
         /* step 3: check security and precedence [ignored] */
 
         /* step 4: Check for a SYN
-         * RFC 5691 4.2 : Send a challenge ack
+         * RFC 5961 4.2 : Send a challenge ack
          */
         if (th->syn) {
 syn_challenge:
@@ -5865,7 +5866,7 @@ static inline void pr_drop_req(struct request_sock *req, __u16 port, int family)
  * If we receive a SYN packet with these bits set, it means a
  * network is playing bad games with TOS bits. In order to
  * avoid possible false congestion notifications, we disable
- * TCP ECN negociation.
+ * TCP ECN negotiation.
  *
  * Exception: tcp_ca wants ECN. This is required for DCTCP
  * congestion control; it requires setting ECT on all packets,
diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
index 0169ccf5aa4f..06e897832a7a 100644
--- a/net/ipv6/addrconf.c
+++ b/net/ipv6/addrconf.c
@@ -1170,6 +1170,9 @@ enum {
         IPV6_SADDR_RULE_PRIVACY,
         IPV6_SADDR_RULE_ORCHID,
         IPV6_SADDR_RULE_PREFIX,
+#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
+        IPV6_SADDR_RULE_NOT_OPTIMISTIC,
+#endif
         IPV6_SADDR_RULE_MAX
 };
 
@@ -1197,6 +1200,15 @@ static inline int ipv6_saddr_preferred(int type)
         return 0;
 }
 
+static inline bool ipv6_use_optimistic_addr(struct inet6_dev *idev)
+{
+#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
+        return idev && idev->cnf.optimistic_dad && idev->cnf.use_optimistic;
+#else
+        return false;
+#endif
+}
+
 static int ipv6_get_saddr_eval(struct net *net,
                                struct ipv6_saddr_score *score,
                                struct ipv6_saddr_dst *dst,
@@ -1257,10 +1269,16 @@ static int ipv6_get_saddr_eval(struct net *net,
                 score->scopedist = ret;
                 break;
         case IPV6_SADDR_RULE_PREFERRED:
+            {
                 /* Rule 3: Avoid deprecated and optimistic addresses */
+                u8 avoid = IFA_F_DEPRECATED;
+
+                if (!ipv6_use_optimistic_addr(score->ifa->idev))
+                        avoid |= IFA_F_OPTIMISTIC;
                 ret = ipv6_saddr_preferred(score->addr_type) ||
-                      !(score->ifa->flags & (IFA_F_DEPRECATED|IFA_F_OPTIMISTIC));
+                      !(score->ifa->flags & avoid);
                 break;
+            }
 #ifdef CONFIG_IPV6_MIP6
         case IPV6_SADDR_RULE_HOA:
             {
@@ -1306,6 +1324,14 @@ static int ipv6_get_saddr_eval(struct net *net,
                         ret = score->ifa->prefix_len;
                 score->matchlen = ret;
                 break;
+#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
+        case IPV6_SADDR_RULE_NOT_OPTIMISTIC:
+                /* Optimistic addresses still have lower precedence than other
+                 * preferred addresses.
+                 */
+                ret = !(score->ifa->flags & IFA_F_OPTIMISTIC);
+                break;
+#endif
         default:
                 ret = 0;
         }
@@ -2315,8 +2341,8 @@ ok:
                         else
                                 stored_lft = 0;
                         if (!update_lft && !create && stored_lft) {
-                                const u32 minimum_lft = min(
-                                        stored_lft, (u32)MIN_VALID_LIFETIME);
+                                const u32 minimum_lft = min_t(u32,
+                                        stored_lft, MIN_VALID_LIFETIME);
                                 valid_lft = max(valid_lft, minimum_lft);
 
                                 /* RFC4862 Section 5.5.3e:
@@ -3222,8 +3248,15 @@ static void addrconf_dad_begin(struct inet6_ifaddr *ifp)
          * Optimistic nodes can start receiving
          * Frames right away
          */
-        if (ifp->flags & IFA_F_OPTIMISTIC)
+        if (ifp->flags & IFA_F_OPTIMISTIC) {
                 ip6_ins_rt(ifp->rt);
+                if (ipv6_use_optimistic_addr(idev)) {
+                        /* Because optimistic nodes can use this address,
+                         * notify listeners. If DAD fails, RTM_DELADDR is sent.
+                         */
+                        ipv6_ifa_notify(RTM_NEWADDR, ifp);
+                }
+        }
 
         addrconf_dad_kick(ifp);
 out:
@@ -4330,6 +4363,7 @@ static inline void ipv6_store_devconf(struct ipv6_devconf *cnf,
         array[DEVCONF_ACCEPT_SOURCE_ROUTE] = cnf->accept_source_route;
 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
         array[DEVCONF_OPTIMISTIC_DAD] = cnf->optimistic_dad;
+        array[DEVCONF_USE_OPTIMISTIC] = cnf->use_optimistic;
 #endif
 #ifdef CONFIG_IPV6_MROUTE
         array[DEVCONF_MC_FORWARDING] = cnf->mc_forwarding;
@@ -5156,6 +5190,14 @@ static struct addrconf_sysctl_table
                         .proc_handler   = proc_dointvec,
 
                 },
+                {
+                        .procname       = "use_optimistic",
+                        .data           = &ipv6_devconf.use_optimistic,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
+
+                },
 #endif
 #ifdef CONFIG_IPV6_MROUTE
                 {
diff --git a/net/ipv6/exthdrs.c b/net/ipv6/exthdrs.c
index bfde361b6134..601d896f22d0 100644
--- a/net/ipv6/exthdrs.c
+++ b/net/ipv6/exthdrs.c
@@ -47,7 +47,7 @@
 #include <net/xfrm.h>
 #endif
 
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 
 /*
  *      Parsing tlv encoded headers.
diff --git a/net/ipv6/icmp.c b/net/ipv6/icmp.c
index 97ae70077a4f..62c1037d9e83 100644
--- a/net/ipv6/icmp.c
+++ b/net/ipv6/icmp.c
@@ -1009,4 +1009,3 @@ struct ctl_table * __net_init ipv6_icmp_sysctl_init(struct net *net)
         return table;
 }
 #endif
-
diff --git a/net/ipv6/ip6_tunnel.c b/net/ipv6/ip6_tunnel.c
index 9409887fb664..8c97cd1048c2 100644
--- a/net/ipv6/ip6_tunnel.c
+++ b/net/ipv6/ip6_tunnel.c
@@ -477,6 +477,7 @@ ip6_tnl_err(struct sk_buff *skb, __u8 ipproto, struct inet6_skb_parm *opt,
         int rel_msg = 0;
         u8 rel_type = ICMPV6_DEST_UNREACH;
         u8 rel_code = ICMPV6_ADDR_UNREACH;
+        u8 tproto;
         __u32 rel_info = 0;
         __u16 len;
         int err = -ENOENT;
@@ -490,7 +491,8 @@ ip6_tnl_err(struct sk_buff *skb, __u8 ipproto, struct inet6_skb_parm *opt,
                                         &ipv6h->saddr)) == NULL)
                 goto out;
 
-        if (t->parms.proto != ipproto && t->parms.proto != 0)
+        tproto = ACCESS_ONCE(t->parms.proto);
+        if (tproto != ipproto && tproto != 0)
                 goto out;
 
         err = 0;
@@ -791,6 +793,7 @@ static int ip6_tnl_rcv(struct sk_buff *skb, __u16 protocol,
 {
         struct ip6_tnl *t;
         const struct ipv6hdr *ipv6h = ipv6_hdr(skb);
+        u8 tproto;
         int err;
 
         rcu_read_lock();
@@ -799,7 +802,8 @@ static int ip6_tnl_rcv(struct sk_buff *skb, __u16 protocol,
                                         &ipv6h->daddr)) != NULL) {
                 struct pcpu_sw_netstats *tstats;
 
-                if (t->parms.proto != ipproto && t->parms.proto != 0) {
+                tproto = ACCESS_ONCE(t->parms.proto);
+                if (tproto != ipproto && tproto != 0) {
                         rcu_read_unlock();
                         goto discard;
                 }
@@ -1078,9 +1082,11 @@ ip4ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev)
         struct flowi6 fl6;
         __u8 dsfield;
         __u32 mtu;
+        u8 tproto;
         int err;
 
-        if ((t->parms.proto != IPPROTO_IPIP && t->parms.proto != 0) ||
+        tproto = ACCESS_ONCE(t->parms.proto);
+        if ((tproto != IPPROTO_IPIP && tproto != 0) ||
             !ip6_tnl_xmit_ctl(t))
                 return -1;
 
@@ -1120,9 +1126,11 @@ ip6ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev)
         struct flowi6 fl6;
         __u8 dsfield;
         __u32 mtu;
+        u8 tproto;
         int err;
 
-        if ((t->parms.proto != IPPROTO_IPV6 && t->parms.proto != 0) ||
+        tproto = ACCESS_ONCE(t->parms.proto);
+        if ((tproto != IPPROTO_IPV6 && tproto != 0) ||
             !ip6_tnl_xmit_ctl(t) || ip6_tnl_addr_conflict(t, ipv6h))
                 return -1;
 
@@ -1285,6 +1293,14 @@ static int ip6_tnl_update(struct ip6_tnl *t, struct __ip6_tnl_parm *p)
         return err;
 }
 
+static int ip6_tnl0_update(struct ip6_tnl *t, struct __ip6_tnl_parm *p)
+{
+        /* for default tnl0 device allow to change only the proto */
+        t->parms.proto = p->proto;
+        netdev_state_change(t->dev);
+        return 0;
+}
+
 static void
 ip6_tnl_parm_from_user(struct __ip6_tnl_parm *p, const struct ip6_tnl_parm *u)
 {
@@ -1384,7 +1400,7 @@ ip6_tnl_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
                         break;
                 ip6_tnl_parm_from_user(&p1, &p);
                 t = ip6_tnl_locate(net, &p1, cmd == SIOCADDTUNNEL);
-                if (dev != ip6n->fb_tnl_dev && cmd == SIOCCHGTUNNEL) {
+                if (cmd == SIOCCHGTUNNEL) {
                         if (t != NULL) {
                                 if (t->dev != dev) {
                                         err = -EEXIST;
@@ -1392,8 +1408,10 @@ ip6_tnl_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
                                 }
                         } else
                                 t = netdev_priv(dev);
-
-                        err = ip6_tnl_update(t, &p1);
+                        if (dev == ip6n->fb_tnl_dev)
+                                err = ip6_tnl0_update(t, &p1);
+                        else
+                                err = ip6_tnl_update(t, &p1);
                 }
                 if (t) {
                         err = 0;
diff --git a/net/ipv6/ip6mr.c b/net/ipv6/ip6mr.c
index 0171f08325c3..467f310dbbb3 100644
--- a/net/ipv6/ip6mr.c
+++ b/net/ipv6/ip6mr.c
@@ -2090,7 +2090,7 @@ static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
         if (ipv6_addr_any(&cache->mf6c_origin) && true_vifi >= 0) {
                 struct mfc6_cache *cache_proxy;
 
-                /* For an (*,G) entry, we only check that the incomming
+                /* For an (*,G) entry, we only check that the incoming
                  * interface is part of the static tree.
                  */
                 cache_proxy = ip6mr_cache_find_any_parent(mrt, vif);
diff --git a/net/ipv6/raw.c b/net/ipv6/raw.c
index 896af8807979..075a0fb400e7 100644
--- a/net/ipv6/raw.c
+++ b/net/ipv6/raw.c
@@ -548,7 +548,8 @@ static int rawv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6,
         if (!rp->checksum)
                 goto send;
 
-        if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
+        skb = skb_peek(&sk->sk_write_queue);
+        if (!skb)
                 goto out;
 
         offset = rp->offset;
diff --git a/net/ipv6/reassembly.c b/net/ipv6/reassembly.c
index 1a157ca2ebc1..51ab096ae574 100644
--- a/net/ipv6/reassembly.c
+++ b/net/ipv6/reassembly.c
@@ -69,7 +69,7 @@ struct ip6frag_skb_cb {
 
 #define FRAG6_CB(skb)   ((struct ip6frag_skb_cb *)((skb)->cb))
 
-static inline u8 ip6_frag_ecn(const struct ipv6hdr *ipv6h)
+static u8 ip6_frag_ecn(const struct ipv6hdr *ipv6h)
 {
         return 1 << (ipv6_get_dsfield(ipv6h) & INET_ECN_MASK);
 }
@@ -178,7 +178,7 @@ static void ip6_frag_expire(unsigned long data)
         ip6_expire_frag_queue(net, fq, &ip6_frags);
 }
 
-static __inline__ struct frag_queue *
+static struct frag_queue *
 fq_find(struct net *net, __be32 id, const struct in6_addr *src,
         const struct in6_addr *dst, u8 ecn)
 {
@@ -684,21 +684,21 @@ static void ip6_frags_sysctl_unregister(void)
         unregister_net_sysctl_table(ip6_ctl_header);
 }
 #else
-static inline int ip6_frags_ns_sysctl_register(struct net *net)
+static int ip6_frags_ns_sysctl_register(struct net *net)
 {
         return 0;
 }
 
-static inline void ip6_frags_ns_sysctl_unregister(struct net *net)
+static void ip6_frags_ns_sysctl_unregister(struct net *net)
 {
 }
 
-static inline int ip6_frags_sysctl_register(void)
+static int ip6_frags_sysctl_register(void)
 {
         return 0;
 }
 
-static inline void ip6_frags_sysctl_unregister(void)
+static void ip6_frags_sysctl_unregister(void)
 {
 }
 #endif
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index a318dd89b6d9..c91083156edb 100644
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -772,23 +772,22 @@ int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
 }
 #endif
 
-#define BACKTRACK(__net, saddr)                 \
-do { \
-        if (rt == __net->ipv6.ip6_null_entry) { \
-                struct fib6_node *pn; \
-                while (1) { \
-                        if (fn->fn_flags & RTN_TL_ROOT) \
-                                goto out; \
-                        pn = fn->parent; \
-                        if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
-                                fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
-                        else \
-                                fn = pn; \
-                        if (fn->fn_flags & RTN_RTINFO) \
-                                goto restart; \
-                } \
-        } \
-} while (0)
+static struct fib6_node* fib6_backtrack(struct fib6_node *fn,
+                                        struct in6_addr *saddr)
+{
+        struct fib6_node *pn;
+        while (1) {
+                if (fn->fn_flags & RTN_TL_ROOT)
+                        return NULL;
+                pn = fn->parent;
+                if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn)
+                        fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr);
+                else
+                        fn = pn;
+                if (fn->fn_flags & RTN_RTINFO)
+                        return fn;
+        }
+}
 
 static struct rt6_info *ip6_pol_route_lookup(struct net *net,
                                              struct fib6_table *table,
@@ -804,8 +803,11 @@ restart:
         rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);
         if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0)
                 rt = rt6_multipath_select(rt, fl6, fl6->flowi6_oif, flags);
-        BACKTRACK(net, &fl6->saddr);
-out:
+        if (rt == net->ipv6.ip6_null_entry) {
+                fn = fib6_backtrack(fn, &fl6->saddr);
+                if (fn)
+                        goto restart;
+        }
         dst_use(&rt->dst, jiffies);
         read_unlock_bh(&table->tb6_lock);
         return rt;
@@ -915,33 +917,48 @@ static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort,
 static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
                                       struct flowi6 *fl6, int flags)
 {
-        struct fib6_node *fn;
+        struct fib6_node *fn, *saved_fn;
         struct rt6_info *rt, *nrt;
         int strict = 0;
         int attempts = 3;
         int err;
-        int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
 
         strict |= flags & RT6_LOOKUP_F_IFACE;
+        if (net->ipv6.devconf_all->forwarding == 0)
+                strict |= RT6_LOOKUP_F_REACHABLE;
 
-relookup:
+redo_fib6_lookup_lock:
         read_lock_bh(&table->tb6_lock);
 
-restart_2:
         fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
+        saved_fn = fn;
 
-restart:
-        rt = rt6_select(fn, oif, strict | reachable);
+redo_rt6_select:
+        rt = rt6_select(fn, oif, strict);
         if (rt->rt6i_nsiblings)
-                rt = rt6_multipath_select(rt, fl6, oif, strict | reachable);
-        BACKTRACK(net, &fl6->saddr);
-        if (rt == net->ipv6.ip6_null_entry ||
-            rt->rt6i_flags & RTF_CACHE)
-                goto out;
+                rt = rt6_multipath_select(rt, fl6, oif, strict);
+        if (rt == net->ipv6.ip6_null_entry) {
+                fn = fib6_backtrack(fn, &fl6->saddr);
+                if (fn)
+                        goto redo_rt6_select;
+                else if (strict & RT6_LOOKUP_F_REACHABLE) {
+                        /* also consider unreachable route */
+                        strict &= ~RT6_LOOKUP_F_REACHABLE;
+                        fn = saved_fn;
+                        goto redo_rt6_select;
+                } else {
+                        dst_hold(&rt->dst);
+                        read_unlock_bh(&table->tb6_lock);
+                        goto out2;
+                }
+        }
 
         dst_hold(&rt->dst);
         read_unlock_bh(&table->tb6_lock);
 
+        if (rt->rt6i_flags & RTF_CACHE)
+                goto out2;
+
         if (!(rt->rt6i_flags & (RTF_NONEXTHOP | RTF_GATEWAY)))
                 nrt = rt6_alloc_cow(rt, &fl6->daddr, &fl6->saddr);
         else if (!(rt->dst.flags & DST_HOST))
@@ -967,15 +984,8 @@ restart:
          * released someone could insert this route.  Relookup.
          */
         ip6_rt_put(rt);
-        goto relookup;
+        goto redo_fib6_lookup_lock;
 
-out:
-        if (reachable) {
-                reachable = 0;
-                goto restart_2;
-        }
-        dst_hold(&rt->dst);
-        read_unlock_bh(&table->tb6_lock);
 out2:
         rt->dst.lastuse = jiffies;
         rt->dst.__use++;
@@ -1235,10 +1245,12 @@ restart:
                 rt = net->ipv6.ip6_null_entry;
         else if (rt->dst.error) {
                 rt = net->ipv6.ip6_null_entry;
-                goto out;
+        } else if (rt == net->ipv6.ip6_null_entry) {
+                fn = fib6_backtrack(fn, &fl6->saddr);
+                if (fn)
+                        goto restart;
         }
-        BACKTRACK(net, &fl6->saddr);
-out:
+
         dst_hold(&rt->dst);
 
         read_unlock_bh(&table->tb6_lock);
diff --git a/net/ipv6/syncookies.c b/net/ipv6/syncookies.c
index 2f25cb6347ca..be291baa2ec2 100644
--- a/net/ipv6/syncookies.c
+++ b/net/ipv6/syncookies.c
@@ -171,8 +171,11 @@ struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb)
         if (!sysctl_tcp_syncookies || !th->ack || th->rst)
                 goto out;
 
-        if (tcp_synq_no_recent_overflow(sk) ||
-                (mss = __cookie_v6_check(ipv6_hdr(skb), th, cookie)) == 0) {
+        if (tcp_synq_no_recent_overflow(sk))
+                goto out;
+
+        mss = __cookie_v6_check(ipv6_hdr(skb), th, cookie);
+        if (mss == 0) {
                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SYNCOOKIESFAILED);
                 goto out;
         }
@@ -269,4 +272,3 @@ out_free:
         reqsk_free(req);
         return NULL;
 }
-
diff --git a/net/ipx/af_ipx.c b/net/ipx/af_ipx.c
index 91729b807c7d..313ef4644069 100644
--- a/net/ipx/af_ipx.c
+++ b/net/ipx/af_ipx.c
@@ -306,7 +306,7 @@ void ipxitf_down(struct ipx_interface *intrfc)
         spin_unlock_bh(&ipx_interfaces_lock);
 }
 
-static __inline__ void __ipxitf_put(struct ipx_interface *intrfc)
+static void __ipxitf_put(struct ipx_interface *intrfc)
 {
         if (atomic_dec_and_test(&intrfc->refcnt))
                 __ipxitf_down(intrfc);
diff --git a/net/ipx/ipx_proc.c b/net/ipx/ipx_proc.c
index e15c16a517e7..c1d247ebe916 100644
--- a/net/ipx/ipx_proc.c
+++ b/net/ipx/ipx_proc.c
@@ -45,7 +45,7 @@ static int ipx_seq_interface_show(struct seq_file *seq, void *v)
         }
 
         i = list_entry(v, struct ipx_interface, node);
-        seq_printf(seq, "%08lX   ", (unsigned long int)ntohl(i->if_netnum));
+        seq_printf(seq, "%08X   ", ntohl(i->if_netnum));
         seq_printf(seq, "%02X%02X%02X%02X%02X%02X   ",
                         i->if_node[0], i->if_node[1], i->if_node[2],
                         i->if_node[3], i->if_node[4], i->if_node[5]);
@@ -87,10 +87,10 @@ static int ipx_seq_route_show(struct seq_file *seq, void *v)
 
         rt = list_entry(v, struct ipx_route, node);
 
-        seq_printf(seq, "%08lX   ", (unsigned long int)ntohl(rt->ir_net));
+        seq_printf(seq, "%08X   ", ntohl(rt->ir_net));
         if (rt->ir_routed)
-                seq_printf(seq, "%08lX     %02X%02X%02X%02X%02X%02X\n",
-                           (long unsigned int)ntohl(rt->ir_intrfc->if_netnum),
+                seq_printf(seq, "%08X     %02X%02X%02X%02X%02X%02X\n",
+                           ntohl(rt->ir_intrfc->if_netnum),
                            rt->ir_router_node[0], rt->ir_router_node[1],
                            rt->ir_router_node[2], rt->ir_router_node[3],
                            rt->ir_router_node[4], rt->ir_router_node[5]);
@@ -194,19 +194,19 @@ static int ipx_seq_socket_show(struct seq_file *seq, void *v)
         s = v;
         ipxs = ipx_sk(s);
 #ifdef CONFIG_IPX_INTERN
-        seq_printf(seq, "%08lX:%02X%02X%02X%02X%02X%02X:%04X  ",
-                   (unsigned long)ntohl(ipxs->intrfc->if_netnum),
+        seq_printf(seq, "%08X:%02X%02X%02X%02X%02X%02X:%04X  ",
+                   ntohl(ipxs->intrfc->if_netnum),
                    ipxs->node[0], ipxs->node[1], ipxs->node[2], ipxs->node[3],
                    ipxs->node[4], ipxs->node[5], ntohs(ipxs->port));
 #else
-        seq_printf(seq, "%08lX:%04X  ", (unsigned long) ntohl(ipxs->intrfc->if_netnum),
+        seq_printf(seq, "%08X:%04X  ", ntohl(ipxs->intrfc->if_netnum),
                    ntohs(ipxs->port));
 #endif  /* CONFIG_IPX_INTERN */
         if (s->sk_state != TCP_ESTABLISHED)
                 seq_printf(seq, "%-28s", "Not_Connected");
         else {
-                seq_printf(seq, "%08lX:%02X%02X%02X%02X%02X%02X:%04X  ",
-                           (unsigned long)ntohl(ipxs->dest_addr.net),
+                seq_printf(seq, "%08X:%02X%02X%02X%02X%02X%02X:%04X  ",
+                           ntohl(ipxs->dest_addr.net),
                            ipxs->dest_addr.node[0], ipxs->dest_addr.node[1],
                            ipxs->dest_addr.node[2], ipxs->dest_addr.node[3],
                            ipxs->dest_addr.node[4], ipxs->dest_addr.node[5],
diff --git a/net/ipx/sysctl_net_ipx.c b/net/ipx/sysctl_net_ipx.c
index ad7c03dedaab..0dafcc561ed6 100644
--- a/net/ipx/sysctl_net_ipx.c
+++ b/net/ipx/sysctl_net_ipx.c
@@ -9,14 +9,12 @@
 #include <linux/mm.h>
 #include <linux/sysctl.h>
 #include <net/net_namespace.h>
+#include <net/ipx.h>
 
 #ifndef CONFIG_SYSCTL
 #error This file should not be compiled without CONFIG_SYSCTL defined
 #endif
 
-/* From af_ipx.c */
-extern int sysctl_ipx_pprop_broadcasting;
-
 static struct ctl_table ipx_table[] = {
         {
                 .procname       = "ipx_pprop_broadcasting",
diff --git a/net/lapb/lapb_iface.c b/net/lapb/lapb_iface.c
index 3cdaa046c1bc..fc60d9d738b5 100644
--- a/net/lapb/lapb_iface.c
+++ b/net/lapb/lapb_iface.c
@@ -73,6 +73,7 @@ static void __lapb_remove_cb(struct lapb_cb *lapb)
                 lapb_put(lapb);
         }
 }
+EXPORT_SYMBOL(lapb_register);
 
 /*
  *      Add a socket to the bound sockets list.
@@ -195,6 +196,7 @@ out:
         write_unlock_bh(&lapb_list_lock);
         return rc;
 }
+EXPORT_SYMBOL(lapb_unregister);
 
 int lapb_getparms(struct net_device *dev, struct lapb_parms_struct *parms)
 {
@@ -227,6 +229,7 @@ int lapb_getparms(struct net_device *dev, struct lapb_parms_struct *parms)
 out:
         return rc;
 }
+EXPORT_SYMBOL(lapb_getparms);
 
 int lapb_setparms(struct net_device *dev, struct lapb_parms_struct *parms)
 {
@@ -262,6 +265,7 @@ out_put:
 out:
         return rc;
 }
+EXPORT_SYMBOL(lapb_setparms);
 
 int lapb_connect_request(struct net_device *dev)
 {
@@ -290,6 +294,7 @@ out_put:
 out:
         return rc;
 }
+EXPORT_SYMBOL(lapb_connect_request);
 
 int lapb_disconnect_request(struct net_device *dev)
 {
@@ -334,6 +339,7 @@ out_put:
 out:
         return rc;
 }
+EXPORT_SYMBOL(lapb_disconnect_request);
 
 int lapb_data_request(struct net_device *dev, struct sk_buff *skb)
 {
@@ -355,6 +361,7 @@ out_put:
 out:
         return rc;
 }
+EXPORT_SYMBOL(lapb_data_request);
 
 int lapb_data_received(struct net_device *dev, struct sk_buff *skb)
 {
@@ -369,6 +376,7 @@ int lapb_data_received(struct net_device *dev, struct sk_buff *skb)
 
         return rc;
 }
+EXPORT_SYMBOL(lapb_data_received);
 
 void lapb_connect_confirmation(struct lapb_cb *lapb, int reason)
 {
@@ -415,15 +423,6 @@ int lapb_data_transmit(struct lapb_cb *lapb, struct sk_buff *skb)
         return used;
 }
 
-EXPORT_SYMBOL(lapb_register);
-EXPORT_SYMBOL(lapb_unregister);
-EXPORT_SYMBOL(lapb_getparms);
-EXPORT_SYMBOL(lapb_setparms);
-EXPORT_SYMBOL(lapb_connect_request);
-EXPORT_SYMBOL(lapb_disconnect_request);
-EXPORT_SYMBOL(lapb_data_request);
-EXPORT_SYMBOL(lapb_data_received);
-
 static int __init lapb_init(void)
 {
         return 0;
diff --git a/net/llc/llc_if.c b/net/llc/llc_if.c
index 25c31c0a3fdb..6daf391b3e84 100644
--- a/net/llc/llc_if.c
+++ b/net/llc/llc_if.c
@@ -15,7 +15,7 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
-#include <asm/errno.h>
+#include <linux/errno.h>
 #include <net/llc_if.h>
 #include <net/llc_sap.h>
 #include <net/llc_s_ev.h>
diff --git a/net/openvswitch/Kconfig b/net/openvswitch/Kconfig
index ba3bb8203b99..2a9673e39ca1 100644
--- a/net/openvswitch/Kconfig
+++ b/net/openvswitch/Kconfig
@@ -29,11 +29,11 @@ config OPENVSWITCH
           If unsure, say N.
 
 config OPENVSWITCH_GRE
-        bool "Open vSwitch GRE tunneling support"
+        tristate "Open vSwitch GRE tunneling support"
         depends on INET
         depends on OPENVSWITCH
-        depends on NET_IPGRE_DEMUX && !(OPENVSWITCH=y && NET_IPGRE_DEMUX=m)
-        default y
+        depends on NET_IPGRE_DEMUX
+        default OPENVSWITCH
         ---help---
           If you say Y here, then the Open vSwitch will be able create GRE
           vport.
@@ -43,11 +43,11 @@ config OPENVSWITCH_GRE
           If unsure, say Y.
 
 config OPENVSWITCH_VXLAN
-        bool "Open vSwitch VXLAN tunneling support"
+        tristate "Open vSwitch VXLAN tunneling support"
         depends on INET
         depends on OPENVSWITCH
-        depends on VXLAN && !(OPENVSWITCH=y && VXLAN=m)
-        default y
+        depends on VXLAN
+        default OPENVSWITCH
         ---help---
           If you say Y here, then the Open vSwitch will be able create vxlan vport.
 
@@ -56,11 +56,11 @@ config OPENVSWITCH_VXLAN
           If unsure, say Y.
 
 config OPENVSWITCH_GENEVE
-        bool "Open vSwitch Geneve tunneling support"
+        tristate "Open vSwitch Geneve tunneling support"
         depends on INET
         depends on OPENVSWITCH
-        depends on GENEVE && !(OPENVSWITCH=y && GENEVE=m)
-        default y
+        depends on GENEVE
+        default OPENVSWITCH
         ---help---
           If you say Y here, then the Open vSwitch will be able create geneve vport.
 
diff --git a/net/openvswitch/Makefile b/net/openvswitch/Makefile
index 9a33a273c375..91b9478413ef 100644
--- a/net/openvswitch/Makefile
+++ b/net/openvswitch/Makefile
@@ -15,14 +15,6 @@ openvswitch-y := \
         vport-internal_dev.o \
         vport-netdev.o
 
-ifneq ($(CONFIG_OPENVSWITCH_GENEVE),)
-openvswitch-y += vport-geneve.o
-endif
-
-ifneq ($(CONFIG_OPENVSWITCH_VXLAN),)
-openvswitch-y += vport-vxlan.o
-endif
-
-ifneq ($(CONFIG_OPENVSWITCH_GRE),)
-openvswitch-y += vport-gre.o
-endif
+obj-$(CONFIG_OPENVSWITCH_GENEVE)+= vport-geneve.o
+obj-$(CONFIG_OPENVSWITCH_VXLAN) += vport-vxlan.o
+obj-$(CONFIG_OPENVSWITCH_GRE)   += vport-gre.o
diff --git a/net/openvswitch/actions.c b/net/openvswitch/actions.c
index 006886dbee36..922c133b1933 100644
--- a/net/openvswitch/actions.c
+++ b/net/openvswitch/actions.c
@@ -504,11 +504,6 @@ static int output_userspace(struct datapath *dp, struct sk_buff *skb,
         return ovs_dp_upcall(dp, skb, &upcall);
 }
 
-static bool last_action(const struct nlattr *a, int rem)
-{
-        return a->nla_len == rem;
-}
-
 static int sample(struct datapath *dp, struct sk_buff *skb,
                   struct sw_flow_key *key, const struct nlattr *attr)
 {
@@ -543,7 +538,7 @@ static int sample(struct datapath *dp, struct sk_buff *skb,
          * user space. This skb will be consumed by its caller.
          */
         if (likely(nla_type(a) == OVS_ACTION_ATTR_USERSPACE &&
-                   last_action(a, rem)))
+                   nla_is_last(a, rem)))
                 return output_userspace(dp, skb, key, a);
 
         skb = skb_clone(skb, GFP_ATOMIC);
@@ -633,7 +628,7 @@ static int execute_recirc(struct datapath *dp, struct sk_buff *skb,
         if (err)
                 return err;
 
-        if (!last_action(a, rem)) {
+        if (!nla_is_last(a, rem)) {
                 /* Recirc action is the not the last action
                  * of the action list, need to clone the skb.
                  */
@@ -707,7 +702,7 @@ static int do_execute_actions(struct datapath *dp, struct sk_buff *skb,
 
                 case OVS_ACTION_ATTR_RECIRC:
                         err = execute_recirc(dp, skb, key, a, rem);
-                        if (last_action(a, rem)) {
+                        if (nla_is_last(a, rem)) {
                                 /* If this is the last action, the skb has
                                  * been consumed or freed.
                                  * Return immediately.
diff --git a/net/openvswitch/datapath.c b/net/openvswitch/datapath.c
index e6d7255183eb..f18302f32049 100644
--- a/net/openvswitch/datapath.c
+++ b/net/openvswitch/datapath.c
@@ -59,6 +59,7 @@
 #include "vport-netdev.h"
 
 int ovs_net_id __read_mostly;
+EXPORT_SYMBOL(ovs_net_id);
 
 static struct genl_family dp_packet_genl_family;
 static struct genl_family dp_flow_genl_family;
@@ -130,6 +131,7 @@ int lockdep_ovsl_is_held(void)
         else
                 return 1;
 }
+EXPORT_SYMBOL(lockdep_ovsl_is_held);
 #endif
 
 static struct vport *new_vport(const struct vport_parms *);
@@ -1764,6 +1766,7 @@ static int ovs_vport_cmd_new(struct sk_buff *skb, struct genl_info *info)
                 return -ENOMEM;
 
         ovs_lock();
+restart:
         dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex);
         err = -ENODEV;
         if (!dp)
@@ -1795,8 +1798,11 @@ static int ovs_vport_cmd_new(struct sk_buff *skb, struct genl_info *info)
 
         vport = new_vport(&parms);
         err = PTR_ERR(vport);
-        if (IS_ERR(vport))
+        if (IS_ERR(vport)) {
+                if (err == -EAGAIN)
+                        goto restart;
                 goto exit_unlock_free;
+        }
 
         err = ovs_vport_cmd_fill_info(vport, reply, info->snd_portid,
                                       info->snd_seq, 0, OVS_VPORT_CMD_NEW);
@@ -2112,12 +2118,18 @@ static int __init dp_init(void)
         if (err)
                 goto error_netns_exit;
 
+        err = ovs_netdev_init();
+        if (err)
+                goto error_unreg_notifier;
+
         err = dp_register_genl();
         if (err < 0)
-                goto error_unreg_notifier;
+                goto error_unreg_netdev;
 
         return 0;
 
+error_unreg_netdev:
+        ovs_netdev_exit();
 error_unreg_notifier:
         unregister_netdevice_notifier(&ovs_dp_device_notifier);
 error_netns_exit:
@@ -2137,6 +2149,7 @@ error:
 static void dp_cleanup(void)
 {
         dp_unregister_genl(ARRAY_SIZE(dp_genl_families));
+        ovs_netdev_exit();
         unregister_netdevice_notifier(&ovs_dp_device_notifier);
         unregister_pernet_device(&ovs_net_ops);
         rcu_barrier();
diff --git a/net/openvswitch/vport-geneve.c b/net/openvswitch/vport-geneve.c
index 106a9d80b663..70c9765011f4 100644
--- a/net/openvswitch/vport-geneve.c
+++ b/net/openvswitch/vport-geneve.c
@@ -17,6 +17,7 @@
 #include <linux/rculist.h>
 #include <linux/udp.h>
 #include <linux/if_vlan.h>
+#include <linux/module.h>
 
 #include <net/geneve.h>
 #include <net/icmp.h>
@@ -28,6 +29,8 @@
 #include "datapath.h"
 #include "vport.h"
 
+static struct vport_ops ovs_geneve_vport_ops;
+
 /**
  * struct geneve_port - Keeps track of open UDP ports
  * @gs: The socket created for this port number.
@@ -225,11 +228,29 @@ static const char *geneve_get_name(const struct vport *vport)
         return geneve_port->name;
 }
 
-const struct vport_ops ovs_geneve_vport_ops = {
+static struct vport_ops ovs_geneve_vport_ops = {
         .type           = OVS_VPORT_TYPE_GENEVE,
         .create         = geneve_tnl_create,
         .destroy        = geneve_tnl_destroy,
         .get_name       = geneve_get_name,
         .get_options    = geneve_get_options,
         .send           = geneve_tnl_send,
+        .owner          = THIS_MODULE,
 };
+
+static int __init ovs_geneve_tnl_init(void)
+{
+        return ovs_vport_ops_register(&ovs_geneve_vport_ops);
+}
+
+static void __exit ovs_geneve_tnl_exit(void)
+{
+        ovs_vport_ops_unregister(&ovs_geneve_vport_ops);
+}
+
+module_init(ovs_geneve_tnl_init);
+module_exit(ovs_geneve_tnl_exit);
+
+MODULE_DESCRIPTION("OVS: Geneve swiching port");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("vport-type-5");
diff --git a/net/openvswitch/vport-gre.c b/net/openvswitch/vport-gre.c
index 108b82da2fd9..00270b608844 100644
--- a/net/openvswitch/vport-gre.c
+++ b/net/openvswitch/vport-gre.c
@@ -29,6 +29,7 @@
 #include <linux/jhash.h>
 #include <linux/list.h>
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/workqueue.h>
 #include <linux/rculist.h>
 #include <net/route.h>
@@ -45,6 +46,8 @@
 #include "datapath.h"
 #include "vport.h"
 
+static struct vport_ops ovs_gre_vport_ops;
+
 /* Returns the least-significant 32 bits of a __be64. */
 static __be32 be64_get_low32(__be64 x)
 {
@@ -281,10 +284,28 @@ static void gre_tnl_destroy(struct vport *vport)
         gre_exit();
 }
 
-const struct vport_ops ovs_gre_vport_ops = {
+static struct vport_ops ovs_gre_vport_ops = {
         .type           = OVS_VPORT_TYPE_GRE,
         .create         = gre_create,
         .destroy        = gre_tnl_destroy,
         .get_name       = gre_get_name,
         .send           = gre_tnl_send,
+        .owner          = THIS_MODULE,
 };
+
+static int __init ovs_gre_tnl_init(void)
+{
+        return ovs_vport_ops_register(&ovs_gre_vport_ops);
+}
+
+static void __exit ovs_gre_tnl_exit(void)
+{
+        ovs_vport_ops_unregister(&ovs_gre_vport_ops);
+}
+
+module_init(ovs_gre_tnl_init);
+module_exit(ovs_gre_tnl_exit);
+
+MODULE_DESCRIPTION("OVS: GRE switching port");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("vport-type-3");
diff --git a/net/openvswitch/vport-internal_dev.c b/net/openvswitch/vport-internal_dev.c
index 84516126e5f3..10dc07e1678b 100644
--- a/net/openvswitch/vport-internal_dev.c
+++ b/net/openvswitch/vport-internal_dev.c
@@ -36,6 +36,8 @@ struct internal_dev {
         struct vport *vport;
 };
 
+static struct vport_ops ovs_internal_vport_ops;
+
 static struct internal_dev *internal_dev_priv(struct net_device *netdev)
 {
         return netdev_priv(netdev);
@@ -238,7 +240,7 @@ static int internal_dev_recv(struct vport *vport, struct sk_buff *skb)
         return len;
 }
 
-const struct vport_ops ovs_internal_vport_ops = {
+static struct vport_ops ovs_internal_vport_ops = {
         .type           = OVS_VPORT_TYPE_INTERNAL,
         .create         = internal_dev_create,
         .destroy        = internal_dev_destroy,
@@ -261,10 +263,21 @@ struct vport *ovs_internal_dev_get_vport(struct net_device *netdev)
 
 int ovs_internal_dev_rtnl_link_register(void)
 {
-        return rtnl_link_register(&internal_dev_link_ops);
+        int err;
+
+        err = rtnl_link_register(&internal_dev_link_ops);
+        if (err < 0)
+                return err;
+
+        err = ovs_vport_ops_register(&ovs_internal_vport_ops);
+        if (err < 0)
+                rtnl_link_unregister(&internal_dev_link_ops);
+
+        return err;
 }
 
 void ovs_internal_dev_rtnl_link_unregister(void)
 {
+        ovs_vport_ops_unregister(&ovs_internal_vport_ops);
         rtnl_link_unregister(&internal_dev_link_ops);
 }
diff --git a/net/openvswitch/vport-netdev.c b/net/openvswitch/vport-netdev.c
index d21f77d875ba..877ee74b4f08 100644
--- a/net/openvswitch/vport-netdev.c
+++ b/net/openvswitch/vport-netdev.c
@@ -33,6 +33,8 @@
 #include "vport-internal_dev.h"
 #include "vport-netdev.h"
 
+static struct vport_ops ovs_netdev_vport_ops;
+
 /* Must be called with rcu_read_lock. */
 static void netdev_port_receive(struct vport *vport, struct sk_buff *skb)
 {
@@ -224,10 +226,20 @@ struct vport *ovs_netdev_get_vport(struct net_device *dev)
                 return NULL;
 }
 
-const struct vport_ops ovs_netdev_vport_ops = {
+static struct vport_ops ovs_netdev_vport_ops = {
         .type           = OVS_VPORT_TYPE_NETDEV,
         .create         = netdev_create,
         .destroy        = netdev_destroy,
         .get_name       = ovs_netdev_get_name,
         .send           = netdev_send,
 };
+
+int __init ovs_netdev_init(void)
+{
+        return ovs_vport_ops_register(&ovs_netdev_vport_ops);
+}
+
+void ovs_netdev_exit(void)
+{
+        ovs_vport_ops_unregister(&ovs_netdev_vport_ops);
+}
diff --git a/net/openvswitch/vport-netdev.h b/net/openvswitch/vport-netdev.h
index 8df01c1127e5..6f7038e79c52 100644
--- a/net/openvswitch/vport-netdev.h
+++ b/net/openvswitch/vport-netdev.h
@@ -41,4 +41,7 @@ netdev_vport_priv(const struct vport *vport)
 const char *ovs_netdev_get_name(const struct vport *);
 void ovs_netdev_detach_dev(struct vport *);
 
+int __init ovs_netdev_init(void);
+void ovs_netdev_exit(void);
+
 #endif /* vport_netdev.h */
diff --git a/net/openvswitch/vport-vxlan.c b/net/openvswitch/vport-vxlan.c
index 2735e01dca73..965e7500c5a6 100644
--- a/net/openvswitch/vport-vxlan.c
+++ b/net/openvswitch/vport-vxlan.c
@@ -24,6 +24,7 @@
 #include <linux/net.h>
 #include <linux/rculist.h>
 #include <linux/udp.h>
+#include <linux/module.h>
 
 #include <net/icmp.h>
 #include <net/ip.h>
@@ -50,6 +51,8 @@ struct vxlan_port {
         char name[IFNAMSIZ];
 };
 
+static struct vport_ops ovs_vxlan_vport_ops;
+
 static inline struct vxlan_port *vxlan_vport(const struct vport *vport)
 {
         return vport_priv(vport);
@@ -192,11 +195,29 @@ static const char *vxlan_get_name(const struct vport *vport)
         return vxlan_port->name;
 }
 
-const struct vport_ops ovs_vxlan_vport_ops = {
+static struct vport_ops ovs_vxlan_vport_ops = {
         .type           = OVS_VPORT_TYPE_VXLAN,
         .create         = vxlan_tnl_create,
         .destroy        = vxlan_tnl_destroy,
         .get_name       = vxlan_get_name,
         .get_options    = vxlan_get_options,
         .send           = vxlan_tnl_send,
+        .owner          = THIS_MODULE,
 };
+
+static int __init ovs_vxlan_tnl_init(void)
+{
+        return ovs_vport_ops_register(&ovs_vxlan_vport_ops);
+}
+
+static void __exit ovs_vxlan_tnl_exit(void)
+{
+        ovs_vport_ops_unregister(&ovs_vxlan_vport_ops);
+}
+
+module_init(ovs_vxlan_tnl_init);
+module_exit(ovs_vxlan_tnl_exit);
+
+MODULE_DESCRIPTION("OVS: VXLAN switching port");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("vport-type-4");
diff --git a/net/openvswitch/vport.c b/net/openvswitch/vport.c
index 6015802ebe6f..8168ef021337 100644
--- a/net/openvswitch/vport.c
+++ b/net/openvswitch/vport.c
@@ -28,6 +28,7 @@
 #include <linux/rtnetlink.h>
 #include <linux/compat.h>
 #include <net/net_namespace.h>
+#include <linux/module.h>
 
 #include "datapath.h"
 #include "vport.h"
@@ -36,22 +37,7 @@
 static void ovs_vport_record_error(struct vport *,
                                    enum vport_err_type err_type);
 
-/* List of statically compiled vport implementations.  Don't forget to also
- * add yours to the list at the bottom of vport.h. */
-static const struct vport_ops *vport_ops_list[] = {
-        &ovs_netdev_vport_ops,
-        &ovs_internal_vport_ops,
-
-#ifdef CONFIG_OPENVSWITCH_GRE
-        &ovs_gre_vport_ops,
-#endif
-#ifdef CONFIG_OPENVSWITCH_VXLAN
-        &ovs_vxlan_vport_ops,
-#endif
-#ifdef CONFIG_OPENVSWITCH_GENEVE
-        &ovs_geneve_vport_ops,
-#endif
-};
+static LIST_HEAD(vport_ops_list);
 
 /* Protected by RCU read lock for reading, ovs_mutex for writing. */
 static struct hlist_head *dev_table;
@@ -88,6 +74,32 @@ static struct hlist_head *hash_bucket(struct net *net, const char *name)
         return &dev_table[hash & (VPORT_HASH_BUCKETS - 1)];
 }
 
+int ovs_vport_ops_register(struct vport_ops *ops)
+{
+        int err = -EEXIST;
+        struct vport_ops *o;
+
+        ovs_lock();
+        list_for_each_entry(o, &vport_ops_list, list)
+                if (ops->type == o->type)
+                        goto errout;
+
+        list_add_tail(&ops->list, &vport_ops_list);
+        err = 0;
+errout:
+        ovs_unlock();
+        return err;
+}
+EXPORT_SYMBOL(ovs_vport_ops_register);
+
+void ovs_vport_ops_unregister(struct vport_ops *ops)
+{
+        ovs_lock();
+        list_del(&ops->list);
+        ovs_unlock();
+}
+EXPORT_SYMBOL(ovs_vport_ops_unregister);
+
 /**
  *      ovs_vport_locate - find a port that has already been created
  *
@@ -153,6 +165,7 @@ struct vport *ovs_vport_alloc(int priv_size, const struct vport_ops *ops,
 
         return vport;
 }
+EXPORT_SYMBOL(ovs_vport_alloc);
 
 /**
  *      ovs_vport_free - uninitialize and free vport
@@ -173,6 +186,18 @@ void ovs_vport_free(struct vport *vport)
         free_percpu(vport->percpu_stats);
         kfree(vport);
 }
+EXPORT_SYMBOL(ovs_vport_free);
+
+static struct vport_ops *ovs_vport_lookup(const struct vport_parms *parms)
+{
+        struct vport_ops *ops;
+
+        list_for_each_entry(ops, &vport_ops_list, list)
+                if (ops->type == parms->type)
+                        return ops;
+
+        return NULL;
+}
 
 /**
  *      ovs_vport_add - add vport device (for kernel callers)
@@ -184,31 +209,40 @@ void ovs_vport_free(struct vport *vport)
  */
 struct vport *ovs_vport_add(const struct vport_parms *parms)
 {
+        struct vport_ops *ops;
         struct vport *vport;
-        int err = 0;
-        int i;
 
-        for (i = 0; i < ARRAY_SIZE(vport_ops_list); i++) {
-                if (vport_ops_list[i]->type == parms->type) {
-                        struct hlist_head *bucket;
+        ops = ovs_vport_lookup(parms);
+        if (ops) {
+                struct hlist_head *bucket;
 
-                        vport = vport_ops_list[i]->create(parms);
-                        if (IS_ERR(vport)) {
-                                err = PTR_ERR(vport);
-                                goto out;
-                        }
+                if (!try_module_get(ops->owner))
+                        return ERR_PTR(-EAFNOSUPPORT);
 
-                        bucket = hash_bucket(ovs_dp_get_net(vport->dp),
-                                             vport->ops->get_name(vport));
-                        hlist_add_head_rcu(&vport->hash_node, bucket);
+                vport = ops->create(parms);
+                if (IS_ERR(vport)) {
+                        module_put(ops->owner);
                         return vport;
                 }
+
+                bucket = hash_bucket(ovs_dp_get_net(vport->dp),
+                                     vport->ops->get_name(vport));
+                hlist_add_head_rcu(&vport->hash_node, bucket);
+                return vport;
         }
 
-        err = -EAFNOSUPPORT;
+        /* Unlock to attempt module load and return -EAGAIN if load
+         * was successful as we need to restart the port addition
+         * workflow.
+         */
+        ovs_unlock();
+        request_module("vport-type-%d", parms->type);
+        ovs_lock();
 
-out:
-        return ERR_PTR(err);
+        if (!ovs_vport_lookup(parms))
+                return ERR_PTR(-EAFNOSUPPORT);
+        else
+                return ERR_PTR(-EAGAIN);
 }
 
 /**
@@ -242,6 +276,8 @@ void ovs_vport_del(struct vport *vport)
         hlist_del_rcu(&vport->hash_node);
 
         vport->ops->destroy(vport);
+
+        module_put(vport->ops->owner);
 }
 
 /**
@@ -457,6 +493,7 @@ void ovs_vport_receive(struct vport *vport, struct sk_buff *skb,
         }
         ovs_dp_process_packet(skb, &key);
 }
+EXPORT_SYMBOL(ovs_vport_receive);
 
 /**
  *      ovs_vport_send - send a packet on a device
@@ -535,3 +572,4 @@ void ovs_vport_deferred_free(struct vport *vport)
 
         call_rcu(&vport->rcu, free_vport_rcu);
 }
+EXPORT_SYMBOL(ovs_vport_deferred_free);
diff --git a/net/openvswitch/vport.h b/net/openvswitch/vport.h
index 8942125de3a6..e41c3facf799 100644
--- a/net/openvswitch/vport.h
+++ b/net/openvswitch/vport.h
@@ -161,6 +161,9 @@ struct vport_ops {
         const char *(*get_name)(const struct vport *);
 
         int (*send)(struct vport *, struct sk_buff *);
+
+        struct module *owner;
+        struct list_head list;
 };
 
 enum vport_err_type {
@@ -209,14 +212,6 @@ static inline struct vport *vport_from_priv(void *priv)
 void ovs_vport_receive(struct vport *, struct sk_buff *,
                        struct ovs_tunnel_info *);
 
-/* List of statically compiled vport implementations.  Don't forget to also
- * add yours to the list at the top of vport.c. */
-extern const struct vport_ops ovs_netdev_vport_ops;
-extern const struct vport_ops ovs_internal_vport_ops;
-extern const struct vport_ops ovs_gre_vport_ops;
-extern const struct vport_ops ovs_vxlan_vport_ops;
-extern const struct vport_ops ovs_geneve_vport_ops;
-
 static inline void ovs_skb_postpush_rcsum(struct sk_buff *skb,
                                       const void *start, unsigned int len)
 {
@@ -224,4 +219,7 @@ static inline void ovs_skb_postpush_rcsum(struct sk_buff *skb,
                 skb->csum = csum_add(skb->csum, csum_partial(start, len, 0));
 }
 
+int ovs_vport_ops_register(struct vport_ops *ops);
+void ovs_vport_ops_unregister(struct vport_ops *ops);
+
 #endif /* vport.h */
diff --git a/net/sctp/proc.c b/net/sctp/proc.c
index 34229ee7f379..0697eda5aed8 100644
--- a/net/sctp/proc.c
+++ b/net/sctp/proc.c
@@ -417,7 +417,7 @@ static void *sctp_remaddr_seq_start(struct seq_file *seq, loff_t *pos)
 
         if (*pos == 0)
                 seq_printf(seq, "ADDR ASSOC_ID HB_ACT RTO MAX_PATH_RTX "
-                                "REM_ADDR_RTX  START\n");
+                                "REM_ADDR_RTX START STATE\n");
 
         return (void *)pos;
 }
@@ -490,14 +490,20 @@ static int sctp_remaddr_seq_show(struct seq_file *seq, void *v)
                          * Note: We don't have a way to tally this at the moment
                          * so lets just leave it as zero for the moment
                          */
-                        seq_printf(seq, "0 ");
+                        seq_puts(seq, "0 ");
 
                         /*
                          * remote address start time (START).  This is also not
                          * currently implemented, but we can record it with a
                          * jiffies marker in a subsequent patch
                          */
-                        seq_printf(seq, "0");
+                        seq_puts(seq, "0 ");
+
+                        /*
+                         * The current state of this destination. I.e.
+                         * SCTP_ACTIVE, SCTP_INACTIVE, ...
+                         */
+                        seq_printf(seq, "%d", tsp->state);
 
                         seq_printf(seq, "\n");
                 }
diff --git a/net/tipc/msg.c b/net/tipc/msg.c
index 74745a47d72a..ec18076e81ec 100644
--- a/net/tipc/msg.c
+++ b/net/tipc/msg.c
@@ -91,7 +91,7 @@ struct sk_buff *tipc_msg_create(uint user, uint type, uint hdr_sz,
  * @*headbuf: in:  NULL for first frag, otherwise value returned from prev call
  *            out: set when successful non-complete reassembly, otherwise NULL
  * @*buf:     in:  the buffer to append. Always defined
- *            out: head buf after sucessful complete reassembly, otherwise NULL
+ *            out: head buf after successful complete reassembly, otherwise NULL
  * Returns 1 when reassembly complete, otherwise 0
  */
 int tipc_buf_append(struct sk_buff **headbuf, struct sk_buff **buf)
@@ -311,7 +311,7 @@ bool tipc_msg_bundle(struct sk_buff *bbuf, struct sk_buff *buf, u32 mtu)
  * @mtu:  max allowable size for the bundle buffer, inclusive header
  * @dnode: destination node for message. (Not always present in header)
  * Replaces buffer if successful
- * Returns true if sucess, otherwise false
+ * Returns true if success, otherwise false
  */
 bool tipc_msg_make_bundle(struct sk_buff **buf, u32 mtu, u32 dnode)
 {
diff --git a/net/tipc/socket.c b/net/tipc/socket.c
index 51bddc236a15..ad8a1a1e2275 100644
--- a/net/tipc/socket.c
+++ b/net/tipc/socket.c
@@ -1556,7 +1556,7 @@ static void tipc_data_ready(struct sock *sk)
  * @tsk: TIPC socket
  * @msg: message
  *
- * Returns 0 (TIPC_OK) if everyting ok, -TIPC_ERR_NO_PORT otherwise
+ * Returns 0 (TIPC_OK) if everything ok, -TIPC_ERR_NO_PORT otherwise
  */
 static int filter_connect(struct tipc_sock *tsk, struct sk_buff **buf)
 {
diff --git a/samples/bpf/test_verifier.c b/samples/bpf/test_verifier.c
index eb4bec0ad8af..63402742345e 100644
--- a/samples/bpf/test_verifier.c
+++ b/samples/bpf/test_verifier.c
@@ -602,6 +602,45 @@ static struct bpf_test tests[] = {
                 },
                 .result = ACCEPT,
         },
+        {
+                "jump test 5",
+                .insns = {
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_MOV64_REG(BPF_REG_3, BPF_REG_2),
+                        BPF_JMP_IMM(BPF_JGE, BPF_REG_1, 0, 2),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_3, -8),
+                        BPF_JMP_IMM(BPF_JA, 0, 0, 2),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_2, -8),
+                        BPF_JMP_IMM(BPF_JA, 0, 0, 0),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_JMP_IMM(BPF_JGE, BPF_REG_1, 0, 2),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_3, -8),
+                        BPF_JMP_IMM(BPF_JA, 0, 0, 2),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_2, -8),
+                        BPF_JMP_IMM(BPF_JA, 0, 0, 0),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_JMP_IMM(BPF_JGE, BPF_REG_1, 0, 2),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_3, -8),
+                        BPF_JMP_IMM(BPF_JA, 0, 0, 2),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_2, -8),
+                        BPF_JMP_IMM(BPF_JA, 0, 0, 0),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_JMP_IMM(BPF_JGE, BPF_REG_1, 0, 2),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_3, -8),
+                        BPF_JMP_IMM(BPF_JA, 0, 0, 2),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_2, -8),
+                        BPF_JMP_IMM(BPF_JA, 0, 0, 0),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_JMP_IMM(BPF_JGE, BPF_REG_1, 0, 2),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_3, -8),
+                        BPF_JMP_IMM(BPF_JA, 0, 0, 2),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_2, -8),
+                        BPF_JMP_IMM(BPF_JA, 0, 0, 0),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .result = ACCEPT,
+        },
 };
 
 static int probe_filter_length(struct bpf_insn *fp)
@@ -630,7 +669,7 @@ static int create_map(void)
 
 static int test(void)
 {
-        int prog_fd, i;
+        int prog_fd, i, pass_cnt = 0, err_cnt = 0;
 
         for (i = 0; i < ARRAY_SIZE(tests); i++) {
                 struct bpf_insn *prog = tests[i].insns;
@@ -657,21 +696,25 @@ static int test(void)
                                 printf("FAIL\nfailed to load prog '%s'\n",
                                        strerror(errno));
                                 printf("%s", bpf_log_buf);
+                                err_cnt++;
                                 goto fail;
                         }
                 } else {
                         if (prog_fd >= 0) {
                                 printf("FAIL\nunexpected success to load\n");
                                 printf("%s", bpf_log_buf);
+                                err_cnt++;
                                 goto fail;
                         }
                         if (strstr(bpf_log_buf, tests[i].errstr) == 0) {
                                 printf("FAIL\nunexpected error message: %s",
                                        bpf_log_buf);
+                                err_cnt++;
                                 goto fail;
                         }
                 }
 
+                pass_cnt++;
                 printf("OK\n");
 fail:
                 if (map_fd >= 0)
@@ -679,6 +722,7 @@ fail:
                 close(prog_fd);
 
         }
+        printf("Summary: %d PASSED, %d FAILED\n", pass_cnt, err_cnt);
 
         return 0;
 }