371 files changed, 3825 insertions, 2001 deletions

diff --git a/Documentation/ABI/testing/sysfs-ata b/Documentation/ABI/testing/sysfs-ata
index aa4296498859..9ab0ef1dd1c7 100644
--- a/Documentation/ABI/testing/sysfs-ata
+++ b/Documentation/ABI/testing/sysfs-ata
@@ -1,110 +1,139 @@
 What:           /sys/class/ata_...
-Date:           August 2008
-Contact:        Gwendal Grignou<gwendal@google.com>
 Description:
-
-Provide a place in sysfs for storing the ATA topology of the system.  This allows
-retrieving various information about ATA objects.
+                Provide a place in sysfs for storing the ATA topology of the
+                system. This allows retrieving various information about ATA
+                objects.
 
 Files under /sys/class/ata_port
 -------------------------------
 
-        For each port, a directory ataX is created where X is the ata_port_id of
-        the port. The device parent is the ata host device.
+For each port, a directory ataX is created where X is the ata_port_id of the
+port. The device parent is the ata host device.
 
-idle_irq (read)
 
-        Number of IRQ received by the port while idle [some ata HBA only].
+What:           /sys/class/ata_port/ataX/nr_pmp_links
+What:           /sys/class/ata_port/ataX/idle_irq
+Date:           May, 2010
+KernelVersion:  v2.6.37
+Contact:        Gwendal Grignou <gwendal@chromium.org>
+Description:
+                nr_pmp_links:   (RO) If a SATA Port Multiplier (PM) is
+                                connected, the number of links behind it.
 
-nr_pmp_links (read)
+                idle_irq:       (RO) Number of IRQ received by the port while
+                                idle [some ata HBA only].
 
-        If a SATA Port Multiplier (PM) is connected, number of link behind it.
+
+What:           /sys/class/ata_port/ataX/port_no
+Date:           May, 2013
+KernelVersion:  v3.11
+Contact:        Gwendal Grignou <gwendal@chromium.org>
+Description:
+                (RO) Host local port number. While registering host controller,
+                port numbers are tracked based upon number of ports available on
+                the controller. This attribute is needed by udev for composing
+                persistent links in /dev/disk/by-path.
 
 Files under /sys/class/ata_link
 -------------------------------
 
-        Behind each port, there is a ata_link. If there is a SATA PM in the
-        topology, 15 ata_link objects are created.
-
-        If a link is behind a port, the directory name is linkX, where X is
-        ata_port_id of the port.
-        If a link is behind a PM, its name is linkX.Y where X is ata_port_id
-        of the parent port and Y the PM port.
+Behind each port, there is a ata_link. If there is a SATA PM in the topology, 15
+ata_link objects are created.
 
-hw_sata_spd_limit
+If a link is behind a port, the directory name is linkX, where X is ata_port_id
+of the port. If a link is behind a PM, its name is linkX.Y where X is
+ata_port_id of the parent port and Y the PM port.
 
-        Maximum speed supported by the connected SATA device.
 
-sata_spd_limit
+What:           /sys/class/ata_link/linkX[.Y]/hw_sata_spd_limit
+What:           /sys/class/ata_link/linkX[.Y]/sata_spd_limit
+What:           /sys/class/ata_link/linkX[.Y]/sata_spd
+Date:           May, 2010
+KernelVersion:  v2.6.37
+Contact:        Gwendal Grignou <gwendal@chromium.org>
+Description:
+                hw_sata_spd_limit:      (RO) Maximum speed supported by the
+                                        connected SATA device.
 
-        Maximum speed imposed by libata.
+                sata_spd_limit:         (RO) Maximum speed imposed by libata.
 
-sata_spd
+                sata_spd:               (RO) Current speed of the link
+                                        eg. 1.5, 3 Gbps etc.
 
-        Current speed of the link [1.5, 3Gps,...].
 
 Files under /sys/class/ata_device
 ---------------------------------
 
-        Behind each link, up to two ata device are created.
-        The name of the directory is devX[.Y].Z where:
-        - X is ata_port_id of the port where the device is connected,
-        - Y the port of the PM if any, and
-        - Z the device id: for PATA, there is usually 2 devices [0,1],
-        only 1 for SATA.
-
-class
-        Device class. Can be "ata" for disk, "atapi" for packet device,
-        "pmp" for PM, or "none" if no device was found behind the link.
-
-dma_mode
+Behind each link, up to two ata devices are created.
+The name of the directory is devX[.Y].Z where:
+- X is ata_port_id of the port where the device is connected,
+- Y the port of the PM if any, and
+- Z the device id: for PATA, there is usually 2 devices [0,1], only 1 for SATA.
+
+
+What:           /sys/class/ata_device/devX[.Y].Z/spdn_cnt
+What:           /sys/class/ata_device/devX[.Y].Z/gscr
+What:           /sys/class/ata_device/devX[.Y].Z/ering
+What:           /sys/class/ata_device/devX[.Y].Z/id
+What:           /sys/class/ata_device/devX[.Y].Z/pio_mode
+What:           /sys/class/ata_device/devX[.Y].Z/xfer_mode
+What:           /sys/class/ata_device/devX[.Y].Z/dma_mode
+What:           /sys/class/ata_device/devX[.Y].Z/class
+Date:           May, 2010
+KernelVersion:  v2.6.37
+Contact:        Gwendal Grignou <gwendal@chromium.org>
+Description:
+                spdn_cnt:       (RO) Number of times libata decided to lower the
+                                speed of link due to errors.
 
-        Transfer modes supported by the device when in DMA mode.
-        Mostly used by PATA device.
+                gscr:           (RO) Cached result of the dump of PM GSCR
+                                register. Valid registers are:
 
-pio_mode
+                                0:      SATA_PMP_GSCR_PROD_ID,
+                                1:      SATA_PMP_GSCR_REV,
+                                2:      SATA_PMP_GSCR_PORT_INFO,
+                                32:     SATA_PMP_GSCR_ERROR,
+                                33:     SATA_PMP_GSCR_ERROR_EN,
+                                64:     SATA_PMP_GSCR_FEAT,
+                                96:     SATA_PMP_GSCR_FEAT_EN,
+                                130:    SATA_PMP_GSCR_SII_GPIO
 
-        Transfer modes supported by the device when in PIO mode.
-        Mostly used by PATA device.
+                                Only valid if the device is a PM.
 
-xfer_mode
+                ering:          (RO) Formatted output of the error ring of the
+                                device.
 
-        Current transfer mode.
+                id:             (RO) Cached result of IDENTIFY command, as
+                                described in ATA8 7.16 and 7.17. Only valid if
+                                the device is not a PM.
 
-id
+                pio_mode:       (RO) Transfer modes supported by the device when
+                                in PIO mode. Mostly used by PATA device.
 
-        Cached result of IDENTIFY command, as described in ATA8 7.16 and 7.17.
-        Only valid if the device is not a PM.
+                xfer_mode:      (RO) Current transfer mode
 
-gscr
+                dma_mode:       (RO) Transfer modes supported by the device when
+                                in DMA mode. Mostly used by PATA device.
 
-        Cached result of the dump of PM GSCR register.
-        Valid registers are:
-        0:      SATA_PMP_GSCR_PROD_ID,
-        1:      SATA_PMP_GSCR_REV,
-        2:      SATA_PMP_GSCR_PORT_INFO,
-        32:     SATA_PMP_GSCR_ERROR,
-        33:     SATA_PMP_GSCR_ERROR_EN,
-        64:     SATA_PMP_GSCR_FEAT,
-        96:     SATA_PMP_GSCR_FEAT_EN,
-        130:    SATA_PMP_GSCR_SII_GPIO
-        Only valid if the device is a PM.
+                class:          (RO) Device class. Can be "ata" for disk,
+                                "atapi" for packet device, "pmp" for PM, or
+                                "none" if no device was found behind the link.
 
-trim
 
-        Shows the DSM TRIM mode currently used by the device. Valid
-        values are:
-        unsupported:            Drive does not support DSM TRIM
-        unqueued:               Drive supports unqueued DSM TRIM only
-        queued:                 Drive supports queued DSM TRIM
-        forced_unqueued:        Drive's queued DSM support is known to be
-                                buggy and only unqueued TRIM commands
-                                are sent
+What:           /sys/class/ata_device/devX[.Y].Z/trim
+Date:           May, 2015
+KernelVersion:  v4.10
+Contact:        Gwendal Grignou <gwendal@chromium.org>
+Description:
+                (RO) Shows the DSM TRIM mode currently used by the device. Valid
+                values are:
 
-spdn_cnt
+                unsupported:            Drive does not support DSM TRIM
 
-        Number of time libata decided to lower the speed of link due to errors.
+                unqueued:               Drive supports unqueued DSM TRIM only
 
-ering
+                queued:                 Drive supports queued DSM TRIM
 
-        Formatted output of the error ring of the device.
+                forced_unqueued:        Drive's queued DSM support is known to
+                                        be buggy and only unqueued TRIM commands
+                                        are sent
diff --git a/Documentation/ABI/testing/sysfs-block-device b/Documentation/ABI/testing/sysfs-block-device
new file mode 100644
index 000000000000..82ef6eab042d
--- /dev/null
+++ b/Documentation/ABI/testing/sysfs-block-device
@@ -0,0 +1,58 @@
+What:           /sys/block/*/device/sw_activity
+Date:           Jun, 2008
+KernelVersion:  v2.6.27
+Contact:        linux-ide@vger.kernel.org
+Description:
+                (RW) Used by drivers which support software controlled activity
+                LEDs.
+
+                It has the following valid values:
+
+                0       OFF - the LED is not activated on activity
+                1       BLINK_ON - the LED blinks on every 10ms when activity is
+                        detected.
+                2       BLINK_OFF - the LED is on when idle, and blinks off
+                        every 10ms when activity is detected.
+
+                Note that the user must turn sw_activity OFF it they wish to
+                control the activity LED via the em_message file.
+
+
+What:           /sys/block/*/device/unload_heads
+Date:           Sep, 2008
+KernelVersion:  v2.6.28
+Contact:        linux-ide@vger.kernel.org
+Description:
+                (RW) Hard disk shock protection
+
+                Writing an integer value to this file will take the heads of the
+                respective drive off the platter and block all I/O operations
+                for the specified number of milliseconds.
+
+                - If the device does not support the unload heads feature,
+                  access is denied with -EOPNOTSUPP.
+                - The maximal value accepted for a timeout is 30000
+                  milliseconds.
+                - A previously set timeout can be cancelled and disk can resume
+                  normal operation immediately by specifying a timeout of 0.
+                - Some hard drives only comply with an earlier version of the
+                  ATA standard, but support the unload feature nonetheless.
+                  There is no safe way Linux can detect these devices, so this
+                  is not enabled by default. If it is known that your device
+                  does support the unload feature, then you can tell the kernel
+                  to enable it by writing -1. It can be disabled again by
+                  writing -2.
+                - Values below -2 are rejected with -EINVAL
+
+                For more information, see
+                Documentation/laptops/disk-shock-protection.txt
+
+
+What:           /sys/block/*/device/ncq_prio_enable
+Date:           Oct, 2016
+KernelVersion:  v4.10
+Contact:        linux-ide@vger.kernel.org
+Description:
+                (RW) Write to the file to turn on or off the SATA ncq (native
+                command queueing) support. By default this feature is turned
+                off.
diff --git a/Documentation/ABI/testing/sysfs-class-scsi_host b/Documentation/ABI/testing/sysfs-class-scsi_host
index 0eb255e7db12..bafc59fd7b69 100644
--- a/Documentation/ABI/testing/sysfs-class-scsi_host
+++ b/Documentation/ABI/testing/sysfs-class-scsi_host
@@ -27,3 +27,92 @@ Description:	This file contains the current status of the "SSD Smart Path"
                 the direct i/o path to physical devices.  This setting is
                 controller wide, affecting all configured logical drives on the
                 controller.  This file is readable and writable.
+
+What:           /sys/class/scsi_host/hostX/link_power_management_policy
+Date:           Oct, 2007
+KernelVersion:  v2.6.24
+Contact:        linux-ide@vger.kernel.org
+Description:
+                (RW) This parameter allows the user to read and set the link
+                (interface) power management.
+
+                There are four possible options:
+
+                min_power: Tell the controller to try to make the link use the
+                least possible power when possible. This may sacrifice some
+                performance due to increased latency when coming out of lower
+                power states.
+
+                max_performance: Generally, this means no power management.
+                Tell the controller to have performance be a priority over power
+                management.
+
+                medium_power: Tell the controller to enter a lower power state
+                when possible, but do not enter the lowest power state, thus
+                improving latency over min_power setting.
+
+                med_power_with_dipm: Identical to the existing medium_power
+                setting except that it enables dipm (device initiated power
+                management) on top, which makes it match the Windows IRST (Intel
+                Rapid Storage Technology) driver settings. This setting is also
+                close to min_power, except that:
+                a) It does not use host-initiated slumber mode, but it does
+                allow device-initiated slumber
+                b) It does not enable low power device sleep mode (DevSlp).
+
+What:           /sys/class/scsi_host/hostX/em_message
+What:           /sys/class/scsi_host/hostX/em_message_type
+Date:           Jun, 2008
+KernelVersion:  v2.6.27
+Contact:        linux-ide@vger.kernel.org
+Description:
+                em_message: (RW) Enclosure management support. For the LED
+                protocol, writes and reads correspond to the LED message format
+                as defined in the AHCI spec.
+
+                The user must turn sw_activity (under /sys/block/*/device/) OFF
+                it they wish to control the activity LED via the em_message
+                file.
+
+                em_message_type: (RO) Displays the current enclosure management
+                protocol that is being used by the driver (for eg. LED, SAF-TE,
+                SES-2, SGPIO etc).
+
+What:           /sys/class/scsi_host/hostX/ahci_port_cmd
+What:           /sys/class/scsi_host/hostX/ahci_host_caps
+What:           /sys/class/scsi_host/hostX/ahci_host_cap2
+Date:           Mar, 2010
+KernelVersion:  v2.6.35
+Contact:        linux-ide@vger.kernel.org
+Description:
+                [to be documented]
+
+What:           /sys/class/scsi_host/hostX/ahci_host_version
+Date:           Mar, 2010
+KernelVersion:  v2.6.35
+Contact:        linux-ide@vger.kernel.org
+Description:
+                (RO) Display the version of the AHCI spec implemented by the
+                host.
+
+What:           /sys/class/scsi_host/hostX/em_buffer
+Date:           Apr, 2010
+KernelVersion:  v2.6.35
+Contact:        linux-ide@vger.kernel.org
+Description:
+                (RW) Allows access to AHCI EM (enclosure management) buffer
+                directly if the host supports EM.
+
+                For eg. the AHCI driver supports SGPIO EM messages but the
+                SATA/AHCI specs do not define the SGPIO message format of the EM
+                buffer. Different hardware(HW) vendors may have different
+                definitions. With the em_buffer attribute, this issue can be
+                solved by allowing HW vendors to provide userland drivers and
+                tools for their SGPIO initiators.
+
+What:           /sys/class/scsi_host/hostX/em_message_supported
+Date:           Oct, 2009
+KernelVersion:  v2.6.39
+Contact:        linux-ide@vger.kernel.org
+Description:
+                (RO) Displays supported enclosure management message types.
diff --git a/Documentation/devicetree/bindings/display/exynos/exynos_hdmi.txt b/Documentation/devicetree/bindings/display/exynos/exynos_hdmi.txt
index 6394ea9e3b9e..58b12e25bbb1 100644
--- a/Documentation/devicetree/bindings/display/exynos/exynos_hdmi.txt
+++ b/Documentation/devicetree/bindings/display/exynos/exynos_hdmi.txt
@@ -16,6 +16,7 @@ Required properties:
 - ddc: phandle to the hdmi ddc node
 - phy: phandle to the hdmi phy node
 - samsung,syscon-phandle: phandle for system controller node for PMU.
+- #sound-dai-cells: should be 0.
 
 Required properties for Exynos 4210, 4212, 5420 and 5433:
 - clocks: list of clock IDs from SoC clock driver.
diff --git a/Documentation/devicetree/bindings/iio/adc/sigma-delta-modulator.txt b/Documentation/devicetree/bindings/iio/adc/sigma-delta-modulator.txt
index e9ebb8a20e0d..ba24ca7ba95e 100644
--- a/Documentation/devicetree/bindings/iio/adc/sigma-delta-modulator.txt
+++ b/Documentation/devicetree/bindings/iio/adc/sigma-delta-modulator.txt
@@ -3,11 +3,11 @@ Device-Tree bindings for sigma delta modulator
 Required properties:
 - compatible: should be "ads1201", "sd-modulator". "sd-modulator" can be use
         as a generic SD modulator if modulator not specified in compatible list.
-- #io-channel-cells = <1>: See the IIO bindings section "IIO consumers".
+- #io-channel-cells = <0>: See the IIO bindings section "IIO consumers".
 
 Example node:
 
         ads1202: adc@0 {
                 compatible = "sd-modulator";
-                #io-channel-cells = <1>;
+                #io-channel-cells = <0>;
         };
diff --git a/Documentation/devicetree/bindings/net/dsa/marvell.txt b/Documentation/devicetree/bindings/net/dsa/marvell.txt
index 1d4d0f49c9d0..8c033d48e2ba 100644
--- a/Documentation/devicetree/bindings/net/dsa/marvell.txt
+++ b/Documentation/devicetree/bindings/net/dsa/marvell.txt
@@ -50,14 +50,15 @@ Example:
                         compatible = "marvell,mv88e6085";
                         reg = <0>;
                         reset-gpios = <&gpio5 1 GPIO_ACTIVE_LOW>;
-                };
-                mdio {
-                        #address-cells = <1>;
-                        #size-cells = <0>;
-                        switch1phy0: switch1phy0@0 {
-                                reg = <0>;
-                                interrupt-parent = <&switch0>;
-                                interrupts = <0 IRQ_TYPE_LEVEL_HIGH>;
+
+                        mdio {
+                                #address-cells = <1>;
+                                #size-cells = <0>;
+                                switch1phy0: switch1phy0@0 {
+                                        reg = <0>;
+                                        interrupt-parent = <&switch0>;
+                                        interrupts = <0 IRQ_TYPE_LEVEL_HIGH>;
+                                };
                         };
                 };
         };
@@ -74,23 +75,24 @@ Example:
                         compatible = "marvell,mv88e6390";
                         reg = <0>;
                         reset-gpios = <&gpio5 1 GPIO_ACTIVE_LOW>;
-                };
-                mdio {
-                        #address-cells = <1>;
-                        #size-cells = <0>;
-                        switch1phy0: switch1phy0@0 {
-                                reg = <0>;
-                                interrupt-parent = <&switch0>;
-                                interrupts = <0 IRQ_TYPE_LEVEL_HIGH>;
+
+                        mdio {
+                                #address-cells = <1>;
+                                #size-cells = <0>;
+                                switch1phy0: switch1phy0@0 {
+                                        reg = <0>;
+                                        interrupt-parent = <&switch0>;
+                                        interrupts = <0 IRQ_TYPE_LEVEL_HIGH>;
+                                };
                         };
-                };
 
-                mdio1 {
-                        compatible = "marvell,mv88e6xxx-mdio-external";
-                        #address-cells = <1>;
-                        #size-cells = <0>;
-                        switch1phy9: switch1phy0@9 {
-                                reg = <9>;
+                        mdio1 {
+                                compatible = "marvell,mv88e6xxx-mdio-external";
+                                #address-cells = <1>;
+                                #size-cells = <0>;
+                                switch1phy9: switch1phy0@9 {
+                                        reg = <9>;
+                                };
                         };
                 };
         };
diff --git a/Documentation/devicetree/bindings/net/renesas,ravb.txt b/Documentation/devicetree/bindings/net/renesas,ravb.txt
index 92fd4b2f17b2..b4dc455eb155 100644
--- a/Documentation/devicetree/bindings/net/renesas,ravb.txt
+++ b/Documentation/devicetree/bindings/net/renesas,ravb.txt
@@ -27,7 +27,11 @@ Required properties:
         SoC-specific version corresponding to the platform first followed by
         the generic version.
 
-- reg: offset and length of (1) the register block and (2) the stream buffer.
+- reg: Offset and length of (1) the register block and (2) the stream buffer.
+       The region for the register block is mandatory.
+       The region for the stream buffer is optional, as it is only present on
+       R-Car Gen2 and RZ/G1 SoCs, and on R-Car H3 (R8A7795), M3-W (R8A7796),
+       and M3-N (R8A77965).
 - interrupts: A list of interrupt-specifiers, one for each entry in
               interrupt-names.
               If interrupt-names is not present, an interrupt specifier
diff --git a/Documentation/networking/segmentation-offloads.txt b/Documentation/networking/segmentation-offloads.txt
index d47480b61ac6..aca542ec125c 100644
--- a/Documentation/networking/segmentation-offloads.txt
+++ b/Documentation/networking/segmentation-offloads.txt
@@ -20,8 +20,8 @@ TCP Segmentation Offload
 
 TCP segmentation allows a device to segment a single frame into multiple
 frames with a data payload size specified in skb_shinfo()->gso_size.
-When TCP segmentation requested the bit for either SKB_GSO_TCP or
-SKB_GSO_TCP6 should be set in skb_shinfo()->gso_type and
+When TCP segmentation requested the bit for either SKB_GSO_TCPV4 or
+SKB_GSO_TCPV6 should be set in skb_shinfo()->gso_type and
 skb_shinfo()->gso_size should be set to a non-zero value.
 
 TCP segmentation is dependent on support for the use of partial checksum
@@ -153,8 +153,18 @@ To signal this, gso_size is set to the special value GSO_BY_FRAGS.
 
 Therefore, any code in the core networking stack must be aware of the
 possibility that gso_size will be GSO_BY_FRAGS and handle that case
-appropriately. (For size checks, the skb_gso_validate_*_len family of
-helpers do this automatically.)
+appropriately.
+
+There are some helpers to make this easier:
+
+ - skb_is_gso(skb) && skb_is_gso_sctp(skb) is the best way to see if
+   an skb is an SCTP GSO skb.
+
+ - For size checks, the skb_gso_validate_*_len family of helpers correctly
+   considers GSO_BY_FRAGS.
+
+ - For manipulating packets, skb_increase_gso_size and skb_decrease_gso_size
+   will check for GSO_BY_FRAGS and WARN if asked to manipulate these skbs.
 
 This also affects drivers with the NETIF_F_FRAGLIST & NETIF_F_GSO_SCTP bits
 set. Note also that NETIF_F_GSO_SCTP is included in NETIF_F_GSO_SOFTWARE.
diff --git a/MAINTAINERS b/MAINTAINERS
index 205c8fc12a9c..73c0cdabf755 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -10334,7 +10334,7 @@ F:	drivers/oprofile/
 F:      include/linux/oprofile.h
 
 ORACLE CLUSTER FILESYSTEM 2 (OCFS2)
-M:      Mark Fasheh <mfasheh@versity.com>
+M:      Mark Fasheh <mark@fasheh.com>
 M:      Joel Becker <jlbec@evilplan.org>
 L:      ocfs2-devel@oss.oracle.com (moderated for non-subscribers)
 W:      http://ocfs2.wiki.kernel.org
@@ -10844,6 +10844,7 @@ F:	drivers/platform/x86/peaq-wmi.c
 PER-CPU MEMORY ALLOCATOR
 M:      Tejun Heo <tj@kernel.org>
 M:      Christoph Lameter <cl@linux.com>
+M:      Dennis Zhou <dennisszhou@gmail.com>
 T:      git git://git.kernel.org/pub/scm/linux/kernel/git/tj/percpu.git
 S:      Maintained
 F:      include/linux/percpu*.h
diff --git a/Makefile b/Makefile
index d65e2e229017..486db374d1c1 100644
--- a/Makefile
+++ b/Makefile
@@ -826,6 +826,15 @@ KBUILD_CFLAGS += $(call cc-disable-warning, pointer-sign)
 # disable invalid "can't wrap" optimizations for signed / pointers
 KBUILD_CFLAGS   += $(call cc-option,-fno-strict-overflow)
 
+# clang sets -fmerge-all-constants by default as optimization, but this
+# is non-conforming behavior for C and in fact breaks the kernel, so we
+# need to disable it here generally.
+KBUILD_CFLAGS   += $(call cc-option,-fno-merge-all-constants)
+
+# for gcc -fno-merge-all-constants disables everything, but it is fine
+# to have actual conforming behavior enabled.
+KBUILD_CFLAGS   += $(call cc-option,-fmerge-constants)
+
 # Make sure -fstack-check isn't enabled (like gentoo apparently did)
 KBUILD_CFLAGS  += $(call cc-option,-fno-stack-check,)
 
diff --git a/arch/arm64/mm/mmu.c b/arch/arm64/mm/mmu.c
index 8c704f1e53c2..2dbb2c9f1ec1 100644
--- a/arch/arm64/mm/mmu.c
+++ b/arch/arm64/mm/mmu.c
@@ -972,3 +972,13 @@ int pmd_clear_huge(pmd_t *pmdp)
         pmd_clear(pmdp);
         return 1;
 }
+
+int pud_free_pmd_page(pud_t *pud)
+{
+        return pud_none(*pud);
+}
+
+int pmd_free_pte_page(pmd_t *pmd)
+{
+        return pmd_none(*pmd);
+}
diff --git a/arch/h8300/include/asm/byteorder.h b/arch/h8300/include/asm/byteorder.h
index ecff2d1ca5a3..6eaa7ad5fc2c 100644
--- a/arch/h8300/include/asm/byteorder.h
+++ b/arch/h8300/include/asm/byteorder.h
@@ -2,7 +2,6 @@
 #ifndef __H8300_BYTEORDER_H__
 #define __H8300_BYTEORDER_H__
 
-#define __BIG_ENDIAN __ORDER_BIG_ENDIAN__
 #include <linux/byteorder/big_endian.h>
 
 #endif
diff --git a/arch/mips/lantiq/Kconfig b/arch/mips/lantiq/Kconfig
index 692ae85a3e3d..8e3a1fc2bc39 100644
--- a/arch/mips/lantiq/Kconfig
+++ b/arch/mips/lantiq/Kconfig
@@ -13,6 +13,8 @@ choice
 config SOC_AMAZON_SE
         bool "Amazon SE"
         select SOC_TYPE_XWAY
+        select MFD_SYSCON
+        select MFD_CORE
 
 config SOC_XWAY
         bool "XWAY"
diff --git a/arch/mips/lantiq/xway/sysctrl.c b/arch/mips/lantiq/xway/sysctrl.c
index 52500d3b7004..e0af39b33e28 100644
--- a/arch/mips/lantiq/xway/sysctrl.c
+++ b/arch/mips/lantiq/xway/sysctrl.c
@@ -549,9 +549,9 @@ void __init ltq_soc_init(void)
                 clkdev_add_static(ltq_ar9_cpu_hz(), ltq_ar9_fpi_hz(),
                                 ltq_ar9_fpi_hz(), CLOCK_250M);
                 clkdev_add_pmu("1f203018.usb2-phy", "phy", 1, 0, PMU_USB0_P);
-                clkdev_add_pmu("1e101000.usb", "otg", 1, 0, PMU_USB0);
+                clkdev_add_pmu("1e101000.usb", "otg", 1, 0, PMU_USB0 | PMU_AHBM);
                 clkdev_add_pmu("1f203034.usb2-phy", "phy", 1, 0, PMU_USB1_P);
-                clkdev_add_pmu("1e106000.usb", "otg", 1, 0, PMU_USB1);
+                clkdev_add_pmu("1e106000.usb", "otg", 1, 0, PMU_USB1 | PMU_AHBM);
                 clkdev_add_pmu("1e180000.etop", "switch", 1, 0, PMU_SWITCH);
                 clkdev_add_pmu("1e103000.sdio", NULL, 1, 0, PMU_SDIO);
                 clkdev_add_pmu("1e103100.deu", NULL, 1, 0, PMU_DEU);
@@ -560,7 +560,7 @@ void __init ltq_soc_init(void)
         } else {
                 clkdev_add_static(ltq_danube_cpu_hz(), ltq_danube_fpi_hz(),
                                 ltq_danube_fpi_hz(), ltq_danube_pp32_hz());
-                clkdev_add_pmu("1f203018.usb2-phy", "ctrl", 1, 0, PMU_USB0);
+                clkdev_add_pmu("1e101000.usb", "otg", 1, 0, PMU_USB0 | PMU_AHBM);
                 clkdev_add_pmu("1f203018.usb2-phy", "phy", 1, 0, PMU_USB0_P);
                 clkdev_add_pmu("1e103000.sdio", NULL, 1, 0, PMU_SDIO);
                 clkdev_add_pmu("1e103100.deu", NULL, 1, 0, PMU_DEU);
diff --git a/arch/mips/ralink/mt7621.c b/arch/mips/ralink/mt7621.c
index 1b274742077d..d2718de60b9b 100644
--- a/arch/mips/ralink/mt7621.c
+++ b/arch/mips/ralink/mt7621.c
@@ -170,6 +170,28 @@ void prom_soc_init(struct ralink_soc_info *soc_info)
         u32 n1;
         u32 rev;
 
+        /* Early detection of CMP support */
+        mips_cm_probe();
+        mips_cpc_probe();
+
+        if (mips_cps_numiocu(0)) {
+                /*
+                 * mips_cm_probe() wipes out bootloader
+                 * config for CM regions and we have to configure them
+                 * again. This SoC cannot talk to pamlbus devices
+                 * witout proper iocu region set up.
+                 *
+                 * FIXME: it would be better to do this with values
+                 * from DT, but we need this very early because
+                 * without this we cannot talk to pretty much anything
+                 * including serial.
+                 */
+                write_gcr_reg0_base(MT7621_PALMBUS_BASE);
+                write_gcr_reg0_mask(~MT7621_PALMBUS_SIZE |
+                                    CM_GCR_REGn_MASK_CMTGT_IOCU0);
+                __sync();
+        }
+
         n0 = __raw_readl(sysc + SYSC_REG_CHIP_NAME0);
         n1 = __raw_readl(sysc + SYSC_REG_CHIP_NAME1);
 
@@ -194,26 +216,6 @@ void prom_soc_init(struct ralink_soc_info *soc_info)
 
         rt2880_pinmux_data = mt7621_pinmux_data;
 
-        /* Early detection of CMP support */
-        mips_cm_probe();
-        mips_cpc_probe();
-
-        if (mips_cps_numiocu(0)) {
-                /*
-                 * mips_cm_probe() wipes out bootloader
-                 * config for CM regions and we have to configure them
-                 * again. This SoC cannot talk to pamlbus devices
-                 * witout proper iocu region set up.
-                 *
-                 * FIXME: it would be better to do this with values
-                 * from DT, but we need this very early because
-                 * without this we cannot talk to pretty much anything
-                 * including serial.
-                 */
-                write_gcr_reg0_base(MT7621_PALMBUS_BASE);
-                write_gcr_reg0_mask(~MT7621_PALMBUS_SIZE |
-                                    CM_GCR_REGn_MASK_CMTGT_IOCU0);
-        }
 
         if (!register_cps_smp_ops())
                 return;
diff --git a/arch/mips/ralink/reset.c b/arch/mips/ralink/reset.c
index 64543d66e76b..e9531fea23a2 100644
--- a/arch/mips/ralink/reset.c
+++ b/arch/mips/ralink/reset.c
@@ -96,16 +96,9 @@ static void ralink_restart(char *command)
         unreachable();
 }
 
-static void ralink_halt(void)
-{
-        local_irq_disable();
-        unreachable();
-}
-
 static int __init mips_reboot_setup(void)
 {
         _machine_restart = ralink_restart;
-        _machine_halt = ralink_halt;
 
         return 0;
 }
diff --git a/arch/x86/events/core.c b/arch/x86/events/core.c
index 140d33288e78..88797c80b3e0 100644
--- a/arch/x86/events/core.c
+++ b/arch/x86/events/core.c
@@ -2118,7 +2118,8 @@ static int x86_pmu_event_init(struct perf_event *event)
                         event->destroy(event);
         }
 
-        if (READ_ONCE(x86_pmu.attr_rdpmc))
+        if (READ_ONCE(x86_pmu.attr_rdpmc) &&
+            !(event->hw.flags & PERF_X86_EVENT_LARGE_PEBS))
                 event->hw.flags |= PERF_X86_EVENT_RDPMC_ALLOWED;
 
         return err;
diff --git a/arch/x86/events/intel/core.c b/arch/x86/events/intel/core.c
index 56457cb73448..1e41d7508d99 100644
--- a/arch/x86/events/intel/core.c
+++ b/arch/x86/events/intel/core.c
@@ -2952,9 +2952,9 @@ static void intel_pebs_aliases_skl(struct perf_event *event)
         return intel_pebs_aliases_precdist(event);
 }
 
-static unsigned long intel_pmu_free_running_flags(struct perf_event *event)
+static unsigned long intel_pmu_large_pebs_flags(struct perf_event *event)
 {
-        unsigned long flags = x86_pmu.free_running_flags;
+        unsigned long flags = x86_pmu.large_pebs_flags;
 
         if (event->attr.use_clockid)
                 flags &= ~PERF_SAMPLE_TIME;
@@ -2976,8 +2976,8 @@ static int intel_pmu_hw_config(struct perf_event *event)
                 if (!event->attr.freq) {
                         event->hw.flags |= PERF_X86_EVENT_AUTO_RELOAD;
                         if (!(event->attr.sample_type &
-                              ~intel_pmu_free_running_flags(event)))
-                                event->hw.flags |= PERF_X86_EVENT_FREERUNNING;
+                              ~intel_pmu_large_pebs_flags(event)))
+                                event->hw.flags |= PERF_X86_EVENT_LARGE_PEBS;
                 }
                 if (x86_pmu.pebs_aliases)
                         x86_pmu.pebs_aliases(event);
@@ -3194,7 +3194,7 @@ static unsigned bdw_limit_period(struct perf_event *event, unsigned left)
                         X86_CONFIG(.event=0xc0, .umask=0x01)) {
                 if (left < 128)
                         left = 128;
-                left &= ~0x3fu;
+                left &= ~0x3fULL;
         }
         return left;
 }
@@ -3460,7 +3460,7 @@ static __initconst const struct x86_pmu core_pmu = {
         .event_map              = intel_pmu_event_map,
         .max_events             = ARRAY_SIZE(intel_perfmon_event_map),
         .apic                   = 1,
-        .free_running_flags     = PEBS_FREERUNNING_FLAGS,
+        .large_pebs_flags       = LARGE_PEBS_FLAGS,
 
         /*
          * Intel PMCs cannot be accessed sanely above 32-bit width,
@@ -3502,7 +3502,7 @@ static __initconst const struct x86_pmu intel_pmu = {
         .event_map              = intel_pmu_event_map,
         .max_events             = ARRAY_SIZE(intel_perfmon_event_map),
         .apic                   = 1,
-        .free_running_flags     = PEBS_FREERUNNING_FLAGS,
+        .large_pebs_flags       = LARGE_PEBS_FLAGS,
         /*
          * Intel PMCs cannot be accessed sanely above 32 bit width,
          * so we install an artificial 1<<31 period regardless of
diff --git a/arch/x86/events/intel/ds.c b/arch/x86/events/intel/ds.c
index 18c25ab28557..d8015235ba76 100644
--- a/arch/x86/events/intel/ds.c
+++ b/arch/x86/events/intel/ds.c
@@ -935,7 +935,7 @@ void intel_pmu_pebs_add(struct perf_event *event)
         bool needed_cb = pebs_needs_sched_cb(cpuc);
 
         cpuc->n_pebs++;
-        if (hwc->flags & PERF_X86_EVENT_FREERUNNING)
+        if (hwc->flags & PERF_X86_EVENT_LARGE_PEBS)
                 cpuc->n_large_pebs++;
 
         pebs_update_state(needed_cb, cpuc, event->ctx->pmu);
@@ -975,7 +975,7 @@ void intel_pmu_pebs_del(struct perf_event *event)
         bool needed_cb = pebs_needs_sched_cb(cpuc);
 
         cpuc->n_pebs--;
-        if (hwc->flags & PERF_X86_EVENT_FREERUNNING)
+        if (hwc->flags & PERF_X86_EVENT_LARGE_PEBS)
                 cpuc->n_large_pebs--;
 
         pebs_update_state(needed_cb, cpuc, event->ctx->pmu);
@@ -1530,7 +1530,7 @@ void __init intel_ds_init(void)
                         x86_pmu.pebs_record_size =
                                                 sizeof(struct pebs_record_skl);
                         x86_pmu.drain_pebs = intel_pmu_drain_pebs_nhm;
-                        x86_pmu.free_running_flags |= PERF_SAMPLE_TIME;
+                        x86_pmu.large_pebs_flags |= PERF_SAMPLE_TIME;
                         break;
 
                 default:
diff --git a/arch/x86/events/intel/uncore_snbep.c b/arch/x86/events/intel/uncore_snbep.c
index 22ec65bc033a..c98b943e58b4 100644
--- a/arch/x86/events/intel/uncore_snbep.c
+++ b/arch/x86/events/intel/uncore_snbep.c
@@ -3343,6 +3343,7 @@ static struct extra_reg skx_uncore_cha_extra_regs[] = {
         SNBEP_CBO_EVENT_EXTRA_REG(0x9134, 0xffff, 0x4),
         SNBEP_CBO_EVENT_EXTRA_REG(0x35, 0xff, 0x8),
         SNBEP_CBO_EVENT_EXTRA_REG(0x36, 0xff, 0x8),
+        SNBEP_CBO_EVENT_EXTRA_REG(0x38, 0xff, 0x3),
         EVENT_EXTRA_END
 };
 
@@ -3562,24 +3563,27 @@ static struct intel_uncore_type *skx_msr_uncores[] = {
         NULL,
 };
 
+/*
+ * To determine the number of CHAs, it should read bits 27:0 in the CAPID6
+ * register which located at Device 30, Function 3, Offset 0x9C. PCI ID 0x2083.
+ */
+#define SKX_CAPID6              0x9c
+#define SKX_CHA_BIT_MASK        GENMASK(27, 0)
+
 static int skx_count_chabox(void)
 {
-        struct pci_dev *chabox_dev = NULL;
-        int bus, count = 0;
+        struct pci_dev *dev = NULL;
+        u32 val = 0;
 
-        while (1) {
-                chabox_dev = pci_get_device(PCI_VENDOR_ID_INTEL, 0x208d, chabox_dev);
-                if (!chabox_dev)
-                        break;
-                if (count == 0)
-                        bus = chabox_dev->bus->number;
-                if (bus != chabox_dev->bus->number)
-                        break;
-                count++;
-        }
+        dev = pci_get_device(PCI_VENDOR_ID_INTEL, 0x2083, dev);
+        if (!dev)
+                goto out;
 
-        pci_dev_put(chabox_dev);
-        return count;
+        pci_read_config_dword(dev, SKX_CAPID6, &val);
+        val &= SKX_CHA_BIT_MASK;
+out:
+        pci_dev_put(dev);
+        return hweight32(val);
 }
 
 void skx_uncore_cpu_init(void)
diff --git a/arch/x86/events/perf_event.h b/arch/x86/events/perf_event.h
index 78f91ec1056e..39cd0615f04f 100644
--- a/arch/x86/events/perf_event.h
+++ b/arch/x86/events/perf_event.h
@@ -69,7 +69,7 @@ struct event_constraint {
 #define PERF_X86_EVENT_RDPMC_ALLOWED    0x0100 /* grant rdpmc permission */
 #define PERF_X86_EVENT_EXCL_ACCT        0x0200 /* accounted EXCL event */
 #define PERF_X86_EVENT_AUTO_RELOAD      0x0400 /* use PEBS auto-reload */
-#define PERF_X86_EVENT_FREERUNNING      0x0800 /* use freerunning PEBS */
+#define PERF_X86_EVENT_LARGE_PEBS       0x0800 /* use large PEBS */
 
 
 struct amd_nb {
@@ -88,7 +88,7 @@ struct amd_nb {
  * REGS_USER can be handled for events limited to ring 3.
  *
  */
-#define PEBS_FREERUNNING_FLAGS \
+#define LARGE_PEBS_FLAGS \
         (PERF_SAMPLE_IP | PERF_SAMPLE_TID | PERF_SAMPLE_ADDR | \
         PERF_SAMPLE_ID | PERF_SAMPLE_CPU | PERF_SAMPLE_STREAM_ID | \
         PERF_SAMPLE_DATA_SRC | PERF_SAMPLE_IDENTIFIER | \
@@ -608,7 +608,7 @@ struct x86_pmu {
         struct event_constraint *pebs_constraints;
         void            (*pebs_aliases)(struct perf_event *event);
         int             max_pebs_events;
-        unsigned long   free_running_flags;
+        unsigned long   large_pebs_flags;
 
         /*
          * Intel LBR
diff --git a/arch/x86/include/asm/vmx.h b/arch/x86/include/asm/vmx.h
index 8b6780751132..5db8b0b10766 100644
--- a/arch/x86/include/asm/vmx.h
+++ b/arch/x86/include/asm/vmx.h
@@ -352,6 +352,7 @@ enum vmcs_field {
 #define INTR_TYPE_NMI_INTR              (2 << 8) /* NMI */
 #define INTR_TYPE_HARD_EXCEPTION        (3 << 8) /* processor exception */
 #define INTR_TYPE_SOFT_INTR             (4 << 8) /* software interrupt */
+#define INTR_TYPE_PRIV_SW_EXCEPTION     (5 << 8) /* ICE breakpoint - undocumented */
 #define INTR_TYPE_SOFT_EXCEPTION        (6 << 8) /* software exception */
 
 /* GUEST_INTERRUPTIBILITY_INFO flags. */
diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c
index 051dab74e4e9..2d87603f9179 100644
--- a/arch/x86/kvm/vmx.c
+++ b/arch/x86/kvm/vmx.c
@@ -1045,6 +1045,13 @@ static inline bool is_machine_check(u32 intr_info)
                 (INTR_TYPE_HARD_EXCEPTION | MC_VECTOR | INTR_INFO_VALID_MASK);
 }
 
+/* Undocumented: icebp/int1 */
+static inline bool is_icebp(u32 intr_info)
+{
+        return (intr_info & (INTR_INFO_INTR_TYPE_MASK | INTR_INFO_VALID_MASK))
+                == (INTR_TYPE_PRIV_SW_EXCEPTION | INTR_INFO_VALID_MASK);
+}
+
 static inline bool cpu_has_vmx_msr_bitmap(void)
 {
         return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_USE_MSR_BITMAPS;
@@ -6179,7 +6186,7 @@ static int handle_exception(struct kvm_vcpu *vcpu)
                       (KVM_GUESTDBG_SINGLESTEP | KVM_GUESTDBG_USE_HW_BP))) {
                         vcpu->arch.dr6 &= ~15;
                         vcpu->arch.dr6 |= dr6 | DR6_RTM;
-                        if (!(dr6 & ~DR6_RESERVED)) /* icebp */
+                        if (is_icebp(intr_info))
                                 skip_emulated_instruction(vcpu);
 
                         kvm_queue_exception(vcpu, DB_VECTOR);
diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c
index 8b72923f1d35..af11a2890235 100644
--- a/arch/x86/mm/init_64.c
+++ b/arch/x86/mm/init_64.c
@@ -800,17 +800,11 @@ int arch_add_memory(int nid, u64 start, u64 size, struct vmem_altmap *altmap,
 
 #define PAGE_INUSE 0xFD
 
-static void __meminit free_pagetable(struct page *page, int order,
-                struct vmem_altmap *altmap)
+static void __meminit free_pagetable(struct page *page, int order)
 {
         unsigned long magic;
         unsigned int nr_pages = 1 << order;
 
-        if (altmap) {
-                vmem_altmap_free(altmap, nr_pages);
-                return;
-        }
-
         /* bootmem page has reserved flag */
         if (PageReserved(page)) {
                 __ClearPageReserved(page);
@@ -826,9 +820,17 @@ static void __meminit free_pagetable(struct page *page, int order,
                 free_pages((unsigned long)page_address(page), order);
 }
 
-static void __meminit free_pte_table(pte_t *pte_start, pmd_t *pmd,
+static void __meminit free_hugepage_table(struct page *page,
                 struct vmem_altmap *altmap)
 {
+        if (altmap)
+                vmem_altmap_free(altmap, PMD_SIZE / PAGE_SIZE);
+        else
+                free_pagetable(page, get_order(PMD_SIZE));
+}
+
+static void __meminit free_pte_table(pte_t *pte_start, pmd_t *pmd)
+{
         pte_t *pte;
         int i;
 
@@ -839,14 +841,13 @@ static void __meminit free_pte_table(pte_t *pte_start, pmd_t *pmd,
         }
 
         /* free a pte talbe */
-        free_pagetable(pmd_page(*pmd), 0, altmap);
+        free_pagetable(pmd_page(*pmd), 0);
         spin_lock(&init_mm.page_table_lock);
         pmd_clear(pmd);
         spin_unlock(&init_mm.page_table_lock);
 }
 
-static void __meminit free_pmd_table(pmd_t *pmd_start, pud_t *pud,
-                struct vmem_altmap *altmap)
+static void __meminit free_pmd_table(pmd_t *pmd_start, pud_t *pud)
 {
         pmd_t *pmd;
         int i;
@@ -858,14 +859,13 @@ static void __meminit free_pmd_table(pmd_t *pmd_start, pud_t *pud,
         }
 
         /* free a pmd talbe */
-        free_pagetable(pud_page(*pud), 0, altmap);
+        free_pagetable(pud_page(*pud), 0);
         spin_lock(&init_mm.page_table_lock);
         pud_clear(pud);
         spin_unlock(&init_mm.page_table_lock);
 }
 
-static void __meminit free_pud_table(pud_t *pud_start, p4d_t *p4d,
-                struct vmem_altmap *altmap)
+static void __meminit free_pud_table(pud_t *pud_start, p4d_t *p4d)
 {
         pud_t *pud;
         int i;
@@ -877,7 +877,7 @@ static void __meminit free_pud_table(pud_t *pud_start, p4d_t *p4d,
         }
 
         /* free a pud talbe */
-        free_pagetable(p4d_page(*p4d), 0, altmap);
+        free_pagetable(p4d_page(*p4d), 0);
         spin_lock(&init_mm.page_table_lock);
         p4d_clear(p4d);
         spin_unlock(&init_mm.page_table_lock);
@@ -885,7 +885,7 @@ static void __meminit free_pud_table(pud_t *pud_start, p4d_t *p4d,
 
 static void __meminit
 remove_pte_table(pte_t *pte_start, unsigned long addr, unsigned long end,
-                 struct vmem_altmap *altmap, bool direct)
+                 bool direct)
 {
         unsigned long next, pages = 0;
         pte_t *pte;
@@ -916,7 +916,7 @@ remove_pte_table(pte_t *pte_start, unsigned long addr, unsigned long end,
                          * freed when offlining, or simplely not in use.
                          */
                         if (!direct)
-                                free_pagetable(pte_page(*pte), 0, altmap);
+                                free_pagetable(pte_page(*pte), 0);
 
                         spin_lock(&init_mm.page_table_lock);
                         pte_clear(&init_mm, addr, pte);
@@ -939,7 +939,7 @@ remove_pte_table(pte_t *pte_start, unsigned long addr, unsigned long end,
 
                         page_addr = page_address(pte_page(*pte));
                         if (!memchr_inv(page_addr, PAGE_INUSE, PAGE_SIZE)) {
-                                free_pagetable(pte_page(*pte), 0, altmap);
+                                free_pagetable(pte_page(*pte), 0);
 
                                 spin_lock(&init_mm.page_table_lock);
                                 pte_clear(&init_mm, addr, pte);
@@ -974,9 +974,8 @@ remove_pmd_table(pmd_t *pmd_start, unsigned long addr, unsigned long end,
                         if (IS_ALIGNED(addr, PMD_SIZE) &&
                             IS_ALIGNED(next, PMD_SIZE)) {
                                 if (!direct)
-                                        free_pagetable(pmd_page(*pmd),
-                                                       get_order(PMD_SIZE),
-                                                       altmap);
+                                        free_hugepage_table(pmd_page(*pmd),
+                                                            altmap);
 
                                 spin_lock(&init_mm.page_table_lock);
                                 pmd_clear(pmd);
@@ -989,9 +988,8 @@ remove_pmd_table(pmd_t *pmd_start, unsigned long addr, unsigned long end,
                                 page_addr = page_address(pmd_page(*pmd));
                                 if (!memchr_inv(page_addr, PAGE_INUSE,
                                                 PMD_SIZE)) {
-                                        free_pagetable(pmd_page(*pmd),
-                                                       get_order(PMD_SIZE),
-                                                       altmap);
+                                        free_hugepage_table(pmd_page(*pmd),
+                                                            altmap);
 
                                         spin_lock(&init_mm.page_table_lock);
                                         pmd_clear(pmd);
@@ -1003,8 +1001,8 @@ remove_pmd_table(pmd_t *pmd_start, unsigned long addr, unsigned long end,
                 }
 
                 pte_base = (pte_t *)pmd_page_vaddr(*pmd);
-                remove_pte_table(pte_base, addr, next, altmap, direct);
-                free_pte_table(pte_base, pmd, altmap);
+                remove_pte_table(pte_base, addr, next, direct);
+                free_pte_table(pte_base, pmd);
         }
 
         /* Call free_pmd_table() in remove_pud_table(). */
@@ -1033,8 +1031,7 @@ remove_pud_table(pud_t *pud_start, unsigned long addr, unsigned long end,
                             IS_ALIGNED(next, PUD_SIZE)) {
                                 if (!direct)
                                         free_pagetable(pud_page(*pud),
-                                                       get_order(PUD_SIZE),
-                                                       altmap);
+                                                       get_order(PUD_SIZE));
 
                                 spin_lock(&init_mm.page_table_lock);
                                 pud_clear(pud);
@@ -1048,8 +1045,7 @@ remove_pud_table(pud_t *pud_start, unsigned long addr, unsigned long end,
                                 if (!memchr_inv(page_addr, PAGE_INUSE,
                                                 PUD_SIZE)) {
                                         free_pagetable(pud_page(*pud),
-                                                       get_order(PUD_SIZE),
-                                                       altmap);
+                                                       get_order(PUD_SIZE));
 
                                         spin_lock(&init_mm.page_table_lock);
                                         pud_clear(pud);
@@ -1062,7 +1058,7 @@ remove_pud_table(pud_t *pud_start, unsigned long addr, unsigned long end,
 
                 pmd_base = pmd_offset(pud, 0);
                 remove_pmd_table(pmd_base, addr, next, direct, altmap);
-                free_pmd_table(pmd_base, pud, altmap);
+                free_pmd_table(pmd_base, pud);
         }
 
         if (direct)
@@ -1094,7 +1090,7 @@ remove_p4d_table(p4d_t *p4d_start, unsigned long addr, unsigned long end,
                  * to adapt for boot-time switching between 4 and 5 level page tables.
                  */
                 if (CONFIG_PGTABLE_LEVELS == 5)
-                        free_pud_table(pud_base, p4d, altmap);
+                        free_pud_table(pud_base, p4d);
         }
 
         if (direct)
diff --git a/arch/x86/mm/pgtable.c b/arch/x86/mm/pgtable.c
index 004abf9ebf12..34cda7e0551b 100644
--- a/arch/x86/mm/pgtable.c
+++ b/arch/x86/mm/pgtable.c
@@ -702,4 +702,52 @@ int pmd_clear_huge(pmd_t *pmd)
 
         return 0;
 }
+
+/**
+ * pud_free_pmd_page - Clear pud entry and free pmd page.
+ * @pud: Pointer to a PUD.
+ *
+ * Context: The pud range has been unmaped and TLB purged.
+ * Return: 1 if clearing the entry succeeded. 0 otherwise.
+ */
+int pud_free_pmd_page(pud_t *pud)
+{
+        pmd_t *pmd;
+        int i;
+
+        if (pud_none(*pud))
+                return 1;
+
+        pmd = (pmd_t *)pud_page_vaddr(*pud);
+
+        for (i = 0; i < PTRS_PER_PMD; i++)
+                if (!pmd_free_pte_page(&pmd[i]))
+                        return 0;
+
+        pud_clear(pud);
+        free_page((unsigned long)pmd);
+
+        return 1;
+}
+
+/**
+ * pmd_free_pte_page - Clear pmd entry and free pte page.
+ * @pmd: Pointer to a PMD.
+ *
+ * Context: The pmd range has been unmaped and TLB purged.
+ * Return: 1 if clearing the entry succeeded. 0 otherwise.
+ */
+int pmd_free_pte_page(pmd_t *pmd)
+{
+        pte_t *pte;
+
+        if (pmd_none(*pmd))
+                return 1;
+
+        pte = (pte_t *)pmd_page_vaddr(*pmd);
+        pmd_clear(pmd);
+        free_page((unsigned long)pte);
+
+        return 1;
+}
 #endif  /* CONFIG_HAVE_ARCH_HUGE_VMAP */
diff --git a/arch/x86/net/bpf_jit_comp.c b/arch/x86/net/bpf_jit_comp.c
index 45e4eb5bcbb2..ce5b2ebd5701 100644
--- a/arch/x86/net/bpf_jit_comp.c
+++ b/arch/x86/net/bpf_jit_comp.c
@@ -1188,7 +1188,7 @@ skip_init_addrs:
          * may converge on the last pass. In such case do one more
          * pass to emit the final image
          */
-        for (pass = 0; pass < 10 || image; pass++) {
+        for (pass = 0; pass < 20 || image; pass++) {
                 proglen = do_jit(prog, addrs, image, oldproglen, &ctx);
                 if (proglen <= 0) {
                         image = NULL;
@@ -1215,6 +1215,7 @@ skip_init_addrs:
                         }
                 }
                 oldproglen = proglen;
+                cond_resched();
         }
 
         if (bpf_jit_enable > 1)
diff --git a/drivers/acpi/acpi_watchdog.c b/drivers/acpi/acpi_watchdog.c
index 11b113f8e367..ebb626ffb5fa 100644
--- a/drivers/acpi/acpi_watchdog.c
+++ b/drivers/acpi/acpi_watchdog.c
@@ -74,10 +74,10 @@ void __init acpi_watchdog_init(void)
                 res.start = gas->address;
                 if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
                         res.flags = IORESOURCE_MEM;
-                        res.end = res.start + ALIGN(gas->access_width, 4);
+                        res.end = res.start + ALIGN(gas->access_width, 4) - 1;
                 } else if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
                         res.flags = IORESOURCE_IO;
-                        res.end = res.start + gas->access_width;
+                        res.end = res.start + gas->access_width - 1;
                 } else {
                         pr_warn("Unsupported address space: %u\n",
                                 gas->space_id);
diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c
index 7128488a3a72..f2eb6c37ea0a 100644
--- a/drivers/acpi/battery.c
+++ b/drivers/acpi/battery.c
@@ -70,7 +70,6 @@ static async_cookie_t async_cookie;
 static bool battery_driver_registered;
 static int battery_bix_broken_package;
 static int battery_notification_delay_ms;
-static int battery_full_discharging;
 static unsigned int cache_time = 1000;
 module_param(cache_time, uint, 0644);
 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
@@ -215,12 +214,9 @@ static int acpi_battery_get_property(struct power_supply *psy,
                 return -ENODEV;
         switch (psp) {
         case POWER_SUPPLY_PROP_STATUS:
-                if (battery->state & ACPI_BATTERY_STATE_DISCHARGING) {
-                        if (battery_full_discharging && battery->rate_now == 0)
-                                val->intval = POWER_SUPPLY_STATUS_FULL;
-                        else
-                                val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
-                } else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
+                if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
+                        val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
+                else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
                 else if (acpi_battery_is_charged(battery))
                         val->intval = POWER_SUPPLY_STATUS_FULL;
@@ -1170,12 +1166,6 @@ battery_notification_delay_quirk(const struct dmi_system_id *d)
         return 0;
 }
 
-static int __init battery_full_discharging_quirk(const struct dmi_system_id *d)
-{
-        battery_full_discharging = 1;
-        return 0;
-}
-
 static const struct dmi_system_id bat_dmi_table[] __initconst = {
         {
                 .callback = battery_bix_broken_package_quirk,
@@ -1193,38 +1183,6 @@ static const struct dmi_system_id bat_dmi_table[] __initconst = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"),
                 },
         },
-        {
-                .callback = battery_full_discharging_quirk,
-                .ident = "ASUS GL502VSK",
-                .matches = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "GL502VSK"),
-                },
-        },
-        {
-                .callback = battery_full_discharging_quirk,
-                .ident = "ASUS UX305LA",
-                .matches = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "UX305LA"),
-                },
-        },
-        {
-                .callback = battery_full_discharging_quirk,
-                .ident = "ASUS UX360UA",
-                .matches = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "UX360UA"),
-                },
-        },
-        {
-                .callback = battery_full_discharging_quirk,
-                .ident = "ASUS UX410UAK",
-                .matches = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "UX410UAK"),
-                },
-        },
         {},
 };
 
diff --git a/drivers/acpi/nfit/core.c b/drivers/acpi/nfit/core.c
index bbe48ad20886..eb09ef55c38a 100644
--- a/drivers/acpi/nfit/core.c
+++ b/drivers/acpi/nfit/core.c
@@ -2675,10 +2675,14 @@ static int acpi_nfit_register_region(struct acpi_nfit_desc *acpi_desc,
         else
                 ndr_desc->numa_node = NUMA_NO_NODE;
 
-        if(acpi_desc->platform_cap & ACPI_NFIT_CAPABILITY_CACHE_FLUSH)
+        /*
+         * Persistence domain bits are hierarchical, if
+         * ACPI_NFIT_CAPABILITY_CACHE_FLUSH is set then
+         * ACPI_NFIT_CAPABILITY_MEM_FLUSH is implied.
+         */
+        if (acpi_desc->platform_cap & ACPI_NFIT_CAPABILITY_CACHE_FLUSH)
                 set_bit(ND_REGION_PERSIST_CACHE, &ndr_desc->flags);
-
-        if (acpi_desc->platform_cap & ACPI_NFIT_CAPABILITY_MEM_FLUSH)
+        else if (acpi_desc->platform_cap & ACPI_NFIT_CAPABILITY_MEM_FLUSH)
                 set_bit(ND_REGION_PERSIST_MEMCTRL, &ndr_desc->flags);
 
         list_for_each_entry(nfit_memdev, &acpi_desc->memdevs, list) {
diff --git a/drivers/acpi/numa.c b/drivers/acpi/numa.c
index 8ccaae3550d2..85167603b9c9 100644
--- a/drivers/acpi/numa.c
+++ b/drivers/acpi/numa.c
@@ -103,25 +103,27 @@ int acpi_map_pxm_to_node(int pxm)
  */
 int acpi_map_pxm_to_online_node(int pxm)
 {
-        int node, n, dist, min_dist;
+        int node, min_node;
 
         node = acpi_map_pxm_to_node(pxm);
 
         if (node == NUMA_NO_NODE)
                 node = 0;
 
+        min_node = node;
         if (!node_online(node)) {
-                min_dist = INT_MAX;
+                int min_dist = INT_MAX, dist, n;
+
                 for_each_online_node(n) {
                         dist = node_distance(node, n);
                         if (dist < min_dist) {
                                 min_dist = dist;
-                                node = n;
+                                min_node = n;
                         }
                 }
         }
 
-        return node;
+        return min_node;
 }
 EXPORT_SYMBOL(acpi_map_pxm_to_online_node);
 
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index 355a95a83a34..1ff17799769d 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -550,7 +550,9 @@ static const struct pci_device_id ahci_pci_tbl[] = {
           .driver_data = board_ahci_yes_fbs },
         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL_EXT, 0x9230),
           .driver_data = board_ahci_yes_fbs },
-        { PCI_DEVICE(PCI_VENDOR_ID_TTI, 0x0642),
+        { PCI_DEVICE(PCI_VENDOR_ID_TTI, 0x0642), /* highpoint rocketraid 642L */
+          .driver_data = board_ahci_yes_fbs },
+        { PCI_DEVICE(PCI_VENDOR_ID_TTI, 0x0645), /* highpoint rocketraid 644L */
           .driver_data = board_ahci_yes_fbs },
 
         /* Promise */
diff --git a/drivers/ata/libahci.c b/drivers/ata/libahci.c
index a0de7a38430c..7adcf3caabd0 100644
--- a/drivers/ata/libahci.c
+++ b/drivers/ata/libahci.c
@@ -665,6 +665,16 @@ int ahci_stop_engine(struct ata_port *ap)
         if ((tmp & (PORT_CMD_START | PORT_CMD_LIST_ON)) == 0)
                 return 0;
 
+        /*
+         * Don't try to issue commands but return with ENODEV if the
+         * AHCI controller not available anymore (e.g. due to PCIe hot
+         * unplugging). Otherwise a 500ms delay for each port is added.
+         */
+        if (tmp == 0xffffffff) {
+                dev_err(ap->host->dev, "AHCI controller unavailable!\n");
+                return -ENODEV;
+        }
+
         /* setting HBA to idle */
         tmp &= ~PORT_CMD_START;
         writel(tmp, port_mmio + PORT_CMD);
diff --git a/drivers/ata/libahci_platform.c b/drivers/ata/libahci_platform.c
index 341d0ef82cbd..30cc8f1a31e1 100644
--- a/drivers/ata/libahci_platform.c
+++ b/drivers/ata/libahci_platform.c
@@ -340,7 +340,7 @@ static int ahci_platform_get_regulator(struct ahci_host_priv *hpriv, u32 port,
  * 2) regulator for controlling the targets power (optional)
  * 3) 0 - AHCI_MAX_CLKS clocks, as specified in the devs devicetree node,
  *    or for non devicetree enabled platforms a single clock
- *      4) phys (optional)
+ * 4) phys (optional)
  *
  * RETURNS:
  * The allocated ahci_host_priv on success, otherwise an ERR_PTR value
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 3c09122bf038..7431ccd03316 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -4530,6 +4530,25 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
         { "PIONEER DVD-RW  DVR-212D",   NULL,   ATA_HORKAGE_NOSETXFER },
         { "PIONEER DVD-RW  DVR-216D",   NULL,   ATA_HORKAGE_NOSETXFER },
 
+        /* Crucial BX100 SSD 500GB has broken LPM support */
+        { "CT500BX100SSD1",             NULL,   ATA_HORKAGE_NOLPM },
+
+        /* 512GB MX100 with MU01 firmware has both queued TRIM and LPM issues */
+        { "Crucial_CT512MX100*",        "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
+                                                ATA_HORKAGE_ZERO_AFTER_TRIM |
+                                                ATA_HORKAGE_NOLPM, },
+        /* 512GB MX100 with newer firmware has only LPM issues */
+        { "Crucial_CT512MX100*",        NULL,   ATA_HORKAGE_ZERO_AFTER_TRIM |
+                                                ATA_HORKAGE_NOLPM, },
+
+        /* 480GB+ M500 SSDs have both queued TRIM and LPM issues */
+        { "Crucial_CT480M500*",         NULL,   ATA_HORKAGE_NO_NCQ_TRIM |
+                                                ATA_HORKAGE_ZERO_AFTER_TRIM |
+                                                ATA_HORKAGE_NOLPM, },
+        { "Crucial_CT960M500*",         NULL,   ATA_HORKAGE_NO_NCQ_TRIM |
+                                                ATA_HORKAGE_ZERO_AFTER_TRIM |
+                                                ATA_HORKAGE_NOLPM, },
+
         /* devices that don't properly handle queued TRIM commands */
         { "Micron_M500_*",              NULL,   ATA_HORKAGE_NO_NCQ_TRIM |
                                                 ATA_HORKAGE_ZERO_AFTER_TRIM, },
@@ -4541,7 +4560,9 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
                                                 ATA_HORKAGE_ZERO_AFTER_TRIM, },
         { "Crucial_CT*MX100*",          "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
                                                 ATA_HORKAGE_ZERO_AFTER_TRIM, },
-        { "Samsung SSD 8*",             NULL,   ATA_HORKAGE_NO_NCQ_TRIM |
+        { "Samsung SSD 840*",           NULL,   ATA_HORKAGE_NO_NCQ_TRIM |
+                                                ATA_HORKAGE_ZERO_AFTER_TRIM, },
+        { "Samsung SSD 850*",           NULL,   ATA_HORKAGE_NO_NCQ_TRIM |
                                                 ATA_HORKAGE_ZERO_AFTER_TRIM, },
         { "FCCT*M500*",                 NULL,   ATA_HORKAGE_NO_NCQ_TRIM |
                                                 ATA_HORKAGE_ZERO_AFTER_TRIM, },
@@ -5401,8 +5422,7 @@ void ata_qc_issue(struct ata_queued_cmd *qc)
          * We guarantee to LLDs that they will have at least one
          * non-zero sg if the command is a data command.
          */
-        if (WARN_ON_ONCE(ata_is_data(prot) &&
-                         (!qc->sg || !qc->n_elem || !qc->nbytes)))
+        if (ata_is_data(prot) && (!qc->sg || !qc->n_elem || !qc->nbytes))
                 goto sys_err;
 
         if (ata_is_dma(prot) || (ata_is_pio(prot) &&
diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index 11c3137d7b0a..c016829a38fd 100644
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -815,7 +815,8 @@ void ata_scsi_port_error_handler(struct Scsi_Host *host, struct ata_port *ap)
 
         if (ap->pflags & ATA_PFLAG_LOADING)
                 ap->pflags &= ~ATA_PFLAG_LOADING;
-        else if (ap->pflags & ATA_PFLAG_SCSI_HOTPLUG)
+        else if ((ap->pflags & ATA_PFLAG_SCSI_HOTPLUG) &&
+                !(ap->flags & ATA_FLAG_SAS_HOST))
                 schedule_delayed_work(&ap->hotplug_task, 0);
 
         if (ap->pflags & ATA_PFLAG_RECOVERED)
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index 66be961c93a4..89a9d4a2efc8 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -3316,6 +3316,12 @@ static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
                 goto invalid_fld;
         }
 
+        /* We may not issue NCQ commands to devices not supporting NCQ */
+        if (ata_is_ncq(tf->protocol) && !ata_ncq_enabled(dev)) {
+                fp = 1;
+                goto invalid_fld;
+        }
+
         /* sanity check for pio multi commands */
         if ((cdb[1] & 0xe0) && !is_multi_taskfile(tf)) {
                 fp = 1;
@@ -4282,7 +4288,7 @@ static inline void ata_scsi_dump_cdb(struct ata_port *ap,
 #ifdef ATA_DEBUG
         struct scsi_device *scsidev = cmd->device;
 
-        DPRINTK("CDB (%u:%d,%d,%d) %9ph\n",
+        DPRINTK("CDB (%u:%d,%d,%lld) %9ph\n",
                 ap->print_id,
                 scsidev->channel, scsidev->id, scsidev->lun,
                 cmd->cmnd);
@@ -4309,7 +4315,9 @@ static inline int __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
                 if (likely((scsi_op != ATA_16) || !atapi_passthru16)) {
                         /* relay SCSI command to ATAPI device */
                         int len = COMMAND_SIZE(scsi_op);
-                        if (unlikely(len > scmd->cmd_len || len > dev->cdb_len))
+                        if (unlikely(len > scmd->cmd_len ||
+                                     len > dev->cdb_len ||
+                                     scmd->cmd_len > ATAPI_CDB_LEN))
                                 goto bad_cdb_len;
 
                         xlat_func = atapi_xlat;
diff --git a/drivers/ata/sata_rcar.c b/drivers/ata/sata_rcar.c
index 80ee2f2a50d0..6456e07db72a 100644
--- a/drivers/ata/sata_rcar.c
+++ b/drivers/ata/sata_rcar.c
@@ -146,6 +146,7 @@
 enum sata_rcar_type {
         RCAR_GEN1_SATA,
         RCAR_GEN2_SATA,
+        RCAR_GEN3_SATA,
         RCAR_R8A7790_ES1_SATA,
 };
 
@@ -784,26 +785,11 @@ static void sata_rcar_setup_port(struct ata_host *host)
         ioaddr->command_addr    = ioaddr->cmd_addr + (ATA_REG_CMD << 2);
 }
 
-static void sata_rcar_init_controller(struct ata_host *host)
+static void sata_rcar_init_module(struct sata_rcar_priv *priv)
 {
-        struct sata_rcar_priv *priv = host->private_data;
         void __iomem *base = priv->base;
         u32 val;
 
-        /* reset and setup phy */
-        switch (priv->type) {
-        case RCAR_GEN1_SATA:
-                sata_rcar_gen1_phy_init(priv);
-                break;
-        case RCAR_GEN2_SATA:
-        case RCAR_R8A7790_ES1_SATA:
-                sata_rcar_gen2_phy_init(priv);
-                break;
-        default:
-                dev_warn(host->dev, "SATA phy is not initialized\n");
-                break;
-        }
-
         /* SATA-IP reset state */
         val = ioread32(base + ATAPI_CONTROL1_REG);
         val |= ATAPI_CONTROL1_RESET;
@@ -824,10 +810,33 @@ static void sata_rcar_init_controller(struct ata_host *host)
         /* ack and mask */
         iowrite32(0, base + SATAINTSTAT_REG);
         iowrite32(0x7ff, base + SATAINTMASK_REG);
+
         /* enable interrupts */
         iowrite32(ATAPI_INT_ENABLE_SATAINT, base + ATAPI_INT_ENABLE_REG);
 }
 
+static void sata_rcar_init_controller(struct ata_host *host)
+{
+        struct sata_rcar_priv *priv = host->private_data;
+
+        /* reset and setup phy */
+        switch (priv->type) {
+        case RCAR_GEN1_SATA:
+                sata_rcar_gen1_phy_init(priv);
+                break;
+        case RCAR_GEN2_SATA:
+        case RCAR_GEN3_SATA:
+        case RCAR_R8A7790_ES1_SATA:
+                sata_rcar_gen2_phy_init(priv);
+                break;
+        default:
+                dev_warn(host->dev, "SATA phy is not initialized\n");
+                break;
+        }
+
+        sata_rcar_init_module(priv);
+}
+
 static const struct of_device_id sata_rcar_match[] = {
         {
                 /* Deprecated by "renesas,sata-r8a7779" */
@@ -856,7 +865,7 @@ static const struct of_device_id sata_rcar_match[] = {
         },
         {
                 .compatible = "renesas,sata-r8a7795",
-                .data = (void *)RCAR_GEN2_SATA
+                .data = (void *)RCAR_GEN3_SATA
         },
         {
                 .compatible = "renesas,rcar-gen2-sata",
@@ -864,7 +873,7 @@ static const struct of_device_id sata_rcar_match[] = {
         },
         {
                 .compatible = "renesas,rcar-gen3-sata",
-                .data = (void *)RCAR_GEN2_SATA
+                .data = (void *)RCAR_GEN3_SATA
         },
         { },
 };
@@ -982,11 +991,18 @@ static int sata_rcar_resume(struct device *dev)
         if (ret)
                 return ret;
 
-        /* ack and mask */
-        iowrite32(0, base + SATAINTSTAT_REG);
-        iowrite32(0x7ff, base + SATAINTMASK_REG);
-        /* enable interrupts */
-        iowrite32(ATAPI_INT_ENABLE_SATAINT, base + ATAPI_INT_ENABLE_REG);
+        if (priv->type == RCAR_GEN3_SATA) {
+                sata_rcar_gen2_phy_init(priv);
+                sata_rcar_init_module(priv);
+        } else {
+                /* ack and mask */
+                iowrite32(0, base + SATAINTSTAT_REG);
+                iowrite32(0x7ff, base + SATAINTMASK_REG);
+
+                /* enable interrupts */
+                iowrite32(ATAPI_INT_ENABLE_SATAINT,
+                          base + ATAPI_INT_ENABLE_REG);
+        }
 
         ata_host_resume(host);
 
diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c
index 60bf04b8f103..366a49c7c08f 100644
--- a/drivers/bluetooth/btusb.c
+++ b/drivers/bluetooth/btusb.c
@@ -231,7 +231,6 @@ static const struct usb_device_id blacklist_table[] = {
         { USB_DEVICE(0x0930, 0x0227), .driver_info = BTUSB_ATH3012 },
         { USB_DEVICE(0x0b05, 0x17d0), .driver_info = BTUSB_ATH3012 },
         { USB_DEVICE(0x0cf3, 0x0036), .driver_info = BTUSB_ATH3012 },
-        { USB_DEVICE(0x0cf3, 0x3004), .driver_info = BTUSB_ATH3012 },
         { USB_DEVICE(0x0cf3, 0x3008), .driver_info = BTUSB_ATH3012 },
         { USB_DEVICE(0x0cf3, 0x311d), .driver_info = BTUSB_ATH3012 },
         { USB_DEVICE(0x0cf3, 0x311e), .driver_info = BTUSB_ATH3012 },
@@ -264,6 +263,7 @@ static const struct usb_device_id blacklist_table[] = {
         { USB_DEVICE(0x0489, 0xe03c), .driver_info = BTUSB_ATH3012 },
 
         /* QCA ROME chipset */
+        { USB_DEVICE(0x0cf3, 0x3004), .driver_info = BTUSB_QCA_ROME },
         { USB_DEVICE(0x0cf3, 0xe007), .driver_info = BTUSB_QCA_ROME },
         { USB_DEVICE(0x0cf3, 0xe009), .driver_info = BTUSB_QCA_ROME },
         { USB_DEVICE(0x0cf3, 0xe010), .driver_info = BTUSB_QCA_ROME },
@@ -386,10 +386,10 @@ static const struct usb_device_id blacklist_table[] = {
  */
 static const struct dmi_system_id btusb_needs_reset_resume_table[] = {
         {
-                /* Lenovo Yoga 920 (QCA Rome device 0cf3:e300) */
+                /* Dell OptiPlex 3060 (QCA ROME device 0cf3:e007) */
                 .matches = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
-                        DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo YOGA 920"),
+                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 3060"),
                 },
         },
         {}
diff --git a/drivers/bluetooth/hci_bcm.c b/drivers/bluetooth/hci_bcm.c
index 6314dfb02969..40b9fb247010 100644
--- a/drivers/bluetooth/hci_bcm.c
+++ b/drivers/bluetooth/hci_bcm.c
@@ -244,7 +244,9 @@ static irqreturn_t bcm_host_wake(int irq, void *data)
 
         bt_dev_dbg(bdev, "Host wake IRQ");
 
-        pm_request_resume(bdev->dev);
+        pm_runtime_get(bdev->dev);
+        pm_runtime_mark_last_busy(bdev->dev);
+        pm_runtime_put_autosuspend(bdev->dev);
 
         return IRQ_HANDLED;
 }
@@ -301,7 +303,7 @@ static const struct bcm_set_sleep_mode default_sleep_params = {
         .usb_auto_sleep = 0,
         .usb_resume_timeout = 0,
         .break_to_host = 0,
-        .pulsed_host_wake = 0,
+        .pulsed_host_wake = 1,
 };
 
 static int bcm_setup_sleep(struct hci_uart *hu)
@@ -586,8 +588,11 @@ static int bcm_recv(struct hci_uart *hu, const void *data, int count)
         } else if (!bcm->rx_skb) {
                 /* Delay auto-suspend when receiving completed packet */
                 mutex_lock(&bcm_device_lock);
-                if (bcm->dev && bcm_device_exists(bcm->dev))
-                        pm_request_resume(bcm->dev->dev);
+                if (bcm->dev && bcm_device_exists(bcm->dev)) {
+                        pm_runtime_get(bcm->dev->dev);
+                        pm_runtime_mark_last_busy(bcm->dev->dev);
+                        pm_runtime_put_autosuspend(bcm->dev->dev);
+                }
                 mutex_unlock(&bcm_device_lock);
         }
 
diff --git a/drivers/clk/bcm/clk-bcm2835.c b/drivers/clk/bcm/clk-bcm2835.c
index 44301a3d9963..a07f6451694a 100644
--- a/drivers/clk/bcm/clk-bcm2835.c
+++ b/drivers/clk/bcm/clk-bcm2835.c
@@ -449,17 +449,17 @@ struct bcm2835_pll_ana_bits {
 static const struct bcm2835_pll_ana_bits bcm2835_ana_default = {
         .mask0 = 0,
         .set0 = 0,
-        .mask1 = (u32)~(A2W_PLL_KI_MASK | A2W_PLL_KP_MASK),
+        .mask1 = A2W_PLL_KI_MASK | A2W_PLL_KP_MASK,
         .set1 = (2 << A2W_PLL_KI_SHIFT) | (8 << A2W_PLL_KP_SHIFT),
-        .mask3 = (u32)~A2W_PLL_KA_MASK,
+        .mask3 = A2W_PLL_KA_MASK,
         .set3 = (2 << A2W_PLL_KA_SHIFT),
         .fb_prediv_mask = BIT(14),
 };
 
 static const struct bcm2835_pll_ana_bits bcm2835_ana_pllh = {
-        .mask0 = (u32)~(A2W_PLLH_KA_MASK | A2W_PLLH_KI_LOW_MASK),
+        .mask0 = A2W_PLLH_KA_MASK | A2W_PLLH_KI_LOW_MASK,
         .set0 = (2 << A2W_PLLH_KA_SHIFT) | (2 << A2W_PLLH_KI_LOW_SHIFT),
-        .mask1 = (u32)~(A2W_PLLH_KI_HIGH_MASK | A2W_PLLH_KP_MASK),
+        .mask1 = A2W_PLLH_KI_HIGH_MASK | A2W_PLLH_KP_MASK,
         .set1 = (6 << A2W_PLLH_KP_SHIFT),
         .mask3 = 0,
         .set3 = 0,
@@ -623,8 +623,10 @@ static int bcm2835_pll_on(struct clk_hw *hw)
                      ~A2W_PLL_CTRL_PWRDN);
 
         /* Take the PLL out of reset. */
+        spin_lock(&cprman->regs_lock);
         cprman_write(cprman, data->cm_ctrl_reg,
                      cprman_read(cprman, data->cm_ctrl_reg) & ~CM_PLL_ANARST);
+        spin_unlock(&cprman->regs_lock);
 
         /* Wait for the PLL to lock. */
         timeout = ktime_add_ns(ktime_get(), LOCK_TIMEOUT_NS);
@@ -701,9 +703,11 @@ static int bcm2835_pll_set_rate(struct clk_hw *hw,
         }
 
         /* Unmask the reference clock from the oscillator. */
+        spin_lock(&cprman->regs_lock);
         cprman_write(cprman, A2W_XOSC_CTRL,
                      cprman_read(cprman, A2W_XOSC_CTRL) |
                      data->reference_enable_mask);
+        spin_unlock(&cprman->regs_lock);
 
         if (do_ana_setup_first)
                 bcm2835_pll_write_ana(cprman, data->ana_reg_base, ana);
diff --git a/drivers/clk/clk-aspeed.c b/drivers/clk/clk-aspeed.c
index 9f7f931d6b2f..5eb50c31e455 100644
--- a/drivers/clk/clk-aspeed.c
+++ b/drivers/clk/clk-aspeed.c
@@ -205,6 +205,18 @@ static const struct aspeed_clk_soc_data ast2400_data = {
         .calc_pll = aspeed_ast2400_calc_pll,
 };
 
+static int aspeed_clk_is_enabled(struct clk_hw *hw)
+{
+        struct aspeed_clk_gate *gate = to_aspeed_clk_gate(hw);
+        u32 clk = BIT(gate->clock_idx);
+        u32 enval = (gate->flags & CLK_GATE_SET_TO_DISABLE) ? 0 : clk;
+        u32 reg;
+
+        regmap_read(gate->map, ASPEED_CLK_STOP_CTRL, &reg);
+
+        return ((reg & clk) == enval) ? 1 : 0;
+}
+
 static int aspeed_clk_enable(struct clk_hw *hw)
 {
         struct aspeed_clk_gate *gate = to_aspeed_clk_gate(hw);
@@ -215,6 +227,11 @@ static int aspeed_clk_enable(struct clk_hw *hw)
 
         spin_lock_irqsave(gate->lock, flags);
 
+        if (aspeed_clk_is_enabled(hw)) {
+                spin_unlock_irqrestore(gate->lock, flags);
+                return 0;
+        }
+
         if (gate->reset_idx >= 0) {
                 /* Put IP in reset */
                 regmap_update_bits(gate->map, ASPEED_RESET_CTRL, rst, rst);
@@ -255,17 +272,6 @@ static void aspeed_clk_disable(struct clk_hw *hw)
         spin_unlock_irqrestore(gate->lock, flags);
 }
 
-static int aspeed_clk_is_enabled(struct clk_hw *hw)
-{
-        struct aspeed_clk_gate *gate = to_aspeed_clk_gate(hw);
-        u32 clk = BIT(gate->clock_idx);
-        u32 reg;
-
-        regmap_read(gate->map, ASPEED_CLK_STOP_CTRL, &reg);
-
-        return (reg & clk) ? 0 : 1;
-}
-
 static const struct clk_ops aspeed_clk_gate_ops = {
         .enable = aspeed_clk_enable,
         .disable = aspeed_clk_disable,
diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
index 0f686a9dac3e..076d4244d672 100644
--- a/drivers/clk/clk.c
+++ b/drivers/clk/clk.c
@@ -1125,8 +1125,10 @@ static int clk_core_round_rate_nolock(struct clk_core *core,
 {
         lockdep_assert_held(&prepare_lock);
 
-        if (!core)
+        if (!core) {
+                req->rate = 0;
                 return 0;
+        }
 
         clk_core_init_rate_req(core, req);
 
@@ -2309,8 +2311,11 @@ static int clk_core_set_phase_nolock(struct clk_core *core, int degrees)
 
         trace_clk_set_phase(core, degrees);
 
-        if (core->ops->set_phase)
+        if (core->ops->set_phase) {
                 ret = core->ops->set_phase(core->hw, degrees);
+                if (!ret)
+                        core->phase = degrees;
+        }
 
         trace_clk_set_phase_complete(core, degrees);
 
@@ -2968,22 +2973,37 @@ static int __clk_core_init(struct clk_core *core)
         core->rate = core->req_rate = rate;
 
         /*
+         * Enable CLK_IS_CRITICAL clocks so newly added critical clocks
+         * don't get accidentally disabled when walking the orphan tree and
+         * reparenting clocks
+         */
+        if (core->flags & CLK_IS_CRITICAL) {
+                unsigned long flags;
+
+                clk_core_prepare(core);
+
+                flags = clk_enable_lock();
+                clk_core_enable(core);
+                clk_enable_unlock(flags);
+        }
+
+        /*
          * walk the list of orphan clocks and reparent any that newly finds a
          * parent.
          */
         hlist_for_each_entry_safe(orphan, tmp2, &clk_orphan_list, child_node) {
                 struct clk_core *parent = __clk_init_parent(orphan);
-                unsigned long flags;
 
                 /*
-                 * we could call __clk_set_parent, but that would result in a
-                 * redundant call to the .set_rate op, if it exists
+                 * We need to use __clk_set_parent_before() and _after() to
+                 * to properly migrate any prepare/enable count of the orphan
+                 * clock. This is important for CLK_IS_CRITICAL clocks, which
+                 * are enabled during init but might not have a parent yet.
                  */
                 if (parent) {
                         /* update the clk tree topology */
-                        flags = clk_enable_lock();
-                        clk_reparent(orphan, parent);
-                        clk_enable_unlock(flags);
+                        __clk_set_parent_before(orphan, parent);
+                        __clk_set_parent_after(orphan, parent, NULL);
                         __clk_recalc_accuracies(orphan);
                         __clk_recalc_rates(orphan, 0);
                 }
@@ -3000,16 +3020,6 @@ static int __clk_core_init(struct clk_core *core)
         if (core->ops->init)
                 core->ops->init(core->hw);
 
-        if (core->flags & CLK_IS_CRITICAL) {
-                unsigned long flags;
-
-                clk_core_prepare(core);
-
-                flags = clk_enable_lock();
-                clk_core_enable(core);
-                clk_enable_unlock(flags);
-        }
-
         kref_init(&core->ref);
 out:
         clk_pm_runtime_put(core);
diff --git a/drivers/clk/hisilicon/clk-hi3660-stub.c b/drivers/clk/hisilicon/clk-hi3660-stub.c
index 9b6c72bbddf9..e8b2c43b1bb8 100644
--- a/drivers/clk/hisilicon/clk-hi3660-stub.c
+++ b/drivers/clk/hisilicon/clk-hi3660-stub.c
@@ -149,6 +149,8 @@ static int hi3660_stub_clk_probe(struct platform_device *pdev)
                 return PTR_ERR(stub_clk_chan.mbox);
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -EINVAL;
         freq_reg = devm_ioremap(dev, res->start, resource_size(res));
         if (!freq_reg)
                 return -ENOMEM;
diff --git a/drivers/clk/imx/clk-imx51-imx53.c b/drivers/clk/imx/clk-imx51-imx53.c
index c864992e6983..caa8bd40692c 100644
--- a/drivers/clk/imx/clk-imx51-imx53.c
+++ b/drivers/clk/imx/clk-imx51-imx53.c
@@ -131,7 +131,17 @@ static const char *ieee1588_sels[] = { "pll3_sw", "pll4_sw", "dummy" /* usbphy2_
 static struct clk *clk[IMX5_CLK_END];
 static struct clk_onecell_data clk_data;
 
-static struct clk ** const uart_clks[] __initconst = {
+static struct clk ** const uart_clks_mx51[] __initconst = {
+        &clk[IMX5_CLK_UART1_IPG_GATE],
+        &clk[IMX5_CLK_UART1_PER_GATE],
+        &clk[IMX5_CLK_UART2_IPG_GATE],
+        &clk[IMX5_CLK_UART2_PER_GATE],
+        &clk[IMX5_CLK_UART3_IPG_GATE],
+        &clk[IMX5_CLK_UART3_PER_GATE],
+        NULL
+};
+
+static struct clk ** const uart_clks_mx50_mx53[] __initconst = {
         &clk[IMX5_CLK_UART1_IPG_GATE],
         &clk[IMX5_CLK_UART1_PER_GATE],
         &clk[IMX5_CLK_UART2_IPG_GATE],
@@ -321,8 +331,6 @@ static void __init mx5_clocks_common_init(void __iomem *ccm_base)
         clk_prepare_enable(clk[IMX5_CLK_TMAX1]);
         clk_prepare_enable(clk[IMX5_CLK_TMAX2]); /* esdhc2, fec */
         clk_prepare_enable(clk[IMX5_CLK_TMAX3]); /* esdhc1, esdhc4 */
-
-        imx_register_uart_clocks(uart_clks);
 }
 
 static void __init mx50_clocks_init(struct device_node *np)
@@ -388,6 +396,8 @@ static void __init mx50_clocks_init(struct device_node *np)
 
         r = clk_round_rate(clk[IMX5_CLK_USBOH3_PER_GATE], 54000000);
         clk_set_rate(clk[IMX5_CLK_USBOH3_PER_GATE], r);
+
+        imx_register_uart_clocks(uart_clks_mx50_mx53);
 }
 CLK_OF_DECLARE(imx50_ccm, "fsl,imx50-ccm", mx50_clocks_init);
 
@@ -477,6 +487,8 @@ static void __init mx51_clocks_init(struct device_node *np)
         val = readl(MXC_CCM_CLPCR);
         val |= 1 << 23;
         writel(val, MXC_CCM_CLPCR);
+
+        imx_register_uart_clocks(uart_clks_mx51);
 }
 CLK_OF_DECLARE(imx51_ccm, "fsl,imx51-ccm", mx51_clocks_init);
 
@@ -606,5 +618,7 @@ static void __init mx53_clocks_init(struct device_node *np)
 
         r = clk_round_rate(clk[IMX5_CLK_USBOH3_PER_GATE], 54000000);
         clk_set_rate(clk[IMX5_CLK_USBOH3_PER_GATE], r);
+
+        imx_register_uart_clocks(uart_clks_mx50_mx53);
 }
 CLK_OF_DECLARE(imx53_ccm, "fsl,imx53-ccm", mx53_clocks_init);
diff --git a/drivers/clk/qcom/apcs-msm8916.c b/drivers/clk/qcom/apcs-msm8916.c
index 246957f1a413..b1cc8dbcd327 100644
--- a/drivers/clk/qcom/apcs-msm8916.c
+++ b/drivers/clk/qcom/apcs-msm8916.c
@@ -49,11 +49,10 @@ static int qcom_apcs_msm8916_clk_probe(struct platform_device *pdev)
         struct clk_regmap_mux_div *a53cc;
         struct regmap *regmap;
         struct clk_init_data init = { };
-        int ret;
+        int ret = -ENODEV;
 
         regmap = dev_get_regmap(parent, NULL);
-        if (IS_ERR(regmap)) {
-                ret = PTR_ERR(regmap);
+        if (!regmap) {
                 dev_err(dev, "failed to get regmap: %d\n", ret);
                 return ret;
         }
diff --git a/drivers/clk/sunxi-ng/ccu-sun6i-a31.c b/drivers/clk/sunxi-ng/ccu-sun6i-a31.c
index 72b16ed1012b..3b97f60540ad 100644
--- a/drivers/clk/sunxi-ng/ccu-sun6i-a31.c
+++ b/drivers/clk/sunxi-ng/ccu-sun6i-a31.c
@@ -762,7 +762,7 @@ static struct ccu_mp out_a_clk = {
                 .features       = CCU_FEATURE_FIXED_PREDIV,
                 .hw.init        = CLK_HW_INIT_PARENTS("out-a",
                                                       clk_out_parents,
-                                                      &ccu_div_ops,
+                                                      &ccu_mp_ops,
                                                       0),
         },
 };
@@ -783,7 +783,7 @@ static struct ccu_mp out_b_clk = {
                 .features       = CCU_FEATURE_FIXED_PREDIV,
                 .hw.init        = CLK_HW_INIT_PARENTS("out-b",
                                                       clk_out_parents,
-                                                      &ccu_div_ops,
+                                                      &ccu_mp_ops,
                                                       0),
         },
 };
@@ -804,7 +804,7 @@ static struct ccu_mp out_c_clk = {
                 .features       = CCU_FEATURE_FIXED_PREDIV,
                 .hw.init        = CLK_HW_INIT_PARENTS("out-c",
                                                       clk_out_parents,
-                                                      &ccu_div_ops,
+                                                      &ccu_mp_ops,
                                                       0),
         },
 };
diff --git a/drivers/clk/ti/clk-33xx.c b/drivers/clk/ti/clk-33xx.c
index 612491a26070..12e0a2d19911 100644
--- a/drivers/clk/ti/clk-33xx.c
+++ b/drivers/clk/ti/clk-33xx.c
@@ -45,7 +45,7 @@ static const struct omap_clkctrl_bit_data am3_gpio4_bit_data[] __initconst = {
 
 static const struct omap_clkctrl_reg_data am3_l4_per_clkctrl_regs[] __initconst = {
         { AM3_CPGMAC0_CLKCTRL, NULL, CLKF_SW_SUP, "cpsw_125mhz_gclk", "cpsw_125mhz_clkdm" },
-        { AM3_LCDC_CLKCTRL, NULL, CLKF_SW_SUP, "lcd_gclk", "lcdc_clkdm" },
+        { AM3_LCDC_CLKCTRL, NULL, CLKF_SW_SUP | CLKF_SET_RATE_PARENT, "lcd_gclk", "lcdc_clkdm" },
         { AM3_USB_OTG_HS_CLKCTRL, NULL, CLKF_SW_SUP, "usbotg_fck", "l3s_clkdm" },
         { AM3_TPTC0_CLKCTRL, NULL, CLKF_SW_SUP, "l3_gclk", "l3_clkdm" },
         { AM3_EMIF_CLKCTRL, NULL, CLKF_SW_SUP, "dpll_ddr_m2_div2_ck", "l3_clkdm" },
diff --git a/drivers/clk/ti/clk-43xx.c b/drivers/clk/ti/clk-43xx.c
index 2b7c2e017665..63c5ddb50187 100644
--- a/drivers/clk/ti/clk-43xx.c
+++ b/drivers/clk/ti/clk-43xx.c
@@ -187,7 +187,7 @@ static const struct omap_clkctrl_reg_data am4_l4_per_clkctrl_regs[] __initconst
         { AM4_OCP2SCP0_CLKCTRL, NULL, CLKF_SW_SUP, "l4ls_gclk" },
         { AM4_OCP2SCP1_CLKCTRL, NULL, CLKF_SW_SUP, "l4ls_gclk" },
         { AM4_EMIF_CLKCTRL, NULL, CLKF_SW_SUP, "dpll_ddr_m2_ck", "emif_clkdm" },
-        { AM4_DSS_CORE_CLKCTRL, NULL, CLKF_SW_SUP, "disp_clk", "dss_clkdm" },
+        { AM4_DSS_CORE_CLKCTRL, NULL, CLKF_SW_SUP | CLKF_SET_RATE_PARENT, "disp_clk", "dss_clkdm" },
         { AM4_CPGMAC0_CLKCTRL, NULL, CLKF_SW_SUP, "cpsw_125mhz_gclk", "cpsw_125mhz_clkdm" },
         { 0 },
 };
diff --git a/drivers/clk/ti/clkctrl.c b/drivers/clk/ti/clkctrl.c
index afa0d6bfc5c1..421b05392220 100644
--- a/drivers/clk/ti/clkctrl.c
+++ b/drivers/clk/ti/clkctrl.c
@@ -537,6 +537,8 @@ static void __init _ti_omap4_clkctrl_setup(struct device_node *node)
                 init.parent_names = &reg_data->parent;
                 init.num_parents = 1;
                 init.flags = 0;
+                if (reg_data->flags & CLKF_SET_RATE_PARENT)
+                        init.flags |= CLK_SET_RATE_PARENT;
                 init.name = kasprintf(GFP_KERNEL, "%s:%s:%04x:%d",
                                       node->parent->name, node->name,
                                       reg_data->offset, 0);
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
index af1b879a9ee9..66cb10cdc7c3 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
@@ -2063,9 +2063,12 @@ void amdgpu_device_fini(struct amdgpu_device *adev)
 
         DRM_INFO("amdgpu: finishing device.\n");
         adev->shutdown = true;
-        if (adev->mode_info.mode_config_initialized)
-                drm_crtc_force_disable_all(adev->ddev);
-
+        if (adev->mode_info.mode_config_initialized){
+                if (!amdgpu_device_has_dc_support(adev))
+                        drm_crtc_force_disable_all(adev->ddev);
+                else
+                        drm_atomic_helper_shutdown(adev->ddev);
+        }
         amdgpu_ib_pool_fini(adev);
         amdgpu_fence_driver_fini(adev);
         amdgpu_fbdev_fini(adev);
diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
index c345e645f1d7..63c67346d316 100644
--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
+++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
@@ -3134,8 +3134,6 @@ static int amdgpu_dm_plane_init(struct amdgpu_display_manager *dm,
 
         switch (aplane->base.type) {
         case DRM_PLANE_TYPE_PRIMARY:
-                aplane->base.format_default = true;
-
                 res = drm_universal_plane_init(
                                 dm->adev->ddev,
                                 &aplane->base,
@@ -4794,6 +4792,9 @@ static int dm_atomic_check_plane_state_fb(struct drm_atomic_state *state,
                         return -EDEADLK;
 
                 crtc_state = drm_atomic_get_crtc_state(plane_state->state, crtc);
+                if (IS_ERR(crtc_state))
+                        return PTR_ERR(crtc_state);
+
                 if (crtc->primary == plane && crtc_state->active) {
                         if (!plane_state->fb)
                                 return -EINVAL;
diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_helpers.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_helpers.c
index 9bd142f65f9b..e1acc10e35a2 100644
--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_helpers.c
+++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_helpers.c
@@ -109,7 +109,7 @@ enum dc_edid_status dm_helpers_parse_edid_caps(
                 struct cea_sad *sad = &sads[i];
 
                 edid_caps->audio_modes[i].format_code = sad->format;
-                edid_caps->audio_modes[i].channel_count = sad->channels;
+                edid_caps->audio_modes[i].channel_count = sad->channels + 1;
                 edid_caps->audio_modes[i].sample_rate = sad->freq;
                 edid_caps->audio_modes[i].sample_size = sad->byte2;
         }
diff --git a/drivers/gpu/drm/amd/display/dc/dce/dce_hwseq.h b/drivers/gpu/drm/amd/display/dc/dce/dce_hwseq.h
index a993279a8f2d..f11f17fe08f9 100644
--- a/drivers/gpu/drm/amd/display/dc/dce/dce_hwseq.h
+++ b/drivers/gpu/drm/amd/display/dc/dce/dce_hwseq.h
@@ -496,6 +496,9 @@ struct dce_hwseq_registers {
         HWS_SF(, DOMAIN7_PG_STATUS, DOMAIN7_PGFSM_PWR_STATUS, mask_sh), \
         HWS_SF(, DC_IP_REQUEST_CNTL, IP_REQUEST_EN, mask_sh), \
         HWS_SF(, D1VGA_CONTROL, D1VGA_MODE_ENABLE, mask_sh),\
+        HWS_SF(, D2VGA_CONTROL, D2VGA_MODE_ENABLE, mask_sh),\
+        HWS_SF(, D3VGA_CONTROL, D3VGA_MODE_ENABLE, mask_sh),\
+        HWS_SF(, D4VGA_CONTROL, D4VGA_MODE_ENABLE, mask_sh),\
         HWS_SF(, VGA_TEST_CONTROL, VGA_TEST_ENABLE, mask_sh),\
         HWS_SF(, VGA_TEST_CONTROL, VGA_TEST_RENDER_START, mask_sh),\
         HWS_SF(, LVTMA_PWRSEQ_CNTL, LVTMA_BLON, mask_sh), \
@@ -591,7 +594,10 @@ struct dce_hwseq_registers {
         type DENTIST_DISPCLK_WDIVIDER; \
         type VGA_TEST_ENABLE; \
         type VGA_TEST_RENDER_START; \
-        type D1VGA_MODE_ENABLE;
+        type D1VGA_MODE_ENABLE; \
+        type D2VGA_MODE_ENABLE; \
+        type D3VGA_MODE_ENABLE; \
+        type D4VGA_MODE_ENABLE;
 
 struct dce_hwseq_shift {
         HWSEQ_REG_FIELD_LIST(uint8_t)
diff --git a/drivers/gpu/drm/amd/display/dc/dce/dce_opp.c b/drivers/gpu/drm/amd/display/dc/dce/dce_opp.c
index 3931412ab6d3..87093894ea9e 100644
--- a/drivers/gpu/drm/amd/display/dc/dce/dce_opp.c
+++ b/drivers/gpu/drm/amd/display/dc/dce/dce_opp.c
@@ -128,23 +128,22 @@ static void set_truncation(
                 return;
         }
         /* on other format-to do */
-        if (params->flags.TRUNCATE_ENABLED == 0 ||
-                        params->flags.TRUNCATE_DEPTH == 2)
+        if (params->flags.TRUNCATE_ENABLED == 0)
                 return;
         /*Set truncation depth and Enable truncation*/
         REG_UPDATE_3(FMT_BIT_DEPTH_CONTROL,
                                 FMT_TRUNCATE_EN, 1,
                                 FMT_TRUNCATE_DEPTH,
-                                params->flags.TRUNCATE_MODE,
+                                params->flags.TRUNCATE_DEPTH,
                                 FMT_TRUNCATE_MODE,
-                                params->flags.TRUNCATE_DEPTH);
+                                params->flags.TRUNCATE_MODE);
 }
 
 
 /**
  *      set_spatial_dither
  *      1) set spatial dithering mode: pattern of seed
- *      2) set spatical dithering depth: 0 for 18bpp or 1 for 24bpp
+ *      2) set spatial dithering depth: 0 for 18bpp or 1 for 24bpp
  *      3) set random seed
  *      4) set random mode
  *              lfsr is reset every frame or not reset
diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hw_sequencer.c b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hw_sequencer.c
index 072e4485e85e..dc1e010725c1 100644
--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hw_sequencer.c
+++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hw_sequencer.c
@@ -238,14 +238,24 @@ static void enable_power_gating_plane(
 static void disable_vga(
         struct dce_hwseq *hws)
 {
-        unsigned int in_vga_mode = 0;
-
-        REG_GET(D1VGA_CONTROL, D1VGA_MODE_ENABLE, &in_vga_mode);
-
-        if (in_vga_mode == 0)
+        unsigned int in_vga1_mode = 0;
+        unsigned int in_vga2_mode = 0;
+        unsigned int in_vga3_mode = 0;
+        unsigned int in_vga4_mode = 0;
+
+        REG_GET(D1VGA_CONTROL, D1VGA_MODE_ENABLE, &in_vga1_mode);
+        REG_GET(D2VGA_CONTROL, D2VGA_MODE_ENABLE, &in_vga2_mode);
+        REG_GET(D3VGA_CONTROL, D3VGA_MODE_ENABLE, &in_vga3_mode);
+        REG_GET(D4VGA_CONTROL, D4VGA_MODE_ENABLE, &in_vga4_mode);
+
+        if (in_vga1_mode == 0 && in_vga2_mode == 0 &&
+                        in_vga3_mode == 0 && in_vga4_mode == 0)
                 return;
 
         REG_WRITE(D1VGA_CONTROL, 0);
+        REG_WRITE(D2VGA_CONTROL, 0);
+        REG_WRITE(D3VGA_CONTROL, 0);
+        REG_WRITE(D4VGA_CONTROL, 0);
 
         /* HW Engineer's Notes:
          *  During switch from vga->extended, if we set the VGA_TEST_ENABLE and
diff --git a/drivers/gpu/drm/ast/ast_tables.h b/drivers/gpu/drm/ast/ast_tables.h
index 5f4c2e833a65..d665dd5af5dd 100644
--- a/drivers/gpu/drm/ast/ast_tables.h
+++ b/drivers/gpu/drm/ast/ast_tables.h
@@ -97,7 +97,7 @@ static const struct ast_vbios_dclk_info dclk_table[] = {
         {0x67, 0x22, 0x00},                     /* 0E: VCLK157_5        */
         {0x6A, 0x22, 0x00},                     /* 0F: VCLK162          */
         {0x4d, 0x4c, 0x80},                     /* 10: VCLK154          */
-        {0xa7, 0x78, 0x80},                     /* 11: VCLK83.5         */
+        {0x68, 0x6f, 0x80},                     /* 11: VCLK83.5         */
         {0x28, 0x49, 0x80},                     /* 12: VCLK106.5        */
         {0x37, 0x49, 0x80},                     /* 13: VCLK146.25       */
         {0x1f, 0x45, 0x80},                     /* 14: VCLK148.5        */
@@ -127,7 +127,7 @@ static const struct ast_vbios_dclk_info dclk_table_ast2500[] = {
         {0x67, 0x22, 0x00},                     /* 0E: VCLK157_5        */
         {0x6A, 0x22, 0x00},                     /* 0F: VCLK162          */
         {0x4d, 0x4c, 0x80},                     /* 10: VCLK154          */
-        {0xa7, 0x78, 0x80},                     /* 11: VCLK83.5         */
+        {0x68, 0x6f, 0x80},                     /* 11: VCLK83.5         */
         {0x28, 0x49, 0x80},                     /* 12: VCLK106.5        */
         {0x37, 0x49, 0x80},                     /* 13: VCLK146.25       */
         {0x1f, 0x45, 0x80},                     /* 14: VCLK148.5        */
diff --git a/drivers/gpu/drm/drm_framebuffer.c b/drivers/gpu/drm/drm_framebuffer.c
index c0530a1af5e3..2dc5e8bed172 100644
--- a/drivers/gpu/drm/drm_framebuffer.c
+++ b/drivers/gpu/drm/drm_framebuffer.c
@@ -461,6 +461,12 @@ int drm_mode_getfb(struct drm_device *dev,
         if (!fb)
                 return -ENOENT;
 
+        /* Multi-planar framebuffers need getfb2. */
+        if (fb->format->num_planes > 1) {
+                ret = -EINVAL;
+                goto out;
+        }
+
         r->height = fb->height;
         r->width = fb->width;
         r->depth = fb->format->depth;
@@ -484,6 +490,7 @@ int drm_mode_getfb(struct drm_device *dev,
                 ret = -ENODEV;
         }
 
+out:
         drm_framebuffer_put(fb);
 
         return ret;
diff --git a/drivers/gpu/drm/i915/intel_ddi.c b/drivers/gpu/drm/i915/intel_ddi.c
index f51645a08dca..6aff9d096e13 100644
--- a/drivers/gpu/drm/i915/intel_ddi.c
+++ b/drivers/gpu/drm/i915/intel_ddi.c
@@ -2175,8 +2175,7 @@ static void intel_ddi_pre_enable_dp(struct intel_encoder *encoder,
                 intel_prepare_dp_ddi_buffers(encoder, crtc_state);
 
         intel_ddi_init_dp_buf_reg(encoder);
-        if (!is_mst)
-                intel_dp_sink_dpms(intel_dp, DRM_MODE_DPMS_ON);
+        intel_dp_sink_dpms(intel_dp, DRM_MODE_DPMS_ON);
         intel_dp_start_link_train(intel_dp);
         if (port != PORT_A || INTEL_GEN(dev_priv) >= 9)
                 intel_dp_stop_link_train(intel_dp);
@@ -2274,14 +2273,12 @@ static void intel_ddi_post_disable_dp(struct intel_encoder *encoder,
         struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
         struct intel_digital_port *dig_port = enc_to_dig_port(&encoder->base);
         struct intel_dp *intel_dp = &dig_port->dp;
-        bool is_mst = intel_crtc_has_type(old_crtc_state, INTEL_OUTPUT_DP_MST);
 
         /*
          * Power down sink before disabling the port, otherwise we end
          * up getting interrupts from the sink on detecting link loss.
          */
-        if (!is_mst)
-                intel_dp_sink_dpms(intel_dp, DRM_MODE_DPMS_OFF);
+        intel_dp_sink_dpms(intel_dp, DRM_MODE_DPMS_OFF);
 
         intel_disable_ddi_buf(encoder);
 
diff --git a/drivers/gpu/drm/i915/intel_hangcheck.c b/drivers/gpu/drm/i915/intel_hangcheck.c
index 348a4f7ffb67..53747318f4a7 100644
--- a/drivers/gpu/drm/i915/intel_hangcheck.c
+++ b/drivers/gpu/drm/i915/intel_hangcheck.c
@@ -246,7 +246,7 @@ engine_stuck(struct intel_engine_cs *engine, u64 acthd)
          */
         tmp = I915_READ_CTL(engine);
         if (tmp & RING_WAIT) {
-                i915_handle_error(dev_priv, 0,
+                i915_handle_error(dev_priv, BIT(engine->id),
                                   "Kicking stuck wait on %s",
                                   engine->name);
                 I915_WRITE_CTL(engine, tmp);
@@ -258,7 +258,7 @@ engine_stuck(struct intel_engine_cs *engine, u64 acthd)
                 default:
                         return ENGINE_DEAD;
                 case 1:
-                        i915_handle_error(dev_priv, 0,
+                        i915_handle_error(dev_priv, ALL_ENGINES,
                                           "Kicking stuck semaphore on %s",
                                           engine->name);
                         I915_WRITE_CTL(engine, tmp);
diff --git a/drivers/gpu/drm/imx/ipuv3-crtc.c b/drivers/gpu/drm/imx/ipuv3-crtc.c
index 9a9961802f5c..e83af0f2be86 100644
--- a/drivers/gpu/drm/imx/ipuv3-crtc.c
+++ b/drivers/gpu/drm/imx/ipuv3-crtc.c
@@ -225,7 +225,11 @@ static void ipu_crtc_atomic_begin(struct drm_crtc *crtc,
                                   struct drm_crtc_state *old_crtc_state)
 {
         drm_crtc_vblank_on(crtc);
+}
 
+static void ipu_crtc_atomic_flush(struct drm_crtc *crtc,
+                                  struct drm_crtc_state *old_crtc_state)
+{
         spin_lock_irq(&crtc->dev->event_lock);
         if (crtc->state->event) {
                 WARN_ON(drm_crtc_vblank_get(crtc));
@@ -293,6 +297,7 @@ static const struct drm_crtc_helper_funcs ipu_helper_funcs = {
         .mode_set_nofb = ipu_crtc_mode_set_nofb,
         .atomic_check = ipu_crtc_atomic_check,
         .atomic_begin = ipu_crtc_atomic_begin,
+        .atomic_flush = ipu_crtc_atomic_flush,
         .atomic_disable = ipu_crtc_atomic_disable,
         .atomic_enable = ipu_crtc_atomic_enable,
 };
diff --git a/drivers/gpu/drm/imx/ipuv3-plane.c b/drivers/gpu/drm/imx/ipuv3-plane.c
index 57ed56d8623f..d9113faaa62f 100644
--- a/drivers/gpu/drm/imx/ipuv3-plane.c
+++ b/drivers/gpu/drm/imx/ipuv3-plane.c
@@ -22,6 +22,7 @@
 #include <drm/drm_plane_helper.h>
 
 #include "video/imx-ipu-v3.h"
+#include "imx-drm.h"
 #include "ipuv3-plane.h"
 
 struct ipu_plane_state {
@@ -272,7 +273,7 @@ static void ipu_plane_destroy(struct drm_plane *plane)
         kfree(ipu_plane);
 }
 
-void ipu_plane_state_reset(struct drm_plane *plane)
+static void ipu_plane_state_reset(struct drm_plane *plane)
 {
         struct ipu_plane_state *ipu_state;
 
@@ -292,7 +293,8 @@ void ipu_plane_state_reset(struct drm_plane *plane)
         plane->state = &ipu_state->base;
 }
 
-struct drm_plane_state *ipu_plane_duplicate_state(struct drm_plane *plane)
+static struct drm_plane_state *
+ipu_plane_duplicate_state(struct drm_plane *plane)
 {
         struct ipu_plane_state *state;
 
@@ -306,8 +308,8 @@ struct drm_plane_state *ipu_plane_duplicate_state(struct drm_plane *plane)
         return &state->base;
 }
 
-void ipu_plane_destroy_state(struct drm_plane *plane,
-                             struct drm_plane_state *state)
+static void ipu_plane_destroy_state(struct drm_plane *plane,
+                                    struct drm_plane_state *state)
 {
         struct ipu_plane_state *ipu_state = to_ipu_plane_state(state);
 
diff --git a/drivers/gpu/drm/radeon/radeon_connectors.c b/drivers/gpu/drm/radeon/radeon_connectors.c
index 2e2ca3c6b47d..df9469a8fdb1 100644
--- a/drivers/gpu/drm/radeon/radeon_connectors.c
+++ b/drivers/gpu/drm/radeon/radeon_connectors.c
@@ -90,25 +90,18 @@ void radeon_connector_hotplug(struct drm_connector *connector)
                 /* don't do anything if sink is not display port, i.e.,
                  * passive dp->(dvi|hdmi) adaptor
                  */
-                if (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
-                        int saved_dpms = connector->dpms;
-                        /* Only turn off the display if it's physically disconnected */
-                        if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
-                                drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
-                        } else if (radeon_dp_needs_link_train(radeon_connector)) {
-                                /* Don't try to start link training before we
-                                 * have the dpcd */
-                                if (!radeon_dp_getdpcd(radeon_connector))
-                                        return;
-
-                                /* set it to OFF so that drm_helper_connector_dpms()
-                                 * won't return immediately since the current state
-                                 * is ON at this point.
-                                 */
-                                connector->dpms = DRM_MODE_DPMS_OFF;
-                                drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
-                        }
-                        connector->dpms = saved_dpms;
+                if (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT &&
+                    radeon_hpd_sense(rdev, radeon_connector->hpd.hpd) &&
+                    radeon_dp_needs_link_train(radeon_connector)) {
+                        /* Don't start link training before we have the DPCD */
+                        if (!radeon_dp_getdpcd(radeon_connector))
+                                return;
+
+                        /* Turn the connector off and back on immediately, which
+                         * will trigger link training
+                         */
+                        drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
+                        drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
                 }
         }
 }
diff --git a/drivers/gpu/drm/sun4i/sun4i_drv.c b/drivers/gpu/drm/sun4i/sun4i_drv.c
index 4570da0227b4..d9a71f361b14 100644
--- a/drivers/gpu/drm/sun4i/sun4i_drv.c
+++ b/drivers/gpu/drm/sun4i/sun4i_drv.c
@@ -111,7 +111,7 @@ static int sun4i_drv_bind(struct device *dev)
         /* drm_vblank_init calls kcalloc, which can fail */
         ret = drm_vblank_init(drm, drm->mode_config.num_crtc);
         if (ret)
-                goto free_mem_region;
+                goto cleanup_mode_config;
 
         drm->irq_enabled = true;
 
@@ -139,7 +139,6 @@ finish_poll:
         sun4i_framebuffer_free(drm);
 cleanup_mode_config:
         drm_mode_config_cleanup(drm);
-free_mem_region:
         of_reserved_mem_device_release(dev);
 free_drm:
         drm_dev_unref(drm);
diff --git a/drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c b/drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c
index 500b6fb3e028..fa4bcd092eaf 100644
--- a/drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c
+++ b/drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c
@@ -538,7 +538,8 @@ static int sun4i_hdmi_bind(struct device *dev, struct device *master,
                                              &sun4i_hdmi_regmap_config);
         if (IS_ERR(hdmi->regmap)) {
                 dev_err(dev, "Couldn't create HDMI encoder regmap\n");
-                return PTR_ERR(hdmi->regmap);
+                ret = PTR_ERR(hdmi->regmap);
+                goto err_disable_mod_clk;
         }
 
         ret = sun4i_tmds_create(hdmi);
@@ -551,7 +552,8 @@ static int sun4i_hdmi_bind(struct device *dev, struct device *master,
                 hdmi->ddc_parent_clk = devm_clk_get(dev, "ddc");
                 if (IS_ERR(hdmi->ddc_parent_clk)) {
                         dev_err(dev, "Couldn't get the HDMI DDC clock\n");
-                        return PTR_ERR(hdmi->ddc_parent_clk);
+                        ret = PTR_ERR(hdmi->ddc_parent_clk);
+                        goto err_disable_mod_clk;
                 }
         } else {
                 hdmi->ddc_parent_clk = hdmi->tmds_clk;
diff --git a/drivers/gpu/drm/sun4i/sun4i_tcon.c b/drivers/gpu/drm/sun4i/sun4i_tcon.c
index 2de586b7c98b..a818ca491605 100644
--- a/drivers/gpu/drm/sun4i/sun4i_tcon.c
+++ b/drivers/gpu/drm/sun4i/sun4i_tcon.c
@@ -103,6 +103,7 @@ static void sun4i_tcon_channel_set_status(struct sun4i_tcon *tcon, int channel,
 
         if (enabled) {
                 clk_prepare_enable(clk);
+                clk_rate_exclusive_get(clk);
         } else {
                 clk_rate_exclusive_put(clk);
                 clk_disable_unprepare(clk);
@@ -262,7 +263,7 @@ static void sun4i_tcon0_mode_set_common(struct sun4i_tcon *tcon,
                                         const struct drm_display_mode *mode)
 {
         /* Configure the dot clock */
-        clk_set_rate_exclusive(tcon->dclk, mode->crtc_clock * 1000);
+        clk_set_rate(tcon->dclk, mode->crtc_clock * 1000);
 
         /* Set the resolution */
         regmap_write(tcon->regs, SUN4I_TCON0_BASIC0_REG,
@@ -423,7 +424,7 @@ static void sun4i_tcon1_mode_set(struct sun4i_tcon *tcon,
         WARN_ON(!tcon->quirks->has_channel_1);
 
         /* Configure the dot clock */
-        clk_set_rate_exclusive(tcon->sclk1, mode->crtc_clock * 1000);
+        clk_set_rate(tcon->sclk1, mode->crtc_clock * 1000);
 
         /* Adjust clock delay */
         clk_delay = sun4i_tcon_get_clk_delay(mode, 1);
diff --git a/drivers/gpu/drm/tegra/dc.c b/drivers/gpu/drm/tegra/dc.c
index b8403ed48285..fbffe1948b3b 100644
--- a/drivers/gpu/drm/tegra/dc.c
+++ b/drivers/gpu/drm/tegra/dc.c
@@ -1903,8 +1903,12 @@ cleanup:
         if (!IS_ERR(primary))
                 drm_plane_cleanup(primary);
 
-        if (group && tegra->domain) {
-                iommu_detach_group(tegra->domain, group);
+        if (group && dc->domain) {
+                if (group == tegra->group) {
+                        iommu_detach_group(dc->domain, group);
+                        tegra->group = NULL;
+                }
+
                 dc->domain = NULL;
         }
 
@@ -1913,8 +1917,10 @@ cleanup:
 
 static int tegra_dc_exit(struct host1x_client *client)
 {
+        struct drm_device *drm = dev_get_drvdata(client->parent);
         struct iommu_group *group = iommu_group_get(client->dev);
         struct tegra_dc *dc = host1x_client_to_dc(client);
+        struct tegra_drm *tegra = drm->dev_private;
         int err;
 
         devm_free_irq(dc->dev, dc->irq, dc);
@@ -1926,7 +1932,11 @@ static int tegra_dc_exit(struct host1x_client *client)
         }
 
         if (group && dc->domain) {
-                iommu_detach_group(dc->domain, group);
+                if (group == tegra->group) {
+                        iommu_detach_group(dc->domain, group);
+                        tegra->group = NULL;
+                }
+
                 dc->domain = NULL;
         }
 
diff --git a/drivers/gpu/drm/tegra/drm.c b/drivers/gpu/drm/tegra/drm.c
index d50bddb2e447..7fcf4a242840 100644
--- a/drivers/gpu/drm/tegra/drm.c
+++ b/drivers/gpu/drm/tegra/drm.c
@@ -250,6 +250,7 @@ static void tegra_drm_unload(struct drm_device *drm)
 
         drm_kms_helper_poll_fini(drm);
         tegra_drm_fb_exit(drm);
+        drm_atomic_helper_shutdown(drm);
         drm_mode_config_cleanup(drm);
 
         err = host1x_device_exit(device);
diff --git a/drivers/gpu/drm/tegra/dsi.c b/drivers/gpu/drm/tegra/dsi.c
index 4d2ed966f9e3..87c5d89bc9ba 100644
--- a/drivers/gpu/drm/tegra/dsi.c
+++ b/drivers/gpu/drm/tegra/dsi.c
@@ -1072,7 +1072,6 @@ static int tegra_dsi_exit(struct host1x_client *client)
         struct tegra_dsi *dsi = host1x_client_to_dsi(client);
 
         tegra_output_exit(&dsi->output);
-        regulator_disable(dsi->vdd);
 
         return 0;
 }
diff --git a/drivers/gpu/drm/tegra/plane.c b/drivers/gpu/drm/tegra/plane.c
index 36a06a993698..94dac79ac3c9 100644
--- a/drivers/gpu/drm/tegra/plane.c
+++ b/drivers/gpu/drm/tegra/plane.c
@@ -297,6 +297,10 @@ int tegra_plane_format_get_alpha(unsigned int opaque, unsigned int *alpha)
         case WIN_COLOR_DEPTH_B8G8R8X8:
                 *alpha = WIN_COLOR_DEPTH_B8G8R8A8;
                 return 0;
+
+        case WIN_COLOR_DEPTH_B5G6R5:
+                *alpha = opaque;
+                return 0;
         }
 
         return -EINVAL;
@@ -330,9 +334,6 @@ void tegra_plane_check_dependent(struct tegra_plane *tegra,
         unsigned int zpos[2];
         unsigned int i;
 
-        for (i = 0; i < 3; i++)
-                state->dependent[i] = false;
-
         for (i = 0; i < 2; i++)
                 zpos[i] = 0;
 
@@ -346,6 +347,8 @@ void tegra_plane_check_dependent(struct tegra_plane *tegra,
 
                 index = tegra_plane_get_overlap_index(tegra, p);
 
+                state->dependent[index] = false;
+
                 /*
                  * If any of the other planes is on top of this plane and uses
                  * a format with an alpha component, mark this plane as being
diff --git a/drivers/gpu/drm/udl/udl_fb.c b/drivers/gpu/drm/udl/udl_fb.c
index b5b335c9b2bb..2ebdc6d5a76e 100644
--- a/drivers/gpu/drm/udl/udl_fb.c
+++ b/drivers/gpu/drm/udl/udl_fb.c
@@ -159,10 +159,15 @@ static int udl_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
 {
         unsigned long start = vma->vm_start;
         unsigned long size = vma->vm_end - vma->vm_start;
-        unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
+        unsigned long offset;
         unsigned long page, pos;
 
-        if (offset + size > info->fix.smem_len)
+        if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
+                return -EINVAL;
+
+        offset = vma->vm_pgoff << PAGE_SHIFT;
+
+        if (offset > info->fix.smem_len || size > info->fix.smem_len - offset)
                 return -EINVAL;
 
         pos = (unsigned long)info->fix.smem_start + offset;
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
index 184340d486c3..86d25f18aa99 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
@@ -1337,6 +1337,19 @@ static void __vmw_svga_disable(struct vmw_private *dev_priv)
  */
 void vmw_svga_disable(struct vmw_private *dev_priv)
 {
+        /*
+         * Disabling SVGA will turn off device modesetting capabilities, so
+         * notify KMS about that so that it doesn't cache atomic state that
+         * isn't valid anymore, for example crtcs turned on.
+         * Strictly we'd want to do this under the SVGA lock (or an SVGA mutex),
+         * but vmw_kms_lost_device() takes the reservation sem and thus we'll
+         * end up with lock order reversal. Thus, a master may actually perform
+         * a new modeset just after we call vmw_kms_lost_device() and race with
+         * vmw_svga_disable(), but that should at worst cause atomic KMS state
+         * to be inconsistent with the device, causing modesetting problems.
+         *
+         */
+        vmw_kms_lost_device(dev_priv->dev);
         ttm_write_lock(&dev_priv->reservation_sem, false);
         spin_lock(&dev_priv->svga_lock);
         if (dev_priv->bdev.man[TTM_PL_VRAM].use_type) {
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
index d08753e8fd94..9116fe8baebc 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
@@ -938,6 +938,7 @@ int vmw_kms_present(struct vmw_private *dev_priv,
 int vmw_kms_update_layout_ioctl(struct drm_device *dev, void *data,
                                 struct drm_file *file_priv);
 void vmw_kms_legacy_hotspot_clear(struct vmw_private *dev_priv);
+void vmw_kms_lost_device(struct drm_device *dev);
 
 int vmw_dumb_create(struct drm_file *file_priv,
                     struct drm_device *dev,
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
index ead61015cd79..3c824fd7cbf3 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
@@ -31,7 +31,6 @@
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_rect.h>
 
-
 /* Might need a hrtimer here? */
 #define VMWGFX_PRESENT_RATE ((HZ / 60 > 0) ? HZ / 60 : 1)
 
@@ -2517,9 +2516,12 @@ void vmw_kms_helper_buffer_finish(struct vmw_private *dev_priv,
  * Helper to be used if an error forces the caller to undo the actions of
  * vmw_kms_helper_resource_prepare.
  */
-void vmw_kms_helper_resource_revert(struct vmw_resource *res)
+void vmw_kms_helper_resource_revert(struct vmw_validation_ctx *ctx)
 {
-        vmw_kms_helper_buffer_revert(res->backup);
+        struct vmw_resource *res = ctx->res;
+
+        vmw_kms_helper_buffer_revert(ctx->buf);
+        vmw_dmabuf_unreference(&ctx->buf);
         vmw_resource_unreserve(res, false, NULL, 0);
         mutex_unlock(&res->dev_priv->cmdbuf_mutex);
 }
@@ -2536,10 +2538,14 @@ void vmw_kms_helper_resource_revert(struct vmw_resource *res)
  * interrupted by a signal.
  */
 int vmw_kms_helper_resource_prepare(struct vmw_resource *res,
-                                    bool interruptible)
+                                    bool interruptible,
+                                    struct vmw_validation_ctx *ctx)
 {
         int ret = 0;
 
+        ctx->buf = NULL;
+        ctx->res = res;
+
         if (interruptible)
                 ret = mutex_lock_interruptible(&res->dev_priv->cmdbuf_mutex);
         else
@@ -2558,6 +2564,8 @@ int vmw_kms_helper_resource_prepare(struct vmw_resource *res,
                                                     res->dev_priv->has_mob);
                 if (ret)
                         goto out_unreserve;
+
+                ctx->buf = vmw_dmabuf_reference(res->backup);
         }
         ret = vmw_resource_validate(res);
         if (ret)
@@ -2565,7 +2573,7 @@ int vmw_kms_helper_resource_prepare(struct vmw_resource *res,
         return 0;
 
 out_revert:
-        vmw_kms_helper_buffer_revert(res->backup);
+        vmw_kms_helper_buffer_revert(ctx->buf);
 out_unreserve:
         vmw_resource_unreserve(res, false, NULL, 0);
 out_unlock:
@@ -2581,11 +2589,13 @@ out_unlock:
  * @out_fence: Optional pointer to a fence pointer. If non-NULL, a
  * ref-counted fence pointer is returned here.
  */
-void vmw_kms_helper_resource_finish(struct vmw_resource *res,
-                             struct vmw_fence_obj **out_fence)
+void vmw_kms_helper_resource_finish(struct vmw_validation_ctx *ctx,
+                                    struct vmw_fence_obj **out_fence)
 {
-        if (res->backup || out_fence)
-                vmw_kms_helper_buffer_finish(res->dev_priv, NULL, res->backup,
+        struct vmw_resource *res = ctx->res;
+
+        if (ctx->buf || out_fence)
+                vmw_kms_helper_buffer_finish(res->dev_priv, NULL, ctx->buf,
                                              out_fence, NULL);
 
         vmw_resource_unreserve(res, false, NULL, 0);
@@ -2851,3 +2861,14 @@ int vmw_kms_set_config(struct drm_mode_set *set,
 
         return drm_atomic_helper_set_config(set, ctx);
 }
+
+
+/**
+ * vmw_kms_lost_device - Notify kms that modesetting capabilities will be lost
+ *
+ * @dev: Pointer to the drm device
+ */
+void vmw_kms_lost_device(struct drm_device *dev)
+{
+        drm_atomic_helper_shutdown(dev);
+}
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.h b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.h
index cd9da2dd79af..3d2ca280eaa7 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.h
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.h
@@ -240,6 +240,11 @@ struct vmw_display_unit {
         int set_gui_y;
 };
 
+struct vmw_validation_ctx {
+        struct vmw_resource *res;
+        struct vmw_dma_buffer *buf;
+};
+
 #define vmw_crtc_to_du(x) \
         container_of(x, struct vmw_display_unit, crtc)
 #define vmw_connector_to_du(x) \
@@ -296,9 +301,10 @@ void vmw_kms_helper_buffer_finish(struct vmw_private *dev_priv,
                                   struct drm_vmw_fence_rep __user *
                                   user_fence_rep);
 int vmw_kms_helper_resource_prepare(struct vmw_resource *res,
-                                    bool interruptible);
-void vmw_kms_helper_resource_revert(struct vmw_resource *res);
-void vmw_kms_helper_resource_finish(struct vmw_resource *res,
+                                    bool interruptible,
+                                    struct vmw_validation_ctx *ctx);
+void vmw_kms_helper_resource_revert(struct vmw_validation_ctx *ctx);
+void vmw_kms_helper_resource_finish(struct vmw_validation_ctx *ctx,
                                     struct vmw_fence_obj **out_fence);
 int vmw_kms_readback(struct vmw_private *dev_priv,
                      struct drm_file *file_priv,
@@ -439,5 +445,4 @@ int vmw_kms_stdu_dma(struct vmw_private *dev_priv,
 
 int vmw_kms_set_config(struct drm_mode_set *set,
                        struct drm_modeset_acquire_ctx *ctx);
-
 #endif
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c b/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c
index 63a4cd794b73..3ec9eae831b8 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c
@@ -909,12 +909,13 @@ int vmw_kms_sou_do_surface_dirty(struct vmw_private *dev_priv,
         struct vmw_framebuffer_surface *vfbs =
                 container_of(framebuffer, typeof(*vfbs), base);
         struct vmw_kms_sou_surface_dirty sdirty;
+        struct vmw_validation_ctx ctx;
         int ret;
 
         if (!srf)
                 srf = &vfbs->surface->res;
 
-        ret = vmw_kms_helper_resource_prepare(srf, true);
+        ret = vmw_kms_helper_resource_prepare(srf, true, &ctx);
         if (ret)
                 return ret;
 
@@ -933,7 +934,7 @@ int vmw_kms_sou_do_surface_dirty(struct vmw_private *dev_priv,
         ret = vmw_kms_helper_dirty(dev_priv, framebuffer, clips, vclips,
                                    dest_x, dest_y, num_clips, inc,
                                    &sdirty.base);
-        vmw_kms_helper_resource_finish(srf, out_fence);
+        vmw_kms_helper_resource_finish(&ctx, out_fence);
 
         return ret;
 }
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c b/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c
index b68d74888ab1..6b969e5dea2a 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c
@@ -980,12 +980,13 @@ int vmw_kms_stdu_surface_dirty(struct vmw_private *dev_priv,
         struct vmw_framebuffer_surface *vfbs =
                 container_of(framebuffer, typeof(*vfbs), base);
         struct vmw_stdu_dirty sdirty;
+        struct vmw_validation_ctx ctx;
         int ret;
 
         if (!srf)
                 srf = &vfbs->surface->res;
 
-        ret = vmw_kms_helper_resource_prepare(srf, true);
+        ret = vmw_kms_helper_resource_prepare(srf, true, &ctx);
         if (ret)
                 return ret;
 
@@ -1008,7 +1009,7 @@ int vmw_kms_stdu_surface_dirty(struct vmw_private *dev_priv,
                                    dest_x, dest_y, num_clips, inc,
                                    &sdirty.base);
 out_finish:
-        vmw_kms_helper_resource_finish(srf, out_fence);
+        vmw_kms_helper_resource_finish(&ctx, out_fence);
 
         return ret;
 }
diff --git a/drivers/gpu/ipu-v3/ipu-prg.c b/drivers/gpu/ipu-v3/ipu-prg.c
index 97b99500153d..83f9dd934a5d 100644
--- a/drivers/gpu/ipu-v3/ipu-prg.c
+++ b/drivers/gpu/ipu-v3/ipu-prg.c
@@ -250,10 +250,14 @@ void ipu_prg_channel_disable(struct ipuv3_channel *ipu_chan)
 {
         int prg_chan = ipu_prg_ipu_to_prg_chan(ipu_chan->num);
         struct ipu_prg *prg = ipu_chan->ipu->prg_priv;
-        struct ipu_prg_channel *chan = &prg->chan[prg_chan];
+        struct ipu_prg_channel *chan;
         u32 val;
 
-        if (!chan->enabled || prg_chan < 0)
+        if (prg_chan < 0)
+                return;
+
+        chan = &prg->chan[prg_chan];
+        if (!chan->enabled)
                 return;
 
         pm_runtime_get_sync(prg->dev);
@@ -280,13 +284,15 @@ int ipu_prg_channel_configure(struct ipuv3_channel *ipu_chan,
 {
         int prg_chan = ipu_prg_ipu_to_prg_chan(ipu_chan->num);
         struct ipu_prg *prg = ipu_chan->ipu->prg_priv;
-        struct ipu_prg_channel *chan = &prg->chan[prg_chan];
+        struct ipu_prg_channel *chan;
         u32 val;
         int ret;
 
         if (prg_chan < 0)
                 return prg_chan;
 
+        chan = &prg->chan[prg_chan];
+
         if (chan->enabled) {
                 ipu_pre_update(prg->pres[chan->used_pre], *eba);
                 return 0;
diff --git a/drivers/hv/ring_buffer.c b/drivers/hv/ring_buffer.c
index 50e071444a5c..8699bb969e7e 100644
--- a/drivers/hv/ring_buffer.c
+++ b/drivers/hv/ring_buffer.c
@@ -417,13 +417,24 @@ __hv_pkt_iter_next(struct vmbus_channel *channel,
 }
 EXPORT_SYMBOL_GPL(__hv_pkt_iter_next);
 
+/* How many bytes were read in this iterator cycle */
+static u32 hv_pkt_iter_bytes_read(const struct hv_ring_buffer_info *rbi,
+                                        u32 start_read_index)
+{
+        if (rbi->priv_read_index >= start_read_index)
+                return rbi->priv_read_index - start_read_index;
+        else
+                return rbi->ring_datasize - start_read_index +
+                        rbi->priv_read_index;
+}
+
 /*
  * Update host ring buffer after iterating over packets.
  */
 void hv_pkt_iter_close(struct vmbus_channel *channel)
 {
         struct hv_ring_buffer_info *rbi = &channel->inbound;
-        u32 orig_write_sz = hv_get_bytes_to_write(rbi);
+        u32 curr_write_sz, pending_sz, bytes_read, start_read_index;
 
         /*
          * Make sure all reads are done before we update the read index since
@@ -431,8 +442,12 @@ void hv_pkt_iter_close(struct vmbus_channel *channel)
          * is updated.
          */
         virt_rmb();
+        start_read_index = rbi->ring_buffer->read_index;
         rbi->ring_buffer->read_index = rbi->priv_read_index;
 
+        if (!rbi->ring_buffer->feature_bits.feat_pending_send_sz)
+                return;
+
         /*
          * Issue a full memory barrier before making the signaling decision.
          * Here is the reason for having this barrier:
@@ -446,26 +461,29 @@ void hv_pkt_iter_close(struct vmbus_channel *channel)
          */
         virt_mb();
 
-        /* If host has disabled notifications then skip */
-        if (rbi->ring_buffer->interrupt_mask)
+        pending_sz = READ_ONCE(rbi->ring_buffer->pending_send_sz);
+        if (!pending_sz)
                 return;
 
-        if (rbi->ring_buffer->feature_bits.feat_pending_send_sz) {
-                u32 pending_sz = READ_ONCE(rbi->ring_buffer->pending_send_sz);
+        /*
+         * Ensure the read of write_index in hv_get_bytes_to_write()
+         * happens after the read of pending_send_sz.
+         */
+        virt_rmb();
+        curr_write_sz = hv_get_bytes_to_write(rbi);
+        bytes_read = hv_pkt_iter_bytes_read(rbi, start_read_index);
 
-                /*
-                 * If there was space before we began iteration,
-                 * then host was not blocked. Also handles case where
-                 * pending_sz is zero then host has nothing pending
-                 * and does not need to be signaled.
-                 */
-                if (orig_write_sz > pending_sz)
-                        return;
+        /*
+         * If there was space before we began iteration,
+         * then host was not blocked.
+         */
 
-                /* If pending write will not fit, don't give false hope. */
-                if (hv_get_bytes_to_write(rbi) < pending_sz)
-                        return;
-        }
+        if (curr_write_sz - bytes_read > pending_sz)
+                return;
+
+        /* If pending write will not fit, don't give false hope. */
+        if (curr_write_sz <= pending_sz)
+                return;
 
         vmbus_setevent(channel);
 }
diff --git a/drivers/iio/accel/st_accel_core.c b/drivers/iio/accel/st_accel_core.c
index 6fe995cf16a6..3e6fd5a8ac5b 100644
--- a/drivers/iio/accel/st_accel_core.c
+++ b/drivers/iio/accel/st_accel_core.c
@@ -920,6 +920,8 @@ static const struct iio_trigger_ops st_accel_trigger_ops = {
 int st_accel_common_probe(struct iio_dev *indio_dev)
 {
         struct st_sensor_data *adata = iio_priv(indio_dev);
+        struct st_sensors_platform_data *pdata =
+                (struct st_sensors_platform_data *)adata->dev->platform_data;
         int irq = adata->get_irq_data_ready(indio_dev);
         int err;
 
@@ -946,7 +948,10 @@ int st_accel_common_probe(struct iio_dev *indio_dev)
                                         &adata->sensor_settings->fs.fs_avl[0];
         adata->odr = adata->sensor_settings->odr.odr_avl[0].hz;
 
-        err = st_sensors_init_sensor(indio_dev, adata->dev->platform_data);
+        if (!pdata)
+                pdata = (struct st_sensors_platform_data *)&default_accel_pdata;
+
+        err = st_sensors_init_sensor(indio_dev, pdata);
         if (err < 0)
                 goto st_accel_power_off;
 
diff --git a/drivers/iio/adc/meson_saradc.c b/drivers/iio/adc/meson_saradc.c
index 29fa7736d80c..ede955d9b2a4 100644
--- a/drivers/iio/adc/meson_saradc.c
+++ b/drivers/iio/adc/meson_saradc.c
@@ -462,8 +462,10 @@ static int meson_sar_adc_lock(struct iio_dev *indio_dev)
                         regmap_read(priv->regmap, MESON_SAR_ADC_DELAY, &val);
                 } while (val & MESON_SAR_ADC_DELAY_BL30_BUSY && timeout--);
 
-                if (timeout < 0)
+                if (timeout < 0) {
+                        mutex_unlock(&indio_dev->mlock);
                         return -ETIMEDOUT;
+                }
         }
 
         return 0;
diff --git a/drivers/iio/adc/stm32-dfsdm-adc.c b/drivers/iio/adc/stm32-dfsdm-adc.c
index daa026d6a94f..01422d11753c 100644
--- a/drivers/iio/adc/stm32-dfsdm-adc.c
+++ b/drivers/iio/adc/stm32-dfsdm-adc.c
@@ -54,7 +54,6 @@ struct stm32_dfsdm_adc {
         struct stm32_dfsdm *dfsdm;
         const struct stm32_dfsdm_dev_data *dev_data;
         unsigned int fl_id;
-        unsigned int ch_id;
 
         /* ADC specific */
         unsigned int oversamp;
@@ -384,7 +383,7 @@ static ssize_t dfsdm_adc_audio_set_spiclk(struct iio_dev *indio_dev,
 {
         struct stm32_dfsdm_adc *adc = iio_priv(indio_dev);
         struct stm32_dfsdm_filter *fl = &adc->dfsdm->fl_list[adc->fl_id];
-        struct stm32_dfsdm_channel *ch = &adc->dfsdm->ch_list[adc->ch_id];
+        struct stm32_dfsdm_channel *ch = &adc->dfsdm->ch_list[chan->channel];
         unsigned int sample_freq = adc->sample_freq;
         unsigned int spi_freq;
         int ret;
@@ -419,18 +418,20 @@ static ssize_t dfsdm_adc_audio_set_spiclk(struct iio_dev *indio_dev,
         return len;
 }
 
-static int stm32_dfsdm_start_conv(struct stm32_dfsdm_adc *adc, bool dma)
+static int stm32_dfsdm_start_conv(struct stm32_dfsdm_adc *adc,
+                                  const struct iio_chan_spec *chan,
+                                  bool dma)
 {
         struct regmap *regmap = adc->dfsdm->regmap;
         int ret;
         unsigned int dma_en = 0, cont_en = 0;
 
-        ret = stm32_dfsdm_start_channel(adc->dfsdm, adc->ch_id);
+        ret = stm32_dfsdm_start_channel(adc->dfsdm, chan->channel);
         if (ret < 0)
                 return ret;
 
         ret = stm32_dfsdm_filter_configure(adc->dfsdm, adc->fl_id,
-                                           adc->ch_id);
+                                           chan->channel);
         if (ret < 0)
                 goto stop_channels;
 
@@ -464,12 +465,13 @@ stop_channels:
 
         regmap_update_bits(regmap, DFSDM_CR1(adc->fl_id),
                            DFSDM_CR1_RCONT_MASK, 0);
-        stm32_dfsdm_stop_channel(adc->dfsdm, adc->fl_id);
+        stm32_dfsdm_stop_channel(adc->dfsdm, chan->channel);
 
         return ret;
 }
 
-static void stm32_dfsdm_stop_conv(struct stm32_dfsdm_adc *adc)
+static void stm32_dfsdm_stop_conv(struct stm32_dfsdm_adc *adc,
+                                  const struct iio_chan_spec *chan)
 {
         struct regmap *regmap = adc->dfsdm->regmap;
 
@@ -482,7 +484,7 @@ static void stm32_dfsdm_stop_conv(struct stm32_dfsdm_adc *adc)
         regmap_update_bits(regmap, DFSDM_CR1(adc->fl_id),
                            DFSDM_CR1_RCONT_MASK, 0);
 
-        stm32_dfsdm_stop_channel(adc->dfsdm, adc->ch_id);
+        stm32_dfsdm_stop_channel(adc->dfsdm, chan->channel);
 }
 
 static int stm32_dfsdm_set_watermark(struct iio_dev *indio_dev,
@@ -609,6 +611,7 @@ static int stm32_dfsdm_adc_dma_start(struct iio_dev *indio_dev)
 static int stm32_dfsdm_postenable(struct iio_dev *indio_dev)
 {
         struct stm32_dfsdm_adc *adc = iio_priv(indio_dev);
+        const struct iio_chan_spec *chan = &indio_dev->channels[0];
         int ret;
 
         /* Reset adc buffer index */
@@ -618,7 +621,7 @@ static int stm32_dfsdm_postenable(struct iio_dev *indio_dev)
         if (ret < 0)
                 return ret;
 
-        ret = stm32_dfsdm_start_conv(adc, true);
+        ret = stm32_dfsdm_start_conv(adc, chan, true);
         if (ret) {
                 dev_err(&indio_dev->dev, "Can't start conversion\n");
                 goto stop_dfsdm;
@@ -635,7 +638,7 @@ static int stm32_dfsdm_postenable(struct iio_dev *indio_dev)
         return 0;
 
 err_stop_conv:
-        stm32_dfsdm_stop_conv(adc);
+        stm32_dfsdm_stop_conv(adc, chan);
 stop_dfsdm:
         stm32_dfsdm_stop_dfsdm(adc->dfsdm);
 
@@ -645,11 +648,12 @@ stop_dfsdm:
 static int stm32_dfsdm_predisable(struct iio_dev *indio_dev)
 {
         struct stm32_dfsdm_adc *adc = iio_priv(indio_dev);
+        const struct iio_chan_spec *chan = &indio_dev->channels[0];
 
         if (adc->dma_chan)
                 dmaengine_terminate_all(adc->dma_chan);
 
-        stm32_dfsdm_stop_conv(adc);
+        stm32_dfsdm_stop_conv(adc, chan);
 
         stm32_dfsdm_stop_dfsdm(adc->dfsdm);
 
@@ -730,7 +734,7 @@ static int stm32_dfsdm_single_conv(struct iio_dev *indio_dev,
         if (ret < 0)
                 goto stop_dfsdm;
 
-        ret = stm32_dfsdm_start_conv(adc, false);
+        ret = stm32_dfsdm_start_conv(adc, chan, false);
         if (ret < 0) {
                 regmap_update_bits(adc->dfsdm->regmap, DFSDM_CR2(adc->fl_id),
                                    DFSDM_CR2_REOCIE_MASK, DFSDM_CR2_REOCIE(0));
@@ -751,7 +755,7 @@ static int stm32_dfsdm_single_conv(struct iio_dev *indio_dev,
         else
                 ret = IIO_VAL_INT;
 
-        stm32_dfsdm_stop_conv(adc);
+        stm32_dfsdm_stop_conv(adc, chan);
 
 stop_dfsdm:
         stm32_dfsdm_stop_dfsdm(adc->dfsdm);
@@ -765,7 +769,7 @@ static int stm32_dfsdm_write_raw(struct iio_dev *indio_dev,
 {
         struct stm32_dfsdm_adc *adc = iio_priv(indio_dev);
         struct stm32_dfsdm_filter *fl = &adc->dfsdm->fl_list[adc->fl_id];
-        struct stm32_dfsdm_channel *ch = &adc->dfsdm->ch_list[adc->ch_id];
+        struct stm32_dfsdm_channel *ch = &adc->dfsdm->ch_list[chan->channel];
         unsigned int spi_freq = adc->spi_freq;
         int ret = -EINVAL;
 
@@ -972,7 +976,6 @@ static int stm32_dfsdm_adc_chan_init_one(struct iio_dev *indio_dev,
         }
         ch->scan_type.realbits = 24;
         ch->scan_type.storagebits = 32;
-        adc->ch_id = ch->channel;
 
         return stm32_dfsdm_chan_configure(adc->dfsdm,
                                           &adc->dfsdm->ch_list[ch->channel]);
@@ -1001,7 +1004,7 @@ static int stm32_dfsdm_audio_init(struct iio_dev *indio_dev)
         }
         ch->info_mask_separate = BIT(IIO_CHAN_INFO_SAMP_FREQ);
 
-        d_ch = &adc->dfsdm->ch_list[adc->ch_id];
+        d_ch = &adc->dfsdm->ch_list[ch->channel];
         if (d_ch->src != DFSDM_CHANNEL_SPI_CLOCK_EXTERNAL)
                 adc->spi_freq = adc->dfsdm->spi_master_freq;
 
@@ -1042,8 +1045,8 @@ static int stm32_dfsdm_adc_init(struct iio_dev *indio_dev)
                 return -ENOMEM;
 
         for (chan_idx = 0; chan_idx < num_ch; chan_idx++) {
-                ch->scan_index = chan_idx;
-                ret = stm32_dfsdm_adc_chan_init_one(indio_dev, ch);
+                ch[chan_idx].scan_index = chan_idx;
+                ret = stm32_dfsdm_adc_chan_init_one(indio_dev, &ch[chan_idx]);
                 if (ret < 0) {
                         dev_err(&indio_dev->dev, "Channels init failed\n");
                         return ret;
diff --git a/drivers/iio/adc/stm32-dfsdm-core.c b/drivers/iio/adc/stm32-dfsdm-core.c
index 6290332cfd3f..e50efdcc41ff 100644
--- a/drivers/iio/adc/stm32-dfsdm-core.c
+++ b/drivers/iio/adc/stm32-dfsdm-core.c
@@ -83,7 +83,7 @@ int stm32_dfsdm_start_dfsdm(struct stm32_dfsdm *dfsdm)
 {
         struct dfsdm_priv *priv = container_of(dfsdm, struct dfsdm_priv, dfsdm);
         struct device *dev = &priv->pdev->dev;
-        unsigned int clk_div = priv->spi_clk_out_div;
+        unsigned int clk_div = priv->spi_clk_out_div, clk_src;
         int ret;
 
         if (atomic_inc_return(&priv->n_active_ch) == 1) {
@@ -100,6 +100,14 @@ int stm32_dfsdm_start_dfsdm(struct stm32_dfsdm *dfsdm)
                         }
                 }
 
+                /* select clock source, e.g. 0 for "dfsdm" or 1 for "audio" */
+                clk_src = priv->aclk ? 1 : 0;
+                ret = regmap_update_bits(dfsdm->regmap, DFSDM_CHCFGR1(0),
+                                         DFSDM_CHCFGR1_CKOUTSRC_MASK,
+                                         DFSDM_CHCFGR1_CKOUTSRC(clk_src));
+                if (ret < 0)
+                        goto disable_aclk;
+
                 /* Output the SPI CLKOUT (if clk_div == 0 clock if OFF) */
                 ret = regmap_update_bits(dfsdm->regmap, DFSDM_CHCFGR1(0),
                                          DFSDM_CHCFGR1_CKOUTDIV_MASK,
@@ -274,7 +282,7 @@ static int stm32_dfsdm_probe(struct platform_device *pdev)
 
         dfsdm->regmap = devm_regmap_init_mmio_clk(&pdev->dev, "dfsdm",
                                                   dfsdm->base,
-                                                  &stm32h7_dfsdm_regmap_cfg);
+                                                  dev_data->regmap_cfg);
         if (IS_ERR(dfsdm->regmap)) {
                 ret = PTR_ERR(dfsdm->regmap);
                 dev_err(&pdev->dev, "%s: Failed to allocate regmap: %d\n",
diff --git a/drivers/iio/chemical/ccs811.c b/drivers/iio/chemical/ccs811.c
index fbe2431f5b81..1ea9f5513b02 100644
--- a/drivers/iio/chemical/ccs811.c
+++ b/drivers/iio/chemical/ccs811.c
@@ -133,6 +133,9 @@ static int ccs811_start_sensor_application(struct i2c_client *client)
         if (ret < 0)
                 return ret;
 
+        if ((ret & CCS811_STATUS_FW_MODE_APPLICATION))
+                return 0;
+
         if ((ret & CCS811_STATUS_APP_VALID_MASK) !=
             CCS811_STATUS_APP_VALID_LOADED)
                 return -EIO;
diff --git a/drivers/iio/pressure/st_pressure_core.c b/drivers/iio/pressure/st_pressure_core.c
index 349e5c713c03..4ddb6cf7d401 100644
--- a/drivers/iio/pressure/st_pressure_core.c
+++ b/drivers/iio/pressure/st_pressure_core.c
@@ -640,7 +640,7 @@ int st_press_common_probe(struct iio_dev *indio_dev)
                        press_data->sensor_settings->drdy_irq.int2.addr))
                 pdata = (struct st_sensors_platform_data *)&default_press_pdata;
 
-        err = st_sensors_init_sensor(indio_dev, press_data->dev->platform_data);
+        err = st_sensors_init_sensor(indio_dev, pdata);
         if (err < 0)
                 goto st_press_power_off;
 
diff --git a/drivers/infiniband/core/cma.c b/drivers/infiniband/core/cma.c
index e66963ca58bd..a5367c5efbe7 100644
--- a/drivers/infiniband/core/cma.c
+++ b/drivers/infiniband/core/cma.c
@@ -3069,7 +3069,8 @@ static int cma_port_is_unique(struct rdma_bind_list *bind_list,
                         continue;
 
                 /* different dest port -> unique */
-                if (!cma_any_port(cur_daddr) &&
+                if (!cma_any_port(daddr) &&
+                    !cma_any_port(cur_daddr) &&
                     (dport != cur_dport))
                         continue;
 
@@ -3080,7 +3081,8 @@ static int cma_port_is_unique(struct rdma_bind_list *bind_list,
                         continue;
 
                 /* different dst address -> unique */
-                if (!cma_any_addr(cur_daddr) &&
+                if (!cma_any_addr(daddr) &&
+                    !cma_any_addr(cur_daddr) &&
                     cma_addr_cmp(daddr, cur_daddr))
                         continue;
 
@@ -3378,13 +3380,13 @@ int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr)
                 }
 #endif
         }
+        daddr = cma_dst_addr(id_priv);
+        daddr->sa_family = addr->sa_family;
+
         ret = cma_get_port(id_priv);
         if (ret)
                 goto err2;
 
-        daddr = cma_dst_addr(id_priv);
-        daddr->sa_family = addr->sa_family;
-
         return 0;
 err2:
         if (id_priv->cma_dev)
@@ -4173,6 +4175,9 @@ int rdma_join_multicast(struct rdma_cm_id *id, struct sockaddr *addr,
         struct cma_multicast *mc;
         int ret;
 
+        if (!id->device)
+                return -EINVAL;
+
         id_priv = container_of(id, struct rdma_id_private, id);
         if (!cma_comp(id_priv, RDMA_CM_ADDR_BOUND) &&
             !cma_comp(id_priv, RDMA_CM_ADDR_RESOLVED))
diff --git a/drivers/infiniband/core/ucma.c b/drivers/infiniband/core/ucma.c
index 3a9d0f5b5881..e5a1e7d81326 100644
--- a/drivers/infiniband/core/ucma.c
+++ b/drivers/infiniband/core/ucma.c
@@ -132,7 +132,7 @@ static inline struct ucma_context *_ucma_find_context(int id,
         ctx = idr_find(&ctx_idr, id);
         if (!ctx)
                 ctx = ERR_PTR(-ENOENT);
-        else if (ctx->file != file)
+        else if (ctx->file != file || !ctx->cm_id)
                 ctx = ERR_PTR(-EINVAL);
         return ctx;
 }
@@ -456,6 +456,7 @@ static ssize_t ucma_create_id(struct ucma_file *file, const char __user *inbuf,
         struct rdma_ucm_create_id cmd;
         struct rdma_ucm_create_id_resp resp;
         struct ucma_context *ctx;
+        struct rdma_cm_id *cm_id;
         enum ib_qp_type qp_type;
         int ret;
 
@@ -476,10 +477,10 @@ static ssize_t ucma_create_id(struct ucma_file *file, const char __user *inbuf,
                 return -ENOMEM;
 
         ctx->uid = cmd.uid;
-        ctx->cm_id = rdma_create_id(current->nsproxy->net_ns,
-                                    ucma_event_handler, ctx, cmd.ps, qp_type);
-        if (IS_ERR(ctx->cm_id)) {
-                ret = PTR_ERR(ctx->cm_id);
+        cm_id = rdma_create_id(current->nsproxy->net_ns,
+                               ucma_event_handler, ctx, cmd.ps, qp_type);
+        if (IS_ERR(cm_id)) {
+                ret = PTR_ERR(cm_id);
                 goto err1;
         }
 
@@ -489,14 +490,19 @@ static ssize_t ucma_create_id(struct ucma_file *file, const char __user *inbuf,
                 ret = -EFAULT;
                 goto err2;
         }
+
+        ctx->cm_id = cm_id;
         return 0;
 
 err2:
-        rdma_destroy_id(ctx->cm_id);
+        rdma_destroy_id(cm_id);
 err1:
         mutex_lock(&mut);
         idr_remove(&ctx_idr, ctx->id);
         mutex_unlock(&mut);
+        mutex_lock(&file->mut);
+        list_del(&ctx->list);
+        mutex_unlock(&file->mut);
         kfree(ctx);
         return ret;
 }
@@ -664,19 +670,23 @@ static ssize_t ucma_resolve_ip(struct ucma_file *file,
                                int in_len, int out_len)
 {
         struct rdma_ucm_resolve_ip cmd;
+        struct sockaddr *src, *dst;
         struct ucma_context *ctx;
         int ret;
 
         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
                 return -EFAULT;
 
+        src = (struct sockaddr *) &cmd.src_addr;
+        dst = (struct sockaddr *) &cmd.dst_addr;
+        if (!rdma_addr_size(src) || !rdma_addr_size(dst))
+                return -EINVAL;
+
         ctx = ucma_get_ctx(file, cmd.id);
         if (IS_ERR(ctx))
                 return PTR_ERR(ctx);
 
-        ret = rdma_resolve_addr(ctx->cm_id, (struct sockaddr *) &cmd.src_addr,
-                                (struct sockaddr *) &cmd.dst_addr,
-                                cmd.timeout_ms);
+        ret = rdma_resolve_addr(ctx->cm_id, src, dst, cmd.timeout_ms);
         ucma_put_ctx(ctx);
         return ret;
 }
@@ -1349,7 +1359,7 @@ static ssize_t ucma_process_join(struct ucma_file *file,
                 return -ENOSPC;
 
         addr = (struct sockaddr *) &cmd->addr;
-        if (!cmd->addr_size || (cmd->addr_size != rdma_addr_size(addr)))
+        if (cmd->addr_size != rdma_addr_size(addr))
                 return -EINVAL;
 
         if (cmd->join_flags == RDMA_MC_JOIN_FLAG_FULLMEMBER)
@@ -1417,6 +1427,9 @@ static ssize_t ucma_join_ip_multicast(struct ucma_file *file,
         join_cmd.uid = cmd.uid;
         join_cmd.id = cmd.id;
         join_cmd.addr_size = rdma_addr_size((struct sockaddr *) &cmd.addr);
+        if (!join_cmd.addr_size)
+                return -EINVAL;
+
         join_cmd.join_flags = RDMA_MC_JOIN_FLAG_FULLMEMBER;
         memcpy(&join_cmd.addr, &cmd.addr, join_cmd.addr_size);
 
@@ -1432,6 +1445,9 @@ static ssize_t ucma_join_multicast(struct ucma_file *file,
         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
                 return -EFAULT;
 
+        if (!rdma_addr_size((struct sockaddr *)&cmd.addr))
+                return -EINVAL;
+
         return ucma_process_join(file, &cmd, out_len);
 }
 
diff --git a/drivers/infiniband/hw/bnxt_re/bnxt_re.h b/drivers/infiniband/hw/bnxt_re/bnxt_re.h
index 3eb7a8387116..96f76896488d 100644
--- a/drivers/infiniband/hw/bnxt_re/bnxt_re.h
+++ b/drivers/infiniband/hw/bnxt_re/bnxt_re.h
@@ -57,8 +57,8 @@
 #define BNXT_RE_PAGE_SIZE_8M            BIT(BNXT_RE_PAGE_SHIFT_8M)
 #define BNXT_RE_PAGE_SIZE_1G            BIT(BNXT_RE_PAGE_SHIFT_1G)
 
-#define BNXT_RE_MAX_MR_SIZE_LOW         BIT(BNXT_RE_PAGE_SHIFT_1G)
-#define BNXT_RE_MAX_MR_SIZE_HIGH        BIT(39)
+#define BNXT_RE_MAX_MR_SIZE_LOW         BIT_ULL(BNXT_RE_PAGE_SHIFT_1G)
+#define BNXT_RE_MAX_MR_SIZE_HIGH        BIT_ULL(39)
 #define BNXT_RE_MAX_MR_SIZE             BNXT_RE_MAX_MR_SIZE_HIGH
 
 #define BNXT_RE_MAX_QPC_COUNT           (64 * 1024)
diff --git a/drivers/infiniband/hw/bnxt_re/ib_verbs.c b/drivers/infiniband/hw/bnxt_re/ib_verbs.c
index 0dd75f449872..8301d7e5fa8c 100644
--- a/drivers/infiniband/hw/bnxt_re/ib_verbs.c
+++ b/drivers/infiniband/hw/bnxt_re/ib_verbs.c
@@ -3598,7 +3598,7 @@ struct ib_mr *bnxt_re_reg_user_mr(struct ib_pd *ib_pd, u64 start, u64 length,
         int umem_pgs, page_shift, rc;
 
         if (length > BNXT_RE_MAX_MR_SIZE) {
-                dev_err(rdev_to_dev(rdev), "MR Size: %lld > Max supported:%ld\n",
+                dev_err(rdev_to_dev(rdev), "MR Size: %lld > Max supported:%lld\n",
                         length, BNXT_RE_MAX_MR_SIZE);
                 return ERR_PTR(-ENOMEM);
         }
diff --git a/drivers/infiniband/hw/bnxt_re/qplib_fp.c b/drivers/infiniband/hw/bnxt_re/qplib_fp.c
index 06b42c880fd4..3a78faba8d91 100644
--- a/drivers/infiniband/hw/bnxt_re/qplib_fp.c
+++ b/drivers/infiniband/hw/bnxt_re/qplib_fp.c
@@ -243,7 +243,7 @@ static void bnxt_qplib_service_nq(unsigned long data)
         u32 sw_cons, raw_cons;
         u16 type;
         int budget = nq->budget;
-        u64 q_handle;
+        uintptr_t q_handle;
 
         /* Service the NQ until empty */
         raw_cons = hwq->cons;
@@ -526,7 +526,7 @@ int bnxt_qplib_create_srq(struct bnxt_qplib_res *res,
 
         /* Configure the request */
         req.dpi = cpu_to_le32(srq->dpi->dpi);
-        req.srq_handle = cpu_to_le64(srq);
+        req.srq_handle = cpu_to_le64((uintptr_t)srq);
 
         req.srq_size = cpu_to_le16((u16)srq->hwq.max_elements);
         pbl = &srq->hwq.pbl[PBL_LVL_0];
diff --git a/drivers/infiniband/hw/mlx5/main.c b/drivers/infiniband/hw/mlx5/main.c
index 033b6af90de9..da091de4e69d 100644
--- a/drivers/infiniband/hw/mlx5/main.c
+++ b/drivers/infiniband/hw/mlx5/main.c
@@ -4860,19 +4860,19 @@ static int mlx5_ib_stage_ib_reg_init(struct mlx5_ib_dev *dev)
         return ib_register_device(&dev->ib_dev, NULL);
 }
 
-static void mlx5_ib_stage_ib_reg_cleanup(struct mlx5_ib_dev *dev)
+static void mlx5_ib_stage_pre_ib_reg_umr_cleanup(struct mlx5_ib_dev *dev)
 {
-        ib_unregister_device(&dev->ib_dev);
+        destroy_umrc_res(dev);
 }
 
-static int mlx5_ib_stage_umr_res_init(struct mlx5_ib_dev *dev)
+static void mlx5_ib_stage_ib_reg_cleanup(struct mlx5_ib_dev *dev)
 {
-        return create_umr_res(dev);
+        ib_unregister_device(&dev->ib_dev);
 }
 
-static void mlx5_ib_stage_umr_res_cleanup(struct mlx5_ib_dev *dev)
+static int mlx5_ib_stage_post_ib_reg_umr_init(struct mlx5_ib_dev *dev)
 {
-        destroy_umrc_res(dev);
+        return create_umr_res(dev);
 }
 
 static int mlx5_ib_stage_delay_drop_init(struct mlx5_ib_dev *dev)
@@ -4982,12 +4982,15 @@ static const struct mlx5_ib_profile pf_profile = {
         STAGE_CREATE(MLX5_IB_STAGE_BFREG,
                      mlx5_ib_stage_bfrag_init,
                      mlx5_ib_stage_bfrag_cleanup),
+        STAGE_CREATE(MLX5_IB_STAGE_PRE_IB_REG_UMR,
+                     NULL,
+                     mlx5_ib_stage_pre_ib_reg_umr_cleanup),
         STAGE_CREATE(MLX5_IB_STAGE_IB_REG,
                      mlx5_ib_stage_ib_reg_init,
                      mlx5_ib_stage_ib_reg_cleanup),
-        STAGE_CREATE(MLX5_IB_STAGE_UMR_RESOURCES,
-                     mlx5_ib_stage_umr_res_init,
-                     mlx5_ib_stage_umr_res_cleanup),
+        STAGE_CREATE(MLX5_IB_STAGE_POST_IB_REG_UMR,
+                     mlx5_ib_stage_post_ib_reg_umr_init,
+                     NULL),
         STAGE_CREATE(MLX5_IB_STAGE_DELAY_DROP,
                      mlx5_ib_stage_delay_drop_init,
                      mlx5_ib_stage_delay_drop_cleanup),
diff --git a/drivers/infiniband/hw/mlx5/mlx5_ib.h b/drivers/infiniband/hw/mlx5/mlx5_ib.h
index 139385129973..a5272499b600 100644
--- a/drivers/infiniband/hw/mlx5/mlx5_ib.h
+++ b/drivers/infiniband/hw/mlx5/mlx5_ib.h
@@ -739,8 +739,9 @@ enum mlx5_ib_stages {
         MLX5_IB_STAGE_CONG_DEBUGFS,
         MLX5_IB_STAGE_UAR,
         MLX5_IB_STAGE_BFREG,
+        MLX5_IB_STAGE_PRE_IB_REG_UMR,
         MLX5_IB_STAGE_IB_REG,
-        MLX5_IB_STAGE_UMR_RESOURCES,
+        MLX5_IB_STAGE_POST_IB_REG_UMR,
         MLX5_IB_STAGE_DELAY_DROP,
         MLX5_IB_STAGE_CLASS_ATTR,
         MLX5_IB_STAGE_MAX,
diff --git a/drivers/infiniband/hw/mlx5/mr.c b/drivers/infiniband/hw/mlx5/mr.c
index 1961c6a45437..c51c602f06d6 100644
--- a/drivers/infiniband/hw/mlx5/mr.c
+++ b/drivers/infiniband/hw/mlx5/mr.c
@@ -838,7 +838,8 @@ static int mr_umem_get(struct ib_pd *pd, u64 start, u64 length,
         *umem = ib_umem_get(pd->uobject->context, start, length,
                             access_flags, 0);
         err = PTR_ERR_OR_ZERO(*umem);
-        if (err < 0) {
+        if (err) {
+                *umem = NULL;
                 mlx5_ib_err(dev, "umem get failed (%d)\n", err);
                 return err;
         }
@@ -1415,6 +1416,7 @@ int mlx5_ib_rereg_user_mr(struct ib_mr *ib_mr, int flags, u64 start,
                 if (err) {
                         mlx5_ib_warn(dev, "Failed to rereg UMR\n");
                         ib_umem_release(mr->umem);
+                        mr->umem = NULL;
                         clean_mr(dev, mr);
                         return err;
                 }
@@ -1498,14 +1500,11 @@ static int clean_mr(struct mlx5_ib_dev *dev, struct mlx5_ib_mr *mr)
                 u32 key = mr->mmkey.key;
 
                 err = destroy_mkey(dev, mr);
-                kfree(mr);
                 if (err) {
                         mlx5_ib_warn(dev, "failed to destroy mkey 0x%x (%d)\n",
                                      key, err);
                         return err;
                 }
-        } else {
-                mlx5_mr_cache_free(dev, mr);
         }
 
         return 0;
@@ -1548,6 +1547,11 @@ static int dereg_mr(struct mlx5_ib_dev *dev, struct mlx5_ib_mr *mr)
                 atomic_sub(npages, &dev->mdev->priv.reg_pages);
         }
 
+        if (!mr->allocated_from_cache)
+                kfree(mr);
+        else
+                mlx5_mr_cache_free(dev, mr);
+
         return 0;
 }
 
diff --git a/drivers/infiniband/hw/mlx5/qp.c b/drivers/infiniband/hw/mlx5/qp.c
index 36197fbac63a..a2e1aa86e133 100644
--- a/drivers/infiniband/hw/mlx5/qp.c
+++ b/drivers/infiniband/hw/mlx5/qp.c
@@ -1161,7 +1161,7 @@ static void destroy_raw_packet_qp_sq(struct mlx5_ib_dev *dev,
         ib_umem_release(sq->ubuffer.umem);
 }
 
-static int get_rq_pas_size(void *qpc)
+static size_t get_rq_pas_size(void *qpc)
 {
         u32 log_page_size = MLX5_GET(qpc, qpc, log_page_size) + 12;
         u32 log_rq_stride = MLX5_GET(qpc, qpc, log_rq_stride);
@@ -1177,7 +1177,8 @@ static int get_rq_pas_size(void *qpc)
 }
 
 static int create_raw_packet_qp_rq(struct mlx5_ib_dev *dev,
-                                   struct mlx5_ib_rq *rq, void *qpin)
+                                   struct mlx5_ib_rq *rq, void *qpin,
+                                   size_t qpinlen)
 {
         struct mlx5_ib_qp *mqp = rq->base.container_mibqp;
         __be64 *pas;
@@ -1186,9 +1187,12 @@ static int create_raw_packet_qp_rq(struct mlx5_ib_dev *dev,
         void *rqc;
         void *wq;
         void *qpc = MLX5_ADDR_OF(create_qp_in, qpin, qpc);
-        int inlen;
+        size_t rq_pas_size = get_rq_pas_size(qpc);
+        size_t inlen;
         int err;
-        u32 rq_pas_size = get_rq_pas_size(qpc);
+
+        if (qpinlen < rq_pas_size + MLX5_BYTE_OFF(create_qp_in, pas))
+                return -EINVAL;
 
         inlen = MLX5_ST_SZ_BYTES(create_rq_in) + rq_pas_size;
         in = kvzalloc(inlen, GFP_KERNEL);
@@ -1277,7 +1281,7 @@ static void destroy_raw_packet_qp_tir(struct mlx5_ib_dev *dev,
 }
 
 static int create_raw_packet_qp(struct mlx5_ib_dev *dev, struct mlx5_ib_qp *qp,
-                                u32 *in,
+                                u32 *in, size_t inlen,
                                 struct ib_pd *pd)
 {
         struct mlx5_ib_raw_packet_qp *raw_packet_qp = &qp->raw_packet_qp;
@@ -1309,7 +1313,7 @@ static int create_raw_packet_qp(struct mlx5_ib_dev *dev, struct mlx5_ib_qp *qp,
                         rq->flags |= MLX5_IB_RQ_CVLAN_STRIPPING;
                 if (qp->flags & MLX5_IB_QP_PCI_WRITE_END_PADDING)
                         rq->flags |= MLX5_IB_RQ_PCI_WRITE_END_PADDING;
-                err = create_raw_packet_qp_rq(dev, rq, in);
+                err = create_raw_packet_qp_rq(dev, rq, in, inlen);
                 if (err)
                         goto err_destroy_sq;
 
@@ -1872,11 +1876,16 @@ static int create_qp_common(struct mlx5_ib_dev *dev, struct ib_pd *pd,
                 }
         }
 
+        if (inlen < 0) {
+                err = -EINVAL;
+                goto err;
+        }
+
         if (init_attr->qp_type == IB_QPT_RAW_PACKET ||
             qp->flags & MLX5_IB_QP_UNDERLAY) {
                 qp->raw_packet_qp.sq.ubuffer.buf_addr = ucmd.sq_buf_addr;
                 raw_packet_qp_copy_info(qp, &qp->raw_packet_qp);
-                err = create_raw_packet_qp(dev, qp, in, pd);
+                err = create_raw_packet_qp(dev, qp, in, inlen, pd);
         } else {
                 err = mlx5_core_create_qp(dev->mdev, &base->mqp, in, inlen);
         }
diff --git a/drivers/infiniband/hw/mlx5/srq.c b/drivers/infiniband/hw/mlx5/srq.c
index 6d5fadad9090..3c7522d025f2 100644
--- a/drivers/infiniband/hw/mlx5/srq.c
+++ b/drivers/infiniband/hw/mlx5/srq.c
@@ -241,8 +241,8 @@ struct ib_srq *mlx5_ib_create_srq(struct ib_pd *pd,
 {
         struct mlx5_ib_dev *dev = to_mdev(pd->device);
         struct mlx5_ib_srq *srq;
-        int desc_size;
-        int buf_size;
+        size_t desc_size;
+        size_t buf_size;
         int err;
         struct mlx5_srq_attr in = {0};
         __u32 max_srq_wqes = 1 << MLX5_CAP_GEN(dev->mdev, log_max_srq_sz);
@@ -266,15 +266,18 @@ struct ib_srq *mlx5_ib_create_srq(struct ib_pd *pd,
 
         desc_size = sizeof(struct mlx5_wqe_srq_next_seg) +
                     srq->msrq.max_gs * sizeof(struct mlx5_wqe_data_seg);
+        if (desc_size == 0 || srq->msrq.max_gs > desc_size)
+                return ERR_PTR(-EINVAL);
         desc_size = roundup_pow_of_two(desc_size);
-        desc_size = max_t(int, 32, desc_size);
+        desc_size = max_t(size_t, 32, desc_size);
+        if (desc_size < sizeof(struct mlx5_wqe_srq_next_seg))
+                return ERR_PTR(-EINVAL);
         srq->msrq.max_avail_gather = (desc_size - sizeof(struct mlx5_wqe_srq_next_seg)) /
                 sizeof(struct mlx5_wqe_data_seg);
         srq->msrq.wqe_shift = ilog2(desc_size);
         buf_size = srq->msrq.max * desc_size;
-        mlx5_ib_dbg(dev, "desc_size 0x%x, req wr 0x%x, srq size 0x%x, max_gs 0x%x, max_avail_gather 0x%x\n",
-                    desc_size, init_attr->attr.max_wr, srq->msrq.max, srq->msrq.max_gs,
-                    srq->msrq.max_avail_gather);
+        if (buf_size < desc_size)
+                return ERR_PTR(-EINVAL);
         in.type = init_attr->srq_type;
 
         if (pd->uobject)
diff --git a/drivers/media/Kconfig b/drivers/media/Kconfig
index 372c074bb1b9..86c1a190d946 100644
--- a/drivers/media/Kconfig
+++ b/drivers/media/Kconfig
@@ -151,7 +151,7 @@ config DVB_MMAP
         select VIDEOBUF2_VMALLOC
         default n
         help
-          This option enables DVB experimental memory-mapped API, with
+          This option enables DVB experimental memory-mapped API, which
           reduces the number of context switches to read DVB buffers, as
           the buffers can use mmap() syscalls.
 
diff --git a/drivers/media/platform/tegra-cec/tegra_cec.c b/drivers/media/platform/tegra-cec/tegra_cec.c
index 92f93a880015..aba488cd0e64 100644
--- a/drivers/media/platform/tegra-cec/tegra_cec.c
+++ b/drivers/media/platform/tegra-cec/tegra_cec.c
@@ -172,16 +172,13 @@ static irqreturn_t tegra_cec_irq_handler(int irq, void *data)
                 }
         }
 
-        if (status & (TEGRA_CEC_INT_STAT_RX_REGISTER_OVERRUN |
-                      TEGRA_CEC_INT_STAT_RX_BUS_ANOMALY_DETECTED |
-                      TEGRA_CEC_INT_STAT_RX_START_BIT_DETECTED |
-                      TEGRA_CEC_INT_STAT_RX_BUS_ERROR_DETECTED)) {
+        if (status & TEGRA_CEC_INT_STAT_RX_START_BIT_DETECTED) {
                 cec_write(cec, TEGRA_CEC_INT_STAT,
-                          (TEGRA_CEC_INT_STAT_RX_REGISTER_OVERRUN |
-                           TEGRA_CEC_INT_STAT_RX_BUS_ANOMALY_DETECTED |
-                           TEGRA_CEC_INT_STAT_RX_START_BIT_DETECTED |
-                           TEGRA_CEC_INT_STAT_RX_BUS_ERROR_DETECTED));
-        } else if (status & TEGRA_CEC_INT_STAT_RX_REGISTER_FULL) {
+                          TEGRA_CEC_INT_STAT_RX_START_BIT_DETECTED);
+                cec->rx_done = false;
+                cec->rx_buf_cnt = 0;
+        }
+        if (status & TEGRA_CEC_INT_STAT_RX_REGISTER_FULL) {
                 u32 v;
 
                 cec_write(cec, TEGRA_CEC_INT_STAT,
@@ -255,7 +252,7 @@ static int tegra_cec_adap_enable(struct cec_adapter *adap, bool enable)
                   TEGRA_CEC_INT_MASK_TX_BUS_ANOMALY_DETECTED |
                   TEGRA_CEC_INT_MASK_TX_FRAME_TRANSMITTED |
                   TEGRA_CEC_INT_MASK_RX_REGISTER_FULL |
-                  TEGRA_CEC_INT_MASK_RX_REGISTER_OVERRUN);
+                  TEGRA_CEC_INT_MASK_RX_START_BIT_DETECTED);
 
         cec_write(cec, TEGRA_CEC_HW_CONTROL, TEGRA_CEC_HWCTRL_TX_RX_MODE);
         return 0;
diff --git a/drivers/mmc/core/block.c b/drivers/mmc/core/block.c
index 20135a5de748..2cfb963d9f37 100644
--- a/drivers/mmc/core/block.c
+++ b/drivers/mmc/core/block.c
@@ -72,6 +72,7 @@ MODULE_ALIAS("mmc:block");
 #define MMC_BLK_TIMEOUT_MS  (10 * 1000)
 #define MMC_SANITIZE_REQ_TIMEOUT 240000
 #define MMC_EXTRACT_INDEX_FROM_ARG(x) ((x & 0x00FF0000) >> 16)
+#define MMC_EXTRACT_VALUE_FROM_ARG(x) ((x & 0x0000FF00) >> 8)
 
 #define mmc_req_rel_wr(req)     ((req->cmd_flags & REQ_FUA) && \
                                   (rq_data_dir(req) == WRITE))
@@ -587,6 +588,24 @@ static int __mmc_blk_ioctl_cmd(struct mmc_card *card, struct mmc_blk_data *md,
         }
 
         /*
+         * Make sure the cache of the PARTITION_CONFIG register and
+         * PARTITION_ACCESS bits is updated in case the ioctl ext_csd write
+         * changed it successfully.
+         */
+        if ((MMC_EXTRACT_INDEX_FROM_ARG(cmd.arg) == EXT_CSD_PART_CONFIG) &&
+            (cmd.opcode == MMC_SWITCH)) {
+                struct mmc_blk_data *main_md = dev_get_drvdata(&card->dev);
+                u8 value = MMC_EXTRACT_VALUE_FROM_ARG(cmd.arg);
+
+                /*
+                 * Update cache so the next mmc_blk_part_switch call operates
+                 * on up-to-date data.
+                 */
+                card->ext_csd.part_config = value;
+                main_md->part_curr = value & EXT_CSD_PART_CONFIG_ACC_MASK;
+        }
+
+        /*
          * According to the SD specs, some commands require a delay after
          * issuing the command.
          */
diff --git a/drivers/mmc/core/card.h b/drivers/mmc/core/card.h
index 79a5b985ccf5..9c821eedd156 100644
--- a/drivers/mmc/core/card.h
+++ b/drivers/mmc/core/card.h
@@ -82,6 +82,7 @@ struct mmc_fixup {
 #define CID_MANFID_APACER       0x27
 #define CID_MANFID_KINGSTON     0x70
 #define CID_MANFID_HYNIX        0x90
+#define CID_MANFID_NUMONYX      0xFE
 
 #define END_FIXUP { NULL }
 
diff --git a/drivers/mmc/core/quirks.h b/drivers/mmc/core/quirks.h
index 75d317623852..5153577754f0 100644
--- a/drivers/mmc/core/quirks.h
+++ b/drivers/mmc/core/quirks.h
@@ -109,6 +109,12 @@ static const struct mmc_fixup mmc_ext_csd_fixups[] = {
          */
         MMC_FIXUP_EXT_CSD_REV(CID_NAME_ANY, CID_MANFID_HYNIX,
                               0x014a, add_quirk, MMC_QUIRK_BROKEN_HPI, 5),
+        /*
+         * Certain Micron (Numonyx) eMMC 4.5 cards might get broken when HPI
+         * feature is used so disable the HPI feature for such buggy cards.
+         */
+        MMC_FIXUP_EXT_CSD_REV(CID_NAME_ANY, CID_MANFID_NUMONYX,
+                              0x014e, add_quirk, MMC_QUIRK_BROKEN_HPI, 6),
 
         END_FIXUP
 };
diff --git a/drivers/mmc/host/dw_mmc-exynos.c b/drivers/mmc/host/dw_mmc-exynos.c
index fa41d9422d57..a84aa3f1ae85 100644
--- a/drivers/mmc/host/dw_mmc-exynos.c
+++ b/drivers/mmc/host/dw_mmc-exynos.c
@@ -165,9 +165,15 @@ static void dw_mci_exynos_set_clksel_timing(struct dw_mci *host, u32 timing)
 static int dw_mci_exynos_runtime_resume(struct device *dev)
 {
         struct dw_mci *host = dev_get_drvdata(dev);
+        int ret;
+
+        ret = dw_mci_runtime_resume(dev);
+        if (ret)
+                return ret;
 
         dw_mci_exynos_config_smu(host);
-        return dw_mci_runtime_resume(dev);
+
+        return ret;
 }
 
 /**
diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c
index d9b4acefed31..06d47414d0c1 100644
--- a/drivers/mmc/host/dw_mmc.c
+++ b/drivers/mmc/host/dw_mmc.c
@@ -413,7 +413,9 @@ static inline void dw_mci_set_cto(struct dw_mci *host)
         cto_div = (mci_readl(host, CLKDIV) & 0xff) * 2;
         if (cto_div == 0)
                 cto_div = 1;
-        cto_ms = DIV_ROUND_UP(MSEC_PER_SEC * cto_clks * cto_div, host->bus_hz);
+
+        cto_ms = DIV_ROUND_UP_ULL((u64)MSEC_PER_SEC * cto_clks * cto_div,
+                                  host->bus_hz);
 
         /* add a bit spare time */
         cto_ms += 10;
@@ -562,6 +564,7 @@ static int dw_mci_idmac_init(struct dw_mci *host)
                                         (sizeof(struct idmac_desc_64addr) *
                                                         (i + 1))) >> 32;
                         /* Initialize reserved and buffer size fields to "0" */
+                        p->des0 = 0;
                         p->des1 = 0;
                         p->des2 = 0;
                         p->des3 = 0;
@@ -584,6 +587,7 @@ static int dw_mci_idmac_init(struct dw_mci *host)
                      i++, p++) {
                         p->des3 = cpu_to_le32(host->sg_dma +
                                         (sizeof(struct idmac_desc) * (i + 1)));
+                        p->des0 = 0;
                         p->des1 = 0;
                 }
 
@@ -1799,8 +1803,8 @@ static bool dw_mci_reset(struct dw_mci *host)
         }
 
         if (host->use_dma == TRANS_MODE_IDMAC)
-                /* It is also recommended that we reset and reprogram idmac */
-                dw_mci_idmac_reset(host);
+                /* It is also required that we reinit idmac */
+                dw_mci_idmac_init(host);
 
         ret = true;
 
@@ -1948,8 +1952,9 @@ static void dw_mci_set_drto(struct dw_mci *host)
         drto_div = (mci_readl(host, CLKDIV) & 0xff) * 2;
         if (drto_div == 0)
                 drto_div = 1;
-        drto_ms = DIV_ROUND_UP(MSEC_PER_SEC * drto_clks * drto_div,
-                               host->bus_hz);
+
+        drto_ms = DIV_ROUND_UP_ULL((u64)MSEC_PER_SEC * drto_clks * drto_div,
+                                   host->bus_hz);
 
         /* add a bit spare time */
         drto_ms += 10;
diff --git a/drivers/mmc/host/sdhci-acpi.c b/drivers/mmc/host/sdhci-acpi.c
index 4065da58789d..32321bd596d8 100644
--- a/drivers/mmc/host/sdhci-acpi.c
+++ b/drivers/mmc/host/sdhci-acpi.c
@@ -680,7 +680,7 @@ static int sdhci_acpi_probe(struct platform_device *pdev)
         host->hw_name   = "ACPI";
         host->ops       = &sdhci_acpi_ops_dflt;
         host->irq       = platform_get_irq(pdev, 0);
-        if (host->irq <= 0) {
+        if (host->irq < 0) {
                 err = -EINVAL;
                 goto err_free;
         }
diff --git a/drivers/mtd/mtdchar.c b/drivers/mtd/mtdchar.c
index de8c902059b8..7d80a8bb96fe 100644
--- a/drivers/mtd/mtdchar.c
+++ b/drivers/mtd/mtdchar.c
@@ -479,7 +479,7 @@ static int shrink_ecclayout(struct mtd_info *mtd,
         for (i = 0; i < MTD_MAX_ECCPOS_ENTRIES;) {
                 u32 eccpos;
 
-                ret = mtd_ooblayout_ecc(mtd, section, &oobregion);
+                ret = mtd_ooblayout_ecc(mtd, section++, &oobregion);
                 if (ret < 0) {
                         if (ret != -ERANGE)
                                 return ret;
@@ -526,7 +526,7 @@ static int get_oobinfo(struct mtd_info *mtd, struct nand_oobinfo *to)
         for (i = 0; i < ARRAY_SIZE(to->eccpos);) {
                 u32 eccpos;
 
-                ret = mtd_ooblayout_ecc(mtd, section, &oobregion);
+                ret = mtd_ooblayout_ecc(mtd, section++, &oobregion);
                 if (ret < 0) {
                         if (ret != -ERANGE)
                                 return ret;
diff --git a/drivers/mtd/nand/fsl_ifc_nand.c b/drivers/mtd/nand/fsl_ifc_nand.c
index 4872a7ba6503..5a9c2f0020c2 100644
--- a/drivers/mtd/nand/fsl_ifc_nand.c
+++ b/drivers/mtd/nand/fsl_ifc_nand.c
@@ -173,14 +173,9 @@ static void set_addr(struct mtd_info *mtd, int column, int page_addr, int oob)
 
 /* returns nonzero if entire page is blank */
 static int check_read_ecc(struct mtd_info *mtd, struct fsl_ifc_ctrl *ctrl,
-                          u32 *eccstat, unsigned int bufnum)
+                          u32 eccstat, unsigned int bufnum)
 {
-        u32 reg = eccstat[bufnum / 4];
-        int errors;
-
-        errors = (reg >> ((3 - bufnum % 4) * 8)) & 15;
-
-        return errors;
+        return  (eccstat >> ((3 - bufnum % 4) * 8)) & 15;
 }
 
 /*
@@ -193,7 +188,7 @@ static void fsl_ifc_run_command(struct mtd_info *mtd)
         struct fsl_ifc_ctrl *ctrl = priv->ctrl;
         struct fsl_ifc_nand_ctrl *nctrl = ifc_nand_ctrl;
         struct fsl_ifc_runtime __iomem *ifc = ctrl->rregs;
-        u32 eccstat[4];
+        u32 eccstat;
         int i;
 
         /* set the chip select for NAND Transaction */
@@ -228,19 +223,17 @@ static void fsl_ifc_run_command(struct mtd_info *mtd)
         if (nctrl->eccread) {
                 int errors;
                 int bufnum = nctrl->page & priv->bufnum_mask;
-                int sector = bufnum * chip->ecc.steps;
-                int sector_end = sector + chip->ecc.steps - 1;
+                int sector_start = bufnum * chip->ecc.steps;
+                int sector_end = sector_start + chip->ecc.steps - 1;
                 __be32 *eccstat_regs;
 
-                if (ctrl->version >= FSL_IFC_VERSION_2_0_0)
-                        eccstat_regs = ifc->ifc_nand.v2_nand_eccstat;
-                else
-                        eccstat_regs = ifc->ifc_nand.v1_nand_eccstat;
+                eccstat_regs = ifc->ifc_nand.nand_eccstat;
+                eccstat = ifc_in32(&eccstat_regs[sector_start / 4]);
 
-                for (i = sector / 4; i <= sector_end / 4; i++)
-                        eccstat[i] = ifc_in32(&eccstat_regs[i]);
+                for (i = sector_start; i <= sector_end; i++) {
+                        if (i != sector_start && !(i % 4))
+                                eccstat = ifc_in32(&eccstat_regs[i / 4]);
 
-                for (i = sector; i <= sector_end; i++) {
                         errors = check_read_ecc(mtd, ctrl, eccstat, i);
 
                         if (errors == 15) {
@@ -626,6 +619,7 @@ static int fsl_ifc_wait(struct mtd_info *mtd, struct nand_chip *chip)
         struct fsl_ifc_ctrl *ctrl = priv->ctrl;
         struct fsl_ifc_runtime __iomem *ifc = ctrl->rregs;
         u32 nand_fsr;
+        int status;
 
         /* Use READ_STATUS command, but wait for the device to be ready */
         ifc_out32((IFC_FIR_OP_CW0 << IFC_NAND_FIR0_OP0_SHIFT) |
@@ -640,12 +634,12 @@ static int fsl_ifc_wait(struct mtd_info *mtd, struct nand_chip *chip)
         fsl_ifc_run_command(mtd);
 
         nand_fsr = ifc_in32(&ifc->ifc_nand.nand_fsr);
-
+        status = nand_fsr >> 24;
         /*
          * The chip always seems to report that it is
          * write-protected, even when it is not.
          */
-        return nand_fsr | NAND_STATUS_WP;
+        return status | NAND_STATUS_WP;
 }
 
 /*
diff --git a/drivers/net/can/cc770/cc770.c b/drivers/net/can/cc770/cc770.c
index 1e37313054f3..6da69af103e6 100644
--- a/drivers/net/can/cc770/cc770.c
+++ b/drivers/net/can/cc770/cc770.c
@@ -390,37 +390,23 @@ static int cc770_get_berr_counter(const struct net_device *dev,
         return 0;
 }
 
-static netdev_tx_t cc770_start_xmit(struct sk_buff *skb, struct net_device *dev)
+static void cc770_tx(struct net_device *dev, int mo)
 {
         struct cc770_priv *priv = netdev_priv(dev);
-        struct net_device_stats *stats = &dev->stats;
-        struct can_frame *cf = (struct can_frame *)skb->data;
-        unsigned int mo = obj2msgobj(CC770_OBJ_TX);
+        struct can_frame *cf = (struct can_frame *)priv->tx_skb->data;
         u8 dlc, rtr;
         u32 id;
         int i;
 
-        if (can_dropped_invalid_skb(dev, skb))
-                return NETDEV_TX_OK;
-
-        if ((cc770_read_reg(priv,
-                            msgobj[mo].ctrl1) & TXRQST_UNC) == TXRQST_SET) {
-                netdev_err(dev, "TX register is still occupied!\n");
-                return NETDEV_TX_BUSY;
-        }
-
-        netif_stop_queue(dev);
-
         dlc = cf->can_dlc;
         id = cf->can_id;
-        if (cf->can_id & CAN_RTR_FLAG)
-                rtr = 0;
-        else
-                rtr = MSGCFG_DIR;
+        rtr = cf->can_id & CAN_RTR_FLAG ? 0 : MSGCFG_DIR;
+
+        cc770_write_reg(priv, msgobj[mo].ctrl0,
+                        MSGVAL_RES | TXIE_RES | RXIE_RES | INTPND_RES);
         cc770_write_reg(priv, msgobj[mo].ctrl1,
                         RMTPND_RES | TXRQST_RES | CPUUPD_SET | NEWDAT_RES);
-        cc770_write_reg(priv, msgobj[mo].ctrl0,
-                        MSGVAL_SET | TXIE_SET | RXIE_RES | INTPND_RES);
+
         if (id & CAN_EFF_FLAG) {
                 id &= CAN_EFF_MASK;
                 cc770_write_reg(priv, msgobj[mo].config,
@@ -439,22 +425,30 @@ static netdev_tx_t cc770_start_xmit(struct sk_buff *skb, struct net_device *dev)
         for (i = 0; i < dlc; i++)
                 cc770_write_reg(priv, msgobj[mo].data[i], cf->data[i]);
 
-        /* Store echo skb before starting the transfer */
-        can_put_echo_skb(skb, dev, 0);
-
         cc770_write_reg(priv, msgobj[mo].ctrl1,
-                        RMTPND_RES | TXRQST_SET | CPUUPD_RES | NEWDAT_UNC);
+                        RMTPND_UNC | TXRQST_SET | CPUUPD_RES | NEWDAT_UNC);
+        cc770_write_reg(priv, msgobj[mo].ctrl0,
+                        MSGVAL_SET | TXIE_SET | RXIE_SET | INTPND_UNC);
+}
 
-        stats->tx_bytes += dlc;
+static netdev_tx_t cc770_start_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+        struct cc770_priv *priv = netdev_priv(dev);
+        unsigned int mo = obj2msgobj(CC770_OBJ_TX);
 
+        if (can_dropped_invalid_skb(dev, skb))
+                return NETDEV_TX_OK;
 
-        /*
-         * HM: We had some cases of repeated IRQs so make sure the
-         * INT is acknowledged I know it's already further up, but
-         * doing again fixed the issue
-         */
-        cc770_write_reg(priv, msgobj[mo].ctrl0,
-                        MSGVAL_UNC | TXIE_UNC | RXIE_UNC | INTPND_RES);
+        netif_stop_queue(dev);
+
+        if ((cc770_read_reg(priv,
+                            msgobj[mo].ctrl1) & TXRQST_UNC) == TXRQST_SET) {
+                netdev_err(dev, "TX register is still occupied!\n");
+                return NETDEV_TX_BUSY;
+        }
+
+        priv->tx_skb = skb;
+        cc770_tx(dev, mo);
 
         return NETDEV_TX_OK;
 }
@@ -680,19 +674,46 @@ static void cc770_tx_interrupt(struct net_device *dev, unsigned int o)
         struct cc770_priv *priv = netdev_priv(dev);
         struct net_device_stats *stats = &dev->stats;
         unsigned int mo = obj2msgobj(o);
+        struct can_frame *cf;
+        u8 ctrl1;
+
+        ctrl1 = cc770_read_reg(priv, msgobj[mo].ctrl1);
 
-        /* Nothing more to send, switch off interrupts */
         cc770_write_reg(priv, msgobj[mo].ctrl0,
                         MSGVAL_RES | TXIE_RES | RXIE_RES | INTPND_RES);
-        /*
-         * We had some cases of repeated IRQ so make sure the
-         * INT is acknowledged
+        cc770_write_reg(priv, msgobj[mo].ctrl1,
+                        RMTPND_RES | TXRQST_RES | MSGLST_RES | NEWDAT_RES);
+
+        if (unlikely(!priv->tx_skb)) {
+                netdev_err(dev, "missing tx skb in tx interrupt\n");
+                return;
+        }
+
+        if (unlikely(ctrl1 & MSGLST_SET)) {
+                stats->rx_over_errors++;
+                stats->rx_errors++;
+        }
+
+        /* When the CC770 is sending an RTR message and it receives a regular
+         * message that matches the id of the RTR message, it will overwrite the
+         * outgoing message in the TX register. When this happens we must
+         * process the received message and try to transmit the outgoing skb
+         * again.
          */
-        cc770_write_reg(priv, msgobj[mo].ctrl0,
-                        MSGVAL_UNC | TXIE_UNC | RXIE_UNC | INTPND_RES);
+        if (unlikely(ctrl1 & NEWDAT_SET)) {
+                cc770_rx(dev, mo, ctrl1);
+                cc770_tx(dev, mo);
+                return;
+        }
 
+        cf = (struct can_frame *)priv->tx_skb->data;
+        stats->tx_bytes += cf->can_dlc;
         stats->tx_packets++;
+
+        can_put_echo_skb(priv->tx_skb, dev, 0);
         can_get_echo_skb(dev, 0);
+        priv->tx_skb = NULL;
+
         netif_wake_queue(dev);
 }
 
@@ -804,6 +825,7 @@ struct net_device *alloc_cc770dev(int sizeof_priv)
         priv->can.do_set_bittiming = cc770_set_bittiming;
         priv->can.do_set_mode = cc770_set_mode;
         priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES;
+        priv->tx_skb = NULL;
 
         memcpy(priv->obj_flags, cc770_obj_flags, sizeof(cc770_obj_flags));
 
diff --git a/drivers/net/can/cc770/cc770.h b/drivers/net/can/cc770/cc770.h
index a1739db98d91..95752e1d1283 100644
--- a/drivers/net/can/cc770/cc770.h
+++ b/drivers/net/can/cc770/cc770.h
@@ -193,6 +193,8 @@ struct cc770_priv {
         u8 cpu_interface;       /* CPU interface register */
         u8 clkout;              /* Clock out register */
         u8 bus_config;          /* Bus conffiguration register */
+
+        struct sk_buff *tx_skb;
 };
 
 struct net_device *alloc_cc770dev(int sizeof_priv);
diff --git a/drivers/net/can/ifi_canfd/ifi_canfd.c b/drivers/net/can/ifi_canfd/ifi_canfd.c
index 2772d05ff11c..fedd927ba6ed 100644
--- a/drivers/net/can/ifi_canfd/ifi_canfd.c
+++ b/drivers/net/can/ifi_canfd/ifi_canfd.c
@@ -30,6 +30,7 @@
 #define IFI_CANFD_STCMD_ERROR_ACTIVE            BIT(2)
 #define IFI_CANFD_STCMD_ERROR_PASSIVE           BIT(3)
 #define IFI_CANFD_STCMD_BUSOFF                  BIT(4)
+#define IFI_CANFD_STCMD_ERROR_WARNING           BIT(5)
 #define IFI_CANFD_STCMD_BUSMONITOR              BIT(16)
 #define IFI_CANFD_STCMD_LOOPBACK                BIT(18)
 #define IFI_CANFD_STCMD_DISABLE_CANFD           BIT(24)
@@ -52,7 +53,10 @@
 #define IFI_CANFD_TXSTCMD_OVERFLOW              BIT(13)
 
 #define IFI_CANFD_INTERRUPT                     0xc
+#define IFI_CANFD_INTERRUPT_ERROR_BUSOFF        BIT(0)
 #define IFI_CANFD_INTERRUPT_ERROR_WARNING       BIT(1)
+#define IFI_CANFD_INTERRUPT_ERROR_STATE_CHG     BIT(2)
+#define IFI_CANFD_INTERRUPT_ERROR_REC_TEC_INC   BIT(3)
 #define IFI_CANFD_INTERRUPT_ERROR_COUNTER       BIT(10)
 #define IFI_CANFD_INTERRUPT_TXFIFO_EMPTY        BIT(16)
 #define IFI_CANFD_INTERRUPT_TXFIFO_REMOVE       BIT(22)
@@ -61,6 +65,10 @@
 #define IFI_CANFD_INTERRUPT_SET_IRQ             ((u32)BIT(31))
 
 #define IFI_CANFD_IRQMASK                       0x10
+#define IFI_CANFD_IRQMASK_ERROR_BUSOFF          BIT(0)
+#define IFI_CANFD_IRQMASK_ERROR_WARNING         BIT(1)
+#define IFI_CANFD_IRQMASK_ERROR_STATE_CHG       BIT(2)
+#define IFI_CANFD_IRQMASK_ERROR_REC_TEC_INC     BIT(3)
 #define IFI_CANFD_IRQMASK_SET_ERR               BIT(7)
 #define IFI_CANFD_IRQMASK_SET_TS                BIT(15)
 #define IFI_CANFD_IRQMASK_TXFIFO_EMPTY          BIT(16)
@@ -136,6 +144,8 @@
 #define IFI_CANFD_SYSCLOCK                      0x50
 
 #define IFI_CANFD_VER                           0x54
+#define IFI_CANFD_VER_REV_MASK                  0xff
+#define IFI_CANFD_VER_REV_MIN_SUPPORTED         0x15
 
 #define IFI_CANFD_IP_ID                         0x58
 #define IFI_CANFD_IP_ID_VALUE                   0xD073CAFD
@@ -220,7 +230,10 @@ static void ifi_canfd_irq_enable(struct net_device *ndev, bool enable)
 
         if (enable) {
                 enirq = IFI_CANFD_IRQMASK_TXFIFO_EMPTY |
-                        IFI_CANFD_IRQMASK_RXFIFO_NEMPTY;
+                        IFI_CANFD_IRQMASK_RXFIFO_NEMPTY |
+                        IFI_CANFD_IRQMASK_ERROR_STATE_CHG |
+                        IFI_CANFD_IRQMASK_ERROR_WARNING |
+                        IFI_CANFD_IRQMASK_ERROR_BUSOFF;
                 if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
                         enirq |= IFI_CANFD_INTERRUPT_ERROR_COUNTER;
         }
@@ -361,12 +374,13 @@ static int ifi_canfd_handle_lost_msg(struct net_device *ndev)
         return 1;
 }
 
-static int ifi_canfd_handle_lec_err(struct net_device *ndev, const u32 errctr)
+static int ifi_canfd_handle_lec_err(struct net_device *ndev)
 {
         struct ifi_canfd_priv *priv = netdev_priv(ndev);
         struct net_device_stats *stats = &ndev->stats;
         struct can_frame *cf;
         struct sk_buff *skb;
+        u32 errctr = readl(priv->base + IFI_CANFD_ERROR_CTR);
         const u32 errmask = IFI_CANFD_ERROR_CTR_OVERLOAD_FIRST |
                             IFI_CANFD_ERROR_CTR_ACK_ERROR_FIRST |
                             IFI_CANFD_ERROR_CTR_BIT0_ERROR_FIRST |
@@ -449,6 +463,11 @@ static int ifi_canfd_handle_state_change(struct net_device *ndev,
 
         switch (new_state) {
         case CAN_STATE_ERROR_ACTIVE:
+                /* error active state */
+                priv->can.can_stats.error_warning++;
+                priv->can.state = CAN_STATE_ERROR_ACTIVE;
+                break;
+        case CAN_STATE_ERROR_WARNING:
                 /* error warning state */
                 priv->can.can_stats.error_warning++;
                 priv->can.state = CAN_STATE_ERROR_WARNING;
@@ -477,7 +496,7 @@ static int ifi_canfd_handle_state_change(struct net_device *ndev,
         ifi_canfd_get_berr_counter(ndev, &bec);
 
         switch (new_state) {
-        case CAN_STATE_ERROR_ACTIVE:
+        case CAN_STATE_ERROR_WARNING:
                 /* error warning state */
                 cf->can_id |= CAN_ERR_CRTL;
                 cf->data[1] = (bec.txerr > bec.rxerr) ?
@@ -510,22 +529,21 @@ static int ifi_canfd_handle_state_change(struct net_device *ndev,
         return 1;
 }
 
-static int ifi_canfd_handle_state_errors(struct net_device *ndev, u32 stcmd)
+static int ifi_canfd_handle_state_errors(struct net_device *ndev)
 {
         struct ifi_canfd_priv *priv = netdev_priv(ndev);
+        u32 stcmd = readl(priv->base + IFI_CANFD_STCMD);
         int work_done = 0;
-        u32 isr;
 
-        /*
-         * The ErrWarn condition is a little special, since the bit is
-         * located in the INTERRUPT register instead of STCMD register.
-         */
-        isr = readl(priv->base + IFI_CANFD_INTERRUPT);
-        if ((isr & IFI_CANFD_INTERRUPT_ERROR_WARNING) &&
+        if ((stcmd & IFI_CANFD_STCMD_ERROR_ACTIVE) &&
+            (priv->can.state != CAN_STATE_ERROR_ACTIVE)) {
+                netdev_dbg(ndev, "Error, entered active state\n");
+                work_done += ifi_canfd_handle_state_change(ndev,
+                                                CAN_STATE_ERROR_ACTIVE);
+        }
+
+        if ((stcmd & IFI_CANFD_STCMD_ERROR_WARNING) &&
             (priv->can.state != CAN_STATE_ERROR_WARNING)) {
-                /* Clear the interrupt */
-                writel(IFI_CANFD_INTERRUPT_ERROR_WARNING,
-                       priv->base + IFI_CANFD_INTERRUPT);
                 netdev_dbg(ndev, "Error, entered warning state\n");
                 work_done += ifi_canfd_handle_state_change(ndev,
                                                 CAN_STATE_ERROR_WARNING);
@@ -552,18 +570,11 @@ static int ifi_canfd_poll(struct napi_struct *napi, int quota)
 {
         struct net_device *ndev = napi->dev;
         struct ifi_canfd_priv *priv = netdev_priv(ndev);
-        const u32 stcmd_state_mask = IFI_CANFD_STCMD_ERROR_PASSIVE |
-                                     IFI_CANFD_STCMD_BUSOFF;
-        int work_done = 0;
-
-        u32 stcmd = readl(priv->base + IFI_CANFD_STCMD);
         u32 rxstcmd = readl(priv->base + IFI_CANFD_RXSTCMD);
-        u32 errctr = readl(priv->base + IFI_CANFD_ERROR_CTR);
+        int work_done = 0;
 
         /* Handle bus state changes */
-        if ((stcmd & stcmd_state_mask) ||
-            ((stcmd & IFI_CANFD_STCMD_ERROR_ACTIVE) == 0))
-                work_done += ifi_canfd_handle_state_errors(ndev, stcmd);
+        work_done += ifi_canfd_handle_state_errors(ndev);
 
         /* Handle lost messages on RX */
         if (rxstcmd & IFI_CANFD_RXSTCMD_OVERFLOW)
@@ -571,7 +582,7 @@ static int ifi_canfd_poll(struct napi_struct *napi, int quota)
 
         /* Handle lec errors on the bus */
         if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
-                work_done += ifi_canfd_handle_lec_err(ndev, errctr);
+                work_done += ifi_canfd_handle_lec_err(ndev);
 
         /* Handle normal messages on RX */
         if (!(rxstcmd & IFI_CANFD_RXSTCMD_EMPTY))
@@ -592,12 +603,13 @@ static irqreturn_t ifi_canfd_isr(int irq, void *dev_id)
         struct net_device_stats *stats = &ndev->stats;
         const u32 rx_irq_mask = IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY |
                                 IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY_PER |
+                                IFI_CANFD_INTERRUPT_ERROR_COUNTER |
+                                IFI_CANFD_INTERRUPT_ERROR_STATE_CHG |
                                 IFI_CANFD_INTERRUPT_ERROR_WARNING |
-                                IFI_CANFD_INTERRUPT_ERROR_COUNTER;
+                                IFI_CANFD_INTERRUPT_ERROR_BUSOFF;
         const u32 tx_irq_mask = IFI_CANFD_INTERRUPT_TXFIFO_EMPTY |
                                 IFI_CANFD_INTERRUPT_TXFIFO_REMOVE;
-        const u32 clr_irq_mask = ~((u32)(IFI_CANFD_INTERRUPT_SET_IRQ |
-                                         IFI_CANFD_INTERRUPT_ERROR_WARNING));
+        const u32 clr_irq_mask = ~((u32)IFI_CANFD_INTERRUPT_SET_IRQ);
         u32 isr;
 
         isr = readl(priv->base + IFI_CANFD_INTERRUPT);
@@ -933,7 +945,7 @@ static int ifi_canfd_plat_probe(struct platform_device *pdev)
         struct resource *res;
         void __iomem *addr;
         int irq, ret;
-        u32 id;
+        u32 id, rev;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         addr = devm_ioremap_resource(dev, res);
@@ -947,6 +959,13 @@ static int ifi_canfd_plat_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
+        rev = readl(addr + IFI_CANFD_VER) & IFI_CANFD_VER_REV_MASK;
+        if (rev < IFI_CANFD_VER_REV_MIN_SUPPORTED) {
+                dev_err(dev, "This block is too old (rev %i), minimum supported is rev %i\n",
+                        rev, IFI_CANFD_VER_REV_MIN_SUPPORTED);
+                return -EINVAL;
+        }
+
         ndev = alloc_candev(sizeof(*priv), 1);
         if (!ndev)
                 return -ENOMEM;
diff --git a/drivers/net/can/m_can/m_can.c b/drivers/net/can/m_can/m_can.c
index 2594f7779c6f..b397a33f3d32 100644
--- a/drivers/net/can/m_can/m_can.c
+++ b/drivers/net/can/m_can/m_can.c
@@ -26,6 +26,7 @@
 #include <linux/pm_runtime.h>
 #include <linux/iopoll.h>
 #include <linux/can/dev.h>
+#include <linux/pinctrl/consumer.h>
 
 /* napi related */
 #define M_CAN_NAPI_WEIGHT       64
@@ -253,7 +254,7 @@ enum m_can_mram_cfg {
 
 /* Rx FIFO 0/1 Configuration (RXF0C/RXF1C) */
 #define RXFC_FWM_SHIFT  24
-#define RXFC_FWM_MASK   (0x7f < RXFC_FWM_SHIFT)
+#define RXFC_FWM_MASK   (0x7f << RXFC_FWM_SHIFT)
 #define RXFC_FS_SHIFT   16
 #define RXFC_FS_MASK    (0x7f << RXFC_FS_SHIFT)
 
@@ -1700,6 +1701,8 @@ static __maybe_unused int m_can_suspend(struct device *dev)
                 m_can_clk_stop(priv);
         }
 
+        pinctrl_pm_select_sleep_state(dev);
+
         priv->can.state = CAN_STATE_SLEEPING;
 
         return 0;
@@ -1710,6 +1713,8 @@ static __maybe_unused int m_can_resume(struct device *dev)
         struct net_device *ndev = dev_get_drvdata(dev);
         struct m_can_priv *priv = netdev_priv(ndev);
 
+        pinctrl_pm_select_default_state(dev);
+
         m_can_init_ram(priv);
 
         priv->can.state = CAN_STATE_ERROR_ACTIVE;
diff --git a/drivers/net/can/peak_canfd/peak_canfd.c b/drivers/net/can/peak_canfd/peak_canfd.c
index 55513411a82e..ed8561d4a90f 100644
--- a/drivers/net/can/peak_canfd/peak_canfd.c
+++ b/drivers/net/can/peak_canfd/peak_canfd.c
@@ -262,7 +262,6 @@ static int pucan_handle_can_rx(struct peak_canfd_priv *priv,
 
                 spin_lock_irqsave(&priv->echo_lock, flags);
                 can_get_echo_skb(priv->ndev, msg->client);
-                spin_unlock_irqrestore(&priv->echo_lock, flags);
 
                 /* count bytes of the echo instead of skb */
                 stats->tx_bytes += cf_len;
@@ -271,6 +270,7 @@ static int pucan_handle_can_rx(struct peak_canfd_priv *priv,
                 /* restart tx queue (a slot is free) */
                 netif_wake_queue(priv->ndev);
 
+                spin_unlock_irqrestore(&priv->echo_lock, flags);
                 return 0;
         }
 
@@ -333,7 +333,6 @@ static int pucan_handle_status(struct peak_canfd_priv *priv,
 
         /* this STATUS is the CNF of the RX_BARRIER: Tx path can be setup */
         if (pucan_status_is_rx_barrier(msg)) {
-                unsigned long flags;
 
                 if (priv->enable_tx_path) {
                         int err = priv->enable_tx_path(priv);
@@ -342,16 +341,8 @@ static int pucan_handle_status(struct peak_canfd_priv *priv,
                                 return err;
                 }
 
-                /* restart network queue only if echo skb array is free */
-                spin_lock_irqsave(&priv->echo_lock, flags);
-
-                if (!priv->can.echo_skb[priv->echo_idx]) {
-                        spin_unlock_irqrestore(&priv->echo_lock, flags);
-
-                        netif_wake_queue(ndev);
-                } else {
-                        spin_unlock_irqrestore(&priv->echo_lock, flags);
-                }
+                /* start network queue (echo_skb array is empty) */
+                netif_start_queue(ndev);
 
                 return 0;
         }
@@ -726,11 +717,6 @@ static netdev_tx_t peak_canfd_start_xmit(struct sk_buff *skb,
          */
         should_stop_tx_queue = !!(priv->can.echo_skb[priv->echo_idx]);
 
-        spin_unlock_irqrestore(&priv->echo_lock, flags);
-
-        /* write the skb on the interface */
-        priv->write_tx_msg(priv, msg);
-
         /* stop network tx queue if not enough room to save one more msg too */
         if (priv->can.ctrlmode & CAN_CTRLMODE_FD)
                 should_stop_tx_queue |= (room_left <
@@ -742,6 +728,11 @@ static netdev_tx_t peak_canfd_start_xmit(struct sk_buff *skb,
         if (should_stop_tx_queue)
                 netif_stop_queue(ndev);
 
+        spin_unlock_irqrestore(&priv->echo_lock, flags);
+
+        /* write the skb on the interface */
+        priv->write_tx_msg(priv, msg);
+
         return NETDEV_TX_OK;
 }
 
diff --git a/drivers/net/can/peak_canfd/peak_pciefd_main.c b/drivers/net/can/peak_canfd/peak_pciefd_main.c
index 788c3464a3b0..3c51a884db87 100644
--- a/drivers/net/can/peak_canfd/peak_pciefd_main.c
+++ b/drivers/net/can/peak_canfd/peak_pciefd_main.c
@@ -349,8 +349,12 @@ static irqreturn_t pciefd_irq_handler(int irq, void *arg)
                 priv->tx_pages_free++;
                 spin_unlock_irqrestore(&priv->tx_lock, flags);
 
-                /* wake producer up */
-                netif_wake_queue(priv->ucan.ndev);
+                /* wake producer up (only if enough room in echo_skb array) */
+                spin_lock_irqsave(&priv->ucan.echo_lock, flags);
+                if (!priv->ucan.can.echo_skb[priv->ucan.echo_idx])
+                        netif_wake_queue(priv->ucan.ndev);
+
+                spin_unlock_irqrestore(&priv->ucan.echo_lock, flags);
         }
 
         /* re-enable Rx DMA transfer for this CAN */
diff --git a/drivers/net/dsa/Makefile b/drivers/net/dsa/Makefile
index d040aeb45172..15c2a831edf1 100644
--- a/drivers/net/dsa/Makefile
+++ b/drivers/net/dsa/Makefile
@@ -1,7 +1,10 @@
 # SPDX-License-Identifier: GPL-2.0
 obj-$(CONFIG_NET_DSA_BCM_SF2)   += bcm-sf2.o
 bcm-sf2-objs                    := bcm_sf2.o bcm_sf2_cfp.o
-obj-$(CONFIG_NET_DSA_LOOP)      += dsa_loop.o dsa_loop_bdinfo.o
+obj-$(CONFIG_NET_DSA_LOOP)      += dsa_loop.o
+ifdef CONFIG_NET_DSA_LOOP
+obj-$(CONFIG_FIXED_PHY)         += dsa_loop_bdinfo.o
+endif
 obj-$(CONFIG_NET_DSA_MT7530)    += mt7530.o
 obj-$(CONFIG_NET_DSA_MV88E6060) += mv88e6060.o
 obj-$(CONFIG_NET_DSA_QCA8K)     += qca8k.o
diff --git a/drivers/net/dsa/b53/b53_common.c b/drivers/net/dsa/b53/b53_common.c
index db830a1141d9..63e02a54d537 100644
--- a/drivers/net/dsa/b53/b53_common.c
+++ b/drivers/net/dsa/b53/b53_common.c
@@ -814,8 +814,8 @@ void b53_get_strings(struct dsa_switch *ds, int port, uint8_t *data)
         unsigned int i;
 
         for (i = 0; i < mib_size; i++)
-                memcpy(data + i * ETH_GSTRING_LEN,
-                       mibs[i].name, ETH_GSTRING_LEN);
+                strlcpy(data + i * ETH_GSTRING_LEN,
+                        mibs[i].name, ETH_GSTRING_LEN);
 }
 EXPORT_SYMBOL(b53_get_strings);
 
diff --git a/drivers/net/ethernet/8390/Kconfig b/drivers/net/ethernet/8390/Kconfig
index 29c3075bfb05..fdc673484add 100644
--- a/drivers/net/ethernet/8390/Kconfig
+++ b/drivers/net/ethernet/8390/Kconfig
@@ -3,7 +3,7 @@
 #
 
 config NET_VENDOR_8390
-        bool "National Semi-conductor 8390 devices"
+        bool "National Semiconductor 8390 devices"
         default y
         depends on NET_VENDOR_NATSEMI
         ---help---
diff --git a/drivers/net/ethernet/aquantia/atlantic/aq_cfg.h b/drivers/net/ethernet/aquantia/atlantic/aq_cfg.h
index 0b49f1aeebd3..fc7383106946 100644
--- a/drivers/net/ethernet/aquantia/atlantic/aq_cfg.h
+++ b/drivers/net/ethernet/aquantia/atlantic/aq_cfg.h
@@ -36,6 +36,8 @@
 #define AQ_CFG_TX_FRAME_MAX  (16U * 1024U)
 #define AQ_CFG_RX_FRAME_MAX  (4U * 1024U)
 
+#define AQ_CFG_TX_CLEAN_BUDGET 256U
+
 /* LRO */
 #define AQ_CFG_IS_LRO_DEF           1U
 
diff --git a/drivers/net/ethernet/aquantia/atlantic/aq_nic.c b/drivers/net/ethernet/aquantia/atlantic/aq_nic.c
index ebbaf63eaf47..c96a92118b8b 100644
--- a/drivers/net/ethernet/aquantia/atlantic/aq_nic.c
+++ b/drivers/net/ethernet/aquantia/atlantic/aq_nic.c
@@ -247,6 +247,8 @@ void aq_nic_ndev_init(struct aq_nic_s *self)
         self->ndev->hw_features |= aq_hw_caps->hw_features;
         self->ndev->features = aq_hw_caps->hw_features;
         self->ndev->priv_flags = aq_hw_caps->hw_priv_flags;
+        self->ndev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
+
         self->ndev->mtu = aq_nic_cfg->mtu - ETH_HLEN;
         self->ndev->max_mtu = aq_hw_caps->mtu - ETH_FCS_LEN - ETH_HLEN;
 
@@ -937,3 +939,23 @@ err_exit:
 out:
         return err;
 }
+
+void aq_nic_shutdown(struct aq_nic_s *self)
+{
+        int err = 0;
+
+        if (!self->ndev)
+                return;
+
+        rtnl_lock();
+
+        netif_device_detach(self->ndev);
+
+        err = aq_nic_stop(self);
+        if (err < 0)
+                goto err_exit;
+        aq_nic_deinit(self);
+
+err_exit:
+        rtnl_unlock();
+}
\ No newline at end of file
diff --git a/drivers/net/ethernet/aquantia/atlantic/aq_nic.h b/drivers/net/ethernet/aquantia/atlantic/aq_nic.h
index d16b0f1a95aa..219b550d1665 100644
--- a/drivers/net/ethernet/aquantia/atlantic/aq_nic.h
+++ b/drivers/net/ethernet/aquantia/atlantic/aq_nic.h
@@ -118,5 +118,6 @@ struct aq_nic_cfg_s *aq_nic_get_cfg(struct aq_nic_s *self);
 u32 aq_nic_get_fw_version(struct aq_nic_s *self);
 int aq_nic_change_pm_state(struct aq_nic_s *self, pm_message_t *pm_msg);
 int aq_nic_update_interrupt_moderation_settings(struct aq_nic_s *self);
+void aq_nic_shutdown(struct aq_nic_s *self);
 
 #endif /* AQ_NIC_H */
diff --git a/drivers/net/ethernet/aquantia/atlantic/aq_pci_func.c b/drivers/net/ethernet/aquantia/atlantic/aq_pci_func.c
index 87c4308b52a7..ecc6306f940f 100644
--- a/drivers/net/ethernet/aquantia/atlantic/aq_pci_func.c
+++ b/drivers/net/ethernet/aquantia/atlantic/aq_pci_func.c
@@ -323,6 +323,20 @@ static void aq_pci_remove(struct pci_dev *pdev)
         pci_disable_device(pdev);
 }
 
+static void aq_pci_shutdown(struct pci_dev *pdev)
+{
+        struct aq_nic_s *self = pci_get_drvdata(pdev);
+
+        aq_nic_shutdown(self);
+
+        pci_disable_device(pdev);
+
+        if (system_state == SYSTEM_POWER_OFF) {
+                pci_wake_from_d3(pdev, false);
+                pci_set_power_state(pdev, PCI_D3hot);
+        }
+}
+
 static int aq_pci_suspend(struct pci_dev *pdev, pm_message_t pm_msg)
 {
         struct aq_nic_s *self = pci_get_drvdata(pdev);
@@ -345,6 +359,7 @@ static struct pci_driver aq_pci_ops = {
         .remove = aq_pci_remove,
         .suspend = aq_pci_suspend,
         .resume = aq_pci_resume,
+        .shutdown = aq_pci_shutdown,
 };
 
 module_pci_driver(aq_pci_ops);
diff --git a/drivers/net/ethernet/aquantia/atlantic/aq_ring.c b/drivers/net/ethernet/aquantia/atlantic/aq_ring.c
index 0be6a11370bb..b5f1f62e8e25 100644
--- a/drivers/net/ethernet/aquantia/atlantic/aq_ring.c
+++ b/drivers/net/ethernet/aquantia/atlantic/aq_ring.c
@@ -136,11 +136,12 @@ void aq_ring_queue_stop(struct aq_ring_s *ring)
                 netif_stop_subqueue(ndev, ring->idx);
 }
 
-void aq_ring_tx_clean(struct aq_ring_s *self)
+bool aq_ring_tx_clean(struct aq_ring_s *self)
 {
         struct device *dev = aq_nic_get_dev(self->aq_nic);
+        unsigned int budget = AQ_CFG_TX_CLEAN_BUDGET;
 
-        for (; self->sw_head != self->hw_head;
+        for (; self->sw_head != self->hw_head && budget--;
                 self->sw_head = aq_ring_next_dx(self, self->sw_head)) {
                 struct aq_ring_buff_s *buff = &self->buff_ring[self->sw_head];
 
@@ -167,6 +168,8 @@ void aq_ring_tx_clean(struct aq_ring_s *self)
                 buff->pa = 0U;
                 buff->eop_index = 0xffffU;
         }
+
+        return !!budget;
 }
 
 #define AQ_SKB_ALIGN SKB_DATA_ALIGN(sizeof(struct skb_shared_info))
diff --git a/drivers/net/ethernet/aquantia/atlantic/aq_ring.h b/drivers/net/ethernet/aquantia/atlantic/aq_ring.h
index 965fae0fb6e0..ac1329f4051d 100644
--- a/drivers/net/ethernet/aquantia/atlantic/aq_ring.h
+++ b/drivers/net/ethernet/aquantia/atlantic/aq_ring.h
@@ -153,7 +153,7 @@ void aq_ring_free(struct aq_ring_s *self);
 void aq_ring_update_queue_state(struct aq_ring_s *ring);
 void aq_ring_queue_wake(struct aq_ring_s *ring);
 void aq_ring_queue_stop(struct aq_ring_s *ring);
-void aq_ring_tx_clean(struct aq_ring_s *self);
+bool aq_ring_tx_clean(struct aq_ring_s *self);
 int aq_ring_rx_clean(struct aq_ring_s *self,
                      struct napi_struct *napi,
                      int *work_done,
diff --git a/drivers/net/ethernet/aquantia/atlantic/aq_vec.c b/drivers/net/ethernet/aquantia/atlantic/aq_vec.c
index f890b8a5a862..d335c334fa56 100644
--- a/drivers/net/ethernet/aquantia/atlantic/aq_vec.c
+++ b/drivers/net/ethernet/aquantia/atlantic/aq_vec.c
@@ -35,12 +35,12 @@ struct aq_vec_s {
 static int aq_vec_poll(struct napi_struct *napi, int budget)
 {
         struct aq_vec_s *self = container_of(napi, struct aq_vec_s, napi);
+        unsigned int sw_tail_old = 0U;
         struct aq_ring_s *ring = NULL;
+        bool was_tx_cleaned = true;
+        unsigned int i = 0U;
         int work_done = 0;
         int err = 0;
-        unsigned int i = 0U;
-        unsigned int sw_tail_old = 0U;
-        bool was_tx_cleaned = false;
 
         if (!self) {
                 err = -EINVAL;
@@ -57,9 +57,8 @@ static int aq_vec_poll(struct napi_struct *napi, int budget)
 
                         if (ring[AQ_VEC_TX_ID].sw_head !=
                             ring[AQ_VEC_TX_ID].hw_head) {
-                                aq_ring_tx_clean(&ring[AQ_VEC_TX_ID]);
+                                was_tx_cleaned = aq_ring_tx_clean(&ring[AQ_VEC_TX_ID]);
                                 aq_ring_update_queue_state(&ring[AQ_VEC_TX_ID]);
-                                was_tx_cleaned = true;
                         }
 
                         err = self->aq_hw_ops->hw_ring_rx_receive(self->aq_hw,
@@ -90,7 +89,7 @@ static int aq_vec_poll(struct napi_struct *napi, int budget)
                         }
                 }
 
-                if (was_tx_cleaned)
+                if (!was_tx_cleaned)
                         work_done = budget;
 
                 if (work_done < budget) {
diff --git a/drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils.c b/drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils.c
index 967f0fd07fcf..d3b847ec7465 100644
--- a/drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils.c
+++ b/drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils.c
@@ -21,6 +21,10 @@
 
 #define HW_ATL_UCP_0X370_REG    0x0370U
 
+#define HW_ATL_MIF_CMD          0x0200U
+#define HW_ATL_MIF_ADDR         0x0208U
+#define HW_ATL_MIF_VAL          0x020CU
+
 #define HW_ATL_FW_SM_RAM        0x2U
 #define HW_ATL_MPI_FW_VERSION   0x18
 #define HW_ATL_MPI_CONTROL_ADR  0x0368U
@@ -79,16 +83,15 @@ int hw_atl_utils_initfw(struct aq_hw_s *self, const struct aq_fw_ops **fw_ops)
 
 static int hw_atl_utils_soft_reset_flb(struct aq_hw_s *self)
 {
+        u32 gsr, val;
         int k = 0;
-        u32 gsr;
 
         aq_hw_write_reg(self, 0x404, 0x40e1);
         AQ_HW_SLEEP(50);
 
         /* Cleanup SPI */
-        aq_hw_write_reg(self, 0x534, 0xA0);
-        aq_hw_write_reg(self, 0x100, 0x9F);
-        aq_hw_write_reg(self, 0x100, 0x809F);
+        val = aq_hw_read_reg(self, 0x53C);
+        aq_hw_write_reg(self, 0x53C, val | 0x10);
 
         gsr = aq_hw_read_reg(self, HW_ATL_GLB_SOFT_RES_ADR);
         aq_hw_write_reg(self, HW_ATL_GLB_SOFT_RES_ADR, (gsr & 0xBFFF) | 0x8000);
@@ -97,7 +100,14 @@ static int hw_atl_utils_soft_reset_flb(struct aq_hw_s *self)
         aq_hw_write_reg(self, 0x404, 0x80e0);
         aq_hw_write_reg(self, 0x32a8, 0x0);
         aq_hw_write_reg(self, 0x520, 0x1);
+
+        /* Reset SPI again because of possible interrupted SPI burst */
+        val = aq_hw_read_reg(self, 0x53C);
+        aq_hw_write_reg(self, 0x53C, val | 0x10);
         AQ_HW_SLEEP(10);
+        /* Clear SPI reset state */
+        aq_hw_write_reg(self, 0x53C, val & ~0x10);
+
         aq_hw_write_reg(self, 0x404, 0x180e0);
 
         for (k = 0; k < 1000; k++) {
@@ -141,13 +151,15 @@ static int hw_atl_utils_soft_reset_flb(struct aq_hw_s *self)
                 aq_pr_err("FW kickstart failed\n");
                 return -EIO;
         }
+        /* Old FW requires fixed delay after init */
+        AQ_HW_SLEEP(15);
 
         return 0;
 }
 
 static int hw_atl_utils_soft_reset_rbl(struct aq_hw_s *self)
 {
-        u32 gsr, rbl_status;
+        u32 gsr, val, rbl_status;
         int k;
 
         aq_hw_write_reg(self, 0x404, 0x40e1);
@@ -157,6 +169,10 @@ static int hw_atl_utils_soft_reset_rbl(struct aq_hw_s *self)
         /* Alter RBL status */
         aq_hw_write_reg(self, 0x388, 0xDEAD);
 
+        /* Cleanup SPI */
+        val = aq_hw_read_reg(self, 0x53C);
+        aq_hw_write_reg(self, 0x53C, val | 0x10);
+
         /* Global software reset*/
         hw_atl_rx_rx_reg_res_dis_set(self, 0U);
         hw_atl_tx_tx_reg_res_dis_set(self, 0U);
@@ -204,6 +220,8 @@ static int hw_atl_utils_soft_reset_rbl(struct aq_hw_s *self)
                 aq_pr_err("FW kickstart failed\n");
                 return -EIO;
         }
+        /* Old FW requires fixed delay after init */
+        AQ_HW_SLEEP(15);
 
         return 0;
 }
@@ -255,18 +273,22 @@ int hw_atl_utils_fw_downld_dwords(struct aq_hw_s *self, u32 a,
                 }
         }
 
-        aq_hw_write_reg(self, 0x00000208U, a);
-
-        for (++cnt; --cnt;) {
-                u32 i = 0U;
+        aq_hw_write_reg(self, HW_ATL_MIF_ADDR, a);
 
-                aq_hw_write_reg(self, 0x00000200U, 0x00008000U);
+        for (++cnt; --cnt && !err;) {
+                aq_hw_write_reg(self, HW_ATL_MIF_CMD, 0x00008000U);
 
-                for (i = 1024U;
-                        (0x100U & aq_hw_read_reg(self, 0x00000200U)) && --i;) {
-                }
+                if (IS_CHIP_FEATURE(REVISION_B1))
+                        AQ_HW_WAIT_FOR(a != aq_hw_read_reg(self,
+                                                           HW_ATL_MIF_ADDR),
+                                       1, 1000U);
+                else
+                        AQ_HW_WAIT_FOR(!(0x100 & aq_hw_read_reg(self,
+                                                           HW_ATL_MIF_CMD)),
+                                       1, 1000U);
 
-                *(p++) = aq_hw_read_reg(self, 0x0000020CU);
+                *(p++) = aq_hw_read_reg(self, HW_ATL_MIF_VAL);
+                a += 4;
         }
 
         hw_atl_reg_glb_cpu_sem_set(self, 1U, HW_ATL_FW_SM_RAM);
@@ -662,14 +684,18 @@ void hw_atl_utils_hw_chip_features_init(struct aq_hw_s *self, u32 *p)
         u32 val = hw_atl_reg_glb_mif_id_get(self);
         u32 mif_rev = val & 0xFFU;
 
-        if ((3U & mif_rev) == 1U) {
-                chip_features |=
-                        HAL_ATLANTIC_UTILS_CHIP_REVISION_A0 |
+        if ((0xFU & mif_rev) == 1U) {
+                chip_features |= HAL_ATLANTIC_UTILS_CHIP_REVISION_A0 |
                         HAL_ATLANTIC_UTILS_CHIP_MPI_AQ |
                         HAL_ATLANTIC_UTILS_CHIP_MIPS;
-        } else if ((3U & mif_rev) == 2U) {
-                chip_features |=
-                        HAL_ATLANTIC_UTILS_CHIP_REVISION_B0 |
+        } else if ((0xFU & mif_rev) == 2U) {
+                chip_features |= HAL_ATLANTIC_UTILS_CHIP_REVISION_B0 |
+                        HAL_ATLANTIC_UTILS_CHIP_MPI_AQ |
+                        HAL_ATLANTIC_UTILS_CHIP_MIPS |
+                        HAL_ATLANTIC_UTILS_CHIP_TPO2 |
+                        HAL_ATLANTIC_UTILS_CHIP_RPF2;
+        } else if ((0xFU & mif_rev) == 0xAU) {
+                chip_features |= HAL_ATLANTIC_UTILS_CHIP_REVISION_B1 |
                         HAL_ATLANTIC_UTILS_CHIP_MPI_AQ |
                         HAL_ATLANTIC_UTILS_CHIP_MIPS |
                         HAL_ATLANTIC_UTILS_CHIP_TPO2 |
diff --git a/drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils.h b/drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils.h
index 2c690947910a..cd8f18f39c61 100644
--- a/drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils.h
+++ b/drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils.h
@@ -161,6 +161,7 @@ struct __packed hw_aq_atl_utils_mbox {
 #define HAL_ATLANTIC_UTILS_CHIP_MPI_AQ       0x00000010U
 #define HAL_ATLANTIC_UTILS_CHIP_REVISION_A0  0x01000000U
 #define HAL_ATLANTIC_UTILS_CHIP_REVISION_B0  0x02000000U
+#define HAL_ATLANTIC_UTILS_CHIP_REVISION_B1  0x04000000U
 
 #define IS_CHIP_FEATURE(_F_) (HAL_ATLANTIC_UTILS_CHIP_##_F_ & \
         self->chip_features)
diff --git a/drivers/net/ethernet/aquantia/atlantic/ver.h b/drivers/net/ethernet/aquantia/atlantic/ver.h
index 5265b937677b..a445de6837a6 100644
--- a/drivers/net/ethernet/aquantia/atlantic/ver.h
+++ b/drivers/net/ethernet/aquantia/atlantic/ver.h
@@ -13,7 +13,7 @@
 #define NIC_MAJOR_DRIVER_VERSION           2
 #define NIC_MINOR_DRIVER_VERSION           0
 #define NIC_BUILD_DRIVER_VERSION           2
-#define NIC_REVISION_DRIVER_VERSION        0
+#define NIC_REVISION_DRIVER_VERSION        1
 
 #define AQ_CFG_DRV_VERSION_SUFFIX "-kern"
 
diff --git a/drivers/net/ethernet/arc/emac_rockchip.c b/drivers/net/ethernet/arc/emac_rockchip.c
index 16f9bee992fe..0f6576802607 100644
--- a/drivers/net/ethernet/arc/emac_rockchip.c
+++ b/drivers/net/ethernet/arc/emac_rockchip.c
@@ -169,8 +169,10 @@ static int emac_rockchip_probe(struct platform_device *pdev)
         /* Optional regulator for PHY */
         priv->regulator = devm_regulator_get_optional(dev, "phy");
         if (IS_ERR(priv->regulator)) {
-                if (PTR_ERR(priv->regulator) == -EPROBE_DEFER)
-                        return -EPROBE_DEFER;
+                if (PTR_ERR(priv->regulator) == -EPROBE_DEFER) {
+                        err = -EPROBE_DEFER;
+                        goto out_clk_disable;
+                }
                 dev_err(dev, "no regulator found\n");
                 priv->regulator = NULL;
         }
diff --git a/drivers/net/ethernet/broadcom/bcmsysport.c b/drivers/net/ethernet/broadcom/bcmsysport.c
index f15a8fc6dfc9..3fc549b88c43 100644
--- a/drivers/net/ethernet/broadcom/bcmsysport.c
+++ b/drivers/net/ethernet/broadcom/bcmsysport.c
@@ -855,10 +855,12 @@ static void bcm_sysport_tx_reclaim_one(struct bcm_sysport_tx_ring *ring,
 static unsigned int __bcm_sysport_tx_reclaim(struct bcm_sysport_priv *priv,
                                              struct bcm_sysport_tx_ring *ring)
 {
-        unsigned int c_index, last_c_index, last_tx_cn, num_tx_cbs;
         unsigned int pkts_compl = 0, bytes_compl = 0;
         struct net_device *ndev = priv->netdev;
+        unsigned int txbds_processed = 0;
         struct bcm_sysport_cb *cb;
+        unsigned int txbds_ready;
+        unsigned int c_index;
         u32 hw_ind;
 
         /* Clear status before servicing to reduce spurious interrupts */
@@ -871,29 +873,23 @@ static unsigned int __bcm_sysport_tx_reclaim(struct bcm_sysport_priv *priv,
         /* Compute how many descriptors have been processed since last call */
         hw_ind = tdma_readl(priv, TDMA_DESC_RING_PROD_CONS_INDEX(ring->index));
         c_index = (hw_ind >> RING_CONS_INDEX_SHIFT) & RING_CONS_INDEX_MASK;
-        ring->p_index = (hw_ind & RING_PROD_INDEX_MASK);
-
-        last_c_index = ring->c_index;
-        num_tx_cbs = ring->size;
-
-        c_index &= (num_tx_cbs - 1);
-
-        if (c_index >= last_c_index)
-                last_tx_cn = c_index - last_c_index;
-        else
-                last_tx_cn = num_tx_cbs - last_c_index + c_index;
+        txbds_ready = (c_index - ring->c_index) & RING_CONS_INDEX_MASK;
 
         netif_dbg(priv, tx_done, ndev,
-                  "ring=%d c_index=%d last_tx_cn=%d last_c_index=%d\n",
-                  ring->index, c_index, last_tx_cn, last_c_index);
+                  "ring=%d old_c_index=%u c_index=%u txbds_ready=%u\n",
+                  ring->index, ring->c_index, c_index, txbds_ready);
 
-        while (last_tx_cn-- > 0) {
-                cb = ring->cbs + last_c_index;
+        while (txbds_processed < txbds_ready) {
+                cb = &ring->cbs[ring->clean_index];
                 bcm_sysport_tx_reclaim_one(ring, cb, &bytes_compl, &pkts_compl);
 
                 ring->desc_count++;
-                last_c_index++;
-                last_c_index &= (num_tx_cbs - 1);
+                txbds_processed++;
+
+                if (likely(ring->clean_index < ring->size - 1))
+                        ring->clean_index++;
+                else
+                        ring->clean_index = 0;
         }
 
         u64_stats_update_begin(&priv->syncp);
@@ -1394,6 +1390,7 @@ static int bcm_sysport_init_tx_ring(struct bcm_sysport_priv *priv,
         netif_tx_napi_add(priv->netdev, &ring->napi, bcm_sysport_tx_poll, 64);
         ring->index = index;
         ring->size = size;
+        ring->clean_index = 0;
         ring->alloc_size = ring->size;
         ring->desc_cpu = p;
         ring->desc_count = ring->size;
diff --git a/drivers/net/ethernet/broadcom/bcmsysport.h b/drivers/net/ethernet/broadcom/bcmsysport.h
index f5a984c1c986..19c91c76e327 100644
--- a/drivers/net/ethernet/broadcom/bcmsysport.h
+++ b/drivers/net/ethernet/broadcom/bcmsysport.h
@@ -706,7 +706,7 @@ struct bcm_sysport_tx_ring {
         unsigned int    desc_count;     /* Number of descriptors */
         unsigned int    curr_desc;      /* Current descriptor */
         unsigned int    c_index;        /* Last consumer index */
-        unsigned int    p_index;        /* Current producer index */
+        unsigned int    clean_index;    /* Current clean index */
         struct bcm_sysport_cb *cbs;     /* Transmit control blocks */
         struct dma_desc *desc_cpu;      /* CPU view of the descriptor */
         struct bcm_sysport_priv *priv;  /* private context backpointer */
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
index 74fc9af4aadb..b8388e93520a 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
@@ -13913,7 +13913,7 @@ static void bnx2x_register_phc(struct bnx2x *bp)
         bp->ptp_clock = ptp_clock_register(&bp->ptp_clock_info, &bp->pdev->dev);
         if (IS_ERR(bp->ptp_clock)) {
                 bp->ptp_clock = NULL;
-                BNX2X_ERR("PTP clock registeration failed\n");
+                BNX2X_ERR("PTP clock registration failed\n");
         }
 }
 
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.c b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
index 1500243b9886..c7e5e6f09647 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
@@ -1439,7 +1439,7 @@ static inline struct sk_buff *bnxt_tpa_end(struct bnxt *bp,
             (skb->dev->features & NETIF_F_HW_VLAN_CTAG_RX)) {
                 u16 vlan_proto = tpa_info->metadata >>
                         RX_CMP_FLAGS2_METADATA_TPID_SFT;
-                u16 vtag = tpa_info->metadata & RX_CMP_FLAGS2_METADATA_VID_MASK;
+                u16 vtag = tpa_info->metadata & RX_CMP_FLAGS2_METADATA_TCI_MASK;
 
                 __vlan_hwaccel_put_tag(skb, htons(vlan_proto), vtag);
         }
@@ -1623,7 +1623,7 @@ static int bnxt_rx_pkt(struct bnxt *bp, struct bnxt_napi *bnapi, u32 *raw_cons,
              cpu_to_le32(RX_CMP_FLAGS2_META_FORMAT_VLAN)) &&
             (skb->dev->features & NETIF_F_HW_VLAN_CTAG_RX)) {
                 u32 meta_data = le32_to_cpu(rxcmp1->rx_cmp_meta_data);
-                u16 vtag = meta_data & RX_CMP_FLAGS2_METADATA_VID_MASK;
+                u16 vtag = meta_data & RX_CMP_FLAGS2_METADATA_TCI_MASK;
                 u16 vlan_proto = meta_data >> RX_CMP_FLAGS2_METADATA_TPID_SFT;
 
                 __vlan_hwaccel_put_tag(skb, htons(vlan_proto), vtag);
@@ -3847,6 +3847,9 @@ static int bnxt_hwrm_vnic_set_tpa(struct bnxt *bp, u16 vnic_id, u32 tpa_flags)
         struct bnxt_vnic_info *vnic = &bp->vnic_info[vnic_id];
         struct hwrm_vnic_tpa_cfg_input req = {0};
 
+        if (vnic->fw_vnic_id == INVALID_HW_RING_ID)
+                return 0;
+
         bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_VNIC_TPA_CFG, -1, -1);
 
         if (tpa_flags) {
@@ -4558,18 +4561,17 @@ int __bnxt_hwrm_get_tx_rings(struct bnxt *bp, u16 fid, int *tx_rings)
         return rc;
 }
 
-static int
-bnxt_hwrm_reserve_pf_rings(struct bnxt *bp, int tx_rings, int rx_rings,
-                           int ring_grps, int cp_rings, int vnics)
+static void
+__bnxt_hwrm_reserve_pf_rings(struct bnxt *bp, struct hwrm_func_cfg_input *req,
+                             int tx_rings, int rx_rings, int ring_grps,
+                             int cp_rings, int vnics)
 {
-        struct hwrm_func_cfg_input req = {0};
         u32 enables = 0;
-        int rc;
 
-        bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_CFG, -1, -1);
-        req.fid = cpu_to_le16(0xffff);
+        bnxt_hwrm_cmd_hdr_init(bp, req, HWRM_FUNC_CFG, -1, -1);
+        req->fid = cpu_to_le16(0xffff);
         enables |= tx_rings ? FUNC_CFG_REQ_ENABLES_NUM_TX_RINGS : 0;
-        req.num_tx_rings = cpu_to_le16(tx_rings);
+        req->num_tx_rings = cpu_to_le16(tx_rings);
         if (bp->flags & BNXT_FLAG_NEW_RM) {
                 enables |= rx_rings ? FUNC_CFG_REQ_ENABLES_NUM_RX_RINGS : 0;
                 enables |= cp_rings ? FUNC_CFG_REQ_ENABLES_NUM_CMPL_RINGS |
@@ -4578,16 +4580,53 @@ bnxt_hwrm_reserve_pf_rings(struct bnxt *bp, int tx_rings, int rx_rings,
                            FUNC_CFG_REQ_ENABLES_NUM_HW_RING_GRPS : 0;
                 enables |= vnics ? FUNC_VF_CFG_REQ_ENABLES_NUM_VNICS : 0;
 
-                req.num_rx_rings = cpu_to_le16(rx_rings);
-                req.num_hw_ring_grps = cpu_to_le16(ring_grps);
-                req.num_cmpl_rings = cpu_to_le16(cp_rings);
-                req.num_stat_ctxs = req.num_cmpl_rings;
-                req.num_vnics = cpu_to_le16(vnics);
+                req->num_rx_rings = cpu_to_le16(rx_rings);
+                req->num_hw_ring_grps = cpu_to_le16(ring_grps);
+                req->num_cmpl_rings = cpu_to_le16(cp_rings);
+                req->num_stat_ctxs = req->num_cmpl_rings;
+                req->num_vnics = cpu_to_le16(vnics);
         }
-        if (!enables)
+        req->enables = cpu_to_le32(enables);
+}
+
+static void
+__bnxt_hwrm_reserve_vf_rings(struct bnxt *bp,
+                             struct hwrm_func_vf_cfg_input *req, int tx_rings,
+                             int rx_rings, int ring_grps, int cp_rings,
+                             int vnics)
+{
+        u32 enables = 0;
+
+        bnxt_hwrm_cmd_hdr_init(bp, req, HWRM_FUNC_VF_CFG, -1, -1);
+        enables |= tx_rings ? FUNC_VF_CFG_REQ_ENABLES_NUM_TX_RINGS : 0;
+        enables |= rx_rings ? FUNC_VF_CFG_REQ_ENABLES_NUM_RX_RINGS : 0;
+        enables |= cp_rings ? FUNC_VF_CFG_REQ_ENABLES_NUM_CMPL_RINGS |
+                              FUNC_VF_CFG_REQ_ENABLES_NUM_STAT_CTXS : 0;
+        enables |= ring_grps ? FUNC_VF_CFG_REQ_ENABLES_NUM_HW_RING_GRPS : 0;
+        enables |= vnics ? FUNC_VF_CFG_REQ_ENABLES_NUM_VNICS : 0;
+
+        req->num_tx_rings = cpu_to_le16(tx_rings);
+        req->num_rx_rings = cpu_to_le16(rx_rings);
+        req->num_hw_ring_grps = cpu_to_le16(ring_grps);
+        req->num_cmpl_rings = cpu_to_le16(cp_rings);
+        req->num_stat_ctxs = req->num_cmpl_rings;
+        req->num_vnics = cpu_to_le16(vnics);
+
+        req->enables = cpu_to_le32(enables);
+}
+
+static int
+bnxt_hwrm_reserve_pf_rings(struct bnxt *bp, int tx_rings, int rx_rings,
+                           int ring_grps, int cp_rings, int vnics)
+{
+        struct hwrm_func_cfg_input req = {0};
+        int rc;
+
+        __bnxt_hwrm_reserve_pf_rings(bp, &req, tx_rings, rx_rings, ring_grps,
+                                     cp_rings, vnics);
+        if (!req.enables)
                 return 0;
 
-        req.enables = cpu_to_le32(enables);
         rc = hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
         if (rc)
                 return -ENOMEM;
@@ -4604,7 +4643,6 @@ bnxt_hwrm_reserve_vf_rings(struct bnxt *bp, int tx_rings, int rx_rings,
                            int ring_grps, int cp_rings, int vnics)
 {
         struct hwrm_func_vf_cfg_input req = {0};
-        u32 enables = 0;
         int rc;
 
         if (!(bp->flags & BNXT_FLAG_NEW_RM)) {
@@ -4612,22 +4650,8 @@ bnxt_hwrm_reserve_vf_rings(struct bnxt *bp, int tx_rings, int rx_rings,
                 return 0;
         }
 
-        bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_VF_CFG, -1, -1);
-        enables |= tx_rings ? FUNC_VF_CFG_REQ_ENABLES_NUM_TX_RINGS : 0;
-        enables |= rx_rings ? FUNC_VF_CFG_REQ_ENABLES_NUM_RX_RINGS : 0;
-        enables |= cp_rings ? FUNC_VF_CFG_REQ_ENABLES_NUM_CMPL_RINGS |
-                              FUNC_VF_CFG_REQ_ENABLES_NUM_STAT_CTXS : 0;
-        enables |= ring_grps ? FUNC_VF_CFG_REQ_ENABLES_NUM_HW_RING_GRPS : 0;
-        enables |= vnics ? FUNC_VF_CFG_REQ_ENABLES_NUM_VNICS : 0;
-
-        req.num_tx_rings = cpu_to_le16(tx_rings);
-        req.num_rx_rings = cpu_to_le16(rx_rings);
-        req.num_hw_ring_grps = cpu_to_le16(ring_grps);
-        req.num_cmpl_rings = cpu_to_le16(cp_rings);
-        req.num_stat_ctxs = req.num_cmpl_rings;
-        req.num_vnics = cpu_to_le16(vnics);
-
-        req.enables = cpu_to_le32(enables);
+        __bnxt_hwrm_reserve_vf_rings(bp, &req, tx_rings, rx_rings, ring_grps,
+                                     cp_rings, vnics);
         rc = hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
         if (rc)
                 return -ENOMEM;
@@ -4743,39 +4767,25 @@ static bool bnxt_need_reserve_rings(struct bnxt *bp)
 }
 
 static int bnxt_hwrm_check_vf_rings(struct bnxt *bp, int tx_rings, int rx_rings,
-                                    int ring_grps, int cp_rings)
+                                    int ring_grps, int cp_rings, int vnics)
 {
         struct hwrm_func_vf_cfg_input req = {0};
-        u32 flags, enables;
+        u32 flags;
         int rc;
 
         if (!(bp->flags & BNXT_FLAG_NEW_RM))
                 return 0;
 
-        bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_VF_CFG, -1, -1);
+        __bnxt_hwrm_reserve_vf_rings(bp, &req, tx_rings, rx_rings, ring_grps,
+                                     cp_rings, vnics);
         flags = FUNC_VF_CFG_REQ_FLAGS_TX_ASSETS_TEST |
                 FUNC_VF_CFG_REQ_FLAGS_RX_ASSETS_TEST |
                 FUNC_VF_CFG_REQ_FLAGS_CMPL_ASSETS_TEST |
                 FUNC_VF_CFG_REQ_FLAGS_RING_GRP_ASSETS_TEST |
                 FUNC_VF_CFG_REQ_FLAGS_STAT_CTX_ASSETS_TEST |
                 FUNC_VF_CFG_REQ_FLAGS_VNIC_ASSETS_TEST;
-        enables = FUNC_VF_CFG_REQ_ENABLES_NUM_TX_RINGS |
-                  FUNC_VF_CFG_REQ_ENABLES_NUM_RX_RINGS |
-                  FUNC_VF_CFG_REQ_ENABLES_NUM_CMPL_RINGS |
-                  FUNC_VF_CFG_REQ_ENABLES_NUM_HW_RING_GRPS |
-                  FUNC_VF_CFG_REQ_ENABLES_NUM_STAT_CTXS |
-                  FUNC_VF_CFG_REQ_ENABLES_NUM_VNICS;
 
         req.flags = cpu_to_le32(flags);
-        req.enables = cpu_to_le32(enables);
-        req.num_tx_rings = cpu_to_le16(tx_rings);
-        req.num_rx_rings = cpu_to_le16(rx_rings);
-        req.num_cmpl_rings = cpu_to_le16(cp_rings);
-        req.num_hw_ring_grps = cpu_to_le16(ring_grps);
-        req.num_stat_ctxs = cpu_to_le16(cp_rings);
-        req.num_vnics = cpu_to_le16(1);
-        if (bp->flags & BNXT_FLAG_RFS)
-                req.num_vnics = cpu_to_le16(rx_rings + 1);
         rc = hwrm_send_message_silent(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
         if (rc)
                 return -ENOMEM;
@@ -4783,38 +4793,23 @@ static int bnxt_hwrm_check_vf_rings(struct bnxt *bp, int tx_rings, int rx_rings,
 }
 
 static int bnxt_hwrm_check_pf_rings(struct bnxt *bp, int tx_rings, int rx_rings,
-                                    int ring_grps, int cp_rings)
+                                    int ring_grps, int cp_rings, int vnics)
 {
         struct hwrm_func_cfg_input req = {0};
-        u32 flags, enables;
+        u32 flags;
         int rc;
 
-        bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_CFG, -1, -1);
-        req.fid = cpu_to_le16(0xffff);
+        __bnxt_hwrm_reserve_pf_rings(bp, &req, tx_rings, rx_rings, ring_grps,
+                                     cp_rings, vnics);
         flags = FUNC_CFG_REQ_FLAGS_TX_ASSETS_TEST;
-        enables = FUNC_CFG_REQ_ENABLES_NUM_TX_RINGS;
-        req.num_tx_rings = cpu_to_le16(tx_rings);
-        if (bp->flags & BNXT_FLAG_NEW_RM) {
+        if (bp->flags & BNXT_FLAG_NEW_RM)
                 flags |= FUNC_CFG_REQ_FLAGS_RX_ASSETS_TEST |
                          FUNC_CFG_REQ_FLAGS_CMPL_ASSETS_TEST |
                          FUNC_CFG_REQ_FLAGS_RING_GRP_ASSETS_TEST |
                          FUNC_CFG_REQ_FLAGS_STAT_CTX_ASSETS_TEST |
                          FUNC_CFG_REQ_FLAGS_VNIC_ASSETS_TEST;
-                enables |= FUNC_CFG_REQ_ENABLES_NUM_RX_RINGS |
-                           FUNC_CFG_REQ_ENABLES_NUM_CMPL_RINGS |
-                           FUNC_CFG_REQ_ENABLES_NUM_HW_RING_GRPS |
-                           FUNC_CFG_REQ_ENABLES_NUM_STAT_CTXS |
-                           FUNC_CFG_REQ_ENABLES_NUM_VNICS;
-                req.num_rx_rings = cpu_to_le16(rx_rings);
-                req.num_cmpl_rings = cpu_to_le16(cp_rings);
-                req.num_hw_ring_grps = cpu_to_le16(ring_grps);
-                req.num_stat_ctxs = cpu_to_le16(cp_rings);
-                req.num_vnics = cpu_to_le16(1);
-                if (bp->flags & BNXT_FLAG_RFS)
-                        req.num_vnics = cpu_to_le16(rx_rings + 1);
-        }
+
         req.flags = cpu_to_le32(flags);
-        req.enables = cpu_to_le32(enables);
         rc = hwrm_send_message_silent(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
         if (rc)
                 return -ENOMEM;
@@ -4822,17 +4817,17 @@ static int bnxt_hwrm_check_pf_rings(struct bnxt *bp, int tx_rings, int rx_rings,
 }
 
 static int bnxt_hwrm_check_rings(struct bnxt *bp, int tx_rings, int rx_rings,
-                                 int ring_grps, int cp_rings)
+                                 int ring_grps, int cp_rings, int vnics)
 {
         if (bp->hwrm_spec_code < 0x10801)
                 return 0;
 
         if (BNXT_PF(bp))
                 return bnxt_hwrm_check_pf_rings(bp, tx_rings, rx_rings,
-                                                ring_grps, cp_rings);
+                                                ring_grps, cp_rings, vnics);
 
         return bnxt_hwrm_check_vf_rings(bp, tx_rings, rx_rings, ring_grps,
-                                        cp_rings);
+                                        cp_rings, vnics);
 }
 
 static void bnxt_hwrm_set_coal_params(struct bnxt_coal *hw_coal,
@@ -5865,7 +5860,6 @@ static int bnxt_init_msix(struct bnxt *bp)
                 if (rc)
                         goto msix_setup_exit;
 
-                bp->tx_nr_rings_per_tc = bp->tx_nr_rings;
                 bp->cp_nr_rings = (min == 1) ?
                                   max_t(int, bp->tx_nr_rings, bp->rx_nr_rings) :
                                   bp->tx_nr_rings + bp->rx_nr_rings;
@@ -5897,7 +5891,6 @@ static int bnxt_init_inta(struct bnxt *bp)
         bp->rx_nr_rings = 1;
         bp->tx_nr_rings = 1;
         bp->cp_nr_rings = 1;
-        bp->tx_nr_rings_per_tc = bp->tx_nr_rings;
         bp->flags |= BNXT_FLAG_SHARED_RINGS;
         bp->irq_tbl[0].vector = bp->pdev->irq;
         return 0;
@@ -7531,7 +7524,7 @@ int bnxt_check_rings(struct bnxt *bp, int tx, int rx, bool sh, int tcs,
         int max_rx, max_tx, tx_sets = 1;
         int tx_rings_needed;
         int rx_rings = rx;
-        int cp, rc;
+        int cp, vnics, rc;
 
         if (tcs)
                 tx_sets = tcs;
@@ -7547,10 +7540,15 @@ int bnxt_check_rings(struct bnxt *bp, int tx, int rx, bool sh, int tcs,
         if (max_tx < tx_rings_needed)
                 return -ENOMEM;
 
+        vnics = 1;
+        if (bp->flags & BNXT_FLAG_RFS)
+                vnics += rx_rings;
+
         if (bp->flags & BNXT_FLAG_AGG_RINGS)
                 rx_rings <<= 1;
         cp = sh ? max_t(int, tx_rings_needed, rx) : tx_rings_needed + rx;
-        return bnxt_hwrm_check_rings(bp, tx_rings_needed, rx_rings, rx, cp);
+        return bnxt_hwrm_check_rings(bp, tx_rings_needed, rx_rings, rx, cp,
+                                     vnics);
 }
 
 static void bnxt_unmap_bars(struct bnxt *bp, struct pci_dev *pdev)
@@ -8437,13 +8435,20 @@ int bnxt_restore_pf_fw_resources(struct bnxt *bp)
                 return 0;
 
         bnxt_hwrm_func_qcaps(bp);
-        __bnxt_close_nic(bp, true, false);
+
+        if (netif_running(bp->dev))
+                __bnxt_close_nic(bp, true, false);
+
         bnxt_clear_int_mode(bp);
         rc = bnxt_init_int_mode(bp);
-        if (rc)
-                dev_close(bp->dev);
-        else
-                rc = bnxt_open_nic(bp, true, false);
+
+        if (netif_running(bp->dev)) {
+                if (rc)
+                        dev_close(bp->dev);
+                else
+                        rc = bnxt_open_nic(bp, true, false);
+        }
+
         return rc;
 }
 
@@ -8664,6 +8669,11 @@ static int bnxt_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (rc)
                 goto init_err_pci_clean;
 
+        /* No TC has been set yet and rings may have been trimmed due to
+         * limited MSIX, so we re-initialize the TX rings per TC.
+         */
+        bp->tx_nr_rings_per_tc = bp->tx_nr_rings;
+
         bnxt_get_wol_settings(bp);
         if (bp->flags & BNXT_FLAG_WOL_CAP)
                 device_set_wakeup_enable(&pdev->dev, bp->wol);
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.h b/drivers/net/ethernet/broadcom/bnxt/bnxt.h
index 1989c470172c..5e3d62189cab 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.h
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.h
@@ -189,6 +189,7 @@ struct rx_cmp_ext {
         #define RX_CMP_FLAGS2_T_L4_CS_CALC                      (0x1 << 3)
         #define RX_CMP_FLAGS2_META_FORMAT_VLAN                  (0x1 << 4)
         __le32 rx_cmp_meta_data;
+        #define RX_CMP_FLAGS2_METADATA_TCI_MASK                 0xffff
         #define RX_CMP_FLAGS2_METADATA_VID_MASK                 0xfff
         #define RX_CMP_FLAGS2_METADATA_TPID_MASK                0xffff0000
          #define RX_CMP_FLAGS2_METADATA_TPID_SFT                 16
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c
index fbe6e208e17b..65c2cee35766 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c
@@ -349,6 +349,9 @@ static int bnxt_hwrm_cfa_flow_free(struct bnxt *bp, __le16 flow_handle)
         if (rc)
                 netdev_info(bp->dev, "Error: %s: flow_handle=0x%x rc=%d",
                             __func__, flow_handle, rc);
+
+        if (rc)
+                rc = -EIO;
         return rc;
 }
 
@@ -484,13 +487,15 @@ static int bnxt_hwrm_cfa_flow_alloc(struct bnxt *bp, struct bnxt_tc_flow *flow,
         req.action_flags = cpu_to_le16(action_flags);
 
         mutex_lock(&bp->hwrm_cmd_lock);
-
         rc = _hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
         if (!rc)
                 *flow_handle = resp->flow_handle;
-
         mutex_unlock(&bp->hwrm_cmd_lock);
 
+        if (rc == HWRM_ERR_CODE_RESOURCE_ALLOC_ERROR)
+                rc = -ENOSPC;
+        else if (rc)
+                rc = -EIO;
         return rc;
 }
 
@@ -561,6 +566,8 @@ static int hwrm_cfa_decap_filter_alloc(struct bnxt *bp,
                 netdev_info(bp->dev, "%s: Error rc=%d", __func__, rc);
         mutex_unlock(&bp->hwrm_cmd_lock);
 
+        if (rc)
+                rc = -EIO;
         return rc;
 }
 
@@ -576,6 +583,9 @@ static int hwrm_cfa_decap_filter_free(struct bnxt *bp,
         rc = hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
         if (rc)
                 netdev_info(bp->dev, "%s: Error rc=%d", __func__, rc);
+
+        if (rc)
+                rc = -EIO;
         return rc;
 }
 
@@ -624,6 +634,8 @@ static int hwrm_cfa_encap_record_alloc(struct bnxt *bp,
                 netdev_info(bp->dev, "%s: Error rc=%d", __func__, rc);
         mutex_unlock(&bp->hwrm_cmd_lock);
 
+        if (rc)
+                rc = -EIO;
         return rc;
 }
 
@@ -639,6 +651,9 @@ static int hwrm_cfa_encap_record_free(struct bnxt *bp,
         rc = hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
         if (rc)
                 netdev_info(bp->dev, "%s: Error rc=%d", __func__, rc);
+
+        if (rc)
+                rc = -EIO;
         return rc;
 }
 
@@ -1269,11 +1284,8 @@ static int bnxt_tc_del_flow(struct bnxt *bp,
         flow_node = rhashtable_lookup_fast(&tc_info->flow_table,
                                            &tc_flow_cmd->cookie,
                                            tc_info->flow_ht_params);
-        if (!flow_node) {
-                netdev_info(bp->dev, "ERROR: no flow_node for cookie %lx",
-                            tc_flow_cmd->cookie);
+        if (!flow_node)
                 return -EINVAL;
-        }
 
         return __bnxt_tc_del_flow(bp, flow_node);
 }
@@ -1290,11 +1302,8 @@ static int bnxt_tc_get_flow_stats(struct bnxt *bp,
         flow_node = rhashtable_lookup_fast(&tc_info->flow_table,
                                            &tc_flow_cmd->cookie,
                                            tc_info->flow_ht_params);
-        if (!flow_node) {
-                netdev_info(bp->dev, "Error: no flow_node for cookie %lx",
-                            tc_flow_cmd->cookie);
+        if (!flow_node)
                 return -1;
-        }
 
         flow = &flow_node->flow;
         curr_stats = &flow->stats;
@@ -1344,8 +1353,10 @@ bnxt_hwrm_cfa_flow_stats_get(struct bnxt *bp, int num_flows,
         } else {
                 netdev_info(bp->dev, "error rc=%d", rc);
         }
-
         mutex_unlock(&bp->hwrm_cmd_lock);
+
+        if (rc)
+                rc = -EIO;
         return rc;
 }
 
diff --git a/drivers/net/ethernet/broadcom/tg3.c b/drivers/net/ethernet/broadcom/tg3.c
index c1841db1b500..f2593978ae75 100644
--- a/drivers/net/ethernet/broadcom/tg3.c
+++ b/drivers/net/ethernet/broadcom/tg3.c
@@ -820,7 +820,7 @@ static int tg3_ape_event_lock(struct tg3 *tp, u32 timeout_us)
 
                 tg3_ape_unlock(tp, TG3_APE_LOCK_MEM);
 
-                usleep_range(10, 20);
+                udelay(10);
                 timeout_us -= (timeout_us > 10) ? 10 : timeout_us;
         }
 
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
index 7b452e85de2a..61022b5f6743 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
@@ -4970,7 +4970,6 @@ static void cxgb4_mgmt_setup(struct net_device *dev)
         /* Initialize the device structure. */
         dev->netdev_ops = &cxgb4_mgmt_netdev_ops;
         dev->ethtool_ops = &cxgb4_mgmt_ethtool_ops;
-        dev->needs_free_netdev = true;
 }
 
 static int cxgb4_iov_configure(struct pci_dev *pdev, int num_vfs)
@@ -5181,6 +5180,8 @@ static int init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         adapter->name = pci_name(pdev);
         adapter->mbox = func;
         adapter->pf = func;
+        adapter->params.chip = chip;
+        adapter->adap_idx = adap_idx;
         adapter->msg_enable = DFLT_MSG_ENABLE;
         adapter->mbox_log = kzalloc(sizeof(*adapter->mbox_log) +
                                     (sizeof(struct mbox_cmd) *
diff --git a/drivers/net/ethernet/cortina/gemini.c b/drivers/net/ethernet/cortina/gemini.c
index 5eb999af2c40..bd3f6e4d1341 100644
--- a/drivers/net/ethernet/cortina/gemini.c
+++ b/drivers/net/ethernet/cortina/gemini.c
@@ -540,6 +540,7 @@ static int gmac_setup_txqs(struct net_device *netdev)
 
         if (port->txq_dma_base & ~DMA_Q_BASE_MASK) {
                 dev_warn(geth->dev, "TX queue base it not aligned\n");
+                kfree(skb_tab);
                 return -ENOMEM;
         }
 
diff --git a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c
index 7caa8da48421..e4ec32a9ca15 100644
--- a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c
+++ b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c
@@ -2008,7 +2008,6 @@ static inline int dpaa_xmit(struct dpaa_priv *priv,
         }
 
         if (unlikely(err < 0)) {
-                percpu_stats->tx_errors++;
                 percpu_stats->tx_fifo_errors++;
                 return err;
         }
@@ -2278,7 +2277,6 @@ static enum qman_cb_dqrr_result rx_default_dqrr(struct qman_portal *portal,
         vaddr = phys_to_virt(addr);
         prefetch(vaddr + qm_fd_get_offset(fd));
 
-        fd_format = qm_fd_get_format(fd);
         /* The only FD types that we may receive are contig and S/G */
         WARN_ON((fd_format != qm_fd_contig) && (fd_format != qm_fd_sg));
 
@@ -2311,8 +2309,10 @@ static enum qman_cb_dqrr_result rx_default_dqrr(struct qman_portal *portal,
 
         skb_len = skb->len;
 
-        if (unlikely(netif_receive_skb(skb) == NET_RX_DROP))
+        if (unlikely(netif_receive_skb(skb) == NET_RX_DROP)) {
+                percpu_stats->rx_dropped++;
                 return qman_cb_dqrr_consume;
+        }
 
         percpu_stats->rx_packets++;
         percpu_stats->rx_bytes += skb_len;
@@ -2860,7 +2860,7 @@ static int dpaa_remove(struct platform_device *pdev)
         struct device *dev;
         int err;
 
-        dev = &pdev->dev;
+        dev = pdev->dev.parent;
         net_dev = dev_get_drvdata(dev);
 
         priv = netdev_priv(net_dev);
diff --git a/drivers/net/ethernet/freescale/fec_main.c b/drivers/net/ethernet/freescale/fec_main.c
index 7a7f3a42b2aa..d4604bc8eb5b 100644
--- a/drivers/net/ethernet/freescale/fec_main.c
+++ b/drivers/net/ethernet/freescale/fec_main.c
@@ -3600,6 +3600,8 @@ fec_drv_remove(struct platform_device *pdev)
         fec_enet_mii_remove(fep);
         if (fep->reg_phy)
                 regulator_disable(fep->reg_phy);
+        pm_runtime_put(&pdev->dev);
+        pm_runtime_disable(&pdev->dev);
         if (of_phy_is_fixed_link(np))
                 of_phy_deregister_fixed_link(np);
         of_node_put(fep->phy_node);
diff --git a/drivers/net/ethernet/freescale/fman/fman_dtsec.c b/drivers/net/ethernet/freescale/fman/fman_dtsec.c
index ea43b4974149..7af31ddd093f 100644
--- a/drivers/net/ethernet/freescale/fman/fman_dtsec.c
+++ b/drivers/net/ethernet/freescale/fman/fman_dtsec.c
@@ -1100,7 +1100,7 @@ int dtsec_add_hash_mac_address(struct fman_mac *dtsec, enet_addr_t *eth_addr)
         set_bucket(dtsec->regs, bucket, true);
 
         /* Create element to be added to the driver hash table */
-        hash_entry = kmalloc(sizeof(*hash_entry), GFP_KERNEL);
+        hash_entry = kmalloc(sizeof(*hash_entry), GFP_ATOMIC);
         if (!hash_entry)
                 return -ENOMEM;
         hash_entry->addr = addr;
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_gmac.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_gmac.c
index 86944bc3b273..74bd260ca02a 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_gmac.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_gmac.c
@@ -666,7 +666,7 @@ static void hns_gmac_get_strings(u32 stringset, u8 *data)
 
 static int hns_gmac_get_sset_count(int stringset)
 {
-        if (stringset == ETH_SS_STATS || stringset == ETH_SS_PRIV_FLAGS)
+        if (stringset == ETH_SS_STATS)
                 return ARRAY_SIZE(g_gmac_stats_string);
 
         return 0;
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_ppe.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_ppe.c
index b62816c1574e..93e71e27401b 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_ppe.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_ppe.c
@@ -422,7 +422,7 @@ void hns_ppe_update_stats(struct hns_ppe_cb *ppe_cb)
 
 int hns_ppe_get_sset_count(int stringset)
 {
-        if (stringset == ETH_SS_STATS || stringset == ETH_SS_PRIV_FLAGS)
+        if (stringset == ETH_SS_STATS)
                 return ETH_PPE_STATIC_NUM;
         return 0;
 }
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.c
index 6f3570cfb501..e2e28532e4dc 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.c
@@ -876,7 +876,7 @@ void hns_rcb_get_stats(struct hnae_queue *queue, u64 *data)
  */
 int hns_rcb_get_ring_sset_count(int stringset)
 {
-        if (stringset == ETH_SS_STATS || stringset == ETH_SS_PRIV_FLAGS)
+        if (stringset == ETH_SS_STATS)
                 return HNS_RING_STATIC_REG_NUM;
 
         return 0;
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_ethtool.c b/drivers/net/ethernet/hisilicon/hns/hns_ethtool.c
index 7ea7f8a4aa2a..2e14a3ae1d8b 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_ethtool.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_ethtool.c
@@ -993,8 +993,10 @@ int hns_get_sset_count(struct net_device *netdev, int stringset)
                         cnt--;
 
                 return cnt;
-        } else {
+        } else if (stringset == ETH_SS_STATS) {
                 return (HNS_NET_STATS_CNT + ops->get_sset_count(h, stringset));
+        } else {
+                return -EOPNOTSUPP;
         }
 }
 
diff --git a/drivers/net/ethernet/intel/e1000e/defines.h b/drivers/net/ethernet/intel/e1000e/defines.h
index afb7ebe20b24..824fd44e25f0 100644
--- a/drivers/net/ethernet/intel/e1000e/defines.h
+++ b/drivers/net/ethernet/intel/e1000e/defines.h
@@ -400,6 +400,10 @@
 #define E1000_ICR_RXDMT0        0x00000010 /* Rx desc min. threshold (0) */
 #define E1000_ICR_RXO           0x00000040 /* Receiver Overrun */
 #define E1000_ICR_RXT0          0x00000080 /* Rx timer intr (ring 0) */
+#define E1000_ICR_MDAC          0x00000200 /* MDIO Access Complete */
+#define E1000_ICR_SRPD          0x00010000 /* Small Receive Packet Detected */
+#define E1000_ICR_ACK           0x00020000 /* Receive ACK Frame Detected */
+#define E1000_ICR_MNG           0x00040000 /* Manageability Event Detected */
 #define E1000_ICR_ECCER         0x00400000 /* Uncorrectable ECC Error */
 /* If this bit asserted, the driver should claim the interrupt */
 #define E1000_ICR_INT_ASSERTED  0x80000000
@@ -407,7 +411,7 @@
 #define E1000_ICR_RXQ1          0x00200000 /* Rx Queue 1 Interrupt */
 #define E1000_ICR_TXQ0          0x00400000 /* Tx Queue 0 Interrupt */
 #define E1000_ICR_TXQ1          0x00800000 /* Tx Queue 1 Interrupt */
-#define E1000_ICR_OTHER         0x01000000 /* Other Interrupts */
+#define E1000_ICR_OTHER         0x01000000 /* Other Interrupt */
 
 /* PBA ECC Register */
 #define E1000_PBA_ECC_COUNTER_MASK  0xFFF00000 /* ECC counter mask */
@@ -431,12 +435,27 @@
         E1000_IMS_RXSEQ  |    \
         E1000_IMS_LSC)
 
+/* These are all of the events related to the OTHER interrupt.
+ */
+#define IMS_OTHER_MASK ( \
+        E1000_IMS_LSC  | \
+        E1000_IMS_RXO  | \
+        E1000_IMS_MDAC | \
+        E1000_IMS_SRPD | \
+        E1000_IMS_ACK  | \
+        E1000_IMS_MNG)
+
 /* Interrupt Mask Set */
 #define E1000_IMS_TXDW      E1000_ICR_TXDW      /* Transmit desc written back */
 #define E1000_IMS_LSC       E1000_ICR_LSC       /* Link Status Change */
 #define E1000_IMS_RXSEQ     E1000_ICR_RXSEQ     /* Rx sequence error */
 #define E1000_IMS_RXDMT0    E1000_ICR_RXDMT0    /* Rx desc min. threshold */
+#define E1000_IMS_RXO       E1000_ICR_RXO       /* Receiver Overrun */
 #define E1000_IMS_RXT0      E1000_ICR_RXT0      /* Rx timer intr */
+#define E1000_IMS_MDAC      E1000_ICR_MDAC      /* MDIO Access Complete */
+#define E1000_IMS_SRPD      E1000_ICR_SRPD      /* Small Receive Packet */
+#define E1000_IMS_ACK       E1000_ICR_ACK       /* Receive ACK Frame Detected */
+#define E1000_IMS_MNG       E1000_ICR_MNG       /* Manageability Event */
 #define E1000_IMS_ECCER     E1000_ICR_ECCER     /* Uncorrectable ECC Error */
 #define E1000_IMS_RXQ0      E1000_ICR_RXQ0      /* Rx Queue 0 Interrupt */
 #define E1000_IMS_RXQ1      E1000_ICR_RXQ1      /* Rx Queue 1 Interrupt */
diff --git a/drivers/net/ethernet/intel/e1000e/ich8lan.c b/drivers/net/ethernet/intel/e1000e/ich8lan.c
index 31277d3bb7dc..1dddfb7b2de6 100644
--- a/drivers/net/ethernet/intel/e1000e/ich8lan.c
+++ b/drivers/net/ethernet/intel/e1000e/ich8lan.c
@@ -1367,9 +1367,6 @@ out:
  *  Checks to see of the link status of the hardware has changed.  If a
  *  change in link status has been detected, then we read the PHY registers
  *  to get the current speed/duplex if link exists.
- *
- *  Returns a negative error code (-E1000_ERR_*) or 0 (link down) or 1 (link
- *  up).
  **/
 static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
 {
@@ -1385,7 +1382,8 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
          * Change or Rx Sequence Error interrupt.
          */
         if (!mac->get_link_status)
-                return 1;
+                return 0;
+        mac->get_link_status = false;
 
         /* First we want to see if the MII Status Register reports
          * link.  If so, then we want to get the current speed/duplex
@@ -1393,12 +1391,12 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
          */
         ret_val = e1000e_phy_has_link_generic(hw, 1, 0, &link);
         if (ret_val)
-                return ret_val;
+                goto out;
 
         if (hw->mac.type == e1000_pchlan) {
                 ret_val = e1000_k1_gig_workaround_hv(hw, link);
                 if (ret_val)
-                        return ret_val;
+                        goto out;
         }
 
         /* When connected at 10Mbps half-duplex, some parts are excessively
@@ -1431,7 +1429,7 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
 
                 ret_val = hw->phy.ops.acquire(hw);
                 if (ret_val)
-                        return ret_val;
+                        goto out;
 
                 if (hw->mac.type == e1000_pch2lan)
                         emi_addr = I82579_RX_CONFIG;
@@ -1453,7 +1451,7 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
                 hw->phy.ops.release(hw);
 
                 if (ret_val)
-                        return ret_val;
+                        goto out;
 
                 if (hw->mac.type >= e1000_pch_spt) {
                         u16 data;
@@ -1462,14 +1460,14 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
                         if (speed == SPEED_1000) {
                                 ret_val = hw->phy.ops.acquire(hw);
                                 if (ret_val)
-                                        return ret_val;
+                                        goto out;
 
                                 ret_val = e1e_rphy_locked(hw,
                                                           PHY_REG(776, 20),
                                                           &data);
                                 if (ret_val) {
                                         hw->phy.ops.release(hw);
-                                        return ret_val;
+                                        goto out;
                                 }
 
                                 ptr_gap = (data & (0x3FF << 2)) >> 2;
@@ -1483,18 +1481,18 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
                                 }
                                 hw->phy.ops.release(hw);
                                 if (ret_val)
-                                        return ret_val;
+                                        goto out;
                         } else {
                                 ret_val = hw->phy.ops.acquire(hw);
                                 if (ret_val)
-                                        return ret_val;
+                                        goto out;
 
                                 ret_val = e1e_wphy_locked(hw,
                                                           PHY_REG(776, 20),
                                                           0xC023);
                                 hw->phy.ops.release(hw);
                                 if (ret_val)
-                                        return ret_val;
+                                        goto out;
 
                         }
                 }
@@ -1521,7 +1519,7 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
             (hw->adapter->pdev->device == E1000_DEV_ID_PCH_I218_V3)) {
                 ret_val = e1000_k1_workaround_lpt_lp(hw, link);
                 if (ret_val)
-                        return ret_val;
+                        goto out;
         }
         if (hw->mac.type >= e1000_pch_lpt) {
                 /* Set platform power management values for
@@ -1529,7 +1527,7 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
                  */
                 ret_val = e1000_platform_pm_pch_lpt(hw, link);
                 if (ret_val)
-                        return ret_val;
+                        goto out;
         }
 
         /* Clear link partner's EEE ability */
@@ -1552,9 +1550,7 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
         }
 
         if (!link)
-                return 0;       /* No link detected */
-
-        mac->get_link_status = false;
+                goto out;
 
         switch (hw->mac.type) {
         case e1000_pch2lan:
@@ -1616,12 +1612,14 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
          * different link partner.
          */
         ret_val = e1000e_config_fc_after_link_up(hw);
-        if (ret_val) {
+        if (ret_val)
                 e_dbg("Error configuring flow control\n");
-                return ret_val;
-        }
 
-        return 1;
+        return ret_val;
+
+out:
+        mac->get_link_status = true;
+        return ret_val;
 }
 
 static s32 e1000_get_variants_ich8lan(struct e1000_adapter *adapter)
diff --git a/drivers/net/ethernet/intel/e1000e/mac.c b/drivers/net/ethernet/intel/e1000e/mac.c
index f457c5703d0c..5bdc3a2d4fd7 100644
--- a/drivers/net/ethernet/intel/e1000e/mac.c
+++ b/drivers/net/ethernet/intel/e1000e/mac.c
@@ -410,9 +410,6 @@ void e1000e_clear_hw_cntrs_base(struct e1000_hw *hw)
  *  Checks to see of the link status of the hardware has changed.  If a
  *  change in link status has been detected, then we read the PHY registers
  *  to get the current speed/duplex if link exists.
- *
- *  Returns a negative error code (-E1000_ERR_*) or 0 (link down) or 1 (link
- *  up).
  **/
 s32 e1000e_check_for_copper_link(struct e1000_hw *hw)
 {
@@ -426,20 +423,16 @@ s32 e1000e_check_for_copper_link(struct e1000_hw *hw)
          * Change or Rx Sequence Error interrupt.
          */
         if (!mac->get_link_status)
-                return 1;
+                return 0;
+        mac->get_link_status = false;
 
         /* First we want to see if the MII Status Register reports
          * link.  If so, then we want to get the current speed/duplex
          * of the PHY.
          */
         ret_val = e1000e_phy_has_link_generic(hw, 1, 0, &link);
-        if (ret_val)
-                return ret_val;
-
-        if (!link)
-                return 0;       /* No link detected */
-
-        mac->get_link_status = false;
+        if (ret_val || !link)
+                goto out;
 
         /* Check if there was DownShift, must be checked
          * immediately after link-up
@@ -464,12 +457,14 @@ s32 e1000e_check_for_copper_link(struct e1000_hw *hw)
          * different link partner.
          */
         ret_val = e1000e_config_fc_after_link_up(hw);
-        if (ret_val) {
+        if (ret_val)
                 e_dbg("Error configuring flow control\n");
-                return ret_val;
-        }
 
-        return 1;
+        return ret_val;
+
+out:
+        mac->get_link_status = true;
+        return ret_val;
 }
 
 /**
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index 1298b69f990b..dc853b0863af 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -1914,30 +1914,20 @@ static irqreturn_t e1000_msix_other(int __always_unused irq, void *data)
         struct net_device *netdev = data;
         struct e1000_adapter *adapter = netdev_priv(netdev);
         struct e1000_hw *hw = &adapter->hw;
-        u32 icr;
-        bool enable = true;
-
-        icr = er32(ICR);
-        if (icr & E1000_ICR_RXO) {
-                ew32(ICR, E1000_ICR_RXO);
-                enable = false;
-                /* napi poll will re-enable Other, make sure it runs */
-                if (napi_schedule_prep(&adapter->napi)) {
-                        adapter->total_rx_bytes = 0;
-                        adapter->total_rx_packets = 0;
-                        __napi_schedule(&adapter->napi);
-                }
-        }
+        u32 icr = er32(ICR);
+
+        if (icr & adapter->eiac_mask)
+                ew32(ICS, (icr & adapter->eiac_mask));
+
         if (icr & E1000_ICR_LSC) {
-                ew32(ICR, E1000_ICR_LSC);
                 hw->mac.get_link_status = true;
                 /* guard against interrupt when we're going down */
                 if (!test_bit(__E1000_DOWN, &adapter->state))
                         mod_timer(&adapter->watchdog_timer, jiffies + 1);
         }
 
-        if (enable && !test_bit(__E1000_DOWN, &adapter->state))
-                ew32(IMS, E1000_IMS_OTHER);
+        if (!test_bit(__E1000_DOWN, &adapter->state))
+                ew32(IMS, E1000_IMS_OTHER | IMS_OTHER_MASK);
 
         return IRQ_HANDLED;
 }
@@ -2040,7 +2030,6 @@ static void e1000_configure_msix(struct e1000_adapter *adapter)
                        hw->hw_addr + E1000_EITR_82574(vector));
         else
                 writel(1, hw->hw_addr + E1000_EITR_82574(vector));
-        adapter->eiac_mask |= E1000_IMS_OTHER;
 
         /* Cause Tx interrupts on every write back */
         ivar |= BIT(31);
@@ -2265,7 +2254,8 @@ static void e1000_irq_enable(struct e1000_adapter *adapter)
 
         if (adapter->msix_entries) {
                 ew32(EIAC_82574, adapter->eiac_mask & E1000_EIAC_MASK_82574);
-                ew32(IMS, adapter->eiac_mask | E1000_IMS_LSC);
+                ew32(IMS, adapter->eiac_mask | E1000_IMS_OTHER |
+                     IMS_OTHER_MASK);
         } else if (hw->mac.type >= e1000_pch_lpt) {
                 ew32(IMS, IMS_ENABLE_MASK | E1000_IMS_ECCER);
         } else {
@@ -2333,8 +2323,8 @@ static int e1000_alloc_ring_dma(struct e1000_adapter *adapter,
 {
         struct pci_dev *pdev = adapter->pdev;
 
-        ring->desc = dma_alloc_coherent(&pdev->dev, ring->size, &ring->dma,
-                                        GFP_KERNEL);
+        ring->desc = dma_zalloc_coherent(&pdev->dev, ring->size, &ring->dma,
+                                         GFP_KERNEL);
         if (!ring->desc)
                 return -ENOMEM;
 
@@ -2707,8 +2697,7 @@ static int e1000e_poll(struct napi_struct *napi, int weight)
                 napi_complete_done(napi, work_done);
                 if (!test_bit(__E1000_DOWN, &adapter->state)) {
                         if (adapter->msix_entries)
-                                ew32(IMS, adapter->rx_ring->ims_val |
-                                     E1000_IMS_OTHER);
+                                ew32(IMS, adapter->rx_ring->ims_val);
                         else
                                 e1000_irq_enable(adapter);
                 }
@@ -5101,7 +5090,7 @@ static bool e1000e_has_link(struct e1000_adapter *adapter)
         case e1000_media_type_copper:
                 if (hw->mac.get_link_status) {
                         ret_val = hw->mac.ops.check_for_link(hw);
-                        link_active = ret_val > 0;
+                        link_active = !hw->mac.get_link_status;
                 } else {
                         link_active = true;
                 }
diff --git a/drivers/net/ethernet/mellanox/mlxsw/core_acl_flex_actions.c b/drivers/net/ethernet/mellanox/mlxsw/core_acl_flex_actions.c
index b698fb481b2e..996dc099cd58 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/core_acl_flex_actions.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/core_acl_flex_actions.c
@@ -443,6 +443,17 @@ int mlxsw_afa_block_jump(struct mlxsw_afa_block *block, u16 group_id)
 }
 EXPORT_SYMBOL(mlxsw_afa_block_jump);
 
+int mlxsw_afa_block_terminate(struct mlxsw_afa_block *block)
+{
+        if (block->finished)
+                return -EINVAL;
+        mlxsw_afa_set_goto_set(block->cur_set,
+                               MLXSW_AFA_SET_GOTO_BINDING_CMD_TERM, 0);
+        block->finished = true;
+        return 0;
+}
+EXPORT_SYMBOL(mlxsw_afa_block_terminate);
+
 static struct mlxsw_afa_fwd_entry *
 mlxsw_afa_fwd_entry_create(struct mlxsw_afa *mlxsw_afa, u8 local_port)
 {
diff --git a/drivers/net/ethernet/mellanox/mlxsw/core_acl_flex_actions.h b/drivers/net/ethernet/mellanox/mlxsw/core_acl_flex_actions.h
index 43132293475c..b91f2b0829b0 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/core_acl_flex_actions.h
+++ b/drivers/net/ethernet/mellanox/mlxsw/core_acl_flex_actions.h
@@ -65,6 +65,7 @@ char *mlxsw_afa_block_first_set(struct mlxsw_afa_block *block);
 u32 mlxsw_afa_block_first_set_kvdl_index(struct mlxsw_afa_block *block);
 int mlxsw_afa_block_continue(struct mlxsw_afa_block *block);
 int mlxsw_afa_block_jump(struct mlxsw_afa_block *block, u16 group_id);
+int mlxsw_afa_block_terminate(struct mlxsw_afa_block *block);
 int mlxsw_afa_block_append_drop(struct mlxsw_afa_block *block);
 int mlxsw_afa_block_append_trap(struct mlxsw_afa_block *block, u16 trap_id);
 int mlxsw_afa_block_append_trap_and_forward(struct mlxsw_afa_block *block,
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
index c7e941aecc2a..bf400c75fcc8 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
@@ -655,13 +655,17 @@ static int mlxsw_sp_span_port_mtu_update(struct mlxsw_sp_port *port, u16 mtu)
 }
 
 static struct mlxsw_sp_span_inspected_port *
-mlxsw_sp_span_entry_bound_port_find(struct mlxsw_sp_port *port,
-                                    struct mlxsw_sp_span_entry *span_entry)
+mlxsw_sp_span_entry_bound_port_find(struct mlxsw_sp_span_entry *span_entry,
+                                    enum mlxsw_sp_span_type type,
+                                    struct mlxsw_sp_port *port,
+                                    bool bind)
 {
         struct mlxsw_sp_span_inspected_port *p;
 
         list_for_each_entry(p, &span_entry->bound_ports_list, list)
-                if (port->local_port == p->local_port)
+                if (type == p->type &&
+                    port->local_port == p->local_port &&
+                    bind == p->bound)
                         return p;
         return NULL;
 }
@@ -691,8 +695,22 @@ mlxsw_sp_span_inspected_port_add(struct mlxsw_sp_port *port,
         struct mlxsw_sp_span_inspected_port *inspected_port;
         struct mlxsw_sp *mlxsw_sp = port->mlxsw_sp;
         char sbib_pl[MLXSW_REG_SBIB_LEN];
+        int i;
         int err;
 
+        /* A given (source port, direction) can only be bound to one analyzer,
+         * so if a binding is requested, check for conflicts.
+         */
+        if (bind)
+                for (i = 0; i < mlxsw_sp->span.entries_count; i++) {
+                        struct mlxsw_sp_span_entry *curr =
+                                &mlxsw_sp->span.entries[i];
+
+                        if (mlxsw_sp_span_entry_bound_port_find(curr, type,
+                                                                port, bind))
+                                return -EEXIST;
+                }
+
         /* if it is an egress SPAN, bind a shared buffer to it */
         if (type == MLXSW_SP_SPAN_EGRESS) {
                 u32 buffsize = mlxsw_sp_span_mtu_to_buffsize(mlxsw_sp,
@@ -720,6 +738,7 @@ mlxsw_sp_span_inspected_port_add(struct mlxsw_sp_port *port,
         }
         inspected_port->local_port = port->local_port;
         inspected_port->type = type;
+        inspected_port->bound = bind;
         list_add_tail(&inspected_port->list, &span_entry->bound_ports_list);
 
         return 0;
@@ -746,7 +765,8 @@ mlxsw_sp_span_inspected_port_del(struct mlxsw_sp_port *port,
         struct mlxsw_sp *mlxsw_sp = port->mlxsw_sp;
         char sbib_pl[MLXSW_REG_SBIB_LEN];
 
-        inspected_port = mlxsw_sp_span_entry_bound_port_find(port, span_entry);
+        inspected_port = mlxsw_sp_span_entry_bound_port_find(span_entry, type,
+                                                             port, bind);
         if (!inspected_port)
                 return;
 
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum.h b/drivers/net/ethernet/mellanox/mlxsw/spectrum.h
index 4ec1ca3c96c8..92064db2ae44 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum.h
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum.h
@@ -120,6 +120,9 @@ struct mlxsw_sp_span_inspected_port {
         struct list_head list;
         enum mlxsw_sp_span_type type;
         u8 local_port;
+
+        /* Whether this is a directly bound mirror (port-to-port) or an ACL. */
+        bool bound;
 };
 
 struct mlxsw_sp_span_entry {
@@ -553,6 +556,7 @@ void mlxsw_sp_acl_rulei_keymask_buf(struct mlxsw_sp_acl_rule_info *rulei,
 int mlxsw_sp_acl_rulei_act_continue(struct mlxsw_sp_acl_rule_info *rulei);
 int mlxsw_sp_acl_rulei_act_jump(struct mlxsw_sp_acl_rule_info *rulei,
                                 u16 group_id);
+int mlxsw_sp_acl_rulei_act_terminate(struct mlxsw_sp_acl_rule_info *rulei);
 int mlxsw_sp_acl_rulei_act_drop(struct mlxsw_sp_acl_rule_info *rulei);
 int mlxsw_sp_acl_rulei_act_trap(struct mlxsw_sp_acl_rule_info *rulei);
 int mlxsw_sp_acl_rulei_act_mirror(struct mlxsw_sp *mlxsw_sp,
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_acl.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_acl.c
index 0897a5435cc2..92d90ed7207e 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_acl.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_acl.c
@@ -528,6 +528,11 @@ int mlxsw_sp_acl_rulei_act_jump(struct mlxsw_sp_acl_rule_info *rulei,
         return mlxsw_afa_block_jump(rulei->act_block, group_id);
 }
 
+int mlxsw_sp_acl_rulei_act_terminate(struct mlxsw_sp_acl_rule_info *rulei)
+{
+        return mlxsw_afa_block_terminate(rulei->act_block);
+}
+
 int mlxsw_sp_acl_rulei_act_drop(struct mlxsw_sp_acl_rule_info *rulei)
 {
         return mlxsw_afa_block_append_drop(rulei->act_block);
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_buffers.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_buffers.c
index 93728c694e6d..0a9adc5962fb 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_buffers.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_buffers.c
@@ -385,13 +385,13 @@ static const struct mlxsw_sp_sb_cm mlxsw_sp_sb_cms_egress[] = {
 
 static const struct mlxsw_sp_sb_cm mlxsw_sp_cpu_port_sb_cms[] = {
         MLXSW_SP_CPU_PORT_SB_CM,
+        MLXSW_SP_SB_CM(MLXSW_PORT_MAX_MTU, 0, 0),
+        MLXSW_SP_SB_CM(MLXSW_PORT_MAX_MTU, 0, 0),
+        MLXSW_SP_SB_CM(MLXSW_PORT_MAX_MTU, 0, 0),
+        MLXSW_SP_SB_CM(MLXSW_PORT_MAX_MTU, 0, 0),
+        MLXSW_SP_SB_CM(MLXSW_PORT_MAX_MTU, 0, 0),
         MLXSW_SP_CPU_PORT_SB_CM,
-        MLXSW_SP_CPU_PORT_SB_CM,
-        MLXSW_SP_CPU_PORT_SB_CM,
-        MLXSW_SP_CPU_PORT_SB_CM,
-        MLXSW_SP_CPU_PORT_SB_CM,
-        MLXSW_SP_CPU_PORT_SB_CM,
-        MLXSW_SP_SB_CM(10000, 0, 0),
+        MLXSW_SP_SB_CM(MLXSW_PORT_MAX_MTU, 0, 0),
         MLXSW_SP_CPU_PORT_SB_CM,
         MLXSW_SP_CPU_PORT_SB_CM,
         MLXSW_SP_CPU_PORT_SB_CM,
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c
index 6ce00e28d4ea..89dbf569dff5 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c
@@ -65,7 +65,7 @@ static int mlxsw_sp_flower_parse_actions(struct mlxsw_sp *mlxsw_sp,
         tcf_exts_to_list(exts, &actions);
         list_for_each_entry(a, &actions, list) {
                 if (is_tcf_gact_ok(a)) {
-                        err = mlxsw_sp_acl_rulei_act_continue(rulei);
+                        err = mlxsw_sp_acl_rulei_act_terminate(rulei);
                         if (err)
                                 return err;
                 } else if (is_tcf_gact_shot(a)) {
diff --git a/drivers/net/ethernet/natsemi/Kconfig b/drivers/net/ethernet/natsemi/Kconfig
index a10ef50e4f12..017fb2322589 100644
--- a/drivers/net/ethernet/natsemi/Kconfig
+++ b/drivers/net/ethernet/natsemi/Kconfig
@@ -1,16 +1,16 @@
 #
-# National Semi-conductor device configuration
+# National Semiconductor device configuration
 #
 
 config NET_VENDOR_NATSEMI
-        bool "National Semi-conductor devices"
+        bool "National Semiconductor devices"
         default y
         ---help---
           If you have a network (Ethernet) card belonging to this class, say Y.
 
           Note that the answer to this question doesn't directly affect the
           kernel: saying N will just cause the configurator to skip all
-          the questions about National Semi-conductor devices. If you say Y,
+          the questions about National Semiconductor devices. If you say Y,
           you will be asked for your specific card in the following questions.
 
 if NET_VENDOR_NATSEMI
diff --git a/drivers/net/ethernet/natsemi/Makefile b/drivers/net/ethernet/natsemi/Makefile
index cc664977596e..a759aa09ef59 100644
--- a/drivers/net/ethernet/natsemi/Makefile
+++ b/drivers/net/ethernet/natsemi/Makefile
@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: GPL-2.0
 #
-# Makefile for the National Semi-conductor Sonic devices.
+# Makefile for the National Semiconductor Sonic devices.
 #
 
 obj-$(CONFIG_MACSONIC) += macsonic.o
diff --git a/drivers/net/ethernet/qlogic/qed/qed_cxt.c b/drivers/net/ethernet/qlogic/qed/qed_cxt.c
index 6f546e869d8d..00f41c145d4d 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_cxt.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_cxt.c
@@ -2480,7 +2480,10 @@ int qed_cxt_free_proto_ilt(struct qed_hwfn *p_hwfn, enum protocol_type proto)
         if (rc)
                 return rc;
 
-        /* Free Task CXT */
+        /* Free Task CXT ( Intentionally RoCE as task-id is shared between
+         * RoCE and iWARP )
+         */
+        proto = PROTOCOLID_ROCE;
         rc = qed_cxt_free_ilt_range(p_hwfn, QED_ELEM_TASK, 0,
                                     qed_cxt_get_proto_tid_count(p_hwfn, proto));
         if (rc)
diff --git a/drivers/net/ethernet/qlogic/qed/qed_iwarp.c b/drivers/net/ethernet/qlogic/qed/qed_iwarp.c
index ca4a81dc1ace..d5d02be72947 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_iwarp.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_iwarp.c
@@ -1703,6 +1703,13 @@ qed_iwarp_parse_rx_pkt(struct qed_hwfn *p_hwfn,
         iph = (struct iphdr *)((u8 *)(ethh) + eth_hlen);
 
         if (eth_type == ETH_P_IP) {
+                if (iph->protocol != IPPROTO_TCP) {
+                        DP_NOTICE(p_hwfn,
+                                  "Unexpected ip protocol on ll2 %x\n",
+                                  iph->protocol);
+                        return -EINVAL;
+                }
+
                 cm_info->local_ip[0] = ntohl(iph->daddr);
                 cm_info->remote_ip[0] = ntohl(iph->saddr);
                 cm_info->ip_version = TCP_IPV4;
@@ -1711,6 +1718,14 @@ qed_iwarp_parse_rx_pkt(struct qed_hwfn *p_hwfn,
                 *payload_len = ntohs(iph->tot_len) - ip_hlen;
         } else if (eth_type == ETH_P_IPV6) {
                 ip6h = (struct ipv6hdr *)iph;
+
+                if (ip6h->nexthdr != IPPROTO_TCP) {
+                        DP_NOTICE(p_hwfn,
+                                  "Unexpected ip protocol on ll2 %x\n",
+                                  iph->protocol);
+                        return -EINVAL;
+                }
+
                 for (i = 0; i < 4; i++) {
                         cm_info->local_ip[i] =
                             ntohl(ip6h->daddr.in6_u.u6_addr32[i]);
@@ -1928,8 +1943,8 @@ qed_iwarp_update_fpdu_length(struct qed_hwfn *p_hwfn,
                 /* Missing lower byte is now available */
                 mpa_len = fpdu->fpdu_length | *mpa_data;
                 fpdu->fpdu_length = QED_IWARP_FPDU_LEN_WITH_PAD(mpa_len);
-                fpdu->mpa_frag_len = fpdu->fpdu_length;
                 /* one byte of hdr */
+                fpdu->mpa_frag_len = 1;
                 fpdu->incomplete_bytes = fpdu->fpdu_length - 1;
                 DP_VERBOSE(p_hwfn,
                            QED_MSG_RDMA,
diff --git a/drivers/net/ethernet/qlogic/qed/qed_rdma.c b/drivers/net/ethernet/qlogic/qed/qed_rdma.c
index 5d040b873137..a411f9c702a1 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_rdma.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_rdma.c
@@ -379,6 +379,7 @@ static void qed_rdma_free(struct qed_hwfn *p_hwfn)
         DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "Freeing RDMA\n");
 
         qed_rdma_free_reserved_lkey(p_hwfn);
+        qed_cxt_free_proto_ilt(p_hwfn, p_hwfn->p_rdma_info->proto);
         qed_rdma_resc_free(p_hwfn);
 }
 
diff --git a/drivers/net/ethernet/qlogic/qede/qede_main.c b/drivers/net/ethernet/qlogic/qede/qede_main.c
index 2db70eabddfe..a01e7d6e5442 100644
--- a/drivers/net/ethernet/qlogic/qede/qede_main.c
+++ b/drivers/net/ethernet/qlogic/qede/qede_main.c
@@ -288,7 +288,7 @@ int __init qede_init(void)
         }
 
         /* Must register notifier before pci ops, since we might miss
-         * interface rename after pci probe and netdev registeration.
+         * interface rename after pci probe and netdev registration.
          */
         ret = register_netdevice_notifier(&qede_netdev_notifier);
         if (ret) {
@@ -988,7 +988,7 @@ static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level,
         if (rc)
                 goto err3;
 
-        /* Prepare the lock prior to the registeration of the netdev,
+        /* Prepare the lock prior to the registration of the netdev,
          * as once it's registered we might reach flows requiring it
          * [it's even possible to reach a flow needing it directly
          * from there, although it's unlikely].
@@ -2067,8 +2067,6 @@ static int qede_load(struct qede_dev *edev, enum qede_load_mode mode,
         link_params.link_up = true;
         edev->ops->common->set_link(edev->cdev, &link_params);
 
-        qede_rdma_dev_event_open(edev);
-
         edev->state = QEDE_STATE_OPEN;
 
         DP_INFO(edev, "Ending successfully qede load\n");
@@ -2169,12 +2167,14 @@ static void qede_link_update(void *dev, struct qed_link_output *link)
                         DP_NOTICE(edev, "Link is up\n");
                         netif_tx_start_all_queues(edev->ndev);
                         netif_carrier_on(edev->ndev);
+                        qede_rdma_dev_event_open(edev);
                 }
         } else {
                 if (netif_carrier_ok(edev->ndev)) {
                         DP_NOTICE(edev, "Link is down\n");
                         netif_tx_disable(edev->ndev);
                         netif_carrier_off(edev->ndev);
+                        qede_rdma_dev_event_close(edev);
                 }
         }
 }
diff --git a/drivers/net/ethernet/qlogic/qede/qede_ptp.c b/drivers/net/ethernet/qlogic/qede/qede_ptp.c
index 9b2280badaf7..02adb513f475 100644
--- a/drivers/net/ethernet/qlogic/qede/qede_ptp.c
+++ b/drivers/net/ethernet/qlogic/qede/qede_ptp.c
@@ -485,7 +485,7 @@ int qede_ptp_enable(struct qede_dev *edev, bool init_tc)
         ptp->clock = ptp_clock_register(&ptp->clock_info, &edev->pdev->dev);
         if (IS_ERR(ptp->clock)) {
                 rc = -EINVAL;
-                DP_ERR(edev, "PTP clock registeration failed\n");
+                DP_ERR(edev, "PTP clock registration failed\n");
                 goto err2;
         }
 
diff --git a/drivers/net/ethernet/qualcomm/emac/emac-mac.c b/drivers/net/ethernet/qualcomm/emac/emac-mac.c
index 9cbb27263742..d5a32b7c7dc5 100644
--- a/drivers/net/ethernet/qualcomm/emac/emac-mac.c
+++ b/drivers/net/ethernet/qualcomm/emac/emac-mac.c
@@ -1194,9 +1194,9 @@ void emac_mac_tx_process(struct emac_adapter *adpt, struct emac_tx_queue *tx_q)
         while (tx_q->tpd.consume_idx != hw_consume_idx) {
                 tpbuf = GET_TPD_BUFFER(tx_q, tx_q->tpd.consume_idx);
                 if (tpbuf->dma_addr) {
-                        dma_unmap_single(adpt->netdev->dev.parent,
-                                         tpbuf->dma_addr, tpbuf->length,
-                                         DMA_TO_DEVICE);
+                        dma_unmap_page(adpt->netdev->dev.parent,
+                                       tpbuf->dma_addr, tpbuf->length,
+                                       DMA_TO_DEVICE);
                         tpbuf->dma_addr = 0;
                 }
 
@@ -1353,9 +1353,11 @@ static void emac_tx_fill_tpd(struct emac_adapter *adpt,
 
                 tpbuf = GET_TPD_BUFFER(tx_q, tx_q->tpd.produce_idx);
                 tpbuf->length = mapped_len;
-                tpbuf->dma_addr = dma_map_single(adpt->netdev->dev.parent,
-                                                 skb->data, tpbuf->length,
-                                                 DMA_TO_DEVICE);
+                tpbuf->dma_addr = dma_map_page(adpt->netdev->dev.parent,
+                                               virt_to_page(skb->data),
+                                               offset_in_page(skb->data),
+                                               tpbuf->length,
+                                               DMA_TO_DEVICE);
                 ret = dma_mapping_error(adpt->netdev->dev.parent,
                                         tpbuf->dma_addr);
                 if (ret)
@@ -1371,9 +1373,12 @@ static void emac_tx_fill_tpd(struct emac_adapter *adpt,
         if (mapped_len < len) {
                 tpbuf = GET_TPD_BUFFER(tx_q, tx_q->tpd.produce_idx);
                 tpbuf->length = len - mapped_len;
-                tpbuf->dma_addr = dma_map_single(adpt->netdev->dev.parent,
-                                                 skb->data + mapped_len,
-                                                 tpbuf->length, DMA_TO_DEVICE);
+                tpbuf->dma_addr = dma_map_page(adpt->netdev->dev.parent,
+                                               virt_to_page(skb->data +
+                                                            mapped_len),
+                                               offset_in_page(skb->data +
+                                                              mapped_len),
+                                               tpbuf->length, DMA_TO_DEVICE);
                 ret = dma_mapping_error(adpt->netdev->dev.parent,
                                         tpbuf->dma_addr);
                 if (ret)
diff --git a/drivers/net/ethernet/smsc/smsc911x.c b/drivers/net/ethernet/smsc/smsc911x.c
index 012fb66eed8d..f0afb88d7bc2 100644
--- a/drivers/net/ethernet/smsc/smsc911x.c
+++ b/drivers/net/ethernet/smsc/smsc911x.c
@@ -2335,14 +2335,14 @@ static int smsc911x_drv_remove(struct platform_device *pdev)
         pdata = netdev_priv(dev);
         BUG_ON(!pdata);
         BUG_ON(!pdata->ioaddr);
-        WARN_ON(dev->phydev);
 
         SMSC_TRACE(pdata, ifdown, "Stopping driver");
 
+        unregister_netdev(dev);
+
         mdiobus_unregister(pdata->mii_bus);
         mdiobus_free(pdata->mii_bus);
 
-        unregister_netdev(dev);
         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
                                            "smsc911x-memory");
         if (!res)
diff --git a/drivers/net/ethernet/socionext/sni_ave.c b/drivers/net/ethernet/socionext/sni_ave.c
index 111e7ca9df56..f5c5984afefb 100644
--- a/drivers/net/ethernet/socionext/sni_ave.c
+++ b/drivers/net/ethernet/socionext/sni_ave.c
@@ -1295,7 +1295,7 @@ static int ave_open(struct net_device *ndev)
         val |= AVE_IIRQC_EN0 | (AVE_INTM_COUNT << 16);
         writel(val, priv->base + AVE_IIRQC);
 
-        val = AVE_GI_RXIINT | AVE_GI_RXOVF | AVE_GI_TX;
+        val = AVE_GI_RXIINT | AVE_GI_RXOVF | AVE_GI_TX | AVE_GI_RXDROP;
         ave_irq_restore(ndev, val);
 
         napi_enable(&priv->napi_rx);
diff --git a/drivers/net/ethernet/sun/sunvnet.c b/drivers/net/ethernet/sun/sunvnet.c
index 63d3d6b215f3..a94f50442613 100644
--- a/drivers/net/ethernet/sun/sunvnet.c
+++ b/drivers/net/ethernet/sun/sunvnet.c
@@ -312,7 +312,7 @@ static struct vnet *vnet_new(const u64 *local_mac,
         dev->ethtool_ops = &vnet_ethtool_ops;
         dev->watchdog_timeo = VNET_TX_TIMEOUT;
 
-        dev->hw_features = NETIF_F_TSO | NETIF_F_GSO | NETIF_F_GSO_SOFTWARE |
+        dev->hw_features = NETIF_F_TSO | NETIF_F_GSO | NETIF_F_ALL_TSO |
                            NETIF_F_HW_CSUM | NETIF_F_SG;
         dev->features = dev->hw_features;
 
diff --git a/drivers/net/ethernet/ti/cpsw.c b/drivers/net/ethernet/ti/cpsw.c
index 1b1b78fdc138..b2b30c9df037 100644
--- a/drivers/net/ethernet/ti/cpsw.c
+++ b/drivers/net/ethernet/ti/cpsw.c
@@ -1014,7 +1014,8 @@ static void _cpsw_adjust_link(struct cpsw_slave *slave,
                 /* set speed_in input in case RMII mode is used in 100Mbps */
                 if (phy->speed == 100)
                         mac_control |= BIT(15);
-                else if (phy->speed == 10)
+                /* in band mode only works in 10Mbps RGMII mode */
+                else if ((phy->speed == 10) && phy_interface_is_rgmii(phy))
                         mac_control |= BIT(18); /* In Band mode */
 
                 if (priv->rx_pause)
diff --git a/drivers/net/hyperv/hyperv_net.h b/drivers/net/hyperv/hyperv_net.h
index 0db3bd1ea06f..32861036c3fc 100644
--- a/drivers/net/hyperv/hyperv_net.h
+++ b/drivers/net/hyperv/hyperv_net.h
@@ -173,6 +173,7 @@ struct rndis_device {
         struct list_head req_list;
 
         struct work_struct mcast_work;
+        u32 filter;
 
         bool link_state;        /* 0 - link up, 1 - link down */
 
@@ -211,7 +212,6 @@ void netvsc_channel_cb(void *context);
 int netvsc_poll(struct napi_struct *napi, int budget);
 
 void rndis_set_subchannel(struct work_struct *w);
-bool rndis_filter_opened(const struct netvsc_device *nvdev);
 int rndis_filter_open(struct netvsc_device *nvdev);
 int rndis_filter_close(struct netvsc_device *nvdev);
 struct netvsc_device *rndis_filter_device_add(struct hv_device *dev,
diff --git a/drivers/net/hyperv/netvsc.c b/drivers/net/hyperv/netvsc.c
index 0265d703eb03..7472172823f3 100644
--- a/drivers/net/hyperv/netvsc.c
+++ b/drivers/net/hyperv/netvsc.c
@@ -90,6 +90,11 @@ static void free_netvsc_device(struct rcu_head *head)
                 = container_of(head, struct netvsc_device, rcu);
         int i;
 
+        kfree(nvdev->extension);
+        vfree(nvdev->recv_buf);
+        vfree(nvdev->send_buf);
+        kfree(nvdev->send_section_map);
+
         for (i = 0; i < VRSS_CHANNEL_MAX; i++)
                 vfree(nvdev->chan_table[i].mrc.slots);
 
@@ -211,12 +216,6 @@ static void netvsc_teardown_gpadl(struct hv_device *device,
                 net_device->recv_buf_gpadl_handle = 0;
         }
 
-        if (net_device->recv_buf) {
-                /* Free up the receive buffer */
-                vfree(net_device->recv_buf);
-                net_device->recv_buf = NULL;
-        }
-
         if (net_device->send_buf_gpadl_handle) {
                 ret = vmbus_teardown_gpadl(device->channel,
                                            net_device->send_buf_gpadl_handle);
@@ -231,12 +230,6 @@ static void netvsc_teardown_gpadl(struct hv_device *device,
                 }
                 net_device->send_buf_gpadl_handle = 0;
         }
-        if (net_device->send_buf) {
-                /* Free up the send buffer */
-                vfree(net_device->send_buf);
-                net_device->send_buf = NULL;
-        }
-        kfree(net_device->send_section_map);
 }
 
 int netvsc_alloc_recv_comp_ring(struct netvsc_device *net_device, u32 q_idx)
@@ -562,26 +555,29 @@ void netvsc_device_remove(struct hv_device *device)
                 = rtnl_dereference(net_device_ctx->nvdev);
         int i;
 
-        cancel_work_sync(&net_device->subchan_work);
-
         netvsc_revoke_buf(device, net_device);
 
         RCU_INIT_POINTER(net_device_ctx->nvdev, NULL);
 
+        /* And disassociate NAPI context from device */
+        for (i = 0; i < net_device->num_chn; i++)
+                netif_napi_del(&net_device->chan_table[i].napi);
+
         /*
          * At this point, no one should be accessing net_device
          * except in here
          */
         netdev_dbg(ndev, "net device safe to remove\n");
 
+        /* older versions require that buffer be revoked before close */
+        if (net_device->nvsp_version < NVSP_PROTOCOL_VERSION_4)
+                netvsc_teardown_gpadl(device, net_device);
+
         /* Now, we can close the channel safely */
         vmbus_close(device->channel);
 
-        netvsc_teardown_gpadl(device, net_device);
-
-        /* And dissassociate NAPI context from device */
-        for (i = 0; i < net_device->num_chn; i++)
-                netif_napi_del(&net_device->chan_table[i].napi);
+        if (net_device->nvsp_version >= NVSP_PROTOCOL_VERSION_4)
+                netvsc_teardown_gpadl(device, net_device);
 
         /* Release all resources */
         free_netvsc_device_rcu(net_device);
@@ -645,14 +641,18 @@ static void netvsc_send_tx_complete(struct netvsc_device *net_device,
         queue_sends =
                 atomic_dec_return(&net_device->chan_table[q_idx].queue_sends);
 
-        if (net_device->destroy && queue_sends == 0)
-                wake_up(&net_device->wait_drain);
+        if (unlikely(net_device->destroy)) {
+                if (queue_sends == 0)
+                        wake_up(&net_device->wait_drain);
+        } else {
+                struct netdev_queue *txq = netdev_get_tx_queue(ndev, q_idx);
 
-        if (netif_tx_queue_stopped(netdev_get_tx_queue(ndev, q_idx)) &&
-            (hv_ringbuf_avail_percent(&channel->outbound) > RING_AVAIL_PERCENT_HIWATER ||
-             queue_sends < 1)) {
-                netif_tx_wake_queue(netdev_get_tx_queue(ndev, q_idx));
-                ndev_ctx->eth_stats.wake_queue++;
+                if (netif_tx_queue_stopped(txq) &&
+                    (hv_ringbuf_avail_percent(&channel->outbound) > RING_AVAIL_PERCENT_HIWATER ||
+                     queue_sends < 1)) {
+                        netif_tx_wake_queue(txq);
+                        ndev_ctx->eth_stats.wake_queue++;
+                }
         }
 }
 
diff --git a/drivers/net/hyperv/netvsc_drv.c b/drivers/net/hyperv/netvsc_drv.c
index cdb78eefab67..f28c85d212ce 100644
--- a/drivers/net/hyperv/netvsc_drv.c
+++ b/drivers/net/hyperv/netvsc_drv.c
@@ -46,7 +46,10 @@
 
 #include "hyperv_net.h"
 
-#define RING_SIZE_MIN           64
+#define RING_SIZE_MIN   64
+#define RETRY_US_LO     5000
+#define RETRY_US_HI     10000
+#define RETRY_MAX       2000    /* >10 sec */
 
 #define LINKCHANGE_INT (2 * HZ)
 #define VF_TAKEOVER_INT (HZ / 10)
@@ -89,15 +92,20 @@ static void netvsc_change_rx_flags(struct net_device *net, int change)
 static void netvsc_set_rx_mode(struct net_device *net)
 {
         struct net_device_context *ndev_ctx = netdev_priv(net);
-        struct net_device *vf_netdev = rtnl_dereference(ndev_ctx->vf_netdev);
-        struct netvsc_device *nvdev = rtnl_dereference(ndev_ctx->nvdev);
+        struct net_device *vf_netdev;
+        struct netvsc_device *nvdev;
 
+        rcu_read_lock();
+        vf_netdev = rcu_dereference(ndev_ctx->vf_netdev);
         if (vf_netdev) {
                 dev_uc_sync(vf_netdev, net);
                 dev_mc_sync(vf_netdev, net);
         }
 
-        rndis_filter_update(nvdev);
+        nvdev = rcu_dereference(ndev_ctx->nvdev);
+        if (nvdev)
+                rndis_filter_update(nvdev);
+        rcu_read_unlock();
 }
 
 static int netvsc_open(struct net_device *net)
@@ -118,10 +126,8 @@ static int netvsc_open(struct net_device *net)
         }
 
         rdev = nvdev->extension;
-        if (!rdev->link_state) {
+        if (!rdev->link_state)
                 netif_carrier_on(net);
-                netif_tx_wake_all_queues(net);
-        }
 
         if (vf_netdev) {
                 /* Setting synthetic device up transparently sets
@@ -137,36 +143,25 @@ static int netvsc_open(struct net_device *net)
         return 0;
 }
 
-static int netvsc_close(struct net_device *net)
+static int netvsc_wait_until_empty(struct netvsc_device *nvdev)
 {
-        struct net_device_context *net_device_ctx = netdev_priv(net);
-        struct net_device *vf_netdev
-                = rtnl_dereference(net_device_ctx->vf_netdev);
-        struct netvsc_device *nvdev = rtnl_dereference(net_device_ctx->nvdev);
-        int ret = 0;
-        u32 aread, i, msec = 10, retry = 0, retry_max = 20;
-        struct vmbus_channel *chn;
-
-        netif_tx_disable(net);
-
-        /* No need to close rndis filter if it is removed already */
-        if (!nvdev)
-                goto out;
-
-        ret = rndis_filter_close(nvdev);
-        if (ret != 0) {
-                netdev_err(net, "unable to close device (ret %d).\n", ret);
-                return ret;
-        }
+        unsigned int retry = 0;
+        int i;
 
         /* Ensure pending bytes in ring are read */
-        while (true) {
-                aread = 0;
+        for (;;) {
+                u32 aread = 0;
+
                 for (i = 0; i < nvdev->num_chn; i++) {
-                        chn = nvdev->chan_table[i].channel;
+                        struct vmbus_channel *chn
+                                = nvdev->chan_table[i].channel;
+
                         if (!chn)
                                 continue;
 
+                        /* make sure receive not running now */
+                        napi_synchronize(&nvdev->chan_table[i].napi);
+
                         aread = hv_get_bytes_to_read(&chn->inbound);
                         if (aread)
                                 break;
@@ -176,22 +171,40 @@ static int netvsc_close(struct net_device *net)
                                 break;
                 }
 
-                retry++;
-                if (retry > retry_max || aread == 0)
-                        break;
+                if (aread == 0)
+                        return 0;
 
-                msleep(msec);
+                if (++retry > RETRY_MAX)
+                        return -ETIMEDOUT;
 
-                if (msec < 1000)
-                        msec *= 2;
+                usleep_range(RETRY_US_LO, RETRY_US_HI);
         }
+}
 
-        if (aread) {
-                netdev_err(net, "Ring buffer not empty after closing rndis\n");
-                ret = -ETIMEDOUT;
+static int netvsc_close(struct net_device *net)
+{
+        struct net_device_context *net_device_ctx = netdev_priv(net);
+        struct net_device *vf_netdev
+                = rtnl_dereference(net_device_ctx->vf_netdev);
+        struct netvsc_device *nvdev = rtnl_dereference(net_device_ctx->nvdev);
+        int ret;
+
+        netif_tx_disable(net);
+
+        /* No need to close rndis filter if it is removed already */
+        if (!nvdev)
+                return 0;
+
+        ret = rndis_filter_close(nvdev);
+        if (ret != 0) {
+                netdev_err(net, "unable to close device (ret %d).\n", ret);
+                return ret;
         }
 
-out:
+        ret = netvsc_wait_until_empty(nvdev);
+        if (ret)
+                netdev_err(net, "Ring buffer not empty after closing rndis\n");
+
         if (vf_netdev)
                 dev_close(vf_netdev);
 
@@ -840,16 +853,81 @@ static void netvsc_get_channels(struct net_device *net,
         }
 }
 
+static int netvsc_detach(struct net_device *ndev,
+                         struct netvsc_device *nvdev)
+{
+        struct net_device_context *ndev_ctx = netdev_priv(ndev);
+        struct hv_device *hdev = ndev_ctx->device_ctx;
+        int ret;
+
+        /* Don't try continuing to try and setup sub channels */
+        if (cancel_work_sync(&nvdev->subchan_work))
+                nvdev->num_chn = 1;
+
+        /* If device was up (receiving) then shutdown */
+        if (netif_running(ndev)) {
+                netif_tx_disable(ndev);
+
+                ret = rndis_filter_close(nvdev);
+                if (ret) {
+                        netdev_err(ndev,
+                                   "unable to close device (ret %d).\n", ret);
+                        return ret;
+                }
+
+                ret = netvsc_wait_until_empty(nvdev);
+                if (ret) {
+                        netdev_err(ndev,
+                                   "Ring buffer not empty after closing rndis\n");
+                        return ret;
+                }
+        }
+
+        netif_device_detach(ndev);
+
+        rndis_filter_device_remove(hdev, nvdev);
+
+        return 0;
+}
+
+static int netvsc_attach(struct net_device *ndev,
+                         struct netvsc_device_info *dev_info)
+{
+        struct net_device_context *ndev_ctx = netdev_priv(ndev);
+        struct hv_device *hdev = ndev_ctx->device_ctx;
+        struct netvsc_device *nvdev;
+        struct rndis_device *rdev;
+        int ret;
+
+        nvdev = rndis_filter_device_add(hdev, dev_info);
+        if (IS_ERR(nvdev))
+                return PTR_ERR(nvdev);
+
+        /* Note: enable and attach happen when sub-channels setup */
+
+        netif_carrier_off(ndev);
+
+        if (netif_running(ndev)) {
+                ret = rndis_filter_open(nvdev);
+                if (ret)
+                        return ret;
+
+                rdev = nvdev->extension;
+                if (!rdev->link_state)
+                        netif_carrier_on(ndev);
+        }
+
+        return 0;
+}
+
 static int netvsc_set_channels(struct net_device *net,
                                struct ethtool_channels *channels)
 {
         struct net_device_context *net_device_ctx = netdev_priv(net);
-        struct hv_device *dev = net_device_ctx->device_ctx;
         struct netvsc_device *nvdev = rtnl_dereference(net_device_ctx->nvdev);
         unsigned int orig, count = channels->combined_count;
         struct netvsc_device_info device_info;
-        bool was_opened;
-        int ret = 0;
+        int ret;
 
         /* We do not support separate count for rx, tx, or other */
         if (count == 0 ||
@@ -866,9 +944,6 @@ static int netvsc_set_channels(struct net_device *net,
                 return -EINVAL;
 
         orig = nvdev->num_chn;
-        was_opened = rndis_filter_opened(nvdev);
-        if (was_opened)
-                rndis_filter_close(nvdev);
 
         memset(&device_info, 0, sizeof(device_info));
         device_info.num_chn = count;
@@ -877,28 +952,17 @@ static int netvsc_set_channels(struct net_device *net,
         device_info.recv_sections = nvdev->recv_section_cnt;
         device_info.recv_section_size = nvdev->recv_section_size;
 
-        rndis_filter_device_remove(dev, nvdev);
+        ret = netvsc_detach(net, nvdev);
+        if (ret)
+                return ret;
 
-        nvdev = rndis_filter_device_add(dev, &device_info);
-        if (IS_ERR(nvdev)) {
-                ret = PTR_ERR(nvdev);
+        ret = netvsc_attach(net, &device_info);
+        if (ret) {
                 device_info.num_chn = orig;
-                nvdev = rndis_filter_device_add(dev, &device_info);
-
-                if (IS_ERR(nvdev)) {
-                        netdev_err(net, "restoring channel setting failed: %ld\n",
-                                   PTR_ERR(nvdev));
-                        return ret;
-                }
+                if (netvsc_attach(net, &device_info))
+                        netdev_err(net, "restoring channel setting failed\n");
         }
 
-        if (was_opened)
-                rndis_filter_open(nvdev);
-
-        /* We may have missed link change notifications */
-        net_device_ctx->last_reconfig = 0;
-        schedule_delayed_work(&net_device_ctx->dwork, 0);
-
         return ret;
 }
 
@@ -964,10 +1028,8 @@ static int netvsc_change_mtu(struct net_device *ndev, int mtu)
         struct net_device_context *ndevctx = netdev_priv(ndev);
         struct net_device *vf_netdev = rtnl_dereference(ndevctx->vf_netdev);
         struct netvsc_device *nvdev = rtnl_dereference(ndevctx->nvdev);
-        struct hv_device *hdev = ndevctx->device_ctx;
         int orig_mtu = ndev->mtu;
         struct netvsc_device_info device_info;
-        bool was_opened;
         int ret = 0;
 
         if (!nvdev || nvdev->destroy)
@@ -980,11 +1042,6 @@ static int netvsc_change_mtu(struct net_device *ndev, int mtu)
                         return ret;
         }
 
-        netif_device_detach(ndev);
-        was_opened = rndis_filter_opened(nvdev);
-        if (was_opened)
-                rndis_filter_close(nvdev);
-
         memset(&device_info, 0, sizeof(device_info));
         device_info.num_chn = nvdev->num_chn;
         device_info.send_sections = nvdev->send_section_cnt;
@@ -992,35 +1049,27 @@ static int netvsc_change_mtu(struct net_device *ndev, int mtu)
         device_info.recv_sections = nvdev->recv_section_cnt;
         device_info.recv_section_size = nvdev->recv_section_size;
 
-        rndis_filter_device_remove(hdev, nvdev);
+        ret = netvsc_detach(ndev, nvdev);
+        if (ret)
+                goto rollback_vf;
 
         ndev->mtu = mtu;
 
-        nvdev = rndis_filter_device_add(hdev, &device_info);
-        if (IS_ERR(nvdev)) {
-                ret = PTR_ERR(nvdev);
-
-                /* Attempt rollback to original MTU */
-                ndev->mtu = orig_mtu;
-                nvdev = rndis_filter_device_add(hdev, &device_info);
-
-                if (vf_netdev)
-                        dev_set_mtu(vf_netdev, orig_mtu);
-
-                if (IS_ERR(nvdev)) {
-                        netdev_err(ndev, "restoring mtu failed: %ld\n",
-                                   PTR_ERR(nvdev));
-                        return ret;
-                }
-        }
+        ret = netvsc_attach(ndev, &device_info);
+        if (ret)
+                goto rollback;
 
-        if (was_opened)
-                rndis_filter_open(nvdev);
+        return 0;
 
-        netif_device_attach(ndev);
+rollback:
+        /* Attempt rollback to original MTU */
+        ndev->mtu = orig_mtu;
 
-        /* We may have missed link change notifications */
-        schedule_delayed_work(&ndevctx->dwork, 0);
+        if (netvsc_attach(ndev, &device_info))
+                netdev_err(ndev, "restoring mtu failed\n");
+rollback_vf:
+        if (vf_netdev)
+                dev_set_mtu(vf_netdev, orig_mtu);
 
         return ret;
 }
@@ -1526,11 +1575,9 @@ static int netvsc_set_ringparam(struct net_device *ndev,
 {
         struct net_device_context *ndevctx = netdev_priv(ndev);
         struct netvsc_device *nvdev = rtnl_dereference(ndevctx->nvdev);
-        struct hv_device *hdev = ndevctx->device_ctx;
         struct netvsc_device_info device_info;
         struct ethtool_ringparam orig;
         u32 new_tx, new_rx;
-        bool was_opened;
         int ret = 0;
 
         if (!nvdev || nvdev->destroy)
@@ -1555,34 +1602,18 @@ static int netvsc_set_ringparam(struct net_device *ndev,
         device_info.recv_sections = new_rx;
         device_info.recv_section_size = nvdev->recv_section_size;
 
-        netif_device_detach(ndev);
-        was_opened = rndis_filter_opened(nvdev);
-        if (was_opened)
-                rndis_filter_close(nvdev);
-
-        rndis_filter_device_remove(hdev, nvdev);
-
-        nvdev = rndis_filter_device_add(hdev, &device_info);
-        if (IS_ERR(nvdev)) {
-                ret = PTR_ERR(nvdev);
+        ret = netvsc_detach(ndev, nvdev);
+        if (ret)
+                return ret;
 
+        ret = netvsc_attach(ndev, &device_info);
+        if (ret) {
                 device_info.send_sections = orig.tx_pending;
                 device_info.recv_sections = orig.rx_pending;
-                nvdev = rndis_filter_device_add(hdev, &device_info);
-                if (IS_ERR(nvdev)) {
-                        netdev_err(ndev, "restoring ringparam failed: %ld\n",
-                                   PTR_ERR(nvdev));
-                        return ret;
-                }
-        }
-
-        if (was_opened)
-                rndis_filter_open(nvdev);
-        netif_device_attach(ndev);
 
-        /* We may have missed link change notifications */
-        ndevctx->last_reconfig = 0;
-        schedule_delayed_work(&ndevctx->dwork, 0);
+                if (netvsc_attach(ndev, &device_info))
+                        netdev_err(ndev, "restoring ringparam failed");
+        }
 
         return ret;
 }
@@ -1846,8 +1877,12 @@ static void __netvsc_vf_setup(struct net_device *ndev,
 
         /* set multicast etc flags on VF */
         dev_change_flags(vf_netdev, ndev->flags | IFF_SLAVE);
+
+        /* sync address list from ndev to VF */
+        netif_addr_lock_bh(ndev);
         dev_uc_sync(vf_netdev, ndev);
         dev_mc_sync(vf_netdev, ndev);
+        netif_addr_unlock_bh(ndev);
 
         if (netif_running(ndev)) {
                 ret = dev_open(vf_netdev);
@@ -2063,8 +2098,8 @@ no_net:
 static int netvsc_remove(struct hv_device *dev)
 {
         struct net_device_context *ndev_ctx;
-        struct net_device *vf_netdev;
-        struct net_device *net;
+        struct net_device *vf_netdev, *net;
+        struct netvsc_device *nvdev;
 
         net = hv_get_drvdata(dev);
         if (net == NULL) {
@@ -2074,10 +2109,14 @@ static int netvsc_remove(struct hv_device *dev)
 
         ndev_ctx = netdev_priv(net);
 
-        netif_device_detach(net);
-
         cancel_delayed_work_sync(&ndev_ctx->dwork);
 
+        rcu_read_lock();
+        nvdev = rcu_dereference(ndev_ctx->nvdev);
+
+        if  (nvdev)
+                cancel_work_sync(&nvdev->subchan_work);
+
         /*
          * Call to the vsc driver to let it know that the device is being
          * removed. Also blocks mtu and channel changes.
@@ -2087,11 +2126,13 @@ static int netvsc_remove(struct hv_device *dev)
         if (vf_netdev)
                 netvsc_unregister_vf(vf_netdev);
 
+        if (nvdev)
+                rndis_filter_device_remove(dev, nvdev);
+
         unregister_netdevice(net);
 
-        rndis_filter_device_remove(dev,
-                                   rtnl_dereference(ndev_ctx->nvdev));
         rtnl_unlock();
+        rcu_read_unlock();
 
         hv_set_drvdata(dev, NULL);
 
diff --git a/drivers/net/hyperv/rndis_filter.c b/drivers/net/hyperv/rndis_filter.c
index 8927c483c217..a6ec41c399d6 100644
--- a/drivers/net/hyperv/rndis_filter.c
+++ b/drivers/net/hyperv/rndis_filter.c
@@ -264,13 +264,23 @@ static void rndis_set_link_state(struct rndis_device *rdev,
         }
 }
 
-static void rndis_filter_receive_response(struct rndis_device *dev,
-                                       struct rndis_message *resp)
+static void rndis_filter_receive_response(struct net_device *ndev,
+                                          struct netvsc_device *nvdev,
+                                          const struct rndis_message *resp)
 {
+        struct rndis_device *dev = nvdev->extension;
         struct rndis_request *request = NULL;
         bool found = false;
         unsigned long flags;
-        struct net_device *ndev = dev->ndev;
+
+        /* This should never happen, it means control message
+         * response received after device removed.
+         */
+        if (dev->state == RNDIS_DEV_UNINITIALIZED) {
+                netdev_err(ndev,
+                           "got rndis message uninitialized\n");
+                return;
+        }
 
         spin_lock_irqsave(&dev->request_lock, flags);
         list_for_each_entry(request, &dev->req_list, list_ent) {
@@ -352,7 +362,6 @@ static inline void *rndis_get_ppi(struct rndis_packet *rpkt, u32 type)
 
 static int rndis_filter_receive_data(struct net_device *ndev,
                                      struct netvsc_device *nvdev,
-                                     struct rndis_device *dev,
                                      struct rndis_message *msg,
                                      struct vmbus_channel *channel,
                                      void *data, u32 data_buflen)
@@ -372,7 +381,7 @@ static int rndis_filter_receive_data(struct net_device *ndev,
          * should be the data packet size plus the trailer padding size
          */
         if (unlikely(data_buflen < rndis_pkt->data_len)) {
-                netdev_err(dev->ndev, "rndis message buffer "
+                netdev_err(ndev, "rndis message buffer "
                            "overflow detected (got %u, min %u)"
                            "...dropping this message!\n",
                            data_buflen, rndis_pkt->data_len);
@@ -400,35 +409,20 @@ int rndis_filter_receive(struct net_device *ndev,
                          void *data, u32 buflen)
 {
         struct net_device_context *net_device_ctx = netdev_priv(ndev);
-        struct rndis_device *rndis_dev = net_dev->extension;
         struct rndis_message *rndis_msg = data;
 
-        /* Make sure the rndis device state is initialized */
-        if (unlikely(!rndis_dev)) {
-                netif_dbg(net_device_ctx, rx_err, ndev,
-                          "got rndis message but no rndis device!\n");
-                return NVSP_STAT_FAIL;
-        }
-
-        if (unlikely(rndis_dev->state == RNDIS_DEV_UNINITIALIZED)) {
-                netif_dbg(net_device_ctx, rx_err, ndev,
-                          "got rndis message uninitialized\n");
-                return NVSP_STAT_FAIL;
-        }
-
         if (netif_msg_rx_status(net_device_ctx))
                 dump_rndis_message(ndev, rndis_msg);
 
         switch (rndis_msg->ndis_msg_type) {
         case RNDIS_MSG_PACKET:
-                return rndis_filter_receive_data(ndev, net_dev,
-                                                 rndis_dev, rndis_msg,
+                return rndis_filter_receive_data(ndev, net_dev, rndis_msg,
                                                  channel, data, buflen);
         case RNDIS_MSG_INIT_C:
         case RNDIS_MSG_QUERY_C:
         case RNDIS_MSG_SET_C:
                 /* completion msgs */
-                rndis_filter_receive_response(rndis_dev, rndis_msg);
+                rndis_filter_receive_response(ndev, net_dev, rndis_msg);
                 break;
 
         case RNDIS_MSG_INDICATE:
@@ -825,13 +819,15 @@ static int rndis_filter_set_packet_filter(struct rndis_device *dev,
         struct rndis_set_request *set;
         int ret;
 
+        if (dev->filter == new_filter)
+                return 0;
+
         request = get_rndis_request(dev, RNDIS_MSG_SET,
                         RNDIS_MESSAGE_SIZE(struct rndis_set_request) +
                         sizeof(u32));
         if (!request)
                 return -ENOMEM;
 
-
         /* Setup the rndis set */
         set = &request->request_msg.msg.set_req;
         set->oid = RNDIS_OID_GEN_CURRENT_PACKET_FILTER;
@@ -842,8 +838,10 @@ static int rndis_filter_set_packet_filter(struct rndis_device *dev,
                &new_filter, sizeof(u32));
 
         ret = rndis_filter_send_request(dev, request);
-        if (ret == 0)
+        if (ret == 0) {
                 wait_for_completion(&request->wait_event);
+                dev->filter = new_filter;
+        }
 
         put_rndis_request(dev, request);
 
@@ -861,9 +859,9 @@ static void rndis_set_multicast(struct work_struct *w)
                 filter = NDIS_PACKET_TYPE_PROMISCUOUS;
         } else {
                 if (flags & IFF_ALLMULTI)
-                        flags |= NDIS_PACKET_TYPE_ALL_MULTICAST;
+                        filter |= NDIS_PACKET_TYPE_ALL_MULTICAST;
                 if (flags & IFF_BROADCAST)
-                        flags |= NDIS_PACKET_TYPE_BROADCAST;
+                        filter |= NDIS_PACKET_TYPE_BROADCAST;
         }
 
         rndis_filter_set_packet_filter(rdev, filter);
@@ -1120,6 +1118,7 @@ void rndis_set_subchannel(struct work_struct *w)
         for (i = 0; i < VRSS_SEND_TAB_SIZE; i++)
                 ndev_ctx->tx_table[i] = i % nvdev->num_chn;
 
+        netif_device_attach(ndev);
         rtnl_unlock();
         return;
 
@@ -1130,6 +1129,8 @@ failed:
 
         nvdev->max_chn = 1;
         nvdev->num_chn = 1;
+
+        netif_device_attach(ndev);
 unlock:
         rtnl_unlock();
 }
@@ -1332,6 +1333,10 @@ out:
                 net_device->num_chn = 1;
         }
 
+        /* No sub channels, device is ready */
+        if (net_device->num_chn == 1)
+                netif_device_attach(net);
+
         return net_device;
 
 err_dev_remv:
@@ -1344,16 +1349,12 @@ void rndis_filter_device_remove(struct hv_device *dev,
 {
         struct rndis_device *rndis_dev = net_dev->extension;
 
-        /* Don't try and setup sub channels if about to halt */
-        cancel_work_sync(&net_dev->subchan_work);
-
         /* Halt and release the rndis device */
         rndis_filter_halt_device(rndis_dev);
 
         net_dev->extension = NULL;
 
         netvsc_device_remove(dev);
-        kfree(rndis_dev);
 }
 
 int rndis_filter_open(struct netvsc_device *nvdev)
@@ -1371,10 +1372,3 @@ int rndis_filter_close(struct netvsc_device *nvdev)
 
         return rndis_filter_close_device(nvdev->extension);
 }
-
-bool rndis_filter_opened(const struct netvsc_device *nvdev)
-{
-        const struct rndis_device *dev = nvdev->extension;
-
-        return dev->state == RNDIS_DEV_DATAINITIALIZED;
-}
diff --git a/drivers/net/macsec.c b/drivers/net/macsec.c
index 7de88b33d5b9..9cbb0c8a896a 100644
--- a/drivers/net/macsec.c
+++ b/drivers/net/macsec.c
@@ -3277,7 +3277,7 @@ static int macsec_newlink(struct net *net, struct net_device *dev,
 
         err = netdev_upper_dev_link(real_dev, dev, extack);
         if (err < 0)
-                goto unregister;
+                goto put_dev;
 
         /* need to be already registered so that ->init has run and
          * the MAC addr is set
@@ -3316,7 +3316,8 @@ del_dev:
         macsec_del_dev(macsec);
 unlink:
         netdev_upper_dev_unlink(real_dev, dev);
-unregister:
+put_dev:
+        dev_put(real_dev);
         unregister_netdevice(dev);
         return err;
 }
diff --git a/drivers/net/macvlan.c b/drivers/net/macvlan.c
index 8fc02d9db3d0..725f4b4afc6d 100644
--- a/drivers/net/macvlan.c
+++ b/drivers/net/macvlan.c
@@ -1036,7 +1036,7 @@ static netdev_features_t macvlan_fix_features(struct net_device *dev,
         lowerdev_features &= (features | ~NETIF_F_LRO);
         features = netdev_increment_features(lowerdev_features, features, mask);
         features |= ALWAYS_ON_FEATURES;
-        features &= ~NETIF_F_NETNS_LOCAL;
+        features &= (ALWAYS_ON_FEATURES | MACVLAN_FEATURES);
 
         return features;
 }
diff --git a/drivers/net/phy/bcm-phy-lib.c b/drivers/net/phy/bcm-phy-lib.c
index 171010eb4d9c..5ad130c3da43 100644
--- a/drivers/net/phy/bcm-phy-lib.c
+++ b/drivers/net/phy/bcm-phy-lib.c
@@ -341,8 +341,8 @@ void bcm_phy_get_strings(struct phy_device *phydev, u8 *data)
         unsigned int i;
 
         for (i = 0; i < ARRAY_SIZE(bcm_phy_hw_stats); i++)
-                memcpy(data + i * ETH_GSTRING_LEN,
-                       bcm_phy_hw_stats[i].string, ETH_GSTRING_LEN);
+                strlcpy(data + i * ETH_GSTRING_LEN,
+                        bcm_phy_hw_stats[i].string, ETH_GSTRING_LEN);
 }
 EXPORT_SYMBOL_GPL(bcm_phy_get_strings);
 
diff --git a/drivers/net/phy/marvell.c b/drivers/net/phy/marvell.c
index 22d9bc9c33a4..0e0978d8a0eb 100644
--- a/drivers/net/phy/marvell.c
+++ b/drivers/net/phy/marvell.c
@@ -1452,8 +1452,8 @@ static void marvell_get_strings(struct phy_device *phydev, u8 *data)
         int i;
 
         for (i = 0; i < ARRAY_SIZE(marvell_hw_stats); i++) {
-                memcpy(data + i * ETH_GSTRING_LEN,
-                       marvell_hw_stats[i].string, ETH_GSTRING_LEN);
+                strlcpy(data + i * ETH_GSTRING_LEN,
+                        marvell_hw_stats[i].string, ETH_GSTRING_LEN);
         }
 }
 
diff --git a/drivers/net/phy/micrel.c b/drivers/net/phy/micrel.c
index 0f45310300f6..f41b224a9cdb 100644
--- a/drivers/net/phy/micrel.c
+++ b/drivers/net/phy/micrel.c
@@ -635,25 +635,6 @@ static int ksz8873mll_config_aneg(struct phy_device *phydev)
         return 0;
 }
 
-/* This routine returns -1 as an indication to the caller that the
- * Micrel ksz9021 10/100/1000 PHY does not support standard IEEE
- * MMD extended PHY registers.
- */
-static int
-ksz9021_rd_mmd_phyreg(struct phy_device *phydev, int devad, u16 regnum)
-{
-        return -1;
-}
-
-/* This routine does nothing since the Micrel ksz9021 does not support
- * standard IEEE MMD extended PHY registers.
- */
-static int
-ksz9021_wr_mmd_phyreg(struct phy_device *phydev, int devad, u16 regnum, u16 val)
-{
-        return -1;
-}
-
 static int kszphy_get_sset_count(struct phy_device *phydev)
 {
         return ARRAY_SIZE(kszphy_hw_stats);
@@ -664,8 +645,8 @@ static void kszphy_get_strings(struct phy_device *phydev, u8 *data)
         int i;
 
         for (i = 0; i < ARRAY_SIZE(kszphy_hw_stats); i++) {
-                memcpy(data + i * ETH_GSTRING_LEN,
-                       kszphy_hw_stats[i].string, ETH_GSTRING_LEN);
+                strlcpy(data + i * ETH_GSTRING_LEN,
+                        kszphy_hw_stats[i].string, ETH_GSTRING_LEN);
         }
 }
 
@@ -946,8 +927,8 @@ static struct phy_driver ksphy_driver[] = {
         .get_stats      = kszphy_get_stats,
         .suspend        = genphy_suspend,
         .resume         = genphy_resume,
-        .read_mmd       = ksz9021_rd_mmd_phyreg,
-        .write_mmd      = ksz9021_wr_mmd_phyreg,
+        .read_mmd       = genphy_read_mmd_unsupported,
+        .write_mmd      = genphy_write_mmd_unsupported,
 }, {
         .phy_id         = PHY_ID_KSZ9031,
         .phy_id_mask    = MICREL_PHY_ID_MASK,
diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c
index a6f924fee584..9aabfa1a455a 100644
--- a/drivers/net/phy/phy.c
+++ b/drivers/net/phy/phy.c
@@ -618,6 +618,77 @@ static void phy_error(struct phy_device *phydev)
 }
 
 /**
+ * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
+ * @phydev: target phy_device struct
+ */
+static int phy_disable_interrupts(struct phy_device *phydev)
+{
+        int err;
+
+        /* Disable PHY interrupts */
+        err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
+        if (err)
+                goto phy_err;
+
+        /* Clear the interrupt */
+        err = phy_clear_interrupt(phydev);
+        if (err)
+                goto phy_err;
+
+        return 0;
+
+phy_err:
+        phy_error(phydev);
+
+        return err;
+}
+
+/**
+ * phy_change - Called by the phy_interrupt to handle PHY changes
+ * @phydev: phy_device struct that interrupted
+ */
+static irqreturn_t phy_change(struct phy_device *phydev)
+{
+        if (phy_interrupt_is_valid(phydev)) {
+                if (phydev->drv->did_interrupt &&
+                    !phydev->drv->did_interrupt(phydev))
+                        return IRQ_NONE;
+
+                if (phydev->state == PHY_HALTED)
+                        if (phy_disable_interrupts(phydev))
+                                goto phy_err;
+        }
+
+        mutex_lock(&phydev->lock);
+        if ((PHY_RUNNING == phydev->state) || (PHY_NOLINK == phydev->state))
+                phydev->state = PHY_CHANGELINK;
+        mutex_unlock(&phydev->lock);
+
+        /* reschedule state queue work to run as soon as possible */
+        phy_trigger_machine(phydev, true);
+
+        if (phy_interrupt_is_valid(phydev) && phy_clear_interrupt(phydev))
+                goto phy_err;
+        return IRQ_HANDLED;
+
+phy_err:
+        phy_error(phydev);
+        return IRQ_NONE;
+}
+
+/**
+ * phy_change_work - Scheduled by the phy_mac_interrupt to handle PHY changes
+ * @work: work_struct that describes the work to be done
+ */
+void phy_change_work(struct work_struct *work)
+{
+        struct phy_device *phydev =
+                container_of(work, struct phy_device, phy_queue);
+
+        phy_change(phydev);
+}
+
+/**
  * phy_interrupt - PHY interrupt handler
  * @irq: interrupt line
  * @phy_dat: phy_device pointer
@@ -632,9 +703,7 @@ static irqreturn_t phy_interrupt(int irq, void *phy_dat)
         if (PHY_HALTED == phydev->state)
                 return IRQ_NONE;                /* It can't be ours.  */
 
-        phy_change(phydev);
-
-        return IRQ_HANDLED;
+        return phy_change(phydev);
 }
 
 /**
@@ -652,32 +721,6 @@ static int phy_enable_interrupts(struct phy_device *phydev)
 }
 
 /**
- * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
- * @phydev: target phy_device struct
- */
-static int phy_disable_interrupts(struct phy_device *phydev)
-{
-        int err;
-
-        /* Disable PHY interrupts */
-        err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
-        if (err)
-                goto phy_err;
-
-        /* Clear the interrupt */
-        err = phy_clear_interrupt(phydev);
-        if (err)
-                goto phy_err;
-
-        return 0;
-
-phy_err:
-        phy_error(phydev);
-
-        return err;
-}
-
-/**
  * phy_start_interrupts - request and enable interrupts for a PHY device
  * @phydev: target phy_device struct
  *
@@ -720,50 +763,6 @@ int phy_stop_interrupts(struct phy_device *phydev)
 EXPORT_SYMBOL(phy_stop_interrupts);
 
 /**
- * phy_change - Called by the phy_interrupt to handle PHY changes
- * @phydev: phy_device struct that interrupted
- */
-void phy_change(struct phy_device *phydev)
-{
-        if (phy_interrupt_is_valid(phydev)) {
-                if (phydev->drv->did_interrupt &&
-                    !phydev->drv->did_interrupt(phydev))
-                        return;
-
-                if (phydev->state == PHY_HALTED)
-                        if (phy_disable_interrupts(phydev))
-                                goto phy_err;
-        }
-
-        mutex_lock(&phydev->lock);
-        if ((PHY_RUNNING == phydev->state) || (PHY_NOLINK == phydev->state))
-                phydev->state = PHY_CHANGELINK;
-        mutex_unlock(&phydev->lock);
-
-        /* reschedule state queue work to run as soon as possible */
-        phy_trigger_machine(phydev, true);
-
-        if (phy_interrupt_is_valid(phydev) && phy_clear_interrupt(phydev))
-                goto phy_err;
-        return;
-
-phy_err:
-        phy_error(phydev);
-}
-
-/**
- * phy_change_work - Scheduled by the phy_mac_interrupt to handle PHY changes
- * @work: work_struct that describes the work to be done
- */
-void phy_change_work(struct work_struct *work)
-{
-        struct phy_device *phydev =
-                container_of(work, struct phy_device, phy_queue);
-
-        phy_change(phydev);
-}
-
-/**
  * phy_stop - Bring down the PHY link, and stop checking the status
  * @phydev: target phy_device struct
  */
diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c
index 478405e544cc..74664a6c0cdc 100644
--- a/drivers/net/phy/phy_device.c
+++ b/drivers/net/phy/phy_device.c
@@ -1012,10 +1012,17 @@ int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
         err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj,
                                 "attached_dev");
         if (!err) {
-                err = sysfs_create_link(&dev->dev.kobj, &phydev->mdio.dev.kobj,
-                                        "phydev");
-                if (err)
-                        goto error;
+                err = sysfs_create_link_nowarn(&dev->dev.kobj,
+                                               &phydev->mdio.dev.kobj,
+                                               "phydev");
+                if (err) {
+                        dev_err(&dev->dev, "could not add device link to %s err %d\n",
+                                kobject_name(&phydev->mdio.dev.kobj),
+                                err);
+                        /* non-fatal - some net drivers can use one netdevice
+                         * with more then one phy
+                         */
+                }
 
                 phydev->sysfs_links = true;
         }
@@ -1666,6 +1673,23 @@ int genphy_config_init(struct phy_device *phydev)
 }
 EXPORT_SYMBOL(genphy_config_init);
 
+/* This is used for the phy device which doesn't support the MMD extended
+ * register access, but it does have side effect when we are trying to access
+ * the MMD register via indirect method.
+ */
+int genphy_read_mmd_unsupported(struct phy_device *phdev, int devad, u16 regnum)
+{
+        return -EOPNOTSUPP;
+}
+EXPORT_SYMBOL(genphy_read_mmd_unsupported);
+
+int genphy_write_mmd_unsupported(struct phy_device *phdev, int devnum,
+                                 u16 regnum, u16 val)
+{
+        return -EOPNOTSUPP;
+}
+EXPORT_SYMBOL(genphy_write_mmd_unsupported);
+
 int genphy_suspend(struct phy_device *phydev)
 {
         return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN);
diff --git a/drivers/net/phy/realtek.c b/drivers/net/phy/realtek.c
index ee3ca4a2f12b..9f48ecf9c627 100644
--- a/drivers/net/phy/realtek.c
+++ b/drivers/net/phy/realtek.c
@@ -172,6 +172,8 @@ static struct phy_driver realtek_drvs[] = {
                 .flags          = PHY_HAS_INTERRUPT,
                 .ack_interrupt  = &rtl821x_ack_interrupt,
                 .config_intr    = &rtl8211b_config_intr,
+                .read_mmd       = &genphy_read_mmd_unsupported,
+                .write_mmd      = &genphy_write_mmd_unsupported,
         }, {
                 .phy_id         = 0x001cc914,
                 .name           = "RTL8211DN Gigabit Ethernet",
diff --git a/drivers/net/ppp/ppp_generic.c b/drivers/net/ppp/ppp_generic.c
index fa2a9bdd1866..da1937832c99 100644
--- a/drivers/net/ppp/ppp_generic.c
+++ b/drivers/net/ppp/ppp_generic.c
@@ -257,7 +257,7 @@ struct ppp_net {
 /* Prototypes. */
 static int ppp_unattached_ioctl(struct net *net, struct ppp_file *pf,
                         struct file *file, unsigned int cmd, unsigned long arg);
-static void ppp_xmit_process(struct ppp *ppp);
+static void ppp_xmit_process(struct ppp *ppp, struct sk_buff *skb);
 static void ppp_send_frame(struct ppp *ppp, struct sk_buff *skb);
 static void ppp_push(struct ppp *ppp);
 static void ppp_channel_push(struct channel *pch);
@@ -513,13 +513,12 @@ static ssize_t ppp_write(struct file *file, const char __user *buf,
                 goto out;
         }
 
-        skb_queue_tail(&pf->xq, skb);
-
         switch (pf->kind) {
         case INTERFACE:
-                ppp_xmit_process(PF_TO_PPP(pf));
+                ppp_xmit_process(PF_TO_PPP(pf), skb);
                 break;
         case CHANNEL:
+                skb_queue_tail(&pf->xq, skb);
                 ppp_channel_push(PF_TO_CHANNEL(pf));
                 break;
         }
@@ -1267,8 +1266,8 @@ ppp_start_xmit(struct sk_buff *skb, struct net_device *dev)
         put_unaligned_be16(proto, pp);
 
         skb_scrub_packet(skb, !net_eq(ppp->ppp_net, dev_net(dev)));
-        skb_queue_tail(&ppp->file.xq, skb);
-        ppp_xmit_process(ppp);
+        ppp_xmit_process(ppp, skb);
+
         return NETDEV_TX_OK;
 
  outf:
@@ -1420,13 +1419,14 @@ static void ppp_setup(struct net_device *dev)
  */
 
 /* Called to do any work queued up on the transmit side that can now be done */
-static void __ppp_xmit_process(struct ppp *ppp)
+static void __ppp_xmit_process(struct ppp *ppp, struct sk_buff *skb)
 {
-        struct sk_buff *skb;
-
         ppp_xmit_lock(ppp);
         if (!ppp->closing) {
                 ppp_push(ppp);
+
+                if (skb)
+                        skb_queue_tail(&ppp->file.xq, skb);
                 while (!ppp->xmit_pending &&
                        (skb = skb_dequeue(&ppp->file.xq)))
                         ppp_send_frame(ppp, skb);
@@ -1440,7 +1440,7 @@ static void __ppp_xmit_process(struct ppp *ppp)
         ppp_xmit_unlock(ppp);
 }
 
-static void ppp_xmit_process(struct ppp *ppp)
+static void ppp_xmit_process(struct ppp *ppp, struct sk_buff *skb)
 {
         local_bh_disable();
 
@@ -1448,7 +1448,7 @@ static void ppp_xmit_process(struct ppp *ppp)
                 goto err;
 
         (*this_cpu_ptr(ppp->xmit_recursion))++;
-        __ppp_xmit_process(ppp);
+        __ppp_xmit_process(ppp, skb);
         (*this_cpu_ptr(ppp->xmit_recursion))--;
 
         local_bh_enable();
@@ -1458,6 +1458,8 @@ static void ppp_xmit_process(struct ppp *ppp)
 err:
         local_bh_enable();
 
+        kfree_skb(skb);
+
         if (net_ratelimit())
                 netdev_err(ppp->dev, "recursion detected\n");
 }
@@ -1942,7 +1944,7 @@ static void __ppp_channel_push(struct channel *pch)
         if (skb_queue_empty(&pch->file.xq)) {
                 ppp = pch->ppp;
                 if (ppp)
-                        __ppp_xmit_process(ppp);
+                        __ppp_xmit_process(ppp, NULL);
         }
 }
 
diff --git a/drivers/net/team/team.c b/drivers/net/team/team.c
index a468439969df..56c701b73c12 100644
--- a/drivers/net/team/team.c
+++ b/drivers/net/team/team.c
@@ -2395,7 +2395,7 @@ send_done:
         if (!nlh) {
                 err = __send_and_alloc_skb(&skb, team, portid, send_func);
                 if (err)
-                        goto errout;
+                        return err;
                 goto send_done;
         }
 
@@ -2681,7 +2681,7 @@ send_done:
         if (!nlh) {
                 err = __send_and_alloc_skb(&skb, team, portid, send_func);
                 if (err)
-                        goto errout;
+                        return err;
                 goto send_done;
         }
 
diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index 7433bb2e4451..28cfa642e39a 100644
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -655,7 +655,7 @@ static struct tun_struct *tun_enable_queue(struct tun_file *tfile)
         return tun;
 }
 
-static void tun_ptr_free(void *ptr)
+void tun_ptr_free(void *ptr)
 {
         if (!ptr)
                 return;
@@ -667,6 +667,7 @@ static void tun_ptr_free(void *ptr)
                 __skb_array_destroy_skb(ptr);
         }
 }
+EXPORT_SYMBOL_GPL(tun_ptr_free);
 
 static void tun_queue_purge(struct tun_file *tfile)
 {
diff --git a/drivers/net/usb/usbnet.c b/drivers/net/usb/usbnet.c
index 8a22ff67b026..d9eea8cfe6cb 100644
--- a/drivers/net/usb/usbnet.c
+++ b/drivers/net/usb/usbnet.c
@@ -315,6 +315,7 @@ static void __usbnet_status_stop_force(struct usbnet *dev)
 void usbnet_skb_return (struct usbnet *dev, struct sk_buff *skb)
 {
         struct pcpu_sw_netstats *stats64 = this_cpu_ptr(dev->stats64);
+        unsigned long flags;
         int     status;
 
         if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
@@ -326,10 +327,10 @@ void usbnet_skb_return (struct usbnet *dev, struct sk_buff *skb)
         if (skb->protocol == 0)
                 skb->protocol = eth_type_trans (skb, dev->net);
 
-        u64_stats_update_begin(&stats64->syncp);
+        flags = u64_stats_update_begin_irqsave(&stats64->syncp);
         stats64->rx_packets++;
         stats64->rx_bytes += skb->len;
-        u64_stats_update_end(&stats64->syncp);
+        u64_stats_update_end_irqrestore(&stats64->syncp, flags);
 
         netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
                   skb->len + sizeof (struct ethhdr), skb->protocol);
@@ -1248,11 +1249,12 @@ static void tx_complete (struct urb *urb)
 
         if (urb->status == 0) {
                 struct pcpu_sw_netstats *stats64 = this_cpu_ptr(dev->stats64);
+                unsigned long flags;
 
-                u64_stats_update_begin(&stats64->syncp);
+                flags = u64_stats_update_begin_irqsave(&stats64->syncp);
                 stats64->tx_packets += entry->packets;
                 stats64->tx_bytes += entry->length;
-                u64_stats_update_end(&stats64->syncp);
+                u64_stats_update_end_irqrestore(&stats64->syncp, flags);
         } else {
                 dev->net->stats.tx_errors++;
 
diff --git a/drivers/net/vmxnet3/vmxnet3_drv.c b/drivers/net/vmxnet3/vmxnet3_drv.c
index 8b39c160743d..e04937f44f33 100644
--- a/drivers/net/vmxnet3/vmxnet3_drv.c
+++ b/drivers/net/vmxnet3/vmxnet3_drv.c
@@ -977,6 +977,8 @@ vmxnet3_tq_xmit(struct sk_buff *skb, struct vmxnet3_tx_queue *tq,
 {
         int ret;
         u32 count;
+        int num_pkts;
+        int tx_num_deferred;
         unsigned long flags;
         struct vmxnet3_tx_ctx ctx;
         union Vmxnet3_GenericDesc *gdesc;
@@ -1075,12 +1077,12 @@ vmxnet3_tq_xmit(struct sk_buff *skb, struct vmxnet3_tx_queue *tq,
 #else
         gdesc = ctx.sop_txd;
 #endif
+        tx_num_deferred = le32_to_cpu(tq->shared->txNumDeferred);
         if (ctx.mss) {
                 gdesc->txd.hlen = ctx.eth_ip_hdr_size + ctx.l4_hdr_size;
                 gdesc->txd.om = VMXNET3_OM_TSO;
                 gdesc->txd.msscof = ctx.mss;
-                le32_add_cpu(&tq->shared->txNumDeferred, (skb->len -
-                             gdesc->txd.hlen + ctx.mss - 1) / ctx.mss);
+                num_pkts = (skb->len - gdesc->txd.hlen + ctx.mss - 1) / ctx.mss;
         } else {
                 if (skb->ip_summed == CHECKSUM_PARTIAL) {
                         gdesc->txd.hlen = ctx.eth_ip_hdr_size;
@@ -1091,8 +1093,10 @@ vmxnet3_tq_xmit(struct sk_buff *skb, struct vmxnet3_tx_queue *tq,
                         gdesc->txd.om = 0;
                         gdesc->txd.msscof = 0;
                 }
-                le32_add_cpu(&tq->shared->txNumDeferred, 1);
+                num_pkts = 1;
         }
+        le32_add_cpu(&tq->shared->txNumDeferred, num_pkts);
+        tx_num_deferred += num_pkts;
 
         if (skb_vlan_tag_present(skb)) {
                 gdesc->txd.ti = 1;
@@ -1118,8 +1122,7 @@ vmxnet3_tq_xmit(struct sk_buff *skb, struct vmxnet3_tx_queue *tq,
 
         spin_unlock_irqrestore(&tq->tx_lock, flags);
 
-        if (le32_to_cpu(tq->shared->txNumDeferred) >=
-                                        le32_to_cpu(tq->shared->txThreshold)) {
+        if (tx_num_deferred >= le32_to_cpu(tq->shared->txThreshold)) {
                 tq->shared->txNumDeferred = 0;
                 VMXNET3_WRITE_BAR0_REG(adapter,
                                        VMXNET3_REG_TXPROD + tq->qid * 8,
@@ -1470,7 +1473,8 @@ vmxnet3_rq_rx_complete(struct vmxnet3_rx_queue *rq,
                         vmxnet3_rx_csum(adapter, skb,
                                         (union Vmxnet3_GenericDesc *)rcd);
                         skb->protocol = eth_type_trans(skb, adapter->netdev);
-                        if (!rcd->tcp || !adapter->lro)
+                        if (!rcd->tcp ||
+                            !(adapter->netdev->features & NETIF_F_LRO))
                                 goto not_lro;
 
                         if (segCnt != 0 && mss != 0) {
diff --git a/drivers/net/vmxnet3/vmxnet3_int.h b/drivers/net/vmxnet3/vmxnet3_int.h
index 5ba222920e80..59ec34052a65 100644
--- a/drivers/net/vmxnet3/vmxnet3_int.h
+++ b/drivers/net/vmxnet3/vmxnet3_int.h
@@ -69,10 +69,10 @@
 /*
  * Version numbers
  */
-#define VMXNET3_DRIVER_VERSION_STRING   "1.4.11.0-k"
+#define VMXNET3_DRIVER_VERSION_STRING   "1.4.13.0-k"
 
 /* a 32-bit int, each byte encode a verion number in VMXNET3_DRIVER_VERSION */
-#define VMXNET3_DRIVER_VERSION_NUM      0x01040b00
+#define VMXNET3_DRIVER_VERSION_NUM      0x01040d00
 
 #if defined(CONFIG_PCI_MSI)
         /* RSS only makes sense if MSI-X is supported. */
@@ -342,9 +342,6 @@ struct vmxnet3_adapter {
         u8                      __iomem *hw_addr1; /* for BAR 1 */
         u8                              version;
 
-        bool                            rxcsum;
-        bool                            lro;
-
 #ifdef VMXNET3_RSS
         struct UPT1_RSSConf             *rss_conf;
         bool                            rss;
diff --git a/drivers/net/wireless/ath/ath9k/htc_drv_init.c b/drivers/net/wireless/ath/ath9k/htc_drv_init.c
index e89e5ef2c2a4..f246e9ed4a81 100644
--- a/drivers/net/wireless/ath/ath9k/htc_drv_init.c
+++ b/drivers/net/wireless/ath/ath9k/htc_drv_init.c
@@ -729,6 +729,7 @@ static void ath9k_set_hw_capab(struct ath9k_htc_priv *priv,
         ieee80211_hw_set(hw, SPECTRUM_MGMT);
         ieee80211_hw_set(hw, SIGNAL_DBM);
         ieee80211_hw_set(hw, AMPDU_AGGREGATION);
+        ieee80211_hw_set(hw, DOESNT_SUPPORT_QOS_NDP);
 
         if (ath9k_ps_enable)
                 ieee80211_hw_set(hw, SUPPORTS_PS);
diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/core.h b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/core.h
index df8a1ecb9924..232dcbb83311 100644
--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/core.h
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/core.h
@@ -181,6 +181,7 @@ enum brcmf_netif_stop_reason {
  * @netif_stop_lock: spinlock for update netif_stop from multiple sources.
  * @pend_8021x_cnt: tracks outstanding number of 802.1x frames.
  * @pend_8021x_wait: used for signalling change in count.
+ * @fwil_fwerr: flag indicating fwil layer should return firmware error codes.
  */
 struct brcmf_if {
         struct brcmf_pub *drvr;
@@ -198,6 +199,7 @@ struct brcmf_if {
         wait_queue_head_t pend_8021x_wait;
         struct in6_addr ipv6_addr_tbl[NDOL_MAX_ENTRIES];
         u8 ipv6addr_idx;
+        bool fwil_fwerr;
 };
 
 int brcmf_netdev_wait_pend8021x(struct brcmf_if *ifp);
diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/feature.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/feature.c
index 47de35a33853..bede7b7fd996 100644
--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/feature.c
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/feature.c
@@ -104,6 +104,9 @@ static void brcmf_feat_iovar_int_get(struct brcmf_if *ifp,
         u32 data;
         int err;
 
+        /* we need to know firmware error */
+        ifp->fwil_fwerr = true;
+
         err = brcmf_fil_iovar_int_get(ifp, name, &data);
         if (err == 0) {
                 brcmf_dbg(INFO, "enabling feature: %s\n", brcmf_feat_names[id]);
@@ -112,6 +115,8 @@ static void brcmf_feat_iovar_int_get(struct brcmf_if *ifp,
                 brcmf_dbg(TRACE, "%s feature check failed: %d\n",
                           brcmf_feat_names[id], err);
         }
+
+        ifp->fwil_fwerr = false;
 }
 
 static void brcmf_feat_iovar_data_set(struct brcmf_if *ifp,
@@ -120,6 +125,9 @@ static void brcmf_feat_iovar_data_set(struct brcmf_if *ifp,
 {
         int err;
 
+        /* we need to know firmware error */
+        ifp->fwil_fwerr = true;
+
         err = brcmf_fil_iovar_data_set(ifp, name, data, len);
         if (err != -BRCMF_FW_UNSUPPORTED) {
                 brcmf_dbg(INFO, "enabling feature: %s\n", brcmf_feat_names[id]);
@@ -128,6 +136,8 @@ static void brcmf_feat_iovar_data_set(struct brcmf_if *ifp,
                 brcmf_dbg(TRACE, "%s feature check failed: %d\n",
                           brcmf_feat_names[id], err);
         }
+
+        ifp->fwil_fwerr = false;
 }
 
 #define MAX_CAPS_BUFFER_SIZE    512
diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwil.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwil.c
index f2cfdd3b2bf1..fc5751116d99 100644
--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwil.c
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwil.c
@@ -131,6 +131,9 @@ brcmf_fil_cmd_data(struct brcmf_if *ifp, u32 cmd, void *data, u32 len, bool set)
                           brcmf_fil_get_errstr((u32)(-fwerr)), fwerr);
                 err = -EBADE;
         }
+        if (ifp->fwil_fwerr)
+                return fwerr;
+
         return err;
 }
 
diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c
index 2ee54133efa1..82064e909784 100644
--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c
@@ -462,25 +462,23 @@ static int brcmf_p2p_set_firmware(struct brcmf_if *ifp, u8 *p2p_mac)
  * @dev_addr: optional device address.
  *
  * P2P needs mac addresses for P2P device and interface. If no device
- * address it specified, these are derived from the primary net device, ie.
- * the permanent ethernet address of the device.
+ * address it specified, these are derived from a random ethernet
+ * address.
  */
 static void brcmf_p2p_generate_bss_mac(struct brcmf_p2p_info *p2p, u8 *dev_addr)
 {
-        struct brcmf_if *pri_ifp = p2p->bss_idx[P2PAPI_BSSCFG_PRIMARY].vif->ifp;
-        bool local_admin = false;
+        bool random_addr = false;
 
-        if (!dev_addr || is_zero_ether_addr(dev_addr)) {
-                dev_addr = pri_ifp->mac_addr;
-                local_admin = true;
-        }
+        if (!dev_addr || is_zero_ether_addr(dev_addr))
+                random_addr = true;
 
-        /* Generate the P2P Device Address.  This consists of the device's
-         * primary MAC address with the locally administered bit set.
+        /* Generate the P2P Device Address obtaining a random ethernet
+         * address with the locally administered bit set.
          */
-        memcpy(p2p->dev_addr, dev_addr, ETH_ALEN);
-        if (local_admin)
-                p2p->dev_addr[0] |= 0x02;
+        if (random_addr)
+                eth_random_addr(p2p->dev_addr);
+        else
+                memcpy(p2p->dev_addr, dev_addr, ETH_ALEN);
 
         /* Generate the P2P Interface Address.  If the discovery and connection
          * BSSCFGs need to simultaneously co-exist, then this address must be
diff --git a/drivers/net/wireless/intel/iwlwifi/Kconfig b/drivers/net/wireless/intel/iwlwifi/Kconfig
index c5f2ddf9b0fe..e5a2fc738ac3 100644
--- a/drivers/net/wireless/intel/iwlwifi/Kconfig
+++ b/drivers/net/wireless/intel/iwlwifi/Kconfig
@@ -91,7 +91,6 @@ config IWLWIFI_BCAST_FILTERING
 config IWLWIFI_PCIE_RTPM
        bool "Enable runtime power management mode for PCIe devices"
        depends on IWLMVM && PM && EXPERT
-       default false
        help
          Say Y here to enable runtime power management for PCIe
          devices.  If enabled, the device will go into low power mode
diff --git a/drivers/net/wireless/intel/iwlwifi/fw/api/time-event.h b/drivers/net/wireless/intel/iwlwifi/fw/api/time-event.h
index 3721a3ed358b..f824bebceb06 100644
--- a/drivers/net/wireless/intel/iwlwifi/fw/api/time-event.h
+++ b/drivers/net/wireless/intel/iwlwifi/fw/api/time-event.h
@@ -211,7 +211,7 @@ enum {
  * @TE_V2_NOTIF_HOST_FRAG_END:request/receive notification on frag end
  * @TE_V2_NOTIF_INTERNAL_FRAG_START: internal FW use.
  * @TE_V2_NOTIF_INTERNAL_FRAG_END: internal FW use.
- * @T2_V2_START_IMMEDIATELY: start time event immediately
+ * @TE_V2_START_IMMEDIATELY: start time event immediately
  * @TE_V2_DEP_OTHER: depends on another time event
  * @TE_V2_DEP_TSF: depends on a specific time
  * @TE_V2_EVENT_SOCIOPATHIC: can't co-exist with other events of tha same MAC
@@ -230,7 +230,7 @@ enum iwl_time_event_policy {
         TE_V2_NOTIF_HOST_FRAG_END = BIT(5),
         TE_V2_NOTIF_INTERNAL_FRAG_START = BIT(6),
         TE_V2_NOTIF_INTERNAL_FRAG_END = BIT(7),
-        T2_V2_START_IMMEDIATELY = BIT(11),
+        TE_V2_START_IMMEDIATELY = BIT(11),
 
         /* placement characteristics */
         TE_V2_DEP_OTHER = BIT(TE_V2_PLACEMENT_POS),
diff --git a/drivers/net/wireless/intel/iwlwifi/fw/dbg.c b/drivers/net/wireless/intel/iwlwifi/fw/dbg.c
index 67aefc8fc9ac..7bd704a3e640 100644
--- a/drivers/net/wireless/intel/iwlwifi/fw/dbg.c
+++ b/drivers/net/wireless/intel/iwlwifi/fw/dbg.c
@@ -8,6 +8,7 @@
  * Copyright(c) 2008 - 2014 Intel Corporation. All rights reserved.
  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  * Copyright(c) 2015 - 2017 Intel Deutschland GmbH
+ * Copyright(c) 2018        Intel Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of version 2 of the GNU General Public License as
@@ -33,6 +34,7 @@
  * Copyright(c) 2005 - 2014 Intel Corporation. All rights reserved.
  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  * Copyright(c) 2015 - 2017 Intel Deutschland GmbH
+ * Copyright(c) 2018        Intel Corporation
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -942,7 +944,6 @@ dump_trans_data:
 
 out:
         iwl_fw_free_dump_desc(fwrt);
-        fwrt->dump.trig = NULL;
         clear_bit(IWL_FWRT_STATUS_DUMPING, &fwrt->status);
         IWL_DEBUG_INFO(fwrt, "WRT dump done\n");
 }
@@ -1112,6 +1113,14 @@ void iwl_fw_error_dump_wk(struct work_struct *work)
             fwrt->ops->dump_start(fwrt->ops_ctx))
                 return;
 
+        if (fwrt->ops && fwrt->ops->fw_running &&
+            !fwrt->ops->fw_running(fwrt->ops_ctx)) {
+                IWL_ERR(fwrt, "Firmware not running - cannot dump error\n");
+                iwl_fw_free_dump_desc(fwrt);
+                clear_bit(IWL_FWRT_STATUS_DUMPING, &fwrt->status);
+                goto out;
+        }
+
         if (fwrt->trans->cfg->device_family == IWL_DEVICE_FAMILY_7000) {
                 /* stop recording */
                 iwl_fw_dbg_stop_recording(fwrt);
@@ -1145,7 +1154,7 @@ void iwl_fw_error_dump_wk(struct work_struct *work)
                         iwl_write_prph(fwrt->trans, DBGC_OUT_CTRL, out_ctrl);
                 }
         }
-
+out:
         if (fwrt->ops && fwrt->ops->dump_end)
                 fwrt->ops->dump_end(fwrt->ops_ctx);
 }
diff --git a/drivers/net/wireless/intel/iwlwifi/fw/dbg.h b/drivers/net/wireless/intel/iwlwifi/fw/dbg.h
index 223fb77a3aa9..72259bff9922 100644
--- a/drivers/net/wireless/intel/iwlwifi/fw/dbg.h
+++ b/drivers/net/wireless/intel/iwlwifi/fw/dbg.h
@@ -8,6 +8,7 @@
  * Copyright(c) 2008 - 2014 Intel Corporation. All rights reserved.
  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  * Copyright(c) 2015 - 2017 Intel Deutschland GmbH
+ * Copyright(c) 2018        Intel Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of version 2 of the GNU General Public License as
@@ -33,6 +34,7 @@
  * Copyright(c) 2005 - 2014 Intel Corporation. All rights reserved.
  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  * Copyright(c) 2015 - 2017 Intel Deutschland GmbH
+ * Copyright(c) 2018        Intel Corporation
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -91,6 +93,7 @@ static inline void iwl_fw_free_dump_desc(struct iwl_fw_runtime *fwrt)
         if (fwrt->dump.desc != &iwl_dump_desc_assert)
                 kfree(fwrt->dump.desc);
         fwrt->dump.desc = NULL;
+        fwrt->dump.trig = NULL;
 }
 
 void iwl_fw_error_dump(struct iwl_fw_runtime *fwrt);
diff --git a/drivers/net/wireless/intel/iwlwifi/fw/debugfs.h b/drivers/net/wireless/intel/iwlwifi/fw/debugfs.h
index e57ff92a68ae..3da468d2cc92 100644
--- a/drivers/net/wireless/intel/iwlwifi/fw/debugfs.h
+++ b/drivers/net/wireless/intel/iwlwifi/fw/debugfs.h
@@ -75,6 +75,20 @@ static inline void iwl_fw_cancel_timestamp(struct iwl_fw_runtime *fwrt)
         cancel_delayed_work_sync(&fwrt->timestamp.wk);
 }
 
+static inline void iwl_fw_suspend_timestamp(struct iwl_fw_runtime *fwrt)
+{
+        cancel_delayed_work_sync(&fwrt->timestamp.wk);
+}
+
+static inline void iwl_fw_resume_timestamp(struct iwl_fw_runtime *fwrt)
+{
+        if (!fwrt->timestamp.delay)
+                return;
+
+        schedule_delayed_work(&fwrt->timestamp.wk,
+                              round_jiffies_relative(fwrt->timestamp.delay));
+}
+
 #else
 static inline int iwl_fwrt_dbgfs_register(struct iwl_fw_runtime *fwrt,
                                           struct dentry *dbgfs_dir)
@@ -84,4 +98,8 @@ static inline int iwl_fwrt_dbgfs_register(struct iwl_fw_runtime *fwrt,
 
 static inline void iwl_fw_cancel_timestamp(struct iwl_fw_runtime *fwrt) {}
 
+static inline void iwl_fw_suspend_timestamp(struct iwl_fw_runtime *fwrt) {}
+
+static inline void iwl_fw_resume_timestamp(struct iwl_fw_runtime *fwrt) {}
+
 #endif /* CONFIG_IWLWIFI_DEBUGFS */
diff --git a/drivers/net/wireless/intel/iwlwifi/fw/init.c b/drivers/net/wireless/intel/iwlwifi/fw/init.c
index c39fe84bb4c4..2efac307909e 100644
--- a/drivers/net/wireless/intel/iwlwifi/fw/init.c
+++ b/drivers/net/wireless/intel/iwlwifi/fw/init.c
@@ -77,8 +77,14 @@ void iwl_fw_runtime_init(struct iwl_fw_runtime *fwrt, struct iwl_trans *trans,
 }
 IWL_EXPORT_SYMBOL(iwl_fw_runtime_init);
 
-void iwl_fw_runtime_exit(struct iwl_fw_runtime *fwrt)
+void iwl_fw_runtime_suspend(struct iwl_fw_runtime *fwrt)
 {
-        iwl_fw_cancel_timestamp(fwrt);
+        iwl_fw_suspend_timestamp(fwrt);
 }
-IWL_EXPORT_SYMBOL(iwl_fw_runtime_exit);
+IWL_EXPORT_SYMBOL(iwl_fw_runtime_suspend);
+
+void iwl_fw_runtime_resume(struct iwl_fw_runtime *fwrt)
+{
+        iwl_fw_resume_timestamp(fwrt);
+}
+IWL_EXPORT_SYMBOL(iwl_fw_runtime_resume);
diff --git a/drivers/net/wireless/intel/iwlwifi/fw/runtime.h b/drivers/net/wireless/intel/iwlwifi/fw/runtime.h
index e25c049f980f..3fb940ebd74a 100644
--- a/drivers/net/wireless/intel/iwlwifi/fw/runtime.h
+++ b/drivers/net/wireless/intel/iwlwifi/fw/runtime.h
@@ -6,6 +6,7 @@
  * GPL LICENSE SUMMARY
  *
  * Copyright(c) 2017 Intel Deutschland GmbH
+ * Copyright(c) 2018 Intel Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of version 2 of the GNU General Public License as
@@ -26,6 +27,7 @@
  * BSD LICENSE
  *
  * Copyright(c) 2017 Intel Deutschland GmbH
+ * Copyright(c) 2018 Intel Corporation
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -68,6 +70,7 @@
 struct iwl_fw_runtime_ops {
         int (*dump_start)(void *ctx);
         void (*dump_end)(void *ctx);
+        bool (*fw_running)(void *ctx);
 };
 
 #define MAX_NUM_LMAC 2
@@ -150,6 +153,10 @@ void iwl_fw_runtime_init(struct iwl_fw_runtime *fwrt, struct iwl_trans *trans,
 
 void iwl_fw_runtime_exit(struct iwl_fw_runtime *fwrt);
 
+void iwl_fw_runtime_suspend(struct iwl_fw_runtime *fwrt);
+
+void iwl_fw_runtime_resume(struct iwl_fw_runtime *fwrt);
+
 static inline void iwl_fw_set_current_image(struct iwl_fw_runtime *fwrt,
                                             enum iwl_ucode_type cur_fw_img)
 {
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/d3.c b/drivers/net/wireless/intel/iwlwifi/mvm/d3.c
index 0e6cf39285f4..2efe9b099556 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/d3.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/d3.c
@@ -1098,6 +1098,8 @@ int iwl_mvm_suspend(struct ieee80211_hw *hw, struct cfg80211_wowlan *wowlan)
         /* make sure the d0i3 exit work is not pending */
         flush_work(&mvm->d0i3_exit_work);
 
+        iwl_fw_runtime_suspend(&mvm->fwrt);
+
         ret = iwl_trans_suspend(trans);
         if (ret)
                 return ret;
@@ -2012,6 +2014,8 @@ int iwl_mvm_resume(struct ieee80211_hw *hw)
 
         mvm->trans->system_pm_mode = IWL_PLAT_PM_MODE_DISABLED;
 
+        iwl_fw_runtime_resume(&mvm->fwrt);
+
         return ret;
 }
 
@@ -2038,6 +2042,8 @@ static int iwl_mvm_d3_test_open(struct inode *inode, struct file *file)
 
         mvm->trans->system_pm_mode = IWL_PLAT_PM_MODE_D3;
 
+        iwl_fw_runtime_suspend(&mvm->fwrt);
+
         /* start pseudo D3 */
         rtnl_lock();
         err = __iwl_mvm_suspend(mvm->hw, mvm->hw->wiphy->wowlan_config, true);
@@ -2098,6 +2104,8 @@ static int iwl_mvm_d3_test_release(struct inode *inode, struct file *file)
         __iwl_mvm_resume(mvm, true);
         rtnl_unlock();
 
+        iwl_fw_runtime_resume(&mvm->fwrt);
+
         mvm->trans->system_pm_mode = IWL_PLAT_PM_MODE_DISABLED;
 
         iwl_abort_notification_waits(&mvm->notif_wait);
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/debugfs.c b/drivers/net/wireless/intel/iwlwifi/mvm/debugfs.c
index a7892c1254a2..9c436d8d001d 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/debugfs.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/debugfs.c
@@ -8,6 +8,7 @@
  * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
+ * Copyright(c) 2018        Intel Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of version 2 of the GNU General Public License as
@@ -35,6 +36,7 @@
  * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
+ * Copyright(c) 2018        Intel Corporation
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -1281,9 +1283,6 @@ static ssize_t iwl_dbgfs_fw_dbg_collect_write(struct iwl_mvm *mvm,
 {
         int ret;
 
-        if (!iwl_mvm_firmware_running(mvm))
-                return -EIO;
-
         ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_PRPH_WRITE);
         if (ret)
                 return ret;
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c b/drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c
index 2f22e14e00fe..8ba16fc24e3a 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c
@@ -438,7 +438,8 @@ int iwl_mvm_mac_ctxt_init(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
         }
 
         /* Allocate the CAB queue for softAP and GO interfaces */
-        if (vif->type == NL80211_IFTYPE_AP) {
+        if (vif->type == NL80211_IFTYPE_AP ||
+            vif->type == NL80211_IFTYPE_ADHOC) {
                 /*
                  * For TVQM this will be overwritten later with the FW assigned
                  * queue value (when queue is enabled).
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c b/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c
index 8aed40a8bc38..ebf511150f4d 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c
@@ -8,6 +8,7 @@
  * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
+ * Copyright(c) 2018        Intel Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of version 2 of the GNU General Public License as
@@ -2106,15 +2107,40 @@ static int iwl_mvm_start_ap_ibss(struct ieee80211_hw *hw,
         if (ret)
                 goto out_remove;
 
-        ret = iwl_mvm_add_mcast_sta(mvm, vif);
-        if (ret)
-                goto out_unbind;
-
-        /* Send the bcast station. At this stage the TBTT and DTIM time events
-         * are added and applied to the scheduler */
-        ret = iwl_mvm_send_add_bcast_sta(mvm, vif);
-        if (ret)
-                goto out_rm_mcast;
+        /*
+         * This is not very nice, but the simplest:
+         * For older FWs adding the mcast sta before the bcast station may
+         * cause assert 0x2b00.
+         * This is fixed in later FW so make the order of removal depend on
+         * the TLV
+         */
+        if (fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_STA_TYPE)) {
+                ret = iwl_mvm_add_mcast_sta(mvm, vif);
+                if (ret)
+                        goto out_unbind;
+                /*
+                 * Send the bcast station. At this stage the TBTT and DTIM time
+                 * events are added and applied to the scheduler
+                 */
+                ret = iwl_mvm_send_add_bcast_sta(mvm, vif);
+                if (ret) {
+                        iwl_mvm_rm_mcast_sta(mvm, vif);
+                        goto out_unbind;
+                }
+        } else {
+                /*
+                 * Send the bcast station. At this stage the TBTT and DTIM time
+                 * events are added and applied to the scheduler
+                 */
+                iwl_mvm_send_add_bcast_sta(mvm, vif);
+                if (ret)
+                        goto out_unbind;
+                iwl_mvm_add_mcast_sta(mvm, vif);
+                if (ret) {
+                        iwl_mvm_send_rm_bcast_sta(mvm, vif);
+                        goto out_unbind;
+                }
+        }
 
         /* must be set before quota calculations */
         mvmvif->ap_ibss_active = true;
@@ -2144,7 +2170,6 @@ out_quota_failed:
         iwl_mvm_power_update_mac(mvm);
         mvmvif->ap_ibss_active = false;
         iwl_mvm_send_rm_bcast_sta(mvm, vif);
-out_rm_mcast:
         iwl_mvm_rm_mcast_sta(mvm, vif);
 out_unbind:
         iwl_mvm_binding_remove_vif(mvm, vif);
@@ -2682,6 +2707,10 @@ static int iwl_mvm_mac_sta_state(struct ieee80211_hw *hw,
 
                 /* enable beacon filtering */
                 WARN_ON(iwl_mvm_enable_beacon_filter(mvm, vif, 0));
+
+                iwl_mvm_rs_rate_init(mvm, sta, mvmvif->phy_ctxt->channel->band,
+                                     false);
+
                 ret = 0;
         } else if (old_state == IEEE80211_STA_AUTHORIZED &&
                    new_state == IEEE80211_STA_ASSOC) {
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h b/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h
index 2d28e0804218..89ff02d7c876 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h
@@ -90,6 +90,7 @@
 #include "fw/runtime.h"
 #include "fw/dbg.h"
 #include "fw/acpi.h"
+#include "fw/debugfs.h"
 
 #define IWL_MVM_MAX_ADDRESSES           5
 /* RSSI offset for WkP */
@@ -1783,6 +1784,7 @@ static inline u32 iwl_mvm_flushable_queues(struct iwl_mvm *mvm)
 
 static inline void iwl_mvm_stop_device(struct iwl_mvm *mvm)
 {
+        iwl_fw_cancel_timestamp(&mvm->fwrt);
         iwl_free_fw_paging(&mvm->fwrt);
         clear_bit(IWL_MVM_STATUS_FIRMWARE_RUNNING, &mvm->status);
         iwl_fw_dump_conf_clear(&mvm->fwrt);
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/ops.c b/drivers/net/wireless/intel/iwlwifi/mvm/ops.c
index 5d525a0023dc..ab7fb5aad984 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/ops.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/ops.c
@@ -8,6 +8,7 @@
  * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
+ * Copyright(c) 2018        Intel Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of version 2 of the GNU General Public License as
@@ -35,6 +36,7 @@
  * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
+ * Copyright(c) 2018        Intel Corporation
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -552,9 +554,15 @@ static void iwl_mvm_fwrt_dump_end(void *ctx)
         iwl_mvm_unref(mvm, IWL_MVM_REF_FW_DBG_COLLECT);
 }
 
+static bool iwl_mvm_fwrt_fw_running(void *ctx)
+{
+        return iwl_mvm_firmware_running(ctx);
+}
+
 static const struct iwl_fw_runtime_ops iwl_mvm_fwrt_ops = {
         .dump_start = iwl_mvm_fwrt_dump_start,
         .dump_end = iwl_mvm_fwrt_dump_end,
+        .fw_running = iwl_mvm_fwrt_fw_running,
 };
 
 static struct iwl_op_mode *
@@ -802,7 +810,6 @@ iwl_op_mode_mvm_start(struct iwl_trans *trans, const struct iwl_cfg *cfg,
         iwl_mvm_leds_exit(mvm);
         iwl_mvm_thermal_exit(mvm);
  out_free:
-        iwl_fw_runtime_exit(&mvm->fwrt);
         iwl_fw_flush_dump(&mvm->fwrt);
 
         if (iwlmvm_mod_params.init_dbg)
@@ -843,7 +850,6 @@ static void iwl_op_mode_mvm_stop(struct iwl_op_mode *op_mode)
 #if defined(CONFIG_PM_SLEEP) && defined(CONFIG_IWLWIFI_DEBUGFS)
         kfree(mvm->d3_resume_sram);
 #endif
-        iwl_fw_runtime_exit(&mvm->fwrt);
         iwl_trans_op_mode_leave(mvm->trans);
 
         iwl_phy_db_free(mvm->phy_db);
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/rs.c b/drivers/net/wireless/intel/iwlwifi/mvm/rs.c
index 60abb0084ee5..47f4c7a1d80d 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/rs.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/rs.c
@@ -2684,7 +2684,8 @@ static void rs_get_initial_rate(struct iwl_mvm *mvm,
                                 struct ieee80211_sta *sta,
                                 struct iwl_lq_sta *lq_sta,
                                 enum nl80211_band band,
-                                struct rs_rate *rate)
+                                struct rs_rate *rate,
+                                bool init)
 {
         int i, nentries;
         unsigned long active_rate;
@@ -2738,14 +2739,25 @@ static void rs_get_initial_rate(struct iwl_mvm *mvm,
          */
         if (sta->vht_cap.vht_supported &&
             best_rssi > IWL_RS_LOW_RSSI_THRESHOLD) {
-                switch (sta->bandwidth) {
-                case IEEE80211_STA_RX_BW_160:
-                case IEEE80211_STA_RX_BW_80:
-                case IEEE80211_STA_RX_BW_40:
+                /*
+                 * In AP mode, when a new station associates, rs is initialized
+                 * immediately upon association completion, before the phy
+                 * context is updated with the association parameters, so the
+                 * sta bandwidth might be wider than the phy context allows.
+                 * To avoid this issue, always initialize rs with 20mhz
+                 * bandwidth rate, and after authorization, when the phy context
+                 * is already up-to-date, re-init rs with the correct bw.
+                 */
+                u32 bw = init ? RATE_MCS_CHAN_WIDTH_20 : rs_bw_from_sta_bw(sta);
+
+                switch (bw) {
+                case RATE_MCS_CHAN_WIDTH_40:
+                case RATE_MCS_CHAN_WIDTH_80:
+                case RATE_MCS_CHAN_WIDTH_160:
                         initial_rates = rs_optimal_rates_vht;
                         nentries = ARRAY_SIZE(rs_optimal_rates_vht);
                         break;
-                case IEEE80211_STA_RX_BW_20:
+                case RATE_MCS_CHAN_WIDTH_20:
                         initial_rates = rs_optimal_rates_vht_20mhz;
                         nentries = ARRAY_SIZE(rs_optimal_rates_vht_20mhz);
                         break;
@@ -2756,7 +2768,7 @@ static void rs_get_initial_rate(struct iwl_mvm *mvm,
 
                 active_rate = lq_sta->active_siso_rate;
                 rate->type = LQ_VHT_SISO;
-                rate->bw = rs_bw_from_sta_bw(sta);
+                rate->bw = bw;
         } else if (sta->ht_cap.ht_supported &&
                    best_rssi > IWL_RS_LOW_RSSI_THRESHOLD) {
                 initial_rates = rs_optimal_rates_ht;
@@ -2839,7 +2851,7 @@ static void rs_initialize_lq(struct iwl_mvm *mvm,
         tbl = &(lq_sta->lq_info[active_tbl]);
         rate = &tbl->rate;
 
-        rs_get_initial_rate(mvm, sta, lq_sta, band, rate);
+        rs_get_initial_rate(mvm, sta, lq_sta, band, rate, init);
         rs_init_optimal_rate(mvm, sta, lq_sta);
 
         WARN_ONCE(rate->ant != ANT_A && rate->ant != ANT_B,
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c b/drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c
index a3f7c1bf3cc8..580de5851fc7 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c
@@ -71,6 +71,7 @@ static inline int iwl_mvm_check_pn(struct iwl_mvm *mvm, struct sk_buff *skb,
         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
         struct ieee80211_rx_status *stats = IEEE80211_SKB_RXCB(skb);
         struct iwl_mvm_key_pn *ptk_pn;
+        int res;
         u8 tid, keyidx;
         u8 pn[IEEE80211_CCMP_PN_LEN];
         u8 *extiv;
@@ -127,12 +128,13 @@ static inline int iwl_mvm_check_pn(struct iwl_mvm *mvm, struct sk_buff *skb,
         pn[4] = extiv[1];
         pn[5] = extiv[0];
 
-        if (memcmp(pn, ptk_pn->q[queue].pn[tid],
-                   IEEE80211_CCMP_PN_LEN) <= 0)
+        res = memcmp(pn, ptk_pn->q[queue].pn[tid], IEEE80211_CCMP_PN_LEN);
+        if (res < 0)
+                return -1;
+        if (!res && !(stats->flag & RX_FLAG_ALLOW_SAME_PN))
                 return -1;
 
-        if (!(stats->flag & RX_FLAG_AMSDU_MORE))
-                memcpy(ptk_pn->q[queue].pn[tid], pn, IEEE80211_CCMP_PN_LEN);
+        memcpy(ptk_pn->q[queue].pn[tid], pn, IEEE80211_CCMP_PN_LEN);
         stats->flag |= RX_FLAG_PN_VALIDATED;
 
         return 0;
@@ -314,28 +316,21 @@ static void iwl_mvm_rx_csum(struct ieee80211_sta *sta,
 }
 
 /*
- * returns true if a packet outside BA session is a duplicate and
- * should be dropped
+ * returns true if a packet is a duplicate and should be dropped.
+ * Updates AMSDU PN tracking info
  */
-static bool iwl_mvm_is_nonagg_dup(struct ieee80211_sta *sta, int queue,
-                                  struct ieee80211_rx_status *rx_status,
-                                  struct ieee80211_hdr *hdr,
-                                  struct iwl_rx_mpdu_desc *desc)
+static bool iwl_mvm_is_dup(struct ieee80211_sta *sta, int queue,
+                           struct ieee80211_rx_status *rx_status,
+                           struct ieee80211_hdr *hdr,
+                           struct iwl_rx_mpdu_desc *desc)
 {
         struct iwl_mvm_sta *mvm_sta;
         struct iwl_mvm_rxq_dup_data *dup_data;
-        u8 baid, tid, sub_frame_idx;
+        u8 tid, sub_frame_idx;
 
         if (WARN_ON(IS_ERR_OR_NULL(sta)))
                 return false;
 
-        baid = (le32_to_cpu(desc->reorder_data) &
-                IWL_RX_MPDU_REORDER_BAID_MASK) >>
-                IWL_RX_MPDU_REORDER_BAID_SHIFT;
-
-        if (baid != IWL_RX_REORDER_DATA_INVALID_BAID)
-                return false;
-
         mvm_sta = iwl_mvm_sta_from_mac80211(sta);
         dup_data = &mvm_sta->dup_data[queue];
 
@@ -365,6 +360,12 @@ static bool iwl_mvm_is_nonagg_dup(struct ieee80211_sta *sta, int queue,
                      dup_data->last_sub_frame[tid] >= sub_frame_idx))
                 return true;
 
+        /* Allow same PN as the first subframe for following sub frames */
+        if (dup_data->last_seq[tid] == hdr->seq_ctrl &&
+            sub_frame_idx > dup_data->last_sub_frame[tid] &&
+            desc->mac_flags2 & IWL_RX_MPDU_MFLG2_AMSDU)
+                rx_status->flag |= RX_FLAG_ALLOW_SAME_PN;
+
         dup_data->last_seq[tid] = hdr->seq_ctrl;
         dup_data->last_sub_frame[tid] = sub_frame_idx;
 
@@ -971,7 +972,7 @@ void iwl_mvm_rx_mpdu_mq(struct iwl_mvm *mvm, struct napi_struct *napi,
                 if (ieee80211_is_data(hdr->frame_control))
                         iwl_mvm_rx_csum(sta, skb, desc);
 
-                if (iwl_mvm_is_nonagg_dup(sta, queue, rx_status, hdr, desc)) {
+                if (iwl_mvm_is_dup(sta, queue, rx_status, hdr, desc)) {
                         kfree_skb(skb);
                         goto out;
                 }
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/sta.c b/drivers/net/wireless/intel/iwlwifi/mvm/sta.c
index 6b2674e02606..630e23cb0ffb 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/sta.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/sta.c
@@ -2039,7 +2039,7 @@ int iwl_mvm_add_mcast_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
         struct iwl_trans_txq_scd_cfg cfg = {
                 .fifo = IWL_MVM_TX_FIFO_MCAST,
                 .sta_id = msta->sta_id,
-                .tid = IWL_MAX_TID_COUNT,
+                .tid = 0,
                 .aggregate = false,
                 .frame_limit = IWL_FRAME_LIMIT,
         };
@@ -2053,6 +2053,17 @@ int iwl_mvm_add_mcast_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
                 return -ENOTSUPP;
 
         /*
+         * In IBSS, ieee80211_check_queues() sets the cab_queue to be
+         * invalid, so make sure we use the queue we want.
+         * Note that this is done here as we want to avoid making DQA
+         * changes in mac80211 layer.
+         */
+        if (vif->type == NL80211_IFTYPE_ADHOC) {
+                vif->cab_queue = IWL_MVM_DQA_GCAST_QUEUE;
+                mvmvif->cab_queue = vif->cab_queue;
+        }
+
+        /*
          * While in previous FWs we had to exclude cab queue from TFD queue
          * mask, now it is needed as any other queue.
          */
@@ -2079,24 +2090,13 @@ int iwl_mvm_add_mcast_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
         if (iwl_mvm_has_new_tx_api(mvm)) {
                 int queue = iwl_mvm_tvqm_enable_txq(mvm, vif->cab_queue,
                                                     msta->sta_id,
-                                                    IWL_MAX_TID_COUNT,
+                                                    0,
                                                     timeout);
                 mvmvif->cab_queue = queue;
         } else if (!fw_has_api(&mvm->fw->ucode_capa,
-                               IWL_UCODE_TLV_API_STA_TYPE)) {
-                /*
-                 * In IBSS, ieee80211_check_queues() sets the cab_queue to be
-                 * invalid, so make sure we use the queue we want.
-                 * Note that this is done here as we want to avoid making DQA
-                 * changes in mac80211 layer.
-                 */
-                if (vif->type == NL80211_IFTYPE_ADHOC) {
-                        vif->cab_queue = IWL_MVM_DQA_GCAST_QUEUE;
-                        mvmvif->cab_queue = vif->cab_queue;
-                }
+                               IWL_UCODE_TLV_API_STA_TYPE))
                 iwl_mvm_enable_txq(mvm, vif->cab_queue, vif->cab_queue, 0,
                                    &cfg, timeout);
-        }
 
         return 0;
 }
@@ -2115,7 +2115,7 @@ int iwl_mvm_rm_mcast_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
         iwl_mvm_flush_sta(mvm, &mvmvif->mcast_sta, true, 0);
 
         iwl_mvm_disable_txq(mvm, mvmvif->cab_queue, vif->cab_queue,
-                            IWL_MAX_TID_COUNT, 0);
+                            0, 0);
 
         ret = iwl_mvm_rm_sta_common(mvm, mvmvif->mcast_sta.sta_id);
         if (ret)
@@ -3170,8 +3170,9 @@ static int __iwl_mvm_remove_sta_key(struct iwl_mvm *mvm, u8 sta_id,
         int ret, size;
         u32 status;
 
+        /* This is a valid situation for GTK removal */
         if (sta_id == IWL_MVM_INVALID_STA)
-                return -EINVAL;
+                return 0;
 
         key_flags = cpu_to_le16((keyconf->keyidx << STA_KEY_FLG_KEYID_POS) &
                                  STA_KEY_FLG_KEYID_MSK);
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/time-event.c b/drivers/net/wireless/intel/iwlwifi/mvm/time-event.c
index 200ab50ec86b..acb217e666db 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/time-event.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/time-event.c
@@ -616,7 +616,7 @@ void iwl_mvm_protect_session(struct iwl_mvm *mvm,
         time_cmd.repeat = 1;
         time_cmd.policy = cpu_to_le16(TE_V2_NOTIF_HOST_EVENT_START |
                                       TE_V2_NOTIF_HOST_EVENT_END |
-                                      T2_V2_START_IMMEDIATELY);
+                                      TE_V2_START_IMMEDIATELY);
 
         if (!wait_for_notif) {
                 iwl_mvm_time_event_send_add(mvm, vif, te_data, &time_cmd);
@@ -803,7 +803,7 @@ int iwl_mvm_start_p2p_roc(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
         time_cmd.repeat = 1;
         time_cmd.policy = cpu_to_le16(TE_V2_NOTIF_HOST_EVENT_START |
                                       TE_V2_NOTIF_HOST_EVENT_END |
-                                      T2_V2_START_IMMEDIATELY);
+                                      TE_V2_START_IMMEDIATELY);
 
         return iwl_mvm_time_event_send_add(mvm, vif, te_data, &time_cmd);
 }
@@ -913,6 +913,8 @@ int iwl_mvm_schedule_csa_period(struct iwl_mvm *mvm,
         time_cmd.interval = cpu_to_le32(1);
         time_cmd.policy = cpu_to_le16(TE_V2_NOTIF_HOST_EVENT_START |
                                       TE_V2_ABSENCE);
+        if (!apply_time)
+                time_cmd.policy |= cpu_to_le16(TE_V2_START_IMMEDIATELY);
 
         return iwl_mvm_time_event_send_add(mvm, vif, te_data, &time_cmd);
 }
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/tx.c b/drivers/net/wireless/intel/iwlwifi/mvm/tx.c
index dda77b327c98..af6dfceab6b8 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/tx.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/tx.c
@@ -419,11 +419,11 @@ static void iwl_mvm_set_tx_cmd_crypto(struct iwl_mvm *mvm,
 {
         struct ieee80211_key_conf *keyconf = info->control.hw_key;
         u8 *crypto_hdr = skb_frag->data + hdrlen;
+        enum iwl_tx_cmd_sec_ctrl type = TX_CMD_SEC_CCM;
         u64 pn;
 
         switch (keyconf->cipher) {
         case WLAN_CIPHER_SUITE_CCMP:
-        case WLAN_CIPHER_SUITE_CCMP_256:
                 iwl_mvm_set_tx_cmd_ccmp(info, tx_cmd);
                 iwl_mvm_set_tx_cmd_pn(info, crypto_hdr);
                 break;
@@ -447,13 +447,16 @@ static void iwl_mvm_set_tx_cmd_crypto(struct iwl_mvm *mvm,
                 break;
         case WLAN_CIPHER_SUITE_GCMP:
         case WLAN_CIPHER_SUITE_GCMP_256:
+                type = TX_CMD_SEC_GCMP;
+                /* Fall through */
+        case WLAN_CIPHER_SUITE_CCMP_256:
                 /* TODO: Taking the key from the table might introduce a race
                  * when PTK rekeying is done, having an old packets with a PN
                  * based on the old key but the message encrypted with a new
                  * one.
                  * Need to handle this.
                  */
-                tx_cmd->sec_ctl |= TX_CMD_SEC_GCMP | TX_CMD_SEC_KEY_FROM_TABLE;
+                tx_cmd->sec_ctl |= type | TX_CMD_SEC_KEY_FROM_TABLE;
                 tx_cmd->key[0] = keyconf->hw_key_idx;
                 iwl_mvm_set_tx_cmd_pn(info, crypto_hdr);
                 break;
@@ -645,7 +648,11 @@ int iwl_mvm_tx_skb_non_sta(struct iwl_mvm *mvm, struct sk_buff *skb)
                 if (info.control.vif->type == NL80211_IFTYPE_P2P_DEVICE ||
                     info.control.vif->type == NL80211_IFTYPE_AP ||
                     info.control.vif->type == NL80211_IFTYPE_ADHOC) {
-                        sta_id = mvmvif->bcast_sta.sta_id;
+                        if (info.control.vif->type == NL80211_IFTYPE_P2P_DEVICE)
+                                sta_id = mvmvif->bcast_sta.sta_id;
+                        else
+                                sta_id = mvmvif->mcast_sta.sta_id;
+
                         queue = iwl_mvm_get_ctrl_vif_queue(mvm, &info,
                                                            hdr->frame_control);
                         if (queue < 0)
diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/tx-gen2.c b/drivers/net/wireless/intel/iwlwifi/pcie/tx-gen2.c
index 6d0a907d5ba5..fabae0f60683 100644
--- a/drivers/net/wireless/intel/iwlwifi/pcie/tx-gen2.c
+++ b/drivers/net/wireless/intel/iwlwifi/pcie/tx-gen2.c
@@ -147,7 +147,7 @@ static void iwl_pcie_gen2_tfd_unmap(struct iwl_trans *trans,
         /* Sanity check on number of chunks */
         num_tbs = iwl_pcie_gen2_get_num_tbs(trans, tfd);
 
-        if (num_tbs >= trans_pcie->max_tbs) {
+        if (num_tbs > trans_pcie->max_tbs) {
                 IWL_ERR(trans, "Too many chunks: %i\n", num_tbs);
                 return;
         }
diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/tx.c b/drivers/net/wireless/intel/iwlwifi/pcie/tx.c
index 3f85713c41dc..1a566287993d 100644
--- a/drivers/net/wireless/intel/iwlwifi/pcie/tx.c
+++ b/drivers/net/wireless/intel/iwlwifi/pcie/tx.c
@@ -378,7 +378,7 @@ static void iwl_pcie_tfd_unmap(struct iwl_trans *trans,
         /* Sanity check on number of chunks */
         num_tbs = iwl_pcie_tfd_get_num_tbs(trans, tfd);
 
-        if (num_tbs >= trans_pcie->max_tbs) {
+        if (num_tbs > trans_pcie->max_tbs) {
                 IWL_ERR(trans, "Too many chunks: %i\n", num_tbs);
                 /* @todo issue fatal error, it is quite serious situation */
                 return;
diff --git a/drivers/net/wireless/mac80211_hwsim.c b/drivers/net/wireless/mac80211_hwsim.c
index 6e0af815f25e..35b21f8152bb 100644
--- a/drivers/net/wireless/mac80211_hwsim.c
+++ b/drivers/net/wireless/mac80211_hwsim.c
@@ -2727,6 +2727,7 @@ static int mac80211_hwsim_new_radio(struct genl_info *info,
         mutex_init(&data->mutex);
 
         data->netgroup = hwsim_net_get_netgroup(net);
+        data->wmediumd = hwsim_net_get_wmediumd(net);
 
         /* Enable frame retransmissions for lossy channels */
         hw->max_rates = 4;
diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8723be/hw.c b/drivers/net/wireless/realtek/rtlwifi/rtl8723be/hw.c
index f9ccd13c79f9..e7bbbc95cdb1 100644
--- a/drivers/net/wireless/realtek/rtlwifi/rtl8723be/hw.c
+++ b/drivers/net/wireless/realtek/rtlwifi/rtl8723be/hw.c
@@ -1125,7 +1125,8 @@ static void _rtl8723be_enable_aspm_back_door(struct ieee80211_hw *hw)
 
         /* Configuration Space offset 0x70f BIT7 is used to control L0S */
         tmp8 = _rtl8723be_dbi_read(rtlpriv, 0x70f);
-        _rtl8723be_dbi_write(rtlpriv, 0x70f, tmp8 | BIT(7));
+        _rtl8723be_dbi_write(rtlpriv, 0x70f, tmp8 | BIT(7) |
+                             ASPM_L1_LATENCY << 3);
 
         /* Configuration Space offset 0x719 Bit3 is for L1
          * BIT4 is for clock request
diff --git a/drivers/nvdimm/blk.c b/drivers/nvdimm/blk.c
index 345acca576b3..1bd7b3734751 100644
--- a/drivers/nvdimm/blk.c
+++ b/drivers/nvdimm/blk.c
@@ -278,8 +278,6 @@ static int nsblk_attach_disk(struct nd_namespace_blk *nsblk)
         disk->queue             = q;
         disk->flags             = GENHD_FL_EXT_DEVT;
         nvdimm_namespace_disk_name(&nsblk->common, disk->disk_name);
-        set_capacity(disk, 0);
-        device_add_disk(dev, disk);
 
         if (devm_add_action_or_reset(dev, nd_blk_release_disk, disk))
                 return -ENOMEM;
@@ -292,6 +290,7 @@ static int nsblk_attach_disk(struct nd_namespace_blk *nsblk)
         }
 
         set_capacity(disk, available_disk_size >> SECTOR_SHIFT);
+        device_add_disk(dev, disk);
         revalidate_disk(disk);
         return 0;
 }
diff --git a/drivers/nvdimm/btt.c b/drivers/nvdimm/btt.c
index 2ef544f10ec8..4b95ac513de2 100644
--- a/drivers/nvdimm/btt.c
+++ b/drivers/nvdimm/btt.c
@@ -1545,8 +1545,6 @@ static int btt_blk_init(struct btt *btt)
         queue_flag_set_unlocked(QUEUE_FLAG_NONROT, btt->btt_queue);
         btt->btt_queue->queuedata = btt;
 
-        set_capacity(btt->btt_disk, 0);
-        device_add_disk(&btt->nd_btt->dev, btt->btt_disk);
         if (btt_meta_size(btt)) {
                 int rc = nd_integrity_init(btt->btt_disk, btt_meta_size(btt));
 
@@ -1558,6 +1556,7 @@ static int btt_blk_init(struct btt *btt)
                 }
         }
         set_capacity(btt->btt_disk, btt->nlba * btt->sector_size >> 9);
+        device_add_disk(&btt->nd_btt->dev, btt->btt_disk);
         btt->nd_btt->size = btt->nlba * (u64)btt->sector_size;
         revalidate_disk(btt->btt_disk);
 
diff --git a/drivers/nvdimm/pfn_devs.c b/drivers/nvdimm/pfn_devs.c
index f5c4e8c6e29d..2f4d18752c97 100644
--- a/drivers/nvdimm/pfn_devs.c
+++ b/drivers/nvdimm/pfn_devs.c
@@ -304,7 +304,7 @@ static const struct attribute_group *nd_pfn_attribute_groups[] = {
 struct device *nd_pfn_devinit(struct nd_pfn *nd_pfn,
                 struct nd_namespace_common *ndns)
 {
-        struct device *dev = &nd_pfn->dev;
+        struct device *dev;
 
         if (!nd_pfn)
                 return NULL;
diff --git a/drivers/nvdimm/region_devs.c b/drivers/nvdimm/region_devs.c
index e6d01911e092..1593e1806b16 100644
--- a/drivers/nvdimm/region_devs.c
+++ b/drivers/nvdimm/region_devs.c
@@ -532,11 +532,13 @@ static ssize_t persistence_domain_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
 {
         struct nd_region *nd_region = to_nd_region(dev);
-        unsigned long flags = nd_region->flags;
 
-        return sprintf(buf, "%s%s\n",
-                        flags & BIT(ND_REGION_PERSIST_CACHE) ? "cpu_cache " : "",
-                        flags & BIT(ND_REGION_PERSIST_MEMCTRL) ? "memory_controller " : "");
+        if (test_bit(ND_REGION_PERSIST_CACHE, &nd_region->flags))
+                return sprintf(buf, "cpu_cache\n");
+        else if (test_bit(ND_REGION_PERSIST_MEMCTRL, &nd_region->flags))
+                return sprintf(buf, "memory_controller\n");
+        else
+                return sprintf(buf, "\n");
 }
 static DEVICE_ATTR_RO(persistence_domain);
 
@@ -593,6 +595,13 @@ static umode_t region_visible(struct kobject *kobj, struct attribute *a, int n)
                         return 0;
         }
 
+        if (a == &dev_attr_persistence_domain.attr) {
+                if ((nd_region->flags & (BIT(ND_REGION_PERSIST_CACHE)
+                                        | BIT(ND_REGION_PERSIST_MEMCTRL))) == 0)
+                        return 0;
+                return a->mode;
+        }
+
         if (a != &dev_attr_set_cookie.attr
                         && a != &dev_attr_available_size.attr)
                 return a->mode;
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 8b14bd326d4a..46d47bd6ca1f 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -3908,6 +3908,8 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_MARVELL_EXT, 0x9230,
                          quirk_dma_func1_alias);
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_TTI, 0x0642,
                          quirk_dma_func1_alias);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_TTI, 0x0645,
+                         quirk_dma_func1_alias);
 /* https://bugs.gentoo.org/show_bug.cgi?id=497630 */
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_JMICRON,
                          PCI_DEVICE_ID_JMICRON_JMB388_ESD,
diff --git a/drivers/pinctrl/samsung/pinctrl-exynos-arm.c b/drivers/pinctrl/samsung/pinctrl-exynos-arm.c
index c32399faff57..90c274490181 100644
--- a/drivers/pinctrl/samsung/pinctrl-exynos-arm.c
+++ b/drivers/pinctrl/samsung/pinctrl-exynos-arm.c
@@ -124,7 +124,7 @@ static const struct samsung_pin_bank_data s5pv210_pin_bank[] __initconst = {
         EXYNOS_PIN_BANK_EINTW(8, 0xc60, "gph3", 0x0c),
 };
 
-const struct samsung_pin_ctrl s5pv210_pin_ctrl[] __initconst = {
+static const struct samsung_pin_ctrl s5pv210_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 0 data */
                 .pin_banks      = s5pv210_pin_bank,
@@ -137,6 +137,11 @@ const struct samsung_pin_ctrl s5pv210_pin_ctrl[] __initconst = {
         },
 };
 
+const struct samsung_pinctrl_of_match_data s5pv210_of_data __initconst = {
+        .ctrl           = s5pv210_pin_ctrl,
+        .num_ctrl       = ARRAY_SIZE(s5pv210_pin_ctrl),
+};
+
 /* Pad retention control code for accessing PMU regmap */
 static atomic_t exynos_shared_retention_refcnt;
 
@@ -199,7 +204,7 @@ static const struct samsung_retention_data exynos3250_retention_data __initconst
  * Samsung pinctrl driver data for Exynos3250 SoC. Exynos3250 SoC includes
  * two gpio/pin-mux/pinconfig controllers.
  */
-const struct samsung_pin_ctrl exynos3250_pin_ctrl[] __initconst = {
+static const struct samsung_pin_ctrl exynos3250_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 0 data */
                 .pin_banks      = exynos3250_pin_banks0,
@@ -220,6 +225,11 @@ const struct samsung_pin_ctrl exynos3250_pin_ctrl[] __initconst = {
         },
 };
 
+const struct samsung_pinctrl_of_match_data exynos3250_of_data __initconst = {
+        .ctrl           = exynos3250_pin_ctrl,
+        .num_ctrl       = ARRAY_SIZE(exynos3250_pin_ctrl),
+};
+
 /* pin banks of exynos4210 pin-controller 0 */
 static const struct samsung_pin_bank_data exynos4210_pin_banks0[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpa0", 0x00),
@@ -303,7 +313,7 @@ static const struct samsung_retention_data exynos4_audio_retention_data __initco
  * Samsung pinctrl driver data for Exynos4210 SoC. Exynos4210 SoC includes
  * three gpio/pin-mux/pinconfig controllers.
  */
-const struct samsung_pin_ctrl exynos4210_pin_ctrl[] __initconst = {
+static const struct samsung_pin_ctrl exynos4210_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 0 data */
                 .pin_banks      = exynos4210_pin_banks0,
@@ -329,6 +339,11 @@ const struct samsung_pin_ctrl exynos4210_pin_ctrl[] __initconst = {
         },
 };
 
+const struct samsung_pinctrl_of_match_data exynos4210_of_data __initconst = {
+        .ctrl           = exynos4210_pin_ctrl,
+        .num_ctrl       = ARRAY_SIZE(exynos4210_pin_ctrl),
+};
+
 /* pin banks of exynos4x12 pin-controller 0 */
 static const struct samsung_pin_bank_data exynos4x12_pin_banks0[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpa0", 0x00),
@@ -391,7 +406,7 @@ static const struct samsung_pin_bank_data exynos4x12_pin_banks3[] __initconst =
  * Samsung pinctrl driver data for Exynos4x12 SoC. Exynos4x12 SoC includes
  * four gpio/pin-mux/pinconfig controllers.
  */
-const struct samsung_pin_ctrl exynos4x12_pin_ctrl[] __initconst = {
+static const struct samsung_pin_ctrl exynos4x12_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 0 data */
                 .pin_banks      = exynos4x12_pin_banks0,
@@ -427,6 +442,11 @@ const struct samsung_pin_ctrl exynos4x12_pin_ctrl[] __initconst = {
         },
 };
 
+const struct samsung_pinctrl_of_match_data exynos4x12_of_data __initconst = {
+        .ctrl           = exynos4x12_pin_ctrl,
+        .num_ctrl       = ARRAY_SIZE(exynos4x12_pin_ctrl),
+};
+
 /* pin banks of exynos5250 pin-controller 0 */
 static const struct samsung_pin_bank_data exynos5250_pin_banks0[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpa0", 0x00),
@@ -487,7 +507,7 @@ static const struct samsung_pin_bank_data exynos5250_pin_banks3[] __initconst =
  * Samsung pinctrl driver data for Exynos5250 SoC. Exynos5250 SoC includes
  * four gpio/pin-mux/pinconfig controllers.
  */
-const struct samsung_pin_ctrl exynos5250_pin_ctrl[] __initconst = {
+static const struct samsung_pin_ctrl exynos5250_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 0 data */
                 .pin_banks      = exynos5250_pin_banks0,
@@ -523,6 +543,11 @@ const struct samsung_pin_ctrl exynos5250_pin_ctrl[] __initconst = {
         },
 };
 
+const struct samsung_pinctrl_of_match_data exynos5250_of_data __initconst = {
+        .ctrl           = exynos5250_pin_ctrl,
+        .num_ctrl       = ARRAY_SIZE(exynos5250_pin_ctrl),
+};
+
 /* pin banks of exynos5260 pin-controller 0 */
 static const struct samsung_pin_bank_data exynos5260_pin_banks0[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(4, 0x000, "gpa0", 0x00),
@@ -567,7 +592,7 @@ static const struct samsung_pin_bank_data exynos5260_pin_banks2[] __initconst =
  * Samsung pinctrl driver data for Exynos5260 SoC. Exynos5260 SoC includes
  * three gpio/pin-mux/pinconfig controllers.
  */
-const struct samsung_pin_ctrl exynos5260_pin_ctrl[] __initconst = {
+static const struct samsung_pin_ctrl exynos5260_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 0 data */
                 .pin_banks      = exynos5260_pin_banks0,
@@ -587,6 +612,11 @@ const struct samsung_pin_ctrl exynos5260_pin_ctrl[] __initconst = {
         },
 };
 
+const struct samsung_pinctrl_of_match_data exynos5260_of_data __initconst = {
+        .ctrl           = exynos5260_pin_ctrl,
+        .num_ctrl       = ARRAY_SIZE(exynos5260_pin_ctrl),
+};
+
 /* pin banks of exynos5410 pin-controller 0 */
 static const struct samsung_pin_bank_data exynos5410_pin_banks0[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpa0", 0x00),
@@ -657,7 +687,7 @@ static const struct samsung_pin_bank_data exynos5410_pin_banks3[] __initconst =
  * Samsung pinctrl driver data for Exynos5410 SoC. Exynos5410 SoC includes
  * four gpio/pin-mux/pinconfig controllers.
  */
-const struct samsung_pin_ctrl exynos5410_pin_ctrl[] __initconst = {
+static const struct samsung_pin_ctrl exynos5410_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 0 data */
                 .pin_banks      = exynos5410_pin_banks0,
@@ -690,6 +720,11 @@ const struct samsung_pin_ctrl exynos5410_pin_ctrl[] __initconst = {
         },
 };
 
+const struct samsung_pinctrl_of_match_data exynos5410_of_data __initconst = {
+        .ctrl           = exynos5410_pin_ctrl,
+        .num_ctrl       = ARRAY_SIZE(exynos5410_pin_ctrl),
+};
+
 /* pin banks of exynos5420 pin-controller 0 */
 static const struct samsung_pin_bank_data exynos5420_pin_banks0[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpy7", 0x00),
@@ -774,7 +809,7 @@ static const struct samsung_retention_data exynos5420_retention_data __initconst
  * Samsung pinctrl driver data for Exynos5420 SoC. Exynos5420 SoC includes
  * four gpio/pin-mux/pinconfig controllers.
  */
-const struct samsung_pin_ctrl exynos5420_pin_ctrl[] __initconst = {
+static const struct samsung_pin_ctrl exynos5420_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 0 data */
                 .pin_banks      = exynos5420_pin_banks0,
@@ -808,3 +843,8 @@ const struct samsung_pin_ctrl exynos5420_pin_ctrl[] __initconst = {
                 .retention_data = &exynos4_audio_retention_data,
         },
 };
+
+const struct samsung_pinctrl_of_match_data exynos5420_of_data __initconst = {
+        .ctrl           = exynos5420_pin_ctrl,
+        .num_ctrl       = ARRAY_SIZE(exynos5420_pin_ctrl),
+};
diff --git a/drivers/pinctrl/samsung/pinctrl-exynos-arm64.c b/drivers/pinctrl/samsung/pinctrl-exynos-arm64.c
index fc8f7833bec0..71c9d1d9f345 100644
--- a/drivers/pinctrl/samsung/pinctrl-exynos-arm64.c
+++ b/drivers/pinctrl/samsung/pinctrl-exynos-arm64.c
@@ -175,7 +175,7 @@ static const struct samsung_retention_data exynos5433_fsys_retention_data __init
  * Samsung pinctrl driver data for Exynos5433 SoC. Exynos5433 SoC includes
  * ten gpio/pin-mux/pinconfig controllers.
  */
-const struct samsung_pin_ctrl exynos5433_pin_ctrl[] __initconst = {
+static const struct samsung_pin_ctrl exynos5433_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 0 data */
                 .pin_banks      = exynos5433_pin_banks0,
@@ -260,6 +260,11 @@ const struct samsung_pin_ctrl exynos5433_pin_ctrl[] __initconst = {
         },
 };
 
+const struct samsung_pinctrl_of_match_data exynos5433_of_data __initconst = {
+        .ctrl           = exynos5433_pin_ctrl,
+        .num_ctrl       = ARRAY_SIZE(exynos5433_pin_ctrl),
+};
+
 /* pin banks of exynos7 pin-controller - ALIVE */
 static const struct samsung_pin_bank_data exynos7_pin_banks0[] __initconst = {
         EXYNOS_PIN_BANK_EINTW(8, 0x000, "gpa0", 0x00),
@@ -339,7 +344,7 @@ static const struct samsung_pin_bank_data exynos7_pin_banks9[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(4, 0x020, "gpz1", 0x04),
 };
 
-const struct samsung_pin_ctrl exynos7_pin_ctrl[] __initconst = {
+static const struct samsung_pin_ctrl exynos7_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 0 Alive data */
                 .pin_banks      = exynos7_pin_banks0,
@@ -392,3 +397,8 @@ const struct samsung_pin_ctrl exynos7_pin_ctrl[] __initconst = {
                 .eint_gpio_init = exynos_eint_gpio_init,
         },
 };
+
+const struct samsung_pinctrl_of_match_data exynos7_of_data __initconst = {
+        .ctrl           = exynos7_pin_ctrl,
+        .num_ctrl       = ARRAY_SIZE(exynos7_pin_ctrl),
+};
diff --git a/drivers/pinctrl/samsung/pinctrl-s3c24xx.c b/drivers/pinctrl/samsung/pinctrl-s3c24xx.c
index 10187cb0e9b9..7e824e4d20f4 100644
--- a/drivers/pinctrl/samsung/pinctrl-s3c24xx.c
+++ b/drivers/pinctrl/samsung/pinctrl-s3c24xx.c
@@ -565,7 +565,7 @@ static const struct samsung_pin_bank_data s3c2412_pin_banks[] __initconst = {
         PIN_BANK_2BIT(13, 0x080, "gpj"),
 };
 
-const struct samsung_pin_ctrl s3c2412_pin_ctrl[] __initconst = {
+static const struct samsung_pin_ctrl s3c2412_pin_ctrl[] __initconst = {
         {
                 .pin_banks      = s3c2412_pin_banks,
                 .nr_banks       = ARRAY_SIZE(s3c2412_pin_banks),
@@ -573,6 +573,11 @@ const struct samsung_pin_ctrl s3c2412_pin_ctrl[] __initconst = {
         },
 };
 
+const struct samsung_pinctrl_of_match_data s3c2412_of_data __initconst = {
+        .ctrl           = s3c2412_pin_ctrl,
+        .num_ctrl       = ARRAY_SIZE(s3c2412_pin_ctrl),
+};
+
 static const struct samsung_pin_bank_data s3c2416_pin_banks[] __initconst = {
         PIN_BANK_A(27, 0x000, "gpa"),
         PIN_BANK_2BIT(11, 0x010, "gpb"),
@@ -587,7 +592,7 @@ static const struct samsung_pin_bank_data s3c2416_pin_banks[] __initconst = {
         PIN_BANK_2BIT(2, 0x100, "gpm"),
 };
 
-const struct samsung_pin_ctrl s3c2416_pin_ctrl[] __initconst = {
+static const struct samsung_pin_ctrl s3c2416_pin_ctrl[] __initconst = {
         {
                 .pin_banks      = s3c2416_pin_banks,
                 .nr_banks       = ARRAY_SIZE(s3c2416_pin_banks),
@@ -595,6 +600,11 @@ const struct samsung_pin_ctrl s3c2416_pin_ctrl[] __initconst = {
         },
 };
 
+const struct samsung_pinctrl_of_match_data s3c2416_of_data __initconst = {
+        .ctrl           = s3c2416_pin_ctrl,
+        .num_ctrl       = ARRAY_SIZE(s3c2416_pin_ctrl),
+};
+
 static const struct samsung_pin_bank_data s3c2440_pin_banks[] __initconst = {
         PIN_BANK_A(25, 0x000, "gpa"),
         PIN_BANK_2BIT(11, 0x010, "gpb"),
@@ -607,7 +617,7 @@ static const struct samsung_pin_bank_data s3c2440_pin_banks[] __initconst = {
         PIN_BANK_2BIT(13, 0x0d0, "gpj"),
 };
 
-const struct samsung_pin_ctrl s3c2440_pin_ctrl[] __initconst = {
+static const struct samsung_pin_ctrl s3c2440_pin_ctrl[] __initconst = {
         {
                 .pin_banks      = s3c2440_pin_banks,
                 .nr_banks       = ARRAY_SIZE(s3c2440_pin_banks),
@@ -615,6 +625,11 @@ const struct samsung_pin_ctrl s3c2440_pin_ctrl[] __initconst = {
         },
 };
 
+const struct samsung_pinctrl_of_match_data s3c2440_of_data __initconst = {
+        .ctrl           = s3c2440_pin_ctrl,
+        .num_ctrl       = ARRAY_SIZE(s3c2440_pin_ctrl),
+};
+
 static const struct samsung_pin_bank_data s3c2450_pin_banks[] __initconst = {
         PIN_BANK_A(28, 0x000, "gpa"),
         PIN_BANK_2BIT(11, 0x010, "gpb"),
@@ -630,10 +645,15 @@ static const struct samsung_pin_bank_data s3c2450_pin_banks[] __initconst = {
         PIN_BANK_2BIT(2, 0x100, "gpm"),
 };
 
-const struct samsung_pin_ctrl s3c2450_pin_ctrl[] __initconst = {
+static const struct samsung_pin_ctrl s3c2450_pin_ctrl[] __initconst = {
         {
                 .pin_banks      = s3c2450_pin_banks,
                 .nr_banks       = ARRAY_SIZE(s3c2450_pin_banks),
                 .eint_wkup_init = s3c24xx_eint_init,
         },
 };
+
+const struct samsung_pinctrl_of_match_data s3c2450_of_data __initconst = {
+        .ctrl           = s3c2450_pin_ctrl,
+        .num_ctrl       = ARRAY_SIZE(s3c2450_pin_ctrl),
+};
diff --git a/drivers/pinctrl/samsung/pinctrl-s3c64xx.c b/drivers/pinctrl/samsung/pinctrl-s3c64xx.c
index 679628ac4b31..288e6567ceb1 100644
--- a/drivers/pinctrl/samsung/pinctrl-s3c64xx.c
+++ b/drivers/pinctrl/samsung/pinctrl-s3c64xx.c
@@ -789,7 +789,7 @@ static const struct samsung_pin_bank_data s3c64xx_pin_banks0[] __initconst = {
  * Samsung pinctrl driver data for S3C64xx SoC. S3C64xx SoC includes
  * one gpio/pin-mux/pinconfig controller.
  */
-const struct samsung_pin_ctrl s3c64xx_pin_ctrl[] __initconst = {
+static const struct samsung_pin_ctrl s3c64xx_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 1 data */
                 .pin_banks      = s3c64xx_pin_banks0,
@@ -798,3 +798,8 @@ const struct samsung_pin_ctrl s3c64xx_pin_ctrl[] __initconst = {
                 .eint_wkup_init = s3c64xx_eint_eint0_init,
         },
 };
+
+const struct samsung_pinctrl_of_match_data s3c64xx_of_data __initconst = {
+        .ctrl           = s3c64xx_pin_ctrl,
+        .num_ctrl       = ARRAY_SIZE(s3c64xx_pin_ctrl),
+};
diff --git a/drivers/pinctrl/samsung/pinctrl-samsung.c b/drivers/pinctrl/samsung/pinctrl-samsung.c
index da58e4554137..336e88d7bdb9 100644
--- a/drivers/pinctrl/samsung/pinctrl-samsung.c
+++ b/drivers/pinctrl/samsung/pinctrl-samsung.c
@@ -942,12 +942,33 @@ static int samsung_gpiolib_register(struct platform_device *pdev,
         return 0;
 }
 
+static const struct samsung_pin_ctrl *
+samsung_pinctrl_get_soc_data_for_of_alias(struct platform_device *pdev)
+{
+        struct device_node *node = pdev->dev.of_node;
+        const struct samsung_pinctrl_of_match_data *of_data;
+        int id;
+
+        id = of_alias_get_id(node, "pinctrl");
+        if (id < 0) {
+                dev_err(&pdev->dev, "failed to get alias id\n");
+                return NULL;
+        }
+
+        of_data = of_device_get_match_data(&pdev->dev);
+        if (id >= of_data->num_ctrl) {
+                dev_err(&pdev->dev, "invalid alias id %d\n", id);
+                return NULL;
+        }
+
+        return &(of_data->ctrl[id]);
+}
+
 /* retrieve the soc specific data */
 static const struct samsung_pin_ctrl *
 samsung_pinctrl_get_soc_data(struct samsung_pinctrl_drv_data *d,
                              struct platform_device *pdev)
 {
-        int id;
         struct device_node *node = pdev->dev.of_node;
         struct device_node *np;
         const struct samsung_pin_bank_data *bdata;
@@ -957,13 +978,9 @@ samsung_pinctrl_get_soc_data(struct samsung_pinctrl_drv_data *d,
         void __iomem *virt_base[SAMSUNG_PINCTRL_NUM_RESOURCES];
         unsigned int i;
 
-        id = of_alias_get_id(node, "pinctrl");
-        if (id < 0) {
-                dev_err(&pdev->dev, "failed to get alias id\n");
+        ctrl = samsung_pinctrl_get_soc_data_for_of_alias(pdev);
+        if (!ctrl)
                 return ERR_PTR(-ENOENT);
-        }
-        ctrl = of_device_get_match_data(&pdev->dev);
-        ctrl += id;
 
         d->suspend = ctrl->suspend;
         d->resume = ctrl->resume;
@@ -1188,41 +1205,41 @@ static int __maybe_unused samsung_pinctrl_resume(struct device *dev)
 static const struct of_device_id samsung_pinctrl_dt_match[] = {
 #ifdef CONFIG_PINCTRL_EXYNOS_ARM
         { .compatible = "samsung,exynos3250-pinctrl",
-                .data = exynos3250_pin_ctrl },
+                .data = &exynos3250_of_data },
         { .compatible = "samsung,exynos4210-pinctrl",
-                .data = exynos4210_pin_ctrl },
+                .data = &exynos4210_of_data },
         { .compatible = "samsung,exynos4x12-pinctrl",
-                .data = exynos4x12_pin_ctrl },
+                .data = &exynos4x12_of_data },
         { .compatible = "samsung,exynos5250-pinctrl",
-                .data = exynos5250_pin_ctrl },
+                .data = &exynos5250_of_data },
         { .compatible = "samsung,exynos5260-pinctrl",
-                .data = exynos5260_pin_ctrl },
+                .data = &exynos5260_of_data },
         { .compatible = "samsung,exynos5410-pinctrl",
-                .data = exynos5410_pin_ctrl },
+                .data = &exynos5410_of_data },
         { .compatible = "samsung,exynos5420-pinctrl",
-                .data = exynos5420_pin_ctrl },
+                .data = &exynos5420_of_data },
         { .compatible = "samsung,s5pv210-pinctrl",
-                .data = s5pv210_pin_ctrl },
+                .data = &s5pv210_of_data },
 #endif
 #ifdef CONFIG_PINCTRL_EXYNOS_ARM64
         { .compatible = "samsung,exynos5433-pinctrl",
-                .data = exynos5433_pin_ctrl },
+                .data = &exynos5433_of_data },
         { .compatible = "samsung,exynos7-pinctrl",
-                .data = exynos7_pin_ctrl },
+                .data = &exynos7_of_data },
 #endif
 #ifdef CONFIG_PINCTRL_S3C64XX
         { .compatible = "samsung,s3c64xx-pinctrl",
-                .data = s3c64xx_pin_ctrl },
+                .data = &s3c64xx_of_data },
 #endif
 #ifdef CONFIG_PINCTRL_S3C24XX
         { .compatible = "samsung,s3c2412-pinctrl",
-                .data = s3c2412_pin_ctrl },
+                .data = &s3c2412_of_data },
         { .compatible = "samsung,s3c2416-pinctrl",
-                .data = s3c2416_pin_ctrl },
+                .data = &s3c2416_of_data },
         { .compatible = "samsung,s3c2440-pinctrl",
-                .data = s3c2440_pin_ctrl },
+                .data = &s3c2440_of_data },
         { .compatible = "samsung,s3c2450-pinctrl",
-                .data = s3c2450_pin_ctrl },
+                .data = &s3c2450_of_data },
 #endif
         {},
 };
diff --git a/drivers/pinctrl/samsung/pinctrl-samsung.h b/drivers/pinctrl/samsung/pinctrl-samsung.h
index e204f609823b..f0cda9424dfe 100644
--- a/drivers/pinctrl/samsung/pinctrl-samsung.h
+++ b/drivers/pinctrl/samsung/pinctrl-samsung.h
@@ -282,6 +282,16 @@ struct samsung_pinctrl_drv_data {
 };
 
 /**
+ * struct samsung_pinctrl_of_match_data: OF match device specific configuration data.
+ * @ctrl: array of pin controller data.
+ * @num_ctrl: size of array @ctrl.
+ */
+struct samsung_pinctrl_of_match_data {
+        const struct samsung_pin_ctrl   *ctrl;
+        unsigned int                    num_ctrl;
+};
+
+/**
  * struct samsung_pin_group: represent group of pins of a pinmux function.
  * @name: name of the pin group, used to lookup the group.
  * @pins: the pins included in this group.
@@ -309,20 +319,20 @@ struct samsung_pmx_func {
 };
 
 /* list of all exported SoC specific data */
-extern const struct samsung_pin_ctrl exynos3250_pin_ctrl[];
-extern const struct samsung_pin_ctrl exynos4210_pin_ctrl[];
-extern const struct samsung_pin_ctrl exynos4x12_pin_ctrl[];
-extern const struct samsung_pin_ctrl exynos5250_pin_ctrl[];
-extern const struct samsung_pin_ctrl exynos5260_pin_ctrl[];
-extern const struct samsung_pin_ctrl exynos5410_pin_ctrl[];
-extern const struct samsung_pin_ctrl exynos5420_pin_ctrl[];
-extern const struct samsung_pin_ctrl exynos5433_pin_ctrl[];
-extern const struct samsung_pin_ctrl exynos7_pin_ctrl[];
-extern const struct samsung_pin_ctrl s3c64xx_pin_ctrl[];
-extern const struct samsung_pin_ctrl s3c2412_pin_ctrl[];
-extern const struct samsung_pin_ctrl s3c2416_pin_ctrl[];
-extern const struct samsung_pin_ctrl s3c2440_pin_ctrl[];
-extern const struct samsung_pin_ctrl s3c2450_pin_ctrl[];
-extern const struct samsung_pin_ctrl s5pv210_pin_ctrl[];
+extern const struct samsung_pinctrl_of_match_data exynos3250_of_data;
+extern const struct samsung_pinctrl_of_match_data exynos4210_of_data;
+extern const struct samsung_pinctrl_of_match_data exynos4x12_of_data;
+extern const struct samsung_pinctrl_of_match_data exynos5250_of_data;
+extern const struct samsung_pinctrl_of_match_data exynos5260_of_data;
+extern const struct samsung_pinctrl_of_match_data exynos5410_of_data;
+extern const struct samsung_pinctrl_of_match_data exynos5420_of_data;
+extern const struct samsung_pinctrl_of_match_data exynos5433_of_data;
+extern const struct samsung_pinctrl_of_match_data exynos7_of_data;
+extern const struct samsung_pinctrl_of_match_data s3c64xx_of_data;
+extern const struct samsung_pinctrl_of_match_data s3c2412_of_data;
+extern const struct samsung_pinctrl_of_match_data s3c2416_of_data;
+extern const struct samsung_pinctrl_of_match_data s3c2440_of_data;
+extern const struct samsung_pinctrl_of_match_data s3c2450_of_data;
+extern const struct samsung_pinctrl_of_match_data s5pv210_of_data;
 
 #endif /* __PINCTRL_SAMSUNG_H */
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a7795.c b/drivers/pinctrl/sh-pfc/pfc-r8a7795.c
index 18aeee592fdc..35951e7b89d2 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a7795.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a7795.c
@@ -1538,7 +1538,6 @@ static const struct sh_pfc_pin pinmux_pins[] = {
         SH_PFC_PIN_NAMED_CFG('B', 18, AVB_TD1, CFG_FLAGS),
         SH_PFC_PIN_NAMED_CFG('B', 19, AVB_RXC, CFG_FLAGS),
         SH_PFC_PIN_NAMED_CFG('C',  1, PRESETOUT#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('F',  1, CLKOUT, CFG_FLAGS),
         SH_PFC_PIN_NAMED_CFG('H', 37, MLB_REF, CFG_FLAGS),
         SH_PFC_PIN_NAMED_CFG('V',  3, QSPI1_SPCLK, CFG_FLAGS),
         SH_PFC_PIN_NAMED_CFG('V',  5, QSPI1_SSL, CFG_FLAGS),
diff --git a/drivers/s390/net/qeth_core_main.c b/drivers/s390/net/qeth_core_main.c
index c8b308cfabf1..3653bea38470 100644
--- a/drivers/s390/net/qeth_core_main.c
+++ b/drivers/s390/net/qeth_core_main.c
@@ -527,8 +527,7 @@ static inline int qeth_is_cq(struct qeth_card *card, unsigned int queue)
             queue == card->qdio.no_in_queues - 1;
 }
 
-
-static int qeth_issue_next_read(struct qeth_card *card)
+static int __qeth_issue_next_read(struct qeth_card *card)
 {
         int rc;
         struct qeth_cmd_buffer *iob;
@@ -559,6 +558,17 @@ static int qeth_issue_next_read(struct qeth_card *card)
         return rc;
 }
 
+static int qeth_issue_next_read(struct qeth_card *card)
+{
+        int ret;
+
+        spin_lock_irq(get_ccwdev_lock(CARD_RDEV(card)));
+        ret = __qeth_issue_next_read(card);
+        spin_unlock_irq(get_ccwdev_lock(CARD_RDEV(card)));
+
+        return ret;
+}
+
 static struct qeth_reply *qeth_alloc_reply(struct qeth_card *card)
 {
         struct qeth_reply *reply;
@@ -960,7 +970,7 @@ void qeth_clear_thread_running_bit(struct qeth_card *card, unsigned long thread)
         spin_lock_irqsave(&card->thread_mask_lock, flags);
         card->thread_running_mask &= ~thread;
         spin_unlock_irqrestore(&card->thread_mask_lock, flags);
-        wake_up(&card->wait_q);
+        wake_up_all(&card->wait_q);
 }
 EXPORT_SYMBOL_GPL(qeth_clear_thread_running_bit);
 
@@ -1164,6 +1174,7 @@ static void qeth_irq(struct ccw_device *cdev, unsigned long intparm,
                 }
                 rc = qeth_get_problem(cdev, irb);
                 if (rc) {
+                        card->read_or_write_problem = 1;
                         qeth_clear_ipacmd_list(card);
                         qeth_schedule_recovery(card);
                         goto out;
@@ -1182,7 +1193,7 @@ static void qeth_irq(struct ccw_device *cdev, unsigned long intparm,
                 return;
         if (channel == &card->read &&
             channel->state == CH_STATE_UP)
-                qeth_issue_next_read(card);
+                __qeth_issue_next_read(card);
 
         iob = channel->iob;
         index = channel->buf_no;
@@ -5087,8 +5098,6 @@ static void qeth_core_free_card(struct qeth_card *card)
         QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
         qeth_clean_channel(&card->read);
         qeth_clean_channel(&card->write);
-        if (card->dev)
-                free_netdev(card->dev);
         qeth_free_qdio_buffers(card);
         unregister_service_level(&card->qeth_service_level);
         kfree(card);
diff --git a/drivers/s390/net/qeth_l2_main.c b/drivers/s390/net/qeth_l2_main.c
index 7f236440483f..5ef4c978ad19 100644
--- a/drivers/s390/net/qeth_l2_main.c
+++ b/drivers/s390/net/qeth_l2_main.c
@@ -915,8 +915,8 @@ static void qeth_l2_remove_device(struct ccwgroup_device *cgdev)
                 qeth_l2_set_offline(cgdev);
 
         if (card->dev) {
-                netif_napi_del(&card->napi);
                 unregister_netdev(card->dev);
+                free_netdev(card->dev);
                 card->dev = NULL;
         }
         return;
diff --git a/drivers/s390/net/qeth_l3_main.c b/drivers/s390/net/qeth_l3_main.c
index 962a04b68dd2..b6b12220da71 100644
--- a/drivers/s390/net/qeth_l3_main.c
+++ b/drivers/s390/net/qeth_l3_main.c
@@ -2865,8 +2865,8 @@ static void qeth_l3_remove_device(struct ccwgroup_device *cgdev)
                 qeth_l3_set_offline(cgdev);
 
         if (card->dev) {
-                netif_napi_del(&card->napi);
                 unregister_netdev(card->dev);
+                free_netdev(card->dev);
                 card->dev = NULL;
         }
 
diff --git a/drivers/scsi/libsas/sas_scsi_host.c b/drivers/scsi/libsas/sas_scsi_host.c
index 6de9681ace82..ceab5e5c41c2 100644
--- a/drivers/scsi/libsas/sas_scsi_host.c
+++ b/drivers/scsi/libsas/sas_scsi_host.c
@@ -223,6 +223,7 @@ out_done:
 static void sas_eh_finish_cmd(struct scsi_cmnd *cmd)
 {
         struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(cmd->device->host);
+        struct domain_device *dev = cmd_to_domain_dev(cmd);
         struct sas_task *task = TO_SAS_TASK(cmd);
 
         /* At this point, we only get called following an actual abort
@@ -231,6 +232,14 @@ static void sas_eh_finish_cmd(struct scsi_cmnd *cmd)
          */
         sas_end_task(cmd, task);
 
+        if (dev_is_sata(dev)) {
+                /* defer commands to libata so that libata EH can
+                 * handle ata qcs correctly
+                 */
+                list_move_tail(&cmd->eh_entry, &sas_ha->eh_ata_q);
+                return;
+        }
+
         /* now finish the command and move it on to the error
          * handler done list, this also takes it off the
          * error handler pending list.
@@ -238,22 +247,6 @@ static void sas_eh_finish_cmd(struct scsi_cmnd *cmd)
         scsi_eh_finish_cmd(cmd, &sas_ha->eh_done_q);
 }
 
-static void sas_eh_defer_cmd(struct scsi_cmnd *cmd)
-{
-        struct domain_device *dev = cmd_to_domain_dev(cmd);
-        struct sas_ha_struct *ha = dev->port->ha;
-        struct sas_task *task = TO_SAS_TASK(cmd);
-
-        if (!dev_is_sata(dev)) {
-                sas_eh_finish_cmd(cmd);
-                return;
-        }
-
-        /* report the timeout to libata */
-        sas_end_task(cmd, task);
-        list_move_tail(&cmd->eh_entry, &ha->eh_ata_q);
-}
-
 static void sas_scsi_clear_queue_lu(struct list_head *error_q, struct scsi_cmnd *my_cmd)
 {
         struct scsi_cmnd *cmd, *n;
@@ -261,7 +254,7 @@ static void sas_scsi_clear_queue_lu(struct list_head *error_q, struct scsi_cmnd
         list_for_each_entry_safe(cmd, n, error_q, eh_entry) {
                 if (cmd->device->sdev_target == my_cmd->device->sdev_target &&
                     cmd->device->lun == my_cmd->device->lun)
-                        sas_eh_defer_cmd(cmd);
+                        sas_eh_finish_cmd(cmd);
         }
 }
 
@@ -631,12 +624,12 @@ static void sas_eh_handle_sas_errors(struct Scsi_Host *shost, struct list_head *
                 case TASK_IS_DONE:
                         SAS_DPRINTK("%s: task 0x%p is done\n", __func__,
                                     task);
-                        sas_eh_defer_cmd(cmd);
+                        sas_eh_finish_cmd(cmd);
                         continue;
                 case TASK_IS_ABORTED:
                         SAS_DPRINTK("%s: task 0x%p is aborted\n",
                                     __func__, task);
-                        sas_eh_defer_cmd(cmd);
+                        sas_eh_finish_cmd(cmd);
                         continue;
                 case TASK_IS_AT_LU:
                         SAS_DPRINTK("task 0x%p is at LU: lu recover\n", task);
@@ -647,7 +640,7 @@ static void sas_eh_handle_sas_errors(struct Scsi_Host *shost, struct list_head *
                                             "recovered\n",
                                             SAS_ADDR(task->dev),
                                             cmd->device->lun);
-                                sas_eh_defer_cmd(cmd);
+                                sas_eh_finish_cmd(cmd);
                                 sas_scsi_clear_queue_lu(work_q, cmd);
                                 goto Again;
                         }
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 00329dda6179..8d7fab3cd01d 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -1719,7 +1719,6 @@ qla24xx_handle_plogi_done_event(struct scsi_qla_host *vha, struct event_arg *ea)
 
                         set_bit(ea->fcport->loop_id, vha->hw->loop_id_map);
                         spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
-                        ea->fcport->loop_id = FC_NO_LOOP_ID;
                         ea->fcport->chip_reset = vha->hw->base_qpair->chip_reset;
                         ea->fcport->logout_on_delete = 1;
                         ea->fcport->send_els_logo = 0;
diff --git a/drivers/soc/fsl/qbman/qman.c b/drivers/soc/fsl/qbman/qman.c
index e4f5bb056fd2..ba3cfa8e279b 100644
--- a/drivers/soc/fsl/qbman/qman.c
+++ b/drivers/soc/fsl/qbman/qman.c
@@ -2443,39 +2443,21 @@ struct cgr_comp {
         struct completion completion;
 };
 
-static int qman_delete_cgr_thread(void *p)
+static void qman_delete_cgr_smp_call(void *p)
 {
-        struct cgr_comp *cgr_comp = (struct cgr_comp *)p;
-        int ret;
-
-        ret = qman_delete_cgr(cgr_comp->cgr);
-        complete(&cgr_comp->completion);
-
-        return ret;
+        qman_delete_cgr((struct qman_cgr *)p);
 }
 
 void qman_delete_cgr_safe(struct qman_cgr *cgr)
 {
-        struct task_struct *thread;
-        struct cgr_comp cgr_comp;
-
         preempt_disable();
         if (qman_cgr_cpus[cgr->cgrid] != smp_processor_id()) {
-                init_completion(&cgr_comp.completion);
-                cgr_comp.cgr = cgr;
-                thread = kthread_create(qman_delete_cgr_thread, &cgr_comp,
-                                        "cgr_del");
-
-                if (IS_ERR(thread))
-                        goto out;
-
-                kthread_bind(thread, qman_cgr_cpus[cgr->cgrid]);
-                wake_up_process(thread);
-                wait_for_completion(&cgr_comp.completion);
+                smp_call_function_single(qman_cgr_cpus[cgr->cgrid],
+                                         qman_delete_cgr_smp_call, cgr, true);
                 preempt_enable();
                 return;
         }
-out:
+
         qman_delete_cgr(cgr);
         preempt_enable();
 }
diff --git a/drivers/staging/ncpfs/ncplib_kernel.c b/drivers/staging/ncpfs/ncplib_kernel.c
index 804adfebba2f..3e047eb4cc7c 100644
--- a/drivers/staging/ncpfs/ncplib_kernel.c
+++ b/drivers/staging/ncpfs/ncplib_kernel.c
@@ -981,6 +981,10 @@ ncp_read_kernel(struct ncp_server *server, const char *file_id,
                 goto out;
         }
         *bytes_read = ncp_reply_be16(server, 0);
+        if (*bytes_read > to_read) {
+                result = -EINVAL;
+                goto out;
+        }
         source = ncp_reply_data(server, 2 + (offset & 1));
 
         memcpy(target, source, *bytes_read);
diff --git a/drivers/tty/vt/vt.c b/drivers/tty/vt/vt.c
index 88b902c525d7..b4e57c5a8bba 100644
--- a/drivers/tty/vt/vt.c
+++ b/drivers/tty/vt/vt.c
@@ -1727,7 +1727,7 @@ static void reset_terminal(struct vc_data *vc, int do_clear)
         default_attr(vc);
         update_attr(vc);
 
-        vc->vc_tab_stop[0]      = 0x01010100;
+        vc->vc_tab_stop[0]      =
         vc->vc_tab_stop[1]      =
         vc->vc_tab_stop[2]      =
         vc->vc_tab_stop[3]      =
@@ -1771,7 +1771,7 @@ static void do_con_trol(struct tty_struct *tty, struct vc_data *vc, int c)
                 vc->vc_pos -= (vc->vc_x << 1);
                 while (vc->vc_x < vc->vc_cols - 1) {
                         vc->vc_x++;
-                        if (vc->vc_tab_stop[vc->vc_x >> 5] & (1 << (vc->vc_x & 31)))
+                        if (vc->vc_tab_stop[7 & (vc->vc_x >> 5)] & (1 << (vc->vc_x & 31)))
                                 break;
                 }
                 vc->vc_pos += (vc->vc_x << 1);
@@ -1831,7 +1831,7 @@ static void do_con_trol(struct tty_struct *tty, struct vc_data *vc, int c)
                         lf(vc);
                         return;
                 case 'H':
-                        vc->vc_tab_stop[vc->vc_x >> 5] |= (1 << (vc->vc_x & 31));
+                        vc->vc_tab_stop[7 & (vc->vc_x >> 5)] |= (1 << (vc->vc_x & 31));
                         return;
                 case 'Z':
                         respond_ID(tty);
@@ -2024,7 +2024,7 @@ static void do_con_trol(struct tty_struct *tty, struct vc_data *vc, int c)
                         return;
                 case 'g':
                         if (!vc->vc_par[0])
-                                vc->vc_tab_stop[vc->vc_x >> 5] &= ~(1 << (vc->vc_x & 31));
+                                vc->vc_tab_stop[7 & (vc->vc_x >> 5)] &= ~(1 << (vc->vc_x & 31));
                         else if (vc->vc_par[0] == 3) {
                                 vc->vc_tab_stop[0] =
                                         vc->vc_tab_stop[1] =
diff --git a/drivers/vfio/pci/vfio_pci.c b/drivers/vfio/pci/vfio_pci.c
index b0f759476900..8a1508a8e481 100644
--- a/drivers/vfio/pci/vfio_pci.c
+++ b/drivers/vfio/pci/vfio_pci.c
@@ -207,9 +207,6 @@ static bool vfio_pci_nointx(struct pci_dev *pdev)
                 }
         }
 
-        if (!pdev->irq)
-                return true;
-
         return false;
 }
 
diff --git a/drivers/vhost/net.c b/drivers/vhost/net.c
index 610cba276d47..8139bc70ad7d 100644
--- a/drivers/vhost/net.c
+++ b/drivers/vhost/net.c
@@ -170,7 +170,7 @@ static void vhost_net_buf_unproduce(struct vhost_net_virtqueue *nvq)
         if (nvq->rx_ring && !vhost_net_buf_is_empty(rxq)) {
                 ptr_ring_unconsume(nvq->rx_ring, rxq->queue + rxq->head,
                                    vhost_net_buf_get_size(rxq),
-                                   __skb_array_destroy_skb);
+                                   tun_ptr_free);
                 rxq->head = rxq->tail = 0;
         }
 }
@@ -948,6 +948,7 @@ static int vhost_net_open(struct inode *inode, struct file *f)
                 n->vqs[i].done_idx = 0;
                 n->vqs[i].vhost_hlen = 0;
                 n->vqs[i].sock_hlen = 0;
+                n->vqs[i].rx_ring = NULL;
                 vhost_net_buf_init(&n->vqs[i].rxq);
         }
         vhost_dev_init(dev, vqs, VHOST_NET_VQ_MAX);
@@ -972,6 +973,7 @@ static struct socket *vhost_net_stop_vq(struct vhost_net *n,
         vhost_net_disable_vq(n, vq);
         vq->private_data = NULL;
         vhost_net_buf_unproduce(nvq);
+        nvq->rx_ring = NULL;
         mutex_unlock(&vq->mutex);
         return sock;
 }
@@ -1161,14 +1163,14 @@ static long vhost_net_set_backend(struct vhost_net *n, unsigned index, int fd)
                 vhost_net_disable_vq(n, vq);
                 vq->private_data = sock;
                 vhost_net_buf_unproduce(nvq);
-                if (index == VHOST_NET_VQ_RX)
-                        nvq->rx_ring = get_tap_ptr_ring(fd);
                 r = vhost_vq_init_access(vq);
                 if (r)
                         goto err_used;
                 r = vhost_net_enable_vq(n, vq);
                 if (r)
                         goto err_used;
+                if (index == VHOST_NET_VQ_RX)
+                        nvq->rx_ring = get_tap_ptr_ring(fd);
 
                 oldubufs = nvq->ubufs;
                 nvq->ubufs = ubufs;
diff --git a/drivers/watchdog/wdat_wdt.c b/drivers/watchdog/wdat_wdt.c
index 6d1fbda0f461..0da9943d405f 100644
--- a/drivers/watchdog/wdat_wdt.c
+++ b/drivers/watchdog/wdat_wdt.c
@@ -392,7 +392,7 @@ static int wdat_wdt_probe(struct platform_device *pdev)
 
                 memset(&r, 0, sizeof(r));
                 r.start = gas->address;
-                r.end = r.start + gas->access_width;
+                r.end = r.start + gas->access_width - 1;
                 if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
                         r.flags = IORESOURCE_MEM;
                 } else if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 8fe1b0aa2896..b9a254dcc0e7 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -108,6 +108,16 @@ static void huge_pagevec_release(struct pagevec *pvec)
         pagevec_reinit(pvec);
 }
 
+/*
+ * Mask used when checking the page offset value passed in via system
+ * calls.  This value will be converted to a loff_t which is signed.
+ * Therefore, we want to check the upper PAGE_SHIFT + 1 bits of the
+ * value.  The extra bit (- 1 in the shift value) is to take the sign
+ * bit into account.
+ */
+#define PGOFF_LOFFT_MAX \
+        (((1UL << (PAGE_SHIFT + 1)) - 1) <<  (BITS_PER_LONG - (PAGE_SHIFT + 1)))
+
 static int hugetlbfs_file_mmap(struct file *file, struct vm_area_struct *vma)
 {
         struct inode *inode = file_inode(file);
@@ -127,12 +137,13 @@ static int hugetlbfs_file_mmap(struct file *file, struct vm_area_struct *vma)
         vma->vm_ops = &hugetlb_vm_ops;
 
         /*
-         * Offset passed to mmap (before page shift) could have been
-         * negative when represented as a (l)off_t.
+         * page based offset in vm_pgoff could be sufficiently large to
+         * overflow a (l)off_t when converted to byte offset.
          */
-        if (((loff_t)vma->vm_pgoff << PAGE_SHIFT) < 0)
+        if (vma->vm_pgoff & PGOFF_LOFFT_MAX)
                 return -EINVAL;
 
+        /* must be huge page aligned */
         if (vma->vm_pgoff & (~huge_page_mask(h) >> PAGE_SHIFT))
                 return -EINVAL;
 
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 150521c9671b..61b770e39809 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -268,6 +268,35 @@ free_blocked_lock(struct nfsd4_blocked_lock *nbl)
         kfree(nbl);
 }
 
+static void
+remove_blocked_locks(struct nfs4_lockowner *lo)
+{
+        struct nfs4_client *clp = lo->lo_owner.so_client;
+        struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
+        struct nfsd4_blocked_lock *nbl;
+        LIST_HEAD(reaplist);
+
+        /* Dequeue all blocked locks */
+        spin_lock(&nn->blocked_locks_lock);
+        while (!list_empty(&lo->lo_blocked)) {
+                nbl = list_first_entry(&lo->lo_blocked,
+                                        struct nfsd4_blocked_lock,
+                                        nbl_list);
+                list_del_init(&nbl->nbl_list);
+                list_move(&nbl->nbl_lru, &reaplist);
+        }
+        spin_unlock(&nn->blocked_locks_lock);
+
+        /* Now free them */
+        while (!list_empty(&reaplist)) {
+                nbl = list_first_entry(&reaplist, struct nfsd4_blocked_lock,
+                                        nbl_lru);
+                list_del_init(&nbl->nbl_lru);
+                posix_unblock_lock(&nbl->nbl_lock);
+                free_blocked_lock(nbl);
+        }
+}
+
 static int
 nfsd4_cb_notify_lock_done(struct nfsd4_callback *cb, struct rpc_task *task)
 {
@@ -1866,6 +1895,7 @@ static __be32 mark_client_expired_locked(struct nfs4_client *clp)
 static void
 __destroy_client(struct nfs4_client *clp)
 {
+        int i;
         struct nfs4_openowner *oo;
         struct nfs4_delegation *dp;
         struct list_head reaplist;
@@ -1895,6 +1925,16 @@ __destroy_client(struct nfs4_client *clp)
                 nfs4_get_stateowner(&oo->oo_owner);
                 release_openowner(oo);
         }
+        for (i = 0; i < OWNER_HASH_SIZE; i++) {
+                struct nfs4_stateowner *so, *tmp;
+
+                list_for_each_entry_safe(so, tmp, &clp->cl_ownerstr_hashtbl[i],
+                                         so_strhash) {
+                        /* Should be no openowners at this point */
+                        WARN_ON_ONCE(so->so_is_open_owner);
+                        remove_blocked_locks(lockowner(so));
+                }
+        }
         nfsd4_return_all_client_layouts(clp);
         nfsd4_shutdown_callback(clp);
         if (clp->cl_cb_conn.cb_xprt)
@@ -6355,6 +6395,7 @@ nfsd4_release_lockowner(struct svc_rqst *rqstp,
         }
         spin_unlock(&clp->cl_lock);
         free_ol_stateid_reaplist(&reaplist);
+        remove_blocked_locks(lo);
         nfs4_put_stateowner(&lo->lo_owner);
 
         return status;
@@ -7140,6 +7181,8 @@ nfs4_state_destroy_net(struct net *net)
                 }
         }
 
+        WARN_ON(!list_empty(&nn->blocked_locks_lru));
+
         for (i = 0; i < CLIENT_HASH_SIZE; i++) {
                 while (!list_empty(&nn->unconf_id_hashtbl[i])) {
                         clp = list_entry(nn->unconf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
@@ -7206,7 +7249,6 @@ nfs4_state_shutdown_net(struct net *net)
         struct nfs4_delegation *dp = NULL;
         struct list_head *pos, *next, reaplist;
         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
-        struct nfsd4_blocked_lock *nbl;
 
         cancel_delayed_work_sync(&nn->laundromat_work);
         locks_end_grace(&nn->nfsd4_manager);
@@ -7227,24 +7269,6 @@ nfs4_state_shutdown_net(struct net *net)
                 nfs4_put_stid(&dp->dl_stid);
         }
 
-        BUG_ON(!list_empty(&reaplist));
-        spin_lock(&nn->blocked_locks_lock);
-        while (!list_empty(&nn->blocked_locks_lru)) {
-                nbl = list_first_entry(&nn->blocked_locks_lru,
-                                        struct nfsd4_blocked_lock, nbl_lru);
-                list_move(&nbl->nbl_lru, &reaplist);
-                list_del_init(&nbl->nbl_list);
-        }
-        spin_unlock(&nn->blocked_locks_lock);
-
-        while (!list_empty(&reaplist)) {
-                nbl = list_first_entry(&reaplist,
-                                        struct nfsd4_blocked_lock, nbl_lru);
-                list_del_init(&nbl->nbl_lru);
-                posix_unblock_lock(&nbl->nbl_lock);
-                free_blocked_lock(nbl);
-        }
-
         nfsd4_client_tracking_exit(net);
         nfs4_state_destroy_net(net);
 }
diff --git a/fs/sysfs/symlink.c b/fs/sysfs/symlink.c
index 8664db25a9a6..215c225b2ca1 100644
--- a/fs/sysfs/symlink.c
+++ b/fs/sysfs/symlink.c
@@ -106,6 +106,7 @@ int sysfs_create_link_nowarn(struct kobject *kobj, struct kobject *target,
 {
         return sysfs_do_create_link(kobj, target, name, 0);
 }
+EXPORT_SYMBOL_GPL(sysfs_create_link_nowarn);
 
 /**
  *      sysfs_delete_link - remove symlink in object's directory.
diff --git a/include/asm-generic/pgtable.h b/include/asm-generic/pgtable.h
index 2cfa3075d148..bfbb44a5ad38 100644
--- a/include/asm-generic/pgtable.h
+++ b/include/asm-generic/pgtable.h
@@ -983,6 +983,8 @@ int pud_set_huge(pud_t *pud, phys_addr_t addr, pgprot_t prot);
 int pmd_set_huge(pmd_t *pmd, phys_addr_t addr, pgprot_t prot);
 int pud_clear_huge(pud_t *pud);
 int pmd_clear_huge(pmd_t *pmd);
+int pud_free_pmd_page(pud_t *pud);
+int pmd_free_pte_page(pmd_t *pmd);
 #else   /* !CONFIG_HAVE_ARCH_HUGE_VMAP */
 static inline int p4d_set_huge(p4d_t *p4d, phys_addr_t addr, pgprot_t prot)
 {
@@ -1008,6 +1010,14 @@ static inline int pmd_clear_huge(pmd_t *pmd)
 {
         return 0;
 }
+static inline int pud_free_pmd_page(pud_t *pud)
+{
+        return 0;
+}
+static inline int pmd_free_pte_page(pmd_t *pmd)
+{
+        return 0;
+}
 #endif  /* CONFIG_HAVE_ARCH_HUGE_VMAP */
 
 #ifndef __HAVE_ARCH_FLUSH_PMD_TLB_RANGE
diff --git a/include/linux/cgroup-defs.h b/include/linux/cgroup-defs.h
index 9f242b876fde..f8e76d01a5ad 100644
--- a/include/linux/cgroup-defs.h
+++ b/include/linux/cgroup-defs.h
@@ -755,13 +755,13 @@ struct sock_cgroup_data {
  * updaters and return part of the previous pointer as the prioidx or
  * classid.  Such races are short-lived and the result isn't critical.
  */
-static inline u16 sock_cgroup_prioidx(struct sock_cgroup_data *skcd)
+static inline u16 sock_cgroup_prioidx(const struct sock_cgroup_data *skcd)
 {
         /* fallback to 1 which is always the ID of the root cgroup */
         return (skcd->is_data & 1) ? skcd->prioidx : 1;
 }
 
-static inline u32 sock_cgroup_classid(struct sock_cgroup_data *skcd)
+static inline u32 sock_cgroup_classid(const struct sock_cgroup_data *skcd)
 {
         /* fallback to 0 which is the unconfigured default classid */
         return (skcd->is_data & 1) ? skcd->classid : 0;
diff --git a/include/linux/fsl_ifc.h b/include/linux/fsl_ifc.h
index c332f0a45607..3fdfede2f0f3 100644
--- a/include/linux/fsl_ifc.h
+++ b/include/linux/fsl_ifc.h
@@ -734,11 +734,7 @@ struct fsl_ifc_nand {
         u32 res19[0x10];
         __be32 nand_fsr;
         u32 res20;
-        /* The V1 nand_eccstat is actually 4 words that overlaps the
-         * V2 nand_eccstat.
-         */
-        __be32 v1_nand_eccstat[2];
-        __be32 v2_nand_eccstat[6];
+        __be32 nand_eccstat[8];
         u32 res21[0x1c];
         __be32 nanndcr;
         u32 res22[0x2];
diff --git a/include/linux/if_tun.h b/include/linux/if_tun.h
index c5b0a75a7812..fd00170b494f 100644
--- a/include/linux/if_tun.h
+++ b/include/linux/if_tun.h
@@ -25,6 +25,7 @@ struct ptr_ring *tun_get_tx_ring(struct file *file);
 bool tun_is_xdp_buff(void *ptr);
 void *tun_xdp_to_ptr(void *ptr);
 void *tun_ptr_to_xdp(void *ptr);
+void tun_ptr_free(void *ptr);
 #else
 #include <linux/err.h>
 #include <linux/errno.h>
@@ -50,5 +51,8 @@ static inline void *tun_ptr_to_xdp(void *ptr)
 {
         return NULL;
 }
+static inline void tun_ptr_free(void *ptr)
+{
+}
 #endif /* CONFIG_TUN */
 #endif /* __IF_TUN_H */
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
index 5e6a2d4dc366..c4a1cff9c768 100644
--- a/include/linux/if_vlan.h
+++ b/include/linux/if_vlan.h
@@ -300,30 +300,34 @@ static inline bool vlan_hw_offload_capable(netdev_features_t features,
 }
 
 /**
- * __vlan_insert_tag - regular VLAN tag inserting
+ * __vlan_insert_inner_tag - inner VLAN tag inserting
  * @skb: skbuff to tag
  * @vlan_proto: VLAN encapsulation protocol
  * @vlan_tci: VLAN TCI to insert
+ * @mac_len: MAC header length including outer vlan headers
  *
- * Inserts the VLAN tag into @skb as part of the payload
+ * Inserts the VLAN tag into @skb as part of the payload at offset mac_len
  * Returns error if skb_cow_head failes.
  *
  * Does not change skb->protocol so this function can be used during receive.
  */
-static inline int __vlan_insert_tag(struct sk_buff *skb,
-                                    __be16 vlan_proto, u16 vlan_tci)
+static inline int __vlan_insert_inner_tag(struct sk_buff *skb,
+                                          __be16 vlan_proto, u16 vlan_tci,
+                                          unsigned int mac_len)
 {
         struct vlan_ethhdr *veth;
 
         if (skb_cow_head(skb, VLAN_HLEN) < 0)
                 return -ENOMEM;
 
-        veth = skb_push(skb, VLAN_HLEN);
+        skb_push(skb, VLAN_HLEN);
 
-        /* Move the mac addresses to the beginning of the new header. */
-        memmove(skb->data, skb->data + VLAN_HLEN, 2 * ETH_ALEN);
+        /* Move the mac header sans proto to the beginning of the new header. */
+        memmove(skb->data, skb->data + VLAN_HLEN, mac_len - ETH_TLEN);
         skb->mac_header -= VLAN_HLEN;
 
+        veth = (struct vlan_ethhdr *)(skb->data + mac_len - ETH_HLEN);
+
         /* first, the ethernet type */
         veth->h_vlan_proto = vlan_proto;
 
@@ -334,12 +338,30 @@ static inline int __vlan_insert_tag(struct sk_buff *skb,
 }
 
 /**
- * vlan_insert_tag - regular VLAN tag inserting
+ * __vlan_insert_tag - regular VLAN tag inserting
  * @skb: skbuff to tag
  * @vlan_proto: VLAN encapsulation protocol
  * @vlan_tci: VLAN TCI to insert
  *
  * Inserts the VLAN tag into @skb as part of the payload
+ * Returns error if skb_cow_head failes.
+ *
+ * Does not change skb->protocol so this function can be used during receive.
+ */
+static inline int __vlan_insert_tag(struct sk_buff *skb,
+                                    __be16 vlan_proto, u16 vlan_tci)
+{
+        return __vlan_insert_inner_tag(skb, vlan_proto, vlan_tci, ETH_HLEN);
+}
+
+/**
+ * vlan_insert_inner_tag - inner VLAN tag inserting
+ * @skb: skbuff to tag
+ * @vlan_proto: VLAN encapsulation protocol
+ * @vlan_tci: VLAN TCI to insert
+ * @mac_len: MAC header length including outer vlan headers
+ *
+ * Inserts the VLAN tag into @skb as part of the payload at offset mac_len
  * Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
  *
  * Following the skb_unshare() example, in case of error, the calling function
@@ -347,12 +369,14 @@ static inline int __vlan_insert_tag(struct sk_buff *skb,
  *
  * Does not change skb->protocol so this function can be used during receive.
  */
-static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb,
-                                              __be16 vlan_proto, u16 vlan_tci)
+static inline struct sk_buff *vlan_insert_inner_tag(struct sk_buff *skb,
+                                                    __be16 vlan_proto,
+                                                    u16 vlan_tci,
+                                                    unsigned int mac_len)
 {
         int err;
 
-        err = __vlan_insert_tag(skb, vlan_proto, vlan_tci);
+        err = __vlan_insert_inner_tag(skb, vlan_proto, vlan_tci, mac_len);
         if (err) {
                 dev_kfree_skb_any(skb);
                 return NULL;
@@ -361,6 +385,26 @@ static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb,
 }
 
 /**
+ * vlan_insert_tag - regular VLAN tag inserting
+ * @skb: skbuff to tag
+ * @vlan_proto: VLAN encapsulation protocol
+ * @vlan_tci: VLAN TCI to insert
+ *
+ * Inserts the VLAN tag into @skb as part of the payload
+ * Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
+ *
+ * Following the skb_unshare() example, in case of error, the calling function
+ * doesn't have to worry about freeing the original skb.
+ *
+ * Does not change skb->protocol so this function can be used during receive.
+ */
+static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb,
+                                              __be16 vlan_proto, u16 vlan_tci)
+{
+        return vlan_insert_inner_tag(skb, vlan_proto, vlan_tci, ETH_HLEN);
+}
+
+/**
  * vlan_insert_tag_set_proto - regular VLAN tag inserting
  * @skb: skbuff to tag
  * @vlan_proto: VLAN encapsulation protocol
diff --git a/include/linux/jump_label.h b/include/linux/jump_label.h
index 2168cc6b8b30..b46b541c67c4 100644
--- a/include/linux/jump_label.h
+++ b/include/linux/jump_label.h
@@ -151,7 +151,7 @@ extern struct jump_entry __start___jump_table[];
 extern struct jump_entry __stop___jump_table[];
 
 extern void jump_label_init(void);
-extern void jump_label_invalidate_init(void);
+extern void jump_label_invalidate_initmem(void);
 extern void jump_label_lock(void);
 extern void jump_label_unlock(void);
 extern void arch_jump_label_transform(struct jump_entry *entry,
@@ -199,7 +199,7 @@ static __always_inline void jump_label_init(void)
         static_key_initialized = true;
 }
 
-static inline void jump_label_invalidate_init(void) {}
+static inline void jump_label_invalidate_initmem(void) {}
 
 static __always_inline bool static_key_false(struct static_key *key)
 {
diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index 8be5077efb5f..f92ea7783652 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -187,7 +187,6 @@ int memblock_search_pfn_nid(unsigned long pfn, unsigned long *start_pfn,
                             unsigned long  *end_pfn);
 void __next_mem_pfn_range(int *idx, int nid, unsigned long *out_start_pfn,
                           unsigned long *out_end_pfn, int *out_nid);
-unsigned long memblock_next_valid_pfn(unsigned long pfn, unsigned long max_pfn);
 
 /**
  * for_each_mem_pfn_range - early memory pfn range iterator
diff --git a/include/linux/mlx5/driver.h b/include/linux/mlx5/driver.h
index 6ed79a8a8318..9d3a03364e6e 100644
--- a/include/linux/mlx5/driver.h
+++ b/include/linux/mlx5/driver.h
@@ -453,8 +453,8 @@ struct mlx5_core_srq {
         struct mlx5_core_rsc_common     common; /* must be first */
         u32             srqn;
         int             max;
-        int             max_gs;
-        int             max_avail_gather;
+        size_t          max_gs;
+        size_t          max_avail_gather;
         int             wqe_shift;
         void (*event)   (struct mlx5_core_srq *, enum mlx5_event);
 
diff --git a/include/linux/net.h b/include/linux/net.h
index 91216b16feb7..2a0391eea05c 100644
--- a/include/linux/net.h
+++ b/include/linux/net.h
@@ -222,6 +222,7 @@ enum {
 int sock_wake_async(struct socket_wq *sk_wq, int how, int band);
 int sock_register(const struct net_proto_family *fam);
 void sock_unregister(int family);
+bool sock_is_registered(int family);
 int __sock_create(struct net *net, int family, int type, int proto,
                   struct socket **res, int kern);
 int sock_create(int family, int type, int proto, struct socket **res);
diff --git a/include/linux/netfilter/x_tables.h b/include/linux/netfilter/x_tables.h
index 1313b35c3ab7..14529511c4b8 100644
--- a/include/linux/netfilter/x_tables.h
+++ b/include/linux/netfilter/x_tables.h
@@ -285,6 +285,8 @@ unsigned int *xt_alloc_entry_offsets(unsigned int size);
 bool xt_find_jump_offset(const unsigned int *offsets,
                          unsigned int target, unsigned int size);
 
+int xt_check_proc_name(const char *name, unsigned int size);
+
 int xt_check_match(struct xt_mtchk_param *, unsigned int size, u_int8_t proto,
                    bool inv_proto);
 int xt_check_target(struct xt_tgchk_param *, unsigned int size, u_int8_t proto,
diff --git a/include/linux/percpu-refcount.h b/include/linux/percpu-refcount.h
index 864d167a1073..009cdf3d65b6 100644
--- a/include/linux/percpu-refcount.h
+++ b/include/linux/percpu-refcount.h
@@ -30,10 +30,14 @@
  * calls io_destroy() or the process exits.
  *
  * In the aio code, kill_ioctx() is called when we wish to destroy a kioctx; it
- * calls percpu_ref_kill(), then hlist_del_rcu() and synchronize_rcu() to remove
- * the kioctx from the proccess's list of kioctxs - after that, there can't be
- * any new users of the kioctx (from lookup_ioctx()) and it's then safe to drop
- * the initial ref with percpu_ref_put().
+ * removes the kioctx from the proccess's table of kioctxs and kills percpu_ref.
+ * After that, there can't be any new users of the kioctx (from lookup_ioctx())
+ * and it's then safe to drop the initial ref with percpu_ref_put().
+ *
+ * Note that the free path, free_ioctx(), needs to go through explicit call_rcu()
+ * to synchronize with RCU protected lookup_ioctx().  percpu_ref operations don't
+ * imply RCU grace periods of any kind and if a user wants to combine percpu_ref
+ * with RCU protection, it must be done explicitly.
  *
  * Code that does a two stage shutdown like this often needs some kind of
  * explicit synchronization to ensure the initial refcount can only be dropped
@@ -113,8 +117,10 @@ void percpu_ref_reinit(struct percpu_ref *ref);
  * Must be used to drop the initial ref on a percpu refcount; must be called
  * precisely once before shutdown.
  *
- * Puts @ref in non percpu mode, then does a call_rcu() before gathering up the
- * percpu counters and dropping the initial ref.
+ * Switches @ref into atomic mode before gathering up the percpu counters
+ * and dropping the initial ref.
+ *
+ * There are no implied RCU grace periods between kill and release.
  */
 static inline void percpu_ref_kill(struct percpu_ref *ref)
 {
diff --git a/include/linux/phy.h b/include/linux/phy.h
index d7069539f351..7c4c2379e010 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -984,6 +984,10 @@ static inline int genphy_no_soft_reset(struct phy_device *phydev)
 {
         return 0;
 }
+int genphy_read_mmd_unsupported(struct phy_device *phdev, int devad,
+                                u16 regnum);
+int genphy_write_mmd_unsupported(struct phy_device *phdev, int devnum,
+                                 u16 regnum, u16 val);
 
 /* Clause 45 PHY */
 int genphy_c45_restart_aneg(struct phy_device *phydev);
@@ -1012,7 +1016,6 @@ int phy_driver_register(struct phy_driver *new_driver, struct module *owner);
 int phy_drivers_register(struct phy_driver *new_driver, int n,
                          struct module *owner);
 void phy_state_machine(struct work_struct *work);
-void phy_change(struct phy_device *phydev);
 void phy_change_work(struct work_struct *work);
 void phy_mac_interrupt(struct phy_device *phydev);
 void phy_start_machine(struct phy_device *phydev);
diff --git a/include/linux/rhashtable.h b/include/linux/rhashtable.h
index c9df2527e0cd..668a21f04b09 100644
--- a/include/linux/rhashtable.h
+++ b/include/linux/rhashtable.h
@@ -766,8 +766,10 @@ slow_path:
                 if (!key ||
                     (params.obj_cmpfn ?
                      params.obj_cmpfn(&arg, rht_obj(ht, head)) :
-                     rhashtable_compare(&arg, rht_obj(ht, head))))
+                     rhashtable_compare(&arg, rht_obj(ht, head)))) {
+                        pprev = &head->next;
                         continue;
+                }
 
                 data = rht_obj(ht, head);
 
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index ddf77cf4ff2d..99df17109e1b 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -4037,6 +4037,12 @@ static inline bool skb_is_gso_v6(const struct sk_buff *skb)
         return skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6;
 }
 
+/* Note: Should be called only if skb_is_gso(skb) is true */
+static inline bool skb_is_gso_sctp(const struct sk_buff *skb)
+{
+        return skb_shinfo(skb)->gso_type & SKB_GSO_SCTP;
+}
+
 static inline void skb_gso_reset(struct sk_buff *skb)
 {
         skb_shinfo(skb)->gso_size = 0;
@@ -4044,6 +4050,22 @@ static inline void skb_gso_reset(struct sk_buff *skb)
         skb_shinfo(skb)->gso_type = 0;
 }
 
+static inline void skb_increase_gso_size(struct skb_shared_info *shinfo,
+                                         u16 increment)
+{
+        if (WARN_ON_ONCE(shinfo->gso_size == GSO_BY_FRAGS))
+                return;
+        shinfo->gso_size += increment;
+}
+
+static inline void skb_decrease_gso_size(struct skb_shared_info *shinfo,
+                                         u16 decrement)
+{
+        if (WARN_ON_ONCE(shinfo->gso_size == GSO_BY_FRAGS))
+                return;
+        shinfo->gso_size -= decrement;
+}
+
 void __skb_warn_lro_forwarding(const struct sk_buff *skb);
 
 static inline bool skb_warn_if_lro(const struct sk_buff *skb)
diff --git a/include/linux/u64_stats_sync.h b/include/linux/u64_stats_sync.h
index 5bdbd9f49395..07ee0f84a46c 100644
--- a/include/linux/u64_stats_sync.h
+++ b/include/linux/u64_stats_sync.h
@@ -90,6 +90,28 @@ static inline void u64_stats_update_end(struct u64_stats_sync *syncp)
 #endif
 }
 
+static inline unsigned long
+u64_stats_update_begin_irqsave(struct u64_stats_sync *syncp)
+{
+        unsigned long flags = 0;
+
+#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
+        local_irq_save(flags);
+        write_seqcount_begin(&syncp->seq);
+#endif
+        return flags;
+}
+
+static inline void
+u64_stats_update_end_irqrestore(struct u64_stats_sync *syncp,
+                                unsigned long flags)
+{
+#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
+        write_seqcount_end(&syncp->seq);
+        local_irq_restore(flags);
+#endif
+}
+
 static inline void u64_stats_update_begin_raw(struct u64_stats_sync *syncp)
 {
 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index bc0cda180c8b..0c3301421c57 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -456,7 +456,6 @@ extern int schedule_on_each_cpu(work_func_t func);
 int execute_in_process_context(work_func_t fn, struct execute_work *);
 
 extern bool flush_work(struct work_struct *work);
-extern bool cancel_work(struct work_struct *work);
 extern bool cancel_work_sync(struct work_struct *work);
 
 extern bool flush_delayed_work(struct delayed_work *dwork);
diff --git a/include/net/ip.h b/include/net/ip.h
index 746abff9ce51..f49b3a576bec 100644
--- a/include/net/ip.h
+++ b/include/net/ip.h
@@ -328,6 +328,13 @@ int ip_decrease_ttl(struct iphdr *iph)
         return --iph->ttl;
 }
 
+static inline int ip_mtu_locked(const struct dst_entry *dst)
+{
+        const struct rtable *rt = (const struct rtable *)dst;
+
+        return rt->rt_mtu_locked || dst_metric_locked(dst, RTAX_MTU);
+}
+
 static inline
 int ip_dont_fragment(const struct sock *sk, const struct dst_entry *dst)
 {
@@ -335,7 +342,7 @@ int ip_dont_fragment(const struct sock *sk, const struct dst_entry *dst)
 
         return  pmtudisc == IP_PMTUDISC_DO ||
                 (pmtudisc == IP_PMTUDISC_WANT &&
-                 !(dst_metric_locked(dst, RTAX_MTU)));
+                 !ip_mtu_locked(dst));
 }
 
 static inline bool ip_sk_accept_pmtu(const struct sock *sk)
@@ -361,7 +368,7 @@ static inline unsigned int ip_dst_mtu_maybe_forward(const struct dst_entry *dst,
         struct net *net = dev_net(dst->dev);
 
         if (net->ipv4.sysctl_ip_fwd_use_pmtu ||
-            dst_metric_locked(dst, RTAX_MTU) ||
+            ip_mtu_locked(dst) ||
             !forwarding)
                 return dst_mtu(dst);
 
diff --git a/include/net/ip6_route.h b/include/net/ip6_route.h
index 27d23a65f3cd..ac0866bb9e93 100644
--- a/include/net/ip6_route.h
+++ b/include/net/ip6_route.h
@@ -179,6 +179,9 @@ void rt6_disable_ip(struct net_device *dev, unsigned long event);
 void rt6_sync_down_dev(struct net_device *dev, unsigned long event);
 void rt6_multipath_rebalance(struct rt6_info *rt);
 
+void rt6_uncached_list_add(struct rt6_info *rt);
+void rt6_uncached_list_del(struct rt6_info *rt);
+
 static inline const struct rt6_info *skb_rt6_info(const struct sk_buff *skb)
 {
         const struct dst_entry *dst = skb_dst(skb);
diff --git a/include/net/ip_fib.h b/include/net/ip_fib.h
index f80524396c06..77d0a78cf7d2 100644
--- a/include/net/ip_fib.h
+++ b/include/net/ip_fib.h
@@ -59,6 +59,7 @@ struct fib_nh_exception {
         int                             fnhe_genid;
         __be32                          fnhe_daddr;
         u32                             fnhe_pmtu;
+        bool                            fnhe_mtu_locked;
         __be32                          fnhe_gw;
         unsigned long                   fnhe_expires;
         struct rtable __rcu             *fnhe_rth_input;
diff --git a/include/net/mac80211.h b/include/net/mac80211.h
index c96511fa9198..2b581bd93812 100644
--- a/include/net/mac80211.h
+++ b/include/net/mac80211.h
@@ -2063,6 +2063,9 @@ struct ieee80211_txq {
  * @IEEE80211_HW_SUPPORTS_TDLS_BUFFER_STA: Hardware supports buffer STA on
  *      TDLS links.
  *
+ * @IEEE80211_HW_DOESNT_SUPPORT_QOS_NDP: The driver (or firmware) doesn't
+ *      support QoS NDP for AP probing - that's most likely a driver bug.
+ *
  * @NUM_IEEE80211_HW_FLAGS: number of hardware flags, used for sizing arrays
  */
 enum ieee80211_hw_flags {
@@ -2106,6 +2109,7 @@ enum ieee80211_hw_flags {
         IEEE80211_HW_REPORTS_LOW_ACK,
         IEEE80211_HW_SUPPORTS_TX_FRAG,
         IEEE80211_HW_SUPPORTS_TDLS_BUFFER_STA,
+        IEEE80211_HW_DOESNT_SUPPORT_QOS_NDP,
 
         /* keep last, obviously */
         NUM_IEEE80211_HW_FLAGS
diff --git a/include/net/route.h b/include/net/route.h
index 1eb9ce470e25..20a92ca9e115 100644
--- a/include/net/route.h
+++ b/include/net/route.h
@@ -63,7 +63,8 @@ struct rtable {
         __be32                  rt_gateway;
 
         /* Miscellaneous cached information */
-        u32                     rt_pmtu;
+        u32                     rt_mtu_locked:1,
+                                rt_pmtu:31;
 
         u32                     rt_table_id;
 
@@ -227,6 +228,9 @@ struct in_ifaddr;
 void fib_add_ifaddr(struct in_ifaddr *);
 void fib_del_ifaddr(struct in_ifaddr *, struct in_ifaddr *);
 
+void rt_add_uncached_list(struct rtable *rt);
+void rt_del_uncached_list(struct rtable *rt);
+
 static inline void ip_rt_put(struct rtable *rt)
 {
         /* dst_release() accepts a NULL parameter.
diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
index e2ab13687fb9..2092d33194dd 100644
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -824,6 +824,16 @@ static inline void __qdisc_drop(struct sk_buff *skb, struct sk_buff **to_free)
         *to_free = skb;
 }
 
+static inline void __qdisc_drop_all(struct sk_buff *skb,
+                                    struct sk_buff **to_free)
+{
+        if (skb->prev)
+                skb->prev->next = *to_free;
+        else
+                skb->next = *to_free;
+        *to_free = skb;
+}
+
 static inline unsigned int __qdisc_queue_drop_head(struct Qdisc *sch,
                                                    struct qdisc_skb_head *qh,
                                                    struct sk_buff **to_free)
@@ -956,6 +966,15 @@ static inline int qdisc_drop(struct sk_buff *skb, struct Qdisc *sch,
         return NET_XMIT_DROP;
 }
 
+static inline int qdisc_drop_all(struct sk_buff *skb, struct Qdisc *sch,
+                                 struct sk_buff **to_free)
+{
+        __qdisc_drop_all(skb, to_free);
+        qdisc_qstats_drop(sch);
+
+        return NET_XMIT_DROP;
+}
+
 /* Length to Time (L2T) lookup in a qdisc_rate_table, to determine how
    long it will take to send a packet given its size.
  */
diff --git a/include/net/sock.h b/include/net/sock.h
index 169c92afcafa..ae23f3b389ca 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -1137,6 +1137,7 @@ struct proto {
 
 int proto_register(struct proto *prot, int alloc_slab);
 void proto_unregister(struct proto *prot);
+int sock_load_diag_module(int family, int protocol);
 
 #ifdef SOCK_REFCNT_DEBUG
 static inline void sk_refcnt_debug_inc(struct sock *sk)
diff --git a/include/rdma/ib_verbs.h b/include/rdma/ib_verbs.h
index 73b2387e3f74..ff3ed435701f 100644
--- a/include/rdma/ib_verbs.h
+++ b/include/rdma/ib_verbs.h
@@ -1537,10 +1537,6 @@ struct ib_xrcd {
 
         struct mutex            tgt_qp_mutex;
         struct list_head        tgt_qp_list;
-        /*
-         * Implementation details of the RDMA core, don't use in drivers:
-         */
-        struct rdma_restrack_entry res;
 };
 
 struct ib_ah {
diff --git a/include/trace/events/mmc.h b/include/trace/events/mmc.h
index 200f731be557..7b706ff21335 100644
--- a/include/trace/events/mmc.h
+++ b/include/trace/events/mmc.h
@@ -86,8 +86,8 @@ TRACE_EVENT(mmc_request_start,
                   __entry->stop_flags, __entry->stop_retries,
                   __entry->sbc_opcode, __entry->sbc_arg,
                   __entry->sbc_flags, __entry->sbc_retries,
-                  __entry->blocks, __entry->blk_addr,
-                  __entry->blksz, __entry->data_flags, __entry->tag,
+                  __entry->blocks, __entry->blksz,
+                  __entry->blk_addr, __entry->data_flags, __entry->tag,
                   __entry->can_retune, __entry->doing_retune,
                   __entry->retune_now, __entry->need_retune,
                   __entry->hold_retune, __entry->retune_period)
diff --git a/include/uapi/linux/if_ether.h b/include/uapi/linux/if_ether.h
index 8bbbcb5cd94b..820de5d222d2 100644
--- a/include/uapi/linux/if_ether.h
+++ b/include/uapi/linux/if_ether.h
@@ -30,6 +30,7 @@
  */
 
 #define ETH_ALEN        6               /* Octets in one ethernet addr   */
+#define ETH_TLEN        2               /* Octets in ethernet type field */
 #define ETH_HLEN        14              /* Total octets in header.       */
 #define ETH_ZLEN        60              /* Min. octets in frame sans FCS */
 #define ETH_DATA_LEN    1500            /* Max. octets in payload        */
diff --git a/include/uapi/linux/lirc.h b/include/uapi/linux/lirc.h
index 4fe580d36e41..f5bf06ecd87d 100644
--- a/include/uapi/linux/lirc.h
+++ b/include/uapi/linux/lirc.h
@@ -54,7 +54,6 @@
 #define LIRC_CAN_SEND_RAW              LIRC_MODE2SEND(LIRC_MODE_RAW)
 #define LIRC_CAN_SEND_PULSE            LIRC_MODE2SEND(LIRC_MODE_PULSE)
 #define LIRC_CAN_SEND_MODE2            LIRC_MODE2SEND(LIRC_MODE_MODE2)
-#define LIRC_CAN_SEND_SCANCODE         LIRC_MODE2SEND(LIRC_MODE_SCANCODE)
 #define LIRC_CAN_SEND_LIRCCODE         LIRC_MODE2SEND(LIRC_MODE_LIRCCODE)
 
 #define LIRC_CAN_SEND_MASK             0x0000003f
diff --git a/include/uapi/linux/usb/audio.h b/include/uapi/linux/usb/audio.h
index 17a022c5b414..da3315ed1bcd 100644
--- a/include/uapi/linux/usb/audio.h
+++ b/include/uapi/linux/usb/audio.h
@@ -370,7 +370,7 @@ static inline __u8 uac_processing_unit_bControlSize(struct uac_processing_unit_d
 {
         return (protocol == UAC_VERSION_1) ?
                 desc->baSourceID[desc->bNrInPins + 4] :
-                desc->baSourceID[desc->bNrInPins + 6];
+                2; /* in UAC2, this value is constant */
 }
 
 static inline __u8 *uac_processing_unit_bmControls(struct uac_processing_unit_descriptor *desc,
@@ -378,7 +378,7 @@ static inline __u8 *uac_processing_unit_bmControls(struct uac_processing_unit_de
 {
         return (protocol == UAC_VERSION_1) ?
                 &desc->baSourceID[desc->bNrInPins + 5] :
-                &desc->baSourceID[desc->bNrInPins + 7];
+                &desc->baSourceID[desc->bNrInPins + 6];
 }
 
 static inline __u8 uac_processing_unit_iProcessing(struct uac_processing_unit_descriptor *desc,
diff --git a/init/main.c b/init/main.c
index 969eaf140ef0..21efbf6ace93 100644
--- a/init/main.c
+++ b/init/main.c
@@ -1001,7 +1001,7 @@ static int __ref kernel_init(void *unused)
         /* need to finish all async __init code before freeing the memory */
         async_synchronize_full();
         ftrace_free_init_mem();
-        jump_label_invalidate_init();
+        jump_label_invalidate_initmem();
         free_initmem();
         mark_readonly();
         system_state = SYSTEM_RUNNING;
diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index d7f309f74dec..a808f29d4c5a 100644
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -325,9 +325,8 @@ err:
 static int mqueue_fill_super(struct super_block *sb, void *data, int silent)
 {
         struct inode *inode;
-        struct ipc_namespace *ns = data;
+        struct ipc_namespace *ns = sb->s_fs_info;
 
-        sb->s_fs_info = ns;
         sb->s_iflags |= SB_I_NOEXEC | SB_I_NODEV;
         sb->s_blocksize = PAGE_SIZE;
         sb->s_blocksize_bits = PAGE_SHIFT;
@@ -344,44 +343,18 @@ static int mqueue_fill_super(struct super_block *sb, void *data, int silent)
         return 0;
 }
 
-static struct file_system_type mqueue_fs_type;
-/*
- * Return value is pinned only by reference in ->mq_mnt; it will
- * live until ipcns dies.  Caller does not need to drop it.
- */
-static struct vfsmount *mq_internal_mount(void)
-{
-        struct ipc_namespace *ns = current->nsproxy->ipc_ns;
-        struct vfsmount *m = ns->mq_mnt;
-        if (m)
-                return m;
-        m = kern_mount_data(&mqueue_fs_type, ns);
-        spin_lock(&mq_lock);
-        if (unlikely(ns->mq_mnt)) {
-                spin_unlock(&mq_lock);
-                if (!IS_ERR(m))
-                        kern_unmount(m);
-                return ns->mq_mnt;
-        }
-        if (!IS_ERR(m))
-                ns->mq_mnt = m;
-        spin_unlock(&mq_lock);
-        return m;
-}
-
 static struct dentry *mqueue_mount(struct file_system_type *fs_type,
                          int flags, const char *dev_name,
                          void *data)
 {
-        struct vfsmount *m;
-        if (flags & SB_KERNMOUNT)
-                return mount_nodev(fs_type, flags, data, mqueue_fill_super);
-        m = mq_internal_mount();
-        if (IS_ERR(m))
-                return ERR_CAST(m);
-        atomic_inc(&m->mnt_sb->s_active);
-        down_write(&m->mnt_sb->s_umount);
-        return dget(m->mnt_root);
+        struct ipc_namespace *ns;
+        if (flags & SB_KERNMOUNT) {
+                ns = data;
+                data = NULL;
+        } else {
+                ns = current->nsproxy->ipc_ns;
+        }
+        return mount_ns(fs_type, flags, data, ns, ns->user_ns, mqueue_fill_super);
 }
 
 static void init_once(void *foo)
@@ -771,16 +744,13 @@ static int prepare_open(struct dentry *dentry, int oflag, int ro,
 static int do_mq_open(const char __user *u_name, int oflag, umode_t mode,
                       struct mq_attr *attr)
 {
-        struct vfsmount *mnt = mq_internal_mount();
-        struct dentry *root;
+        struct vfsmount *mnt = current->nsproxy->ipc_ns->mq_mnt;
+        struct dentry *root = mnt->mnt_root;
         struct filename *name;
         struct path path;
         int fd, error;
         int ro;
 
-        if (IS_ERR(mnt))
-                return PTR_ERR(mnt);
-
         audit_mq_open(oflag, mode, attr);
 
         if (IS_ERR(name = getname(u_name)))
@@ -791,7 +761,6 @@ static int do_mq_open(const char __user *u_name, int oflag, umode_t mode,
                 goto out_putname;
 
         ro = mnt_want_write(mnt);       /* we'll drop it in any case */
-        root = mnt->mnt_root;
         inode_lock(d_inode(root));
         path.dentry = lookup_one_len(name->name, root, strlen(name->name));
         if (IS_ERR(path.dentry)) {
@@ -840,9 +809,6 @@ SYSCALL_DEFINE1(mq_unlink, const char __user *, u_name)
         struct ipc_namespace *ipc_ns = current->nsproxy->ipc_ns;
         struct vfsmount *mnt = ipc_ns->mq_mnt;
 
-        if (!mnt)
-                return -ENOENT;
-
         name = getname(u_name);
         if (IS_ERR(name))
                 return PTR_ERR(name);
@@ -1569,26 +1535,28 @@ int mq_init_ns(struct ipc_namespace *ns)
         ns->mq_msgsize_max   = DFLT_MSGSIZEMAX;
         ns->mq_msg_default   = DFLT_MSG;
         ns->mq_msgsize_default  = DFLT_MSGSIZE;
-        ns->mq_mnt = NULL;
 
+        ns->mq_mnt = kern_mount_data(&mqueue_fs_type, ns);
+        if (IS_ERR(ns->mq_mnt)) {
+                int err = PTR_ERR(ns->mq_mnt);
+                ns->mq_mnt = NULL;
+                return err;
+        }
         return 0;
 }
 
 void mq_clear_sbinfo(struct ipc_namespace *ns)
 {
-        if (ns->mq_mnt)
-                ns->mq_mnt->mnt_sb->s_fs_info = NULL;
+        ns->mq_mnt->mnt_sb->s_fs_info = NULL;
 }
 
 void mq_put_mnt(struct ipc_namespace *ns)
 {
-        if (ns->mq_mnt)
-                kern_unmount(ns->mq_mnt);
+        kern_unmount(ns->mq_mnt);
 }
 
 static int __init init_mqueue_fs(void)
 {
-        struct vfsmount *m;
         int error;
 
         mqueue_inode_cachep = kmem_cache_create("mqueue_inode_cache",
@@ -1610,10 +1578,6 @@ static int __init init_mqueue_fs(void)
         if (error)
                 goto out_filesystem;
 
-        m = kern_mount_data(&mqueue_fs_type, &init_ipc_ns);
-        if (IS_ERR(m))
-                goto out_filesystem;
-        init_ipc_ns.mq_mnt = m;
         return 0;
 
 out_filesystem:
diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c
index e24aa3241387..43f95d190eea 100644
--- a/kernel/bpf/syscall.c
+++ b/kernel/bpf/syscall.c
@@ -1845,7 +1845,7 @@ SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, siz
         union bpf_attr attr = {};
         int err;
 
-        if (!capable(CAP_SYS_ADMIN) && sysctl_unprivileged_bpf_disabled)
+        if (sysctl_unprivileged_bpf_disabled && !capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
         err = check_uarg_tail_zero(uattr, sizeof(attr), size);
diff --git a/kernel/cgroup/cgroup.c b/kernel/cgroup/cgroup.c
index 8cda3bc3ae22..4bfb2908ec15 100644
--- a/kernel/cgroup/cgroup.c
+++ b/kernel/cgroup/cgroup.c
@@ -3183,6 +3183,16 @@ static int cgroup_enable_threaded(struct cgroup *cgrp)
         if (cgroup_is_threaded(cgrp))
                 return 0;
 
+        /*
+         * If @cgroup is populated or has domain controllers enabled, it
+         * can't be switched.  While the below cgroup_can_be_thread_root()
+         * test can catch the same conditions, that's only when @parent is
+         * not mixable, so let's check it explicitly.
+         */
+        if (cgroup_is_populated(cgrp) ||
+            cgrp->subtree_control & ~cgrp_dfl_threaded_ss_mask)
+                return -EOPNOTSUPP;
+
         /* we're joining the parent's domain, ensure its validity */
         if (!cgroup_is_valid_domain(dom_cgrp) ||
             !cgroup_can_be_thread_root(dom_cgrp))
diff --git a/kernel/events/core.c b/kernel/events/core.c
index 4b838470fac4..709a55b9ad97 100644
--- a/kernel/events/core.c
+++ b/kernel/events/core.c
@@ -724,9 +724,15 @@ static inline void __update_cgrp_time(struct perf_cgroup *cgrp)
 
 static inline void update_cgrp_time_from_cpuctx(struct perf_cpu_context *cpuctx)
 {
-        struct perf_cgroup *cgrp_out = cpuctx->cgrp;
-        if (cgrp_out)
-                __update_cgrp_time(cgrp_out);
+        struct perf_cgroup *cgrp = cpuctx->cgrp;
+        struct cgroup_subsys_state *css;
+
+        if (cgrp) {
+                for (css = &cgrp->css; css; css = css->parent) {
+                        cgrp = container_of(css, struct perf_cgroup, css);
+                        __update_cgrp_time(cgrp);
+                }
+        }
 }
 
 static inline void update_cgrp_time_from_event(struct perf_event *event)
@@ -754,6 +760,7 @@ perf_cgroup_set_timestamp(struct task_struct *task,
 {
         struct perf_cgroup *cgrp;
         struct perf_cgroup_info *info;
+        struct cgroup_subsys_state *css;
 
         /*
          * ctx->lock held by caller
@@ -764,8 +771,12 @@ perf_cgroup_set_timestamp(struct task_struct *task,
                 return;
 
         cgrp = perf_cgroup_from_task(task, ctx);
-        info = this_cpu_ptr(cgrp->info);
-        info->timestamp = ctx->timestamp;
+
+        for (css = &cgrp->css; css; css = css->parent) {
+                cgrp = container_of(css, struct perf_cgroup, css);
+                info = this_cpu_ptr(cgrp->info);
+                info->timestamp = ctx->timestamp;
+        }
 }
 
 static DEFINE_PER_CPU(struct list_head, cgrp_cpuctx_list);
diff --git a/kernel/fail_function.c b/kernel/fail_function.c
index 21b0122cb39c..1d5632d8bbcc 100644
--- a/kernel/fail_function.c
+++ b/kernel/fail_function.c
@@ -14,6 +14,15 @@
 
 static int fei_kprobe_handler(struct kprobe *kp, struct pt_regs *regs);
 
+static void fei_post_handler(struct kprobe *kp, struct pt_regs *regs,
+                             unsigned long flags)
+{
+        /*
+         * A dummy post handler is required to prohibit optimizing, because
+         * jump optimization does not support execution path overriding.
+         */
+}
+
 struct fei_attr {
         struct list_head list;
         struct kprobe kp;
@@ -56,6 +65,7 @@ static struct fei_attr *fei_attr_new(const char *sym, unsigned long addr)
                         return NULL;
                 }
                 attr->kp.pre_handler = fei_kprobe_handler;
+                attr->kp.post_handler = fei_post_handler;
                 attr->retval = adjust_error_retval(addr, 0);
                 INIT_LIST_HEAD(&attr->list);
         }
diff --git a/kernel/jump_label.c b/kernel/jump_label.c
index e7214093dcd1..01ebdf1f9f40 100644
--- a/kernel/jump_label.c
+++ b/kernel/jump_label.c
@@ -16,6 +16,7 @@
 #include <linux/jump_label_ratelimit.h>
 #include <linux/bug.h>
 #include <linux/cpu.h>
+#include <asm/sections.h>
 
 #ifdef HAVE_JUMP_LABEL
 
@@ -421,15 +422,15 @@ void __init jump_label_init(void)
         cpus_read_unlock();
 }
 
-/* Disable any jump label entries in __init code */
-void __init jump_label_invalidate_init(void)
+/* Disable any jump label entries in __init/__exit code */
+void __init jump_label_invalidate_initmem(void)
 {
         struct jump_entry *iter_start = __start___jump_table;
         struct jump_entry *iter_stop = __stop___jump_table;
         struct jump_entry *iter;
 
         for (iter = iter_start; iter < iter_stop; iter++) {
-                if (init_kernel_text(iter->code))
+                if (init_section_contains((void *)(unsigned long)iter->code, 1))
                         iter->code = 0;
         }
 }
diff --git a/kernel/locking/mutex.c b/kernel/locking/mutex.c
index 858a07590e39..2048359f33d2 100644
--- a/kernel/locking/mutex.c
+++ b/kernel/locking/mutex.c
@@ -1082,15 +1082,16 @@ static noinline int __sched
 __mutex_lock_interruptible_slowpath(struct mutex *lock);
 
 /**
- * mutex_lock_interruptible - acquire the mutex, interruptible
- * @lock: the mutex to be acquired
+ * mutex_lock_interruptible() - Acquire the mutex, interruptible by signals.
+ * @lock: The mutex to be acquired.
  *
- * Lock the mutex like mutex_lock(), and return 0 if the mutex has
- * been acquired or sleep until the mutex becomes available. If a
- * signal arrives while waiting for the lock then this function
- * returns -EINTR.
+ * Lock the mutex like mutex_lock().  If a signal is delivered while the
+ * process is sleeping, this function will return without acquiring the
+ * mutex.
  *
- * This function is similar to (but not equivalent to) down_interruptible().
+ * Context: Process context.
+ * Return: 0 if the lock was successfully acquired or %-EINTR if a
+ * signal arrived.
  */
 int __sched mutex_lock_interruptible(struct mutex *lock)
 {
@@ -1104,6 +1105,18 @@ int __sched mutex_lock_interruptible(struct mutex *lock)
 
 EXPORT_SYMBOL(mutex_lock_interruptible);
 
+/**
+ * mutex_lock_killable() - Acquire the mutex, interruptible by fatal signals.
+ * @lock: The mutex to be acquired.
+ *
+ * Lock the mutex like mutex_lock().  If a signal which will be fatal to
+ * the current process is delivered while the process is sleeping, this
+ * function will return without acquiring the mutex.
+ *
+ * Context: Process context.
+ * Return: 0 if the lock was successfully acquired or %-EINTR if a
+ * fatal signal arrived.
+ */
 int __sched mutex_lock_killable(struct mutex *lock)
 {
         might_sleep();
@@ -1115,6 +1128,16 @@ int __sched mutex_lock_killable(struct mutex *lock)
 }
 EXPORT_SYMBOL(mutex_lock_killable);
 
+/**
+ * mutex_lock_io() - Acquire the mutex and mark the process as waiting for I/O
+ * @lock: The mutex to be acquired.
+ *
+ * Lock the mutex like mutex_lock().  While the task is waiting for this
+ * mutex, it will be accounted as being in the IO wait state by the
+ * scheduler.
+ *
+ * Context: Process context.
+ */
 void __sched mutex_lock_io(struct mutex *lock)
 {
         int token;
diff --git a/kernel/memremap.c b/kernel/memremap.c
index 4dd4274cabe2..895e6b76b25e 100644
--- a/kernel/memremap.c
+++ b/kernel/memremap.c
@@ -427,7 +427,6 @@ void *devm_memremap_pages(struct device *dev, struct dev_pagemap *pgmap)
  err_pfn_remap:
  err_radix:
         pgmap_radix_release(res, pgoff);
-        devres_free(pgmap);
         return ERR_PTR(error);
 }
 EXPORT_SYMBOL(devm_memremap_pages);
diff --git a/kernel/module.c b/kernel/module.c
index ad2d420024f6..e42764acedb4 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -4228,7 +4228,7 @@ static int modules_open(struct inode *inode, struct file *file)
                 m->private = kallsyms_show_value() ? NULL : (void *)8ul;
         }
 
-        return 0;
+        return err;
 }
 
 static const struct file_operations proc_modules_operations = {
diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index e7c535eee0a6..c94895bc5a2c 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -6683,13 +6683,18 @@ static int tg_cfs_schedulable_down(struct task_group *tg, void *data)
                 parent_quota = parent_b->hierarchical_quota;
 
                 /*
-                 * Ensure max(child_quota) <= parent_quota, inherit when no
+                 * Ensure max(child_quota) <= parent_quota.  On cgroup2,
+                 * always take the min.  On cgroup1, only inherit when no
                  * limit is set:
                  */
-                if (quota == RUNTIME_INF)
-                        quota = parent_quota;
-                else if (parent_quota != RUNTIME_INF && quota > parent_quota)
-                        return -EINVAL;
+                if (cgroup_subsys_on_dfl(cpu_cgrp_subsys)) {
+                        quota = min(quota, parent_quota);
+                } else {
+                        if (quota == RUNTIME_INF)
+                                quota = parent_quota;
+                        else if (parent_quota != RUNTIME_INF && quota > parent_quota)
+                                return -EINVAL;
+                }
         }
         cfs_b->hierarchical_quota = quota;
 
diff --git a/kernel/trace/bpf_trace.c b/kernel/trace/bpf_trace.c
index c0a9e310d715..01e6b3a38871 100644
--- a/kernel/trace/bpf_trace.c
+++ b/kernel/trace/bpf_trace.c
@@ -661,7 +661,41 @@ static const struct bpf_func_proto bpf_get_stackid_proto_tp = {
         .arg3_type      = ARG_ANYTHING,
 };
 
-BPF_CALL_3(bpf_perf_prog_read_value_tp, struct bpf_perf_event_data_kern *, ctx,
+static const struct bpf_func_proto *tp_prog_func_proto(enum bpf_func_id func_id)
+{
+        switch (func_id) {
+        case BPF_FUNC_perf_event_output:
+                return &bpf_perf_event_output_proto_tp;
+        case BPF_FUNC_get_stackid:
+                return &bpf_get_stackid_proto_tp;
+        default:
+                return tracing_func_proto(func_id);
+        }
+}
+
+static bool tp_prog_is_valid_access(int off, int size, enum bpf_access_type type,
+                                    struct bpf_insn_access_aux *info)
+{
+        if (off < sizeof(void *) || off >= PERF_MAX_TRACE_SIZE)
+                return false;
+        if (type != BPF_READ)
+                return false;
+        if (off % size != 0)
+                return false;
+
+        BUILD_BUG_ON(PERF_MAX_TRACE_SIZE % sizeof(__u64));
+        return true;
+}
+
+const struct bpf_verifier_ops tracepoint_verifier_ops = {
+        .get_func_proto  = tp_prog_func_proto,
+        .is_valid_access = tp_prog_is_valid_access,
+};
+
+const struct bpf_prog_ops tracepoint_prog_ops = {
+};
+
+BPF_CALL_3(bpf_perf_prog_read_value, struct bpf_perf_event_data_kern *, ctx,
            struct bpf_perf_event_value *, buf, u32, size)
 {
         int err = -EINVAL;
@@ -678,8 +712,8 @@ clear:
         return err;
 }
 
-static const struct bpf_func_proto bpf_perf_prog_read_value_proto_tp = {
-         .func           = bpf_perf_prog_read_value_tp,
+static const struct bpf_func_proto bpf_perf_prog_read_value_proto = {
+         .func           = bpf_perf_prog_read_value,
          .gpl_only       = true,
          .ret_type       = RET_INTEGER,
          .arg1_type      = ARG_PTR_TO_CTX,
@@ -687,7 +721,7 @@ static const struct bpf_func_proto bpf_perf_prog_read_value_proto_tp = {
          .arg3_type      = ARG_CONST_SIZE,
 };
 
-static const struct bpf_func_proto *tp_prog_func_proto(enum bpf_func_id func_id)
+static const struct bpf_func_proto *pe_prog_func_proto(enum bpf_func_id func_id)
 {
         switch (func_id) {
         case BPF_FUNC_perf_event_output:
@@ -695,34 +729,12 @@ static const struct bpf_func_proto *tp_prog_func_proto(enum bpf_func_id func_id)
         case BPF_FUNC_get_stackid:
                 return &bpf_get_stackid_proto_tp;
         case BPF_FUNC_perf_prog_read_value:
-                return &bpf_perf_prog_read_value_proto_tp;
+                return &bpf_perf_prog_read_value_proto;
         default:
                 return tracing_func_proto(func_id);
         }
 }
 
-static bool tp_prog_is_valid_access(int off, int size, enum bpf_access_type type,
-                                    struct bpf_insn_access_aux *info)
-{
-        if (off < sizeof(void *) || off >= PERF_MAX_TRACE_SIZE)
-                return false;
-        if (type != BPF_READ)
-                return false;
-        if (off % size != 0)
-                return false;
-
-        BUILD_BUG_ON(PERF_MAX_TRACE_SIZE % sizeof(__u64));
-        return true;
-}
-
-const struct bpf_verifier_ops tracepoint_verifier_ops = {
-        .get_func_proto  = tp_prog_func_proto,
-        .is_valid_access = tp_prog_is_valid_access,
-};
-
-const struct bpf_prog_ops tracepoint_prog_ops = {
-};
-
 static bool pe_prog_is_valid_access(int off, int size, enum bpf_access_type type,
                                     struct bpf_insn_access_aux *info)
 {
@@ -779,7 +791,7 @@ static u32 pe_prog_convert_ctx_access(enum bpf_access_type type,
 }
 
 const struct bpf_verifier_ops perf_event_verifier_ops = {
-        .get_func_proto         = tp_prog_func_proto,
+        .get_func_proto         = pe_prog_func_proto,
         .is_valid_access        = pe_prog_is_valid_access,
         .convert_ctx_access     = pe_prog_convert_ctx_access,
 };
diff --git a/kernel/trace/trace_kprobe.c b/kernel/trace/trace_kprobe.c
index 1fad24acd444..ae4147eaebd4 100644
--- a/kernel/trace/trace_kprobe.c
+++ b/kernel/trace/trace_kprobe.c
@@ -659,7 +659,7 @@ static int create_trace_kprobe(int argc, char **argv)
         char *symbol = NULL, *event = NULL, *group = NULL;
         int maxactive = 0;
         char *arg;
-        unsigned long offset = 0;
+        long offset = 0;
         void *addr = NULL;
         char buf[MAX_EVENT_NAME_LEN];
 
@@ -747,7 +747,7 @@ static int create_trace_kprobe(int argc, char **argv)
                 symbol = argv[1];
                 /* TODO: support .init module functions */
                 ret = traceprobe_split_symbol_offset(symbol, &offset);
-                if (ret) {
+                if (ret || offset < 0 || offset > UINT_MAX) {
                         pr_info("Failed to parse either an address or a symbol.\n");
                         return ret;
                 }
diff --git a/kernel/trace/trace_probe.c b/kernel/trace/trace_probe.c
index d59357308677..daf54bda4dc8 100644
--- a/kernel/trace/trace_probe.c
+++ b/kernel/trace/trace_probe.c
@@ -320,7 +320,7 @@ static fetch_func_t get_fetch_size_function(const struct fetch_type *type,
 }
 
 /* Split symbol and offset. */
-int traceprobe_split_symbol_offset(char *symbol, unsigned long *offset)
+int traceprobe_split_symbol_offset(char *symbol, long *offset)
 {
         char *tmp;
         int ret;
@@ -328,13 +328,11 @@ int traceprobe_split_symbol_offset(char *symbol, unsigned long *offset)
         if (!offset)
                 return -EINVAL;
 
-        tmp = strchr(symbol, '+');
+        tmp = strpbrk(symbol, "+-");
         if (tmp) {
-                /* skip sign because kstrtoul doesn't accept '+' */
-                ret = kstrtoul(tmp + 1, 0, offset);
+                ret = kstrtol(tmp, 0, offset);
                 if (ret)
                         return ret;
-
                 *tmp = '\0';
         } else
                 *offset = 0;
diff --git a/kernel/trace/trace_probe.h b/kernel/trace/trace_probe.h
index e101c5bb9eda..6a4d3fa94042 100644
--- a/kernel/trace/trace_probe.h
+++ b/kernel/trace/trace_probe.h
@@ -365,7 +365,7 @@ extern int traceprobe_conflict_field_name(const char *name,
 extern void traceprobe_update_arg(struct probe_arg *arg);
 extern void traceprobe_free_probe_arg(struct probe_arg *arg);
 
-extern int traceprobe_split_symbol_offset(char *symbol, unsigned long *offset);
+extern int traceprobe_split_symbol_offset(char *symbol, long *offset);
 
 /* Sum up total data length for dynamic arraies (strings) */
 static nokprobe_inline int
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index bb9a519cbf50..6ec6ba65127b 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -3018,14 +3018,6 @@ static bool __cancel_work(struct work_struct *work, bool is_dwork)
         return ret;
 }
 
-/*
- * See cancel_delayed_work()
- */
-bool cancel_work(struct work_struct *work)
-{
-        return __cancel_work(work, false);
-}
-
 /**
  * cancel_delayed_work - cancel a delayed work
  * @dwork: delayed_work to cancel
@@ -5337,7 +5329,7 @@ int workqueue_sysfs_register(struct workqueue_struct *wq)
 
         ret = device_register(&wq_dev->dev);
         if (ret) {
-                kfree(wq_dev);
+                put_device(&wq_dev->dev);
                 wq->wq_dev = NULL;
                 return ret;
         }
diff --git a/lib/ioremap.c b/lib/ioremap.c
index b808a390e4c3..54e5bbaa3200 100644
--- a/lib/ioremap.c
+++ b/lib/ioremap.c
@@ -91,7 +91,8 @@ static inline int ioremap_pmd_range(pud_t *pud, unsigned long addr,
 
                 if (ioremap_pmd_enabled() &&
                     ((next - addr) == PMD_SIZE) &&
-                    IS_ALIGNED(phys_addr + addr, PMD_SIZE)) {
+                    IS_ALIGNED(phys_addr + addr, PMD_SIZE) &&
+                    pmd_free_pte_page(pmd)) {
                         if (pmd_set_huge(pmd, phys_addr + addr, prot))
                                 continue;
                 }
@@ -117,7 +118,8 @@ static inline int ioremap_pud_range(p4d_t *p4d, unsigned long addr,
 
                 if (ioremap_pud_enabled() &&
                     ((next - addr) == PUD_SIZE) &&
-                    IS_ALIGNED(phys_addr + addr, PUD_SIZE)) {
+                    IS_ALIGNED(phys_addr + addr, PUD_SIZE) &&
+                    pud_free_pmd_page(pud)) {
                         if (pud_set_huge(pud, phys_addr + addr, prot))
                                 continue;
                 }
diff --git a/lib/percpu-refcount.c b/lib/percpu-refcount.c
index 30e7dd88148b..9f96fa7bc000 100644
--- a/lib/percpu-refcount.c
+++ b/lib/percpu-refcount.c
@@ -322,6 +322,8 @@ EXPORT_SYMBOL_GPL(percpu_ref_switch_to_percpu);
  * This function normally doesn't block and can be called from any context
  * but it may block if @confirm_kill is specified and @ref is in the
  * process of switching to atomic mode by percpu_ref_switch_to_atomic().
+ *
+ * There are no implied RCU grace periods between kill and release.
  */
 void percpu_ref_kill_and_confirm(struct percpu_ref *ref,
                                  percpu_ref_func_t *confirm_kill)
diff --git a/lib/rhashtable.c b/lib/rhashtable.c
index 3825c30aaa36..47de025b6245 100644
--- a/lib/rhashtable.c
+++ b/lib/rhashtable.c
@@ -506,8 +506,10 @@ static void *rhashtable_lookup_one(struct rhashtable *ht,
                 if (!key ||
                     (ht->p.obj_cmpfn ?
                      ht->p.obj_cmpfn(&arg, rht_obj(ht, head)) :
-                     rhashtable_compare(&arg, rht_obj(ht, head))))
+                     rhashtable_compare(&arg, rht_obj(ht, head)))) {
+                        pprev = &head->next;
                         continue;
+                }
 
                 if (!ht->rhlist)
                         return rht_obj(ht, head);
diff --git a/lib/test_bpf.c b/lib/test_bpf.c
index 2efb213716fa..3e9335493fe4 100644
--- a/lib/test_bpf.c
+++ b/lib/test_bpf.c
@@ -5467,7 +5467,7 @@ static struct bpf_test tests[] = {
         {
                 "BPF_MAXINSNS: Jump, gap, jump, ...",
                 { },
-#ifdef CONFIG_BPF_JIT_ALWAYS_ON
+#if defined(CONFIG_BPF_JIT_ALWAYS_ON) && defined(CONFIG_X86)
                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
 #else
                 CLASSIC | FLAG_NO_DATA,
diff --git a/lib/test_rhashtable.c b/lib/test_rhashtable.c
index 76d3667fdea2..f4000c137dbe 100644
--- a/lib/test_rhashtable.c
+++ b/lib/test_rhashtable.c
@@ -79,6 +79,21 @@ struct thread_data {
         struct test_obj *objs;
 };
 
+static u32 my_hashfn(const void *data, u32 len, u32 seed)
+{
+        const struct test_obj_rhl *obj = data;
+
+        return (obj->value.id % 10) << RHT_HASH_RESERVED_SPACE;
+}
+
+static int my_cmpfn(struct rhashtable_compare_arg *arg, const void *obj)
+{
+        const struct test_obj_rhl *test_obj = obj;
+        const struct test_obj_val *val = arg->key;
+
+        return test_obj->value.id - val->id;
+}
+
 static struct rhashtable_params test_rht_params = {
         .head_offset = offsetof(struct test_obj, node),
         .key_offset = offsetof(struct test_obj, value),
@@ -87,6 +102,17 @@ static struct rhashtable_params test_rht_params = {
         .nulls_base = (3U << RHT_BASE_SHIFT),
 };
 
+static struct rhashtable_params test_rht_params_dup = {
+        .head_offset = offsetof(struct test_obj_rhl, list_node),
+        .key_offset = offsetof(struct test_obj_rhl, value),
+        .key_len = sizeof(struct test_obj_val),
+        .hashfn = jhash,
+        .obj_hashfn = my_hashfn,
+        .obj_cmpfn = my_cmpfn,
+        .nelem_hint = 128,
+        .automatic_shrinking = false,
+};
+
 static struct semaphore prestart_sem;
 static struct semaphore startup_sem = __SEMAPHORE_INITIALIZER(startup_sem, 0);
 
@@ -465,6 +491,112 @@ static int __init test_rhashtable_max(struct test_obj *array,
         return err;
 }
 
+static unsigned int __init print_ht(struct rhltable *rhlt)
+{
+        struct rhashtable *ht;
+        const struct bucket_table *tbl;
+        char buff[512] = "";
+        unsigned int i, cnt = 0;
+
+        ht = &rhlt->ht;
+        tbl = rht_dereference(ht->tbl, ht);
+        for (i = 0; i < tbl->size; i++) {
+                struct rhash_head *pos, *next;
+                struct test_obj_rhl *p;
+
+                pos = rht_dereference(tbl->buckets[i], ht);
+                next = !rht_is_a_nulls(pos) ? rht_dereference(pos->next, ht) : NULL;
+
+                if (!rht_is_a_nulls(pos)) {
+                        sprintf(buff, "%s\nbucket[%d] -> ", buff, i);
+                }
+
+                while (!rht_is_a_nulls(pos)) {
+                        struct rhlist_head *list = container_of(pos, struct rhlist_head, rhead);
+                        sprintf(buff, "%s[[", buff);
+                        do {
+                                pos = &list->rhead;
+                                list = rht_dereference(list->next, ht);
+                                p = rht_obj(ht, pos);
+
+                                sprintf(buff, "%s val %d (tid=%d)%s", buff, p->value.id, p->value.tid,
+                                        list? ", " : " ");
+                                cnt++;
+                        } while (list);
+
+                        pos = next,
+                        next = !rht_is_a_nulls(pos) ?
+                                rht_dereference(pos->next, ht) : NULL;
+
+                        sprintf(buff, "%s]]%s", buff, !rht_is_a_nulls(pos) ? " -> " : "");
+                }
+        }
+        printk(KERN_ERR "\n---- ht: ----%s\n-------------\n", buff);
+
+        return cnt;
+}
+
+static int __init test_insert_dup(struct test_obj_rhl *rhl_test_objects,
+                                  int cnt, bool slow)
+{
+        struct rhltable rhlt;
+        unsigned int i, ret;
+        const char *key;
+        int err = 0;
+
+        err = rhltable_init(&rhlt, &test_rht_params_dup);
+        if (WARN_ON(err))
+                return err;
+
+        for (i = 0; i < cnt; i++) {
+                rhl_test_objects[i].value.tid = i;
+                key = rht_obj(&rhlt.ht, &rhl_test_objects[i].list_node.rhead);
+                key += test_rht_params_dup.key_offset;
+
+                if (slow) {
+                        err = PTR_ERR(rhashtable_insert_slow(&rhlt.ht, key,
+                                                             &rhl_test_objects[i].list_node.rhead));
+                        if (err == -EAGAIN)
+                                err = 0;
+                } else
+                        err = rhltable_insert(&rhlt,
+                                              &rhl_test_objects[i].list_node,
+                                              test_rht_params_dup);
+                if (WARN(err, "error %d on element %d/%d (%s)\n", err, i, cnt, slow? "slow" : "fast"))
+                        goto skip_print;
+        }
+
+        ret = print_ht(&rhlt);
+        WARN(ret != cnt, "missing rhltable elements (%d != %d, %s)\n", ret, cnt, slow? "slow" : "fast");
+
+skip_print:
+        rhltable_destroy(&rhlt);
+
+        return 0;
+}
+
+static int __init test_insert_duplicates_run(void)
+{
+        struct test_obj_rhl rhl_test_objects[3] = {};
+
+        pr_info("test inserting duplicates\n");
+
+        /* two different values that map to same bucket */
+        rhl_test_objects[0].value.id = 1;
+        rhl_test_objects[1].value.id = 21;
+
+        /* and another duplicate with same as [0] value
+         * which will be second on the bucket list */
+        rhl_test_objects[2].value.id = rhl_test_objects[0].value.id;
+
+        test_insert_dup(rhl_test_objects, 2, false);
+        test_insert_dup(rhl_test_objects, 3, false);
+        test_insert_dup(rhl_test_objects, 2, true);
+        test_insert_dup(rhl_test_objects, 3, true);
+
+        return 0;
+}
+
 static int thread_lookup_test(struct thread_data *tdata)
 {
         unsigned int entries = tdata->entries;
@@ -613,6 +745,8 @@ static int __init test_rht_init(void)
         do_div(total_time, runs);
         pr_info("Average test time: %llu\n", total_time);
 
+        test_insert_duplicates_run();
+
         if (!tcount)
                 return 0;
 
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index 87ab9b8f56b5..5a68730eebd6 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -555,7 +555,8 @@ static int __do_huge_pmd_anonymous_page(struct vm_fault *vmf, struct page *page,
 
         VM_BUG_ON_PAGE(!PageCompound(page), page);
 
-        if (mem_cgroup_try_charge(page, vma->vm_mm, gfp, &memcg, true)) {
+        if (mem_cgroup_try_charge(page, vma->vm_mm, gfp | __GFP_NORETRY, &memcg,
+                                  true)) {
                 put_page(page);
                 count_vm_event(THP_FAULT_FALLBACK);
                 return VM_FAULT_FALLBACK;
@@ -1316,7 +1317,7 @@ alloc:
         }
 
         if (unlikely(mem_cgroup_try_charge(new_page, vma->vm_mm,
-                                        huge_gfp, &memcg, true))) {
+                                huge_gfp | __GFP_NORETRY, &memcg, true))) {
                 put_page(new_page);
                 split_huge_pmd(vma, vmf->pmd, vmf->address);
                 if (page)
@@ -2783,11 +2784,13 @@ static unsigned long deferred_split_scan(struct shrinker *shrink,
 
         list_for_each_safe(pos, next, &list) {
                 page = list_entry((void *)pos, struct page, mapping);
-                lock_page(page);
+                if (!trylock_page(page))
+                        goto next;
                 /* split_huge_page() removes page from list on success */
                 if (!split_huge_page(page))
                         split++;
                 unlock_page(page);
+next:
                 put_page(page);
         }
 
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index a963f2034dfc..976bbc5646fe 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -18,6 +18,7 @@
 #include <linux/bootmem.h>
 #include <linux/sysfs.h>
 #include <linux/slab.h>
+#include <linux/mmdebug.h>
 #include <linux/sched/signal.h>
 #include <linux/rmap.h>
 #include <linux/string_helpers.h>
@@ -4374,6 +4375,12 @@ int hugetlb_reserve_pages(struct inode *inode,
         struct resv_map *resv_map;
         long gbl_reserve;
 
+        /* This should never happen */
+        if (from > to) {
+                VM_WARN(1, "%s called with a negative range\n", __func__);
+                return -EINVAL;
+        }
+
         /*
          * Only apply hugepage reservation if asked. At fault time, an
          * attempt will be made for VM_NORESERVE to allocate a page
diff --git a/mm/khugepaged.c b/mm/khugepaged.c
index b7e2268dfc9a..e42568284e06 100644
--- a/mm/khugepaged.c
+++ b/mm/khugepaged.c
@@ -530,7 +530,12 @@ static int __collapse_huge_page_isolate(struct vm_area_struct *vma,
                         goto out;
                 }
 
-                VM_BUG_ON_PAGE(PageCompound(page), page);
+                /* TODO: teach khugepaged to collapse THP mapped with pte */
+                if (PageCompound(page)) {
+                        result = SCAN_PAGE_COMPOUND;
+                        goto out;
+                }
+
                 VM_BUG_ON_PAGE(!PageAnon(page), page);
 
                 /*
@@ -960,7 +965,9 @@ static void collapse_huge_page(struct mm_struct *mm,
                 goto out_nolock;
         }
 
-        if (unlikely(mem_cgroup_try_charge(new_page, mm, gfp, &memcg, true))) {
+        /* Do not oom kill for khugepaged charges */
+        if (unlikely(mem_cgroup_try_charge(new_page, mm, gfp | __GFP_NORETRY,
+                                           &memcg, true))) {
                 result = SCAN_CGROUP_CHARGE_FAIL;
                 goto out_nolock;
         }
@@ -1319,7 +1326,9 @@ static void collapse_shmem(struct mm_struct *mm,
                 goto out;
         }
 
-        if (unlikely(mem_cgroup_try_charge(new_page, mm, gfp, &memcg, true))) {
+        /* Do not oom kill for khugepaged charges */
+        if (unlikely(mem_cgroup_try_charge(new_page, mm, gfp | __GFP_NORETRY,
+                                           &memcg, true))) {
                 result = SCAN_CGROUP_CHARGE_FAIL;
                 goto out;
         }
diff --git a/mm/memblock.c b/mm/memblock.c
index b6ba6b7adadc..48376bd33274 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -1101,34 +1101,6 @@ void __init_memblock __next_mem_pfn_range(int *idx, int nid,
                 *out_nid = r->nid;
 }
 
-unsigned long __init_memblock memblock_next_valid_pfn(unsigned long pfn,
-                                                      unsigned long max_pfn)
-{
-        struct memblock_type *type = &memblock.memory;
-        unsigned int right = type->cnt;
-        unsigned int mid, left = 0;
-        phys_addr_t addr = PFN_PHYS(++pfn);
-
-        do {
-                mid = (right + left) / 2;
-
-                if (addr < type->regions[mid].base)
-                        right = mid;
-                else if (addr >= (type->regions[mid].base +
-                                  type->regions[mid].size))
-                        left = mid + 1;
-                else {
-                        /* addr is within the region, so pfn is valid */
-                        return pfn;
-                }
-        } while (left < right);
-
-        if (right == type->cnt)
-                return -1UL;
-        else
-                return PHYS_PFN(type->regions[right].base);
-}
-
 /**
  * memblock_set_node - set node ID on memblock regions
  * @base: base of area to set node ID for
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index d879f1d8a44a..32cba0332787 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -2124,6 +2124,9 @@ bool __mpol_equal(struct mempolicy *a, struct mempolicy *b)
         case MPOL_INTERLEAVE:
                 return !!nodes_equal(a->v.nodes, b->v.nodes);
         case MPOL_PREFERRED:
+                /* a's ->flags is the same as b's */
+                if (a->flags & MPOL_F_LOCAL)
+                        return true;
                 return a->v.preferred_node == b->v.preferred_node;
         default:
                 BUG();
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 635d7dd29d7f..1741dd23e7c1 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -3596,7 +3596,7 @@ static bool __need_fs_reclaim(gfp_t gfp_mask)
                 return false;
 
         /* this guy won't enter reclaim */
-        if ((current->flags & PF_MEMALLOC) && !(gfp_mask & __GFP_NOMEMALLOC))
+        if (current->flags & PF_MEMALLOC)
                 return false;
 
         /* We're only interested __GFP_FS allocations for now */
@@ -5356,17 +5356,8 @@ void __meminit memmap_init_zone(unsigned long size, int nid, unsigned long zone,
                 if (context != MEMMAP_EARLY)
                         goto not_early;
 
-                if (!early_pfn_valid(pfn)) {
-#ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
-                        /*
-                         * Skip to the pfn preceding the next valid one (or
-                         * end_pfn), such that we hit a valid pfn (or end_pfn)
-                         * on our next iteration of the loop.
-                         */
-                        pfn = memblock_next_valid_pfn(pfn, end_pfn) - 1;
-#endif
+                if (!early_pfn_valid(pfn))
                         continue;
-                }
                 if (!early_pfn_in_nid(pfn, nid))
                         continue;
                 if (!update_defer_init(pgdat, pfn, end_pfn, &nr_initialised))
diff --git a/mm/percpu-km.c b/mm/percpu-km.c
index d2a76642c4ae..38de70ab1a0d 100644
--- a/mm/percpu-km.c
+++ b/mm/percpu-km.c
@@ -34,7 +34,7 @@
 #include <linux/log2.h>
 
 static int pcpu_populate_chunk(struct pcpu_chunk *chunk,
-                               int page_start, int page_end)
+                               int page_start, int page_end, gfp_t gfp)
 {
         return 0;
 }
@@ -45,18 +45,18 @@ static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk,
         /* nada */
 }
 
-static struct pcpu_chunk *pcpu_create_chunk(void)
+static struct pcpu_chunk *pcpu_create_chunk(gfp_t gfp)
 {
         const int nr_pages = pcpu_group_sizes[0] >> PAGE_SHIFT;
         struct pcpu_chunk *chunk;
         struct page *pages;
         int i;
 
-        chunk = pcpu_alloc_chunk();
+        chunk = pcpu_alloc_chunk(gfp);
         if (!chunk)
                 return NULL;
 
-        pages = alloc_pages(GFP_KERNEL, order_base_2(nr_pages));
+        pages = alloc_pages(gfp, order_base_2(nr_pages));
         if (!pages) {
                 pcpu_free_chunk(chunk);
                 return NULL;
diff --git a/mm/percpu-vm.c b/mm/percpu-vm.c
index 9158e5a81391..d8078de912de 100644
--- a/mm/percpu-vm.c
+++ b/mm/percpu-vm.c
@@ -37,7 +37,7 @@ static struct page **pcpu_get_pages(void)
         lockdep_assert_held(&pcpu_alloc_mutex);
 
         if (!pages)
-                pages = pcpu_mem_zalloc(pages_size);
+                pages = pcpu_mem_zalloc(pages_size, GFP_KERNEL);
         return pages;
 }
 
@@ -73,18 +73,21 @@ static void pcpu_free_pages(struct pcpu_chunk *chunk,
  * @pages: array to put the allocated pages into, indexed by pcpu_page_idx()
  * @page_start: page index of the first page to be allocated
  * @page_end: page index of the last page to be allocated + 1
+ * @gfp: allocation flags passed to the underlying allocator
  *
  * Allocate pages [@page_start,@page_end) into @pages for all units.
  * The allocation is for @chunk.  Percpu core doesn't care about the
  * content of @pages and will pass it verbatim to pcpu_map_pages().
  */
 static int pcpu_alloc_pages(struct pcpu_chunk *chunk,
-                            struct page **pages, int page_start, int page_end)
+                            struct page **pages, int page_start, int page_end,
+                            gfp_t gfp)
 {
-        const gfp_t gfp = GFP_KERNEL | __GFP_HIGHMEM;
         unsigned int cpu, tcpu;
         int i;
 
+        gfp |= __GFP_HIGHMEM;
+
         for_each_possible_cpu(cpu) {
                 for (i = page_start; i < page_end; i++) {
                         struct page **pagep = &pages[pcpu_page_idx(cpu, i)];
@@ -262,6 +265,7 @@ static void pcpu_post_map_flush(struct pcpu_chunk *chunk,
  * @chunk: chunk of interest
  * @page_start: the start page
  * @page_end: the end page
+ * @gfp: allocation flags passed to the underlying memory allocator
  *
  * For each cpu, populate and map pages [@page_start,@page_end) into
  * @chunk.
@@ -270,7 +274,7 @@ static void pcpu_post_map_flush(struct pcpu_chunk *chunk,
  * pcpu_alloc_mutex, does GFP_KERNEL allocation.
  */
 static int pcpu_populate_chunk(struct pcpu_chunk *chunk,
-                               int page_start, int page_end)
+                               int page_start, int page_end, gfp_t gfp)
 {
         struct page **pages;
 
@@ -278,7 +282,7 @@ static int pcpu_populate_chunk(struct pcpu_chunk *chunk,
         if (!pages)
                 return -ENOMEM;
 
-        if (pcpu_alloc_pages(chunk, pages, page_start, page_end))
+        if (pcpu_alloc_pages(chunk, pages, page_start, page_end, gfp))
                 return -ENOMEM;
 
         if (pcpu_map_pages(chunk, pages, page_start, page_end)) {
@@ -325,12 +329,12 @@ static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk,
         pcpu_free_pages(chunk, pages, page_start, page_end);
 }
 
-static struct pcpu_chunk *pcpu_create_chunk(void)
+static struct pcpu_chunk *pcpu_create_chunk(gfp_t gfp)
 {
         struct pcpu_chunk *chunk;
         struct vm_struct **vms;
 
-        chunk = pcpu_alloc_chunk();
+        chunk = pcpu_alloc_chunk(gfp);
         if (!chunk)
                 return NULL;
 
diff --git a/mm/percpu.c b/mm/percpu.c
index 50e7fdf84055..9297098519a6 100644
--- a/mm/percpu.c
+++ b/mm/percpu.c
@@ -80,6 +80,7 @@
 #include <linux/vmalloc.h>
 #include <linux/workqueue.h>
 #include <linux/kmemleak.h>
+#include <linux/sched.h>
 
 #include <asm/cacheflush.h>
 #include <asm/sections.h>
@@ -447,26 +448,25 @@ static void pcpu_next_fit_region(struct pcpu_chunk *chunk, int alloc_bits,
 /**
  * pcpu_mem_zalloc - allocate memory
  * @size: bytes to allocate
+ * @gfp: allocation flags
  *
  * Allocate @size bytes.  If @size is smaller than PAGE_SIZE,
- * kzalloc() is used; otherwise, vzalloc() is used.  The returned
- * memory is always zeroed.
- *
- * CONTEXT:
- * Does GFP_KERNEL allocation.
+ * kzalloc() is used; otherwise, the equivalent of vzalloc() is used.
+ * This is to facilitate passing through whitelisted flags.  The
+ * returned memory is always zeroed.
  *
  * RETURNS:
  * Pointer to the allocated area on success, NULL on failure.
  */
-static void *pcpu_mem_zalloc(size_t size)
+static void *pcpu_mem_zalloc(size_t size, gfp_t gfp)
 {
         if (WARN_ON_ONCE(!slab_is_available()))
                 return NULL;
 
         if (size <= PAGE_SIZE)
-                return kzalloc(size, GFP_KERNEL);
+                return kzalloc(size, gfp);
         else
-                return vzalloc(size);
+                return __vmalloc(size, gfp | __GFP_ZERO, PAGE_KERNEL);
 }
 
 /**
@@ -1154,12 +1154,12 @@ static struct pcpu_chunk * __init pcpu_alloc_first_chunk(unsigned long tmp_addr,
         return chunk;
 }
 
-static struct pcpu_chunk *pcpu_alloc_chunk(void)
+static struct pcpu_chunk *pcpu_alloc_chunk(gfp_t gfp)
 {
         struct pcpu_chunk *chunk;
         int region_bits;
 
-        chunk = pcpu_mem_zalloc(pcpu_chunk_struct_size);
+        chunk = pcpu_mem_zalloc(pcpu_chunk_struct_size, gfp);
         if (!chunk)
                 return NULL;
 
@@ -1168,17 +1168,17 @@ static struct pcpu_chunk *pcpu_alloc_chunk(void)
         region_bits = pcpu_chunk_map_bits(chunk);
 
         chunk->alloc_map = pcpu_mem_zalloc(BITS_TO_LONGS(region_bits) *
-                                           sizeof(chunk->alloc_map[0]));
+                                           sizeof(chunk->alloc_map[0]), gfp);
         if (!chunk->alloc_map)
                 goto alloc_map_fail;
 
         chunk->bound_map = pcpu_mem_zalloc(BITS_TO_LONGS(region_bits + 1) *
-                                           sizeof(chunk->bound_map[0]));
+                                           sizeof(chunk->bound_map[0]), gfp);
         if (!chunk->bound_map)
                 goto bound_map_fail;
 
         chunk->md_blocks = pcpu_mem_zalloc(pcpu_chunk_nr_blocks(chunk) *
-                                           sizeof(chunk->md_blocks[0]));
+                                           sizeof(chunk->md_blocks[0]), gfp);
         if (!chunk->md_blocks)
                 goto md_blocks_fail;
 
@@ -1277,9 +1277,11 @@ static void pcpu_chunk_depopulated(struct pcpu_chunk *chunk,
  * pcpu_addr_to_page            - translate address to physical address
  * pcpu_verify_alloc_info       - check alloc_info is acceptable during init
  */
-static int pcpu_populate_chunk(struct pcpu_chunk *chunk, int off, int size);
-static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk, int off, int size);
-static struct pcpu_chunk *pcpu_create_chunk(void);
+static int pcpu_populate_chunk(struct pcpu_chunk *chunk,
+                               int page_start, int page_end, gfp_t gfp);
+static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk,
+                                  int page_start, int page_end);
+static struct pcpu_chunk *pcpu_create_chunk(gfp_t gfp);
 static void pcpu_destroy_chunk(struct pcpu_chunk *chunk);
 static struct page *pcpu_addr_to_page(void *addr);
 static int __init pcpu_verify_alloc_info(const struct pcpu_alloc_info *ai);
@@ -1339,6 +1341,8 @@ static struct pcpu_chunk *pcpu_chunk_addr_search(void *addr)
 static void __percpu *pcpu_alloc(size_t size, size_t align, bool reserved,
                                  gfp_t gfp)
 {
+        /* whitelisted flags that can be passed to the backing allocators */
+        gfp_t pcpu_gfp = gfp & (GFP_KERNEL | __GFP_NORETRY | __GFP_NOWARN);
         bool is_atomic = (gfp & GFP_KERNEL) != GFP_KERNEL;
         bool do_warn = !(gfp & __GFP_NOWARN);
         static int warn_limit = 10;
@@ -1369,8 +1373,17 @@ static void __percpu *pcpu_alloc(size_t size, size_t align, bool reserved,
                 return NULL;
         }
 
-        if (!is_atomic)
-                mutex_lock(&pcpu_alloc_mutex);
+        if (!is_atomic) {
+                /*
+                 * pcpu_balance_workfn() allocates memory under this mutex,
+                 * and it may wait for memory reclaim. Allow current task
+                 * to become OOM victim, in case of memory pressure.
+                 */
+                if (gfp & __GFP_NOFAIL)
+                        mutex_lock(&pcpu_alloc_mutex);
+                else if (mutex_lock_killable(&pcpu_alloc_mutex))
+                        return NULL;
+        }
 
         spin_lock_irqsave(&pcpu_lock, flags);
 
@@ -1421,7 +1434,7 @@ restart:
         }
 
         if (list_empty(&pcpu_slot[pcpu_nr_slots - 1])) {
-                chunk = pcpu_create_chunk();
+                chunk = pcpu_create_chunk(pcpu_gfp);
                 if (!chunk) {
                         err = "failed to allocate new chunk";
                         goto fail;
@@ -1450,7 +1463,7 @@ area_found:
                                            page_start, page_end) {
                         WARN_ON(chunk->immutable);
 
-                        ret = pcpu_populate_chunk(chunk, rs, re);
+                        ret = pcpu_populate_chunk(chunk, rs, re, pcpu_gfp);
 
                         spin_lock_irqsave(&pcpu_lock, flags);
                         if (ret) {
@@ -1561,10 +1574,17 @@ void __percpu *__alloc_reserved_percpu(size_t size, size_t align)
  * pcpu_balance_workfn - manage the amount of free chunks and populated pages
  * @work: unused
  *
- * Reclaim all fully free chunks except for the first one.
+ * Reclaim all fully free chunks except for the first one.  This is also
+ * responsible for maintaining the pool of empty populated pages.  However,
+ * it is possible that this is called when physical memory is scarce causing
+ * OOM killer to be triggered.  We should avoid doing so until an actual
+ * allocation causes the failure as it is possible that requests can be
+ * serviced from already backed regions.
  */
 static void pcpu_balance_workfn(struct work_struct *work)
 {
+        /* gfp flags passed to underlying allocators */
+        const gfp_t gfp = GFP_KERNEL | __GFP_NORETRY | __GFP_NOWARN;
         LIST_HEAD(to_free);
         struct list_head *free_head = &pcpu_slot[pcpu_nr_slots - 1];
         struct pcpu_chunk *chunk, *next;
@@ -1600,6 +1620,7 @@ static void pcpu_balance_workfn(struct work_struct *work)
                         spin_unlock_irq(&pcpu_lock);
                 }
                 pcpu_destroy_chunk(chunk);
+                cond_resched();
         }
 
         /*
@@ -1645,7 +1666,7 @@ retry_pop:
                                            chunk->nr_pages) {
                         int nr = min(re - rs, nr_to_pop);
 
-                        ret = pcpu_populate_chunk(chunk, rs, rs + nr);
+                        ret = pcpu_populate_chunk(chunk, rs, rs + nr, gfp);
                         if (!ret) {
                                 nr_to_pop -= nr;
                                 spin_lock_irq(&pcpu_lock);
@@ -1662,7 +1683,7 @@ retry_pop:
 
         if (nr_to_pop) {
                 /* ran out of chunks to populate, create a new one and retry */
-                chunk = pcpu_create_chunk();
+                chunk = pcpu_create_chunk(gfp);
                 if (chunk) {
                         spin_lock_irq(&pcpu_lock);
                         pcpu_chunk_relocate(chunk, -1);
diff --git a/mm/shmem.c b/mm/shmem.c
index 1907688b75ee..b85919243399 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -493,36 +493,45 @@ next:
                 info = list_entry(pos, struct shmem_inode_info, shrinklist);
                 inode = &info->vfs_inode;
 
-                if (nr_to_split && split >= nr_to_split) {
-                        iput(inode);
-                        continue;
-                }
+                if (nr_to_split && split >= nr_to_split)
+                        goto leave;
 
-                page = find_lock_page(inode->i_mapping,
+                page = find_get_page(inode->i_mapping,
                                 (inode->i_size & HPAGE_PMD_MASK) >> PAGE_SHIFT);
                 if (!page)
                         goto drop;
 
+                /* No huge page at the end of the file: nothing to split */
                 if (!PageTransHuge(page)) {
-                        unlock_page(page);
                         put_page(page);
                         goto drop;
                 }
 
+                /*
+                 * Leave the inode on the list if we failed to lock
+                 * the page at this time.
+                 *
+                 * Waiting for the lock may lead to deadlock in the
+                 * reclaim path.
+                 */
+                if (!trylock_page(page)) {
+                        put_page(page);
+                        goto leave;
+                }
+
                 ret = split_huge_page(page);
                 unlock_page(page);
                 put_page(page);
 
-                if (ret) {
-                        /* split failed: leave it on the list */
-                        iput(inode);
-                        continue;
-                }
+                /* If split failed leave the inode on the list */
+                if (ret)
+                        goto leave;
 
                 split++;
 drop:
                 list_del_init(&info->shrinklist);
                 removed++;
+leave:
                 iput(inode);
         }
 
diff --git a/mm/vmscan.c b/mm/vmscan.c
index bee53495a829..cd5dc3faaa57 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -1780,6 +1780,20 @@ shrink_inactive_list(unsigned long nr_to_scan, struct lruvec *lruvec,
                 set_bit(PGDAT_WRITEBACK, &pgdat->flags);
 
         /*
+         * If dirty pages are scanned that are not queued for IO, it
+         * implies that flushers are not doing their job. This can
+         * happen when memory pressure pushes dirty pages to the end of
+         * the LRU before the dirty limits are breached and the dirty
+         * data has expired. It can also happen when the proportion of
+         * dirty pages grows not through writes but through memory
+         * pressure reclaiming all the clean cache. And in some cases,
+         * the flushers simply cannot keep up with the allocation
+         * rate. Nudge the flusher threads in case they are asleep.
+         */
+        if (stat.nr_unqueued_dirty == nr_taken)
+                wakeup_flusher_threads(WB_REASON_VMSCAN);
+
+        /*
          * Legacy memcg will stall in page writeback so avoid forcibly
          * stalling here.
          */
@@ -1791,22 +1805,9 @@ shrink_inactive_list(unsigned long nr_to_scan, struct lruvec *lruvec,
                 if (stat.nr_dirty && stat.nr_dirty == stat.nr_congested)
                         set_bit(PGDAT_CONGESTED, &pgdat->flags);
 
-                /*
-                 * If dirty pages are scanned that are not queued for IO, it
-                 * implies that flushers are not doing their job. This can
-                 * happen when memory pressure pushes dirty pages to the end of
-                 * the LRU before the dirty limits are breached and the dirty
-                 * data has expired. It can also happen when the proportion of
-                 * dirty pages grows not through writes but through memory
-                 * pressure reclaiming all the clean cache. And in some cases,
-                 * the flushers simply cannot keep up with the allocation
-                 * rate. Nudge the flusher threads in case they are asleep, but
-                 * also allow kswapd to start writing pages during reclaim.
-                 */
-                if (stat.nr_unqueued_dirty == nr_taken) {
-                        wakeup_flusher_threads(WB_REASON_VMSCAN);
+                /* Allow kswapd to start writing pages during reclaim. */
+                if (stat.nr_unqueued_dirty == nr_taken)
                         set_bit(PGDAT_DIRTY, &pgdat->flags);
-                }
 
                 /*
                  * If kswapd scans pages marked marked for immediate
diff --git a/net/8021q/vlan_core.c b/net/8021q/vlan_core.c
index 64aa9f755e1d..45c9bf5ff3a0 100644
--- a/net/8021q/vlan_core.c
+++ b/net/8021q/vlan_core.c
@@ -48,8 +48,8 @@ bool vlan_do_receive(struct sk_buff **skbp)
                  * original position later
                  */
                 skb_push(skb, offset);
-                skb = *skbp = vlan_insert_tag(skb, skb->vlan_proto,
-                                              skb->vlan_tci);
+                skb = *skbp = vlan_insert_inner_tag(skb, skb->vlan_proto,
+                                                    skb->vlan_tci, skb->mac_len);
                 if (!skb)
                         return false;
                 skb_pull(skb, offset + VLAN_HLEN);
diff --git a/net/batman-adv/distributed-arp-table.c b/net/batman-adv/distributed-arp-table.c
index 9703c791ffc5..87cd962d28d5 100644
--- a/net/batman-adv/distributed-arp-table.c
+++ b/net/batman-adv/distributed-arp-table.c
@@ -393,7 +393,7 @@ static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb,
                    batadv_arp_hw_src(skb, hdr_size), &ip_src,
                    batadv_arp_hw_dst(skb, hdr_size), &ip_dst);
 
-        if (hdr_size == 0)
+        if (hdr_size < sizeof(struct batadv_unicast_packet))
                 return;
 
         unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
diff --git a/net/batman-adv/icmp_socket.c b/net/batman-adv/icmp_socket.c
index e91f29c7c638..5daa3d50da17 100644
--- a/net/batman-adv/icmp_socket.c
+++ b/net/batman-adv/icmp_socket.c
@@ -24,6 +24,7 @@
 #include <linux/debugfs.h>
 #include <linux/errno.h>
 #include <linux/etherdevice.h>
+#include <linux/eventpoll.h>
 #include <linux/export.h>
 #include <linux/fcntl.h>
 #include <linux/fs.h>
diff --git a/net/batman-adv/log.c b/net/batman-adv/log.c
index dc9fa37ddd14..cdbe0e5e208b 100644
--- a/net/batman-adv/log.c
+++ b/net/batman-adv/log.c
@@ -22,6 +22,7 @@
 #include <linux/compiler.h>
 #include <linux/debugfs.h>
 #include <linux/errno.h>
+#include <linux/eventpoll.h>
 #include <linux/export.h>
 #include <linux/fcntl.h>
 #include <linux/fs.h>
diff --git a/net/batman-adv/multicast.c b/net/batman-adv/multicast.c
index cbdeb47ec3f6..d70640135e3a 100644
--- a/net/batman-adv/multicast.c
+++ b/net/batman-adv/multicast.c
@@ -543,8 +543,8 @@ update:
                 bat_priv->mcast.enabled = true;
         }
 
-        return !(mcast_data.flags &
-                 (BATADV_MCAST_WANT_ALL_IPV4 | BATADV_MCAST_WANT_ALL_IPV6));
+        return !(mcast_data.flags & BATADV_MCAST_WANT_ALL_IPV4 &&
+                 mcast_data.flags & BATADV_MCAST_WANT_ALL_IPV6);
 }
 
 /**
diff --git a/net/batman-adv/routing.c b/net/batman-adv/routing.c
index b6891e8b741c..e61dc1293bb5 100644
--- a/net/batman-adv/routing.c
+++ b/net/batman-adv/routing.c
@@ -759,6 +759,7 @@ free_skb:
 /**
  * batadv_reroute_unicast_packet() - update the unicast header for re-routing
  * @bat_priv: the bat priv with all the soft interface information
+ * @skb: unicast packet to process
  * @unicast_packet: the unicast header to be updated
  * @dst_addr: the payload destination
  * @vid: VLAN identifier
@@ -770,7 +771,7 @@ free_skb:
  * Return: true if the packet header has been updated, false otherwise
  */
 static bool
-batadv_reroute_unicast_packet(struct batadv_priv *bat_priv,
+batadv_reroute_unicast_packet(struct batadv_priv *bat_priv, struct sk_buff *skb,
                               struct batadv_unicast_packet *unicast_packet,
                               u8 *dst_addr, unsigned short vid)
 {
@@ -799,8 +800,10 @@ batadv_reroute_unicast_packet(struct batadv_priv *bat_priv,
         }
 
         /* update the packet header */
+        skb_postpull_rcsum(skb, unicast_packet, sizeof(*unicast_packet));
         ether_addr_copy(unicast_packet->dest, orig_addr);
         unicast_packet->ttvn = orig_ttvn;
+        skb_postpush_rcsum(skb, unicast_packet, sizeof(*unicast_packet));
 
         ret = true;
 out:
@@ -841,7 +844,7 @@ static bool batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
          * the packet to
          */
         if (batadv_tt_local_client_is_roaming(bat_priv, ethhdr->h_dest, vid)) {
-                if (batadv_reroute_unicast_packet(bat_priv, unicast_packet,
+                if (batadv_reroute_unicast_packet(bat_priv, skb, unicast_packet,
                                                   ethhdr->h_dest, vid))
                         batadv_dbg_ratelimited(BATADV_DBG_TT,
                                                bat_priv,
@@ -887,7 +890,7 @@ static bool batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
          * destination can possibly be updated and forwarded towards the new
          * target host
          */
-        if (batadv_reroute_unicast_packet(bat_priv, unicast_packet,
+        if (batadv_reroute_unicast_packet(bat_priv, skb, unicast_packet,
                                           ethhdr->h_dest, vid)) {
                 batadv_dbg_ratelimited(BATADV_DBG_TT, bat_priv,
                                        "Rerouting unicast packet to %pM (dst=%pM): TTVN mismatch old_ttvn=%u new_ttvn=%u\n",
@@ -910,12 +913,14 @@ static bool batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
         if (!primary_if)
                 return false;
 
+        /* update the packet header */
+        skb_postpull_rcsum(skb, unicast_packet, sizeof(*unicast_packet));
         ether_addr_copy(unicast_packet->dest, primary_if->net_dev->dev_addr);
+        unicast_packet->ttvn = curr_ttvn;
+        skb_postpush_rcsum(skb, unicast_packet, sizeof(*unicast_packet));
 
         batadv_hardif_put(primary_if);
 
-        unicast_packet->ttvn = curr_ttvn;
-
         return true;
 }
 
@@ -968,14 +973,10 @@ int batadv_recv_unicast_packet(struct sk_buff *skb,
         struct batadv_orig_node *orig_node = NULL, *orig_node_gw = NULL;
         int check, hdr_size = sizeof(*unicast_packet);
         enum batadv_subtype subtype;
-        struct ethhdr *ethhdr;
         int ret = NET_RX_DROP;
         bool is4addr, is_gw;
 
         unicast_packet = (struct batadv_unicast_packet *)skb->data;
-        unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
-        ethhdr = eth_hdr(skb);
-
         is4addr = unicast_packet->packet_type == BATADV_UNICAST_4ADDR;
         /* the caller function should have already pulled 2 bytes */
         if (is4addr)
@@ -995,12 +996,14 @@ int batadv_recv_unicast_packet(struct sk_buff *skb,
         if (!batadv_check_unicast_ttvn(bat_priv, skb, hdr_size))
                 goto free_skb;
 
+        unicast_packet = (struct batadv_unicast_packet *)skb->data;
+
         /* packet for me */
         if (batadv_is_my_mac(bat_priv, unicast_packet->dest)) {
                 /* If this is a unicast packet from another backgone gw,
                  * drop it.
                  */
-                orig_addr_gw = ethhdr->h_source;
+                orig_addr_gw = eth_hdr(skb)->h_source;
                 orig_node_gw = batadv_orig_hash_find(bat_priv, orig_addr_gw);
                 if (orig_node_gw) {
                         is_gw = batadv_bla_is_backbone_gw(skb, orig_node_gw,
@@ -1015,6 +1018,8 @@ int batadv_recv_unicast_packet(struct sk_buff *skb,
                 }
 
                 if (is4addr) {
+                        unicast_4addr_packet =
+                                (struct batadv_unicast_4addr_packet *)skb->data;
                         subtype = unicast_4addr_packet->subtype;
                         batadv_dat_inc_counter(bat_priv, subtype);
 
diff --git a/net/bluetooth/smp.c b/net/bluetooth/smp.c
index 01117ae84f1d..a2ddae2f37d7 100644
--- a/net/bluetooth/smp.c
+++ b/net/bluetooth/smp.c
@@ -2296,8 +2296,14 @@ static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
         else
                 sec_level = authreq_to_seclevel(auth);
 
-        if (smp_sufficient_security(hcon, sec_level, SMP_USE_LTK))
+        if (smp_sufficient_security(hcon, sec_level, SMP_USE_LTK)) {
+                /* If link is already encrypted with sufficient security we
+                 * still need refresh encryption as per Core Spec 5.0 Vol 3,
+                 * Part H 2.4.6
+                 */
+                smp_ltk_encrypt(conn, hcon->sec_level);
                 return 0;
+        }
 
         if (sec_level > hcon->pending_sec_level)
                 hcon->pending_sec_level = sec_level;
diff --git a/net/bridge/netfilter/ebt_among.c b/net/bridge/netfilter/ebt_among.c
index c5afb4232ecb..620e54f08296 100644
--- a/net/bridge/netfilter/ebt_among.c
+++ b/net/bridge/netfilter/ebt_among.c
@@ -177,6 +177,28 @@ static bool poolsize_invalid(const struct ebt_mac_wormhash *w)
         return w && w->poolsize >= (INT_MAX / sizeof(struct ebt_mac_wormhash_tuple));
 }
 
+static bool wormhash_offset_invalid(int off, unsigned int len)
+{
+        if (off == 0) /* not present */
+                return false;
+
+        if (off < (int)sizeof(struct ebt_among_info) ||
+            off % __alignof__(struct ebt_mac_wormhash))
+                return true;
+
+        off += sizeof(struct ebt_mac_wormhash);
+
+        return off > len;
+}
+
+static bool wormhash_sizes_valid(const struct ebt_mac_wormhash *wh, int a, int b)
+{
+        if (a == 0)
+                a = sizeof(struct ebt_among_info);
+
+        return ebt_mac_wormhash_size(wh) + a == b;
+}
+
 static int ebt_among_mt_check(const struct xt_mtchk_param *par)
 {
         const struct ebt_among_info *info = par->matchinfo;
@@ -189,6 +211,10 @@ static int ebt_among_mt_check(const struct xt_mtchk_param *par)
         if (expected_length > em->match_size)
                 return -EINVAL;
 
+        if (wormhash_offset_invalid(info->wh_dst_ofs, em->match_size) ||
+            wormhash_offset_invalid(info->wh_src_ofs, em->match_size))
+                return -EINVAL;
+
         wh_dst = ebt_among_wh_dst(info);
         if (poolsize_invalid(wh_dst))
                 return -EINVAL;
@@ -201,6 +227,14 @@ static int ebt_among_mt_check(const struct xt_mtchk_param *par)
         if (poolsize_invalid(wh_src))
                 return -EINVAL;
 
+        if (info->wh_src_ofs < info->wh_dst_ofs) {
+                if (!wormhash_sizes_valid(wh_src, info->wh_src_ofs, info->wh_dst_ofs))
+                        return -EINVAL;
+        } else {
+                if (!wormhash_sizes_valid(wh_dst, info->wh_dst_ofs, info->wh_src_ofs))
+                        return -EINVAL;
+        }
+
         expected_length += ebt_mac_wormhash_size(wh_src);
 
         if (em->match_size != EBT_ALIGN(expected_length)) {
diff --git a/net/bridge/netfilter/ebtables.c b/net/bridge/netfilter/ebtables.c
index 254ef9f49567..a94d23b0a9af 100644
--- a/net/bridge/netfilter/ebtables.c
+++ b/net/bridge/netfilter/ebtables.c
@@ -2119,8 +2119,12 @@ static int size_entry_mwt(struct ebt_entry *entry, const unsigned char *base,
          * offsets are relative to beginning of struct ebt_entry (i.e., 0).
          */
         for (i = 0; i < 4 ; ++i) {
-                if (offsets[i] >= *total)
+                if (offsets[i] > *total)
                         return -EINVAL;
+
+                if (i < 3 && offsets[i] == *total)
+                        return -EINVAL;
+
                 if (i == 0)
                         continue;
                 if (offsets[i-1] > offsets[i])
diff --git a/net/core/dev.c b/net/core/dev.c
index 2cedf520cb28..12be20535714 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -3278,15 +3278,23 @@ static inline int __dev_xmit_skb(struct sk_buff *skb, struct Qdisc *q,
 #if IS_ENABLED(CONFIG_CGROUP_NET_PRIO)
 static void skb_update_prio(struct sk_buff *skb)
 {
-        struct netprio_map *map = rcu_dereference_bh(skb->dev->priomap);
+        const struct netprio_map *map;
+        const struct sock *sk;
+        unsigned int prioidx;
 
-        if (!skb->priority && skb->sk && map) {
-                unsigned int prioidx =
-                        sock_cgroup_prioidx(&skb->sk->sk_cgrp_data);
+        if (skb->priority)
+                return;
+        map = rcu_dereference_bh(skb->dev->priomap);
+        if (!map)
+                return;
+        sk = skb_to_full_sk(skb);
+        if (!sk)
+                return;
 
-                if (prioidx < map->priomap_len)
-                        skb->priority = map->priomap[prioidx];
-        }
+        prioidx = sock_cgroup_prioidx(&sk->sk_cgrp_data);
+
+        if (prioidx < map->priomap_len)
+                skb->priority = map->priomap[prioidx];
 }
 #else
 #define skb_update_prio(skb)
diff --git a/net/core/dev_ioctl.c b/net/core/dev_ioctl.c
index 0ab1af04296c..a04e1e88bf3a 100644
--- a/net/core/dev_ioctl.c
+++ b/net/core/dev_ioctl.c
@@ -402,8 +402,6 @@ int dev_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr, bool *need_c
         if (colon)
                 *colon = 0;
 
-        dev_load(net, ifr->ifr_name);
-
         /*
          *      See which interface the caller is talking about.
          */
@@ -423,6 +421,7 @@ int dev_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr, bool *need_c
         case SIOCGIFMAP:
         case SIOCGIFINDEX:
         case SIOCGIFTXQLEN:
+                dev_load(net, ifr->ifr_name);
                 rcu_read_lock();
                 ret = dev_ifsioc_locked(net, ifr, cmd);
                 rcu_read_unlock();
@@ -431,6 +430,7 @@ int dev_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr, bool *need_c
                 return ret;
 
         case SIOCETHTOOL:
+                dev_load(net, ifr->ifr_name);
                 rtnl_lock();
                 ret = dev_ethtool(net, ifr);
                 rtnl_unlock();
@@ -447,6 +447,7 @@ int dev_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr, bool *need_c
         case SIOCGMIIPHY:
         case SIOCGMIIREG:
         case SIOCSIFNAME:
+                dev_load(net, ifr->ifr_name);
                 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
                         return -EPERM;
                 rtnl_lock();
@@ -494,6 +495,7 @@ int dev_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr, bool *need_c
                 /* fall through */
         case SIOCBONDSLAVEINFOQUERY:
         case SIOCBONDINFOQUERY:
+                dev_load(net, ifr->ifr_name);
                 rtnl_lock();
                 ret = dev_ifsioc(net, ifr, cmd);
                 rtnl_unlock();
@@ -518,6 +520,7 @@ int dev_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr, bool *need_c
                     cmd == SIOCGHWTSTAMP ||
                     (cmd >= SIOCDEVPRIVATE &&
                      cmd <= SIOCDEVPRIVATE + 15)) {
+                        dev_load(net, ifr->ifr_name);
                         rtnl_lock();
                         ret = dev_ifsioc(net, ifr, cmd);
                         rtnl_unlock();
diff --git a/net/core/devlink.c b/net/core/devlink.c
index 2f2307d94787..effd4848c2b4 100644
--- a/net/core/devlink.c
+++ b/net/core/devlink.c
@@ -1798,7 +1798,7 @@ send_done:
         if (!nlh) {
                 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
                 if (err)
-                        goto err_skb_send_alloc;
+                        return err;
                 goto send_done;
         }
 
@@ -1807,7 +1807,6 @@ send_done:
 nla_put_failure:
         err = -EMSGSIZE;
 err_table_put:
-err_skb_send_alloc:
         genlmsg_cancel(skb, hdr);
         nlmsg_free(skb);
         return err;
@@ -2073,7 +2072,7 @@ static int devlink_dpipe_entries_fill(struct genl_info *info,
                                              table->counters_enabled,
                                              &dump_ctx);
         if (err)
-                goto err_entries_dump;
+                return err;
 
 send_done:
         nlh = nlmsg_put(dump_ctx.skb, info->snd_portid, info->snd_seq,
@@ -2081,16 +2080,10 @@ send_done:
         if (!nlh) {
                 err = devlink_dpipe_send_and_alloc_skb(&dump_ctx.skb, info);
                 if (err)
-                        goto err_skb_send_alloc;
+                        return err;
                 goto send_done;
         }
         return genlmsg_reply(dump_ctx.skb, info);
-
-err_entries_dump:
-err_skb_send_alloc:
-        genlmsg_cancel(dump_ctx.skb, dump_ctx.hdr);
-        nlmsg_free(dump_ctx.skb);
-        return err;
 }
 
 static int devlink_nl_cmd_dpipe_entries_get(struct sk_buff *skb,
@@ -2229,7 +2222,7 @@ send_done:
         if (!nlh) {
                 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
                 if (err)
-                        goto err_skb_send_alloc;
+                        return err;
                 goto send_done;
         }
         return genlmsg_reply(skb, info);
@@ -2237,7 +2230,6 @@ send_done:
 nla_put_failure:
         err = -EMSGSIZE;
 err_table_put:
-err_skb_send_alloc:
         genlmsg_cancel(skb, hdr);
         nlmsg_free(skb);
         return err;
diff --git a/net/core/filter.c b/net/core/filter.c
index 0c121adbdbaa..48aa7c7320db 100644
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@ -2087,6 +2087,10 @@ static int bpf_skb_proto_4_to_6(struct sk_buff *skb)
         u32 off = skb_mac_header_len(skb);
         int ret;
 
+        /* SCTP uses GSO_BY_FRAGS, thus cannot adjust it. */
+        if (skb_is_gso(skb) && unlikely(skb_is_gso_sctp(skb)))
+                return -ENOTSUPP;
+
         ret = skb_cow(skb, len_diff);
         if (unlikely(ret < 0))
                 return ret;
@@ -2096,19 +2100,21 @@ static int bpf_skb_proto_4_to_6(struct sk_buff *skb)
                 return ret;
 
         if (skb_is_gso(skb)) {
+                struct skb_shared_info *shinfo = skb_shinfo(skb);
+
                 /* SKB_GSO_TCPV4 needs to be changed into
                  * SKB_GSO_TCPV6.
                  */
-                if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4) {
-                        skb_shinfo(skb)->gso_type &= ~SKB_GSO_TCPV4;
-                        skb_shinfo(skb)->gso_type |=  SKB_GSO_TCPV6;
+                if (shinfo->gso_type & SKB_GSO_TCPV4) {
+                        shinfo->gso_type &= ~SKB_GSO_TCPV4;
+                        shinfo->gso_type |=  SKB_GSO_TCPV6;
                 }
 
                 /* Due to IPv6 header, MSS needs to be downgraded. */
-                skb_shinfo(skb)->gso_size -= len_diff;
+                skb_decrease_gso_size(shinfo, len_diff);
                 /* Header must be checked, and gso_segs recomputed. */
-                skb_shinfo(skb)->gso_type |= SKB_GSO_DODGY;
-                skb_shinfo(skb)->gso_segs = 0;
+                shinfo->gso_type |= SKB_GSO_DODGY;
+                shinfo->gso_segs = 0;
         }
 
         skb->protocol = htons(ETH_P_IPV6);
@@ -2123,6 +2129,10 @@ static int bpf_skb_proto_6_to_4(struct sk_buff *skb)
         u32 off = skb_mac_header_len(skb);
         int ret;
 
+        /* SCTP uses GSO_BY_FRAGS, thus cannot adjust it. */
+        if (skb_is_gso(skb) && unlikely(skb_is_gso_sctp(skb)))
+                return -ENOTSUPP;
+
         ret = skb_unclone(skb, GFP_ATOMIC);
         if (unlikely(ret < 0))
                 return ret;
@@ -2132,19 +2142,21 @@ static int bpf_skb_proto_6_to_4(struct sk_buff *skb)
                 return ret;
 
         if (skb_is_gso(skb)) {
+                struct skb_shared_info *shinfo = skb_shinfo(skb);
+
                 /* SKB_GSO_TCPV6 needs to be changed into
                  * SKB_GSO_TCPV4.
                  */
-                if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6) {
-                        skb_shinfo(skb)->gso_type &= ~SKB_GSO_TCPV6;
-                        skb_shinfo(skb)->gso_type |=  SKB_GSO_TCPV4;
+                if (shinfo->gso_type & SKB_GSO_TCPV6) {
+                        shinfo->gso_type &= ~SKB_GSO_TCPV6;
+                        shinfo->gso_type |=  SKB_GSO_TCPV4;
                 }
 
                 /* Due to IPv4 header, MSS can be upgraded. */
-                skb_shinfo(skb)->gso_size += len_diff;
+                skb_increase_gso_size(shinfo, len_diff);
                 /* Header must be checked, and gso_segs recomputed. */
-                skb_shinfo(skb)->gso_type |= SKB_GSO_DODGY;
-                skb_shinfo(skb)->gso_segs = 0;
+                shinfo->gso_type |= SKB_GSO_DODGY;
+                shinfo->gso_segs = 0;
         }
 
         skb->protocol = htons(ETH_P_IP);
@@ -2243,6 +2255,10 @@ static int bpf_skb_net_grow(struct sk_buff *skb, u32 len_diff)
         u32 off = skb_mac_header_len(skb) + bpf_skb_net_base_len(skb);
         int ret;
 
+        /* SCTP uses GSO_BY_FRAGS, thus cannot adjust it. */
+        if (skb_is_gso(skb) && unlikely(skb_is_gso_sctp(skb)))
+                return -ENOTSUPP;
+
         ret = skb_cow(skb, len_diff);
         if (unlikely(ret < 0))
                 return ret;
@@ -2252,11 +2268,13 @@ static int bpf_skb_net_grow(struct sk_buff *skb, u32 len_diff)
                 return ret;
 
         if (skb_is_gso(skb)) {
+                struct skb_shared_info *shinfo = skb_shinfo(skb);
+
                 /* Due to header grow, MSS needs to be downgraded. */
-                skb_shinfo(skb)->gso_size -= len_diff;
+                skb_decrease_gso_size(shinfo, len_diff);
                 /* Header must be checked, and gso_segs recomputed. */
-                skb_shinfo(skb)->gso_type |= SKB_GSO_DODGY;
-                skb_shinfo(skb)->gso_segs = 0;
+                shinfo->gso_type |= SKB_GSO_DODGY;
+                shinfo->gso_segs = 0;
         }
 
         return 0;
@@ -2267,6 +2285,10 @@ static int bpf_skb_net_shrink(struct sk_buff *skb, u32 len_diff)
         u32 off = skb_mac_header_len(skb) + bpf_skb_net_base_len(skb);
         int ret;
 
+        /* SCTP uses GSO_BY_FRAGS, thus cannot adjust it. */
+        if (skb_is_gso(skb) && unlikely(skb_is_gso_sctp(skb)))
+                return -ENOTSUPP;
+
         ret = skb_unclone(skb, GFP_ATOMIC);
         if (unlikely(ret < 0))
                 return ret;
@@ -2276,11 +2298,13 @@ static int bpf_skb_net_shrink(struct sk_buff *skb, u32 len_diff)
                 return ret;
 
         if (skb_is_gso(skb)) {
+                struct skb_shared_info *shinfo = skb_shinfo(skb);
+
                 /* Due to header shrink, MSS can be upgraded. */
-                skb_shinfo(skb)->gso_size += len_diff;
+                skb_increase_gso_size(shinfo, len_diff);
                 /* Header must be checked, and gso_segs recomputed. */
-                skb_shinfo(skb)->gso_type |= SKB_GSO_DODGY;
-                skb_shinfo(skb)->gso_segs = 0;
+                shinfo->gso_type |= SKB_GSO_DODGY;
+                shinfo->gso_segs = 0;
         }
 
         return 0;
diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index 0bb0d8877954..1e7acdc30732 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -4179,7 +4179,7 @@ int sock_queue_err_skb(struct sock *sk, struct sk_buff *skb)
 
         skb_queue_tail(&sk->sk_error_queue, skb);
         if (!sock_flag(sk, SOCK_DEAD))
-                sk->sk_data_ready(sk);
+                sk->sk_error_report(sk);
         return 0;
 }
 EXPORT_SYMBOL(sock_queue_err_skb);
@@ -4904,7 +4904,7 @@ static unsigned int skb_gso_transport_seglen(const struct sk_buff *skb)
                         thlen += inner_tcp_hdrlen(skb);
         } else if (likely(shinfo->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6))) {
                 thlen = tcp_hdrlen(skb);
-        } else if (unlikely(shinfo->gso_type & SKB_GSO_SCTP)) {
+        } else if (unlikely(skb_is_gso_sctp(skb))) {
                 thlen = sizeof(struct sctphdr);
         }
         /* UFO sets gso_size to the size of the fragmentation
@@ -5020,13 +5020,16 @@ EXPORT_SYMBOL_GPL(skb_gso_validate_mac_len);
 
 static struct sk_buff *skb_reorder_vlan_header(struct sk_buff *skb)
 {
+        int mac_len;
+
         if (skb_cow(skb, skb_headroom(skb)) < 0) {
                 kfree_skb(skb);
                 return NULL;
         }
 
-        memmove(skb->data - ETH_HLEN, skb->data - skb->mac_len - VLAN_HLEN,
-                2 * ETH_ALEN);
+        mac_len = skb->data - skb_mac_header(skb);
+        memmove(skb_mac_header(skb) + VLAN_HLEN, skb_mac_header(skb),
+                mac_len - VLAN_HLEN - ETH_TLEN);
         skb->mac_header += VLAN_HLEN;
         return skb;
 }
diff --git a/net/core/sock.c b/net/core/sock.c
index c501499a04fe..85b0b64e7f9d 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -3261,6 +3261,27 @@ void proto_unregister(struct proto *prot)
 }
 EXPORT_SYMBOL(proto_unregister);
 
+int sock_load_diag_module(int family, int protocol)
+{
+        if (!protocol) {
+                if (!sock_is_registered(family))
+                        return -ENOENT;
+
+                return request_module("net-pf-%d-proto-%d-type-%d", PF_NETLINK,
+                                      NETLINK_SOCK_DIAG, family);
+        }
+
+#ifdef CONFIG_INET
+        if (family == AF_INET &&
+            !rcu_access_pointer(inet_protos[protocol]))
+                return -ENOENT;
+#endif
+
+        return request_module("net-pf-%d-proto-%d-type-%d-%d", PF_NETLINK,
+                              NETLINK_SOCK_DIAG, family, protocol);
+}
+EXPORT_SYMBOL(sock_load_diag_module);
+
 #ifdef CONFIG_PROC_FS
 static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
         __acquires(proto_list_mutex)
diff --git a/net/core/sock_diag.c b/net/core/sock_diag.c
index 146b50e30659..c37b5be7c5e4 100644
--- a/net/core/sock_diag.c
+++ b/net/core/sock_diag.c
@@ -220,8 +220,7 @@ static int __sock_diag_cmd(struct sk_buff *skb, struct nlmsghdr *nlh)
                 return -EINVAL;
 
         if (sock_diag_handlers[req->sdiag_family] == NULL)
-                request_module("net-pf-%d-proto-%d-type-%d", PF_NETLINK,
-                                NETLINK_SOCK_DIAG, req->sdiag_family);
+                sock_load_diag_module(req->sdiag_family, 0);
 
         mutex_lock(&sock_diag_table_mutex);
         hndl = sock_diag_handlers[req->sdiag_family];
@@ -247,8 +246,7 @@ static int sock_diag_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
         case TCPDIAG_GETSOCK:
         case DCCPDIAG_GETSOCK:
                 if (inet_rcv_compat == NULL)
-                        request_module("net-pf-%d-proto-%d-type-%d", PF_NETLINK,
-                                        NETLINK_SOCK_DIAG, AF_INET);
+                        sock_load_diag_module(AF_INET, 0);
 
                 mutex_lock(&sock_diag_table_mutex);
                 if (inet_rcv_compat != NULL)
@@ -281,14 +279,12 @@ static int sock_diag_bind(struct net *net, int group)
         case SKNLGRP_INET_TCP_DESTROY:
         case SKNLGRP_INET_UDP_DESTROY:
                 if (!sock_diag_handlers[AF_INET])
-                        request_module("net-pf-%d-proto-%d-type-%d", PF_NETLINK,
-                                       NETLINK_SOCK_DIAG, AF_INET);
+                        sock_load_diag_module(AF_INET, 0);
                 break;
         case SKNLGRP_INET6_TCP_DESTROY:
         case SKNLGRP_INET6_UDP_DESTROY:
                 if (!sock_diag_handlers[AF_INET6])
-                        request_module("net-pf-%d-proto-%d-type-%d", PF_NETLINK,
-                                       NETLINK_SOCK_DIAG, AF_INET6);
+                        sock_load_diag_module(AF_INET6, 0);
                 break;
         }
         return 0;
diff --git a/net/dccp/proto.c b/net/dccp/proto.c
index 15bdc002d90c..84cd4e3fd01b 100644
--- a/net/dccp/proto.c
+++ b/net/dccp/proto.c
@@ -794,6 +794,11 @@ int dccp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
         if (skb == NULL)
                 goto out_release;
 
+        if (sk->sk_state == DCCP_CLOSED) {
+                rc = -ENOTCONN;
+                goto out_discard;
+        }
+
         skb_reserve(skb, sk->sk_prot->max_header);
         rc = memcpy_from_msg(skb_put(skb, len), msg, len);
         if (rc != 0)
diff --git a/net/dsa/legacy.c b/net/dsa/legacy.c
index cb54b81d0bd9..42a7b85b84e1 100644
--- a/net/dsa/legacy.c
+++ b/net/dsa/legacy.c
@@ -194,7 +194,7 @@ static int dsa_switch_setup_one(struct dsa_switch *ds,
                 ds->ports[i].dn = cd->port_dn[i];
                 ds->ports[i].cpu_dp = dst->cpu_dp;
 
-                if (dsa_is_user_port(ds, i))
+                if (!dsa_is_user_port(ds, i))
                         continue;
 
                 ret = dsa_slave_create(&ds->ports[i]);
diff --git a/net/ieee802154/6lowpan/core.c b/net/ieee802154/6lowpan/core.c
index 974765b7d92a..e9f0489e4229 100644
--- a/net/ieee802154/6lowpan/core.c
+++ b/net/ieee802154/6lowpan/core.c
@@ -206,9 +206,13 @@ static inline void lowpan_netlink_fini(void)
 static int lowpan_device_event(struct notifier_block *unused,
                                unsigned long event, void *ptr)
 {
-        struct net_device *wdev = netdev_notifier_info_to_dev(ptr);
+        struct net_device *ndev = netdev_notifier_info_to_dev(ptr);
+        struct wpan_dev *wpan_dev;
 
-        if (wdev->type != ARPHRD_IEEE802154)
+        if (ndev->type != ARPHRD_IEEE802154)
+                return NOTIFY_DONE;
+        wpan_dev = ndev->ieee802154_ptr;
+        if (!wpan_dev)
                 return NOTIFY_DONE;
 
         switch (event) {
@@ -217,8 +221,8 @@ static int lowpan_device_event(struct notifier_block *unused,
                  * also delete possible lowpan interfaces which belongs
                  * to the wpan interface.
                  */
-                if (wdev->ieee802154_ptr->lowpan_dev)
-                        lowpan_dellink(wdev->ieee802154_ptr->lowpan_dev, NULL);
+                if (wpan_dev->lowpan_dev)
+                        lowpan_dellink(wpan_dev->lowpan_dev, NULL);
                 break;
         default:
                 return NOTIFY_DONE;
diff --git a/net/ipv4/inet_diag.c b/net/ipv4/inet_diag.c
index a383f299ce24..4e5bc4b2f14e 100644
--- a/net/ipv4/inet_diag.c
+++ b/net/ipv4/inet_diag.c
@@ -53,8 +53,7 @@ static DEFINE_MUTEX(inet_diag_table_mutex);
 static const struct inet_diag_handler *inet_diag_lock_handler(int proto)
 {
         if (!inet_diag_table[proto])
-                request_module("net-pf-%d-proto-%d-type-%d-%d", PF_NETLINK,
-                               NETLINK_SOCK_DIAG, AF_INET, proto);
+                sock_load_diag_module(AF_INET, proto);
 
         mutex_lock(&inet_diag_table_mutex);
         if (!inet_diag_table[proto])
diff --git a/net/ipv4/inet_fragment.c b/net/ipv4/inet_fragment.c
index 26a3d0315728..e8ec28999f5c 100644
--- a/net/ipv4/inet_fragment.c
+++ b/net/ipv4/inet_fragment.c
@@ -119,6 +119,9 @@ out:
 
 static bool inet_fragq_should_evict(const struct inet_frag_queue *q)
 {
+        if (!hlist_unhashed(&q->list_evictor))
+                return false;
+
         return q->net->low_thresh == 0 ||
                frag_mem_limit(q->net) >= q->net->low_thresh;
 }
diff --git a/net/ipv4/ip_sockglue.c b/net/ipv4/ip_sockglue.c
index 9c41a0cef1a5..74c962b9b09c 100644
--- a/net/ipv4/ip_sockglue.c
+++ b/net/ipv4/ip_sockglue.c
@@ -258,7 +258,8 @@ int ip_cmsg_send(struct sock *sk, struct msghdr *msg, struct ipcm_cookie *ipc,
                         src_info = (struct in6_pktinfo *)CMSG_DATA(cmsg);
                         if (!ipv6_addr_v4mapped(&src_info->ipi6_addr))
                                 return -EINVAL;
-                        ipc->oif = src_info->ipi6_ifindex;
+                        if (src_info->ipi6_ifindex)
+                                ipc->oif = src_info->ipi6_ifindex;
                         ipc->addr = src_info->ipi6_addr.s6_addr32[3];
                         continue;
                 }
@@ -288,7 +289,8 @@ int ip_cmsg_send(struct sock *sk, struct msghdr *msg, struct ipcm_cookie *ipc,
                         if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct in_pktinfo)))
                                 return -EINVAL;
                         info = (struct in_pktinfo *)CMSG_DATA(cmsg);
-                        ipc->oif = info->ipi_ifindex;
+                        if (info->ipi_ifindex)
+                                ipc->oif = info->ipi_ifindex;
                         ipc->addr = info->ipi_spec_dst.s_addr;
                         break;
                 }
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index 860b3fd2f54b..299e247b2032 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -634,6 +634,7 @@ static inline u32 fnhe_hashfun(__be32 daddr)
 static void fill_route_from_fnhe(struct rtable *rt, struct fib_nh_exception *fnhe)
 {
         rt->rt_pmtu = fnhe->fnhe_pmtu;
+        rt->rt_mtu_locked = fnhe->fnhe_mtu_locked;
         rt->dst.expires = fnhe->fnhe_expires;
 
         if (fnhe->fnhe_gw) {
@@ -644,7 +645,7 @@ static void fill_route_from_fnhe(struct rtable *rt, struct fib_nh_exception *fnh
 }
 
 static void update_or_create_fnhe(struct fib_nh *nh, __be32 daddr, __be32 gw,
-                                  u32 pmtu, unsigned long expires)
+                                  u32 pmtu, bool lock, unsigned long expires)
 {
         struct fnhe_hash_bucket *hash;
         struct fib_nh_exception *fnhe;
@@ -681,8 +682,10 @@ static void update_or_create_fnhe(struct fib_nh *nh, __be32 daddr, __be32 gw,
                         fnhe->fnhe_genid = genid;
                 if (gw)
                         fnhe->fnhe_gw = gw;
-                if (pmtu)
+                if (pmtu) {
                         fnhe->fnhe_pmtu = pmtu;
+                        fnhe->fnhe_mtu_locked = lock;
+                }
                 fnhe->fnhe_expires = max(1UL, expires);
                 /* Update all cached dsts too */
                 rt = rcu_dereference(fnhe->fnhe_rth_input);
@@ -706,6 +709,7 @@ static void update_or_create_fnhe(struct fib_nh *nh, __be32 daddr, __be32 gw,
                 fnhe->fnhe_daddr = daddr;
                 fnhe->fnhe_gw = gw;
                 fnhe->fnhe_pmtu = pmtu;
+                fnhe->fnhe_mtu_locked = lock;
                 fnhe->fnhe_expires = expires;
 
                 /* Exception created; mark the cached routes for the nexthop
@@ -787,7 +791,8 @@ static void __ip_do_redirect(struct rtable *rt, struct sk_buff *skb, struct flow
                                 struct fib_nh *nh = &FIB_RES_NH(res);
 
                                 update_or_create_fnhe(nh, fl4->daddr, new_gw,
-                                                0, jiffies + ip_rt_gc_timeout);
+                                                0, false,
+                                                jiffies + ip_rt_gc_timeout);
                         }
                         if (kill_route)
                                 rt->dst.obsolete = DST_OBSOLETE_KILL;
@@ -1009,15 +1014,18 @@ static void __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
 {
         struct dst_entry *dst = &rt->dst;
         struct fib_result res;
+        bool lock = false;
 
-        if (dst_metric_locked(dst, RTAX_MTU))
+        if (ip_mtu_locked(dst))
                 return;
 
         if (ipv4_mtu(dst) < mtu)
                 return;
 
-        if (mtu < ip_rt_min_pmtu)
+        if (mtu < ip_rt_min_pmtu) {
+                lock = true;
                 mtu = ip_rt_min_pmtu;
+        }
 
         if (rt->rt_pmtu == mtu &&
             time_before(jiffies, dst->expires - ip_rt_mtu_expires / 2))
@@ -1027,7 +1035,7 @@ static void __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
         if (fib_lookup(dev_net(dst->dev), fl4, &res, 0) == 0) {
                 struct fib_nh *nh = &FIB_RES_NH(res);
 
-                update_or_create_fnhe(nh, fl4->daddr, 0, mtu,
+                update_or_create_fnhe(nh, fl4->daddr, 0, mtu, lock,
                                       jiffies + ip_rt_mtu_expires);
         }
         rcu_read_unlock();
@@ -1280,7 +1288,7 @@ static unsigned int ipv4_mtu(const struct dst_entry *dst)
 
         mtu = READ_ONCE(dst->dev->mtu);
 
-        if (unlikely(dst_metric_locked(dst, RTAX_MTU))) {
+        if (unlikely(ip_mtu_locked(dst))) {
                 if (rt->rt_uses_gateway && mtu > 576)
                         mtu = 576;
         }
@@ -1393,7 +1401,7 @@ struct uncached_list {
 
 static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt_uncached_list);
 
-static void rt_add_uncached_list(struct rtable *rt)
+void rt_add_uncached_list(struct rtable *rt)
 {
         struct uncached_list *ul = raw_cpu_ptr(&rt_uncached_list);
 
@@ -1404,14 +1412,8 @@ static void rt_add_uncached_list(struct rtable *rt)
         spin_unlock_bh(&ul->lock);
 }
 
-static void ipv4_dst_destroy(struct dst_entry *dst)
+void rt_del_uncached_list(struct rtable *rt)
 {
-        struct dst_metrics *p = (struct dst_metrics *)DST_METRICS_PTR(dst);
-        struct rtable *rt = (struct rtable *) dst;
-
-        if (p != &dst_default_metrics && refcount_dec_and_test(&p->refcnt))
-                kfree(p);
-
         if (!list_empty(&rt->rt_uncached)) {
                 struct uncached_list *ul = rt->rt_uncached_list;
 
@@ -1421,6 +1423,17 @@ static void ipv4_dst_destroy(struct dst_entry *dst)
         }
 }
 
+static void ipv4_dst_destroy(struct dst_entry *dst)
+{
+        struct dst_metrics *p = (struct dst_metrics *)DST_METRICS_PTR(dst);
+        struct rtable *rt = (struct rtable *)dst;
+
+        if (p != &dst_default_metrics && refcount_dec_and_test(&p->refcnt))
+                kfree(p);
+
+        rt_del_uncached_list(rt);
+}
+
 void rt_flush_dev(struct net_device *dev)
 {
         struct net *net = dev_net(dev);
@@ -1516,6 +1529,7 @@ struct rtable *rt_dst_alloc(struct net_device *dev,
                 rt->rt_is_input = 0;
                 rt->rt_iif = 0;
                 rt->rt_pmtu = 0;
+                rt->rt_mtu_locked = 0;
                 rt->rt_gateway = 0;
                 rt->rt_uses_gateway = 0;
                 rt->rt_table_id = 0;
@@ -2541,6 +2555,7 @@ struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_or
                 rt->rt_is_input = ort->rt_is_input;
                 rt->rt_iif = ort->rt_iif;
                 rt->rt_pmtu = ort->rt_pmtu;
+                rt->rt_mtu_locked = ort->rt_mtu_locked;
 
                 rt->rt_genid = rt_genid_ipv4(net);
                 rt->rt_flags = ort->rt_flags;
@@ -2643,6 +2658,8 @@ static int rt_fill_info(struct net *net,  __be32 dst, __be32 src, u32 table_id,
         memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
         if (rt->rt_pmtu && expires)
                 metrics[RTAX_MTU - 1] = rt->rt_pmtu;
+        if (rt->rt_mtu_locked && expires)
+                metrics[RTAX_LOCK - 1] |= BIT(RTAX_MTU);
         if (rtnetlink_put_metrics(skb, metrics) < 0)
                 goto nla_put_failure;
 
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index 48636aee23c3..8b8059b7af4d 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -3566,6 +3566,7 @@ int tcp_abort(struct sock *sk, int err)
 
         bh_unlock_sock(sk);
         local_bh_enable();
+        tcp_write_queue_purge(sk);
         release_sock(sk);
         return 0;
 }
diff --git a/net/ipv4/tcp_timer.c b/net/ipv4/tcp_timer.c
index 71fc60f1b326..f7d944855f8e 100644
--- a/net/ipv4/tcp_timer.c
+++ b/net/ipv4/tcp_timer.c
@@ -34,6 +34,7 @@ static void tcp_write_err(struct sock *sk)
         sk->sk_err = sk->sk_err_soft ? : ETIMEDOUT;
         sk->sk_error_report(sk);
 
+        tcp_write_queue_purge(sk);
         tcp_done(sk);
         __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONTIMEOUT);
 }
diff --git a/net/ipv4/xfrm4_mode_tunnel.c b/net/ipv4/xfrm4_mode_tunnel.c
index 63faeee989a9..2a9764bd1719 100644
--- a/net/ipv4/xfrm4_mode_tunnel.c
+++ b/net/ipv4/xfrm4_mode_tunnel.c
@@ -92,7 +92,8 @@ static int xfrm4_mode_tunnel_input(struct xfrm_state *x, struct sk_buff *skb)
 
         skb_reset_network_header(skb);
         skb_mac_header_rebuild(skb);
-        eth_hdr(skb)->h_proto = skb->protocol;
+        if (skb->mac_len)
+                eth_hdr(skb)->h_proto = skb->protocol;
 
         err = 0;
 
diff --git a/net/ipv4/xfrm4_policy.c b/net/ipv4/xfrm4_policy.c
index 05017e2c849c..fbebda67ac1b 100644
--- a/net/ipv4/xfrm4_policy.c
+++ b/net/ipv4/xfrm4_policy.c
@@ -100,8 +100,10 @@ static int xfrm4_fill_dst(struct xfrm_dst *xdst, struct net_device *dev,
         xdst->u.rt.rt_gateway = rt->rt_gateway;
         xdst->u.rt.rt_uses_gateway = rt->rt_uses_gateway;
         xdst->u.rt.rt_pmtu = rt->rt_pmtu;
+        xdst->u.rt.rt_mtu_locked = rt->rt_mtu_locked;
         xdst->u.rt.rt_table_id = rt->rt_table_id;
         INIT_LIST_HEAD(&xdst->u.rt.rt_uncached);
+        rt_add_uncached_list(&xdst->u.rt);
 
         return 0;
 }
@@ -241,7 +243,8 @@ static void xfrm4_dst_destroy(struct dst_entry *dst)
         struct xfrm_dst *xdst = (struct xfrm_dst *)dst;
 
         dst_destroy_metrics_generic(dst);
-
+        if (xdst->u.rt.rt_uncached_list)
+                rt_del_uncached_list(&xdst->u.rt);
         xfrm_dst_destroy(xdst);
 }
 
diff --git a/net/ipv6/datagram.c b/net/ipv6/datagram.c
index fbf08ce3f5ab..a9f7eca0b6a3 100644
--- a/net/ipv6/datagram.c
+++ b/net/ipv6/datagram.c
@@ -146,10 +146,12 @@ int __ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr,
         struct sockaddr_in6     *usin = (struct sockaddr_in6 *) uaddr;
         struct inet_sock        *inet = inet_sk(sk);
         struct ipv6_pinfo       *np = inet6_sk(sk);
-        struct in6_addr         *daddr;
+        struct in6_addr         *daddr, old_daddr;
+        __be32                  fl6_flowlabel = 0;
+        __be32                  old_fl6_flowlabel;
+        __be16                  old_dport;
         int                     addr_type;
         int                     err;
-        __be32                  fl6_flowlabel = 0;
 
         if (usin->sin6_family == AF_INET) {
                 if (__ipv6_only_sock(sk))
@@ -238,9 +240,13 @@ ipv4_connected:
                 }
         }
 
+        /* save the current peer information before updating it */
+        old_daddr = sk->sk_v6_daddr;
+        old_fl6_flowlabel = np->flow_label;
+        old_dport = inet->inet_dport;
+
         sk->sk_v6_daddr = *daddr;
         np->flow_label = fl6_flowlabel;
-
         inet->inet_dport = usin->sin6_port;
 
         /*
@@ -250,11 +256,12 @@ ipv4_connected:
 
         err = ip6_datagram_dst_update(sk, true);
         if (err) {
-                /* Reset daddr and dport so that udp_v6_early_demux()
-                 * fails to find this socket
+                /* Restore the socket peer info, to keep it consistent with
+                 * the old socket state
                  */
-                memset(&sk->sk_v6_daddr, 0, sizeof(sk->sk_v6_daddr));
-                inet->inet_dport = 0;
+                sk->sk_v6_daddr = old_daddr;
+                np->flow_label = old_fl6_flowlabel;
+                inet->inet_dport = old_dport;
                 goto out;
         }
 
diff --git a/net/ipv6/ip6_gre.c b/net/ipv6/ip6_gre.c
index 3c353125546d..1bbd0930063e 100644
--- a/net/ipv6/ip6_gre.c
+++ b/net/ipv6/ip6_gre.c
@@ -126,7 +126,8 @@ static struct ip6_tnl *ip6gre_tunnel_lookup(struct net_device *dev,
         struct ip6_tnl *t, *cand = NULL;
         struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
         int dev_type = (gre_proto == htons(ETH_P_TEB) ||
-                        gre_proto == htons(ETH_P_ERSPAN)) ?
+                        gre_proto == htons(ETH_P_ERSPAN) ||
+                        gre_proto == htons(ETH_P_ERSPAN2)) ?
                        ARPHRD_ETHER : ARPHRD_IP6GRE;
         int score, cand_score = 4;
 
@@ -902,6 +903,9 @@ static netdev_tx_t ip6erspan_tunnel_xmit(struct sk_buff *skb,
                 truncate = true;
         }
 
+        if (skb_cow_head(skb, dev->needed_headroom))
+                goto tx_err;
+
         t->parms.o_flags &= ~TUNNEL_KEY;
         IPCB(skb)->flags = 0;
 
@@ -944,6 +948,8 @@ static netdev_tx_t ip6erspan_tunnel_xmit(struct sk_buff *skb,
                                                md->u.md2.dir,
                                                get_hwid(&md->u.md2),
                                                truncate, false);
+                } else {
+                        goto tx_err;
                 }
         } else {
                 switch (skb->protocol) {
diff --git a/net/ipv6/ndisc.c b/net/ipv6/ndisc.c
index f61a5b613b52..ba5e04c6ae17 100644
--- a/net/ipv6/ndisc.c
+++ b/net/ipv6/ndisc.c
@@ -1554,7 +1554,8 @@ static void ndisc_fill_redirect_hdr_option(struct sk_buff *skb,
         *(opt++) = (rd_len >> 3);
         opt += 6;
 
-        memcpy(opt, ipv6_hdr(orig_skb), rd_len - 8);
+        skb_copy_bits(orig_skb, skb_network_offset(orig_skb), opt,
+                      rd_len - 8);
 }
 
 void ndisc_send_redirect(struct sk_buff *skb, const struct in6_addr *target)
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index 9dcfadddd800..b0d5c64e1978 100644
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -128,7 +128,7 @@ struct uncached_list {
 
 static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt6_uncached_list);
 
-static void rt6_uncached_list_add(struct rt6_info *rt)
+void rt6_uncached_list_add(struct rt6_info *rt)
 {
         struct uncached_list *ul = raw_cpu_ptr(&rt6_uncached_list);
 
@@ -139,7 +139,7 @@ static void rt6_uncached_list_add(struct rt6_info *rt)
         spin_unlock_bh(&ul->lock);
 }
 
-static void rt6_uncached_list_del(struct rt6_info *rt)
+void rt6_uncached_list_del(struct rt6_info *rt)
 {
         if (!list_empty(&rt->rt6i_uncached)) {
                 struct uncached_list *ul = rt->rt6i_uncached_list;
@@ -1509,7 +1509,30 @@ static void rt6_exceptions_remove_prefsrc(struct rt6_info *rt)
         }
 }
 
-static void rt6_exceptions_update_pmtu(struct rt6_info *rt, int mtu)
+static bool rt6_mtu_change_route_allowed(struct inet6_dev *idev,
+                                         struct rt6_info *rt, int mtu)
+{
+        /* If the new MTU is lower than the route PMTU, this new MTU will be the
+         * lowest MTU in the path: always allow updating the route PMTU to
+         * reflect PMTU decreases.
+         *
+         * If the new MTU is higher, and the route PMTU is equal to the local
+         * MTU, this means the old MTU is the lowest in the path, so allow
+         * updating it: if other nodes now have lower MTUs, PMTU discovery will
+         * handle this.
+         */
+
+        if (dst_mtu(&rt->dst) >= mtu)
+                return true;
+
+        if (dst_mtu(&rt->dst) == idev->cnf.mtu6)
+                return true;
+
+        return false;
+}
+
+static void rt6_exceptions_update_pmtu(struct inet6_dev *idev,
+                                       struct rt6_info *rt, int mtu)
 {
         struct rt6_exception_bucket *bucket;
         struct rt6_exception *rt6_ex;
@@ -1518,20 +1541,22 @@ static void rt6_exceptions_update_pmtu(struct rt6_info *rt, int mtu)
         bucket = rcu_dereference_protected(rt->rt6i_exception_bucket,
                                         lockdep_is_held(&rt6_exception_lock));
 
-        if (bucket) {
-                for (i = 0; i < FIB6_EXCEPTION_BUCKET_SIZE; i++) {
-                        hlist_for_each_entry(rt6_ex, &bucket->chain, hlist) {
-                                struct rt6_info *entry = rt6_ex->rt6i;
-                                /* For RTF_CACHE with rt6i_pmtu == 0
-                                 * (i.e. a redirected route),
-                                 * the metrics of its rt->dst.from has already
-                                 * been updated.
-                                 */
-                                if (entry->rt6i_pmtu && entry->rt6i_pmtu > mtu)
-                                        entry->rt6i_pmtu = mtu;
-                        }
-                        bucket++;
+        if (!bucket)
+                return;
+
+        for (i = 0; i < FIB6_EXCEPTION_BUCKET_SIZE; i++) {
+                hlist_for_each_entry(rt6_ex, &bucket->chain, hlist) {
+                        struct rt6_info *entry = rt6_ex->rt6i;
+
+                        /* For RTF_CACHE with rt6i_pmtu == 0 (i.e. a redirected
+                         * route), the metrics of its rt->dst.from have already
+                         * been updated.
+                         */
+                        if (entry->rt6i_pmtu &&
+                            rt6_mtu_change_route_allowed(idev, entry, mtu))
+                                entry->rt6i_pmtu = mtu;
                 }
+                bucket++;
         }
 }
 
@@ -3809,25 +3834,13 @@ static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
            Since RFC 1981 doesn't include administrative MTU increase
            update PMTU increase is a MUST. (i.e. jumbo frame)
          */
-        /*
-           If new MTU is less than route PMTU, this new MTU will be the
-           lowest MTU in the path, update the route PMTU to reflect PMTU
-           decreases; if new MTU is greater than route PMTU, and the
-           old MTU is the lowest MTU in the path, update the route PMTU
-           to reflect the increase. In this case if the other nodes' MTU
-           also have the lowest MTU, TOO BIG MESSAGE will be lead to
-           PMTU discovery.
-         */
         if (rt->dst.dev == arg->dev &&
-            dst_metric_raw(&rt->dst, RTAX_MTU) &&
             !dst_metric_locked(&rt->dst, RTAX_MTU)) {
                 spin_lock_bh(&rt6_exception_lock);
-                if (dst_mtu(&rt->dst) >= arg->mtu ||
-                    (dst_mtu(&rt->dst) < arg->mtu &&
-                     dst_mtu(&rt->dst) == idev->cnf.mtu6)) {
+                if (dst_metric_raw(&rt->dst, RTAX_MTU) &&
+                    rt6_mtu_change_route_allowed(idev, rt, arg->mtu))
                         dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
-                }
-                rt6_exceptions_update_pmtu(rt, arg->mtu);
+                rt6_exceptions_update_pmtu(idev, rt, arg->mtu);
                 spin_unlock_bh(&rt6_exception_lock);
         }
         return 0;
@@ -4099,6 +4112,7 @@ static int ip6_route_multipath_add(struct fib6_config *cfg,
                                 r_cfg.fc_encap_type = nla_get_u16(nla);
                 }
 
+                r_cfg.fc_flags |= (rtnh->rtnh_flags & RTNH_F_ONLINK);
                 rt = ip6_route_info_create(&r_cfg, extack);
                 if (IS_ERR(rt)) {
                         err = PTR_ERR(rt);
diff --git a/net/ipv6/seg6_iptunnel.c b/net/ipv6/seg6_iptunnel.c
index bd6cc688bd19..7a78dcfda68a 100644
--- a/net/ipv6/seg6_iptunnel.c
+++ b/net/ipv6/seg6_iptunnel.c
@@ -93,7 +93,8 @@ static void set_tun_src(struct net *net, struct net_device *dev,
 /* encapsulate an IPv6 packet within an outer IPv6 header with a given SRH */
 int seg6_do_srh_encap(struct sk_buff *skb, struct ipv6_sr_hdr *osrh, int proto)
 {
-        struct net *net = dev_net(skb_dst(skb)->dev);
+        struct dst_entry *dst = skb_dst(skb);
+        struct net *net = dev_net(dst->dev);
         struct ipv6hdr *hdr, *inner_hdr;
         struct ipv6_sr_hdr *isrh;
         int hdrlen, tot_len, err;
@@ -134,7 +135,7 @@ int seg6_do_srh_encap(struct sk_buff *skb, struct ipv6_sr_hdr *osrh, int proto)
         isrh->nexthdr = proto;
 
         hdr->daddr = isrh->segments[isrh->first_segment];
-        set_tun_src(net, skb->dev, &hdr->daddr, &hdr->saddr);
+        set_tun_src(net, ip6_dst_idev(dst)->dev, &hdr->daddr, &hdr->saddr);
 
 #ifdef CONFIG_IPV6_SEG6_HMAC
         if (sr_has_hmac(isrh)) {
@@ -418,7 +419,7 @@ static int seg6_build_state(struct nlattr *nla,
 
         slwt = seg6_lwt_lwtunnel(newts);
 
-        err = dst_cache_init(&slwt->cache, GFP_KERNEL);
+        err = dst_cache_init(&slwt->cache, GFP_ATOMIC);
         if (err) {
                 kfree(newts);
                 return err;
diff --git a/net/ipv6/xfrm6_mode_tunnel.c b/net/ipv6/xfrm6_mode_tunnel.c
index bb935a3b7fea..de1b0b8c53b0 100644
--- a/net/ipv6/xfrm6_mode_tunnel.c
+++ b/net/ipv6/xfrm6_mode_tunnel.c
@@ -92,7 +92,8 @@ static int xfrm6_mode_tunnel_input(struct xfrm_state *x, struct sk_buff *skb)
 
         skb_reset_network_header(skb);
         skb_mac_header_rebuild(skb);
-        eth_hdr(skb)->h_proto = skb->protocol;
+        if (skb->mac_len)
+                eth_hdr(skb)->h_proto = skb->protocol;
 
         err = 0;
 
diff --git a/net/ipv6/xfrm6_policy.c b/net/ipv6/xfrm6_policy.c
index 09fb44ee3b45..416fe67271a9 100644
--- a/net/ipv6/xfrm6_policy.c
+++ b/net/ipv6/xfrm6_policy.c
@@ -113,6 +113,9 @@ static int xfrm6_fill_dst(struct xfrm_dst *xdst, struct net_device *dev,
         xdst->u.rt6.rt6i_gateway = rt->rt6i_gateway;
         xdst->u.rt6.rt6i_dst = rt->rt6i_dst;
         xdst->u.rt6.rt6i_src = rt->rt6i_src;
+        INIT_LIST_HEAD(&xdst->u.rt6.rt6i_uncached);
+        rt6_uncached_list_add(&xdst->u.rt6);
+        atomic_inc(&dev_net(dev)->ipv6.rt6_stats->fib_rt_uncache);
 
         return 0;
 }
@@ -244,6 +247,8 @@ static void xfrm6_dst_destroy(struct dst_entry *dst)
         if (likely(xdst->u.rt6.rt6i_idev))
                 in6_dev_put(xdst->u.rt6.rt6i_idev);
         dst_destroy_metrics_generic(dst);
+        if (xdst->u.rt6.rt6i_uncached_list)
+                rt6_uncached_list_del(&xdst->u.rt6);
         xfrm_dst_destroy(xdst);
 }
 
diff --git a/net/iucv/af_iucv.c b/net/iucv/af_iucv.c
index 1e8cc7bcbca3..9e2643ab4ccb 100644
--- a/net/iucv/af_iucv.c
+++ b/net/iucv/af_iucv.c
@@ -2433,9 +2433,11 @@ static int afiucv_iucv_init(void)
         af_iucv_dev->driver = &af_iucv_driver;
         err = device_register(af_iucv_dev);
         if (err)
-                goto out_driver;
+                goto out_iucv_dev;
         return 0;
 
+out_iucv_dev:
+        put_device(af_iucv_dev);
 out_driver:
         driver_unregister(&af_iucv_driver);
 out_iucv:
diff --git a/net/kcm/kcmsock.c b/net/kcm/kcmsock.c
index f297d53a11aa..34355fd19f27 100644
--- a/net/kcm/kcmsock.c
+++ b/net/kcm/kcmsock.c
@@ -1381,24 +1381,32 @@ static int kcm_attach(struct socket *sock, struct socket *csock,
                 .parse_msg = kcm_parse_func_strparser,
                 .read_sock_done = kcm_read_sock_done,
         };
-        int err;
+        int err = 0;
 
         csk = csock->sk;
         if (!csk)
                 return -EINVAL;
 
+        lock_sock(csk);
+
         /* Only allow TCP sockets to be attached for now */
         if ((csk->sk_family != AF_INET && csk->sk_family != AF_INET6) ||
-            csk->sk_protocol != IPPROTO_TCP)
-                return -EOPNOTSUPP;
+            csk->sk_protocol != IPPROTO_TCP) {
+                err = -EOPNOTSUPP;
+                goto out;
+        }
 
         /* Don't allow listeners or closed sockets */
-        if (csk->sk_state == TCP_LISTEN || csk->sk_state == TCP_CLOSE)
-                return -EOPNOTSUPP;
+        if (csk->sk_state == TCP_LISTEN || csk->sk_state == TCP_CLOSE) {
+                err = -EOPNOTSUPP;
+                goto out;
+        }
 
         psock = kmem_cache_zalloc(kcm_psockp, GFP_KERNEL);
-        if (!psock)
-                return -ENOMEM;
+        if (!psock) {
+                err = -ENOMEM;
+                goto out;
+        }
 
         psock->mux = mux;
         psock->sk = csk;
@@ -1407,7 +1415,7 @@ static int kcm_attach(struct socket *sock, struct socket *csock,
         err = strp_init(&psock->strp, csk, &cb);
         if (err) {
                 kmem_cache_free(kcm_psockp, psock);
-                return err;
+                goto out;
         }
 
         write_lock_bh(&csk->sk_callback_lock);
@@ -1419,7 +1427,8 @@ static int kcm_attach(struct socket *sock, struct socket *csock,
                 write_unlock_bh(&csk->sk_callback_lock);
                 strp_done(&psock->strp);
                 kmem_cache_free(kcm_psockp, psock);
-                return -EALREADY;
+                err = -EALREADY;
+                goto out;
         }
 
         psock->save_data_ready = csk->sk_data_ready;
@@ -1455,7 +1464,10 @@ static int kcm_attach(struct socket *sock, struct socket *csock,
         /* Schedule RX work in case there are already bytes queued */
         strp_check_rcv(&psock->strp);
 
-        return 0;
+out:
+        release_sock(csk);
+
+        return err;
 }
 
 static int kcm_attach_ioctl(struct socket *sock, struct kcm_attach *info)
@@ -1507,6 +1519,7 @@ static void kcm_unattach(struct kcm_psock *psock)
 
         if (WARN_ON(psock->rx_kcm)) {
                 write_unlock_bh(&csk->sk_callback_lock);
+                release_sock(csk);
                 return;
         }
 
diff --git a/net/l2tp/l2tp_core.c b/net/l2tp/l2tp_core.c
index 83421c6f0bef..14b67dfacc4b 100644
--- a/net/l2tp/l2tp_core.c
+++ b/net/l2tp/l2tp_core.c
@@ -111,6 +111,13 @@ struct l2tp_net {
         spinlock_t l2tp_session_hlist_lock;
 };
 
+#if IS_ENABLED(CONFIG_IPV6)
+static bool l2tp_sk_is_v6(struct sock *sk)
+{
+        return sk->sk_family == PF_INET6 &&
+               !ipv6_addr_v4mapped(&sk->sk_v6_daddr);
+}
+#endif
 
 static inline struct l2tp_tunnel *l2tp_tunnel(struct sock *sk)
 {
@@ -1049,7 +1056,7 @@ static int l2tp_xmit_core(struct l2tp_session *session, struct sk_buff *skb,
         /* Queue the packet to IP for output */
         skb->ignore_df = 1;
 #if IS_ENABLED(CONFIG_IPV6)
-        if (tunnel->sock->sk_family == PF_INET6 && !tunnel->v4mapped)
+        if (l2tp_sk_is_v6(tunnel->sock))
                 error = inet6_csk_xmit(tunnel->sock, skb, NULL);
         else
 #endif
@@ -1112,6 +1119,15 @@ int l2tp_xmit_skb(struct l2tp_session *session, struct sk_buff *skb, int hdr_len
                 goto out_unlock;
         }
 
+        /* The user-space may change the connection status for the user-space
+         * provided socket at run time: we must check it under the socket lock
+         */
+        if (tunnel->fd >= 0 && sk->sk_state != TCP_ESTABLISHED) {
+                kfree_skb(skb);
+                ret = NET_XMIT_DROP;
+                goto out_unlock;
+        }
+
         /* Get routing info from the tunnel socket */
         skb_dst_drop(skb);
         skb_dst_set(skb, dst_clone(__sk_dst_check(sk, 0)));
@@ -1131,7 +1147,7 @@ int l2tp_xmit_skb(struct l2tp_session *session, struct sk_buff *skb, int hdr_len
 
                 /* Calculate UDP checksum if configured to do so */
 #if IS_ENABLED(CONFIG_IPV6)
-                if (sk->sk_family == PF_INET6 && !tunnel->v4mapped)
+                if (l2tp_sk_is_v6(sk))
                         udp6_set_csum(udp_get_no_check6_tx(sk),
                                       skb, &inet6_sk(sk)->saddr,
                                       &sk->sk_v6_daddr, udp_len);
@@ -1457,9 +1473,14 @@ int l2tp_tunnel_create(struct net *net, int fd, int version, u32 tunnel_id, u32
                 encap = cfg->encap;
 
         /* Quick sanity checks */
+        err = -EPROTONOSUPPORT;
+        if (sk->sk_type != SOCK_DGRAM) {
+                pr_debug("tunl %hu: fd %d wrong socket type\n",
+                         tunnel_id, fd);
+                goto err;
+        }
         switch (encap) {
         case L2TP_ENCAPTYPE_UDP:
-                err = -EPROTONOSUPPORT;
                 if (sk->sk_protocol != IPPROTO_UDP) {
                         pr_err("tunl %hu: fd %d wrong protocol, got %d, expected %d\n",
                                tunnel_id, fd, sk->sk_protocol, IPPROTO_UDP);
@@ -1467,7 +1488,6 @@ int l2tp_tunnel_create(struct net *net, int fd, int version, u32 tunnel_id, u32
                 }
                 break;
         case L2TP_ENCAPTYPE_IP:
-                err = -EPROTONOSUPPORT;
                 if (sk->sk_protocol != IPPROTO_L2TP) {
                         pr_err("tunl %hu: fd %d wrong protocol, got %d, expected %d\n",
                                tunnel_id, fd, sk->sk_protocol, IPPROTO_L2TP);
@@ -1507,24 +1527,6 @@ int l2tp_tunnel_create(struct net *net, int fd, int version, u32 tunnel_id, u32
         if (cfg != NULL)
                 tunnel->debug = cfg->debug;
 
-#if IS_ENABLED(CONFIG_IPV6)
-        if (sk->sk_family == PF_INET6) {
-                struct ipv6_pinfo *np = inet6_sk(sk);
-
-                if (ipv6_addr_v4mapped(&np->saddr) &&
-                    ipv6_addr_v4mapped(&sk->sk_v6_daddr)) {
-                        struct inet_sock *inet = inet_sk(sk);
-
-                        tunnel->v4mapped = true;
-                        inet->inet_saddr = np->saddr.s6_addr32[3];
-                        inet->inet_rcv_saddr = sk->sk_v6_rcv_saddr.s6_addr32[3];
-                        inet->inet_daddr = sk->sk_v6_daddr.s6_addr32[3];
-                } else {
-                        tunnel->v4mapped = false;
-                }
-        }
-#endif
-
         /* Mark socket as an encapsulation socket. See net/ipv4/udp.c */
         tunnel->encap = encap;
         if (encap == L2TP_ENCAPTYPE_UDP) {
diff --git a/net/l2tp/l2tp_core.h b/net/l2tp/l2tp_core.h
index a1aa9550f04e..2718d0b284d0 100644
--- a/net/l2tp/l2tp_core.h
+++ b/net/l2tp/l2tp_core.h
@@ -188,9 +188,6 @@ struct l2tp_tunnel {
         struct sock             *sock;          /* Parent socket */
         int                     fd;             /* Parent fd, if tunnel socket
                                                  * was created by userspace */
-#if IS_ENABLED(CONFIG_IPV6)
-        bool                    v4mapped;
-#endif
 
         struct work_struct      del_work;
 
diff --git a/net/mac80211/debugfs.c b/net/mac80211/debugfs.c
index 1f466d12a6bc..94c7ee9df33b 100644
--- a/net/mac80211/debugfs.c
+++ b/net/mac80211/debugfs.c
@@ -212,6 +212,7 @@ static const char *hw_flag_names[] = {
         FLAG(REPORTS_LOW_ACK),
         FLAG(SUPPORTS_TX_FRAG),
         FLAG(SUPPORTS_TDLS_BUFFER_STA),
+        FLAG(DOESNT_SUPPORT_QOS_NDP),
 #undef FLAG
 };
 
diff --git a/net/mac80211/mlme.c b/net/mac80211/mlme.c
index 39b660b9a908..5f303abac5ad 100644
--- a/net/mac80211/mlme.c
+++ b/net/mac80211/mlme.c
@@ -896,7 +896,8 @@ void ieee80211_send_nullfunc(struct ieee80211_local *local,
         struct ieee80211_hdr_3addr *nullfunc;
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 
-        skb = ieee80211_nullfunc_get(&local->hw, &sdata->vif, true);
+        skb = ieee80211_nullfunc_get(&local->hw, &sdata->vif,
+                !ieee80211_hw_check(&local->hw, DOESNT_SUPPORT_QOS_NDP));
         if (!skb)
                 return;
 
diff --git a/net/netfilter/nf_tables_api.c b/net/netfilter/nf_tables_api.c
index 558593e6a0a3..c4acc7340eb1 100644
--- a/net/netfilter/nf_tables_api.c
+++ b/net/netfilter/nf_tables_api.c
@@ -5423,6 +5423,7 @@ err:
 static void nf_tables_flowtable_destroy(struct nft_flowtable *flowtable)
 {
         cancel_delayed_work_sync(&flowtable->data.gc_work);
+        kfree(flowtable->ops);
         kfree(flowtable->name);
         flowtable->data.type->free(&flowtable->data);
         rhashtable_destroy(&flowtable->data.rhashtable);
diff --git a/net/netfilter/nft_set_hash.c b/net/netfilter/nft_set_hash.c
index 3f1624ee056f..d40591fe1b2f 100644
--- a/net/netfilter/nft_set_hash.c
+++ b/net/netfilter/nft_set_hash.c
@@ -674,7 +674,7 @@ static const struct nft_set_ops *
 nft_hash_select_ops(const struct nft_ctx *ctx, const struct nft_set_desc *desc,
                     u32 flags)
 {
-        if (desc->size) {
+        if (desc->size && !(flags & NFT_SET_TIMEOUT)) {
                 switch (desc->klen) {
                 case 4:
                         return &nft_hash_fast_ops;
diff --git a/net/netfilter/x_tables.c b/net/netfilter/x_tables.c
index fa1655aff8d3..4aa01c90e9d1 100644
--- a/net/netfilter/x_tables.c
+++ b/net/netfilter/x_tables.c
@@ -423,6 +423,36 @@ textify_hooks(char *buf, size_t size, unsigned int mask, uint8_t nfproto)
         return buf;
 }
 
+/**
+ * xt_check_proc_name - check that name is suitable for /proc file creation
+ *
+ * @name: file name candidate
+ * @size: length of buffer
+ *
+ * some x_tables modules wish to create a file in /proc.
+ * This function makes sure that the name is suitable for this
+ * purpose, it checks that name is NUL terminated and isn't a 'special'
+ * name, like "..".
+ *
+ * returns negative number on error or 0 if name is useable.
+ */
+int xt_check_proc_name(const char *name, unsigned int size)
+{
+        if (name[0] == '\0')
+                return -EINVAL;
+
+        if (strnlen(name, size) == size)
+                return -ENAMETOOLONG;
+
+        if (strcmp(name, ".") == 0 ||
+            strcmp(name, "..") == 0 ||
+            strchr(name, '/'))
+                return -EINVAL;
+
+        return 0;
+}
+EXPORT_SYMBOL(xt_check_proc_name);
+
 int xt_check_match(struct xt_mtchk_param *par,
                    unsigned int size, u_int8_t proto, bool inv_proto)
 {
diff --git a/net/netfilter/xt_hashlimit.c b/net/netfilter/xt_hashlimit.c
index 66f5aca62a08..3360f13dc208 100644
--- a/net/netfilter/xt_hashlimit.c
+++ b/net/netfilter/xt_hashlimit.c
@@ -917,8 +917,9 @@ static int hashlimit_mt_check_v1(const struct xt_mtchk_param *par)
         struct hashlimit_cfg3 cfg = {};
         int ret;
 
-        if (info->name[sizeof(info->name) - 1] != '\0')
-                return -EINVAL;
+        ret = xt_check_proc_name(info->name, sizeof(info->name));
+        if (ret)
+                return ret;
 
         ret = cfg_copy(&cfg, (void *)&info->cfg, 1);
 
@@ -935,8 +936,9 @@ static int hashlimit_mt_check_v2(const struct xt_mtchk_param *par)
         struct hashlimit_cfg3 cfg = {};
         int ret;
 
-        if (info->name[sizeof(info->name) - 1] != '\0')
-                return -EINVAL;
+        ret = xt_check_proc_name(info->name, sizeof(info->name));
+        if (ret)
+                return ret;
 
         ret = cfg_copy(&cfg, (void *)&info->cfg, 2);
 
@@ -950,9 +952,11 @@ static int hashlimit_mt_check_v2(const struct xt_mtchk_param *par)
 static int hashlimit_mt_check(const struct xt_mtchk_param *par)
 {
         struct xt_hashlimit_mtinfo3 *info = par->matchinfo;
+        int ret;
 
-        if (info->name[sizeof(info->name) - 1] != '\0')
-                return -EINVAL;
+        ret = xt_check_proc_name(info->name, sizeof(info->name));
+        if (ret)
+                return ret;
 
         return hashlimit_mt_check_common(par, &info->hinfo, &info->cfg,
                                          info->name, 3);
diff --git a/net/netfilter/xt_recent.c b/net/netfilter/xt_recent.c
index 6d232d18faff..81ee1d6543b2 100644
--- a/net/netfilter/xt_recent.c
+++ b/net/netfilter/xt_recent.c
@@ -361,9 +361,9 @@ static int recent_mt_check(const struct xt_mtchk_param *par,
                                     info->hit_count, XT_RECENT_MAX_NSTAMPS - 1);
                 return -EINVAL;
         }
-        if (info->name[0] == '\0' ||
-            strnlen(info->name, XT_RECENT_NAME_LEN) == XT_RECENT_NAME_LEN)
-                return -EINVAL;
+        ret = xt_check_proc_name(info->name, sizeof(info->name));
+        if (ret)
+                return ret;
 
         if (ip_pkt_list_tot && info->hit_count < ip_pkt_list_tot)
                 nstamp_mask = roundup_pow_of_two(ip_pkt_list_tot) - 1;
diff --git a/net/netlink/genetlink.c b/net/netlink/genetlink.c
index 6f02499ef007..b9ce82c9440f 100644
--- a/net/netlink/genetlink.c
+++ b/net/netlink/genetlink.c
@@ -1106,7 +1106,7 @@ static int genlmsg_mcast(struct sk_buff *skb, u32 portid, unsigned long group,
         if (!err)
                 delivered = true;
         else if (err != -ESRCH)
-                goto error;
+                return err;
         return delivered ? 0 : -ESRCH;
  error:
         kfree_skb(skb);
diff --git a/net/openvswitch/meter.c b/net/openvswitch/meter.c
index 04b94281a30b..b891a91577f8 100644
--- a/net/openvswitch/meter.c
+++ b/net/openvswitch/meter.c
@@ -242,14 +242,20 @@ static struct dp_meter *dp_meter_create(struct nlattr **a)
 
                 band->type = nla_get_u32(attr[OVS_BAND_ATTR_TYPE]);
                 band->rate = nla_get_u32(attr[OVS_BAND_ATTR_RATE]);
+                if (band->rate == 0) {
+                        err = -EINVAL;
+                        goto exit_free_meter;
+                }
+
                 band->burst_size = nla_get_u32(attr[OVS_BAND_ATTR_BURST]);
                 /* Figure out max delta_t that is enough to fill any bucket.
                  * Keep max_delta_t size to the bucket units:
                  * pkts => 1/1000 packets, kilobits => bits.
+                 *
+                 * Start with a full bucket.
                  */
-                band_max_delta_t = (band->burst_size + band->rate) * 1000;
-                /* Start with a full bucket. */
-                band->bucket = band_max_delta_t;
+                band->bucket = (band->burst_size + band->rate) * 1000;
+                band_max_delta_t = band->bucket / band->rate;
                 if (band_max_delta_t > meter->max_delta_t)
                         meter->max_delta_t = band_max_delta_t;
                 band++;
diff --git a/net/sched/act_bpf.c b/net/sched/act_bpf.c
index b3f2c15affa7..9d2cabf1dc7e 100644
--- a/net/sched/act_bpf.c
+++ b/net/sched/act_bpf.c
@@ -352,7 +352,7 @@ static int tcf_bpf_init(struct net *net, struct nlattr *nla,
         return res;
 out:
         if (res == ACT_P_CREATED)
-                tcf_idr_cleanup(*act, est);
+                tcf_idr_release(*act, bind);
 
         return ret;
 }
diff --git a/net/sched/act_csum.c b/net/sched/act_csum.c
index b7ba9b06b147..2a5c8fd860cf 100644
--- a/net/sched/act_csum.c
+++ b/net/sched/act_csum.c
@@ -350,7 +350,7 @@ static int tcf_csum_sctp(struct sk_buff *skb, unsigned int ihl,
 {
         struct sctphdr *sctph;
 
-        if (skb_is_gso(skb) && skb_shinfo(skb)->gso_type & SKB_GSO_SCTP)
+        if (skb_is_gso(skb) && skb_is_gso_sctp(skb))
                 return 1;
 
         sctph = tcf_csum_skb_nextlayer(skb, ihl, ipl, sizeof(*sctph));
@@ -626,7 +626,8 @@ static void tcf_csum_cleanup(struct tc_action *a)
         struct tcf_csum_params *params;
 
         params = rcu_dereference_protected(p->params, 1);
-        kfree_rcu(params, rcu);
+        if (params)
+                kfree_rcu(params, rcu);
 }
 
 static int tcf_csum_walker(struct net *net, struct sk_buff *skb,
diff --git a/net/sched/act_ipt.c b/net/sched/act_ipt.c
index 06e380ae0928..7e06b9b62613 100644
--- a/net/sched/act_ipt.c
+++ b/net/sched/act_ipt.c
@@ -80,9 +80,12 @@ static void ipt_destroy_target(struct xt_entry_target *t)
 static void tcf_ipt_release(struct tc_action *a)
 {
         struct tcf_ipt *ipt = to_ipt(a);
-        ipt_destroy_target(ipt->tcfi_t);
+
+        if (ipt->tcfi_t) {
+                ipt_destroy_target(ipt->tcfi_t);
+                kfree(ipt->tcfi_t);
+        }
         kfree(ipt->tcfi_tname);
-        kfree(ipt->tcfi_t);
 }
 
 static const struct nla_policy ipt_policy[TCA_IPT_MAX + 1] = {
@@ -187,7 +190,7 @@ err2:
         kfree(tname);
 err1:
         if (ret == ACT_P_CREATED)
-                tcf_idr_cleanup(*a, est);
+                tcf_idr_release(*a, bind);
         return err;
 }
 
diff --git a/net/sched/act_pedit.c b/net/sched/act_pedit.c
index 349beaffb29e..fef08835f26d 100644
--- a/net/sched/act_pedit.c
+++ b/net/sched/act_pedit.c
@@ -176,7 +176,7 @@ static int tcf_pedit_init(struct net *net, struct nlattr *nla,
                 p = to_pedit(*a);
                 keys = kmalloc(ksize, GFP_KERNEL);
                 if (keys == NULL) {
-                        tcf_idr_cleanup(*a, est);
+                        tcf_idr_release(*a, bind);
                         kfree(keys_ex);
                         return -ENOMEM;
                 }
diff --git a/net/sched/act_police.c b/net/sched/act_police.c
index 95d3c9097b25..faebf82b99f1 100644
--- a/net/sched/act_police.c
+++ b/net/sched/act_police.c
@@ -194,7 +194,7 @@ failure:
         qdisc_put_rtab(P_tab);
         qdisc_put_rtab(R_tab);
         if (ret == ACT_P_CREATED)
-                tcf_idr_cleanup(*a, est);
+                tcf_idr_release(*a, bind);
         return err;
 }
 
diff --git a/net/sched/act_sample.c b/net/sched/act_sample.c
index 1ba0df238756..74c5d7e6a0fa 100644
--- a/net/sched/act_sample.c
+++ b/net/sched/act_sample.c
@@ -103,7 +103,8 @@ static void tcf_sample_cleanup(struct tc_action *a)
 
         psample_group = rtnl_dereference(s->psample_group);
         RCU_INIT_POINTER(s->psample_group, NULL);
-        psample_group_put(psample_group);
+        if (psample_group)
+                psample_group_put(psample_group);
 }
 
 static bool tcf_sample_dev_ok_push(struct net_device *dev)
diff --git a/net/sched/act_simple.c b/net/sched/act_simple.c
index 425eac11f6da..b1f38063ada0 100644
--- a/net/sched/act_simple.c
+++ b/net/sched/act_simple.c
@@ -121,7 +121,7 @@ static int tcf_simp_init(struct net *net, struct nlattr *nla,
                 d = to_defact(*a);
                 ret = alloc_defdata(d, defdata);
                 if (ret < 0) {
-                        tcf_idr_cleanup(*a, est);
+                        tcf_idr_release(*a, bind);
                         return ret;
                 }
                 d->tcf_action = parm->action;
diff --git a/net/sched/act_skbmod.c b/net/sched/act_skbmod.c
index fa975262dbac..7b0700f52b50 100644
--- a/net/sched/act_skbmod.c
+++ b/net/sched/act_skbmod.c
@@ -152,7 +152,7 @@ static int tcf_skbmod_init(struct net *net, struct nlattr *nla,
         ASSERT_RTNL();
         p = kzalloc(sizeof(struct tcf_skbmod_params), GFP_KERNEL);
         if (unlikely(!p)) {
-                if (ovr)
+                if (ret == ACT_P_CREATED)
                         tcf_idr_release(*a, bind);
                 return -ENOMEM;
         }
@@ -190,7 +190,8 @@ static void tcf_skbmod_cleanup(struct tc_action *a)
         struct tcf_skbmod_params  *p;
 
         p = rcu_dereference_protected(d->skbmod_p, 1);
-        kfree_rcu(p, rcu);
+        if (p)
+                kfree_rcu(p, rcu);
 }
 
 static int tcf_skbmod_dump(struct sk_buff *skb, struct tc_action *a,
diff --git a/net/sched/act_tunnel_key.c b/net/sched/act_tunnel_key.c
index 0e23aac09ad6..1281ca463727 100644
--- a/net/sched/act_tunnel_key.c
+++ b/net/sched/act_tunnel_key.c
@@ -153,6 +153,7 @@ static int tunnel_key_init(struct net *net, struct nlattr *nla,
                 metadata->u.tun_info.mode |= IP_TUNNEL_INFO_TX;
                 break;
         default:
+                ret = -EINVAL;
                 goto err_out;
         }
 
@@ -207,11 +208,12 @@ static void tunnel_key_release(struct tc_action *a)
         struct tcf_tunnel_key_params *params;
 
         params = rcu_dereference_protected(t->params, 1);
+        if (params) {
+                if (params->tcft_action == TCA_TUNNEL_KEY_ACT_SET)
+                        dst_release(&params->tcft_enc_metadata->dst);
 
-        if (params->tcft_action == TCA_TUNNEL_KEY_ACT_SET)
-                dst_release(&params->tcft_enc_metadata->dst);
-
-        kfree_rcu(params, rcu);
+                kfree_rcu(params, rcu);
+        }
 }
 
 static int tunnel_key_dump_addresses(struct sk_buff *skb,
diff --git a/net/sched/act_vlan.c b/net/sched/act_vlan.c
index e1a1b3f3983a..c49cb61adedf 100644
--- a/net/sched/act_vlan.c
+++ b/net/sched/act_vlan.c
@@ -195,7 +195,7 @@ static int tcf_vlan_init(struct net *net, struct nlattr *nla,
         ASSERT_RTNL();
         p = kzalloc(sizeof(*p), GFP_KERNEL);
         if (!p) {
-                if (ovr)
+                if (ret == ACT_P_CREATED)
                         tcf_idr_release(*a, bind);
                 return -ENOMEM;
         }
@@ -225,7 +225,8 @@ static void tcf_vlan_cleanup(struct tc_action *a)
         struct tcf_vlan_params *p;
 
         p = rcu_dereference_protected(v->vlan_p, 1);
-        kfree_rcu(p, rcu);
+        if (p)
+                kfree_rcu(p, rcu);
 }
 
 static int tcf_vlan_dump(struct sk_buff *skb, struct tc_action *a,
diff --git a/net/sched/sch_generic.c b/net/sched/sch_generic.c
index 190570f21b20..7e3fbe9cc936 100644
--- a/net/sched/sch_generic.c
+++ b/net/sched/sch_generic.c
@@ -106,6 +106,14 @@ static inline void qdisc_enqueue_skb_bad_txq(struct Qdisc *q,
 
         __skb_queue_tail(&q->skb_bad_txq, skb);
 
+        if (qdisc_is_percpu_stats(q)) {
+                qdisc_qstats_cpu_backlog_inc(q, skb);
+                qdisc_qstats_cpu_qlen_inc(q);
+        } else {
+                qdisc_qstats_backlog_inc(q, skb);
+                q->q.qlen++;
+        }
+
         if (lock)
                 spin_unlock(lock);
 }
@@ -196,14 +204,6 @@ static void try_bulk_dequeue_skb_slow(struct Qdisc *q,
                         break;
                 if (unlikely(skb_get_queue_mapping(nskb) != mapping)) {
                         qdisc_enqueue_skb_bad_txq(q, nskb);
-
-                        if (qdisc_is_percpu_stats(q)) {
-                                qdisc_qstats_cpu_backlog_inc(q, nskb);
-                                qdisc_qstats_cpu_qlen_inc(q);
-                        } else {
-                                qdisc_qstats_backlog_inc(q, nskb);
-                                q->q.qlen++;
-                        }
                         break;
                 }
                 skb->next = nskb;
@@ -628,6 +628,7 @@ static int pfifo_fast_enqueue(struct sk_buff *skb, struct Qdisc *qdisc,
         int band = prio2band[skb->priority & TC_PRIO_MAX];
         struct pfifo_fast_priv *priv = qdisc_priv(qdisc);
         struct skb_array *q = band2list(priv, band);
+        unsigned int pkt_len = qdisc_pkt_len(skb);
         int err;
 
         err = skb_array_produce(q, skb);
@@ -636,7 +637,10 @@ static int pfifo_fast_enqueue(struct sk_buff *skb, struct Qdisc *qdisc,
                 return qdisc_drop_cpu(skb, qdisc, to_free);
 
         qdisc_qstats_cpu_qlen_inc(qdisc);
-        qdisc_qstats_cpu_backlog_inc(qdisc, skb);
+        /* Note: skb can not be used after skb_array_produce(),
+         * so we better not use qdisc_qstats_cpu_backlog_inc()
+         */
+        this_cpu_add(qdisc->cpu_qstats->backlog, pkt_len);
         return NET_XMIT_SUCCESS;
 }
 
diff --git a/net/sched/sch_netem.c b/net/sched/sch_netem.c
index 7c179addebcd..7d6801fc5340 100644
--- a/net/sched/sch_netem.c
+++ b/net/sched/sch_netem.c
@@ -509,7 +509,7 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch,
         }
 
         if (unlikely(sch->q.qlen >= sch->limit))
-                return qdisc_drop(skb, sch, to_free);
+                return qdisc_drop_all(skb, sch, to_free);
 
         qdisc_qstats_backlog_inc(sch, skb);
 
diff --git a/net/sctp/input.c b/net/sctp/input.c
index 0247cc432e02..b381d78548ac 100644
--- a/net/sctp/input.c
+++ b/net/sctp/input.c
@@ -106,6 +106,7 @@ int sctp_rcv(struct sk_buff *skb)
         int family;
         struct sctp_af *af;
         struct net *net = dev_net(skb->dev);
+        bool is_gso = skb_is_gso(skb) && skb_is_gso_sctp(skb);
 
         if (skb->pkt_type != PACKET_HOST)
                 goto discard_it;
@@ -123,8 +124,7 @@ int sctp_rcv(struct sk_buff *skb)
          * it's better to just linearize it otherwise crc computing
          * takes longer.
          */
-        if ((!(skb_shinfo(skb)->gso_type & SKB_GSO_SCTP) &&
-             skb_linearize(skb)) ||
+        if ((!is_gso && skb_linearize(skb)) ||
             !pskb_may_pull(skb, sizeof(struct sctphdr)))
                 goto discard_it;
 
@@ -135,7 +135,7 @@ int sctp_rcv(struct sk_buff *skb)
         if (skb_csum_unnecessary(skb))
                 __skb_decr_checksum_unnecessary(skb);
         else if (!sctp_checksum_disable &&
-                 !(skb_shinfo(skb)->gso_type & SKB_GSO_SCTP) &&
+                 !is_gso &&
                  sctp_rcv_checksum(net, skb) < 0)
                 goto discard_it;
         skb->csum_valid = 1;
@@ -1218,7 +1218,7 @@ static struct sctp_association *__sctp_rcv_lookup_harder(struct net *net,
          * issue as packets hitting this are mostly INIT or INIT-ACK and
          * those cannot be on GSO-style anyway.
          */
-        if ((skb_shinfo(skb)->gso_type & SKB_GSO_SCTP) == SKB_GSO_SCTP)
+        if (skb_is_gso(skb) && skb_is_gso_sctp(skb))
                 return NULL;
 
         ch = (struct sctp_chunkhdr *)skb->data;
diff --git a/net/sctp/inqueue.c b/net/sctp/inqueue.c
index 48392552ee7c..23ebc5318edc 100644
--- a/net/sctp/inqueue.c
+++ b/net/sctp/inqueue.c
@@ -170,7 +170,7 @@ next_chunk:
 
                 chunk = list_entry(entry, struct sctp_chunk, list);
 
-                if ((skb_shinfo(chunk->skb)->gso_type & SKB_GSO_SCTP) == SKB_GSO_SCTP) {
+                if (skb_is_gso(chunk->skb) && skb_is_gso_sctp(chunk->skb)) {
                         /* GSO-marked skbs but without frags, handle
                          * them normally
                          */
diff --git a/net/sctp/offload.c b/net/sctp/offload.c
index 35bc7106d182..123e9f2dc226 100644
--- a/net/sctp/offload.c
+++ b/net/sctp/offload.c
@@ -45,7 +45,7 @@ static struct sk_buff *sctp_gso_segment(struct sk_buff *skb,
         struct sk_buff *segs = ERR_PTR(-EINVAL);
         struct sctphdr *sh;
 
-        if (!(skb_shinfo(skb)->gso_type & SKB_GSO_SCTP))
+        if (!skb_is_gso_sctp(skb))
                 goto out;
 
         sh = sctp_hdr(skb);
diff --git a/net/smc/af_smc.c b/net/smc/af_smc.c
index 8cc97834d4f6..1e0d780855c3 100644
--- a/net/smc/af_smc.c
+++ b/net/smc/af_smc.c
@@ -978,10 +978,6 @@ out:
                 lsmc->clcsock = NULL;
         }
         release_sock(lsk);
-        /* no more listening, wake up smc_close_wait_listen_clcsock and
-         * accept
-         */
-        lsk->sk_state_change(lsk);
         sock_put(&lsmc->sk); /* sock_hold in smc_listen */
 }
 
diff --git a/net/smc/smc_close.c b/net/smc/smc_close.c
index e339c0186dcf..fa41d9881741 100644
--- a/net/smc/smc_close.c
+++ b/net/smc/smc_close.c
@@ -30,27 +30,6 @@ static void smc_close_cleanup_listen(struct sock *parent)
                 smc_close_non_accepted(sk);
 }
 
-static void smc_close_wait_listen_clcsock(struct smc_sock *smc)
-{
-        DEFINE_WAIT_FUNC(wait, woken_wake_function);
-        struct sock *sk = &smc->sk;
-        signed long timeout;
-
-        timeout = SMC_CLOSE_WAIT_LISTEN_CLCSOCK_TIME;
-        add_wait_queue(sk_sleep(sk), &wait);
-        do {
-                release_sock(sk);
-                if (smc->clcsock)
-                        timeout = wait_woken(&wait, TASK_UNINTERRUPTIBLE,
-                                             timeout);
-                sched_annotate_sleep();
-                lock_sock(sk);
-                if (!smc->clcsock)
-                        break;
-        } while (timeout);
-        remove_wait_queue(sk_sleep(sk), &wait);
-}
-
 /* wait for sndbuf data being transmitted */
 static void smc_close_stream_wait(struct smc_sock *smc, long timeout)
 {
@@ -204,9 +183,11 @@ again:
                         rc = kernel_sock_shutdown(smc->clcsock, SHUT_RDWR);
                         /* wake up kernel_accept of smc_tcp_listen_worker */
                         smc->clcsock->sk->sk_data_ready(smc->clcsock->sk);
-                        smc_close_wait_listen_clcsock(smc);
                 }
                 smc_close_cleanup_listen(sk);
+                release_sock(sk);
+                flush_work(&smc->tcp_listen_work);
+                lock_sock(sk);
                 break;
         case SMC_ACTIVE:
                 smc_close_stream_wait(smc, timeout);
diff --git a/net/socket.c b/net/socket.c
index a93c99b518ca..08847c3b8c39 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -2587,6 +2587,11 @@ void sock_unregister(int family)
 }
 EXPORT_SYMBOL(sock_unregister);
 
+bool sock_is_registered(int family)
+{
+        return family < NPROTO && rcu_access_pointer(net_families[family]);
+}
+
 static int __init sock_init(void)
 {
         int err;
diff --git a/net/xfrm/xfrm_ipcomp.c b/net/xfrm/xfrm_ipcomp.c
index ccfdc7115a83..a00ec715aa46 100644
--- a/net/xfrm/xfrm_ipcomp.c
+++ b/net/xfrm/xfrm_ipcomp.c
@@ -283,7 +283,7 @@ static struct crypto_comp * __percpu *ipcomp_alloc_tfms(const char *alg_name)
                 struct crypto_comp *tfm;
 
                 /* This can be any valid CPU ID so we don't need locking. */
-                tfm = __this_cpu_read(*pos->tfms);
+                tfm = this_cpu_read(*pos->tfms);
 
                 if (!strcmp(crypto_comp_name(tfm), alg_name)) {
                         pos->users++;
diff --git a/net/xfrm/xfrm_policy.c b/net/xfrm/xfrm_policy.c
index 7a23078132cf..625b3fca5704 100644
--- a/net/xfrm/xfrm_policy.c
+++ b/net/xfrm/xfrm_policy.c
@@ -1458,10 +1458,13 @@ xfrm_tmpl_resolve(struct xfrm_policy **pols, int npols, const struct flowi *fl,
 static int xfrm_get_tos(const struct flowi *fl, int family)
 {
         const struct xfrm_policy_afinfo *afinfo;
-        int tos = 0;
+        int tos;
 
         afinfo = xfrm_policy_get_afinfo(family);
-        tos = afinfo ? afinfo->get_tos(fl) : 0;
+        if (!afinfo)
+                return 0;
+
+        tos = afinfo->get_tos(fl);
 
         rcu_read_unlock();
 
@@ -1891,7 +1894,7 @@ static void xfrm_policy_queue_process(struct timer_list *t)
         spin_unlock(&pq->hold_queue.lock);
 
         dst_hold(xfrm_dst_path(dst));
-        dst = xfrm_lookup(net, xfrm_dst_path(dst), &fl, sk, 0);
+        dst = xfrm_lookup(net, xfrm_dst_path(dst), &fl, sk, XFRM_LOOKUP_QUEUE);
         if (IS_ERR(dst))
                 goto purge_queue;
 
@@ -2729,14 +2732,14 @@ static const void *xfrm_get_dst_nexthop(const struct dst_entry *dst,
         while (dst->xfrm) {
                 const struct xfrm_state *xfrm = dst->xfrm;
 
+                dst = xfrm_dst_child(dst);
+
                 if (xfrm->props.mode == XFRM_MODE_TRANSPORT)
                         continue;
                 if (xfrm->type->flags & XFRM_TYPE_REMOTE_COADDR)
                         daddr = xfrm->coaddr;
                 else if (!(xfrm->type->flags & XFRM_TYPE_LOCAL_COADDR))
                         daddr = &xfrm->id.daddr;
-
-                dst = xfrm_dst_child(dst);
         }
         return daddr;
 }
diff --git a/net/xfrm/xfrm_replay.c b/net/xfrm/xfrm_replay.c
index 1d38c6acf8af..9e3a5e85f828 100644
--- a/net/xfrm/xfrm_replay.c
+++ b/net/xfrm/xfrm_replay.c
@@ -660,7 +660,7 @@ static int xfrm_replay_overflow_offload_esn(struct xfrm_state *x, struct sk_buff
                 } else {
                         XFRM_SKB_CB(skb)->seq.output.low = oseq + 1;
                         XFRM_SKB_CB(skb)->seq.output.hi = oseq_hi;
-                        xo->seq.low = oseq = oseq + 1;
+                        xo->seq.low = oseq + 1;
                         xo->seq.hi = oseq_hi;
                         oseq += skb_shinfo(skb)->gso_segs;
                 }
diff --git a/net/xfrm/xfrm_state.c b/net/xfrm/xfrm_state.c
index 54e21f19d722..f9d2f2233f09 100644
--- a/net/xfrm/xfrm_state.c
+++ b/net/xfrm/xfrm_state.c
@@ -2056,6 +2056,11 @@ int xfrm_user_policy(struct sock *sk, int optname, u8 __user *optval, int optlen
         struct xfrm_mgr *km;
         struct xfrm_policy *pol = NULL;
 
+#ifdef CONFIG_COMPAT
+        if (in_compat_syscall())
+                return -EOPNOTSUPP;
+#endif
+
         if (!optval && !optlen) {
                 xfrm_sk_policy_insert(sk, XFRM_POLICY_IN, NULL);
                 xfrm_sk_policy_insert(sk, XFRM_POLICY_OUT, NULL);
diff --git a/net/xfrm/xfrm_user.c b/net/xfrm/xfrm_user.c
index 7f52b8eb177d..080035f056d9 100644
--- a/net/xfrm/xfrm_user.c
+++ b/net/xfrm/xfrm_user.c
@@ -121,22 +121,17 @@ static inline int verify_replay(struct xfrm_usersa_info *p,
         struct nlattr *rt = attrs[XFRMA_REPLAY_ESN_VAL];
         struct xfrm_replay_state_esn *rs;
 
-        if (p->flags & XFRM_STATE_ESN) {
-                if (!rt)
-                        return -EINVAL;
+        if (!rt)
+                return (p->flags & XFRM_STATE_ESN) ? -EINVAL : 0;
 
-                rs = nla_data(rt);
+        rs = nla_data(rt);
 
-                if (rs->bmp_len > XFRMA_REPLAY_ESN_MAX / sizeof(rs->bmp[0]) / 8)
-                        return -EINVAL;
-
-                if (nla_len(rt) < (int)xfrm_replay_state_esn_len(rs) &&
-                    nla_len(rt) != sizeof(*rs))
-                        return -EINVAL;
-        }
+        if (rs->bmp_len > XFRMA_REPLAY_ESN_MAX / sizeof(rs->bmp[0]) / 8)
+                return -EINVAL;
 
-        if (!rt)
-                return 0;
+        if (nla_len(rt) < (int)xfrm_replay_state_esn_len(rs) &&
+            nla_len(rt) != sizeof(*rs))
+                return -EINVAL;
 
         /* As only ESP and AH support ESN feature. */
         if ((p->id.proto != IPPROTO_ESP) && (p->id.proto != IPPROTO_AH))
diff --git a/sound/drivers/aloop.c b/sound/drivers/aloop.c
index 0333143a1fa7..1063a4377502 100644
--- a/sound/drivers/aloop.c
+++ b/sound/drivers/aloop.c
@@ -192,6 +192,11 @@ static inline void loopback_timer_stop(struct loopback_pcm *dpcm)
         dpcm->timer.expires = 0;
 }
 
+static inline void loopback_timer_stop_sync(struct loopback_pcm *dpcm)
+{
+        del_timer_sync(&dpcm->timer);
+}
+
 #define CABLE_VALID_PLAYBACK    (1 << SNDRV_PCM_STREAM_PLAYBACK)
 #define CABLE_VALID_CAPTURE     (1 << SNDRV_PCM_STREAM_CAPTURE)
 #define CABLE_VALID_BOTH        (CABLE_VALID_PLAYBACK|CABLE_VALID_CAPTURE)
@@ -326,6 +331,8 @@ static int loopback_prepare(struct snd_pcm_substream *substream)
         struct loopback_cable *cable = dpcm->cable;
         int bps, salign;
 
+        loopback_timer_stop_sync(dpcm);
+
         salign = (snd_pcm_format_width(runtime->format) *
                                                 runtime->channels) / 8;
         bps = salign * runtime->rate;
@@ -659,7 +666,9 @@ static void free_cable(struct snd_pcm_substream *substream)
                 return;
         if (cable->streams[!substream->stream]) {
                 /* other stream is still alive */
+                spin_lock_irq(&cable->lock);
                 cable->streams[substream->stream] = NULL;
+                spin_unlock_irq(&cable->lock);
         } else {
                 /* free the cable */
                 loopback->cables[substream->number][dev] = NULL;
@@ -698,7 +707,6 @@ static int loopback_open(struct snd_pcm_substream *substream)
                 loopback->cables[substream->number][dev] = cable;
         }
         dpcm->cable = cable;
-        cable->streams[substream->stream] = dpcm;
 
         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
 
@@ -730,6 +738,11 @@ static int loopback_open(struct snd_pcm_substream *substream)
                 runtime->hw = loopback_pcm_hardware;
         else
                 runtime->hw = cable->hw;
+
+        spin_lock_irq(&cable->lock);
+        cable->streams[substream->stream] = dpcm;
+        spin_unlock_irq(&cable->lock);
+
  unlock:
         if (err < 0) {
                 free_cable(substream);
@@ -744,7 +757,7 @@ static int loopback_close(struct snd_pcm_substream *substream)
         struct loopback *loopback = substream->private_data;
         struct loopback_pcm *dpcm = substream->runtime->private_data;
 
-        loopback_timer_stop(dpcm);
+        loopback_timer_stop_sync(dpcm);
         mutex_lock(&loopback->cable_lock);
         free_cable(substream);
         mutex_unlock(&loopback->cable_lock);
diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index d5017adf9feb..c507c69029e3 100644
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -375,6 +375,7 @@ enum {
                                         ((pci)->device == 0x160c))
 
 #define IS_BXT(pci) ((pci)->vendor == 0x8086 && (pci)->device == 0x5a98)
+#define IS_CFL(pci) ((pci)->vendor == 0x8086 && (pci)->device == 0xa348)
 
 static char *driver_short_names[] = {
         [AZX_DRIVER_ICH] = "HDA Intel",
@@ -1744,6 +1745,10 @@ static int azx_create(struct snd_card *card, struct pci_dev *pci,
         else
                 chip->bdl_pos_adj = bdl_pos_adj[dev];
 
+        /* Workaround for a communication error on CFL (bko#199007) */
+        if (IS_CFL(pci))
+                chip->polling_mode = 1;
+
         err = azx_bus_init(chip, model[dev], &pci_hda_io_ops);
         if (err < 0) {
                 kfree(hda);
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index 9af301c6bba2..aef1f52db7d9 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -3130,6 +3130,8 @@ static void alc256_init(struct hda_codec *codec)
 
         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
+        alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */
+        alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
 }
 
 static void alc256_shutup(struct hda_codec *codec)
@@ -3596,8 +3598,12 @@ static void alc269_fixup_mic_mute_hook(void *private_data, int enabled)
         pinval = snd_hda_codec_get_pin_target(codec, spec->mute_led_nid);
         pinval &= ~AC_PINCTL_VREFEN;
         pinval |= enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80;
-        if (spec->mute_led_nid)
+        if (spec->mute_led_nid) {
+                /* temporarily power up/down for setting VREF */
+                snd_hda_power_up_pm(codec);
                 snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);
+                snd_hda_power_down_pm(codec);
+        }
 }
 
 /* Make sure the led works even in runtime suspend */
@@ -5497,6 +5503,7 @@ enum {
         ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
         ALC298_FIXUP_TPT470_DOCK,
         ALC255_FIXUP_DUMMY_LINEOUT_VERB,
+        ALC255_FIXUP_DELL_HEADSET_MIC,
 };
 
 static const struct hda_fixup alc269_fixups[] = {
@@ -6357,6 +6364,13 @@ static const struct hda_fixup alc269_fixups[] = {
                 .chained = true,
                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
         },
+        [ALC255_FIXUP_DELL_HEADSET_MIC] = {
+                .type = HDA_FIXUP_PINS,
+                .v.pins = (const struct hda_pintbl[]) {
+                        { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
+                        { }
+                },
+        },
 };
 
 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
@@ -6411,6 +6425,8 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
         SND_PCI_QUIRK(0x1028, 0x082a, "Dell XPS 13 9360", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),
         SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
         SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
+        SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
+        SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
         SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
         SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
@@ -7154,6 +7170,8 @@ static int patch_alc269(struct hda_codec *codec)
                 break;
         case 0x10ec0257:
                 spec->codec_variant = ALC269_TYPE_ALC257;
+                spec->shutup = alc256_shutup;
+                spec->init_hook = alc256_init;
                 spec->gen.mixer_nid = 0;
                 break;
         case 0x10ec0215:
diff --git a/tools/bpf/bpftool/common.c b/tools/bpf/bpftool/common.c
index 0b482c0070e0..465995281dcd 100644
--- a/tools/bpf/bpftool/common.c
+++ b/tools/bpf/bpftool/common.c
@@ -55,6 +55,10 @@
 
 #include "main.h"
 
+#ifndef BPF_FS_MAGIC
+#define BPF_FS_MAGIC            0xcafe4a11
+#endif
+
 void p_err(const char *fmt, ...)
 {
         va_list ap;
diff --git a/tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args_string.tc b/tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args_string.tc
new file mode 100644
index 000000000000..5ba73035e1d9
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args_string.tc
@@ -0,0 +1,46 @@
+#!/bin/sh
+# SPDX-License-Identifier: GPL-2.0
+# description: Kprobe event string type argument
+
+[ -f kprobe_events ] || exit_unsupported # this is configurable
+
+echo 0 > events/enable
+echo > kprobe_events
+
+case `uname -m` in
+x86_64)
+  ARG2=%si
+  OFFS=8
+;;
+i[3456]86)
+  ARG2=%cx
+  OFFS=4
+;;
+aarch64)
+  ARG2=%x1
+  OFFS=8
+;;
+arm*)
+  ARG2=%r1
+  OFFS=4
+;;
+*)
+  echo "Please implement other architecture here"
+  exit_untested
+esac
+
+: "Test get argument (1)"
+echo "p:testprobe create_trace_kprobe arg1=+0(+0(${ARG2})):string" > kprobe_events
+echo 1 > events/kprobes/testprobe/enable
+! echo test >> kprobe_events
+tail -n 1 trace | grep -qe "testprobe.* arg1=\"test\""
+
+echo 0 > events/kprobes/testprobe/enable
+: "Test get argument (2)"
+echo "p:testprobe create_trace_kprobe arg1=+0(+0(${ARG2})):string arg2=+0(+${OFFS}(${ARG2})):string" > kprobe_events
+echo 1 > events/kprobes/testprobe/enable
+! echo test1 test2 >> kprobe_events
+tail -n 1 trace | grep -qe "testprobe.* arg1=\"test1\" arg2=\"test2\""
+
+echo 0 > events/enable
+echo > kprobe_events
diff --git a/tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args_syntax.tc b/tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args_syntax.tc
new file mode 100644
index 000000000000..231bcd2c4eb5
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args_syntax.tc
@@ -0,0 +1,97 @@
+#!/bin/sh
+# SPDX-License-Identifier: GPL-2.0
+# description: Kprobe event argument syntax
+
+[ -f kprobe_events ] || exit_unsupported # this is configurable
+
+grep "x8/16/32/64" README > /dev/null || exit_unsupported # version issue
+
+echo 0 > events/enable
+echo > kprobe_events
+
+PROBEFUNC="vfs_read"
+GOODREG=
+BADREG=
+GOODSYM="_sdata"
+if ! grep -qw ${GOODSYM} /proc/kallsyms ; then
+  GOODSYM=$PROBEFUNC
+fi
+BADSYM="deaqswdefr"
+SYMADDR=0x`grep -w ${GOODSYM} /proc/kallsyms | cut -f 1 -d " "`
+GOODTYPE="x16"
+BADTYPE="y16"
+
+case `uname -m` in
+x86_64|i[3456]86)
+  GOODREG=%ax
+  BADREG=%ex
+;;
+aarch64)
+  GOODREG=%x0
+  BADREG=%ax
+;;
+arm*)
+  GOODREG=%r0
+  BADREG=%ax
+;;
+esac
+
+test_goodarg() # Good-args
+{
+  while [ "$1" ]; do
+    echo "p ${PROBEFUNC} $1" > kprobe_events
+    shift 1
+  done;
+}
+
+test_badarg() # Bad-args
+{
+  while [ "$1" ]; do
+    ! echo "p ${PROBEFUNC} $1" > kprobe_events
+    shift 1
+  done;
+}
+
+echo > kprobe_events
+
+: "Register access"
+test_goodarg ${GOODREG}
+test_badarg ${BADREG}
+
+: "Symbol access"
+test_goodarg "@${GOODSYM}" "@${SYMADDR}" "@${GOODSYM}+10" "@${GOODSYM}-10"
+test_badarg "@" "@${BADSYM}" "@${GOODSYM}*10" "@${GOODSYM}/10" \
+            "@${GOODSYM}%10" "@${GOODSYM}&10" "@${GOODSYM}|10"
+
+: "Stack access"
+test_goodarg "\$stack" "\$stack0" "\$stack1"
+test_badarg "\$stackp" "\$stack0+10" "\$stack1-10"
+
+: "Retval access"
+echo "r ${PROBEFUNC} \$retval" > kprobe_events
+! echo "p ${PROBEFUNC} \$retval" > kprobe_events
+
+: "Comm access"
+test_goodarg "\$comm"
+
+: "Indirect memory access"
+test_goodarg "+0(${GOODREG})" "-0(${GOODREG})" "+10(\$stack)" \
+        "+0(\$stack1)" "+10(@${GOODSYM}-10)" "+0(+10(+20(\$stack)))"
+test_badarg "+(${GOODREG})" "(${GOODREG}+10)" "-(${GOODREG})" "(${GOODREG})" \
+        "+10(\$comm)" "+0(${GOODREG})+10"
+
+: "Name assignment"
+test_goodarg "varname=${GOODREG}"
+test_badarg "varname=varname2=${GOODREG}"
+
+: "Type syntax"
+test_goodarg "${GOODREG}:${GOODTYPE}"
+test_badarg "${GOODREG}::${GOODTYPE}" "${GOODREG}:${BADTYPE}" \
+        "${GOODTYPE}:${GOODREG}"
+
+: "Combination check"
+
+test_goodarg "\$comm:string" "+0(\$stack):string"
+test_badarg "\$comm:x64" "\$stack:string" "${GOODREG}:string"
+
+echo > kprobe_events
diff --git a/tools/testing/selftests/ftrace/test.d/kprobe/probepoint.tc b/tools/testing/selftests/ftrace/test.d/kprobe/probepoint.tc
new file mode 100644
index 000000000000..4fda01a08da4
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/kprobe/probepoint.tc
@@ -0,0 +1,43 @@
+#!/bin/sh
+# SPDX-License-Identifier: GPL-2.0
+# description: Kprobe events - probe points
+
+[ -f kprobe_events ] || exit_unsupported # this is configurable
+
+TARGET_FUNC=create_trace_kprobe
+
+dec_addr() { # hexaddr
+  printf "%d" "0x"`echo $1 | tail -c 8`
+}
+
+set_offs() { # prev target next
+  A1=`dec_addr $1`
+  A2=`dec_addr $2`
+  A3=`dec_addr $3`
+  TARGET="0x$2" # an address
+  PREV=`expr $A1 - $A2` # offset to previous symbol
+  NEXT=+`expr $A3 - $A2` # offset to next symbol
+  OVERFLOW=+`printf "0x%x" ${PREV}` # overflow offset to previous symbol
+}
+
+# We have to decode symbol addresses to get correct offsets.
+# If the offset is not an instruction boundary, it cause -EILSEQ.
+set_offs `grep -A1 -B1 ${TARGET_FUNC} /proc/kallsyms | cut -f 1 -d " " | xargs`
+
+UINT_TEST=no
+# printf "%x" -1 returns (unsigned long)-1.
+if [ `printf "%x" -1 | wc -c` != 9 ]; then
+  UINT_TEST=yes
+fi
+
+echo 0 > events/enable
+echo > kprobe_events
+echo "p:testprobe ${TARGET_FUNC}" > kprobe_events
+echo "p:testprobe ${TARGET}" > kprobe_events
+echo "p:testprobe ${TARGET_FUNC}${NEXT}" > kprobe_events
+! echo "p:testprobe ${TARGET_FUNC}${PREV}" > kprobe_events
+if [ "${UINT_TEST}" = yes ]; then
+! echo "p:testprobe ${TARGET_FUNC}${OVERFLOW}" > kprobe_events
+fi
+echo > kprobe_events
+clear_trace