[gentoo-commits] proj/linux-patches:5.4 commit in: /

[Mike Pagano]

commit:     bc50c812f636e7a351f6b1fba8cef0b99c7886ae
Author:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
AuthorDate: Thu Jan 23 11:09:33 2020 +0000
Commit:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
CommitDate: Thu Jan 23 11:09:33 2020 +0000
URL:        https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=bc50c812

Linux patch 5.4.14

Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org>

 0000_README             |    4 +
 1013_linux-5.4.14.patch | 8137 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 8141 insertions(+)

diff --git a/0000_README b/0000_README
index 6df7de3..b9c4fa1 100644
--- a/0000_README
+++ b/0000_README
@@ -95,6 +95,10 @@ Patch:  1012_linux-5.4.13.patch
 From:   http://www.kernel.org
 Desc:   Linux 5.4.13
 
+Patch:  1013_linux-5.4.14.patch
+From:   http://www.kernel.org
+Desc:   Linux 5.4.14
+
 Patch:  1500_XATTR_USER_PREFIX.patch
 From:   https://bugs.gentoo.org/show_bug.cgi?id=470644
 Desc:   Support for namespace user.pax.* on tmpfs.

diff --git a/1013_linux-5.4.14.patch b/1013_linux-5.4.14.patch
new file mode 100644
index 0000000..beb51d5
--- /dev/null
+++ b/1013_linux-5.4.14.patch
@@ -0,0 +1,8137 @@
+diff --git a/Documentation/devicetree/bindings/net/snps,dwmac.yaml b/Documentation/devicetree/bindings/net/snps,dwmac.yaml
+index 4845e29411e4..e08cd4c4d568 100644
+--- a/Documentation/devicetree/bindings/net/snps,dwmac.yaml
++++ b/Documentation/devicetree/bindings/net/snps,dwmac.yaml
+@@ -347,6 +347,7 @@ allOf:
+               - st,spear600-gmac
+ 
+     then:
++      properties:
+         snps,tso:
+           $ref: /schemas/types.yaml#definitions/flag
+           description:
+diff --git a/Makefile b/Makefile
+index d4cf4700ae3f..2b2080d08bb2 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,7 +1,7 @@
+ # SPDX-License-Identifier: GPL-2.0
+ VERSION = 5
+ PATCHLEVEL = 4
+-SUBLEVEL = 13
++SUBLEVEL = 14
+ EXTRAVERSION =
+ NAME = Kleptomaniac Octopus
+ 
+diff --git a/arch/arm/boot/dts/am571x-idk.dts b/arch/arm/boot/dts/am571x-idk.dts
+index 0aaacea1d887..9d6a872c2b23 100644
+--- a/arch/arm/boot/dts/am571x-idk.dts
++++ b/arch/arm/boot/dts/am571x-idk.dts
+@@ -167,7 +167,7 @@
+ 
+ &pcie1_rc {
+ 	status = "okay";
+-	gpios = <&gpio3 23 GPIO_ACTIVE_HIGH>;
++	gpios = <&gpio5 18 GPIO_ACTIVE_HIGH>;
+ };
+ 
+ &pcie1_ep {
+diff --git a/arch/arm/boot/dts/dra7-l4.dtsi b/arch/arm/boot/dts/dra7-l4.dtsi
+index 5cac2dd58241..c3954e34835b 100644
+--- a/arch/arm/boot/dts/dra7-l4.dtsi
++++ b/arch/arm/boot/dts/dra7-l4.dtsi
+@@ -3059,7 +3059,7 @@
+ 
+ 				davinci_mdio: mdio@1000 {
+ 					compatible = "ti,cpsw-mdio","ti,davinci_mdio";
+-					clocks = <&gmac_clkctrl DRA7_GMAC_GMAC_CLKCTRL 0>;
++					clocks = <&gmac_main_clk>;
+ 					clock-names = "fck";
+ 					#address-cells = <1>;
+ 					#size-cells = <0>;
+diff --git a/arch/arm/boot/dts/imx6dl-icore-mipi.dts b/arch/arm/boot/dts/imx6dl-icore-mipi.dts
+index e43bccb78ab2..d8f3821a0ffd 100644
+--- a/arch/arm/boot/dts/imx6dl-icore-mipi.dts
++++ b/arch/arm/boot/dts/imx6dl-icore-mipi.dts
+@@ -8,7 +8,7 @@
+ /dts-v1/;
+ 
+ #include "imx6dl.dtsi"
+-#include "imx6qdl-icore.dtsi"
++#include "imx6qdl-icore-1.5.dtsi"
+ 
+ / {
+ 	model = "Engicam i.CoreM6 DualLite/Solo MIPI Starter Kit";
+diff --git a/arch/arm/boot/dts/imx6q-dhcom-pdk2.dts b/arch/arm/boot/dts/imx6q-dhcom-pdk2.dts
+index 9c61e3be2d9a..1c46df6827f5 100644
+--- a/arch/arm/boot/dts/imx6q-dhcom-pdk2.dts
++++ b/arch/arm/boot/dts/imx6q-dhcom-pdk2.dts
+@@ -55,7 +55,7 @@
+ 		#sound-dai-cells = <0>;
+ 		clocks = <&clk_ext_audio_codec>;
+ 		VDDA-supply = <&reg_3p3v>;
+-		VDDIO-supply = <&reg_3p3v>;
++		VDDIO-supply = <&sw2_reg>;
+ 	};
+ };
+ 
+diff --git a/arch/arm/boot/dts/imx6q-dhcom-som.dtsi b/arch/arm/boot/dts/imx6q-dhcom-som.dtsi
+index 387801dde02e..08a2e17e0539 100644
+--- a/arch/arm/boot/dts/imx6q-dhcom-som.dtsi
++++ b/arch/arm/boot/dts/imx6q-dhcom-som.dtsi
+@@ -206,7 +206,7 @@
+ 	};
+ 
+ 	rtc@56 {
+-		compatible = "rv3029c2";
++		compatible = "microcrystal,rv3029";
+ 		pinctrl-names = "default";
+ 		pinctrl-0 = <&pinctrl_rtc_hw300>;
+ 		reg = <0x56>;
+diff --git a/arch/arm/boot/dts/imx6qdl-sabresd.dtsi b/arch/arm/boot/dts/imx6qdl-sabresd.dtsi
+index 71ca76a5e4a5..fe59dde41b64 100644
+--- a/arch/arm/boot/dts/imx6qdl-sabresd.dtsi
++++ b/arch/arm/boot/dts/imx6qdl-sabresd.dtsi
+@@ -749,10 +749,6 @@
+ 	vin-supply = <&vgen5_reg>;
+ };
+ 
+-&reg_vdd3p0 {
+-	vin-supply = <&sw2_reg>;
+-};
+-
+ &reg_vdd2p5 {
+ 	vin-supply = <&vgen5_reg>;
+ };
+diff --git a/arch/arm/boot/dts/imx6sl-evk.dts b/arch/arm/boot/dts/imx6sl-evk.dts
+index 4829aa682aeb..bc86cfaaa9c2 100644
+--- a/arch/arm/boot/dts/imx6sl-evk.dts
++++ b/arch/arm/boot/dts/imx6sl-evk.dts
+@@ -584,10 +584,6 @@
+ 	vin-supply = <&sw2_reg>;
+ };
+ 
+-&reg_vdd3p0 {
+-	vin-supply = <&sw2_reg>;
+-};
+-
+ &reg_vdd2p5 {
+ 	vin-supply = <&sw2_reg>;
+ };
+diff --git a/arch/arm/boot/dts/imx6sll-evk.dts b/arch/arm/boot/dts/imx6sll-evk.dts
+index 3e1d32fdf4b8..5ace9e6acf85 100644
+--- a/arch/arm/boot/dts/imx6sll-evk.dts
++++ b/arch/arm/boot/dts/imx6sll-evk.dts
+@@ -265,10 +265,6 @@
+ 	status = "okay";
+ };
+ 
+-&reg_3p0 {
+-	vin-supply = <&sw2_reg>;
+-};
+-
+ &snvs_poweroff {
+ 	status = "okay";
+ };
+diff --git a/arch/arm/boot/dts/imx6sx-sdb-reva.dts b/arch/arm/boot/dts/imx6sx-sdb-reva.dts
+index f1830ed387a5..91a7548fdb8d 100644
+--- a/arch/arm/boot/dts/imx6sx-sdb-reva.dts
++++ b/arch/arm/boot/dts/imx6sx-sdb-reva.dts
+@@ -159,10 +159,6 @@
+ 	vin-supply = <&vgen6_reg>;
+ };
+ 
+-&reg_vdd3p0 {
+-	vin-supply = <&sw2_reg>;
+-};
+-
+ &reg_vdd2p5 {
+ 	vin-supply = <&vgen6_reg>;
+ };
+diff --git a/arch/arm/boot/dts/imx6sx-sdb.dts b/arch/arm/boot/dts/imx6sx-sdb.dts
+index a8ee7087af5a..5a63ca615722 100644
+--- a/arch/arm/boot/dts/imx6sx-sdb.dts
++++ b/arch/arm/boot/dts/imx6sx-sdb.dts
+@@ -141,10 +141,6 @@
+ 	vin-supply = <&vgen6_reg>;
+ };
+ 
+-&reg_vdd3p0 {
+-	vin-supply = <&sw2_reg>;
+-};
+-
+ &reg_vdd2p5 {
+ 	vin-supply = <&vgen6_reg>;
+ };
+diff --git a/arch/arm/boot/dts/imx6ul-kontron-n6310-s.dts b/arch/arm/boot/dts/imx6ul-kontron-n6310-s.dts
+index 0205fd56d975..4e99e6c79a68 100644
+--- a/arch/arm/boot/dts/imx6ul-kontron-n6310-s.dts
++++ b/arch/arm/boot/dts/imx6ul-kontron-n6310-s.dts
+@@ -157,10 +157,6 @@
+ 	status = "okay";
+ };
+ 
+-&snvs_poweroff {
+-	status = "okay";
+-};
+-
+ &uart1 {
+ 	pinctrl-names = "default";
+ 	pinctrl-0 = <&pinctrl_uart1>;
+diff --git a/arch/arm/boot/dts/imx7s-colibri.dtsi b/arch/arm/boot/dts/imx7s-colibri.dtsi
+index 1fb1ec5d3d70..6d16e32aed89 100644
+--- a/arch/arm/boot/dts/imx7s-colibri.dtsi
++++ b/arch/arm/boot/dts/imx7s-colibri.dtsi
+@@ -49,3 +49,7 @@
+ 		reg = <0x80000000 0x10000000>;
+ 	};
+ };
++
++&gpmi {
++	status = "okay";
++};
+diff --git a/arch/arm/boot/dts/imx7ulp.dtsi b/arch/arm/boot/dts/imx7ulp.dtsi
+index 6859a3a83750..3dac6898cdc5 100644
+--- a/arch/arm/boot/dts/imx7ulp.dtsi
++++ b/arch/arm/boot/dts/imx7ulp.dtsi
+@@ -37,10 +37,10 @@
+ 		#address-cells = <1>;
+ 		#size-cells = <0>;
+ 
+-		cpu0: cpu@0 {
++		cpu0: cpu@f00 {
+ 			compatible = "arm,cortex-a7";
+ 			device_type = "cpu";
+-			reg = <0>;
++			reg = <0xf00>;
+ 		};
+ 	};
+ 
+diff --git a/arch/arm/boot/dts/meson8.dtsi b/arch/arm/boot/dts/meson8.dtsi
+index 5a7e3e5caebe..3c534cd50ee3 100644
+--- a/arch/arm/boot/dts/meson8.dtsi
++++ b/arch/arm/boot/dts/meson8.dtsi
+@@ -253,7 +253,7 @@
+ &aobus {
+ 	pmu: pmu@e0 {
+ 		compatible = "amlogic,meson8-pmu", "syscon";
+-		reg = <0xe0 0x8>;
++		reg = <0xe0 0x18>;
+ 	};
+ 
+ 	pinctrl_aobus: pinctrl@84 {
+diff --git a/arch/arm/boot/dts/omap4.dtsi b/arch/arm/boot/dts/omap4.dtsi
+index 7cc95bc1598b..e5506ab669fc 100644
+--- a/arch/arm/boot/dts/omap4.dtsi
++++ b/arch/arm/boot/dts/omap4.dtsi
+@@ -330,8 +330,8 @@
+ 
+ 		target-module@56000000 {
+ 			compatible = "ti,sysc-omap4", "ti,sysc";
+-			reg = <0x5601fc00 0x4>,
+-			      <0x5601fc10 0x4>;
++			reg = <0x5600fe00 0x4>,
++			      <0x5600fe10 0x4>;
+ 			reg-names = "rev", "sysc";
+ 			ti,sysc-midle = <SYSC_IDLE_FORCE>,
+ 					<SYSC_IDLE_NO>,
+diff --git a/arch/arm/mach-davinci/Kconfig b/arch/arm/mach-davinci/Kconfig
+index dd427bd2768c..02b180ad7245 100644
+--- a/arch/arm/mach-davinci/Kconfig
++++ b/arch/arm/mach-davinci/Kconfig
+@@ -9,6 +9,7 @@ menuconfig ARCH_DAVINCI
+ 	select PM_GENERIC_DOMAINS if PM
+ 	select PM_GENERIC_DOMAINS_OF if PM && OF
+ 	select REGMAP_MMIO
++	select RESET_CONTROLLER
+ 	select HAVE_IDE
+ 	select PINCTRL_SINGLE
+ 
+diff --git a/arch/arm/mach-omap2/pdata-quirks.c b/arch/arm/mach-omap2/pdata-quirks.c
+index 1b7cf81ff035..33688e1d9acf 100644
+--- a/arch/arm/mach-omap2/pdata-quirks.c
++++ b/arch/arm/mach-omap2/pdata-quirks.c
+@@ -368,10 +368,14 @@ static void __init dra7x_evm_mmc_quirk(void)
+ 
+ static struct clockdomain *ti_sysc_find_one_clockdomain(struct clk *clk)
+ {
++	struct clk_hw *hw = __clk_get_hw(clk);
+ 	struct clockdomain *clkdm = NULL;
+ 	struct clk_hw_omap *hwclk;
+ 
+-	hwclk = to_clk_hw_omap(__clk_get_hw(clk));
++	hwclk = to_clk_hw_omap(hw);
++	if (!omap2_clk_is_hw_omap(hw))
++		return NULL;
++
+ 	if (hwclk && hwclk->clkdm_name)
+ 		clkdm = clkdm_lookup(hwclk->clkdm_name);
+ 
+diff --git a/arch/arm64/boot/dts/allwinner/sun50i-a64-olinuxino-emmc.dts b/arch/arm64/boot/dts/allwinner/sun50i-a64-olinuxino-emmc.dts
+index 96ab0227e82d..121e6cc4849b 100644
+--- a/arch/arm64/boot/dts/allwinner/sun50i-a64-olinuxino-emmc.dts
++++ b/arch/arm64/boot/dts/allwinner/sun50i-a64-olinuxino-emmc.dts
+@@ -15,7 +15,7 @@
+ 	pinctrl-names = "default";
+ 	pinctrl-0 = <&mmc2_pins>;
+ 	vmmc-supply = <&reg_dcdc1>;
+-	vqmmc-supply = <&reg_dcdc1>;
++	vqmmc-supply = <&reg_eldo1>;
+ 	bus-width = <8>;
+ 	non-removable;
+ 	cap-mmc-hw-reset;
+diff --git a/arch/arm64/boot/dts/allwinner/sun50i-a64-olinuxino.dts b/arch/arm64/boot/dts/allwinner/sun50i-a64-olinuxino.dts
+index 01a9a52edae4..393c1948a495 100644
+--- a/arch/arm64/boot/dts/allwinner/sun50i-a64-olinuxino.dts
++++ b/arch/arm64/boot/dts/allwinner/sun50i-a64-olinuxino.dts
+@@ -140,7 +140,7 @@
+ &mmc1 {
+ 	pinctrl-names = "default";
+ 	pinctrl-0 = <&mmc1_pins>;
+-	vmmc-supply = <&reg_aldo2>;
++	vmmc-supply = <&reg_dcdc1>;
+ 	vqmmc-supply = <&reg_dldo4>;
+ 	mmc-pwrseq = <&wifi_pwrseq>;
+ 	bus-width = <4>;
+diff --git a/arch/arm64/boot/dts/allwinner/sun50i-a64.dtsi b/arch/arm64/boot/dts/allwinner/sun50i-a64.dtsi
+index 70f4cce6be43..ba41c1b85887 100644
+--- a/arch/arm64/boot/dts/allwinner/sun50i-a64.dtsi
++++ b/arch/arm64/boot/dts/allwinner/sun50i-a64.dtsi
+@@ -142,6 +142,15 @@
+ 		clock-output-names = "ext-osc32k";
+ 	};
+ 
++	pmu {
++		compatible = "arm,cortex-a53-pmu";
++		interrupts = <GIC_SPI 116 IRQ_TYPE_LEVEL_HIGH>,
++			     <GIC_SPI 117 IRQ_TYPE_LEVEL_HIGH>,
++			     <GIC_SPI 118 IRQ_TYPE_LEVEL_HIGH>,
++			     <GIC_SPI 119 IRQ_TYPE_LEVEL_HIGH>;
++		interrupt-affinity = <&cpu0>, <&cpu1>, <&cpu2>, <&cpu3>;
++	};
++
+ 	psci {
+ 		compatible = "arm,psci-0.2";
+ 		method = "smc";
+diff --git a/arch/arm64/boot/dts/altera/socfpga_stratix10.dtsi b/arch/arm64/boot/dts/altera/socfpga_stratix10.dtsi
+index 144a2c19ac02..d1fc9c2055f4 100644
+--- a/arch/arm64/boot/dts/altera/socfpga_stratix10.dtsi
++++ b/arch/arm64/boot/dts/altera/socfpga_stratix10.dtsi
+@@ -61,10 +61,10 @@
+ 
+ 	pmu {
+ 		compatible = "arm,armv8-pmuv3";
+-		interrupts = <0 120 8>,
+-			     <0 121 8>,
+-			     <0 122 8>,
+-			     <0 123 8>;
++		interrupts = <0 170 4>,
++			     <0 171 4>,
++			     <0 172 4>,
++			     <0 173 4>;
+ 		interrupt-affinity = <&cpu0>,
+ 				     <&cpu1>,
+ 				     <&cpu2>,
+diff --git a/arch/arm64/boot/dts/amlogic/meson-axg.dtsi b/arch/arm64/boot/dts/amlogic/meson-axg.dtsi
+index 82919b106010..bb4a2acb9970 100644
+--- a/arch/arm64/boot/dts/amlogic/meson-axg.dtsi
++++ b/arch/arm64/boot/dts/amlogic/meson-axg.dtsi
+@@ -1162,7 +1162,7 @@
+ 
+ 			toddr_a: audio-controller@100 {
+ 				compatible = "amlogic,axg-toddr";
+-				reg = <0x0 0x100 0x0 0x1c>;
++				reg = <0x0 0x100 0x0 0x2c>;
+ 				#sound-dai-cells = <0>;
+ 				sound-name-prefix = "TODDR_A";
+ 				interrupts = <GIC_SPI 84 IRQ_TYPE_EDGE_RISING>;
+@@ -1173,7 +1173,7 @@
+ 
+ 			toddr_b: audio-controller@140 {
+ 				compatible = "amlogic,axg-toddr";
+-				reg = <0x0 0x140 0x0 0x1c>;
++				reg = <0x0 0x140 0x0 0x2c>;
+ 				#sound-dai-cells = <0>;
+ 				sound-name-prefix = "TODDR_B";
+ 				interrupts = <GIC_SPI 85 IRQ_TYPE_EDGE_RISING>;
+@@ -1184,7 +1184,7 @@
+ 
+ 			toddr_c: audio-controller@180 {
+ 				compatible = "amlogic,axg-toddr";
+-				reg = <0x0 0x180 0x0 0x1c>;
++				reg = <0x0 0x180 0x0 0x2c>;
+ 				#sound-dai-cells = <0>;
+ 				sound-name-prefix = "TODDR_C";
+ 				interrupts = <GIC_SPI 86 IRQ_TYPE_EDGE_RISING>;
+@@ -1195,7 +1195,7 @@
+ 
+ 			frddr_a: audio-controller@1c0 {
+ 				compatible = "amlogic,axg-frddr";
+-				reg = <0x0 0x1c0 0x0 0x1c>;
++				reg = <0x0 0x1c0 0x0 0x2c>;
+ 				#sound-dai-cells = <0>;
+ 				sound-name-prefix = "FRDDR_A";
+ 				interrupts = <GIC_SPI 88 IRQ_TYPE_EDGE_RISING>;
+@@ -1206,7 +1206,7 @@
+ 
+ 			frddr_b: audio-controller@200 {
+ 				compatible = "amlogic,axg-frddr";
+-				reg = <0x0 0x200 0x0 0x1c>;
++				reg = <0x0 0x200 0x0 0x2c>;
+ 				#sound-dai-cells = <0>;
+ 				sound-name-prefix = "FRDDR_B";
+ 				interrupts = <GIC_SPI 89 IRQ_TYPE_EDGE_RISING>;
+@@ -1217,7 +1217,7 @@
+ 
+ 			frddr_c: audio-controller@240 {
+ 				compatible = "amlogic,axg-frddr";
+-				reg = <0x0 0x240 0x0 0x1c>;
++				reg = <0x0 0x240 0x0 0x2c>;
+ 				#sound-dai-cells = <0>;
+ 				sound-name-prefix = "FRDDR_C";
+ 				interrupts = <GIC_SPI 90 IRQ_TYPE_EDGE_RISING>;
+diff --git a/arch/arm64/boot/dts/amlogic/meson-g12-common.dtsi b/arch/arm64/boot/dts/amlogic/meson-g12-common.dtsi
+index 3f39e020f74e..0ee8a369c547 100644
+--- a/arch/arm64/boot/dts/amlogic/meson-g12-common.dtsi
++++ b/arch/arm64/boot/dts/amlogic/meson-g12-common.dtsi
+@@ -1509,7 +1509,7 @@
+ 				toddr_a: audio-controller@100 {
+ 					compatible = "amlogic,g12a-toddr",
+ 						     "amlogic,axg-toddr";
+-					reg = <0x0 0x100 0x0 0x1c>;
++					reg = <0x0 0x100 0x0 0x2c>;
+ 					#sound-dai-cells = <0>;
+ 					sound-name-prefix = "TODDR_A";
+ 					interrupts = <GIC_SPI 148 IRQ_TYPE_EDGE_RISING>;
+@@ -1521,7 +1521,7 @@
+ 				toddr_b: audio-controller@140 {
+ 					compatible = "amlogic,g12a-toddr",
+ 						     "amlogic,axg-toddr";
+-					reg = <0x0 0x140 0x0 0x1c>;
++					reg = <0x0 0x140 0x0 0x2c>;
+ 					#sound-dai-cells = <0>;
+ 					sound-name-prefix = "TODDR_B";
+ 					interrupts = <GIC_SPI 149 IRQ_TYPE_EDGE_RISING>;
+@@ -1533,7 +1533,7 @@
+ 				toddr_c: audio-controller@180 {
+ 					compatible = "amlogic,g12a-toddr",
+ 						     "amlogic,axg-toddr";
+-					reg = <0x0 0x180 0x0 0x1c>;
++					reg = <0x0 0x180 0x0 0x2c>;
+ 					#sound-dai-cells = <0>;
+ 					sound-name-prefix = "TODDR_C";
+ 					interrupts = <GIC_SPI 150 IRQ_TYPE_EDGE_RISING>;
+@@ -1545,7 +1545,7 @@
+ 				frddr_a: audio-controller@1c0 {
+ 					compatible = "amlogic,g12a-frddr",
+ 						     "amlogic,axg-frddr";
+-					reg = <0x0 0x1c0 0x0 0x1c>;
++					reg = <0x0 0x1c0 0x0 0x2c>;
+ 					#sound-dai-cells = <0>;
+ 					sound-name-prefix = "FRDDR_A";
+ 					interrupts = <GIC_SPI 152 IRQ_TYPE_EDGE_RISING>;
+@@ -1557,7 +1557,7 @@
+ 				frddr_b: audio-controller@200 {
+ 					compatible = "amlogic,g12a-frddr",
+ 						     "amlogic,axg-frddr";
+-					reg = <0x0 0x200 0x0 0x1c>;
++					reg = <0x0 0x200 0x0 0x2c>;
+ 					#sound-dai-cells = <0>;
+ 					sound-name-prefix = "FRDDR_B";
+ 					interrupts = <GIC_SPI 153 IRQ_TYPE_EDGE_RISING>;
+@@ -1569,7 +1569,7 @@
+ 				frddr_c: audio-controller@240 {
+ 					compatible = "amlogic,g12a-frddr",
+ 						     "amlogic,axg-frddr";
+-					reg = <0x0 0x240 0x0 0x1c>;
++					reg = <0x0 0x240 0x0 0x2c>;
+ 					#sound-dai-cells = <0>;
+ 					sound-name-prefix = "FRDDR_C";
+ 					interrupts = <GIC_SPI 154 IRQ_TYPE_EDGE_RISING>;
+diff --git a/arch/arm64/boot/dts/amlogic/meson-gxl-s905x-khadas-vim.dts b/arch/arm64/boot/dts/amlogic/meson-gxl-s905x-khadas-vim.dts
+index 8d6f316a5c7b..440bc23c7342 100644
+--- a/arch/arm64/boot/dts/amlogic/meson-gxl-s905x-khadas-vim.dts
++++ b/arch/arm64/boot/dts/amlogic/meson-gxl-s905x-khadas-vim.dts
+@@ -33,11 +33,9 @@
+ 
+ 	gpio-keys-polled {
+ 		compatible = "gpio-keys-polled";
+-		#address-cells = <1>;
+-		#size-cells = <0>;
+ 		poll-interval = <100>;
+ 
+-		button@0 {
++		power-button {
+ 			label = "power";
+ 			linux,code = <KEY_POWER>;
+ 			gpios = <&gpio_ao GPIOAO_2 GPIO_ACTIVE_LOW>;
+diff --git a/arch/arm64/boot/dts/arm/juno-base.dtsi b/arch/arm64/boot/dts/arm/juno-base.dtsi
+index 26a039a028b8..8c11660bbe40 100644
+--- a/arch/arm64/boot/dts/arm/juno-base.dtsi
++++ b/arch/arm64/boot/dts/arm/juno-base.dtsi
+@@ -6,7 +6,6 @@
+ 	/*
+ 	 *  Devices shared by all Juno boards
+ 	 */
+-	dma-ranges = <0 0 0 0 0x100 0>;
+ 
+ 	memtimer: timer@2a810000 {
+ 		compatible = "arm,armv7-timer-mem";
+diff --git a/arch/arm64/boot/dts/arm/juno-clocks.dtsi b/arch/arm64/boot/dts/arm/juno-clocks.dtsi
+index e5e265dfa902..2870b5eeb198 100644
+--- a/arch/arm64/boot/dts/arm/juno-clocks.dtsi
++++ b/arch/arm64/boot/dts/arm/juno-clocks.dtsi
+@@ -8,10 +8,10 @@
+  */
+ / {
+ 	/* SoC fixed clocks */
+-	soc_uartclk: refclk7273800hz {
++	soc_uartclk: refclk7372800hz {
+ 		compatible = "fixed-clock";
+ 		#clock-cells = <0>;
+-		clock-frequency = <7273800>;
++		clock-frequency = <7372800>;
+ 		clock-output-names = "juno:uartclk";
+ 	};
+ 
+diff --git a/arch/arm64/boot/dts/freescale/fsl-ls1028a.dtsi b/arch/arm64/boot/dts/freescale/fsl-ls1028a.dtsi
+index bb960fe2bb64..9589b15693d6 100644
+--- a/arch/arm64/boot/dts/freescale/fsl-ls1028a.dtsi
++++ b/arch/arm64/boot/dts/freescale/fsl-ls1028a.dtsi
+@@ -158,7 +158,7 @@
+ 		dcfg: syscon@1e00000 {
+ 			compatible = "fsl,ls1028a-dcfg", "syscon";
+ 			reg = <0x0 0x1e00000 0x0 0x10000>;
+-			big-endian;
++			little-endian;
+ 		};
+ 
+ 		rst: syscon@1e60000 {
+diff --git a/arch/arm64/boot/dts/freescale/imx8mm-evk.dts b/arch/arm64/boot/dts/freescale/imx8mm-evk.dts
+index f7a15f3904c2..13137451b438 100644
+--- a/arch/arm64/boot/dts/freescale/imx8mm-evk.dts
++++ b/arch/arm64/boot/dts/freescale/imx8mm-evk.dts
+@@ -62,6 +62,8 @@
+ 
+ 		cpudai: simple-audio-card,cpu {
+ 			sound-dai = <&sai3>;
++			dai-tdm-slot-num = <2>;
++			dai-tdm-slot-width = <32>;
+ 		};
+ 
+ 		simple-audio-card,codec {
+diff --git a/arch/arm64/boot/dts/freescale/imx8mm.dtsi b/arch/arm64/boot/dts/freescale/imx8mm.dtsi
+index 23c8fad7932b..fde1849d36ca 100644
+--- a/arch/arm64/boot/dts/freescale/imx8mm.dtsi
++++ b/arch/arm64/boot/dts/freescale/imx8mm.dtsi
+@@ -479,14 +479,18 @@
+ 						<&clk IMX8MM_CLK_AUDIO_AHB>,
+ 						<&clk IMX8MM_CLK_IPG_AUDIO_ROOT>,
+ 						<&clk IMX8MM_SYS_PLL3>,
+-						<&clk IMX8MM_VIDEO_PLL1>;
++						<&clk IMX8MM_VIDEO_PLL1>,
++						<&clk IMX8MM_AUDIO_PLL1>,
++						<&clk IMX8MM_AUDIO_PLL2>;
+ 				assigned-clock-parents = <&clk IMX8MM_SYS_PLL3_OUT>,
+ 							 <&clk IMX8MM_SYS_PLL1_800M>;
+ 				assigned-clock-rates = <0>,
+ 							<400000000>,
+ 							<400000000>,
+ 							<750000000>,
+-							<594000000>;
++							<594000000>,
++							<393216000>,
++							<361267200>;
+ 			};
+ 
+ 			src: reset-controller@30390000 {
+@@ -741,7 +745,7 @@
+ 				reg = <0x30bd0000 0x10000>;
+ 				interrupts = <GIC_SPI 2 IRQ_TYPE_LEVEL_HIGH>;
+ 				clocks = <&clk IMX8MM_CLK_SDMA1_ROOT>,
+-					 <&clk IMX8MM_CLK_SDMA1_ROOT>;
++					 <&clk IMX8MM_CLK_AHB>;
+ 				clock-names = "ipg", "ahb";
+ 				#dma-cells = <3>;
+ 				fsl,sdma-ram-script-name = "imx/sdma/sdma-imx7d.bin";
+diff --git a/arch/arm64/boot/dts/freescale/imx8mq-librem5-devkit.dts b/arch/arm64/boot/dts/freescale/imx8mq-librem5-devkit.dts
+index 683a11035643..98cfe67b7db7 100644
+--- a/arch/arm64/boot/dts/freescale/imx8mq-librem5-devkit.dts
++++ b/arch/arm64/boot/dts/freescale/imx8mq-librem5-devkit.dts
+@@ -421,7 +421,7 @@
+ 		pinctrl-names = "default";
+ 		pinctrl-0 = <&pinctrl_imu>;
+ 		interrupt-parent = <&gpio3>;
+-		interrupts = <19 IRQ_TYPE_LEVEL_LOW>;
++		interrupts = <19 IRQ_TYPE_LEVEL_HIGH>;
+ 		vdd-supply = <&reg_3v3_p>;
+ 		vddio-supply = <&reg_3v3_p>;
+ 	};
+diff --git a/arch/arm64/boot/dts/intel/socfpga_agilex.dtsi b/arch/arm64/boot/dts/intel/socfpga_agilex.dtsi
+index 36abc25320a8..d2cb28da3fff 100644
+--- a/arch/arm64/boot/dts/intel/socfpga_agilex.dtsi
++++ b/arch/arm64/boot/dts/intel/socfpga_agilex.dtsi
+@@ -47,10 +47,10 @@
+ 
+ 	pmu {
+ 		compatible = "arm,armv8-pmuv3";
+-		interrupts = <0 120 8>,
+-			     <0 121 8>,
+-			     <0 122 8>,
+-			     <0 123 8>;
++		interrupts = <0 170 4>,
++			     <0 171 4>,
++			     <0 172 4>,
++			     <0 173 4>;
+ 		interrupt-affinity = <&cpu0>,
+ 				     <&cpu1>,
+ 				     <&cpu2>,
+diff --git a/arch/arm64/boot/dts/marvell/armada-ap806-dual.dtsi b/arch/arm64/boot/dts/marvell/armada-ap806-dual.dtsi
+index 9024a2d9db07..62ae016ee6aa 100644
+--- a/arch/arm64/boot/dts/marvell/armada-ap806-dual.dtsi
++++ b/arch/arm64/boot/dts/marvell/armada-ap806-dual.dtsi
+@@ -21,6 +21,7 @@
+ 			reg = <0x000>;
+ 			enable-method = "psci";
+ 			#cooling-cells = <2>;
++			clocks = <&cpu_clk 0>;
+ 		};
+ 		cpu1: cpu@1 {
+ 			device_type = "cpu";
+@@ -28,6 +29,7 @@
+ 			reg = <0x001>;
+ 			enable-method = "psci";
+ 			#cooling-cells = <2>;
++			clocks = <&cpu_clk 0>;
+ 		};
+ 	};
+ };
+diff --git a/arch/arm64/boot/dts/marvell/armada-cp110.dtsi b/arch/arm64/boot/dts/marvell/armada-cp110.dtsi
+index d81944902650..8259fc8f86f2 100644
+--- a/arch/arm64/boot/dts/marvell/armada-cp110.dtsi
++++ b/arch/arm64/boot/dts/marvell/armada-cp110.dtsi
+@@ -438,10 +438,10 @@
+ 
+ 		CP110_LABEL(nand_controller): nand@720000 {
+ 			/*
+-			* Due to the limitation of the pins available
+-			* this controller is only usable on the CPM
+-			* for A7K and on the CPS for A8K.
+-			*/
++			 * Due to the limitation of the pins available
++			 * this controller is only usable on the CPM
++			 * for A7K and on the CPS for A8K.
++			 */
+ 			compatible = "marvell,armada-8k-nand-controller",
+ 				"marvell,armada370-nand-controller";
+ 			reg = <0x720000 0x54>;
+diff --git a/arch/arm64/boot/dts/qcom/msm8998-mtp.dtsi b/arch/arm64/boot/dts/qcom/msm8998-mtp.dtsi
+index 108667ce4f31..8d15572d18e6 100644
+--- a/arch/arm64/boot/dts/qcom/msm8998-mtp.dtsi
++++ b/arch/arm64/boot/dts/qcom/msm8998-mtp.dtsi
+@@ -27,6 +27,66 @@
+ 	status = "okay";
+ };
+ 
++&etf {
++	status = "okay";
++};
++
++&etm1 {
++	status = "okay";
++};
++
++&etm2 {
++	status = "okay";
++};
++
++&etm3 {
++	status = "okay";
++};
++
++&etm4 {
++	status = "okay";
++};
++
++&etm5 {
++	status = "okay";
++};
++
++&etm6 {
++	status = "okay";
++};
++
++&etm7 {
++	status = "okay";
++};
++
++&etm8 {
++	status = "okay";
++};
++
++&etr {
++	status = "okay";
++};
++
++&funnel1 {
++	status = "okay";
++};
++
++&funnel2 {
++	status = "okay";
++};
++
++&funnel3 {
++	status = "okay";
++};
++
++&funnel4 {
++	status = "okay";
++};
++
++&funnel5 {
++	status = "okay";
++};
++
+ &pm8005_lsid1 {
+ 	pm8005-regulators {
+ 		compatible = "qcom,pm8005-regulators";
+@@ -51,6 +111,10 @@
+ 	vdda-phy-dpdm-supply = <&vreg_l24a_3p075>;
+ };
+ 
++&replicator1 {
++	status = "okay";
++};
++
+ &rpm_requests {
+ 	pm8998-regulators {
+ 		compatible = "qcom,rpm-pm8998-regulators";
+@@ -249,6 +313,10 @@
+ 	pinctrl-1 = <&sdc2_clk_off &sdc2_cmd_off &sdc2_data_off &sdc2_cd_off>;
+ };
+ 
++&stm {
++	status = "okay";
++};
++
+ &ufshc {
+ 	vcc-supply = <&vreg_l20a_2p95>;
+ 	vccq-supply = <&vreg_l26a_1p2>;
+diff --git a/arch/arm64/boot/dts/qcom/msm8998.dtsi b/arch/arm64/boot/dts/qcom/msm8998.dtsi
+index c6f81431983e..ffb64fc239ee 100644
+--- a/arch/arm64/boot/dts/qcom/msm8998.dtsi
++++ b/arch/arm64/boot/dts/qcom/msm8998.dtsi
+@@ -998,11 +998,12 @@
+ 			#interrupt-cells = <0x2>;
+ 		};
+ 
+-		stm@6002000 {
++		stm: stm@6002000 {
+ 			compatible = "arm,coresight-stm", "arm,primecell";
+ 			reg = <0x06002000 0x1000>,
+ 			      <0x16280000 0x180000>;
+ 			reg-names = "stm-base", "stm-data-base";
++			status = "disabled";
+ 
+ 			clocks = <&rpmcc RPM_SMD_QDSS_CLK>, <&rpmcc RPM_SMD_QDSS_A_CLK>;
+ 			clock-names = "apb_pclk", "atclk";
+@@ -1016,9 +1017,10 @@
+ 			};
+ 		};
+ 
+-		funnel@6041000 {
++		funnel1: funnel@6041000 {
+ 			compatible = "arm,coresight-dynamic-funnel", "arm,primecell";
+ 			reg = <0x06041000 0x1000>;
++			status = "disabled";
+ 
+ 			clocks = <&rpmcc RPM_SMD_QDSS_CLK>, <&rpmcc RPM_SMD_QDSS_A_CLK>;
+ 			clock-names = "apb_pclk", "atclk";
+@@ -1045,9 +1047,10 @@
+ 			};
+ 		};
+ 
+-		funnel@6042000 {
++		funnel2: funnel@6042000 {
+ 			compatible = "arm,coresight-dynamic-funnel", "arm,primecell";
+ 			reg = <0x06042000 0x1000>;
++			status = "disabled";
+ 
+ 			clocks = <&rpmcc RPM_SMD_QDSS_CLK>, <&rpmcc RPM_SMD_QDSS_A_CLK>;
+ 			clock-names = "apb_pclk", "atclk";
+@@ -1075,9 +1078,10 @@
+ 			};
+ 		};
+ 
+-		funnel@6045000 {
++		funnel3: funnel@6045000 {
+ 			compatible = "arm,coresight-dynamic-funnel", "arm,primecell";
+ 			reg = <0x06045000 0x1000>;
++			status = "disabled";
+ 
+ 			clocks = <&rpmcc RPM_SMD_QDSS_CLK>, <&rpmcc RPM_SMD_QDSS_A_CLK>;
+ 			clock-names = "apb_pclk", "atclk";
+@@ -1113,9 +1117,10 @@
+ 			};
+ 		};
+ 
+-		replicator@6046000 {
++		replicator1: replicator@6046000 {
+ 			compatible = "arm,coresight-dynamic-replicator", "arm,primecell";
+ 			reg = <0x06046000 0x1000>;
++			status = "disabled";
+ 
+ 			clocks = <&rpmcc RPM_SMD_QDSS_CLK>, <&rpmcc RPM_SMD_QDSS_A_CLK>;
+ 			clock-names = "apb_pclk", "atclk";
+@@ -1137,9 +1142,10 @@
+ 			};
+ 		};
+ 
+-		etf@6047000 {
++		etf: etf@6047000 {
+ 			compatible = "arm,coresight-tmc", "arm,primecell";
+ 			reg = <0x06047000 0x1000>;
++			status = "disabled";
+ 
+ 			clocks = <&rpmcc RPM_SMD_QDSS_CLK>, <&rpmcc RPM_SMD_QDSS_A_CLK>;
+ 			clock-names = "apb_pclk", "atclk";
+@@ -1163,9 +1169,10 @@
+ 			};
+ 		};
+ 
+-		etr@6048000 {
++		etr: etr@6048000 {
+ 			compatible = "arm,coresight-tmc", "arm,primecell";
+ 			reg = <0x06048000 0x1000>;
++			status = "disabled";
+ 
+ 			clocks = <&rpmcc RPM_SMD_QDSS_CLK>, <&rpmcc RPM_SMD_QDSS_A_CLK>;
+ 			clock-names = "apb_pclk", "atclk";
+@@ -1181,9 +1188,10 @@
+ 			};
+ 		};
+ 
+-		etm@7840000 {
++		etm1: etm@7840000 {
+ 			compatible = "arm,coresight-etm4x", "arm,primecell";
+ 			reg = <0x07840000 0x1000>;
++			status = "disabled";
+ 
+ 			clocks = <&rpmcc RPM_SMD_QDSS_CLK>, <&rpmcc RPM_SMD_QDSS_A_CLK>;
+ 			clock-names = "apb_pclk", "atclk";
+@@ -1200,9 +1208,10 @@
+ 			};
+ 		};
+ 
+-		etm@7940000 {
++		etm2: etm@7940000 {
+ 			compatible = "arm,coresight-etm4x", "arm,primecell";
+ 			reg = <0x07940000 0x1000>;
++			status = "disabled";
+ 
+ 			clocks = <&rpmcc RPM_SMD_QDSS_CLK>, <&rpmcc RPM_SMD_QDSS_A_CLK>;
+ 			clock-names = "apb_pclk", "atclk";
+@@ -1219,9 +1228,10 @@
+ 			};
+ 		};
+ 
+-		etm@7a40000 {
++		etm3: etm@7a40000 {
+ 			compatible = "arm,coresight-etm4x", "arm,primecell";
+ 			reg = <0x07a40000 0x1000>;
++			status = "disabled";
+ 
+ 			clocks = <&rpmcc RPM_SMD_QDSS_CLK>, <&rpmcc RPM_SMD_QDSS_A_CLK>;
+ 			clock-names = "apb_pclk", "atclk";
+@@ -1238,9 +1248,10 @@
+ 			};
+ 		};
+ 
+-		etm@7b40000 {
++		etm4: etm@7b40000 {
+ 			compatible = "arm,coresight-etm4x", "arm,primecell";
+ 			reg = <0x07b40000 0x1000>;
++			status = "disabled";
+ 
+ 			clocks = <&rpmcc RPM_SMD_QDSS_CLK>, <&rpmcc RPM_SMD_QDSS_A_CLK>;
+ 			clock-names = "apb_pclk", "atclk";
+@@ -1257,9 +1268,10 @@
+ 			};
+ 		};
+ 
+-		funnel@7b60000 { /* APSS Funnel */
++		funnel4: funnel@7b60000 { /* APSS Funnel */
+ 			compatible = "arm,coresight-etm4x", "arm,primecell";
+ 			reg = <0x07b60000 0x1000>;
++			status = "disabled";
+ 
+ 			clocks = <&rpmcc RPM_SMD_QDSS_CLK>, <&rpmcc RPM_SMD_QDSS_A_CLK>;
+ 			clock-names = "apb_pclk", "atclk";
+@@ -1343,9 +1355,10 @@
+ 			};
+ 		};
+ 
+-		funnel@7b70000 {
++		funnel5: funnel@7b70000 {
+ 			compatible = "arm,coresight-dynamic-funnel", "arm,primecell";
+ 			reg = <0x07b70000 0x1000>;
++			status = "disabled";
+ 
+ 			clocks = <&rpmcc RPM_SMD_QDSS_CLK>, <&rpmcc RPM_SMD_QDSS_A_CLK>;
+ 			clock-names = "apb_pclk", "atclk";
+@@ -1369,9 +1382,10 @@
+ 			};
+ 		};
+ 
+-		etm@7c40000 {
++		etm5: etm@7c40000 {
+ 			compatible = "arm,coresight-etm4x", "arm,primecell";
+ 			reg = <0x07c40000 0x1000>;
++			status = "disabled";
+ 
+ 			clocks = <&rpmcc RPM_SMD_QDSS_CLK>, <&rpmcc RPM_SMD_QDSS_A_CLK>;
+ 			clock-names = "apb_pclk", "atclk";
+@@ -1385,9 +1399,10 @@
+ 			};
+ 		};
+ 
+-		etm@7d40000 {
++		etm6: etm@7d40000 {
+ 			compatible = "arm,coresight-etm4x", "arm,primecell";
+ 			reg = <0x07d40000 0x1000>;
++			status = "disabled";
+ 
+ 			clocks = <&rpmcc RPM_SMD_QDSS_CLK>, <&rpmcc RPM_SMD_QDSS_A_CLK>;
+ 			clock-names = "apb_pclk", "atclk";
+@@ -1401,9 +1416,10 @@
+ 			};
+ 		};
+ 
+-		etm@7e40000 {
++		etm7: etm@7e40000 {
+ 			compatible = "arm,coresight-etm4x", "arm,primecell";
+ 			reg = <0x07e40000 0x1000>;
++			status = "disabled";
+ 
+ 			clocks = <&rpmcc RPM_SMD_QDSS_CLK>, <&rpmcc RPM_SMD_QDSS_A_CLK>;
+ 			clock-names = "apb_pclk", "atclk";
+@@ -1417,9 +1433,10 @@
+ 			};
+ 		};
+ 
+-		etm@7f40000 {
++		etm8: etm@7f40000 {
+ 			compatible = "arm,coresight-etm4x", "arm,primecell";
+ 			reg = <0x07f40000 0x1000>;
++			status = "disabled";
+ 
+ 			clocks = <&rpmcc RPM_SMD_QDSS_CLK>, <&rpmcc RPM_SMD_QDSS_A_CLK>;
+ 			clock-names = "apb_pclk", "atclk";
+diff --git a/arch/arm64/boot/dts/qcom/sdm845-cheza.dtsi b/arch/arm64/boot/dts/qcom/sdm845-cheza.dtsi
+index 34881c0113cb..99a28d64ee62 100644
+--- a/arch/arm64/boot/dts/qcom/sdm845-cheza.dtsi
++++ b/arch/arm64/boot/dts/qcom/sdm845-cheza.dtsi
+@@ -165,6 +165,8 @@
+ /delete-node/ &venus_mem;
+ /delete-node/ &cdsp_mem;
+ /delete-node/ &cdsp_pas;
++/delete-node/ &zap_shader;
++/delete-node/ &gpu_mem;
+ 
+ /* Increase the size from 120 MB to 128 MB */
+ &mpss_region {
+diff --git a/arch/arm64/boot/dts/qcom/sdm845.dtsi b/arch/arm64/boot/dts/qcom/sdm845.dtsi
+index f406a4340b05..2287354fef86 100644
+--- a/arch/arm64/boot/dts/qcom/sdm845.dtsi
++++ b/arch/arm64/boot/dts/qcom/sdm845.dtsi
+@@ -2824,7 +2824,7 @@
+ 
+ 			qcom,gmu = <&gmu>;
+ 
+-			zap-shader {
++			zap_shader: zap-shader {
+ 				memory-region = <&gpu_mem>;
+ 			};
+ 
+diff --git a/arch/arm64/boot/dts/renesas/hihope-common.dtsi b/arch/arm64/boot/dts/renesas/hihope-common.dtsi
+index 3e376d29a730..69585d6e3653 100644
+--- a/arch/arm64/boot/dts/renesas/hihope-common.dtsi
++++ b/arch/arm64/boot/dts/renesas/hihope-common.dtsi
+@@ -86,7 +86,7 @@
+ 
+ 		label = "rcar-sound";
+ 
+-		dais = <&rsnd_port0>;
++		dais = <&rsnd_port>;
+ 	};
+ 
+ 	vbus0_usb2: regulator-vbus0-usb2 {
+@@ -191,7 +191,7 @@
+ 		port@2 {
+ 			reg = <2>;
+ 			dw_hdmi0_snd_in: endpoint {
+-				remote-endpoint = <&rsnd_endpoint0>;
++				remote-endpoint = <&rsnd_endpoint>;
+ 			};
+ 		};
+ 	};
+@@ -327,17 +327,15 @@
+ 	/* Single DAI */
+ 	#sound-dai-cells = <0>;
+ 
+-	ports {
+-		rsnd_port0: port@0 {
+-			rsnd_endpoint0: endpoint {
+-				remote-endpoint = <&dw_hdmi0_snd_in>;
++	rsnd_port: port {
++		rsnd_endpoint: endpoint {
++			remote-endpoint = <&dw_hdmi0_snd_in>;
+ 
+-				dai-format = "i2s";
+-				bitclock-master = <&rsnd_endpoint0>;
+-				frame-master = <&rsnd_endpoint0>;
++			dai-format = "i2s";
++			bitclock-master = <&rsnd_endpoint>;
++			frame-master = <&rsnd_endpoint>;
+ 
+-				playback = <&ssi2>;
+-			};
++			playback = <&ssi2>;
+ 		};
+ 	};
+ };
+diff --git a/arch/arm64/boot/dts/renesas/r8a774a1.dtsi b/arch/arm64/boot/dts/renesas/r8a774a1.dtsi
+index 06c7c849c8ab..c2a7ec3fc209 100644
+--- a/arch/arm64/boot/dts/renesas/r8a774a1.dtsi
++++ b/arch/arm64/boot/dts/renesas/r8a774a1.dtsi
+@@ -1726,17 +1726,6 @@
+ 				      "ssi.1", "ssi.0";
+ 			status = "disabled";
+ 
+-			ports {
+-				#address-cells = <1>;
+-				#size-cells = <0>;
+-				port@0 {
+-					reg = <0>;
+-				};
+-				port@1 {
+-					reg = <1>;
+-				};
+-			};
+-
+ 			rcar_sound,ctu {
+ 				ctu00: ctu-0 { };
+ 				ctu01: ctu-1 { };
+diff --git a/arch/arm64/boot/dts/renesas/r8a77970.dtsi b/arch/arm64/boot/dts/renesas/r8a77970.dtsi
+index 0cd3b376635d..4952981bb6ba 100644
+--- a/arch/arm64/boot/dts/renesas/r8a77970.dtsi
++++ b/arch/arm64/boot/dts/renesas/r8a77970.dtsi
+@@ -652,7 +652,7 @@
+ 		};
+ 
+ 		pwm3: pwm@e6e33000 {
+-			compatible = "renesas,pwm-r8a7790", "renesas,pwm-rcar";
++			compatible = "renesas,pwm-r8a77970", "renesas,pwm-rcar";
+ 			reg = <0 0xe6e33000 0 8>;
+ 			#pwm-cells = <2>;
+ 			clocks = <&cpg CPG_MOD 523>;
+diff --git a/arch/s390/kernel/setup.c b/arch/s390/kernel/setup.c
+index 3ff291bc63b7..b95e6fa34cc8 100644
+--- a/arch/s390/kernel/setup.c
++++ b/arch/s390/kernel/setup.c
+@@ -1059,7 +1059,7 @@ static void __init log_component_list(void)
+ 
+ 	if (!early_ipl_comp_list_addr)
+ 		return;
+-	if (ipl_block.hdr.flags & IPL_PL_FLAG_IPLSR)
++	if (ipl_block.hdr.flags & IPL_PL_FLAG_SIPL)
+ 		pr_info("Linux is running with Secure-IPL enabled\n");
+ 	else
+ 		pr_info("Linux is running with Secure-IPL disabled\n");
+diff --git a/arch/um/drivers/Kconfig b/arch/um/drivers/Kconfig
+index fea5a0d522dc..388096fb45a2 100644
+--- a/arch/um/drivers/Kconfig
++++ b/arch/um/drivers/Kconfig
+@@ -337,7 +337,7 @@ config UML_NET_SLIRP
+ endmenu
+ 
+ config VIRTIO_UML
+-	tristate "UML driver for virtio devices"
++	bool "UML driver for virtio devices"
+ 	select VIRTIO
+ 	help
+ 	  This driver provides support for virtio based paravirtual device
+diff --git a/arch/um/drivers/virtio_uml.c b/arch/um/drivers/virtio_uml.c
+index c5643a59a8c7..179b41ad63ba 100644
+--- a/arch/um/drivers/virtio_uml.c
++++ b/arch/um/drivers/virtio_uml.c
+@@ -4,12 +4,12 @@
+  *
+  * Copyright(c) 2019 Intel Corporation
+  *
+- * This module allows virtio devices to be used over a vhost-user socket.
++ * This driver allows virtio devices to be used over a vhost-user socket.
+  *
+  * Guest devices can be instantiated by kernel module or command line
+  * parameters. One device will be created for each parameter. Syntax:
+  *
+- *		[virtio_uml.]device=<socket>:<virtio_id>[:<platform_id>]
++ *		virtio_uml.device=<socket>:<virtio_id>[:<platform_id>]
+  * where:
+  *		<socket>	:= vhost-user socket path to connect
+  *		<virtio_id>	:= virtio device id (as in virtio_ids.h)
+diff --git a/arch/um/os-Linux/main.c b/arch/um/os-Linux/main.c
+index 8014dfac644d..c8a42ecbd7a2 100644
+--- a/arch/um/os-Linux/main.c
++++ b/arch/um/os-Linux/main.c
+@@ -170,7 +170,7 @@ int __init main(int argc, char **argv, char **envp)
+ 	 * that they won't be delivered after the exec, when
+ 	 * they are definitely not expected.
+ 	 */
+-	unblock_signals_trace();
++	unblock_signals();
+ 
+ 	os_info("\n");
+ 	/* Reboot */
+diff --git a/arch/x86/boot/compressed/head_64.S b/arch/x86/boot/compressed/head_64.S
+index d98cd483377e..e9a7f7cadb12 100644
+--- a/arch/x86/boot/compressed/head_64.S
++++ b/arch/x86/boot/compressed/head_64.S
+@@ -244,6 +244,11 @@ ENTRY(efi32_stub_entry)
+ 	leal	efi32_config(%ebp), %eax
+ 	movl	%eax, efi_config(%ebp)
+ 
++	/* Disable paging */
++	movl	%cr0, %eax
++	btrl	$X86_CR0_PG_BIT, %eax
++	movl	%eax, %cr0
++
+ 	jmp	startup_32
+ ENDPROC(efi32_stub_entry)
+ #endif
+diff --git a/arch/x86/events/intel/uncore_snbep.c b/arch/x86/events/intel/uncore_snbep.c
+index b10a5ec79e48..011644802ce7 100644
+--- a/arch/x86/events/intel/uncore_snbep.c
++++ b/arch/x86/events/intel/uncore_snbep.c
+@@ -4536,6 +4536,7 @@ static struct uncore_event_desc snr_uncore_imc_freerunning_events[] = {
+ 	INTEL_UNCORE_EVENT_DESC(write,		"event=0xff,umask=0x21"),
+ 	INTEL_UNCORE_EVENT_DESC(write.scale,	"3.814697266e-6"),
+ 	INTEL_UNCORE_EVENT_DESC(write.unit,	"MiB"),
++	{ /* end: all zeroes */ },
+ };
+ 
+ static struct intel_uncore_ops snr_uncore_imc_freerunning_ops = {
+diff --git a/arch/x86/kernel/cpu/amd.c b/arch/x86/kernel/cpu/amd.c
+index 90f75e515876..62c30279be77 100644
+--- a/arch/x86/kernel/cpu/amd.c
++++ b/arch/x86/kernel/cpu/amd.c
+@@ -615,9 +615,9 @@ static void early_detect_mem_encrypt(struct cpuinfo_x86 *c)
+ 		return;
+ 
+ clear_all:
+-		clear_cpu_cap(c, X86_FEATURE_SME);
++		setup_clear_cpu_cap(X86_FEATURE_SME);
+ clear_sev:
+-		clear_cpu_cap(c, X86_FEATURE_SEV);
++		setup_clear_cpu_cap(X86_FEATURE_SEV);
+ 	}
+ }
+ 
+diff --git a/arch/x86/kernel/cpu/resctrl/core.c b/arch/x86/kernel/cpu/resctrl/core.c
+index 03eb90d00af0..89049b343c7a 100644
+--- a/arch/x86/kernel/cpu/resctrl/core.c
++++ b/arch/x86/kernel/cpu/resctrl/core.c
+@@ -618,7 +618,7 @@ static void domain_remove_cpu(int cpu, struct rdt_resource *r)
+ 		if (static_branch_unlikely(&rdt_mon_enable_key))
+ 			rmdir_mondata_subdir_allrdtgrp(r, d->id);
+ 		list_del(&d->list);
+-		if (is_mbm_enabled())
++		if (r->mon_capable && is_mbm_enabled())
+ 			cancel_delayed_work(&d->mbm_over);
+ 		if (is_llc_occupancy_enabled() &&  has_busy_rmid(r, d)) {
+ 			/*
+diff --git a/arch/x86/kernel/cpu/resctrl/rdtgroup.c b/arch/x86/kernel/cpu/resctrl/rdtgroup.c
+index 2e3b06d6bbc6..dac7209a0708 100644
+--- a/arch/x86/kernel/cpu/resctrl/rdtgroup.c
++++ b/arch/x86/kernel/cpu/resctrl/rdtgroup.c
+@@ -1741,9 +1741,6 @@ static int set_cache_qos_cfg(int level, bool enable)
+ 	struct rdt_domain *d;
+ 	int cpu;
+ 
+-	if (!zalloc_cpumask_var(&cpu_mask, GFP_KERNEL))
+-		return -ENOMEM;
+-
+ 	if (level == RDT_RESOURCE_L3)
+ 		update = l3_qos_cfg_update;
+ 	else if (level == RDT_RESOURCE_L2)
+@@ -1751,6 +1748,9 @@ static int set_cache_qos_cfg(int level, bool enable)
+ 	else
+ 		return -EINVAL;
+ 
++	if (!zalloc_cpumask_var(&cpu_mask, GFP_KERNEL))
++		return -ENOMEM;
++
+ 	r_l = &rdt_resources_all[level];
+ 	list_for_each_entry(d, &r_l->domains, list) {
+ 		/* Pick one CPU from each domain instance to update MSR */
+diff --git a/block/blk-settings.c b/block/blk-settings.c
+index 5f6dcc7a47bd..c8eda2e7b91e 100644
+--- a/block/blk-settings.c
++++ b/block/blk-settings.c
+@@ -328,7 +328,7 @@ EXPORT_SYMBOL(blk_queue_max_segment_size);
+  *   storage device can address.  The default of 512 covers most
+  *   hardware.
+  **/
+-void blk_queue_logical_block_size(struct request_queue *q, unsigned short size)
++void blk_queue_logical_block_size(struct request_queue *q, unsigned int size)
+ {
+ 	q->limits.logical_block_size = size;
+ 
+diff --git a/block/bsg-lib.c b/block/bsg-lib.c
+index 347dda16c2f4..6cbb7926534c 100644
+--- a/block/bsg-lib.c
++++ b/block/bsg-lib.c
+@@ -266,7 +266,7 @@ static blk_status_t bsg_queue_rq(struct blk_mq_hw_ctx *hctx,
+ 	struct request *req = bd->rq;
+ 	struct bsg_set *bset =
+ 		container_of(q->tag_set, struct bsg_set, tag_set);
+-	int sts = BLK_STS_IOERR;
++	blk_status_t sts = BLK_STS_IOERR;
+ 	int ret;
+ 
+ 	blk_mq_start_request(req);
+diff --git a/drivers/base/firmware_loader/builtin/Makefile b/drivers/base/firmware_loader/builtin/Makefile
+index 4a66888e7253..5fa7ce3745a0 100644
+--- a/drivers/base/firmware_loader/builtin/Makefile
++++ b/drivers/base/firmware_loader/builtin/Makefile
+@@ -17,7 +17,7 @@ PROGBITS  = $(if $(CONFIG_ARM),%,@)progbits
+ filechk_fwbin = \
+ 	echo "/* Generated by $(src)/Makefile */"		;\
+ 	echo "    .section .rodata"				;\
+-	echo "    .p2align $(ASM_ALIGN)"			;\
++	echo "    .p2align 4"					;\
+ 	echo "_fw_$(FWSTR)_bin:"				;\
+ 	echo "    .incbin \"$(fwdir)/$(FWNAME)\""		;\
+ 	echo "_fw_end:"						;\
+diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
+index a74d03913822..c02be06c5299 100644
+--- a/drivers/block/xen-blkfront.c
++++ b/drivers/block/xen-blkfront.c
+@@ -1113,8 +1113,8 @@ static int xlvbd_alloc_gendisk(blkif_sector_t capacity,
+ 	if (!VDEV_IS_EXTENDED(info->vdevice)) {
+ 		err = xen_translate_vdev(info->vdevice, &minor, &offset);
+ 		if (err)
+-			return err;		
+- 		nr_parts = PARTS_PER_DISK;
++			return err;
++		nr_parts = PARTS_PER_DISK;
+ 	} else {
+ 		minor = BLKIF_MINOR_EXT(info->vdevice);
+ 		nr_parts = PARTS_PER_EXT_DISK;
+diff --git a/drivers/bus/ti-sysc.c b/drivers/bus/ti-sysc.c
+index 34bd9bf4e68a..abbf281ee337 100644
+--- a/drivers/bus/ti-sysc.c
++++ b/drivers/bus/ti-sysc.c
+@@ -343,6 +343,12 @@ static int sysc_get_clocks(struct sysc *ddata)
+ 		return -EINVAL;
+ 	}
+ 
++	/* Always add a slot for main clocks fck and ick even if unused */
++	if (!nr_fck)
++		ddata->nr_clocks++;
++	if (!nr_ick)
++		ddata->nr_clocks++;
++
+ 	ddata->clocks = devm_kcalloc(ddata->dev,
+ 				     ddata->nr_clocks, sizeof(*ddata->clocks),
+ 				     GFP_KERNEL);
+@@ -421,7 +427,7 @@ static int sysc_enable_opt_clocks(struct sysc *ddata)
+ 	struct clk *clock;
+ 	int i, error;
+ 
+-	if (!ddata->clocks)
++	if (!ddata->clocks || ddata->nr_clocks < SYSC_OPTFCK0 + 1)
+ 		return 0;
+ 
+ 	for (i = SYSC_OPTFCK0; i < SYSC_MAX_CLOCKS; i++) {
+@@ -455,7 +461,7 @@ static void sysc_disable_opt_clocks(struct sysc *ddata)
+ 	struct clk *clock;
+ 	int i;
+ 
+-	if (!ddata->clocks)
++	if (!ddata->clocks || ddata->nr_clocks < SYSC_OPTFCK0 + 1)
+ 		return;
+ 
+ 	for (i = SYSC_OPTFCK0; i < SYSC_MAX_CLOCKS; i++) {
+diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
+index 4fc294c2f9e8..67f592fa083a 100644
+--- a/drivers/clk/clk.c
++++ b/drivers/clk/clk.c
+@@ -3408,11 +3408,17 @@ static int __clk_core_init(struct clk_core *core)
+ 	if (core->flags & CLK_IS_CRITICAL) {
+ 		unsigned long flags;
+ 
+-		clk_core_prepare(core);
++		ret = clk_core_prepare(core);
++		if (ret)
++			goto out;
+ 
+ 		flags = clk_enable_lock();
+-		clk_core_enable(core);
++		ret = clk_core_enable(core);
+ 		clk_enable_unlock(flags);
++		if (ret) {
++			clk_core_unprepare(core);
++			goto out;
++		}
+ 	}
+ 
+ 	clk_core_reparent_orphans_nolock();
+diff --git a/drivers/clk/imx/clk-imx7ulp.c b/drivers/clk/imx/clk-imx7ulp.c
+index a0f650150367..04a3ae979281 100644
+--- a/drivers/clk/imx/clk-imx7ulp.c
++++ b/drivers/clk/imx/clk-imx7ulp.c
+@@ -24,8 +24,8 @@ static const char * const spll_pfd_sels[]	= { "spll_pfd0", "spll_pfd1", "spll_pf
+ static const char * const spll_sels[]		= { "spll", "spll_pfd_sel", };
+ static const char * const apll_pfd_sels[]	= { "apll_pfd0", "apll_pfd1", "apll_pfd2", "apll_pfd3", };
+ static const char * const apll_sels[]		= { "apll", "apll_pfd_sel", };
+-static const char * const scs_sels[]		= { "dummy", "sosc", "sirc", "firc", "dummy", "apll_sel", "spll_sel", "upll", };
+-static const char * const ddr_sels[]		= { "apll_pfd_sel", "upll", };
++static const char * const scs_sels[]		= { "dummy", "sosc", "sirc", "firc", "dummy", "apll_sel", "spll_sel", "dummy", };
++static const char * const ddr_sels[]		= { "apll_pfd_sel", "dummy", "dummy", "dummy", };
+ static const char * const nic_sels[]		= { "firc", "ddr_clk", };
+ static const char * const periph_plat_sels[]	= { "dummy", "nic1_bus_clk", "nic1_clk", "ddr_clk", "apll_pfd2", "apll_pfd1", "apll_pfd0", "upll", };
+ static const char * const periph_bus_sels[]	= { "dummy", "sosc_bus_clk", "mpll", "firc_bus_clk", "rosc", "nic1_bus_clk", "nic1_clk", "spll_bus_clk", };
+@@ -119,7 +119,7 @@ static void __init imx7ulp_clk_scg1_init(struct device_node *np)
+ 	clks[IMX7ULP_CLK_SYS_SEL]	= imx_clk_hw_mux2("scs_sel", base + 0x14, 24, 4, scs_sels, ARRAY_SIZE(scs_sels));
+ 	clks[IMX7ULP_CLK_HSRUN_SYS_SEL] = imx_clk_hw_mux2("hsrun_scs_sel", base + 0x1c, 24, 4, scs_sels, ARRAY_SIZE(scs_sels));
+ 	clks[IMX7ULP_CLK_NIC_SEL]	= imx_clk_hw_mux2("nic_sel", base + 0x40, 28, 1, nic_sels, ARRAY_SIZE(nic_sels));
+-	clks[IMX7ULP_CLK_DDR_SEL]	= imx_clk_hw_mux_flags("ddr_sel", base + 0x30, 24, 1, ddr_sels, ARRAY_SIZE(ddr_sels), CLK_SET_RATE_PARENT | CLK_OPS_PARENT_ENABLE);
++	clks[IMX7ULP_CLK_DDR_SEL]	= imx_clk_hw_mux_flags("ddr_sel", base + 0x30, 24, 2, ddr_sels, ARRAY_SIZE(ddr_sels), CLK_SET_RATE_PARENT | CLK_OPS_PARENT_ENABLE);
+ 
+ 	clks[IMX7ULP_CLK_CORE_DIV]	= imx_clk_hw_divider_flags("divcore",	"scs_sel",  base + 0x14, 16, 4, CLK_SET_RATE_PARENT);
+ 	clks[IMX7ULP_CLK_HSRUN_CORE_DIV] = imx_clk_hw_divider_flags("hsrun_divcore", "hsrun_scs_sel", base + 0x1c, 16, 4, CLK_SET_RATE_PARENT);
+diff --git a/drivers/clk/qcom/gcc-sdm845.c b/drivers/clk/qcom/gcc-sdm845.c
+index 95be125c3bdd..56d22dd225c9 100644
+--- a/drivers/clk/qcom/gcc-sdm845.c
++++ b/drivers/clk/qcom/gcc-sdm845.c
+@@ -3255,6 +3255,7 @@ static struct gdsc hlos1_vote_aggre_noc_mmu_audio_tbu_gdsc = {
+ 		.name = "hlos1_vote_aggre_noc_mmu_audio_tbu_gdsc",
+ 	},
+ 	.pwrsts = PWRSTS_OFF_ON,
++	.flags = VOTABLE,
+ };
+ 
+ static struct gdsc hlos1_vote_aggre_noc_mmu_pcie_tbu_gdsc = {
+@@ -3263,6 +3264,7 @@ static struct gdsc hlos1_vote_aggre_noc_mmu_pcie_tbu_gdsc = {
+ 		.name = "hlos1_vote_aggre_noc_mmu_pcie_tbu_gdsc",
+ 	},
+ 	.pwrsts = PWRSTS_OFF_ON,
++	.flags = VOTABLE,
+ };
+ 
+ static struct gdsc hlos1_vote_aggre_noc_mmu_tbu1_gdsc = {
+@@ -3271,6 +3273,7 @@ static struct gdsc hlos1_vote_aggre_noc_mmu_tbu1_gdsc = {
+ 		.name = "hlos1_vote_aggre_noc_mmu_tbu1_gdsc",
+ 	},
+ 	.pwrsts = PWRSTS_OFF_ON,
++	.flags = VOTABLE,
+ };
+ 
+ static struct gdsc hlos1_vote_aggre_noc_mmu_tbu2_gdsc = {
+@@ -3279,6 +3282,7 @@ static struct gdsc hlos1_vote_aggre_noc_mmu_tbu2_gdsc = {
+ 		.name = "hlos1_vote_aggre_noc_mmu_tbu2_gdsc",
+ 	},
+ 	.pwrsts = PWRSTS_OFF_ON,
++	.flags = VOTABLE,
+ };
+ 
+ static struct gdsc hlos1_vote_mmnoc_mmu_tbu_hf0_gdsc = {
+@@ -3287,6 +3291,7 @@ static struct gdsc hlos1_vote_mmnoc_mmu_tbu_hf0_gdsc = {
+ 		.name = "hlos1_vote_mmnoc_mmu_tbu_hf0_gdsc",
+ 	},
+ 	.pwrsts = PWRSTS_OFF_ON,
++	.flags = VOTABLE,
+ };
+ 
+ static struct gdsc hlos1_vote_mmnoc_mmu_tbu_hf1_gdsc = {
+@@ -3295,6 +3300,7 @@ static struct gdsc hlos1_vote_mmnoc_mmu_tbu_hf1_gdsc = {
+ 		.name = "hlos1_vote_mmnoc_mmu_tbu_hf1_gdsc",
+ 	},
+ 	.pwrsts = PWRSTS_OFF_ON,
++	.flags = VOTABLE,
+ };
+ 
+ static struct gdsc hlos1_vote_mmnoc_mmu_tbu_sf_gdsc = {
+@@ -3303,6 +3309,7 @@ static struct gdsc hlos1_vote_mmnoc_mmu_tbu_sf_gdsc = {
+ 		.name = "hlos1_vote_mmnoc_mmu_tbu_sf_gdsc",
+ 	},
+ 	.pwrsts = PWRSTS_OFF_ON,
++	.flags = VOTABLE,
+ };
+ 
+ static struct clk_regmap *gcc_sdm845_clocks[] = {
+diff --git a/drivers/clk/samsung/clk-exynos5420.c b/drivers/clk/samsung/clk-exynos5420.c
+index 3b7601647d7b..27fd274e92f8 100644
+--- a/drivers/clk/samsung/clk-exynos5420.c
++++ b/drivers/clk/samsung/clk-exynos5420.c
+@@ -12,6 +12,7 @@
+ #include <linux/clk-provider.h>
+ #include <linux/of.h>
+ #include <linux/of_address.h>
++#include <linux/clk.h>
+ 
+ #include "clk.h"
+ #include "clk-cpu.h"
+@@ -1630,6 +1631,13 @@ static void __init exynos5x_clk_init(struct device_node *np,
+ 				     exynos5x_subcmus);
+ 	}
+ 
++	/*
++	 * Keep top part of G3D clock path enabled permanently to ensure
++	 * that the internal busses get their clock regardless of the
++	 * main G3D clock enablement status.
++	 */
++	clk_prepare_enable(__clk_lookup("mout_sw_aclk_g3d"));
++
+ 	samsung_clk_of_add_provider(np, ctx);
+ }
+ 
+diff --git a/drivers/clk/sprd/common.c b/drivers/clk/sprd/common.c
+index 9d56eac43832..7ad5ba26dfba 100644
+--- a/drivers/clk/sprd/common.c
++++ b/drivers/clk/sprd/common.c
+@@ -46,7 +46,7 @@ int sprd_clk_regmap_init(struct platform_device *pdev,
+ 
+ 	if (of_find_property(node, "sprd,syscon", NULL)) {
+ 		regmap = syscon_regmap_lookup_by_phandle(node, "sprd,syscon");
+-		if (IS_ERR_OR_NULL(regmap)) {
++		if (IS_ERR(regmap)) {
+ 			pr_err("%s: failed to get syscon regmap\n", __func__);
+ 			return PTR_ERR(regmap);
+ 		}
+diff --git a/drivers/clk/sunxi-ng/ccu-sun8i-r40.c b/drivers/clk/sunxi-ng/ccu-sun8i-r40.c
+index 897490800102..23bfe1d12f21 100644
+--- a/drivers/clk/sunxi-ng/ccu-sun8i-r40.c
++++ b/drivers/clk/sunxi-ng/ccu-sun8i-r40.c
+@@ -761,7 +761,8 @@ static struct ccu_mp outa_clk = {
+ 		.reg		= 0x1f0,
+ 		.features	= CCU_FEATURE_FIXED_PREDIV,
+ 		.hw.init	= CLK_HW_INIT_PARENTS("outa", out_parents,
+-						      &ccu_mp_ops, 0),
++						      &ccu_mp_ops,
++						      CLK_SET_RATE_PARENT),
+ 	}
+ };
+ 
+@@ -779,7 +780,8 @@ static struct ccu_mp outb_clk = {
+ 		.reg		= 0x1f4,
+ 		.features	= CCU_FEATURE_FIXED_PREDIV,
+ 		.hw.init	= CLK_HW_INIT_PARENTS("outb", out_parents,
+-						      &ccu_mp_ops, 0),
++						      &ccu_mp_ops,
++						      CLK_SET_RATE_PARENT),
+ 	}
+ };
+ 
+diff --git a/drivers/cpuidle/governors/teo.c b/drivers/cpuidle/governors/teo.c
+index b9b9156618e6..703047434ee1 100644
+--- a/drivers/cpuidle/governors/teo.c
++++ b/drivers/cpuidle/governors/teo.c
+@@ -194,7 +194,7 @@ static void teo_update(struct cpuidle_driver *drv, struct cpuidle_device *dev)
+ 	 * pattern detection.
+ 	 */
+ 	cpu_data->intervals[cpu_data->interval_idx++] = measured_us;
+-	if (cpu_data->interval_idx > INTERVALS)
++	if (cpu_data->interval_idx >= INTERVALS)
+ 		cpu_data->interval_idx = 0;
+ }
+ 
+diff --git a/drivers/firmware/efi/earlycon.c b/drivers/firmware/efi/earlycon.c
+index d4077db6dc97..5d4f84781aa0 100644
+--- a/drivers/firmware/efi/earlycon.c
++++ b/drivers/firmware/efi/earlycon.c
+@@ -17,7 +17,7 @@ static const struct console *earlycon_console __initdata;
+ static const struct font_desc *font;
+ static u32 efi_x, efi_y;
+ static u64 fb_base;
+-static pgprot_t fb_prot;
++static bool fb_wb;
+ static void *efi_fb;
+ 
+ /*
+@@ -33,10 +33,8 @@ static int __init efi_earlycon_remap_fb(void)
+ 	if (!earlycon_console || !(earlycon_console->flags & CON_ENABLED))
+ 		return 0;
+ 
+-	if (pgprot_val(fb_prot) == pgprot_val(PAGE_KERNEL))
+-		efi_fb = memremap(fb_base, screen_info.lfb_size, MEMREMAP_WB);
+-	else
+-		efi_fb = memremap(fb_base, screen_info.lfb_size, MEMREMAP_WC);
++	efi_fb = memremap(fb_base, screen_info.lfb_size,
++			  fb_wb ? MEMREMAP_WB : MEMREMAP_WC);
+ 
+ 	return efi_fb ? 0 : -ENOMEM;
+ }
+@@ -53,9 +51,12 @@ late_initcall(efi_earlycon_unmap_fb);
+ 
+ static __ref void *efi_earlycon_map(unsigned long start, unsigned long len)
+ {
++	pgprot_t fb_prot;
++
+ 	if (efi_fb)
+ 		return efi_fb + start;
+ 
++	fb_prot = fb_wb ? PAGE_KERNEL : pgprot_writecombine(PAGE_KERNEL);
+ 	return early_memremap_prot(fb_base + start, len, pgprot_val(fb_prot));
+ }
+ 
+@@ -215,10 +216,7 @@ static int __init efi_earlycon_setup(struct earlycon_device *device,
+ 	if (screen_info.capabilities & VIDEO_CAPABILITY_64BIT_BASE)
+ 		fb_base |= (u64)screen_info.ext_lfb_base << 32;
+ 
+-	if (opt && !strcmp(opt, "ram"))
+-		fb_prot = PAGE_KERNEL;
+-	else
+-		fb_prot = pgprot_writecombine(PAGE_KERNEL);
++	fb_wb = opt && !strcmp(opt, "ram");
+ 
+ 	si = &screen_info;
+ 	xres = si->lfb_width;
+diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
+index 38e096e6925f..ceb908f7dbe5 100644
+--- a/drivers/gpio/Kconfig
++++ b/drivers/gpio/Kconfig
+@@ -546,7 +546,6 @@ config GPIO_THUNDERX
+ 	tristate "Cavium ThunderX/OCTEON-TX GPIO"
+ 	depends on ARCH_THUNDER || (64BIT && COMPILE_TEST)
+ 	depends on PCI_MSI
+-	select GPIOLIB_IRQCHIP
+ 	select IRQ_DOMAIN_HIERARCHY
+ 	select IRQ_FASTEOI_HIERARCHY_HANDLERS
+ 	help
+diff --git a/drivers/gpio/gpio-thunderx.c b/drivers/gpio/gpio-thunderx.c
+index ddad5c7ea617..715371b5102a 100644
+--- a/drivers/gpio/gpio-thunderx.c
++++ b/drivers/gpio/gpio-thunderx.c
+@@ -53,6 +53,7 @@ struct thunderx_line {
+ struct thunderx_gpio {
+ 	struct gpio_chip	chip;
+ 	u8 __iomem		*register_base;
++	struct irq_domain	*irqd;
+ 	struct msix_entry	*msix_entries;	/* per line MSI-X */
+ 	struct thunderx_line	*line_entries;	/* per line irq info */
+ 	raw_spinlock_t		lock;
+@@ -282,60 +283,54 @@ static void thunderx_gpio_set_multiple(struct gpio_chip *chip,
+ 	}
+ }
+ 
+-static void thunderx_gpio_irq_ack(struct irq_data *d)
++static void thunderx_gpio_irq_ack(struct irq_data *data)
+ {
+-	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+-	struct thunderx_gpio *txgpio = gpiochip_get_data(gc);
++	struct thunderx_line *txline = irq_data_get_irq_chip_data(data);
+ 
+ 	writeq(GPIO_INTR_INTR,
+-	       txgpio->register_base + intr_reg(irqd_to_hwirq(d)));
++	       txline->txgpio->register_base + intr_reg(txline->line));
+ }
+ 
+-static void thunderx_gpio_irq_mask(struct irq_data *d)
++static void thunderx_gpio_irq_mask(struct irq_data *data)
+ {
+-	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+-	struct thunderx_gpio *txgpio = gpiochip_get_data(gc);
++	struct thunderx_line *txline = irq_data_get_irq_chip_data(data);
+ 
+ 	writeq(GPIO_INTR_ENA_W1C,
+-	       txgpio->register_base + intr_reg(irqd_to_hwirq(d)));
++	       txline->txgpio->register_base + intr_reg(txline->line));
+ }
+ 
+-static void thunderx_gpio_irq_mask_ack(struct irq_data *d)
++static void thunderx_gpio_irq_mask_ack(struct irq_data *data)
+ {
+-	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+-	struct thunderx_gpio *txgpio = gpiochip_get_data(gc);
++	struct thunderx_line *txline = irq_data_get_irq_chip_data(data);
+ 
+ 	writeq(GPIO_INTR_ENA_W1C | GPIO_INTR_INTR,
+-	       txgpio->register_base + intr_reg(irqd_to_hwirq(d)));
++	       txline->txgpio->register_base + intr_reg(txline->line));
+ }
+ 
+-static void thunderx_gpio_irq_unmask(struct irq_data *d)
++static void thunderx_gpio_irq_unmask(struct irq_data *data)
+ {
+-	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+-	struct thunderx_gpio *txgpio = gpiochip_get_data(gc);
++	struct thunderx_line *txline = irq_data_get_irq_chip_data(data);
+ 
+ 	writeq(GPIO_INTR_ENA_W1S,
+-	       txgpio->register_base + intr_reg(irqd_to_hwirq(d)));
++	       txline->txgpio->register_base + intr_reg(txline->line));
+ }
+ 
+-static int thunderx_gpio_irq_set_type(struct irq_data *d,
++static int thunderx_gpio_irq_set_type(struct irq_data *data,
+ 				      unsigned int flow_type)
+ {
+-	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+-	struct thunderx_gpio *txgpio = gpiochip_get_data(gc);
+-	struct thunderx_line *txline =
+-		&txgpio->line_entries[irqd_to_hwirq(d)];
++	struct thunderx_line *txline = irq_data_get_irq_chip_data(data);
++	struct thunderx_gpio *txgpio = txline->txgpio;
+ 	u64 bit_cfg;
+ 
+-	irqd_set_trigger_type(d, flow_type);
++	irqd_set_trigger_type(data, flow_type);
+ 
+ 	bit_cfg = txline->fil_bits | GPIO_BIT_CFG_INT_EN;
+ 
+ 	if (flow_type & IRQ_TYPE_EDGE_BOTH) {
+-		irq_set_handler_locked(d, handle_fasteoi_ack_irq);
++		irq_set_handler_locked(data, handle_fasteoi_ack_irq);
+ 		bit_cfg |= GPIO_BIT_CFG_INT_TYPE;
+ 	} else {
+-		irq_set_handler_locked(d, handle_fasteoi_mask_irq);
++		irq_set_handler_locked(data, handle_fasteoi_mask_irq);
+ 	}
+ 
+ 	raw_spin_lock(&txgpio->lock);
+@@ -364,6 +359,33 @@ static void thunderx_gpio_irq_disable(struct irq_data *data)
+ 	irq_chip_disable_parent(data);
+ }
+ 
++static int thunderx_gpio_irq_request_resources(struct irq_data *data)
++{
++	struct thunderx_line *txline = irq_data_get_irq_chip_data(data);
++	struct thunderx_gpio *txgpio = txline->txgpio;
++	int r;
++
++	r = gpiochip_lock_as_irq(&txgpio->chip, txline->line);
++	if (r)
++		return r;
++
++	r = irq_chip_request_resources_parent(data);
++	if (r)
++		gpiochip_unlock_as_irq(&txgpio->chip, txline->line);
++
++	return r;
++}
++
++static void thunderx_gpio_irq_release_resources(struct irq_data *data)
++{
++	struct thunderx_line *txline = irq_data_get_irq_chip_data(data);
++	struct thunderx_gpio *txgpio = txline->txgpio;
++
++	irq_chip_release_resources_parent(data);
++
++	gpiochip_unlock_as_irq(&txgpio->chip, txline->line);
++}
++
+ /*
+  * Interrupts are chained from underlying MSI-X vectors.  We have
+  * these irq_chip functions to be able to handle level triggering
+@@ -380,24 +402,50 @@ static struct irq_chip thunderx_gpio_irq_chip = {
+ 	.irq_unmask		= thunderx_gpio_irq_unmask,
+ 	.irq_eoi		= irq_chip_eoi_parent,
+ 	.irq_set_affinity	= irq_chip_set_affinity_parent,
++	.irq_request_resources	= thunderx_gpio_irq_request_resources,
++	.irq_release_resources	= thunderx_gpio_irq_release_resources,
+ 	.irq_set_type		= thunderx_gpio_irq_set_type,
+ 
+ 	.flags			= IRQCHIP_SET_TYPE_MASKED
+ };
+ 
+-static int thunderx_gpio_child_to_parent_hwirq(struct gpio_chip *gc,
+-					       unsigned int child,
+-					       unsigned int child_type,
+-					       unsigned int *parent,
+-					       unsigned int *parent_type)
++static int thunderx_gpio_irq_translate(struct irq_domain *d,
++				       struct irq_fwspec *fwspec,
++				       irq_hw_number_t *hwirq,
++				       unsigned int *type)
+ {
+-	struct thunderx_gpio *txgpio = gpiochip_get_data(gc);
+-
+-	*parent = txgpio->base_msi + (2 * child);
+-	*parent_type = IRQ_TYPE_LEVEL_HIGH;
++	struct thunderx_gpio *txgpio = d->host_data;
++
++	if (WARN_ON(fwspec->param_count < 2))
++		return -EINVAL;
++	if (fwspec->param[0] >= txgpio->chip.ngpio)
++		return -EINVAL;
++	*hwirq = fwspec->param[0];
++	*type = fwspec->param[1] & IRQ_TYPE_SENSE_MASK;
+ 	return 0;
+ }
+ 
++static int thunderx_gpio_irq_alloc(struct irq_domain *d, unsigned int virq,
++				   unsigned int nr_irqs, void *arg)
++{
++	struct thunderx_line *txline = arg;
++
++	return irq_domain_set_hwirq_and_chip(d, virq, txline->line,
++					     &thunderx_gpio_irq_chip, txline);
++}
++
++static const struct irq_domain_ops thunderx_gpio_irqd_ops = {
++	.alloc		= thunderx_gpio_irq_alloc,
++	.translate	= thunderx_gpio_irq_translate
++};
++
++static int thunderx_gpio_to_irq(struct gpio_chip *chip, unsigned int offset)
++{
++	struct thunderx_gpio *txgpio = gpiochip_get_data(chip);
++
++	return irq_find_mapping(txgpio->irqd, offset);
++}
++
+ static int thunderx_gpio_probe(struct pci_dev *pdev,
+ 			       const struct pci_device_id *id)
+ {
+@@ -405,7 +453,6 @@ static int thunderx_gpio_probe(struct pci_dev *pdev,
+ 	struct device *dev = &pdev->dev;
+ 	struct thunderx_gpio *txgpio;
+ 	struct gpio_chip *chip;
+-	struct gpio_irq_chip *girq;
+ 	int ngpio, i;
+ 	int err = 0;
+ 
+@@ -450,8 +497,8 @@ static int thunderx_gpio_probe(struct pci_dev *pdev,
+ 	}
+ 
+ 	txgpio->msix_entries = devm_kcalloc(dev,
+-					    ngpio, sizeof(struct msix_entry),
+-					    GFP_KERNEL);
++					  ngpio, sizeof(struct msix_entry),
++					  GFP_KERNEL);
+ 	if (!txgpio->msix_entries) {
+ 		err = -ENOMEM;
+ 		goto out;
+@@ -492,6 +539,27 @@ static int thunderx_gpio_probe(struct pci_dev *pdev,
+ 	if (err < 0)
+ 		goto out;
+ 
++	/*
++	 * Push GPIO specific irqdomain on hierarchy created as a side
++	 * effect of the pci_enable_msix()
++	 */
++	txgpio->irqd = irq_domain_create_hierarchy(irq_get_irq_data(txgpio->msix_entries[0].vector)->domain,
++						   0, 0, of_node_to_fwnode(dev->of_node),
++						   &thunderx_gpio_irqd_ops, txgpio);
++	if (!txgpio->irqd) {
++		err = -ENOMEM;
++		goto out;
++	}
++
++	/* Push on irq_data and the domain for each line. */
++	for (i = 0; i < ngpio; i++) {
++		err = irq_domain_push_irq(txgpio->irqd,
++					  txgpio->msix_entries[i].vector,
++					  &txgpio->line_entries[i]);
++		if (err < 0)
++			dev_err(dev, "irq_domain_push_irq: %d\n", err);
++	}
++
+ 	chip->label = KBUILD_MODNAME;
+ 	chip->parent = dev;
+ 	chip->owner = THIS_MODULE;
+@@ -506,28 +574,11 @@ static int thunderx_gpio_probe(struct pci_dev *pdev,
+ 	chip->set = thunderx_gpio_set;
+ 	chip->set_multiple = thunderx_gpio_set_multiple;
+ 	chip->set_config = thunderx_gpio_set_config;
+-	girq = &chip->irq;
+-	girq->chip = &thunderx_gpio_irq_chip;
+-	girq->fwnode = of_node_to_fwnode(dev->of_node);
+-	girq->parent_domain =
+-		irq_get_irq_data(txgpio->msix_entries[0].vector)->domain;
+-	girq->child_to_parent_hwirq = thunderx_gpio_child_to_parent_hwirq;
+-	girq->handler = handle_bad_irq;
+-	girq->default_type = IRQ_TYPE_NONE;
+-
++	chip->to_irq = thunderx_gpio_to_irq;
+ 	err = devm_gpiochip_add_data(dev, chip, txgpio);
+ 	if (err)
+ 		goto out;
+ 
+-	/* Push on irq_data and the domain for each line. */
+-	for (i = 0; i < ngpio; i++) {
+-		err = irq_domain_push_irq(chip->irq.domain,
+-					  txgpio->msix_entries[i].vector,
+-					  chip);
+-		if (err < 0)
+-			dev_err(dev, "irq_domain_push_irq: %d\n", err);
+-	}
+-
+ 	dev_info(dev, "ThunderX GPIO: %d lines with base %d.\n",
+ 		 ngpio, chip->base);
+ 	return 0;
+@@ -542,10 +593,10 @@ static void thunderx_gpio_remove(struct pci_dev *pdev)
+ 	struct thunderx_gpio *txgpio = pci_get_drvdata(pdev);
+ 
+ 	for (i = 0; i < txgpio->chip.ngpio; i++)
+-		irq_domain_pop_irq(txgpio->chip.irq.domain,
++		irq_domain_pop_irq(txgpio->irqd,
+ 				   txgpio->msix_entries[i].vector);
+ 
+-	irq_domain_remove(txgpio->chip.irq.domain);
++	irq_domain_remove(txgpio->irqd);
+ 
+ 	pci_set_drvdata(pdev, NULL);
+ }
+diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v9_0.c b/drivers/gpu/drm/amd/amdgpu/gfx_v9_0.c
+index ab4a0d8545dc..0125ea7c4103 100644
+--- a/drivers/gpu/drm/amd/amdgpu/gfx_v9_0.c
++++ b/drivers/gpu/drm/amd/amdgpu/gfx_v9_0.c
+@@ -2923,7 +2923,9 @@ static void gfx_v9_0_init_pg(struct amdgpu_device *adev)
+ 	 * And it's needed by gfxoff feature.
+ 	 */
+ 	if (adev->gfx.rlc.is_rlc_v2_1) {
+-		if (adev->asic_type == CHIP_VEGA12)
++		if (adev->asic_type == CHIP_VEGA12 ||
++		    (adev->asic_type == CHIP_RAVEN &&
++		     adev->rev_id >= 8))
+ 			gfx_v9_1_init_rlc_save_restore_list(adev);
+ 		gfx_v9_0_enable_save_restore_machine(adev);
+ 	}
+diff --git a/drivers/gpu/drm/amd/display/dc/core/dc_link.c b/drivers/gpu/drm/amd/display/dc/core/dc_link.c
+index 793aa8e8ec9a..c0f1c62c59b4 100644
+--- a/drivers/gpu/drm/amd/display/dc/core/dc_link.c
++++ b/drivers/gpu/drm/amd/display/dc/core/dc_link.c
+@@ -809,8 +809,8 @@ bool dc_link_detect(struct dc_link *link, enum dc_detect_reason reason)
+ 		}
+ 
+ 		case SIGNAL_TYPE_EDP: {
+-			read_edp_current_link_settings_on_detect(link);
+ 			detect_edp_sink_caps(link);
++			read_edp_current_link_settings_on_detect(link);
+ 			sink_caps.transaction_type =
+ 				DDC_TRANSACTION_TYPE_I2C_OVER_AUX;
+ 			sink_caps.signal = SIGNAL_TYPE_EDP;
+diff --git a/drivers/gpu/drm/i915/selftests/i915_random.h b/drivers/gpu/drm/i915/selftests/i915_random.h
+index 8e1ff9c105b6..22335cee2203 100644
+--- a/drivers/gpu/drm/i915/selftests/i915_random.h
++++ b/drivers/gpu/drm/i915/selftests/i915_random.h
+@@ -25,6 +25,7 @@
+ #ifndef __I915_SELFTESTS_RANDOM_H__
+ #define __I915_SELFTESTS_RANDOM_H__
+ 
++#include <linux/math64.h>
+ #include <linux/random.h>
+ 
+ #include "../i915_selftest.h"
+diff --git a/drivers/hwmon/pmbus/ibm-cffps.c b/drivers/hwmon/pmbus/ibm-cffps.c
+index d44745e498e7..929c909ac27a 100644
+--- a/drivers/hwmon/pmbus/ibm-cffps.c
++++ b/drivers/hwmon/pmbus/ibm-cffps.c
+@@ -39,9 +39,13 @@
+ #define CFFPS_MFR_VAUX_FAULT			BIT(6)
+ #define CFFPS_MFR_CURRENT_SHARE_WARNING		BIT(7)
+ 
++/*
++ * LED off state actually relinquishes LED control to PSU firmware, so it can
++ * turn on the LED for faults.
++ */
++#define CFFPS_LED_OFF				0
+ #define CFFPS_LED_BLINK				BIT(0)
+ #define CFFPS_LED_ON				BIT(1)
+-#define CFFPS_LED_OFF				BIT(2)
+ #define CFFPS_BLINK_RATE_MS			250
+ 
+ enum {
+@@ -292,28 +296,38 @@ static int ibm_cffps_read_word_data(struct i2c_client *client, int page,
+ 	return rc;
+ }
+ 
+-static void ibm_cffps_led_brightness_set(struct led_classdev *led_cdev,
+-					 enum led_brightness brightness)
++static int ibm_cffps_led_brightness_set(struct led_classdev *led_cdev,
++					enum led_brightness brightness)
+ {
+ 	int rc;
++	u8 next_led_state;
+ 	struct ibm_cffps *psu = container_of(led_cdev, struct ibm_cffps, led);
+ 
+ 	if (brightness == LED_OFF) {
+-		psu->led_state = CFFPS_LED_OFF;
++		next_led_state = CFFPS_LED_OFF;
+ 	} else {
+ 		brightness = LED_FULL;
++
+ 		if (psu->led_state != CFFPS_LED_BLINK)
+-			psu->led_state = CFFPS_LED_ON;
++			next_led_state = CFFPS_LED_ON;
++		else
++			next_led_state = CFFPS_LED_BLINK;
+ 	}
+ 
++	dev_dbg(&psu->client->dev, "LED brightness set: %d. Command: %d.\n",
++		brightness, next_led_state);
++
+ 	pmbus_set_page(psu->client, 0);
+ 
+ 	rc = i2c_smbus_write_byte_data(psu->client, CFFPS_SYS_CONFIG_CMD,
+-				       psu->led_state);
++				       next_led_state);
+ 	if (rc < 0)
+-		return;
++		return rc;
+ 
++	psu->led_state = next_led_state;
+ 	led_cdev->brightness = brightness;
++
++	return 0;
+ }
+ 
+ static int ibm_cffps_led_blink_set(struct led_classdev *led_cdev,
+@@ -323,10 +337,7 @@ static int ibm_cffps_led_blink_set(struct led_classdev *led_cdev,
+ 	int rc;
+ 	struct ibm_cffps *psu = container_of(led_cdev, struct ibm_cffps, led);
+ 
+-	psu->led_state = CFFPS_LED_BLINK;
+-
+-	if (led_cdev->brightness == LED_OFF)
+-		return 0;
++	dev_dbg(&psu->client->dev, "LED blink set.\n");
+ 
+ 	pmbus_set_page(psu->client, 0);
+ 
+@@ -335,6 +346,8 @@ static int ibm_cffps_led_blink_set(struct led_classdev *led_cdev,
+ 	if (rc < 0)
+ 		return rc;
+ 
++	psu->led_state = CFFPS_LED_BLINK;
++	led_cdev->brightness = LED_FULL;
+ 	*delay_on = CFFPS_BLINK_RATE_MS;
+ 	*delay_off = CFFPS_BLINK_RATE_MS;
+ 
+@@ -351,7 +364,7 @@ static void ibm_cffps_create_led_class(struct ibm_cffps *psu)
+ 		 client->addr);
+ 	psu->led.name = psu->led_name;
+ 	psu->led.max_brightness = LED_FULL;
+-	psu->led.brightness_set = ibm_cffps_led_brightness_set;
++	psu->led.brightness_set_blocking = ibm_cffps_led_brightness_set;
+ 	psu->led.blink_set = ibm_cffps_led_blink_set;
+ 
+ 	rc = devm_led_classdev_register(dev, &psu->led);
+diff --git a/drivers/i2c/busses/i2c-iop3xx.c b/drivers/i2c/busses/i2c-iop3xx.c
+index 38556381f4ca..2f8b8050a223 100644
+--- a/drivers/i2c/busses/i2c-iop3xx.c
++++ b/drivers/i2c/busses/i2c-iop3xx.c
+@@ -433,13 +433,17 @@ iop3xx_i2c_probe(struct platform_device *pdev)
+ 	adapter_data->gpio_scl = devm_gpiod_get_optional(&pdev->dev,
+ 							 "scl",
+ 							 GPIOD_ASIS);
+-	if (IS_ERR(adapter_data->gpio_scl))
+-		return PTR_ERR(adapter_data->gpio_scl);
++	if (IS_ERR(adapter_data->gpio_scl)) {
++		ret = PTR_ERR(adapter_data->gpio_scl);
++		goto free_both;
++	}
+ 	adapter_data->gpio_sda = devm_gpiod_get_optional(&pdev->dev,
+ 							 "sda",
+ 							 GPIOD_ASIS);
+-	if (IS_ERR(adapter_data->gpio_sda))
+-		return PTR_ERR(adapter_data->gpio_sda);
++	if (IS_ERR(adapter_data->gpio_sda)) {
++		ret = PTR_ERR(adapter_data->gpio_sda);
++		goto free_both;
++	}
+ 
+ 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ 	if (!res) {
+diff --git a/drivers/i2c/busses/i2c-tegra.c b/drivers/i2c/busses/i2c-tegra.c
+index c1683f9338b4..dbc43cfec19d 100644
+--- a/drivers/i2c/busses/i2c-tegra.c
++++ b/drivers/i2c/busses/i2c-tegra.c
+@@ -1608,14 +1608,18 @@ static int tegra_i2c_probe(struct platform_device *pdev)
+ 	}
+ 
+ 	pm_runtime_enable(&pdev->dev);
+-	if (!pm_runtime_enabled(&pdev->dev))
++	if (!pm_runtime_enabled(&pdev->dev)) {
+ 		ret = tegra_i2c_runtime_resume(&pdev->dev);
+-	else
++		if (ret < 0) {
++			dev_err(&pdev->dev, "runtime resume failed\n");
++			goto unprepare_div_clk;
++		}
++	} else {
+ 		ret = pm_runtime_get_sync(i2c_dev->dev);
+-
+-	if (ret < 0) {
+-		dev_err(&pdev->dev, "runtime resume failed\n");
+-		goto unprepare_div_clk;
++		if (ret < 0) {
++			dev_err(&pdev->dev, "runtime resume failed\n");
++			goto disable_rpm;
++		}
+ 	}
+ 
+ 	if (i2c_dev->is_multimaster_mode) {
+@@ -1623,7 +1627,7 @@ static int tegra_i2c_probe(struct platform_device *pdev)
+ 		if (ret < 0) {
+ 			dev_err(i2c_dev->dev, "div_clk enable failed %d\n",
+ 				ret);
+-			goto disable_rpm;
++			goto put_rpm;
+ 		}
+ 	}
+ 
+@@ -1671,11 +1675,16 @@ disable_div_clk:
+ 	if (i2c_dev->is_multimaster_mode)
+ 		clk_disable(i2c_dev->div_clk);
+ 
+-disable_rpm:
+-	pm_runtime_disable(&pdev->dev);
+-	if (!pm_runtime_status_suspended(&pdev->dev))
++put_rpm:
++	if (pm_runtime_enabled(&pdev->dev))
++		pm_runtime_put_sync(&pdev->dev);
++	else
+ 		tegra_i2c_runtime_suspend(&pdev->dev);
+ 
++disable_rpm:
++	if (pm_runtime_enabled(&pdev->dev))
++		pm_runtime_disable(&pdev->dev);
++
+ unprepare_div_clk:
+ 	clk_unprepare(i2c_dev->div_clk);
+ 
+@@ -1710,9 +1719,14 @@ static int tegra_i2c_remove(struct platform_device *pdev)
+ static int __maybe_unused tegra_i2c_suspend(struct device *dev)
+ {
+ 	struct tegra_i2c_dev *i2c_dev = dev_get_drvdata(dev);
++	int err;
+ 
+ 	i2c_mark_adapter_suspended(&i2c_dev->adapter);
+ 
++	err = pm_runtime_force_suspend(dev);
++	if (err < 0)
++		return err;
++
+ 	return 0;
+ }
+ 
+@@ -1733,6 +1747,10 @@ static int __maybe_unused tegra_i2c_resume(struct device *dev)
+ 	if (err)
+ 		return err;
+ 
++	err = pm_runtime_force_resume(dev);
++	if (err < 0)
++		return err;
++
+ 	i2c_mark_adapter_resumed(&i2c_dev->adapter);
+ 
+ 	return 0;
+diff --git a/drivers/iio/adc/ad7124.c b/drivers/iio/adc/ad7124.c
+index 3f03abf100b5..306bf15023a7 100644
+--- a/drivers/iio/adc/ad7124.c
++++ b/drivers/iio/adc/ad7124.c
+@@ -494,13 +494,11 @@ static int ad7124_of_parse_channel_config(struct iio_dev *indio_dev,
+ 		st->channel_config[channel].buf_negative =
+ 			of_property_read_bool(child, "adi,buffered-negative");
+ 
+-		*chan = ad7124_channel_template;
+-		chan->address = channel;
+-		chan->scan_index = channel;
+-		chan->channel = ain[0];
+-		chan->channel2 = ain[1];
+-
+-		chan++;
++		chan[channel] = ad7124_channel_template;
++		chan[channel].address = channel;
++		chan[channel].scan_index = channel;
++		chan[channel].channel = ain[0];
++		chan[channel].channel2 = ain[1];
+ 	}
+ 
+ 	return 0;
+diff --git a/drivers/iio/chemical/Kconfig b/drivers/iio/chemical/Kconfig
+index fa4586037bb8..0b91de4df8f4 100644
+--- a/drivers/iio/chemical/Kconfig
++++ b/drivers/iio/chemical/Kconfig
+@@ -65,6 +65,7 @@ config IAQCORE
+ config PMS7003
+ 	tristate "Plantower PMS7003 particulate matter sensor"
+ 	depends on SERIAL_DEV_BUS
++	select IIO_BUFFER
+ 	select IIO_TRIGGERED_BUFFER
+ 	help
+ 	  Say Y here to build support for the Plantower PMS7003 particulate
+diff --git a/drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_core.c b/drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_core.c
+index 3e0528793d95..057a4b010010 100644
+--- a/drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_core.c
++++ b/drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_core.c
+@@ -911,7 +911,8 @@ static int st_lsm6dsx_check_whoami(struct st_lsm6dsx_hw *hw, int id,
+ 
+ 	for (i = 0; i < ARRAY_SIZE(st_lsm6dsx_sensor_settings); i++) {
+ 		for (j = 0; j < ST_LSM6DSX_MAX_ID; j++) {
+-			if (id == st_lsm6dsx_sensor_settings[i].id[j].hw_id)
++			if (st_lsm6dsx_sensor_settings[i].id[j].name &&
++			    id == st_lsm6dsx_sensor_settings[i].id[j].hw_id)
+ 				break;
+ 		}
+ 		if (j < ST_LSM6DSX_MAX_ID)
+diff --git a/drivers/iio/industrialio-buffer.c b/drivers/iio/industrialio-buffer.c
+index c193d64e5217..112225c0e486 100644
+--- a/drivers/iio/industrialio-buffer.c
++++ b/drivers/iio/industrialio-buffer.c
+@@ -566,7 +566,7 @@ static int iio_compute_scan_bytes(struct iio_dev *indio_dev,
+ 				const unsigned long *mask, bool timestamp)
+ {
+ 	unsigned bytes = 0;
+-	int length, i;
++	int length, i, largest = 0;
+ 
+ 	/* How much space will the demuxed element take? */
+ 	for_each_set_bit(i, mask,
+@@ -574,13 +574,17 @@ static int iio_compute_scan_bytes(struct iio_dev *indio_dev,
+ 		length = iio_storage_bytes_for_si(indio_dev, i);
+ 		bytes = ALIGN(bytes, length);
+ 		bytes += length;
++		largest = max(largest, length);
+ 	}
+ 
+ 	if (timestamp) {
+ 		length = iio_storage_bytes_for_timestamp(indio_dev);
+ 		bytes = ALIGN(bytes, length);
+ 		bytes += length;
++		largest = max(largest, length);
+ 	}
++
++	bytes = ALIGN(bytes, largest);
+ 	return bytes;
+ }
+ 
+diff --git a/drivers/iio/light/vcnl4000.c b/drivers/iio/light/vcnl4000.c
+index 16dacea9eadf..b0e241aaefb4 100644
+--- a/drivers/iio/light/vcnl4000.c
++++ b/drivers/iio/light/vcnl4000.c
+@@ -163,7 +163,6 @@ static int vcnl4200_init(struct vcnl4000_data *data)
+ 	if (ret < 0)
+ 		return ret;
+ 
+-	data->al_scale = 24000;
+ 	data->vcnl4200_al.reg = VCNL4200_AL_DATA;
+ 	data->vcnl4200_ps.reg = VCNL4200_PS_DATA;
+ 	switch (id) {
+@@ -172,11 +171,13 @@ static int vcnl4200_init(struct vcnl4000_data *data)
+ 		/* show 54ms in total. */
+ 		data->vcnl4200_al.sampling_rate = ktime_set(0, 54000 * 1000);
+ 		data->vcnl4200_ps.sampling_rate = ktime_set(0, 4200 * 1000);
++		data->al_scale = 24000;
+ 		break;
+ 	case VCNL4040_PROD_ID:
+ 		/* Integration time is 80ms, add 10ms. */
+ 		data->vcnl4200_al.sampling_rate = ktime_set(0, 100000 * 1000);
+ 		data->vcnl4200_ps.sampling_rate = ktime_set(0, 100000 * 1000);
++		data->al_scale = 120000;
+ 		break;
+ 	}
+ 	data->vcnl4200_al.last_measurement = ktime_set(0, 0);
+diff --git a/drivers/irqchip/Kconfig b/drivers/irqchip/Kconfig
+index ccbb8973a324..97f9c001d8ff 100644
+--- a/drivers/irqchip/Kconfig
++++ b/drivers/irqchip/Kconfig
+@@ -483,8 +483,6 @@ config TI_SCI_INTA_IRQCHIP
+ 	  If you wish to use interrupt aggregator irq resources managed by the
+ 	  TI System Controller, say Y here. Otherwise, say N.
+ 
+-endmenu
+-
+ config SIFIVE_PLIC
+ 	bool "SiFive Platform-Level Interrupt Controller"
+ 	depends on RISCV
+@@ -496,3 +494,5 @@ config SIFIVE_PLIC
+ 	   interrupt sources are subordinate to the PLIC.
+ 
+ 	   If you don't know what to do here, say Y.
++
++endmenu
+diff --git a/drivers/md/dm-snap-persistent.c b/drivers/md/dm-snap-persistent.c
+index 3c50c4e4da8f..963d3774c93e 100644
+--- a/drivers/md/dm-snap-persistent.c
++++ b/drivers/md/dm-snap-persistent.c
+@@ -17,7 +17,7 @@
+ #include <linux/dm-bufio.h>
+ 
+ #define DM_MSG_PREFIX "persistent snapshot"
+-#define DM_CHUNK_SIZE_DEFAULT_SECTORS 32	/* 16KB */
++#define DM_CHUNK_SIZE_DEFAULT_SECTORS 32U	/* 16KB */
+ 
+ #define DM_PREFETCH_CHUNKS		12
+ 
+diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
+index b7c20979bd19..322386ff5d22 100644
+--- a/drivers/md/raid0.c
++++ b/drivers/md/raid0.c
+@@ -87,7 +87,7 @@ static int create_strip_zones(struct mddev *mddev, struct r0conf **private_conf)
+ 	char b[BDEVNAME_SIZE];
+ 	char b2[BDEVNAME_SIZE];
+ 	struct r0conf *conf = kzalloc(sizeof(*conf), GFP_KERNEL);
+-	unsigned short blksize = 512;
++	unsigned blksize = 512;
+ 
+ 	*private_conf = ERR_PTR(-ENOMEM);
+ 	if (!conf)
+diff --git a/drivers/message/fusion/mptctl.c b/drivers/message/fusion/mptctl.c
+index f9ac22413000..1074b882c57c 100644
+--- a/drivers/message/fusion/mptctl.c
++++ b/drivers/message/fusion/mptctl.c
+@@ -100,19 +100,19 @@ struct buflist {
+  * Function prototypes. Called from OS entry point mptctl_ioctl.
+  * arg contents specific to function.
+  */
+-static int mptctl_fw_download(unsigned long arg);
+-static int mptctl_getiocinfo(unsigned long arg, unsigned int cmd);
+-static int mptctl_gettargetinfo(unsigned long arg);
+-static int mptctl_readtest(unsigned long arg);
+-static int mptctl_mpt_command(unsigned long arg);
+-static int mptctl_eventquery(unsigned long arg);
+-static int mptctl_eventenable(unsigned long arg);
+-static int mptctl_eventreport(unsigned long arg);
+-static int mptctl_replace_fw(unsigned long arg);
+-
+-static int mptctl_do_reset(unsigned long arg);
+-static int mptctl_hp_hostinfo(unsigned long arg, unsigned int cmd);
+-static int mptctl_hp_targetinfo(unsigned long arg);
++static int mptctl_fw_download(MPT_ADAPTER *iocp, unsigned long arg);
++static int mptctl_getiocinfo(MPT_ADAPTER *iocp, unsigned long arg, unsigned int cmd);
++static int mptctl_gettargetinfo(MPT_ADAPTER *iocp, unsigned long arg);
++static int mptctl_readtest(MPT_ADAPTER *iocp, unsigned long arg);
++static int mptctl_mpt_command(MPT_ADAPTER *iocp, unsigned long arg);
++static int mptctl_eventquery(MPT_ADAPTER *iocp, unsigned long arg);
++static int mptctl_eventenable(MPT_ADAPTER *iocp, unsigned long arg);
++static int mptctl_eventreport(MPT_ADAPTER *iocp, unsigned long arg);
++static int mptctl_replace_fw(MPT_ADAPTER *iocp, unsigned long arg);
++
++static int mptctl_do_reset(MPT_ADAPTER *iocp, unsigned long arg);
++static int mptctl_hp_hostinfo(MPT_ADAPTER *iocp, unsigned long arg, unsigned int cmd);
++static int mptctl_hp_targetinfo(MPT_ADAPTER *iocp, unsigned long arg);
+ 
+ static int  mptctl_probe(struct pci_dev *, const struct pci_device_id *);
+ static void mptctl_remove(struct pci_dev *);
+@@ -123,8 +123,8 @@ static long compat_mpctl_ioctl(struct file *f, unsigned cmd, unsigned long arg);
+ /*
+  * Private function calls.
+  */
+-static int mptctl_do_mpt_command(struct mpt_ioctl_command karg, void __user *mfPtr);
+-static int mptctl_do_fw_download(int ioc, char __user *ufwbuf, size_t fwlen);
++static int mptctl_do_mpt_command(MPT_ADAPTER *iocp, struct mpt_ioctl_command karg, void __user *mfPtr);
++static int mptctl_do_fw_download(MPT_ADAPTER *iocp, char __user *ufwbuf, size_t fwlen);
+ static MptSge_t *kbuf_alloc_2_sgl(int bytes, u32 dir, int sge_offset, int *frags,
+ 		struct buflist **blp, dma_addr_t *sglbuf_dma, MPT_ADAPTER *ioc);
+ static void kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma,
+@@ -656,19 +656,19 @@ __mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+ 	 * by TM and FW reloads.
+ 	 */
+ 	if ((cmd & ~IOCSIZE_MASK) == (MPTIOCINFO & ~IOCSIZE_MASK)) {
+-		return mptctl_getiocinfo(arg, _IOC_SIZE(cmd));
++		return mptctl_getiocinfo(iocp, arg, _IOC_SIZE(cmd));
+ 	} else if (cmd == MPTTARGETINFO) {
+-		return mptctl_gettargetinfo(arg);
++		return mptctl_gettargetinfo(iocp, arg);
+ 	} else if (cmd == MPTTEST) {
+-		return mptctl_readtest(arg);
++		return mptctl_readtest(iocp, arg);
+ 	} else if (cmd == MPTEVENTQUERY) {
+-		return mptctl_eventquery(arg);
++		return mptctl_eventquery(iocp, arg);
+ 	} else if (cmd == MPTEVENTENABLE) {
+-		return mptctl_eventenable(arg);
++		return mptctl_eventenable(iocp, arg);
+ 	} else if (cmd == MPTEVENTREPORT) {
+-		return mptctl_eventreport(arg);
++		return mptctl_eventreport(iocp, arg);
+ 	} else if (cmd == MPTFWREPLACE) {
+-		return mptctl_replace_fw(arg);
++		return mptctl_replace_fw(iocp, arg);
+ 	}
+ 
+ 	/* All of these commands require an interrupt or
+@@ -678,15 +678,15 @@ __mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+ 		return ret;
+ 
+ 	if (cmd == MPTFWDOWNLOAD)
+-		ret = mptctl_fw_download(arg);
++		ret = mptctl_fw_download(iocp, arg);
+ 	else if (cmd == MPTCOMMAND)
+-		ret = mptctl_mpt_command(arg);
++		ret = mptctl_mpt_command(iocp, arg);
+ 	else if (cmd == MPTHARDRESET)
+-		ret = mptctl_do_reset(arg);
++		ret = mptctl_do_reset(iocp, arg);
+ 	else if ((cmd & ~IOCSIZE_MASK) == (HP_GETHOSTINFO & ~IOCSIZE_MASK))
+-		ret = mptctl_hp_hostinfo(arg, _IOC_SIZE(cmd));
++		ret = mptctl_hp_hostinfo(iocp, arg, _IOC_SIZE(cmd));
+ 	else if (cmd == HP_GETTARGETINFO)
+-		ret = mptctl_hp_targetinfo(arg);
++		ret = mptctl_hp_targetinfo(iocp, arg);
+ 	else
+ 		ret = -EINVAL;
+ 
+@@ -705,11 +705,10 @@ mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+ 	return ret;
+ }
+ 
+-static int mptctl_do_reset(unsigned long arg)
++static int mptctl_do_reset(MPT_ADAPTER *iocp, unsigned long arg)
+ {
+ 	struct mpt_ioctl_diag_reset __user *urinfo = (void __user *) arg;
+ 	struct mpt_ioctl_diag_reset krinfo;
+-	MPT_ADAPTER		*iocp;
+ 
+ 	if (copy_from_user(&krinfo, urinfo, sizeof(struct mpt_ioctl_diag_reset))) {
+ 		printk(KERN_ERR MYNAM "%s@%d::mptctl_do_reset - "
+@@ -718,12 +717,6 @@ static int mptctl_do_reset(unsigned long arg)
+ 		return -EFAULT;
+ 	}
+ 
+-	if (mpt_verify_adapter(krinfo.hdr.iocnum, &iocp) < 0) {
+-		printk(KERN_DEBUG MYNAM "%s@%d::mptctl_do_reset - ioc%d not found!\n",
+-				__FILE__, __LINE__, krinfo.hdr.iocnum);
+-		return -ENODEV; /* (-6) No such device or address */
+-	}
+-
+ 	dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "mptctl_do_reset called.\n",
+ 	    iocp->name));
+ 
+@@ -754,7 +747,7 @@ static int mptctl_do_reset(unsigned long arg)
+  *		-ENOMSG if FW upload returned bad status
+  */
+ static int
+-mptctl_fw_download(unsigned long arg)
++mptctl_fw_download(MPT_ADAPTER *iocp, unsigned long arg)
+ {
+ 	struct mpt_fw_xfer __user *ufwdl = (void __user *) arg;
+ 	struct mpt_fw_xfer	 kfwdl;
+@@ -766,7 +759,7 @@ mptctl_fw_download(unsigned long arg)
+ 		return -EFAULT;
+ 	}
+ 
+-	return mptctl_do_fw_download(kfwdl.iocnum, kfwdl.bufp, kfwdl.fwlen);
++	return mptctl_do_fw_download(iocp, kfwdl.bufp, kfwdl.fwlen);
+ }
+ 
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+@@ -784,11 +777,10 @@ mptctl_fw_download(unsigned long arg)
+  *		-ENOMSG if FW upload returned bad status
+  */
+ static int
+-mptctl_do_fw_download(int ioc, char __user *ufwbuf, size_t fwlen)
++mptctl_do_fw_download(MPT_ADAPTER *iocp, char __user *ufwbuf, size_t fwlen)
+ {
+ 	FWDownload_t		*dlmsg;
+ 	MPT_FRAME_HDR		*mf;
+-	MPT_ADAPTER		*iocp;
+ 	FWDownloadTCSGE_t	*ptsge;
+ 	MptSge_t		*sgl, *sgIn;
+ 	char			*sgOut;
+@@ -808,17 +800,10 @@ mptctl_do_fw_download(int ioc, char __user *ufwbuf, size_t fwlen)
+ 	pFWDownloadReply_t	 ReplyMsg = NULL;
+ 	unsigned long		 timeleft;
+ 
+-	if (mpt_verify_adapter(ioc, &iocp) < 0) {
+-		printk(KERN_DEBUG MYNAM "ioctl_fwdl - ioc%d not found!\n",
+-				 ioc);
+-		return -ENODEV; /* (-6) No such device or address */
+-	} else {
+-
+-		/*  Valid device. Get a message frame and construct the FW download message.
+-	 	*/
+-		if ((mf = mpt_get_msg_frame(mptctl_id, iocp)) == NULL)
+-			return -EAGAIN;
+-	}
++	/*  Valid device. Get a message frame and construct the FW download message.
++	*/
++	if ((mf = mpt_get_msg_frame(mptctl_id, iocp)) == NULL)
++		return -EAGAIN;
+ 
+ 	dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT
+ 	    "mptctl_do_fwdl called. mptctl_id = %xh.\n", iocp->name, mptctl_id));
+@@ -826,8 +811,6 @@ mptctl_do_fw_download(int ioc, char __user *ufwbuf, size_t fwlen)
+ 	    iocp->name, ufwbuf));
+ 	dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: kfwdl.fwlen = %d\n",
+ 	    iocp->name, (int)fwlen));
+-	dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: kfwdl.ioc   = %04xh\n",
+-	    iocp->name, ioc));
+ 
+ 	dlmsg = (FWDownload_t*) mf;
+ 	ptsge = (FWDownloadTCSGE_t *) &dlmsg->SGL;
+@@ -1238,13 +1221,11 @@ kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma, struct buflist *buflist, MPT_ADAPTE
+  *		-ENODEV  if no such device/adapter
+  */
+ static int
+-mptctl_getiocinfo (unsigned long arg, unsigned int data_size)
++mptctl_getiocinfo (MPT_ADAPTER *ioc, unsigned long arg, unsigned int data_size)
+ {
+ 	struct mpt_ioctl_iocinfo __user *uarg = (void __user *) arg;
+ 	struct mpt_ioctl_iocinfo *karg;
+-	MPT_ADAPTER		*ioc;
+ 	struct pci_dev		*pdev;
+-	int			iocnum;
+ 	unsigned int		port;
+ 	int			cim_rev;
+ 	struct scsi_device 	*sdev;
+@@ -1272,14 +1253,6 @@ mptctl_getiocinfo (unsigned long arg, unsigned int data_size)
+ 		return PTR_ERR(karg);
+ 	}
+ 
+-	if (((iocnum = mpt_verify_adapter(karg->hdr.iocnum, &ioc)) < 0) ||
+-	    (ioc == NULL)) {
+-		printk(KERN_DEBUG MYNAM "%s::mptctl_getiocinfo() @%d - ioc%d not found!\n",
+-				__FILE__, __LINE__, iocnum);
+-		kfree(karg);
+-		return -ENODEV;
+-	}
+-
+ 	/* Verify the data transfer size is correct. */
+ 	if (karg->hdr.maxDataSize != data_size) {
+ 		printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_getiocinfo - "
+@@ -1385,15 +1358,13 @@ mptctl_getiocinfo (unsigned long arg, unsigned int data_size)
+  *		-ENODEV  if no such device/adapter
+  */
+ static int
+-mptctl_gettargetinfo (unsigned long arg)
++mptctl_gettargetinfo (MPT_ADAPTER *ioc, unsigned long arg)
+ {
+ 	struct mpt_ioctl_targetinfo __user *uarg = (void __user *) arg;
+ 	struct mpt_ioctl_targetinfo karg;
+-	MPT_ADAPTER		*ioc;
+ 	VirtDevice		*vdevice;
+ 	char			*pmem;
+ 	int			*pdata;
+-	int			iocnum;
+ 	int			numDevices = 0;
+ 	int			lun;
+ 	int			maxWordsLeft;
+@@ -1408,13 +1379,6 @@ mptctl_gettargetinfo (unsigned long arg)
+ 		return -EFAULT;
+ 	}
+ 
+-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+-	    (ioc == NULL)) {
+-		printk(KERN_DEBUG MYNAM "%s::mptctl_gettargetinfo() @%d - ioc%d not found!\n",
+-				__FILE__, __LINE__, iocnum);
+-		return -ENODEV;
+-	}
+-
+ 	dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_gettargetinfo called.\n",
+ 	    ioc->name));
+ 	/* Get the port number and set the maximum number of bytes
+@@ -1510,12 +1474,10 @@ mptctl_gettargetinfo (unsigned long arg)
+  *		-ENODEV  if no such device/adapter
+  */
+ static int
+-mptctl_readtest (unsigned long arg)
++mptctl_readtest (MPT_ADAPTER *ioc, unsigned long arg)
+ {
+ 	struct mpt_ioctl_test __user *uarg = (void __user *) arg;
+ 	struct mpt_ioctl_test	 karg;
+-	MPT_ADAPTER *ioc;
+-	int iocnum;
+ 
+ 	if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_test))) {
+ 		printk(KERN_ERR MYNAM "%s@%d::mptctl_readtest - "
+@@ -1524,13 +1486,6 @@ mptctl_readtest (unsigned long arg)
+ 		return -EFAULT;
+ 	}
+ 
+-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+-	    (ioc == NULL)) {
+-		printk(KERN_DEBUG MYNAM "%s::mptctl_readtest() @%d - ioc%d not found!\n",
+-				__FILE__, __LINE__, iocnum);
+-		return -ENODEV;
+-	}
+-
+ 	dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_readtest called.\n",
+ 	    ioc->name));
+ 	/* Fill in the data and return the structure to the calling
+@@ -1571,12 +1526,10 @@ mptctl_readtest (unsigned long arg)
+  *		-ENODEV  if no such device/adapter
+  */
+ static int
+-mptctl_eventquery (unsigned long arg)
++mptctl_eventquery (MPT_ADAPTER *ioc, unsigned long arg)
+ {
+ 	struct mpt_ioctl_eventquery __user *uarg = (void __user *) arg;
+ 	struct mpt_ioctl_eventquery	 karg;
+-	MPT_ADAPTER *ioc;
+-	int iocnum;
+ 
+ 	if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventquery))) {
+ 		printk(KERN_ERR MYNAM "%s@%d::mptctl_eventquery - "
+@@ -1585,13 +1538,6 @@ mptctl_eventquery (unsigned long arg)
+ 		return -EFAULT;
+ 	}
+ 
+-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+-	    (ioc == NULL)) {
+-		printk(KERN_DEBUG MYNAM "%s::mptctl_eventquery() @%d - ioc%d not found!\n",
+-				__FILE__, __LINE__, iocnum);
+-		return -ENODEV;
+-	}
+-
+ 	dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventquery called.\n",
+ 	    ioc->name));
+ 	karg.eventEntries = MPTCTL_EVENT_LOG_SIZE;
+@@ -1610,12 +1556,10 @@ mptctl_eventquery (unsigned long arg)
+ 
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ static int
+-mptctl_eventenable (unsigned long arg)
++mptctl_eventenable (MPT_ADAPTER *ioc, unsigned long arg)
+ {
+ 	struct mpt_ioctl_eventenable __user *uarg = (void __user *) arg;
+ 	struct mpt_ioctl_eventenable	 karg;
+-	MPT_ADAPTER *ioc;
+-	int iocnum;
+ 
+ 	if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventenable))) {
+ 		printk(KERN_ERR MYNAM "%s@%d::mptctl_eventenable - "
+@@ -1624,13 +1568,6 @@ mptctl_eventenable (unsigned long arg)
+ 		return -EFAULT;
+ 	}
+ 
+-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+-	    (ioc == NULL)) {
+-		printk(KERN_DEBUG MYNAM "%s::mptctl_eventenable() @%d - ioc%d not found!\n",
+-				__FILE__, __LINE__, iocnum);
+-		return -ENODEV;
+-	}
+-
+ 	dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventenable called.\n",
+ 	    ioc->name));
+ 	if (ioc->events == NULL) {
+@@ -1658,12 +1595,10 @@ mptctl_eventenable (unsigned long arg)
+ 
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ static int
+-mptctl_eventreport (unsigned long arg)
++mptctl_eventreport (MPT_ADAPTER *ioc, unsigned long arg)
+ {
+ 	struct mpt_ioctl_eventreport __user *uarg = (void __user *) arg;
+ 	struct mpt_ioctl_eventreport	 karg;
+-	MPT_ADAPTER		 *ioc;
+-	int			 iocnum;
+ 	int			 numBytes, maxEvents, max;
+ 
+ 	if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventreport))) {
+@@ -1673,12 +1608,6 @@ mptctl_eventreport (unsigned long arg)
+ 		return -EFAULT;
+ 	}
+ 
+-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+-	    (ioc == NULL)) {
+-		printk(KERN_DEBUG MYNAM "%s::mptctl_eventreport() @%d - ioc%d not found!\n",
+-				__FILE__, __LINE__, iocnum);
+-		return -ENODEV;
+-	}
+ 	dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventreport called.\n",
+ 	    ioc->name));
+ 
+@@ -1712,12 +1641,10 @@ mptctl_eventreport (unsigned long arg)
+ 
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ static int
+-mptctl_replace_fw (unsigned long arg)
++mptctl_replace_fw (MPT_ADAPTER *ioc, unsigned long arg)
+ {
+ 	struct mpt_ioctl_replace_fw __user *uarg = (void __user *) arg;
+ 	struct mpt_ioctl_replace_fw	 karg;
+-	MPT_ADAPTER		 *ioc;
+-	int			 iocnum;
+ 	int			 newFwSize;
+ 
+ 	if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_replace_fw))) {
+@@ -1727,13 +1654,6 @@ mptctl_replace_fw (unsigned long arg)
+ 		return -EFAULT;
+ 	}
+ 
+-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+-	    (ioc == NULL)) {
+-		printk(KERN_DEBUG MYNAM "%s::mptctl_replace_fw() @%d - ioc%d not found!\n",
+-				__FILE__, __LINE__, iocnum);
+-		return -ENODEV;
+-	}
+-
+ 	dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_replace_fw called.\n",
+ 	    ioc->name));
+ 	/* If caching FW, Free the old FW image
+@@ -1780,12 +1700,10 @@ mptctl_replace_fw (unsigned long arg)
+  *		-ENOMEM if memory allocation error
+  */
+ static int
+-mptctl_mpt_command (unsigned long arg)
++mptctl_mpt_command (MPT_ADAPTER *ioc, unsigned long arg)
+ {
+ 	struct mpt_ioctl_command __user *uarg = (void __user *) arg;
+ 	struct mpt_ioctl_command  karg;
+-	MPT_ADAPTER	*ioc;
+-	int		iocnum;
+ 	int		rc;
+ 
+ 
+@@ -1796,14 +1714,7 @@ mptctl_mpt_command (unsigned long arg)
+ 		return -EFAULT;
+ 	}
+ 
+-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+-	    (ioc == NULL)) {
+-		printk(KERN_DEBUG MYNAM "%s::mptctl_mpt_command() @%d - ioc%d not found!\n",
+-				__FILE__, __LINE__, iocnum);
+-		return -ENODEV;
+-	}
+-
+-	rc = mptctl_do_mpt_command (karg, &uarg->MF);
++	rc = mptctl_do_mpt_command (ioc, karg, &uarg->MF);
+ 
+ 	return rc;
+ }
+@@ -1821,9 +1732,8 @@ mptctl_mpt_command (unsigned long arg)
+  *		-EPERM if SCSI I/O and target is untagged
+  */
+ static int
+-mptctl_do_mpt_command (struct mpt_ioctl_command karg, void __user *mfPtr)
++mptctl_do_mpt_command (MPT_ADAPTER *ioc, struct mpt_ioctl_command karg, void __user *mfPtr)
+ {
+-	MPT_ADAPTER	*ioc;
+ 	MPT_FRAME_HDR	*mf = NULL;
+ 	MPIHeader_t	*hdr;
+ 	char		*psge;
+@@ -1832,7 +1742,7 @@ mptctl_do_mpt_command (struct mpt_ioctl_command karg, void __user *mfPtr)
+ 	dma_addr_t	dma_addr_in;
+ 	dma_addr_t	dma_addr_out;
+ 	int		sgSize = 0;	/* Num SG elements */
+-	int		iocnum, flagsLength;
++	int		flagsLength;
+ 	int		sz, rc = 0;
+ 	int		msgContext;
+ 	u16		req_idx;
+@@ -1847,13 +1757,6 @@ mptctl_do_mpt_command (struct mpt_ioctl_command karg, void __user *mfPtr)
+ 	bufIn.kptr = bufOut.kptr = NULL;
+ 	bufIn.len = bufOut.len = 0;
+ 
+-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+-	    (ioc == NULL)) {
+-		printk(KERN_DEBUG MYNAM "%s::mptctl_do_mpt_command() @%d - ioc%d not found!\n",
+-				__FILE__, __LINE__, iocnum);
+-		return -ENODEV;
+-	}
+-
+ 	spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
+ 	if (ioc->ioc_reset_in_progress) {
+ 		spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
+@@ -2418,17 +2321,15 @@ done_free_mem:
+  *		-ENOMEM if memory allocation error
+  */
+ static int
+-mptctl_hp_hostinfo(unsigned long arg, unsigned int data_size)
++mptctl_hp_hostinfo(MPT_ADAPTER *ioc, unsigned long arg, unsigned int data_size)
+ {
+ 	hp_host_info_t	__user *uarg = (void __user *) arg;
+-	MPT_ADAPTER		*ioc;
+ 	struct pci_dev		*pdev;
+ 	char                    *pbuf=NULL;
+ 	dma_addr_t		buf_dma;
+ 	hp_host_info_t		karg;
+ 	CONFIGPARMS		cfg;
+ 	ConfigPageHeader_t	hdr;
+-	int			iocnum;
+ 	int			rc, cim_rev;
+ 	ToolboxIstwiReadWriteRequest_t	*IstwiRWRequest;
+ 	MPT_FRAME_HDR		*mf = NULL;
+@@ -2452,12 +2353,6 @@ mptctl_hp_hostinfo(unsigned long arg, unsigned int data_size)
+ 		return -EFAULT;
+ 	}
+ 
+-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+-	    (ioc == NULL)) {
+-		printk(KERN_DEBUG MYNAM "%s::mptctl_hp_hostinfo() @%d - ioc%d not found!\n",
+-				__FILE__, __LINE__, iocnum);
+-		return -ENODEV;
+-	}
+ 	dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": mptctl_hp_hostinfo called.\n",
+ 	    ioc->name));
+ 
+@@ -2659,15 +2554,13 @@ retry_wait:
+  *		-ENOMEM if memory allocation error
+  */
+ static int
+-mptctl_hp_targetinfo(unsigned long arg)
++mptctl_hp_targetinfo(MPT_ADAPTER *ioc, unsigned long arg)
+ {
+ 	hp_target_info_t __user *uarg = (void __user *) arg;
+ 	SCSIDevicePage0_t	*pg0_alloc;
+ 	SCSIDevicePage3_t	*pg3_alloc;
+-	MPT_ADAPTER		*ioc;
+ 	MPT_SCSI_HOST 		*hd = NULL;
+ 	hp_target_info_t	karg;
+-	int			iocnum;
+ 	int			data_sz;
+ 	dma_addr_t		page_dma;
+ 	CONFIGPARMS	 	cfg;
+@@ -2681,12 +2574,6 @@ mptctl_hp_targetinfo(unsigned long arg)
+ 		return -EFAULT;
+ 	}
+ 
+-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+-		(ioc == NULL)) {
+-		printk(KERN_DEBUG MYNAM "%s::mptctl_hp_targetinfo() @%d - ioc%d not found!\n",
+-				__FILE__, __LINE__, iocnum);
+-		return -ENODEV;
+-	}
+ 	if (karg.hdr.id >= MPT_MAX_FC_DEVICES)
+ 		return -EINVAL;
+ 	dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_hp_targetinfo called.\n",
+@@ -2854,7 +2741,7 @@ compat_mptfwxfer_ioctl(struct file *filp, unsigned int cmd,
+ 	kfw.fwlen = kfw32.fwlen;
+ 	kfw.bufp = compat_ptr(kfw32.bufp);
+ 
+-	ret = mptctl_do_fw_download(kfw.iocnum, kfw.bufp, kfw.fwlen);
++	ret = mptctl_do_fw_download(iocp, kfw.bufp, kfw.fwlen);
+ 
+ 	mutex_unlock(&iocp->ioctl_cmds.mutex);
+ 
+@@ -2908,7 +2795,7 @@ compat_mpt_command(struct file *filp, unsigned int cmd,
+ 
+ 	/* Pass new structure to do_mpt_command
+ 	 */
+-	ret = mptctl_do_mpt_command (karg, &uarg->MF);
++	ret = mptctl_do_mpt_command (iocp, karg, &uarg->MF);
+ 
+ 	mutex_unlock(&iocp->ioctl_cmds.mutex);
+ 
+diff --git a/drivers/mtd/chips/cfi_cmdset_0002.c b/drivers/mtd/chips/cfi_cmdset_0002.c
+index cf8c8be40a9c..a4f2d8cdca12 100644
+--- a/drivers/mtd/chips/cfi_cmdset_0002.c
++++ b/drivers/mtd/chips/cfi_cmdset_0002.c
+@@ -123,19 +123,23 @@ static int cfi_use_status_reg(struct cfi_private *cfi)
+ 		(extp->SoftwareFeatures & poll_mask) == CFI_POLL_STATUS_REG;
+ }
+ 
+-static void cfi_check_err_status(struct map_info *map, struct flchip *chip,
+-				 unsigned long adr)
++static int cfi_check_err_status(struct map_info *map, struct flchip *chip,
++				unsigned long adr)
+ {
+ 	struct cfi_private *cfi = map->fldrv_priv;
+ 	map_word status;
+ 
+ 	if (!cfi_use_status_reg(cfi))
+-		return;
++		return 0;
+ 
+ 	cfi_send_gen_cmd(0x70, cfi->addr_unlock1, chip->start, map, cfi,
+ 			 cfi->device_type, NULL);
+ 	status = map_read(map, adr);
+ 
++	/* The error bits are invalid while the chip's busy */
++	if (!map_word_bitsset(map, status, CMD(CFI_SR_DRB)))
++		return 0;
++
+ 	if (map_word_bitsset(map, status, CMD(0x3a))) {
+ 		unsigned long chipstatus = MERGESTATUS(status);
+ 
+@@ -151,7 +155,12 @@ static void cfi_check_err_status(struct map_info *map, struct flchip *chip,
+ 		if (chipstatus & CFI_SR_SLSB)
+ 			pr_err("%s sector write protected, status %lx\n",
+ 			       map->name, chipstatus);
++
++		/* Erase/Program status bits are set on the operation failure */
++		if (chipstatus & (CFI_SR_ESB | CFI_SR_PSB))
++			return 1;
+ 	}
++	return 0;
+ }
+ 
+ /* #define DEBUG_CFI_FEATURES */
+@@ -848,20 +857,16 @@ static int __xipram chip_good(struct map_info *map, struct flchip *chip,
+ 
+ 	if (cfi_use_status_reg(cfi)) {
+ 		map_word ready = CMD(CFI_SR_DRB);
+-		map_word err = CMD(CFI_SR_PSB | CFI_SR_ESB);
++
+ 		/*
+ 		 * For chips that support status register, check device
+-		 * ready bit and Erase/Program status bit to know if
+-		 * operation succeeded.
++		 * ready bit
+ 		 */
+ 		cfi_send_gen_cmd(0x70, cfi->addr_unlock1, chip->start, map, cfi,
+ 				 cfi->device_type, NULL);
+ 		curd = map_read(map, addr);
+ 
+-		if (map_word_andequal(map, curd, ready, ready))
+-			return !map_word_bitsset(map, curd, err);
+-
+-		return 0;
++		return map_word_andequal(map, curd, ready, ready);
+ 	}
+ 
+ 	oldd = map_read(map, addr);
+@@ -1699,8 +1704,11 @@ static int __xipram do_write_oneword_once(struct map_info *map,
+ 			break;
+ 		}
+ 
+-		if (chip_good(map, chip, adr, datum))
++		if (chip_good(map, chip, adr, datum)) {
++			if (cfi_check_err_status(map, chip, adr))
++				ret = -EIO;
+ 			break;
++		}
+ 
+ 		/* Latency issues. Drop the lock, wait a while and retry */
+ 		UDELAY(map, chip, adr, 1);
+@@ -1773,7 +1781,6 @@ static int __xipram do_write_oneword_retry(struct map_info *map,
+ 	ret = do_write_oneword_once(map, chip, adr, datum, mode, cfi);
+ 	if (ret) {
+ 		/* reset on all failures. */
+-		cfi_check_err_status(map, chip, adr);
+ 		map_write(map, CMD(0xF0), chip->start);
+ 		/* FIXME - should have reset delay before continuing */
+ 
+@@ -1970,12 +1977,17 @@ static int __xipram do_write_buffer_wait(struct map_info *map,
+ 		 */
+ 		if (time_after(jiffies, timeo) &&
+ 		    !chip_good(map, chip, adr, datum)) {
++			pr_err("MTD %s(): software timeout, address:0x%.8lx.\n",
++			       __func__, adr);
+ 			ret = -EIO;
+ 			break;
+ 		}
+ 
+-		if (chip_good(map, chip, adr, datum))
++		if (chip_good(map, chip, adr, datum)) {
++			if (cfi_check_err_status(map, chip, adr))
++				ret = -EIO;
+ 			break;
++		}
+ 
+ 		/* Latency issues. Drop the lock, wait a while and retry */
+ 		UDELAY(map, chip, adr, 1);
+@@ -2071,12 +2083,8 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
+ 				chip->word_write_time);
+ 
+ 	ret = do_write_buffer_wait(map, chip, adr, datum);
+-	if (ret) {
+-		cfi_check_err_status(map, chip, adr);
++	if (ret)
+ 		do_write_buffer_reset(map, chip, cfi);
+-		pr_err("MTD %s(): software timeout, address:0x%.8lx.\n",
+-		       __func__, adr);
+-	}
+ 
+ 	xip_enable(map, chip, adr);
+ 
+@@ -2271,9 +2279,9 @@ retry:
+ 		udelay(1);
+ 	}
+ 
+-	if (!chip_good(map, chip, adr, datum)) {
++	if (!chip_good(map, chip, adr, datum) ||
++	    cfi_check_err_status(map, chip, adr)) {
+ 		/* reset on all failures. */
+-		cfi_check_err_status(map, chip, adr);
+ 		map_write(map, CMD(0xF0), chip->start);
+ 		/* FIXME - should have reset delay before continuing */
+ 
+@@ -2467,8 +2475,11 @@ static int __xipram do_erase_chip(struct map_info *map, struct flchip *chip)
+ 			chip->erase_suspended = 0;
+ 		}
+ 
+-		if (chip_good(map, chip, adr, map_word_ff(map)))
++		if (chip_good(map, chip, adr, map_word_ff(map))) {
++			if (cfi_check_err_status(map, chip, adr))
++				ret = -EIO;
+ 			break;
++		}
+ 
+ 		if (time_after(jiffies, timeo)) {
+ 			printk(KERN_WARNING "MTD %s(): software timeout\n",
+@@ -2483,7 +2494,6 @@ static int __xipram do_erase_chip(struct map_info *map, struct flchip *chip)
+ 	/* Did we succeed? */
+ 	if (ret) {
+ 		/* reset on all failures. */
+-		cfi_check_err_status(map, chip, adr);
+ 		map_write(map, CMD(0xF0), chip->start);
+ 		/* FIXME - should have reset delay before continuing */
+ 
+@@ -2564,8 +2574,11 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
+ 			chip->erase_suspended = 0;
+ 		}
+ 
+-		if (chip_good(map, chip, adr, map_word_ff(map)))
++		if (chip_good(map, chip, adr, map_word_ff(map))) {
++			if (cfi_check_err_status(map, chip, adr))
++				ret = -EIO;
+ 			break;
++		}
+ 
+ 		if (time_after(jiffies, timeo)) {
+ 			printk(KERN_WARNING "MTD %s(): software timeout\n",
+@@ -2580,7 +2593,6 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
+ 	/* Did we succeed? */
+ 	if (ret) {
+ 		/* reset on all failures. */
+-		cfi_check_err_status(map, chip, adr);
+ 		map_write(map, CMD(0xF0), chip->start);
+ 		/* FIXME - should have reset delay before continuing */
+ 
+diff --git a/drivers/mtd/devices/mchp23k256.c b/drivers/mtd/devices/mchp23k256.c
+index b20d02b4f830..77c872fd3d83 100644
+--- a/drivers/mtd/devices/mchp23k256.c
++++ b/drivers/mtd/devices/mchp23k256.c
+@@ -64,15 +64,17 @@ static int mchp23k256_write(struct mtd_info *mtd, loff_t to, size_t len,
+ 	struct spi_transfer transfer[2] = {};
+ 	struct spi_message message;
+ 	unsigned char command[MAX_CMD_SIZE];
+-	int ret;
++	int ret, cmd_len;
+ 
+ 	spi_message_init(&message);
+ 
++	cmd_len = mchp23k256_cmdsz(flash);
++
+ 	command[0] = MCHP23K256_CMD_WRITE;
+ 	mchp23k256_addr2cmd(flash, to, command);
+ 
+ 	transfer[0].tx_buf = command;
+-	transfer[0].len = mchp23k256_cmdsz(flash);
++	transfer[0].len = cmd_len;
+ 	spi_message_add_tail(&transfer[0], &message);
+ 
+ 	transfer[1].tx_buf = buf;
+@@ -88,8 +90,8 @@ static int mchp23k256_write(struct mtd_info *mtd, loff_t to, size_t len,
+ 	if (ret)
+ 		return ret;
+ 
+-	if (retlen && message.actual_length > sizeof(command))
+-		*retlen += message.actual_length - sizeof(command);
++	if (retlen && message.actual_length > cmd_len)
++		*retlen += message.actual_length - cmd_len;
+ 
+ 	return 0;
+ }
+@@ -101,16 +103,18 @@ static int mchp23k256_read(struct mtd_info *mtd, loff_t from, size_t len,
+ 	struct spi_transfer transfer[2] = {};
+ 	struct spi_message message;
+ 	unsigned char command[MAX_CMD_SIZE];
+-	int ret;
++	int ret, cmd_len;
+ 
+ 	spi_message_init(&message);
+ 
++	cmd_len = mchp23k256_cmdsz(flash);
++
+ 	memset(&transfer, 0, sizeof(transfer));
+ 	command[0] = MCHP23K256_CMD_READ;
+ 	mchp23k256_addr2cmd(flash, from, command);
+ 
+ 	transfer[0].tx_buf = command;
+-	transfer[0].len = mchp23k256_cmdsz(flash);
++	transfer[0].len = cmd_len;
+ 	spi_message_add_tail(&transfer[0], &message);
+ 
+ 	transfer[1].rx_buf = buf;
+@@ -126,8 +130,8 @@ static int mchp23k256_read(struct mtd_info *mtd, loff_t from, size_t len,
+ 	if (ret)
+ 		return ret;
+ 
+-	if (retlen && message.actual_length > sizeof(command))
+-		*retlen += message.actual_length - sizeof(command);
++	if (retlen && message.actual_length > cmd_len)
++		*retlen += message.actual_length - cmd_len;
+ 
+ 	return 0;
+ }
+diff --git a/drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c b/drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c
+index 334fe3130285..b9d5d55a5edb 100644
+--- a/drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c
++++ b/drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c
+@@ -148,6 +148,10 @@ static int gpmi_init(struct gpmi_nand_data *this)
+ 	struct resources *r = &this->resources;
+ 	int ret;
+ 
++	ret = pm_runtime_get_sync(this->dev);
++	if (ret < 0)
++		return ret;
++
+ 	ret = gpmi_reset_block(r->gpmi_regs, false);
+ 	if (ret)
+ 		goto err_out;
+@@ -179,8 +183,9 @@ static int gpmi_init(struct gpmi_nand_data *this)
+ 	 */
+ 	writel(BM_GPMI_CTRL1_DECOUPLE_CS, r->gpmi_regs + HW_GPMI_CTRL1_SET);
+ 
+-	return 0;
+ err_out:
++	pm_runtime_mark_last_busy(this->dev);
++	pm_runtime_put_autosuspend(this->dev);
+ 	return ret;
+ }
+ 
+@@ -2722,6 +2727,10 @@ static int gpmi_pm_resume(struct device *dev)
+ 		return ret;
+ 	}
+ 
++	/* Set flag to get timing setup restored for next exec_op */
++	if (this->hw.clk_rate)
++		this->hw.must_apply_timings = true;
++
+ 	/* re-init the BCH registers */
+ 	ret = bch_set_geometry(this);
+ 	if (ret) {
+diff --git a/drivers/mtd/spi-nor/spi-nor.c b/drivers/mtd/spi-nor/spi-nor.c
+index 1548e0f7f5f4..309c808351ac 100644
+--- a/drivers/mtd/spi-nor/spi-nor.c
++++ b/drivers/mtd/spi-nor/spi-nor.c
+@@ -4544,9 +4544,7 @@ static void spi_nor_info_init_params(struct spi_nor *nor)
+ 
+ static void spansion_post_sfdp_fixups(struct spi_nor *nor)
+ {
+-	struct mtd_info *mtd = &nor->mtd;
+-
+-	if (mtd->size <= SZ_16M)
++	if (nor->params.size <= SZ_16M)
+ 		return;
+ 
+ 	nor->flags |= SNOR_F_4B_OPCODES;
+diff --git a/drivers/net/dsa/bcm_sf2.c b/drivers/net/dsa/bcm_sf2.c
+index 69fc13046ac7..47b21096b577 100644
+--- a/drivers/net/dsa/bcm_sf2.c
++++ b/drivers/net/dsa/bcm_sf2.c
+@@ -68,7 +68,7 @@ static void bcm_sf2_imp_setup(struct dsa_switch *ds, int port)
+ 
+ 		/* Force link status for IMP port */
+ 		reg = core_readl(priv, offset);
+-		reg |= (MII_SW_OR | LINK_STS);
++		reg |= (MII_SW_OR | LINK_STS | GMII_SPEED_UP_2G);
+ 		core_writel(priv, reg, offset);
+ 
+ 		/* Enable Broadcast, Multicast, Unicast forwarding to IMP port */
+diff --git a/drivers/net/dsa/sja1105/sja1105_main.c b/drivers/net/dsa/sja1105/sja1105_main.c
+index 7763221286d4..3b51e87a3714 100644
+--- a/drivers/net/dsa/sja1105/sja1105_main.c
++++ b/drivers/net/dsa/sja1105/sja1105_main.c
+@@ -619,7 +619,7 @@ static int sja1105_parse_ports_node(struct sja1105_private *priv,
+ 	struct device *dev = &priv->spidev->dev;
+ 	struct device_node *child;
+ 
+-	for_each_child_of_node(ports_node, child) {
++	for_each_available_child_of_node(ports_node, child) {
+ 		struct device_node *phy_node;
+ 		int phy_mode;
+ 		u32 index;
+diff --git a/drivers/net/ethernet/broadcom/bcmsysport.c b/drivers/net/ethernet/broadcom/bcmsysport.c
+index a977a459bd20..b4c664957266 100644
+--- a/drivers/net/ethernet/broadcom/bcmsysport.c
++++ b/drivers/net/ethernet/broadcom/bcmsysport.c
+@@ -2323,7 +2323,7 @@ static int bcm_sysport_map_queues(struct notifier_block *nb,
+ 		ring->switch_queue = qp;
+ 		ring->switch_port = port;
+ 		ring->inspect = true;
+-		priv->ring_map[q + port * num_tx_queues] = ring;
++		priv->ring_map[qp + port * num_tx_queues] = ring;
+ 		qp++;
+ 	}
+ 
+@@ -2338,7 +2338,7 @@ static int bcm_sysport_unmap_queues(struct notifier_block *nb,
+ 	struct net_device *slave_dev;
+ 	unsigned int num_tx_queues;
+ 	struct net_device *dev;
+-	unsigned int q, port;
++	unsigned int q, qp, port;
+ 
+ 	priv = container_of(nb, struct bcm_sysport_priv, dsa_notifier);
+ 	if (priv->netdev != info->master)
+@@ -2364,7 +2364,8 @@ static int bcm_sysport_unmap_queues(struct notifier_block *nb,
+ 			continue;
+ 
+ 		ring->inspect = false;
+-		priv->ring_map[q + port * num_tx_queues] = NULL;
++		qp = ring->switch_queue;
++		priv->ring_map[qp + port * num_tx_queues] = NULL;
+ 	}
+ 
+ 	return 0;
+diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.c b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
+index 5c75b061243f..cf292f7c3d3c 100644
+--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.c
++++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
+@@ -10991,11 +10991,23 @@ static bool bnxt_fltr_match(struct bnxt_ntuple_filter *f1,
+ 	struct flow_keys *keys1 = &f1->fkeys;
+ 	struct flow_keys *keys2 = &f2->fkeys;
+ 
+-	if (keys1->addrs.v4addrs.src == keys2->addrs.v4addrs.src &&
+-	    keys1->addrs.v4addrs.dst == keys2->addrs.v4addrs.dst &&
+-	    keys1->ports.ports == keys2->ports.ports &&
+-	    keys1->basic.ip_proto == keys2->basic.ip_proto &&
+-	    keys1->basic.n_proto == keys2->basic.n_proto &&
++	if (keys1->basic.n_proto != keys2->basic.n_proto ||
++	    keys1->basic.ip_proto != keys2->basic.ip_proto)
++		return false;
++
++	if (keys1->basic.n_proto == htons(ETH_P_IP)) {
++		if (keys1->addrs.v4addrs.src != keys2->addrs.v4addrs.src ||
++		    keys1->addrs.v4addrs.dst != keys2->addrs.v4addrs.dst)
++			return false;
++	} else {
++		if (memcmp(&keys1->addrs.v6addrs.src, &keys2->addrs.v6addrs.src,
++			   sizeof(keys1->addrs.v6addrs.src)) ||
++		    memcmp(&keys1->addrs.v6addrs.dst, &keys2->addrs.v6addrs.dst,
++			   sizeof(keys1->addrs.v6addrs.dst)))
++			return false;
++	}
++
++	if (keys1->ports.ports == keys2->ports.ports &&
+ 	    keys1->control.flags == keys2->control.flags &&
+ 	    ether_addr_equal(f1->src_mac_addr, f2->src_mac_addr) &&
+ 	    ether_addr_equal(f1->dst_mac_addr, f2->dst_mac_addr))
+@@ -11287,7 +11299,7 @@ int bnxt_get_port_parent_id(struct net_device *dev,
+ 		return -EOPNOTSUPP;
+ 
+ 	/* The PF and it's VF-reps only support the switchdev framework */
+-	if (!BNXT_PF(bp))
++	if (!BNXT_PF(bp) || !(bp->flags & BNXT_FLAG_DSN_VALID))
+ 		return -EOPNOTSUPP;
+ 
+ 	ppid->id_len = sizeof(bp->switch_id);
+@@ -11679,6 +11691,7 @@ static int bnxt_pcie_dsn_get(struct bnxt *bp, u8 dsn[])
+ 	put_unaligned_le32(dw, &dsn[0]);
+ 	pci_read_config_dword(pdev, pos + 4, &dw);
+ 	put_unaligned_le32(dw, &dsn[4]);
++	bp->flags |= BNXT_FLAG_DSN_VALID;
+ 	return 0;
+ }
+ 
+@@ -11790,9 +11803,7 @@ static int bnxt_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
+ 
+ 	if (BNXT_PF(bp)) {
+ 		/* Read the adapter's DSN to use as the eswitch switch_id */
+-		rc = bnxt_pcie_dsn_get(bp, bp->switch_id);
+-		if (rc)
+-			goto init_err_pci_clean;
++		bnxt_pcie_dsn_get(bp, bp->switch_id);
+ 	}
+ 
+ 	/* MTU range: 60 - FW defined max */
+diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.h b/drivers/net/ethernet/broadcom/bnxt/bnxt.h
+index dc26e3ace43f..2e6ad53fdc75 100644
+--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.h
++++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.h
+@@ -1510,6 +1510,7 @@ struct bnxt {
+ 	#define BNXT_FLAG_NO_AGG_RINGS	0x20000
+ 	#define BNXT_FLAG_RX_PAGE_MODE	0x40000
+ 	#define BNXT_FLAG_MULTI_HOST	0x100000
++	#define BNXT_FLAG_DSN_VALID	0x200000
+ 	#define BNXT_FLAG_DOUBLE_DB	0x400000
+ 	#define BNXT_FLAG_CHIP_NITRO_A0	0x1000000
+ 	#define BNXT_FLAG_DIM		0x2000000
+@@ -1904,9 +1905,6 @@ static inline bool bnxt_cfa_hwrm_message(u16 req_type)
+ 	case HWRM_CFA_ENCAP_RECORD_FREE:
+ 	case HWRM_CFA_DECAP_FILTER_ALLOC:
+ 	case HWRM_CFA_DECAP_FILTER_FREE:
+-	case HWRM_CFA_NTUPLE_FILTER_ALLOC:
+-	case HWRM_CFA_NTUPLE_FILTER_FREE:
+-	case HWRM_CFA_NTUPLE_FILTER_CFG:
+ 	case HWRM_CFA_EM_FLOW_ALLOC:
+ 	case HWRM_CFA_EM_FLOW_FREE:
+ 	case HWRM_CFA_EM_FLOW_CFG:
+diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c
+index f9bf7d7250ab..b010b34cdaf8 100644
+--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c
++++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c
+@@ -398,6 +398,9 @@ static int bnxt_vf_reps_create(struct bnxt *bp)
+ 	struct net_device *dev;
+ 	int rc, i;
+ 
++	if (!(bp->flags & BNXT_FLAG_DSN_VALID))
++		return -ENODEV;
++
+ 	bp->vf_reps = kcalloc(num_vfs, sizeof(vf_rep), GFP_KERNEL);
+ 	if (!bp->vf_reps)
+ 		return -ENOMEM;
+diff --git a/drivers/net/ethernet/hisilicon/hns/hns_enet.c b/drivers/net/ethernet/hisilicon/hns/hns_enet.c
+index 14ab20491fd0..eb69e5c81a4d 100644
+--- a/drivers/net/ethernet/hisilicon/hns/hns_enet.c
++++ b/drivers/net/ethernet/hisilicon/hns/hns_enet.c
+@@ -565,7 +565,6 @@ static int hns_nic_poll_rx_skb(struct hns_nic_ring_data *ring_data,
+ 	skb = *out_skb = napi_alloc_skb(&ring_data->napi,
+ 					HNS_RX_HEAD_SIZE);
+ 	if (unlikely(!skb)) {
+-		netdev_err(ndev, "alloc rx skb fail\n");
+ 		ring->stats.sw_err_cnt++;
+ 		return -ENOMEM;
+ 	}
+@@ -1056,7 +1055,6 @@ static int hns_nic_common_poll(struct napi_struct *napi, int budget)
+ 		container_of(napi, struct hns_nic_ring_data, napi);
+ 	struct hnae_ring *ring = ring_data->ring;
+ 
+-try_again:
+ 	clean_complete += ring_data->poll_one(
+ 				ring_data, budget - clean_complete,
+ 				ring_data->ex_process);
+@@ -1066,7 +1064,7 @@ try_again:
+ 			napi_complete(napi);
+ 			ring->q->handle->dev->ops->toggle_ring_irq(ring, 0);
+ 		} else {
+-			goto try_again;
++			return budget;
+ 		}
+ 	}
+ 
+diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c b/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c
+index 84d8816c8681..0c8d2269bc46 100644
+--- a/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c
++++ b/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c
+@@ -54,6 +54,8 @@ MODULE_PARM_DESC(debug, " Network interface message level setting");
+ #define HNS3_INNER_VLAN_TAG	1
+ #define HNS3_OUTER_VLAN_TAG	2
+ 
++#define HNS3_MIN_TX_LEN		33U
++
+ /* hns3_pci_tbl - PCI Device ID Table
+  *
+  * Last entry must be all 0s
+@@ -1329,6 +1331,10 @@ netdev_tx_t hns3_nic_net_xmit(struct sk_buff *skb, struct net_device *netdev)
+ 	int ret;
+ 	int i;
+ 
++	/* Hardware can only handle short frames above 32 bytes */
++	if (skb_put_padto(skb, HNS3_MIN_TX_LEN))
++		return NETDEV_TX_OK;
++
+ 	/* Prefetch the data used later */
+ 	prefetch(skb->data);
+ 
+diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c
+index 4960c9c3e773..a8dd0228b678 100644
+--- a/drivers/net/ethernet/intel/i40e/i40e_main.c
++++ b/drivers/net/ethernet/intel/i40e/i40e_main.c
+@@ -7168,6 +7168,7 @@ static int i40e_setup_macvlans(struct i40e_vsi *vsi, u16 macvlan_cnt, u16 qcnt,
+ 		ch->num_queue_pairs = qcnt;
+ 		if (!i40e_setup_channel(pf, vsi, ch)) {
+ 			ret = -EINVAL;
++			kfree(ch);
+ 			goto err_free;
+ 		}
+ 		ch->parent_vsi = vsi;
+diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
+index 3ec18fb0d479..a806c6190bb1 100644
+--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
++++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
+@@ -812,23 +812,17 @@ static netdev_tx_t mlxsw_sp_port_xmit(struct sk_buff *skb,
+ 	u64 len;
+ 	int err;
+ 
++	if (skb_cow_head(skb, MLXSW_TXHDR_LEN)) {
++		this_cpu_inc(mlxsw_sp_port->pcpu_stats->tx_dropped);
++		dev_kfree_skb_any(skb);
++		return NETDEV_TX_OK;
++	}
++
+ 	memset(skb->cb, 0, sizeof(struct mlxsw_skb_cb));
+ 
+ 	if (mlxsw_core_skb_transmit_busy(mlxsw_sp->core, &tx_info))
+ 		return NETDEV_TX_BUSY;
+ 
+-	if (unlikely(skb_headroom(skb) < MLXSW_TXHDR_LEN)) {
+-		struct sk_buff *skb_orig = skb;
+-
+-		skb = skb_realloc_headroom(skb, MLXSW_TXHDR_LEN);
+-		if (!skb) {
+-			this_cpu_inc(mlxsw_sp_port->pcpu_stats->tx_dropped);
+-			dev_kfree_skb_any(skb_orig);
+-			return NETDEV_TX_OK;
+-		}
+-		dev_consume_skb_any(skb_orig);
+-	}
+-
+ 	if (eth_skb_pad(skb)) {
+ 		this_cpu_inc(mlxsw_sp_port->pcpu_stats->tx_dropped);
+ 		return NETDEV_TX_OK;
+@@ -1167,6 +1161,9 @@ static void update_stats_cache(struct work_struct *work)
+ 			     periodic_hw_stats.update_dw.work);
+ 
+ 	if (!netif_carrier_ok(mlxsw_sp_port->dev))
++		/* Note: mlxsw_sp_port_down_wipe_counters() clears the cache as
++		 * necessary when port goes down.
++		 */
+ 		goto out;
+ 
+ 	mlxsw_sp_port_get_hw_stats(mlxsw_sp_port->dev,
+@@ -4176,6 +4173,15 @@ static int mlxsw_sp_port_unsplit(struct mlxsw_core *mlxsw_core, u8 local_port,
+ 	return 0;
+ }
+ 
++static void
++mlxsw_sp_port_down_wipe_counters(struct mlxsw_sp_port *mlxsw_sp_port)
++{
++	int i;
++
++	for (i = 0; i < TC_MAX_QUEUE; i++)
++		mlxsw_sp_port->periodic_hw_stats.xstats.backlog[i] = 0;
++}
++
+ static void mlxsw_sp_pude_event_func(const struct mlxsw_reg_info *reg,
+ 				     char *pude_pl, void *priv)
+ {
+@@ -4197,6 +4203,7 @@ static void mlxsw_sp_pude_event_func(const struct mlxsw_reg_info *reg,
+ 	} else {
+ 		netdev_info(mlxsw_sp_port->dev, "link down\n");
+ 		netif_carrier_off(mlxsw_sp_port->dev);
++		mlxsw_sp_port_down_wipe_counters(mlxsw_sp_port);
+ 	}
+ }
+ 
+diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_qdisc.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_qdisc.c
+index 720514b5c006..dc63583c4948 100644
+--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_qdisc.c
++++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_qdisc.c
+@@ -195,6 +195,20 @@ mlxsw_sp_qdisc_get_xstats(struct mlxsw_sp_port *mlxsw_sp_port,
+ 	return -EOPNOTSUPP;
+ }
+ 
++static u64
++mlxsw_sp_xstats_backlog(struct mlxsw_sp_port_xstats *xstats, int tclass_num)
++{
++	return xstats->backlog[tclass_num] +
++	       xstats->backlog[tclass_num + 8];
++}
++
++static u64
++mlxsw_sp_xstats_tail_drop(struct mlxsw_sp_port_xstats *xstats, int tclass_num)
++{
++	return xstats->tail_drop[tclass_num] +
++	       xstats->tail_drop[tclass_num + 8];
++}
++
+ static void
+ mlxsw_sp_qdisc_bstats_per_priority_get(struct mlxsw_sp_port_xstats *xstats,
+ 				       u8 prio_bitmap, u64 *tx_packets,
+@@ -269,7 +283,7 @@ mlxsw_sp_setup_tc_qdisc_red_clean_stats(struct mlxsw_sp_port *mlxsw_sp_port,
+ 					       &stats_base->tx_bytes);
+ 	red_base->prob_mark = xstats->ecn;
+ 	red_base->prob_drop = xstats->wred_drop[tclass_num];
+-	red_base->pdrop = xstats->tail_drop[tclass_num];
++	red_base->pdrop = mlxsw_sp_xstats_tail_drop(xstats, tclass_num);
+ 
+ 	stats_base->overlimits = red_base->prob_drop + red_base->prob_mark;
+ 	stats_base->drops = red_base->prob_drop + red_base->pdrop;
+@@ -369,7 +383,8 @@ mlxsw_sp_qdisc_get_red_xstats(struct mlxsw_sp_port *mlxsw_sp_port,
+ 
+ 	early_drops = xstats->wred_drop[tclass_num] - xstats_base->prob_drop;
+ 	marks = xstats->ecn - xstats_base->prob_mark;
+-	pdrops = xstats->tail_drop[tclass_num] - xstats_base->pdrop;
++	pdrops = mlxsw_sp_xstats_tail_drop(xstats, tclass_num) -
++		 xstats_base->pdrop;
+ 
+ 	res->pdrop += pdrops;
+ 	res->prob_drop += early_drops;
+@@ -402,9 +417,10 @@ mlxsw_sp_qdisc_get_red_stats(struct mlxsw_sp_port *mlxsw_sp_port,
+ 
+ 	overlimits = xstats->wred_drop[tclass_num] + xstats->ecn -
+ 		     stats_base->overlimits;
+-	drops = xstats->wred_drop[tclass_num] + xstats->tail_drop[tclass_num] -
++	drops = xstats->wred_drop[tclass_num] +
++		mlxsw_sp_xstats_tail_drop(xstats, tclass_num) -
+ 		stats_base->drops;
+-	backlog = xstats->backlog[tclass_num];
++	backlog = mlxsw_sp_xstats_backlog(xstats, tclass_num);
+ 
+ 	_bstats_update(stats_ptr->bstats, tx_bytes, tx_packets);
+ 	stats_ptr->qstats->overlimits += overlimits;
+@@ -575,9 +591,9 @@ mlxsw_sp_qdisc_get_prio_stats(struct mlxsw_sp_port *mlxsw_sp_port,
+ 	tx_packets = stats->tx_packets - stats_base->tx_packets;
+ 
+ 	for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
+-		drops += xstats->tail_drop[i];
++		drops += mlxsw_sp_xstats_tail_drop(xstats, i);
+ 		drops += xstats->wred_drop[i];
+-		backlog += xstats->backlog[i];
++		backlog += mlxsw_sp_xstats_backlog(xstats, i);
+ 	}
+ 	drops = drops - stats_base->drops;
+ 
+@@ -613,7 +629,7 @@ mlxsw_sp_setup_tc_qdisc_prio_clean_stats(struct mlxsw_sp_port *mlxsw_sp_port,
+ 
+ 	stats_base->drops = 0;
+ 	for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
+-		stats_base->drops += xstats->tail_drop[i];
++		stats_base->drops += mlxsw_sp_xstats_tail_drop(xstats, i);
+ 		stats_base->drops += xstats->wred_drop[i];
+ 	}
+ 
+diff --git a/drivers/net/ethernet/renesas/sh_eth.c b/drivers/net/ethernet/renesas/sh_eth.c
+index 7ba35a0bdb29..8aa1b1bda96d 100644
+--- a/drivers/net/ethernet/renesas/sh_eth.c
++++ b/drivers/net/ethernet/renesas/sh_eth.c
+@@ -2204,24 +2204,28 @@ static size_t __sh_eth_get_regs(struct net_device *ndev, u32 *buf)
+ 	if (cd->tsu) {
+ 		add_tsu_reg(ARSTR);
+ 		add_tsu_reg(TSU_CTRST);
+-		add_tsu_reg(TSU_FWEN0);
+-		add_tsu_reg(TSU_FWEN1);
+-		add_tsu_reg(TSU_FCM);
+-		add_tsu_reg(TSU_BSYSL0);
+-		add_tsu_reg(TSU_BSYSL1);
+-		add_tsu_reg(TSU_PRISL0);
+-		add_tsu_reg(TSU_PRISL1);
+-		add_tsu_reg(TSU_FWSL0);
+-		add_tsu_reg(TSU_FWSL1);
++		if (cd->dual_port) {
++			add_tsu_reg(TSU_FWEN0);
++			add_tsu_reg(TSU_FWEN1);
++			add_tsu_reg(TSU_FCM);
++			add_tsu_reg(TSU_BSYSL0);
++			add_tsu_reg(TSU_BSYSL1);
++			add_tsu_reg(TSU_PRISL0);
++			add_tsu_reg(TSU_PRISL1);
++			add_tsu_reg(TSU_FWSL0);
++			add_tsu_reg(TSU_FWSL1);
++		}
+ 		add_tsu_reg(TSU_FWSLC);
+-		add_tsu_reg(TSU_QTAGM0);
+-		add_tsu_reg(TSU_QTAGM1);
+-		add_tsu_reg(TSU_FWSR);
+-		add_tsu_reg(TSU_FWINMK);
+-		add_tsu_reg(TSU_ADQT0);
+-		add_tsu_reg(TSU_ADQT1);
+-		add_tsu_reg(TSU_VTAG0);
+-		add_tsu_reg(TSU_VTAG1);
++		if (cd->dual_port) {
++			add_tsu_reg(TSU_QTAGM0);
++			add_tsu_reg(TSU_QTAGM1);
++			add_tsu_reg(TSU_FWSR);
++			add_tsu_reg(TSU_FWINMK);
++			add_tsu_reg(TSU_ADQT0);
++			add_tsu_reg(TSU_ADQT1);
++			add_tsu_reg(TSU_VTAG0);
++			add_tsu_reg(TSU_VTAG1);
++		}
+ 		add_tsu_reg(TSU_ADSBSY);
+ 		add_tsu_reg(TSU_TEN);
+ 		add_tsu_reg(TSU_POST1);
+diff --git a/drivers/net/ethernet/socionext/sni_ave.c b/drivers/net/ethernet/socionext/sni_ave.c
+index 6e984d5a729f..38d39c4b5ac8 100644
+--- a/drivers/net/ethernet/socionext/sni_ave.c
++++ b/drivers/net/ethernet/socionext/sni_ave.c
+@@ -424,16 +424,22 @@ static void ave_ethtool_get_wol(struct net_device *ndev,
+ 		phy_ethtool_get_wol(ndev->phydev, wol);
+ }
+ 
+-static int ave_ethtool_set_wol(struct net_device *ndev,
+-			       struct ethtool_wolinfo *wol)
++static int __ave_ethtool_set_wol(struct net_device *ndev,
++				 struct ethtool_wolinfo *wol)
+ {
+-	int ret;
+-
+ 	if (!ndev->phydev ||
+ 	    (wol->wolopts & (WAKE_ARP | WAKE_MAGICSECURE)))
+ 		return -EOPNOTSUPP;
+ 
+-	ret = phy_ethtool_set_wol(ndev->phydev, wol);
++	return phy_ethtool_set_wol(ndev->phydev, wol);
++}
++
++static int ave_ethtool_set_wol(struct net_device *ndev,
++			       struct ethtool_wolinfo *wol)
++{
++	int ret;
++
++	ret = __ave_ethtool_set_wol(ndev, wol);
+ 	if (!ret)
+ 		device_set_wakeup_enable(&ndev->dev, !!wol->wolopts);
+ 
+@@ -1216,7 +1222,7 @@ static int ave_init(struct net_device *ndev)
+ 
+ 	/* set wol initial state disabled */
+ 	wol.wolopts = 0;
+-	ave_ethtool_set_wol(ndev, &wol);
++	__ave_ethtool_set_wol(ndev, &wol);
+ 
+ 	if (!phy_interface_is_rgmii(phydev))
+ 		phy_set_max_speed(phydev, SPEED_100);
+@@ -1768,7 +1774,7 @@ static int ave_resume(struct device *dev)
+ 
+ 	ave_ethtool_get_wol(ndev, &wol);
+ 	wol.wolopts = priv->wolopts;
+-	ave_ethtool_set_wol(ndev, &wol);
++	__ave_ethtool_set_wol(ndev, &wol);
+ 
+ 	if (ndev->phydev) {
+ 		ret = phy_resume(ndev->phydev);
+diff --git a/drivers/net/ethernet/stmicro/stmmac/common.h b/drivers/net/ethernet/stmicro/stmmac/common.h
+index 912bbb6515b2..bc82cdf36cc3 100644
+--- a/drivers/net/ethernet/stmicro/stmmac/common.h
++++ b/drivers/net/ethernet/stmicro/stmmac/common.h
+@@ -364,9 +364,8 @@ struct dma_features {
+ 	unsigned int arpoffsel;
+ };
+ 
+-/* GMAC TX FIFO is 8K, Rx FIFO is 16K */
+-#define BUF_SIZE_16KiB 16384
+-/* RX Buffer size must be < 8191 and multiple of 4/8/16 bytes */
++/* RX Buffer size must be multiple of 4/8/16 bytes */
++#define BUF_SIZE_16KiB 16368
+ #define BUF_SIZE_8KiB 8188
+ #define BUF_SIZE_4KiB 4096
+ #define BUF_SIZE_2KiB 2048
+diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
+index 903c5d8a226e..1b3520d0e59e 100644
+--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
++++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
+@@ -1108,7 +1108,9 @@ static int stmmac_set_bfsize(int mtu, int bufsize)
+ {
+ 	int ret = bufsize;
+ 
+-	if (mtu >= BUF_SIZE_4KiB)
++	if (mtu >= BUF_SIZE_8KiB)
++		ret = BUF_SIZE_16KiB;
++	else if (mtu >= BUF_SIZE_4KiB)
+ 		ret = BUF_SIZE_8KiB;
+ 	else if (mtu >= BUF_SIZE_2KiB)
+ 		ret = BUF_SIZE_4KiB;
+diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c
+index a0513deab1a0..ba03a2d77434 100644
+--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c
++++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c
+@@ -80,7 +80,7 @@ static struct sk_buff *stmmac_test_get_udp_skb(struct stmmac_priv *priv,
+ 	if (attr->max_size && (attr->max_size > size))
+ 		size = attr->max_size;
+ 
+-	skb = netdev_alloc_skb_ip_align(priv->dev, size);
++	skb = netdev_alloc_skb(priv->dev, size);
+ 	if (!skb)
+ 		return NULL;
+ 
+@@ -244,6 +244,8 @@ static int stmmac_test_loopback_validate(struct sk_buff *skb,
+ 					 struct net_device *orig_ndev)
+ {
+ 	struct stmmac_test_priv *tpriv = pt->af_packet_priv;
++	unsigned char *src = tpriv->packet->src;
++	unsigned char *dst = tpriv->packet->dst;
+ 	struct stmmachdr *shdr;
+ 	struct ethhdr *ehdr;
+ 	struct udphdr *uhdr;
+@@ -260,15 +262,15 @@ static int stmmac_test_loopback_validate(struct sk_buff *skb,
+ 		goto out;
+ 
+ 	ehdr = (struct ethhdr *)skb_mac_header(skb);
+-	if (tpriv->packet->dst) {
+-		if (!ether_addr_equal(ehdr->h_dest, tpriv->packet->dst))
++	if (dst) {
++		if (!ether_addr_equal_unaligned(ehdr->h_dest, dst))
+ 			goto out;
+ 	}
+ 	if (tpriv->packet->sarc) {
+-		if (!ether_addr_equal(ehdr->h_source, ehdr->h_dest))
++		if (!ether_addr_equal_unaligned(ehdr->h_source, ehdr->h_dest))
+ 			goto out;
+-	} else if (tpriv->packet->src) {
+-		if (!ether_addr_equal(ehdr->h_source, tpriv->packet->src))
++	} else if (src) {
++		if (!ether_addr_equal_unaligned(ehdr->h_source, src))
+ 			goto out;
+ 	}
+ 
+@@ -714,7 +716,7 @@ static int stmmac_test_flowctrl_validate(struct sk_buff *skb,
+ 	struct ethhdr *ehdr;
+ 
+ 	ehdr = (struct ethhdr *)skb_mac_header(skb);
+-	if (!ether_addr_equal(ehdr->h_source, orig_ndev->dev_addr))
++	if (!ether_addr_equal_unaligned(ehdr->h_source, orig_ndev->dev_addr))
+ 		goto out;
+ 	if (ehdr->h_proto != htons(ETH_P_PAUSE))
+ 		goto out;
+@@ -851,12 +853,16 @@ static int stmmac_test_vlan_validate(struct sk_buff *skb,
+ 	if (tpriv->vlan_id) {
+ 		if (skb->vlan_proto != htons(proto))
+ 			goto out;
+-		if (skb->vlan_tci != tpriv->vlan_id)
++		if (skb->vlan_tci != tpriv->vlan_id) {
++			/* Means filter did not work. */
++			tpriv->ok = false;
++			complete(&tpriv->comp);
+ 			goto out;
++		}
+ 	}
+ 
+ 	ehdr = (struct ethhdr *)skb_mac_header(skb);
+-	if (!ether_addr_equal(ehdr->h_dest, tpriv->packet->dst))
++	if (!ether_addr_equal_unaligned(ehdr->h_dest, tpriv->packet->dst))
+ 		goto out;
+ 
+ 	ihdr = ip_hdr(skb);
+@@ -1291,16 +1297,19 @@ static int __stmmac_test_l3filt(struct stmmac_priv *priv, u32 dst, u32 src,
+ 	struct stmmac_packet_attrs attr = { };
+ 	struct flow_dissector *dissector;
+ 	struct flow_cls_offload *cls;
++	int ret, old_enable = 0;
+ 	struct flow_rule *rule;
+-	int ret;
+ 
+ 	if (!tc_can_offload(priv->dev))
+ 		return -EOPNOTSUPP;
+ 	if (!priv->dma_cap.l3l4fnum)
+ 		return -EOPNOTSUPP;
+-	if (priv->rss.enable)
++	if (priv->rss.enable) {
++		old_enable = priv->rss.enable;
++		priv->rss.enable = false;
+ 		stmmac_rss_configure(priv, priv->hw, NULL,
+ 				     priv->plat->rx_queues_to_use);
++	}
+ 
+ 	dissector = kzalloc(sizeof(*dissector), GFP_KERNEL);
+ 	if (!dissector) {
+@@ -1367,7 +1376,8 @@ cleanup_cls:
+ cleanup_dissector:
+ 	kfree(dissector);
+ cleanup_rss:
+-	if (priv->rss.enable) {
++	if (old_enable) {
++		priv->rss.enable = old_enable;
+ 		stmmac_rss_configure(priv, priv->hw, &priv->rss,
+ 				     priv->plat->rx_queues_to_use);
+ 	}
+@@ -1412,16 +1422,19 @@ static int __stmmac_test_l4filt(struct stmmac_priv *priv, u32 dst, u32 src,
+ 	struct stmmac_packet_attrs attr = { };
+ 	struct flow_dissector *dissector;
+ 	struct flow_cls_offload *cls;
++	int ret, old_enable = 0;
+ 	struct flow_rule *rule;
+-	int ret;
+ 
+ 	if (!tc_can_offload(priv->dev))
+ 		return -EOPNOTSUPP;
+ 	if (!priv->dma_cap.l3l4fnum)
+ 		return -EOPNOTSUPP;
+-	if (priv->rss.enable)
++	if (priv->rss.enable) {
++		old_enable = priv->rss.enable;
++		priv->rss.enable = false;
+ 		stmmac_rss_configure(priv, priv->hw, NULL,
+ 				     priv->plat->rx_queues_to_use);
++	}
+ 
+ 	dissector = kzalloc(sizeof(*dissector), GFP_KERNEL);
+ 	if (!dissector) {
+@@ -1493,7 +1506,8 @@ cleanup_cls:
+ cleanup_dissector:
+ 	kfree(dissector);
+ cleanup_rss:
+-	if (priv->rss.enable) {
++	if (old_enable) {
++		priv->rss.enable = old_enable;
+ 		stmmac_rss_configure(priv, priv->hw, &priv->rss,
+ 				     priv->plat->rx_queues_to_use);
+ 	}
+@@ -1546,7 +1560,7 @@ static int stmmac_test_arp_validate(struct sk_buff *skb,
+ 	struct arphdr *ahdr;
+ 
+ 	ehdr = (struct ethhdr *)skb_mac_header(skb);
+-	if (!ether_addr_equal(ehdr->h_dest, tpriv->packet->src))
++	if (!ether_addr_equal_unaligned(ehdr->h_dest, tpriv->packet->src))
+ 		goto out;
+ 
+ 	ahdr = arp_hdr(skb);
+diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_tc.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_tc.c
+index f9a9a9d82233..1d135b02ea02 100644
+--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_tc.c
++++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_tc.c
+@@ -579,6 +579,10 @@ static int tc_setup_cls(struct stmmac_priv *priv,
+ {
+ 	int ret = 0;
+ 
++	/* When RSS is enabled, the filtering will be bypassed */
++	if (priv->rss.enable)
++		return -EBUSY;
++
+ 	switch (cls->command) {
+ 	case FLOW_CLS_REPLACE:
+ 		ret = tc_add_flow(priv, cls);
+diff --git a/drivers/net/hyperv/rndis_filter.c b/drivers/net/hyperv/rndis_filter.c
+index f81e58267a6e..b9e44bb22289 100644
+--- a/drivers/net/hyperv/rndis_filter.c
++++ b/drivers/net/hyperv/rndis_filter.c
+@@ -1436,8 +1436,6 @@ void rndis_filter_device_remove(struct hv_device *dev,
+ 	/* Halt and release the rndis device */
+ 	rndis_filter_halt_device(net_dev, rndis_dev);
+ 
+-	net_dev->extension = NULL;
+-
+ 	netvsc_device_remove(dev);
+ }
+ 
+diff --git a/drivers/net/macvlan.c b/drivers/net/macvlan.c
+index 747c0542a53c..c5bf61565726 100644
+--- a/drivers/net/macvlan.c
++++ b/drivers/net/macvlan.c
+@@ -259,7 +259,7 @@ static void macvlan_broadcast(struct sk_buff *skb,
+ 			      struct net_device *src,
+ 			      enum macvlan_mode mode)
+ {
+-	const struct ethhdr *eth = skb_eth_hdr(skb);
++	const struct ethhdr *eth = eth_hdr(skb);
+ 	const struct macvlan_dev *vlan;
+ 	struct sk_buff *nskb;
+ 	unsigned int i;
+@@ -513,10 +513,11 @@ static int macvlan_queue_xmit(struct sk_buff *skb, struct net_device *dev)
+ 	const struct macvlan_dev *dest;
+ 
+ 	if (vlan->mode == MACVLAN_MODE_BRIDGE) {
+-		const struct ethhdr *eth = (void *)skb->data;
++		const struct ethhdr *eth = skb_eth_hdr(skb);
+ 
+ 		/* send to other bridge ports directly */
+ 		if (is_multicast_ether_addr(eth->h_dest)) {
++			skb_reset_mac_header(skb);
+ 			macvlan_broadcast(skb, port, dev, MACVLAN_MODE_BRIDGE);
+ 			goto xmit_world;
+ 		}
+diff --git a/drivers/net/phy/dp83867.c b/drivers/net/phy/dp83867.c
+index cf4455bbf888..52e80434e45e 100644
+--- a/drivers/net/phy/dp83867.c
++++ b/drivers/net/phy/dp83867.c
+@@ -80,6 +80,7 @@
+ #define DP83867_PHYCR_FIFO_DEPTH_MAX		0x03
+ #define DP83867_PHYCR_FIFO_DEPTH_MASK		GENMASK(15, 14)
+ #define DP83867_PHYCR_RESERVED_MASK		BIT(11)
++#define DP83867_PHYCR_FORCE_LINK_GOOD		BIT(10)
+ 
+ /* RGMIIDCTL bits */
+ #define DP83867_RGMII_TX_CLK_DELAY_MAX		0xf
+@@ -454,7 +455,12 @@ static int dp83867_phy_reset(struct phy_device *phydev)
+ 
+ 	usleep_range(10, 20);
+ 
+-	return 0;
++	/* After reset FORCE_LINK_GOOD bit is set. Although the
++	 * default value should be unset. Disable FORCE_LINK_GOOD
++	 * for the phy to work properly.
++	 */
++	return phy_modify(phydev, MII_DP83867_PHYCTRL,
++			 DP83867_PHYCR_FORCE_LINK_GOOD, 0);
+ }
+ 
+ static struct phy_driver dp83867_driver[] = {
+diff --git a/drivers/net/usb/lan78xx.c b/drivers/net/usb/lan78xx.c
+index 3e5f2f7a155e..c232f1612083 100644
+--- a/drivers/net/usb/lan78xx.c
++++ b/drivers/net/usb/lan78xx.c
+@@ -3750,6 +3750,7 @@ static int lan78xx_probe(struct usb_interface *intf,
+ 
+ 	/* MTU range: 68 - 9000 */
+ 	netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;
++	netif_set_gso_max_size(netdev, MAX_SINGLE_PACKET_SIZE - MAX_HEADER);
+ 
+ 	dev->ep_blkin = (intf->cur_altsetting)->endpoint + 0;
+ 	dev->ep_blkout = (intf->cur_altsetting)->endpoint + 1;
+diff --git a/drivers/net/usb/r8152.c b/drivers/net/usb/r8152.c
+index b2507c59ba8b..9e4b7a400284 100644
+--- a/drivers/net/usb/r8152.c
++++ b/drivers/net/usb/r8152.c
+@@ -5587,6 +5587,9 @@ static int rtl8152_probe(struct usb_interface *intf,
+ 		return -ENODEV;
+ 	}
+ 
++	if (intf->cur_altsetting->desc.bNumEndpoints < 3)
++		return -ENODEV;
++
+ 	usb_reset_device(udev);
+ 	netdev = alloc_etherdev(sizeof(struct r8152));
+ 	if (!netdev) {
+diff --git a/drivers/net/wan/fsl_ucc_hdlc.c b/drivers/net/wan/fsl_ucc_hdlc.c
+index ca0f3be2b6bf..aef7de225783 100644
+--- a/drivers/net/wan/fsl_ucc_hdlc.c
++++ b/drivers/net/wan/fsl_ucc_hdlc.c
+@@ -73,7 +73,7 @@ static struct ucc_tdm_info utdm_primary_info = {
+ 	},
+ };
+ 
+-static struct ucc_tdm_info utdm_info[MAX_HDLC_NUM];
++static struct ucc_tdm_info utdm_info[UCC_MAX_NUM];
+ 
+ static int uhdlc_init(struct ucc_hdlc_private *priv)
+ {
+diff --git a/drivers/net/wireless/realtek/rtw88/phy.c b/drivers/net/wireless/realtek/rtw88/phy.c
+index d3d3f40de75e..47d199d2e7dc 100644
+--- a/drivers/net/wireless/realtek/rtw88/phy.c
++++ b/drivers/net/wireless/realtek/rtw88/phy.c
+@@ -118,7 +118,7 @@ static void rtw_phy_cck_pd_init(struct rtw_dev *rtwdev)
+ 
+ 	for (i = 0; i <= RTW_CHANNEL_WIDTH_40; i++) {
+ 		for (j = 0; j < RTW_RF_PATH_MAX; j++)
+-			dm_info->cck_pd_lv[i][j] = 0;
++			dm_info->cck_pd_lv[i][j] = CCK_PD_LV0;
+ 	}
+ 
+ 	dm_info->cck_fa_avg = CCK_FA_AVG_RESET;
+@@ -461,7 +461,6 @@ static void rtw_phy_dpk_track(struct rtw_dev *rtwdev)
+ 		chip->ops->dpk_track(rtwdev);
+ }
+ 
+-#define CCK_PD_LV_MAX		5
+ #define CCK_PD_FA_LV1_MIN	1000
+ #define CCK_PD_FA_LV0_MAX	500
+ 
+@@ -471,10 +470,10 @@ static u8 rtw_phy_cck_pd_lv_unlink(struct rtw_dev *rtwdev)
+ 	u32 cck_fa_avg = dm_info->cck_fa_avg;
+ 
+ 	if (cck_fa_avg > CCK_PD_FA_LV1_MIN)
+-		return 1;
++		return CCK_PD_LV1;
+ 
+ 	if (cck_fa_avg < CCK_PD_FA_LV0_MAX)
+-		return 0;
++		return CCK_PD_LV0;
+ 
+ 	return CCK_PD_LV_MAX;
+ }
+@@ -494,15 +493,15 @@ static u8 rtw_phy_cck_pd_lv_link(struct rtw_dev *rtwdev)
+ 	u32 cck_fa_avg = dm_info->cck_fa_avg;
+ 
+ 	if (igi > CCK_PD_IGI_LV4_VAL && rssi > CCK_PD_RSSI_LV4_VAL)
+-		return 4;
++		return CCK_PD_LV4;
+ 	if (igi > CCK_PD_IGI_LV3_VAL && rssi > CCK_PD_RSSI_LV3_VAL)
+-		return 3;
++		return CCK_PD_LV3;
+ 	if (igi > CCK_PD_IGI_LV2_VAL || rssi > CCK_PD_RSSI_LV2_VAL)
+-		return 2;
++		return CCK_PD_LV2;
+ 	if (cck_fa_avg > CCK_PD_FA_LV1_MIN)
+-		return 1;
++		return CCK_PD_LV1;
+ 	if (cck_fa_avg < CCK_PD_FA_LV0_MAX)
+-		return 0;
++		return CCK_PD_LV0;
+ 
+ 	return CCK_PD_LV_MAX;
+ }
+diff --git a/drivers/net/wireless/realtek/rtw88/phy.h b/drivers/net/wireless/realtek/rtw88/phy.h
+index e79b084628e7..33a5eb9637c0 100644
+--- a/drivers/net/wireless/realtek/rtw88/phy.h
++++ b/drivers/net/wireless/realtek/rtw88/phy.h
+@@ -125,6 +125,15 @@ rtw_get_tx_power_params(struct rtw_dev *rtwdev, u8 path,
+ 			u8 rate, u8 bw, u8 ch, u8 regd,
+ 			struct rtw_power_params *pwr_param);
+ 
++enum rtw_phy_cck_pd_lv {
++	CCK_PD_LV0,
++	CCK_PD_LV1,
++	CCK_PD_LV2,
++	CCK_PD_LV3,
++	CCK_PD_LV4,
++	CCK_PD_LV_MAX,
++};
++
+ #define	MASKBYTE0		0xff
+ #define	MASKBYTE1		0xff00
+ #define	MASKBYTE2		0xff0000
+diff --git a/drivers/net/wireless/realtek/rtw88/rtw8822c.c b/drivers/net/wireless/realtek/rtw88/rtw8822c.c
+index c2f6cd76a658..de0505a6a365 100644
+--- a/drivers/net/wireless/realtek/rtw88/rtw8822c.c
++++ b/drivers/net/wireless/realtek/rtw88/rtw8822c.c
+@@ -3168,8 +3168,8 @@ rtw8822c_phy_cck_pd_set_reg(struct rtw_dev *rtwdev,
+ static void rtw8822c_phy_cck_pd_set(struct rtw_dev *rtwdev, u8 new_lvl)
+ {
+ 	struct rtw_dm_info *dm_info = &rtwdev->dm_info;
+-	s8 pd_lvl[4] = {2, 4, 6, 8};
+-	s8 cs_lvl[4] = {2, 2, 2, 4};
++	s8 pd_lvl[CCK_PD_LV_MAX] = {0, 2, 4, 6, 8};
++	s8 cs_lvl[CCK_PD_LV_MAX] = {0, 2, 2, 2, 4};
+ 	u8 cur_lvl;
+ 	u8 nrx, bw;
+ 
+diff --git a/drivers/net/wireless/st/cw1200/fwio.c b/drivers/net/wireless/st/cw1200/fwio.c
+index 6574e78e05ea..2a03dc533b6a 100644
+--- a/drivers/net/wireless/st/cw1200/fwio.c
++++ b/drivers/net/wireless/st/cw1200/fwio.c
+@@ -320,12 +320,12 @@ int cw1200_load_firmware(struct cw1200_common *priv)
+ 		goto out;
+ 	}
+ 
+-	priv->hw_type = cw1200_get_hw_type(val32, &major_revision);
+-	if (priv->hw_type < 0) {
++	ret = cw1200_get_hw_type(val32, &major_revision);
++	if (ret < 0) {
+ 		pr_err("Can't deduce hardware type.\n");
+-		ret = -ENOTSUPP;
+ 		goto out;
+ 	}
++	priv->hw_type = ret;
+ 
+ 	/* Set DPLL Reg value, and read back to confirm writes work */
+ 	ret = cw1200_reg_write_32(priv, ST90TDS_TSET_GEN_R_W_REG_ID,
+diff --git a/drivers/nfc/pn533/usb.c b/drivers/nfc/pn533/usb.c
+index e897e4d768ef..d7a355d05368 100644
+--- a/drivers/nfc/pn533/usb.c
++++ b/drivers/nfc/pn533/usb.c
+@@ -391,7 +391,7 @@ static int pn533_acr122_poweron_rdr(struct pn533_usb_phy *phy)
+ 		       cmd, sizeof(cmd), false);
+ 
+ 	rc = usb_bulk_msg(phy->udev, phy->out_urb->pipe, buffer, sizeof(cmd),
+-			  &transferred, 0);
++			  &transferred, 5000);
+ 	kfree(buffer);
+ 	if (rc || (transferred != sizeof(cmd))) {
+ 		nfc_err(&phy->udev->dev,
+diff --git a/drivers/ptp/ptp_clock.c b/drivers/ptp/ptp_clock.c
+index 61fafe0374ce..b84f16bbd6f2 100644
+--- a/drivers/ptp/ptp_clock.c
++++ b/drivers/ptp/ptp_clock.c
+@@ -170,6 +170,7 @@ static void ptp_clock_release(struct device *dev)
+ {
+ 	struct ptp_clock *ptp = container_of(dev, struct ptp_clock, dev);
+ 
++	ptp_cleanup_pin_groups(ptp);
+ 	mutex_destroy(&ptp->tsevq_mux);
+ 	mutex_destroy(&ptp->pincfg_mux);
+ 	ida_simple_remove(&ptp_clocks_map, ptp->index);
+@@ -302,9 +303,8 @@ int ptp_clock_unregister(struct ptp_clock *ptp)
+ 	if (ptp->pps_source)
+ 		pps_unregister_source(ptp->pps_source);
+ 
+-	ptp_cleanup_pin_groups(ptp);
+-
+ 	posix_clock_unregister(&ptp->clock);
++
+ 	return 0;
+ }
+ EXPORT_SYMBOL(ptp_clock_unregister);
+diff --git a/drivers/reset/core.c b/drivers/reset/core.c
+index f343bd814d32..76c0dc7f165d 100644
+--- a/drivers/reset/core.c
++++ b/drivers/reset/core.c
+@@ -861,8 +861,7 @@ static int of_reset_control_get_count(struct device_node *node)
+  * @acquired: only one reset control may be acquired for a given controller
+  *            and ID
+  *
+- * Returns pointer to allocated reset_control_array on success or
+- * error on failure
++ * Returns pointer to allocated reset_control on success or error on failure
+  */
+ struct reset_control *
+ of_reset_control_array_get(struct device_node *np, bool shared, bool optional,
+@@ -915,8 +914,7 @@ EXPORT_SYMBOL_GPL(of_reset_control_array_get);
+  * that just have to be asserted or deasserted, without any
+  * requirements on the order.
+  *
+- * Returns pointer to allocated reset_control_array on success or
+- * error on failure
++ * Returns pointer to allocated reset_control on success or error on failure
+  */
+ struct reset_control *
+ devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
+diff --git a/drivers/s390/crypto/zcrypt_ccamisc.c b/drivers/s390/crypto/zcrypt_ccamisc.c
+index c1db64a2db21..110fe9d0cb91 100644
+--- a/drivers/s390/crypto/zcrypt_ccamisc.c
++++ b/drivers/s390/crypto/zcrypt_ccamisc.c
+@@ -1037,8 +1037,8 @@ static int _ip_cprb_helper(u16 cardnr, u16 domain,
+ 	prepparm = (struct iprepparm *) prepcblk->rpl_parmb;
+ 
+ 	/* do some plausibility checks on the key block */
+-	if (prepparm->kb.len < 120 + 5 * sizeof(uint16_t) ||
+-	    prepparm->kb.len > 136 + 5 * sizeof(uint16_t)) {
++	if (prepparm->kb.len < 120 + 3 * sizeof(uint16_t) ||
++	    prepparm->kb.len > 136 + 3 * sizeof(uint16_t)) {
+ 		DEBUG_ERR("%s reply with invalid or unknown key block\n",
+ 			  __func__);
+ 		rc = -EIO;
+diff --git a/drivers/scsi/bnx2i/bnx2i_iscsi.c b/drivers/scsi/bnx2i/bnx2i_iscsi.c
+index c5fa5f3b00e9..0b28d44d3573 100644
+--- a/drivers/scsi/bnx2i/bnx2i_iscsi.c
++++ b/drivers/scsi/bnx2i/bnx2i_iscsi.c
+@@ -915,12 +915,12 @@ void bnx2i_free_hba(struct bnx2i_hba *hba)
+ 	INIT_LIST_HEAD(&hba->ep_ofld_list);
+ 	INIT_LIST_HEAD(&hba->ep_active_list);
+ 	INIT_LIST_HEAD(&hba->ep_destroy_list);
+-	pci_dev_put(hba->pcidev);
+ 
+ 	if (hba->regview) {
+ 		pci_iounmap(hba->pcidev, hba->regview);
+ 		hba->regview = NULL;
+ 	}
++	pci_dev_put(hba->pcidev);
+ 	bnx2i_free_mp_bdt(hba);
+ 	bnx2i_release_free_cid_que(hba);
+ 	iscsi_host_free(shost);
+diff --git a/drivers/scsi/esas2r/esas2r_flash.c b/drivers/scsi/esas2r/esas2r_flash.c
+index 7bd376d95ed5..b02ac389e6c6 100644
+--- a/drivers/scsi/esas2r/esas2r_flash.c
++++ b/drivers/scsi/esas2r/esas2r_flash.c
+@@ -1197,6 +1197,7 @@ bool esas2r_nvram_read_direct(struct esas2r_adapter *a)
+ 	if (!esas2r_read_flash_block(a, a->nvram, FLS_OFFSET_NVR,
+ 				     sizeof(struct esas2r_sas_nvram))) {
+ 		esas2r_hdebug("NVRAM read failed, using defaults");
++		up(&a->nvram_semaphore);
+ 		return false;
+ 	}
+ 
+diff --git a/drivers/scsi/fnic/vnic_dev.c b/drivers/scsi/fnic/vnic_dev.c
+index 78af9cc2009b..522636e94628 100644
+--- a/drivers/scsi/fnic/vnic_dev.c
++++ b/drivers/scsi/fnic/vnic_dev.c
+@@ -688,26 +688,26 @@ int vnic_dev_soft_reset_done(struct vnic_dev *vdev, int *done)
+ 
+ int vnic_dev_hang_notify(struct vnic_dev *vdev)
+ {
+-	u64 a0, a1;
++	u64 a0 = 0, a1 = 0;
+ 	int wait = 1000;
+ 	return vnic_dev_cmd(vdev, CMD_HANG_NOTIFY, &a0, &a1, wait);
+ }
+ 
+ int vnic_dev_mac_addr(struct vnic_dev *vdev, u8 *mac_addr)
+ {
+-	u64 a0, a1;
++	u64 a[2] = {};
+ 	int wait = 1000;
+ 	int err, i;
+ 
+ 	for (i = 0; i < ETH_ALEN; i++)
+ 		mac_addr[i] = 0;
+ 
+-	err = vnic_dev_cmd(vdev, CMD_MAC_ADDR, &a0, &a1, wait);
++	err = vnic_dev_cmd(vdev, CMD_MAC_ADDR, &a[0], &a[1], wait);
+ 	if (err)
+ 		return err;
+ 
+ 	for (i = 0; i < ETH_ALEN; i++)
+-		mac_addr[i] = ((u8 *)&a0)[i];
++		mac_addr[i] = ((u8 *)&a)[i];
+ 
+ 	return 0;
+ }
+@@ -732,30 +732,30 @@ void vnic_dev_packet_filter(struct vnic_dev *vdev, int directed, int multicast,
+ 
+ void vnic_dev_add_addr(struct vnic_dev *vdev, u8 *addr)
+ {
+-	u64 a0 = 0, a1 = 0;
++	u64 a[2] = {};
+ 	int wait = 1000;
+ 	int err;
+ 	int i;
+ 
+ 	for (i = 0; i < ETH_ALEN; i++)
+-		((u8 *)&a0)[i] = addr[i];
++		((u8 *)&a)[i] = addr[i];
+ 
+-	err = vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a0, &a1, wait);
++	err = vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a[0], &a[1], wait);
+ 	if (err)
+ 		pr_err("Can't add addr [%pM], %d\n", addr, err);
+ }
+ 
+ void vnic_dev_del_addr(struct vnic_dev *vdev, u8 *addr)
+ {
+-	u64 a0 = 0, a1 = 0;
++	u64 a[2] = {};
+ 	int wait = 1000;
+ 	int err;
+ 	int i;
+ 
+ 	for (i = 0; i < ETH_ALEN; i++)
+-		((u8 *)&a0)[i] = addr[i];
++		((u8 *)&a)[i] = addr[i];
+ 
+-	err = vnic_dev_cmd(vdev, CMD_ADDR_DEL, &a0, &a1, wait);
++	err = vnic_dev_cmd(vdev, CMD_ADDR_DEL, &a[0], &a[1], wait);
+ 	if (err)
+ 		pr_err("Can't del addr [%pM], %d\n", addr, err);
+ }
+diff --git a/drivers/scsi/hisi_sas/hisi_sas_main.c b/drivers/scsi/hisi_sas/hisi_sas_main.c
+index 633effb09c9c..849335d76cf6 100644
+--- a/drivers/scsi/hisi_sas/hisi_sas_main.c
++++ b/drivers/scsi/hisi_sas/hisi_sas_main.c
+@@ -3719,9 +3719,6 @@ static int hisi_sas_debugfs_alloc(struct hisi_hba *hisi_hba)
+ 	int p, c, d;
+ 	size_t sz;
+ 
+-	hisi_hba->debugfs_dump_dentry =
+-			debugfs_create_dir("dump", hisi_hba->debugfs_dir);
+-
+ 	sz = hw->debugfs_reg_array[DEBUGFS_GLOBAL]->count * 4;
+ 	hisi_hba->debugfs_regs[DEBUGFS_GLOBAL] =
+ 				devm_kmalloc(dev, sz, GFP_KERNEL);
+diff --git a/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c b/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
+index ef32ee12f606..723f51c822af 100644
+--- a/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
++++ b/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
+@@ -3022,11 +3022,6 @@ static int debugfs_set_bist_v3_hw(struct hisi_hba *hisi_hba, bool enable)
+ 		hisi_sas_phy_write32(hisi_hba, phy_id,
+ 				     SAS_PHY_BIST_CTRL, reg_val);
+ 
+-		mdelay(100);
+-		reg_val |= (CFG_RX_BIST_EN_MSK | CFG_TX_BIST_EN_MSK);
+-		hisi_sas_phy_write32(hisi_hba, phy_id,
+-				     SAS_PHY_BIST_CTRL, reg_val);
+-
+ 		/* set the bist init value */
+ 		hisi_sas_phy_write32(hisi_hba, phy_id,
+ 				     SAS_PHY_BIST_CODE,
+@@ -3035,6 +3030,11 @@ static int debugfs_set_bist_v3_hw(struct hisi_hba *hisi_hba, bool enable)
+ 				     SAS_PHY_BIST_CODE1,
+ 				     SAS_PHY_BIST_CODE1_INIT);
+ 
++		mdelay(100);
++		reg_val |= (CFG_RX_BIST_EN_MSK | CFG_TX_BIST_EN_MSK);
++		hisi_sas_phy_write32(hisi_hba, phy_id,
++				     SAS_PHY_BIST_CTRL, reg_val);
++
+ 		/* clear error bit */
+ 		mdelay(100);
+ 		hisi_sas_phy_read32(hisi_hba, phy_id, SAS_BIST_ERR_CNT);
+@@ -3423,6 +3423,7 @@ static int hisi_sas_v3_resume(struct pci_dev *pdev)
+ 	if (rc) {
+ 		scsi_remove_host(shost);
+ 		pci_disable_device(pdev);
++		return rc;
+ 	}
+ 	hisi_hba->hw->phys_init(hisi_hba);
+ 	sas_resume_ha(sha);
+diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
+index aa82d538a18a..40706cb842fd 100644
+--- a/drivers/scsi/lpfc/lpfc_scsi.c
++++ b/drivers/scsi/lpfc/lpfc_scsi.c
+@@ -719,7 +719,7 @@ lpfc_get_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
+ 	iocb->ulpLe = 1;
+ 	iocb->ulpClass = CLASS3;
+ 
+-	if (lpfc_ndlp_check_qdepth(phba, ndlp)) {
++	if (lpfc_ndlp_check_qdepth(phba, ndlp) && lpfc_cmd) {
+ 		atomic_inc(&ndlp->cmd_pending);
+ 		lpfc_cmd->flags |= LPFC_SBUF_BUMP_QDEPTH;
+ 	}
+diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
+index 8860f41af3ff..e2cec1f6e659 100644
+--- a/drivers/scsi/lpfc/lpfc_sli.c
++++ b/drivers/scsi/lpfc/lpfc_sli.c
+@@ -20108,6 +20108,13 @@ void lpfc_release_io_buf(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_ncmd,
+ 	lpfc_ncmd->cur_iocbq.wqe_cmpl = NULL;
+ 	lpfc_ncmd->cur_iocbq.iocb_cmpl = NULL;
+ 
++	if (phba->cfg_xpsgl && !phba->nvmet_support &&
++	    !list_empty(&lpfc_ncmd->dma_sgl_xtra_list))
++		lpfc_put_sgl_per_hdwq(phba, lpfc_ncmd);
++
++	if (!list_empty(&lpfc_ncmd->dma_cmd_rsp_list))
++		lpfc_put_cmd_rsp_buf_per_hdwq(phba, lpfc_ncmd);
++
+ 	if (phba->cfg_xri_rebalancing) {
+ 		if (lpfc_ncmd->expedite) {
+ 			/* Return to expedite pool */
+@@ -20172,13 +20179,6 @@ void lpfc_release_io_buf(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_ncmd,
+ 		spin_unlock_irqrestore(&qp->io_buf_list_put_lock,
+ 				       iflag);
+ 	}
+-
+-	if (phba->cfg_xpsgl && !phba->nvmet_support &&
+-	    !list_empty(&lpfc_ncmd->dma_sgl_xtra_list))
+-		lpfc_put_sgl_per_hdwq(phba, lpfc_ncmd);
+-
+-	if (!list_empty(&lpfc_ncmd->dma_cmd_rsp_list))
+-		lpfc_put_cmd_rsp_buf_per_hdwq(phba, lpfc_ncmd);
+ }
+ 
+ /**
+@@ -20414,8 +20414,9 @@ lpfc_get_sgl_per_hdwq(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_buf)
+ 	struct sli4_hybrid_sgl *allocated_sgl = NULL;
+ 	struct lpfc_sli4_hdw_queue *hdwq = lpfc_buf->hdwq;
+ 	struct list_head *buf_list = &hdwq->sgl_list;
++	unsigned long iflags;
+ 
+-	spin_lock_irq(&hdwq->hdwq_lock);
++	spin_lock_irqsave(&hdwq->hdwq_lock, iflags);
+ 
+ 	if (likely(!list_empty(buf_list))) {
+ 		/* break off 1 chunk from the sgl_list */
+@@ -20427,9 +20428,9 @@ lpfc_get_sgl_per_hdwq(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_buf)
+ 		}
+ 	} else {
+ 		/* allocate more */
+-		spin_unlock_irq(&hdwq->hdwq_lock);
++		spin_unlock_irqrestore(&hdwq->hdwq_lock, iflags);
+ 		tmp = kmalloc_node(sizeof(*tmp), GFP_ATOMIC,
+-				   cpu_to_node(smp_processor_id()));
++				   cpu_to_node(hdwq->io_wq->chann));
+ 		if (!tmp) {
+ 			lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
+ 					"8353 error kmalloc memory for HDWQ "
+@@ -20449,7 +20450,7 @@ lpfc_get_sgl_per_hdwq(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_buf)
+ 			return NULL;
+ 		}
+ 
+-		spin_lock_irq(&hdwq->hdwq_lock);
++		spin_lock_irqsave(&hdwq->hdwq_lock, iflags);
+ 		list_add_tail(&tmp->list_node, &lpfc_buf->dma_sgl_xtra_list);
+ 	}
+ 
+@@ -20457,7 +20458,7 @@ lpfc_get_sgl_per_hdwq(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_buf)
+ 					struct sli4_hybrid_sgl,
+ 					list_node);
+ 
+-	spin_unlock_irq(&hdwq->hdwq_lock);
++	spin_unlock_irqrestore(&hdwq->hdwq_lock, iflags);
+ 
+ 	return allocated_sgl;
+ }
+@@ -20481,8 +20482,9 @@ lpfc_put_sgl_per_hdwq(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_buf)
+ 	struct sli4_hybrid_sgl *tmp = NULL;
+ 	struct lpfc_sli4_hdw_queue *hdwq = lpfc_buf->hdwq;
+ 	struct list_head *buf_list = &hdwq->sgl_list;
++	unsigned long iflags;
+ 
+-	spin_lock_irq(&hdwq->hdwq_lock);
++	spin_lock_irqsave(&hdwq->hdwq_lock, iflags);
+ 
+ 	if (likely(!list_empty(&lpfc_buf->dma_sgl_xtra_list))) {
+ 		list_for_each_entry_safe(list_entry, tmp,
+@@ -20495,7 +20497,7 @@ lpfc_put_sgl_per_hdwq(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_buf)
+ 		rc = -EINVAL;
+ 	}
+ 
+-	spin_unlock_irq(&hdwq->hdwq_lock);
++	spin_unlock_irqrestore(&hdwq->hdwq_lock, iflags);
+ 	return rc;
+ }
+ 
+@@ -20516,8 +20518,9 @@ lpfc_free_sgl_per_hdwq(struct lpfc_hba *phba,
+ 	struct list_head *buf_list = &hdwq->sgl_list;
+ 	struct sli4_hybrid_sgl *list_entry = NULL;
+ 	struct sli4_hybrid_sgl *tmp = NULL;
++	unsigned long iflags;
+ 
+-	spin_lock_irq(&hdwq->hdwq_lock);
++	spin_lock_irqsave(&hdwq->hdwq_lock, iflags);
+ 
+ 	/* Free sgl pool */
+ 	list_for_each_entry_safe(list_entry, tmp,
+@@ -20529,7 +20532,7 @@ lpfc_free_sgl_per_hdwq(struct lpfc_hba *phba,
+ 		kfree(list_entry);
+ 	}
+ 
+-	spin_unlock_irq(&hdwq->hdwq_lock);
++	spin_unlock_irqrestore(&hdwq->hdwq_lock, iflags);
+ }
+ 
+ /**
+@@ -20553,8 +20556,9 @@ lpfc_get_cmd_rsp_buf_per_hdwq(struct lpfc_hba *phba,
+ 	struct fcp_cmd_rsp_buf *allocated_buf = NULL;
+ 	struct lpfc_sli4_hdw_queue *hdwq = lpfc_buf->hdwq;
+ 	struct list_head *buf_list = &hdwq->cmd_rsp_buf_list;
++	unsigned long iflags;
+ 
+-	spin_lock_irq(&hdwq->hdwq_lock);
++	spin_lock_irqsave(&hdwq->hdwq_lock, iflags);
+ 
+ 	if (likely(!list_empty(buf_list))) {
+ 		/* break off 1 chunk from the list */
+@@ -20567,9 +20571,9 @@ lpfc_get_cmd_rsp_buf_per_hdwq(struct lpfc_hba *phba,
+ 		}
+ 	} else {
+ 		/* allocate more */
+-		spin_unlock_irq(&hdwq->hdwq_lock);
++		spin_unlock_irqrestore(&hdwq->hdwq_lock, iflags);
+ 		tmp = kmalloc_node(sizeof(*tmp), GFP_ATOMIC,
+-				   cpu_to_node(smp_processor_id()));
++				   cpu_to_node(hdwq->io_wq->chann));
+ 		if (!tmp) {
+ 			lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
+ 					"8355 error kmalloc memory for HDWQ "
+@@ -20594,7 +20598,7 @@ lpfc_get_cmd_rsp_buf_per_hdwq(struct lpfc_hba *phba,
+ 		tmp->fcp_rsp = (struct fcp_rsp *)((uint8_t *)tmp->fcp_cmnd +
+ 				sizeof(struct fcp_cmnd));
+ 
+-		spin_lock_irq(&hdwq->hdwq_lock);
++		spin_lock_irqsave(&hdwq->hdwq_lock, iflags);
+ 		list_add_tail(&tmp->list_node, &lpfc_buf->dma_cmd_rsp_list);
+ 	}
+ 
+@@ -20602,7 +20606,7 @@ lpfc_get_cmd_rsp_buf_per_hdwq(struct lpfc_hba *phba,
+ 					struct fcp_cmd_rsp_buf,
+ 					list_node);
+ 
+-	spin_unlock_irq(&hdwq->hdwq_lock);
++	spin_unlock_irqrestore(&hdwq->hdwq_lock, iflags);
+ 
+ 	return allocated_buf;
+ }
+@@ -20627,8 +20631,9 @@ lpfc_put_cmd_rsp_buf_per_hdwq(struct lpfc_hba *phba,
+ 	struct fcp_cmd_rsp_buf *tmp = NULL;
+ 	struct lpfc_sli4_hdw_queue *hdwq = lpfc_buf->hdwq;
+ 	struct list_head *buf_list = &hdwq->cmd_rsp_buf_list;
++	unsigned long iflags;
+ 
+-	spin_lock_irq(&hdwq->hdwq_lock);
++	spin_lock_irqsave(&hdwq->hdwq_lock, iflags);
+ 
+ 	if (likely(!list_empty(&lpfc_buf->dma_cmd_rsp_list))) {
+ 		list_for_each_entry_safe(list_entry, tmp,
+@@ -20641,7 +20646,7 @@ lpfc_put_cmd_rsp_buf_per_hdwq(struct lpfc_hba *phba,
+ 		rc = -EINVAL;
+ 	}
+ 
+-	spin_unlock_irq(&hdwq->hdwq_lock);
++	spin_unlock_irqrestore(&hdwq->hdwq_lock, iflags);
+ 	return rc;
+ }
+ 
+@@ -20662,8 +20667,9 @@ lpfc_free_cmd_rsp_buf_per_hdwq(struct lpfc_hba *phba,
+ 	struct list_head *buf_list = &hdwq->cmd_rsp_buf_list;
+ 	struct fcp_cmd_rsp_buf *list_entry = NULL;
+ 	struct fcp_cmd_rsp_buf *tmp = NULL;
++	unsigned long iflags;
+ 
+-	spin_lock_irq(&hdwq->hdwq_lock);
++	spin_lock_irqsave(&hdwq->hdwq_lock, iflags);
+ 
+ 	/* Free cmd_rsp buf pool */
+ 	list_for_each_entry_safe(list_entry, tmp,
+@@ -20676,5 +20682,5 @@ lpfc_free_cmd_rsp_buf_per_hdwq(struct lpfc_hba *phba,
+ 		kfree(list_entry);
+ 	}
+ 
+-	spin_unlock_irq(&hdwq->hdwq_lock);
++	spin_unlock_irqrestore(&hdwq->hdwq_lock, iflags);
+ }
+diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
+index 80f276d67c14..9ffaa920fc8f 100644
+--- a/drivers/scsi/qla2xxx/qla_init.c
++++ b/drivers/scsi/qla2xxx/qla_init.c
+@@ -5891,8 +5891,7 @@ qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha)
+ 		if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
+ 			break;
+ 
+-		if ((fcport->flags & FCF_FABRIC_DEVICE) == 0 ||
+-		    (fcport->flags & FCF_LOGIN_NEEDED) == 0)
++		if ((fcport->flags & FCF_FABRIC_DEVICE) == 0)
+ 			continue;
+ 
+ 		if (fcport->scan_state == QLA_FCPORT_SCAN) {
+@@ -5915,7 +5914,8 @@ qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha)
+ 			}
+ 		}
+ 
+-		if (fcport->scan_state == QLA_FCPORT_FOUND)
++		if (fcport->scan_state == QLA_FCPORT_FOUND &&
++		    (fcport->flags & FCF_LOGIN_NEEDED) != 0)
+ 			qla24xx_fcport_handle_login(vha, fcport);
+ 	}
+ 	return (rval);
+diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
+index b3766b1879e3..7c5f2736ebee 100644
+--- a/drivers/scsi/qla2xxx/qla_isr.c
++++ b/drivers/scsi/qla2xxx/qla_isr.c
+@@ -3625,7 +3625,7 @@ qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
+ skip_msix:
+ 
+ 	ql_log(ql_log_info, vha, 0x0037,
+-	    "Falling back-to MSI mode -%d.\n", ret);
++	    "Falling back-to MSI mode -- ret=%d.\n", ret);
+ 
+ 	if (!IS_QLA24XX(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
+ 	    !IS_QLA8001(ha) && !IS_P3P_TYPE(ha) && !IS_QLAFX00(ha) &&
+@@ -3633,13 +3633,13 @@ skip_msix:
+ 		goto skip_msi;
+ 
+ 	ret = pci_alloc_irq_vectors(ha->pdev, 1, 1, PCI_IRQ_MSI);
+-	if (!ret) {
++	if (ret > 0) {
+ 		ql_dbg(ql_dbg_init, vha, 0x0038,
+ 		    "MSI: Enabled.\n");
+ 		ha->flags.msi_enabled = 1;
+ 	} else
+ 		ql_log(ql_log_warn, vha, 0x0039,
+-		    "Falling back-to INTa mode -- %d.\n", ret);
++		    "Falling back-to INTa mode -- ret=%d.\n", ret);
+ skip_msi:
+ 
+ 	/* Skip INTx on ISP82xx. */
+diff --git a/drivers/scsi/qla4xxx/ql4_mbx.c b/drivers/scsi/qla4xxx/ql4_mbx.c
+index dac9a7013208..02636b4785c5 100644
+--- a/drivers/scsi/qla4xxx/ql4_mbx.c
++++ b/drivers/scsi/qla4xxx/ql4_mbx.c
+@@ -640,9 +640,6 @@ int qla4xxx_initialize_fw_cb(struct scsi_qla_host * ha)
+ 
+ 	if (qla4xxx_get_ifcb(ha, &mbox_cmd[0], &mbox_sts[0], init_fw_cb_dma) !=
+ 	    QLA_SUCCESS) {
+-		dma_free_coherent(&ha->pdev->dev,
+-				  sizeof(struct addr_ctrl_blk),
+-				  init_fw_cb, init_fw_cb_dma);
+ 		goto exit_init_fw_cb;
+ 	}
+ 
+diff --git a/drivers/scsi/scsi_trace.c b/drivers/scsi/scsi_trace.c
+index 07a2425ffa2c..ac35c301c792 100644
+--- a/drivers/scsi/scsi_trace.c
++++ b/drivers/scsi/scsi_trace.c
+@@ -9,7 +9,7 @@
+ #include <trace/events/scsi.h>
+ 
+ #define SERVICE_ACTION16(cdb) (cdb[1] & 0x1f)
+-#define SERVICE_ACTION32(cdb) ((cdb[8] << 8) | cdb[9])
++#define SERVICE_ACTION32(cdb) (get_unaligned_be16(&cdb[8]))
+ 
+ static const char *
+ scsi_trace_misc(struct trace_seq *, unsigned char *, int);
+@@ -39,17 +39,12 @@ static const char *
+ scsi_trace_rw10(struct trace_seq *p, unsigned char *cdb, int len)
+ {
+ 	const char *ret = trace_seq_buffer_ptr(p);
+-	sector_t lba = 0, txlen = 0;
++	u32 lba, txlen;
+ 
+-	lba |= (cdb[2] << 24);
+-	lba |= (cdb[3] << 16);
+-	lba |= (cdb[4] << 8);
+-	lba |=  cdb[5];
+-	txlen |= (cdb[7] << 8);
+-	txlen |=  cdb[8];
++	lba = get_unaligned_be32(&cdb[2]);
++	txlen = get_unaligned_be16(&cdb[7]);
+ 
+-	trace_seq_printf(p, "lba=%llu txlen=%llu protect=%u",
+-			 (unsigned long long)lba, (unsigned long long)txlen,
++	trace_seq_printf(p, "lba=%u txlen=%u protect=%u", lba, txlen,
+ 			 cdb[1] >> 5);
+ 
+ 	if (cdb[0] == WRITE_SAME)
+@@ -64,19 +59,12 @@ static const char *
+ scsi_trace_rw12(struct trace_seq *p, unsigned char *cdb, int len)
+ {
+ 	const char *ret = trace_seq_buffer_ptr(p);
+-	sector_t lba = 0, txlen = 0;
+-
+-	lba |= (cdb[2] << 24);
+-	lba |= (cdb[3] << 16);
+-	lba |= (cdb[4] << 8);
+-	lba |=  cdb[5];
+-	txlen |= (cdb[6] << 24);
+-	txlen |= (cdb[7] << 16);
+-	txlen |= (cdb[8] << 8);
+-	txlen |=  cdb[9];
+-
+-	trace_seq_printf(p, "lba=%llu txlen=%llu protect=%u",
+-			 (unsigned long long)lba, (unsigned long long)txlen,
++	u32 lba, txlen;
++
++	lba = get_unaligned_be32(&cdb[2]);
++	txlen = get_unaligned_be32(&cdb[6]);
++
++	trace_seq_printf(p, "lba=%u txlen=%u protect=%u", lba, txlen,
+ 			 cdb[1] >> 5);
+ 	trace_seq_putc(p, 0);
+ 
+@@ -87,23 +75,13 @@ static const char *
+ scsi_trace_rw16(struct trace_seq *p, unsigned char *cdb, int len)
+ {
+ 	const char *ret = trace_seq_buffer_ptr(p);
+-	sector_t lba = 0, txlen = 0;
+-
+-	lba |= ((u64)cdb[2] << 56);
+-	lba |= ((u64)cdb[3] << 48);
+-	lba |= ((u64)cdb[4] << 40);
+-	lba |= ((u64)cdb[5] << 32);
+-	lba |= (cdb[6] << 24);
+-	lba |= (cdb[7] << 16);
+-	lba |= (cdb[8] << 8);
+-	lba |=  cdb[9];
+-	txlen |= (cdb[10] << 24);
+-	txlen |= (cdb[11] << 16);
+-	txlen |= (cdb[12] << 8);
+-	txlen |=  cdb[13];
+-
+-	trace_seq_printf(p, "lba=%llu txlen=%llu protect=%u",
+-			 (unsigned long long)lba, (unsigned long long)txlen,
++	u64 lba;
++	u32 txlen;
++
++	lba = get_unaligned_be64(&cdb[2]);
++	txlen = get_unaligned_be32(&cdb[10]);
++
++	trace_seq_printf(p, "lba=%llu txlen=%u protect=%u", lba, txlen,
+ 			 cdb[1] >> 5);
+ 
+ 	if (cdb[0] == WRITE_SAME_16)
+@@ -118,8 +96,8 @@ static const char *
+ scsi_trace_rw32(struct trace_seq *p, unsigned char *cdb, int len)
+ {
+ 	const char *ret = trace_seq_buffer_ptr(p), *cmd;
+-	sector_t lba = 0, txlen = 0;
+-	u32 ei_lbrt = 0;
++	u64 lba;
++	u32 ei_lbrt, txlen;
+ 
+ 	switch (SERVICE_ACTION32(cdb)) {
+ 	case READ_32:
+@@ -139,26 +117,12 @@ scsi_trace_rw32(struct trace_seq *p, unsigned char *cdb, int len)
+ 		goto out;
+ 	}
+ 
+-	lba |= ((u64)cdb[12] << 56);
+-	lba |= ((u64)cdb[13] << 48);
+-	lba |= ((u64)cdb[14] << 40);
+-	lba |= ((u64)cdb[15] << 32);
+-	lba |= (cdb[16] << 24);
+-	lba |= (cdb[17] << 16);
+-	lba |= (cdb[18] << 8);
+-	lba |=  cdb[19];
+-	ei_lbrt |= (cdb[20] << 24);
+-	ei_lbrt |= (cdb[21] << 16);
+-	ei_lbrt |= (cdb[22] << 8);
+-	ei_lbrt |=  cdb[23];
+-	txlen |= (cdb[28] << 24);
+-	txlen |= (cdb[29] << 16);
+-	txlen |= (cdb[30] << 8);
+-	txlen |=  cdb[31];
+-
+-	trace_seq_printf(p, "%s_32 lba=%llu txlen=%llu protect=%u ei_lbrt=%u",
+-			 cmd, (unsigned long long)lba,
+-			 (unsigned long long)txlen, cdb[10] >> 5, ei_lbrt);
++	lba = get_unaligned_be64(&cdb[12]);
++	ei_lbrt = get_unaligned_be32(&cdb[20]);
++	txlen = get_unaligned_be32(&cdb[28]);
++
++	trace_seq_printf(p, "%s_32 lba=%llu txlen=%u protect=%u ei_lbrt=%u",
++			 cmd, lba, txlen, cdb[10] >> 5, ei_lbrt);
+ 
+ 	if (SERVICE_ACTION32(cdb) == WRITE_SAME_32)
+ 		trace_seq_printf(p, " unmap=%u", cdb[10] >> 3 & 1);
+@@ -173,7 +137,7 @@ static const char *
+ scsi_trace_unmap(struct trace_seq *p, unsigned char *cdb, int len)
+ {
+ 	const char *ret = trace_seq_buffer_ptr(p);
+-	unsigned int regions = cdb[7] << 8 | cdb[8];
++	unsigned int regions = get_unaligned_be16(&cdb[7]);
+ 
+ 	trace_seq_printf(p, "regions=%u", (regions - 8) / 16);
+ 	trace_seq_putc(p, 0);
+@@ -185,8 +149,8 @@ static const char *
+ scsi_trace_service_action_in(struct trace_seq *p, unsigned char *cdb, int len)
+ {
+ 	const char *ret = trace_seq_buffer_ptr(p), *cmd;
+-	sector_t lba = 0;
+-	u32 alloc_len = 0;
++	u64 lba;
++	u32 alloc_len;
+ 
+ 	switch (SERVICE_ACTION16(cdb)) {
+ 	case SAI_READ_CAPACITY_16:
+@@ -200,21 +164,10 @@ scsi_trace_service_action_in(struct trace_seq *p, unsigned char *cdb, int len)
+ 		goto out;
+ 	}
+ 
+-	lba |= ((u64)cdb[2] << 56);
+-	lba |= ((u64)cdb[3] << 48);
+-	lba |= ((u64)cdb[4] << 40);
+-	lba |= ((u64)cdb[5] << 32);
+-	lba |= (cdb[6] << 24);
+-	lba |= (cdb[7] << 16);
+-	lba |= (cdb[8] << 8);
+-	lba |=  cdb[9];
+-	alloc_len |= (cdb[10] << 24);
+-	alloc_len |= (cdb[11] << 16);
+-	alloc_len |= (cdb[12] << 8);
+-	alloc_len |=  cdb[13];
+-
+-	trace_seq_printf(p, "%s lba=%llu alloc_len=%u", cmd,
+-			 (unsigned long long)lba, alloc_len);
++	lba = get_unaligned_be64(&cdb[2]);
++	alloc_len = get_unaligned_be32(&cdb[10]);
++
++	trace_seq_printf(p, "%s lba=%llu alloc_len=%u", cmd, lba, alloc_len);
+ 
+ out:
+ 	trace_seq_putc(p, 0);
+diff --git a/drivers/scsi/scsi_transport_sas.c b/drivers/scsi/scsi_transport_sas.c
+index ef138c57e2a6..182fd25c7c43 100644
+--- a/drivers/scsi/scsi_transport_sas.c
++++ b/drivers/scsi/scsi_transport_sas.c
+@@ -1391,9 +1391,6 @@ static void sas_expander_release(struct device *dev)
+ 	struct sas_rphy *rphy = dev_to_rphy(dev);
+ 	struct sas_expander_device *edev = rphy_to_expander_device(rphy);
+ 
+-	if (rphy->q)
+-		blk_cleanup_queue(rphy->q);
+-
+ 	put_device(dev->parent);
+ 	kfree(edev);
+ }
+@@ -1403,9 +1400,6 @@ static void sas_end_device_release(struct device *dev)
+ 	struct sas_rphy *rphy = dev_to_rphy(dev);
+ 	struct sas_end_device *edev = rphy_to_end_device(rphy);
+ 
+-	if (rphy->q)
+-		blk_cleanup_queue(rphy->q);
+-
+ 	put_device(dev->parent);
+ 	kfree(edev);
+ }
+@@ -1634,8 +1628,7 @@ sas_rphy_remove(struct sas_rphy *rphy)
+ 	}
+ 
+ 	sas_rphy_unlink(rphy);
+-	if (rphy->q)
+-		bsg_unregister_queue(rphy->q);
++	bsg_remove_queue(rphy->q);
+ 	transport_remove_device(dev);
+ 	device_del(dev);
+ }
+diff --git a/drivers/scsi/storvsc_drv.c b/drivers/scsi/storvsc_drv.c
+index 542d2bac2922..5087ed6afbdc 100644
+--- a/drivers/scsi/storvsc_drv.c
++++ b/drivers/scsi/storvsc_drv.c
+@@ -1835,9 +1835,11 @@ static int storvsc_probe(struct hv_device *device,
+ 	 */
+ 	host->sg_tablesize = (stor_device->max_transfer_bytes >> PAGE_SHIFT);
+ 	/*
++	 * For non-IDE disks, the host supports multiple channels.
+ 	 * Set the number of HW queues we are supporting.
+ 	 */
+-	host->nr_hw_queues = num_present_cpus();
++	if (!dev_is_ide)
++		host->nr_hw_queues = num_present_cpus();
+ 
+ 	/*
+ 	 * Set the error handler work queue.
+diff --git a/drivers/soc/amlogic/meson-ee-pwrc.c b/drivers/soc/amlogic/meson-ee-pwrc.c
+index 5823f5b67d16..3f0261d53ad9 100644
+--- a/drivers/soc/amlogic/meson-ee-pwrc.c
++++ b/drivers/soc/amlogic/meson-ee-pwrc.c
+@@ -323,6 +323,8 @@ static int meson_ee_pwrc_init_domain(struct platform_device *pdev,
+ 				     struct meson_ee_pwrc *pwrc,
+ 				     struct meson_ee_pwrc_domain *dom)
+ {
++	int ret;
++
+ 	dom->pwrc = pwrc;
+ 	dom->num_rstc = dom->desc.reset_names_count;
+ 	dom->num_clks = dom->desc.clk_names_count;
+@@ -368,15 +370,21 @@ static int meson_ee_pwrc_init_domain(struct platform_device *pdev,
+          * prepare/enable counters won't be in sync.
+          */
+ 	if (dom->num_clks && dom->desc.get_power && !dom->desc.get_power(dom)) {
+-		int ret = clk_bulk_prepare_enable(dom->num_clks, dom->clks);
++		ret = clk_bulk_prepare_enable(dom->num_clks, dom->clks);
+ 		if (ret)
+ 			return ret;
+ 
+-		pm_genpd_init(&dom->base, &pm_domain_always_on_gov, false);
+-	} else
+-		pm_genpd_init(&dom->base, NULL,
+-			      (dom->desc.get_power ?
+-			       dom->desc.get_power(dom) : true));
++		ret = pm_genpd_init(&dom->base, &pm_domain_always_on_gov,
++				    false);
++		if (ret)
++			return ret;
++	} else {
++		ret = pm_genpd_init(&dom->base, NULL,
++				    (dom->desc.get_power ?
++				     dom->desc.get_power(dom) : true));
++		if (ret)
++			return ret;
++	}
+ 
+ 	return 0;
+ }
+@@ -441,9 +449,7 @@ static int meson_ee_pwrc_probe(struct platform_device *pdev)
+ 		pwrc->xlate.domains[i] = &dom->base;
+ 	}
+ 
+-	of_genpd_add_provider_onecell(pdev->dev.of_node, &pwrc->xlate);
+-
+-	return 0;
++	return of_genpd_add_provider_onecell(pdev->dev.of_node, &pwrc->xlate);
+ }
+ 
+ static void meson_ee_pwrc_shutdown(struct platform_device *pdev)
+diff --git a/drivers/staging/comedi/drivers/ni_routes.c b/drivers/staging/comedi/drivers/ni_routes.c
+index eb61494dc2bd..88beb0d6c42b 100644
+--- a/drivers/staging/comedi/drivers/ni_routes.c
++++ b/drivers/staging/comedi/drivers/ni_routes.c
+@@ -74,9 +74,6 @@ static int ni_find_device_routes(const char *device_family,
+ 		}
+ 	}
+ 
+-	if (!rv)
+-		return -ENODATA;
+-
+ 	/* Second, find the set of routes valid for this device. */
+ 	for (i = 0; ni_device_routes_list[i]; ++i) {
+ 		if (memcmp(ni_device_routes_list[i]->device, board_name,
+@@ -86,12 +83,12 @@ static int ni_find_device_routes(const char *device_family,
+ 		}
+ 	}
+ 
+-	if (!dr)
+-		return -ENODATA;
+-
+ 	tables->route_values = rv;
+ 	tables->valid_routes = dr;
+ 
++	if (!rv || !dr)
++		return -ENODATA;
++
+ 	return 0;
+ }
+ 
+@@ -489,6 +486,9 @@ int ni_find_route_source(const u8 src_sel_reg_value, int dest,
+ {
+ 	int src;
+ 
++	if (!tables->route_values)
++		return -EINVAL;
++
+ 	dest = B(dest); /* subtract NI names offset */
+ 	/* ensure we are not going to under/over run the route value table */
+ 	if (dest < 0 || dest >= NI_NUM_NAMES)
+diff --git a/drivers/target/target_core_fabric_lib.c b/drivers/target/target_core_fabric_lib.c
+index 3c79411c4cd0..6b4b354c88aa 100644
+--- a/drivers/target/target_core_fabric_lib.c
++++ b/drivers/target/target_core_fabric_lib.c
+@@ -118,7 +118,7 @@ static int srp_get_pr_transport_id(
+ 	memset(buf + 8, 0, leading_zero_bytes);
+ 	rc = hex2bin(buf + 8 + leading_zero_bytes, p, count);
+ 	if (rc < 0) {
+-		pr_debug("hex2bin failed for %s: %d\n", __func__, rc);
++		pr_debug("hex2bin failed for %s: %d\n", p, rc);
+ 		return rc;
+ 	}
+ 
+diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
+index 8b23162e4239..4ac74b354801 100644
+--- a/drivers/usb/core/hub.c
++++ b/drivers/usb/core/hub.c
+@@ -1191,6 +1191,7 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
+ 			 * PORT_OVER_CURRENT is not. So check for any of them.
+ 			 */
+ 			if (udev || (portstatus & USB_PORT_STAT_CONNECTION) ||
++			    (portchange & USB_PORT_STAT_C_CONNECTION) ||
+ 			    (portstatus & USB_PORT_STAT_OVERCURRENT) ||
+ 			    (portchange & USB_PORT_STAT_C_OVERCURRENT))
+ 				set_bit(port1, hub->change_bits);
+diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c
+index 3bb1fff02bed..955ab97b9b22 100644
+--- a/drivers/usb/serial/ch341.c
++++ b/drivers/usb/serial/ch341.c
+@@ -589,9 +589,13 @@ static int ch341_tiocmget(struct tty_struct *tty)
+ static int ch341_reset_resume(struct usb_serial *serial)
+ {
+ 	struct usb_serial_port *port = serial->port[0];
+-	struct ch341_private *priv = usb_get_serial_port_data(port);
++	struct ch341_private *priv;
+ 	int ret;
+ 
++	priv = usb_get_serial_port_data(port);
++	if (!priv)
++		return 0;
++
+ 	/* reconfigure ch341 serial port after bus-reset */
+ 	ch341_configure(serial->dev, priv);
+ 
+diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c
+index 9690a5f4b9d6..5737add6a2a4 100644
+--- a/drivers/usb/serial/io_edgeport.c
++++ b/drivers/usb/serial/io_edgeport.c
+@@ -716,7 +716,7 @@ static void edge_interrupt_callback(struct urb *urb)
+ 			if (txCredits) {
+ 				port = edge_serial->serial->port[portNumber];
+ 				edge_port = usb_get_serial_port_data(port);
+-				if (edge_port->open) {
++				if (edge_port && edge_port->open) {
+ 					spin_lock_irqsave(&edge_port->ep_lock,
+ 							  flags);
+ 					edge_port->txCredits += txCredits;
+@@ -1725,7 +1725,8 @@ static void edge_break(struct tty_struct *tty, int break_state)
+ static void process_rcvd_data(struct edgeport_serial *edge_serial,
+ 				unsigned char *buffer, __u16 bufferLength)
+ {
+-	struct device *dev = &edge_serial->serial->dev->dev;
++	struct usb_serial *serial = edge_serial->serial;
++	struct device *dev = &serial->dev->dev;
+ 	struct usb_serial_port *port;
+ 	struct edgeport_port *edge_port;
+ 	__u16 lastBufferLength;
+@@ -1821,11 +1822,10 @@ static void process_rcvd_data(struct edgeport_serial *edge_serial,
+ 
+ 			/* spit this data back into the tty driver if this
+ 			   port is open */
+-			if (rxLen) {
+-				port = edge_serial->serial->port[
+-							edge_serial->rxPort];
++			if (rxLen && edge_serial->rxPort < serial->num_ports) {
++				port = serial->port[edge_serial->rxPort];
+ 				edge_port = usb_get_serial_port_data(port);
+-				if (edge_port->open) {
++				if (edge_port && edge_port->open) {
+ 					dev_dbg(dev, "%s - Sending %d bytes to TTY for port %d\n",
+ 						__func__, rxLen,
+ 						edge_serial->rxPort);
+@@ -1833,8 +1833,8 @@ static void process_rcvd_data(struct edgeport_serial *edge_serial,
+ 							rxLen);
+ 					edge_port->port->icount.rx += rxLen;
+ 				}
+-				buffer += rxLen;
+ 			}
++			buffer += rxLen;
+ 			break;
+ 
+ 		case EXPECT_HDR3:	/* Expect 3rd byte of status header */
+@@ -1869,6 +1869,8 @@ static void process_rcvd_status(struct edgeport_serial *edge_serial,
+ 	__u8 code = edge_serial->rxStatusCode;
+ 
+ 	/* switch the port pointer to the one being currently talked about */
++	if (edge_serial->rxPort >= edge_serial->serial->num_ports)
++		return;
+ 	port = edge_serial->serial->port[edge_serial->rxPort];
+ 	edge_port = usb_get_serial_port_data(port);
+ 	if (edge_port == NULL) {
+diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
+index e66a59ef43a1..aa3dbce22cfb 100644
+--- a/drivers/usb/serial/keyspan.c
++++ b/drivers/usb/serial/keyspan.c
+@@ -1058,6 +1058,8 @@ static void	usa49_glocont_callback(struct urb *urb)
+ 	for (i = 0; i < serial->num_ports; ++i) {
+ 		port = serial->port[i];
+ 		p_priv = usb_get_serial_port_data(port);
++		if (!p_priv)
++			continue;
+ 
+ 		if (p_priv->resend_cont) {
+ 			dev_dbg(&port->dev, "%s - sending setup\n", __func__);
+@@ -1459,6 +1461,8 @@ static void usa67_glocont_callback(struct urb *urb)
+ 	for (i = 0; i < serial->num_ports; ++i) {
+ 		port = serial->port[i];
+ 		p_priv = usb_get_serial_port_data(port);
++		if (!p_priv)
++			continue;
+ 
+ 		if (p_priv->resend_cont) {
+ 			dev_dbg(&port->dev, "%s - sending setup\n", __func__);
+diff --git a/drivers/usb/serial/opticon.c b/drivers/usb/serial/opticon.c
+index cb7aac9cd9e7..ed2b4e6dca38 100644
+--- a/drivers/usb/serial/opticon.c
++++ b/drivers/usb/serial/opticon.c
+@@ -113,7 +113,7 @@ static int send_control_msg(struct usb_serial_port *port, u8 requesttype,
+ 	retval = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
+ 				requesttype,
+ 				USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
+-				0, 0, buffer, 1, 0);
++				0, 0, buffer, 1, USB_CTRL_SET_TIMEOUT);
+ 	kfree(buffer);
+ 
+ 	if (retval < 0)
+diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
+index 2d919d0e6e45..084cc2fff3ae 100644
+--- a/drivers/usb/serial/option.c
++++ b/drivers/usb/serial/option.c
+@@ -248,6 +248,7 @@ static void option_instat_callback(struct urb *urb);
+ #define QUECTEL_PRODUCT_BG96			0x0296
+ #define QUECTEL_PRODUCT_EP06			0x0306
+ #define QUECTEL_PRODUCT_EM12			0x0512
++#define QUECTEL_PRODUCT_RM500Q			0x0800
+ 
+ #define CMOTECH_VENDOR_ID			0x16d8
+ #define CMOTECH_PRODUCT_6001			0x6001
+@@ -1104,6 +1105,11 @@ static const struct usb_device_id option_ids[] = {
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EM12, 0xff, 0xff, 0xff),
+ 	  .driver_info = RSVD(1) | RSVD(2) | RSVD(3) | RSVD(4) | NUMEP2 },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EM12, 0xff, 0, 0) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_RM500Q, 0xff, 0xff, 0x30) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_RM500Q, 0xff, 0, 0) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_RM500Q, 0xff, 0xff, 0x10),
++	  .driver_info = ZLP },
++
+ 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6001) },
+ 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CMU_300) },
+ 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6003),
+diff --git a/drivers/usb/serial/quatech2.c b/drivers/usb/serial/quatech2.c
+index a62981ca7a73..f93b81a297d6 100644
+--- a/drivers/usb/serial/quatech2.c
++++ b/drivers/usb/serial/quatech2.c
+@@ -841,7 +841,10 @@ static void qt2_update_msr(struct usb_serial_port *port, unsigned char *ch)
+ 	u8 newMSR = (u8) *ch;
+ 	unsigned long flags;
+ 
++	/* May be called from qt2_process_read_urb() for an unbound port. */
+ 	port_priv = usb_get_serial_port_data(port);
++	if (!port_priv)
++		return;
+ 
+ 	spin_lock_irqsave(&port_priv->lock, flags);
+ 	port_priv->shadowMSR = newMSR;
+@@ -869,7 +872,10 @@ static void qt2_update_lsr(struct usb_serial_port *port, unsigned char *ch)
+ 	unsigned long flags;
+ 	u8 newLSR = (u8) *ch;
+ 
++	/* May be called from qt2_process_read_urb() for an unbound port. */
+ 	port_priv = usb_get_serial_port_data(port);
++	if (!port_priv)
++		return;
+ 
+ 	if (newLSR & UART_LSR_BI)
+ 		newLSR &= (u8) (UART_LSR_OE | UART_LSR_BI);
+diff --git a/drivers/usb/serial/usb-serial-simple.c b/drivers/usb/serial/usb-serial-simple.c
+index edbbb13d6de6..bd23a7cb1be2 100644
+--- a/drivers/usb/serial/usb-serial-simple.c
++++ b/drivers/usb/serial/usb-serial-simple.c
+@@ -86,6 +86,8 @@ DEVICE(moto_modem, MOTO_IDS);
+ #define MOTOROLA_TETRA_IDS()			\
+ 	{ USB_DEVICE(0x0cad, 0x9011) },	/* Motorola Solutions TETRA PEI */ \
+ 	{ USB_DEVICE(0x0cad, 0x9012) },	/* MTP6550 */ \
++	{ USB_DEVICE(0x0cad, 0x9013) },	/* MTP3xxx */ \
++	{ USB_DEVICE(0x0cad, 0x9015) },	/* MTP85xx */ \
+ 	{ USB_DEVICE(0x0cad, 0x9016) }	/* TPG2200 */
+ DEVICE(motorola_tetra, MOTOROLA_TETRA_IDS);
+ 
+diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
+index 8f066bb55d7d..dc7a65b9ec98 100644
+--- a/drivers/usb/serial/usb-serial.c
++++ b/drivers/usb/serial/usb-serial.c
+@@ -1317,6 +1317,9 @@ static int usb_serial_register(struct usb_serial_driver *driver)
+ 		return -EINVAL;
+ 	}
+ 
++	/* Prevent individual ports from being unbound. */
++	driver->driver.suppress_bind_attrs = true;
++
+ 	usb_serial_operations_init(driver);
+ 
+ 	/* Add this device to our list of devices */
+diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
+index 0b2758961b1c..6f0568fb5899 100644
+--- a/fs/btrfs/inode.c
++++ b/fs/btrfs/inode.c
+@@ -4215,18 +4215,30 @@ out:
+ }
+ 
+ static int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
+-			       struct inode *dir, u64 objectid,
+-			       const char *name, int name_len)
++			       struct inode *dir, struct dentry *dentry)
+ {
+ 	struct btrfs_root *root = BTRFS_I(dir)->root;
++	struct btrfs_inode *inode = BTRFS_I(d_inode(dentry));
+ 	struct btrfs_path *path;
+ 	struct extent_buffer *leaf;
+ 	struct btrfs_dir_item *di;
+ 	struct btrfs_key key;
++	const char *name = dentry->d_name.name;
++	int name_len = dentry->d_name.len;
+ 	u64 index;
+ 	int ret;
++	u64 objectid;
+ 	u64 dir_ino = btrfs_ino(BTRFS_I(dir));
+ 
++	if (btrfs_ino(inode) == BTRFS_FIRST_FREE_OBJECTID) {
++		objectid = inode->root->root_key.objectid;
++	} else if (btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID) {
++		objectid = inode->location.objectid;
++	} else {
++		WARN_ON(1);
++		return -EINVAL;
++	}
++
+ 	path = btrfs_alloc_path();
+ 	if (!path)
+ 		return -ENOMEM;
+@@ -4248,13 +4260,16 @@ static int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
+ 	}
+ 	btrfs_release_path(path);
+ 
+-	ret = btrfs_del_root_ref(trans, objectid, root->root_key.objectid,
+-				 dir_ino, &index, name, name_len);
+-	if (ret < 0) {
+-		if (ret != -ENOENT) {
+-			btrfs_abort_transaction(trans, ret);
+-			goto out;
+-		}
++	/*
++	 * This is a placeholder inode for a subvolume we didn't have a
++	 * reference to at the time of the snapshot creation.  In the meantime
++	 * we could have renamed the real subvol link into our snapshot, so
++	 * depending on btrfs_del_root_ref to return -ENOENT here is incorret.
++	 * Instead simply lookup the dir_index_item for this entry so we can
++	 * remove it.  Otherwise we know we have a ref to the root and we can
++	 * call btrfs_del_root_ref, and it _shouldn't_ fail.
++	 */
++	if (btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID) {
+ 		di = btrfs_search_dir_index_item(root, path, dir_ino,
+ 						 name, name_len);
+ 		if (IS_ERR_OR_NULL(di)) {
+@@ -4269,8 +4284,16 @@ static int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
+ 		leaf = path->nodes[0];
+ 		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
+ 		index = key.offset;
++		btrfs_release_path(path);
++	} else {
++		ret = btrfs_del_root_ref(trans, objectid,
++					 root->root_key.objectid, dir_ino,
++					 &index, name, name_len);
++		if (ret) {
++			btrfs_abort_transaction(trans, ret);
++			goto out;
++		}
+ 	}
+-	btrfs_release_path(path);
+ 
+ 	ret = btrfs_delete_delayed_dir_index(trans, BTRFS_I(dir), index);
+ 	if (ret) {
+@@ -4464,8 +4487,7 @@ int btrfs_delete_subvolume(struct inode *dir, struct dentry *dentry)
+ 
+ 	btrfs_record_snapshot_destroy(trans, BTRFS_I(dir));
+ 
+-	ret = btrfs_unlink_subvol(trans, dir, dest->root_key.objectid,
+-				  dentry->d_name.name, dentry->d_name.len);
++	ret = btrfs_unlink_subvol(trans, dir, dentry);
+ 	if (ret) {
+ 		err = ret;
+ 		btrfs_abort_transaction(trans, ret);
+@@ -4560,10 +4582,7 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
+ 		return PTR_ERR(trans);
+ 
+ 	if (unlikely(btrfs_ino(BTRFS_I(inode)) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
+-		err = btrfs_unlink_subvol(trans, dir,
+-					  BTRFS_I(inode)->location.objectid,
+-					  dentry->d_name.name,
+-					  dentry->d_name.len);
++		err = btrfs_unlink_subvol(trans, dir, dentry);
+ 		goto out;
+ 	}
+ 
+@@ -9519,7 +9538,6 @@ static int btrfs_rename_exchange(struct inode *old_dir,
+ 	u64 new_ino = btrfs_ino(BTRFS_I(new_inode));
+ 	u64 old_idx = 0;
+ 	u64 new_idx = 0;
+-	u64 root_objectid;
+ 	int ret;
+ 	bool root_log_pinned = false;
+ 	bool dest_log_pinned = false;
+@@ -9625,10 +9643,7 @@ static int btrfs_rename_exchange(struct inode *old_dir,
+ 
+ 	/* src is a subvolume */
+ 	if (old_ino == BTRFS_FIRST_FREE_OBJECTID) {
+-		root_objectid = BTRFS_I(old_inode)->root->root_key.objectid;
+-		ret = btrfs_unlink_subvol(trans, old_dir, root_objectid,
+-					  old_dentry->d_name.name,
+-					  old_dentry->d_name.len);
++		ret = btrfs_unlink_subvol(trans, old_dir, old_dentry);
+ 	} else { /* src is an inode */
+ 		ret = __btrfs_unlink_inode(trans, root, BTRFS_I(old_dir),
+ 					   BTRFS_I(old_dentry->d_inode),
+@@ -9644,10 +9659,7 @@ static int btrfs_rename_exchange(struct inode *old_dir,
+ 
+ 	/* dest is a subvolume */
+ 	if (new_ino == BTRFS_FIRST_FREE_OBJECTID) {
+-		root_objectid = BTRFS_I(new_inode)->root->root_key.objectid;
+-		ret = btrfs_unlink_subvol(trans, new_dir, root_objectid,
+-					  new_dentry->d_name.name,
+-					  new_dentry->d_name.len);
++		ret = btrfs_unlink_subvol(trans, new_dir, new_dentry);
+ 	} else { /* dest is an inode */
+ 		ret = __btrfs_unlink_inode(trans, dest, BTRFS_I(new_dir),
+ 					   BTRFS_I(new_dentry->d_inode),
+@@ -9845,7 +9857,6 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
+ 	struct inode *new_inode = d_inode(new_dentry);
+ 	struct inode *old_inode = d_inode(old_dentry);
+ 	u64 index = 0;
+-	u64 root_objectid;
+ 	int ret;
+ 	u64 old_ino = btrfs_ino(BTRFS_I(old_inode));
+ 	bool log_pinned = false;
+@@ -9953,10 +9964,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
+ 				BTRFS_I(old_inode), 1);
+ 
+ 	if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
+-		root_objectid = BTRFS_I(old_inode)->root->root_key.objectid;
+-		ret = btrfs_unlink_subvol(trans, old_dir, root_objectid,
+-					old_dentry->d_name.name,
+-					old_dentry->d_name.len);
++		ret = btrfs_unlink_subvol(trans, old_dir, old_dentry);
+ 	} else {
+ 		ret = __btrfs_unlink_inode(trans, root, BTRFS_I(old_dir),
+ 					BTRFS_I(d_inode(old_dentry)),
+@@ -9975,10 +9983,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
+ 		new_inode->i_ctime = current_time(new_inode);
+ 		if (unlikely(btrfs_ino(BTRFS_I(new_inode)) ==
+ 			     BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
+-			root_objectid = BTRFS_I(new_inode)->location.objectid;
+-			ret = btrfs_unlink_subvol(trans, new_dir, root_objectid,
+-						new_dentry->d_name.name,
+-						new_dentry->d_name.len);
++			ret = btrfs_unlink_subvol(trans, new_dir, new_dentry);
+ 			BUG_ON(new_inode->i_nlink == 0);
+ 		} else {
+ 			ret = btrfs_unlink_inode(trans, dest, BTRFS_I(new_dir),
+diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
+index 5720e450a46f..8e86b2d700c4 100644
+--- a/fs/btrfs/ioctl.c
++++ b/fs/btrfs/ioctl.c
+@@ -4254,7 +4254,19 @@ static long btrfs_ioctl_scrub(struct file *file, void __user *arg)
+ 			      &sa->progress, sa->flags & BTRFS_SCRUB_READONLY,
+ 			      0);
+ 
+-	if (ret == 0 && copy_to_user(arg, sa, sizeof(*sa)))
++	/*
++	 * Copy scrub args to user space even if btrfs_scrub_dev() returned an
++	 * error. This is important as it allows user space to know how much
++	 * progress scrub has done. For example, if scrub is canceled we get
++	 * -ECANCELED from btrfs_scrub_dev() and return that error back to user
++	 * space. Later user space can inspect the progress from the structure
++	 * btrfs_ioctl_scrub_args and resume scrub from where it left off
++	 * previously (btrfs-progs does this).
++	 * If we fail to copy the btrfs_ioctl_scrub_args structure to user space
++	 * then return -EFAULT to signal the structure was not copied or it may
++	 * be corrupt and unreliable due to a partial copy.
++	 */
++	if (copy_to_user(arg, sa, sizeof(*sa)))
+ 		ret = -EFAULT;
+ 
+ 	if (!(sa->flags & BTRFS_SCRUB_READONLY))
+diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c
+index aeb5f2f3cdd7..50517221638a 100644
+--- a/fs/btrfs/qgroup.c
++++ b/fs/btrfs/qgroup.c
+@@ -2423,8 +2423,12 @@ int btrfs_qgroup_account_extent(struct btrfs_trans_handle *trans, u64 bytenr,
+ 	u64 nr_old_roots = 0;
+ 	int ret = 0;
+ 
++	/*
++	 * If quotas get disabled meanwhile, the resouces need to be freed and
++	 * we can't just exit here.
++	 */
+ 	if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags))
+-		return 0;
++		goto out_free;
+ 
+ 	if (new_roots) {
+ 		if (!maybe_fs_roots(new_roots))
+diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
+index fd0f4c1696c8..bc1d7f144ace 100644
+--- a/fs/btrfs/relocation.c
++++ b/fs/btrfs/relocation.c
+@@ -517,6 +517,34 @@ static int update_backref_cache(struct btrfs_trans_handle *trans,
+ 	return 1;
+ }
+ 
++static bool reloc_root_is_dead(struct btrfs_root *root)
++{
++	/*
++	 * Pair with set_bit/clear_bit in clean_dirty_subvols and
++	 * btrfs_update_reloc_root. We need to see the updated bit before
++	 * trying to access reloc_root
++	 */
++	smp_rmb();
++	if (test_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state))
++		return true;
++	return false;
++}
++
++/*
++ * Check if this subvolume tree has valid reloc tree.
++ *
++ * Reloc tree after swap is considered dead, thus not considered as valid.
++ * This is enough for most callers, as they don't distinguish dead reloc root
++ * from no reloc root.  But should_ignore_root() below is a special case.
++ */
++static bool have_reloc_root(struct btrfs_root *root)
++{
++	if (reloc_root_is_dead(root))
++		return false;
++	if (!root->reloc_root)
++		return false;
++	return true;
++}
+ 
+ static int should_ignore_root(struct btrfs_root *root)
+ {
+@@ -525,6 +553,10 @@ static int should_ignore_root(struct btrfs_root *root)
+ 	if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state))
+ 		return 0;
+ 
++	/* This root has been merged with its reloc tree, we can ignore it */
++	if (reloc_root_is_dead(root))
++		return 1;
++
+ 	reloc_root = root->reloc_root;
+ 	if (!reloc_root)
+ 		return 0;
+@@ -1439,7 +1471,7 @@ int btrfs_init_reloc_root(struct btrfs_trans_handle *trans,
+ 	 * The subvolume has reloc tree but the swap is finished, no need to
+ 	 * create/update the dead reloc tree
+ 	 */
+-	if (test_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state))
++	if (reloc_root_is_dead(root))
+ 		return 0;
+ 
+ 	if (root->reloc_root) {
+@@ -1478,8 +1510,7 @@ int btrfs_update_reloc_root(struct btrfs_trans_handle *trans,
+ 	struct btrfs_root_item *root_item;
+ 	int ret;
+ 
+-	if (test_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state) ||
+-	    !root->reloc_root)
++	if (!have_reloc_root(root))
+ 		goto out;
+ 
+ 	reloc_root = root->reloc_root;
+@@ -1489,6 +1520,11 @@ int btrfs_update_reloc_root(struct btrfs_trans_handle *trans,
+ 	if (fs_info->reloc_ctl->merge_reloc_tree &&
+ 	    btrfs_root_refs(root_item) == 0) {
+ 		set_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state);
++		/*
++		 * Mark the tree as dead before we change reloc_root so
++		 * have_reloc_root will not touch it from now on.
++		 */
++		smp_wmb();
+ 		__del_reloc_root(reloc_root);
+ 	}
+ 
+@@ -2202,6 +2238,11 @@ static int clean_dirty_subvols(struct reloc_control *rc)
+ 				if (ret2 < 0 && !ret)
+ 					ret = ret2;
+ 			}
++			/*
++			 * Need barrier to ensure clear_bit() only happens after
++			 * root->reloc_root = NULL. Pairs with have_reloc_root.
++			 */
++			smp_wmb();
+ 			clear_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state);
+ 			btrfs_put_fs_root(root);
+ 		} else {
+@@ -4721,7 +4762,7 @@ void btrfs_reloc_pre_snapshot(struct btrfs_pending_snapshot *pending,
+ 	struct btrfs_root *root = pending->root;
+ 	struct reloc_control *rc = root->fs_info->reloc_ctl;
+ 
+-	if (!root->reloc_root || !rc)
++	if (!rc || !have_reloc_root(root))
+ 		return;
+ 
+ 	if (!rc->merge_reloc_tree)
+@@ -4755,7 +4796,7 @@ int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,
+ 	struct reloc_control *rc = root->fs_info->reloc_ctl;
+ 	int ret;
+ 
+-	if (!root->reloc_root || !rc)
++	if (!rc || !have_reloc_root(root))
+ 		return 0;
+ 
+ 	rc = root->fs_info->reloc_ctl;
+diff --git a/fs/btrfs/root-tree.c b/fs/btrfs/root-tree.c
+index 3b17b647d002..612411c74550 100644
+--- a/fs/btrfs/root-tree.c
++++ b/fs/btrfs/root-tree.c
+@@ -376,11 +376,13 @@ again:
+ 		leaf = path->nodes[0];
+ 		ref = btrfs_item_ptr(leaf, path->slots[0],
+ 				     struct btrfs_root_ref);
+-
+-		WARN_ON(btrfs_root_ref_dirid(leaf, ref) != dirid);
+-		WARN_ON(btrfs_root_ref_name_len(leaf, ref) != name_len);
+ 		ptr = (unsigned long)(ref + 1);
+-		WARN_ON(memcmp_extent_buffer(leaf, name, ptr, name_len));
++		if ((btrfs_root_ref_dirid(leaf, ref) != dirid) ||
++		    (btrfs_root_ref_name_len(leaf, ref) != name_len) ||
++		    memcmp_extent_buffer(leaf, name, ptr, name_len)) {
++			err = -ENOENT;
++			goto out;
++		}
+ 		*sequence = btrfs_root_ref_sequence(leaf, ref);
+ 
+ 		ret = btrfs_del_item(trans, tree_root, path);
+diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
+index d8d7b1ee83ca..97f1ba7c18b2 100644
+--- a/fs/btrfs/volumes.c
++++ b/fs/btrfs/volumes.c
+@@ -4066,7 +4066,11 @@ int btrfs_balance(struct btrfs_fs_info *fs_info,
+ 		}
+ 	}
+ 
+-	num_devices = btrfs_num_devices(fs_info);
++	/*
++	 * rw_devices will not change at the moment, device add/delete/replace
++	 * are excluded by EXCL_OP
++	 */
++	num_devices = fs_info->fs_devices->rw_devices;
+ 
+ 	/*
+ 	 * SINGLE profile on-disk has no profile bit, but in-memory we have a
+diff --git a/fs/fuse/file.c b/fs/fuse/file.c
+index a63d779eac10..ce715380143c 100644
+--- a/fs/fuse/file.c
++++ b/fs/fuse/file.c
+@@ -882,6 +882,7 @@ static void fuse_send_readpages(struct fuse_io_args *ia, struct file *file)
+ 	struct fuse_args_pages *ap = &ia->ap;
+ 	loff_t pos = page_offset(ap->pages[0]);
+ 	size_t count = ap->num_pages << PAGE_SHIFT;
++	ssize_t res;
+ 	int err;
+ 
+ 	ap->args.out_pages = true;
+@@ -896,7 +897,8 @@ static void fuse_send_readpages(struct fuse_io_args *ia, struct file *file)
+ 		if (!err)
+ 			return;
+ 	} else {
+-		err = fuse_simple_request(fc, &ap->args);
++		res = fuse_simple_request(fc, &ap->args);
++		err = res < 0 ? res : 0;
+ 	}
+ 	fuse_readpages_end(fc, &ap->args, err);
+ }
+diff --git a/fs/io_uring.c b/fs/io_uring.c
+index 709671faaed6..b1c9ad1fb9e1 100644
+--- a/fs/io_uring.c
++++ b/fs/io_uring.c
+@@ -3716,6 +3716,12 @@ SYSCALL_DEFINE6(io_uring_enter, unsigned int, fd, u32, to_submit,
+ 			wake_up(&ctx->sqo_wait);
+ 		submitted = to_submit;
+ 	} else if (to_submit) {
++		if (current->mm != ctx->sqo_mm ||
++		    current_cred() != ctx->creds) {
++			ret = -EPERM;
++			goto out;
++		}
++
+ 		to_submit = min(to_submit, ctx->sq_entries);
+ 
+ 		mutex_lock(&ctx->uring_lock);
+diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
+index 62b40df36c98..28b241cd6987 100644
+--- a/fs/reiserfs/xattr.c
++++ b/fs/reiserfs/xattr.c
+@@ -319,8 +319,12 @@ static int reiserfs_for_each_xattr(struct inode *inode,
+ out_dir:
+ 	dput(dir);
+ out:
+-	/* -ENODATA isn't an error */
+-	if (err == -ENODATA)
++	/*
++	 * -ENODATA: this object doesn't have any xattrs
++	 * -EOPNOTSUPP: this file system doesn't have xattrs enabled on disk.
++	 * Neither are errors
++	 */
++	if (err == -ENODATA || err == -EOPNOTSUPP)
+ 		err = 0;
+ 	return err;
+ }
+diff --git a/include/dt-bindings/reset/amlogic,meson8b-reset.h b/include/dt-bindings/reset/amlogic,meson8b-reset.h
+index c614438bcbdb..fbc524a900da 100644
+--- a/include/dt-bindings/reset/amlogic,meson8b-reset.h
++++ b/include/dt-bindings/reset/amlogic,meson8b-reset.h
+@@ -46,9 +46,9 @@
+ #define RESET_VD_RMEM			64
+ #define RESET_AUDIN			65
+ #define RESET_DBLK			66
+-#define RESET_PIC_DC			66
+-#define RESET_PSC			66
+-#define RESET_NAND			66
++#define RESET_PIC_DC			67
++#define RESET_PSC			68
++#define RESET_NAND			69
+ #define RESET_GE2D			70
+ #define RESET_PARSER_REG		71
+ #define RESET_PARSER_FETCH		72
+diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
+index f3ea78b0c91c..51ccb4b8770a 100644
+--- a/include/linux/blkdev.h
++++ b/include/linux/blkdev.h
+@@ -328,6 +328,7 @@ struct queue_limits {
+ 	unsigned int		max_sectors;
+ 	unsigned int		max_segment_size;
+ 	unsigned int		physical_block_size;
++	unsigned int		logical_block_size;
+ 	unsigned int		alignment_offset;
+ 	unsigned int		io_min;
+ 	unsigned int		io_opt;
+@@ -338,7 +339,6 @@ struct queue_limits {
+ 	unsigned int		discard_granularity;
+ 	unsigned int		discard_alignment;
+ 
+-	unsigned short		logical_block_size;
+ 	unsigned short		max_segments;
+ 	unsigned short		max_integrity_segments;
+ 	unsigned short		max_discard_segments;
+@@ -1080,7 +1080,7 @@ extern void blk_queue_max_write_same_sectors(struct request_queue *q,
+ 		unsigned int max_write_same_sectors);
+ extern void blk_queue_max_write_zeroes_sectors(struct request_queue *q,
+ 		unsigned int max_write_same_sectors);
+-extern void blk_queue_logical_block_size(struct request_queue *, unsigned short);
++extern void blk_queue_logical_block_size(struct request_queue *, unsigned int);
+ extern void blk_queue_physical_block_size(struct request_queue *, unsigned int);
+ extern void blk_queue_alignment_offset(struct request_queue *q,
+ 				       unsigned int alignment);
+@@ -1294,7 +1294,7 @@ static inline unsigned int queue_max_segment_size(const struct request_queue *q)
+ 	return q->limits.max_segment_size;
+ }
+ 
+-static inline unsigned short queue_logical_block_size(const struct request_queue *q)
++static inline unsigned queue_logical_block_size(const struct request_queue *q)
+ {
+ 	int retval = 512;
+ 
+@@ -1304,7 +1304,7 @@ static inline unsigned short queue_logical_block_size(const struct request_queue
+ 	return retval;
+ }
+ 
+-static inline unsigned short bdev_logical_block_size(struct block_device *bdev)
++static inline unsigned int bdev_logical_block_size(struct block_device *bdev)
+ {
+ 	return queue_logical_block_size(bdev_get_queue(bdev));
+ }
+diff --git a/include/linux/mm.h b/include/linux/mm.h
+index a2adf95b3f9c..b249d2e033aa 100644
+--- a/include/linux/mm.h
++++ b/include/linux/mm.h
+@@ -2666,13 +2666,25 @@ static inline bool want_init_on_free(void)
+ 	       !page_poisoning_enabled();
+ }
+ 
+-#ifdef CONFIG_DEBUG_PAGEALLOC_ENABLE_DEFAULT
+-DECLARE_STATIC_KEY_TRUE(_debug_pagealloc_enabled);
++#ifdef CONFIG_DEBUG_PAGEALLOC
++extern void init_debug_pagealloc(void);
+ #else
+-DECLARE_STATIC_KEY_FALSE(_debug_pagealloc_enabled);
++static inline void init_debug_pagealloc(void) {}
+ #endif
++extern bool _debug_pagealloc_enabled_early;
++DECLARE_STATIC_KEY_FALSE(_debug_pagealloc_enabled);
+ 
+ static inline bool debug_pagealloc_enabled(void)
++{
++	return IS_ENABLED(CONFIG_DEBUG_PAGEALLOC) &&
++		_debug_pagealloc_enabled_early;
++}
++
++/*
++ * For use in fast paths after init_debug_pagealloc() has run, or when a
++ * false negative result is not harmful when called too early.
++ */
++static inline bool debug_pagealloc_enabled_static(void)
+ {
+ 	if (!IS_ENABLED(CONFIG_DEBUG_PAGEALLOC))
+ 		return false;
+diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
+index bda20282746b..8b5f758942a2 100644
+--- a/include/linux/mmzone.h
++++ b/include/linux/mmzone.h
+@@ -215,9 +215,8 @@ enum node_stat_item {
+ 	NR_INACTIVE_FILE,	/*  "     "     "   "       "         */
+ 	NR_ACTIVE_FILE,		/*  "     "     "   "       "         */
+ 	NR_UNEVICTABLE,		/*  "     "     "   "       "         */
+-	NR_SLAB_RECLAIMABLE,	/* Please do not reorder this item */
+-	NR_SLAB_UNRECLAIMABLE,	/* and this one without looking at
+-				 * memcg_flush_percpu_vmstats() first. */
++	NR_SLAB_RECLAIMABLE,
++	NR_SLAB_UNRECLAIMABLE,
+ 	NR_ISOLATED_ANON,	/* Temporary isolated pages from anon lru */
+ 	NR_ISOLATED_FILE,	/* Temporary isolated pages from file lru */
+ 	WORKINGSET_NODES,
+diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
+index 76d952aeb0fc..13f09706033a 100644
+--- a/include/linux/netdevice.h
++++ b/include/linux/netdevice.h
+@@ -1761,7 +1761,7 @@ enum netdev_priv_flags {
+  *			for hardware timestamping
+  *	@sfp_bus:	attached &struct sfp_bus structure.
+  *	@qdisc_tx_busylock_key: lockdep class annotating Qdisc->busylock
+-				spinlock
++ *				spinlock
+  *	@qdisc_running_key:	lockdep class annotating Qdisc->running seqcount
+  *	@qdisc_xmit_lock_key:	lockdep class annotating
+  *				netdev_queue->_xmit_lock spinlock
+diff --git a/include/linux/regulator/ab8500.h b/include/linux/regulator/ab8500.h
+index 505e94a6e3e8..3ab1ddf151a2 100644
+--- a/include/linux/regulator/ab8500.h
++++ b/include/linux/regulator/ab8500.h
+@@ -42,8 +42,6 @@ enum ab8505_regulator_id {
+ 	AB8505_LDO_ANAMIC2,
+ 	AB8505_LDO_AUX8,
+ 	AB8505_LDO_ANA,
+-	AB8505_SYSCLKREQ_2,
+-	AB8505_SYSCLKREQ_4,
+ 	AB8505_NUM_REGULATORS,
+ };
+ 
+diff --git a/include/linux/skmsg.h b/include/linux/skmsg.h
+index da4caff7efa4..7eb6a8754f19 100644
+--- a/include/linux/skmsg.h
++++ b/include/linux/skmsg.h
+@@ -354,17 +354,22 @@ static inline void sk_psock_update_proto(struct sock *sk,
+ static inline void sk_psock_restore_proto(struct sock *sk,
+ 					  struct sk_psock *psock)
+ {
+-	sk->sk_write_space = psock->saved_write_space;
++	sk->sk_prot->unhash = psock->saved_unhash;
+ 
+ 	if (psock->sk_proto) {
+ 		struct inet_connection_sock *icsk = inet_csk(sk);
+ 		bool has_ulp = !!icsk->icsk_ulp_data;
+ 
+-		if (has_ulp)
+-			tcp_update_ulp(sk, psock->sk_proto);
+-		else
++		if (has_ulp) {
++			tcp_update_ulp(sk, psock->sk_proto,
++				       psock->saved_write_space);
++		} else {
+ 			sk->sk_prot = psock->sk_proto;
++			sk->sk_write_space = psock->saved_write_space;
++		}
+ 		psock->sk_proto = NULL;
++	} else {
++		sk->sk_write_space = psock->saved_write_space;
+ 	}
+ }
+ 
+diff --git a/include/linux/tnum.h b/include/linux/tnum.h
+index c17af77f3fae..ea627d1ab7e3 100644
+--- a/include/linux/tnum.h
++++ b/include/linux/tnum.h
+@@ -30,7 +30,7 @@ struct tnum tnum_lshift(struct tnum a, u8 shift);
+ /* Shift (rsh) a tnum right (by a fixed shift) */
+ struct tnum tnum_rshift(struct tnum a, u8 shift);
+ /* Shift (arsh) a tnum right (by a fixed min_shift) */
+-struct tnum tnum_arshift(struct tnum a, u8 min_shift);
++struct tnum tnum_arshift(struct tnum a, u8 min_shift, u8 insn_bitness);
+ /* Add two tnums, return @a + @b */
+ struct tnum tnum_add(struct tnum a, struct tnum b);
+ /* Subtract two tnums, return @a - @b */
+diff --git a/include/net/tcp.h b/include/net/tcp.h
+index b2367cfe0bda..830c89db1245 100644
+--- a/include/net/tcp.h
++++ b/include/net/tcp.h
+@@ -2132,7 +2132,8 @@ struct tcp_ulp_ops {
+ 	/* initialize ulp */
+ 	int (*init)(struct sock *sk);
+ 	/* update ulp */
+-	void (*update)(struct sock *sk, struct proto *p);
++	void (*update)(struct sock *sk, struct proto *p,
++		       void (*write_space)(struct sock *sk));
+ 	/* cleanup ulp */
+ 	void (*release)(struct sock *sk);
+ 	/* diagnostic */
+@@ -2147,7 +2148,8 @@ void tcp_unregister_ulp(struct tcp_ulp_ops *type);
+ int tcp_set_ulp(struct sock *sk, const char *name);
+ void tcp_get_available_ulp(char *buf, size_t len);
+ void tcp_cleanup_ulp(struct sock *sk);
+-void tcp_update_ulp(struct sock *sk, struct proto *p);
++void tcp_update_ulp(struct sock *sk, struct proto *p,
++		    void (*write_space)(struct sock *sk));
+ 
+ #define MODULE_ALIAS_TCP_ULP(name)				\
+ 	__MODULE_INFO(alias, alias_userspace, name);		\
+diff --git a/include/trace/events/huge_memory.h b/include/trace/events/huge_memory.h
+index dd4db334bd63..d82a0f4e824d 100644
+--- a/include/trace/events/huge_memory.h
++++ b/include/trace/events/huge_memory.h
+@@ -31,7 +31,8 @@
+ 	EM( SCAN_ALLOC_HUGE_PAGE_FAIL,	"alloc_huge_page_failed")	\
+ 	EM( SCAN_CGROUP_CHARGE_FAIL,	"ccgroup_charge_failed")	\
+ 	EM( SCAN_EXCEED_SWAP_PTE,	"exceed_swap_pte")		\
+-	EMe(SCAN_TRUNCATED,		"truncated")			\
++	EM( SCAN_TRUNCATED,		"truncated")			\
++	EMe(SCAN_PAGE_HAS_PRIVATE,	"page_has_private")		\
+ 
+ #undef EM
+ #undef EMe
+diff --git a/init/main.c b/init/main.c
+index 91f6ebb30ef0..c0206c507eba 100644
+--- a/init/main.c
++++ b/init/main.c
+@@ -553,6 +553,7 @@ static void __init mm_init(void)
+ 	 * bigger than MAX_ORDER unless SPARSEMEM.
+ 	 */
+ 	page_ext_init_flatmem();
++	init_debug_pagealloc();
+ 	report_meminit();
+ 	mem_init();
+ 	kmem_cache_init();
+diff --git a/kernel/bpf/tnum.c b/kernel/bpf/tnum.c
+index ca52b9642943..d4f335a9a899 100644
+--- a/kernel/bpf/tnum.c
++++ b/kernel/bpf/tnum.c
+@@ -44,14 +44,19 @@ struct tnum tnum_rshift(struct tnum a, u8 shift)
+ 	return TNUM(a.value >> shift, a.mask >> shift);
+ }
+ 
+-struct tnum tnum_arshift(struct tnum a, u8 min_shift)
++struct tnum tnum_arshift(struct tnum a, u8 min_shift, u8 insn_bitness)
+ {
+ 	/* if a.value is negative, arithmetic shifting by minimum shift
+ 	 * will have larger negative offset compared to more shifting.
+ 	 * If a.value is nonnegative, arithmetic shifting by minimum shift
+ 	 * will have larger positive offset compare to more shifting.
+ 	 */
+-	return TNUM((s64)a.value >> min_shift, (s64)a.mask >> min_shift);
++	if (insn_bitness == 32)
++		return TNUM((u32)(((s32)a.value) >> min_shift),
++			    (u32)(((s32)a.mask)  >> min_shift));
++	else
++		return TNUM((s64)a.value >> min_shift,
++			    (s64)a.mask  >> min_shift);
+ }
+ 
+ struct tnum tnum_add(struct tnum a, struct tnum b)
+diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
+index 9c74c98f6501..b2817d0929b3 100644
+--- a/kernel/bpf/verifier.c
++++ b/kernel/bpf/verifier.c
+@@ -4824,9 +4824,16 @@ static int adjust_scalar_min_max_vals(struct bpf_verifier_env *env,
+ 		/* Upon reaching here, src_known is true and
+ 		 * umax_val is equal to umin_val.
+ 		 */
+-		dst_reg->smin_value >>= umin_val;
+-		dst_reg->smax_value >>= umin_val;
+-		dst_reg->var_off = tnum_arshift(dst_reg->var_off, umin_val);
++		if (insn_bitness == 32) {
++			dst_reg->smin_value = (u32)(((s32)dst_reg->smin_value) >> umin_val);
++			dst_reg->smax_value = (u32)(((s32)dst_reg->smax_value) >> umin_val);
++		} else {
++			dst_reg->smin_value >>= umin_val;
++			dst_reg->smax_value >>= umin_val;
++		}
++
++		dst_reg->var_off = tnum_arshift(dst_reg->var_off, umin_val,
++						insn_bitness);
+ 
+ 		/* blow away the dst_reg umin_value/umax_value and rely on
+ 		 * dst_reg var_off to refine the result.
+diff --git a/kernel/cpu.c b/kernel/cpu.c
+index e2cad3ee2ead..116825437cd6 100644
+--- a/kernel/cpu.c
++++ b/kernel/cpu.c
+@@ -1909,6 +1909,78 @@ void __cpuhp_remove_state(enum cpuhp_state state, bool invoke)
+ }
+ EXPORT_SYMBOL(__cpuhp_remove_state);
+ 
++#ifdef CONFIG_HOTPLUG_SMT
++static void cpuhp_offline_cpu_device(unsigned int cpu)
++{
++	struct device *dev = get_cpu_device(cpu);
++
++	dev->offline = true;
++	/* Tell user space about the state change */
++	kobject_uevent(&dev->kobj, KOBJ_OFFLINE);
++}
++
++static void cpuhp_online_cpu_device(unsigned int cpu)
++{
++	struct device *dev = get_cpu_device(cpu);
++
++	dev->offline = false;
++	/* Tell user space about the state change */
++	kobject_uevent(&dev->kobj, KOBJ_ONLINE);
++}
++
++int cpuhp_smt_disable(enum cpuhp_smt_control ctrlval)
++{
++	int cpu, ret = 0;
++
++	cpu_maps_update_begin();
++	for_each_online_cpu(cpu) {
++		if (topology_is_primary_thread(cpu))
++			continue;
++		ret = cpu_down_maps_locked(cpu, CPUHP_OFFLINE);
++		if (ret)
++			break;
++		/*
++		 * As this needs to hold the cpu maps lock it's impossible
++		 * to call device_offline() because that ends up calling
++		 * cpu_down() which takes cpu maps lock. cpu maps lock
++		 * needs to be held as this might race against in kernel
++		 * abusers of the hotplug machinery (thermal management).
++		 *
++		 * So nothing would update device:offline state. That would
++		 * leave the sysfs entry stale and prevent onlining after
++		 * smt control has been changed to 'off' again. This is
++		 * called under the sysfs hotplug lock, so it is properly
++		 * serialized against the regular offline usage.
++		 */
++		cpuhp_offline_cpu_device(cpu);
++	}
++	if (!ret)
++		cpu_smt_control = ctrlval;
++	cpu_maps_update_done();
++	return ret;
++}
++
++int cpuhp_smt_enable(void)
++{
++	int cpu, ret = 0;
++
++	cpu_maps_update_begin();
++	cpu_smt_control = CPU_SMT_ENABLED;
++	for_each_present_cpu(cpu) {
++		/* Skip online CPUs and CPUs on offline nodes */
++		if (cpu_online(cpu) || !node_online(cpu_to_node(cpu)))
++			continue;
++		ret = _cpu_up(cpu, 0, CPUHP_ONLINE);
++		if (ret)
++			break;
++		/* See comment in cpuhp_smt_disable() */
++		cpuhp_online_cpu_device(cpu);
++	}
++	cpu_maps_update_done();
++	return ret;
++}
++#endif
++
+ #if defined(CONFIG_SYSFS) && defined(CONFIG_HOTPLUG_CPU)
+ static ssize_t show_cpuhp_state(struct device *dev,
+ 				struct device_attribute *attr, char *buf)
+@@ -2063,77 +2135,6 @@ static const struct attribute_group cpuhp_cpu_root_attr_group = {
+ 
+ #ifdef CONFIG_HOTPLUG_SMT
+ 
+-static void cpuhp_offline_cpu_device(unsigned int cpu)
+-{
+-	struct device *dev = get_cpu_device(cpu);
+-
+-	dev->offline = true;
+-	/* Tell user space about the state change */
+-	kobject_uevent(&dev->kobj, KOBJ_OFFLINE);
+-}
+-
+-static void cpuhp_online_cpu_device(unsigned int cpu)
+-{
+-	struct device *dev = get_cpu_device(cpu);
+-
+-	dev->offline = false;
+-	/* Tell user space about the state change */
+-	kobject_uevent(&dev->kobj, KOBJ_ONLINE);
+-}
+-
+-int cpuhp_smt_disable(enum cpuhp_smt_control ctrlval)
+-{
+-	int cpu, ret = 0;
+-
+-	cpu_maps_update_begin();
+-	for_each_online_cpu(cpu) {
+-		if (topology_is_primary_thread(cpu))
+-			continue;
+-		ret = cpu_down_maps_locked(cpu, CPUHP_OFFLINE);
+-		if (ret)
+-			break;
+-		/*
+-		 * As this needs to hold the cpu maps lock it's impossible
+-		 * to call device_offline() because that ends up calling
+-		 * cpu_down() which takes cpu maps lock. cpu maps lock
+-		 * needs to be held as this might race against in kernel
+-		 * abusers of the hotplug machinery (thermal management).
+-		 *
+-		 * So nothing would update device:offline state. That would
+-		 * leave the sysfs entry stale and prevent onlining after
+-		 * smt control has been changed to 'off' again. This is
+-		 * called under the sysfs hotplug lock, so it is properly
+-		 * serialized against the regular offline usage.
+-		 */
+-		cpuhp_offline_cpu_device(cpu);
+-	}
+-	if (!ret)
+-		cpu_smt_control = ctrlval;
+-	cpu_maps_update_done();
+-	return ret;
+-}
+-
+-int cpuhp_smt_enable(void)
+-{
+-	int cpu, ret = 0;
+-
+-	cpu_maps_update_begin();
+-	cpu_smt_control = CPU_SMT_ENABLED;
+-	for_each_present_cpu(cpu) {
+-		/* Skip online CPUs and CPUs on offline nodes */
+-		if (cpu_online(cpu) || !node_online(cpu_to_node(cpu)))
+-			continue;
+-		ret = _cpu_up(cpu, 0, CPUHP_ONLINE);
+-		if (ret)
+-			break;
+-		/* See comment in cpuhp_smt_disable() */
+-		cpuhp_online_cpu_device(cpu);
+-	}
+-	cpu_maps_update_done();
+-	return ret;
+-}
+-
+-
+ static ssize_t
+ __store_smt_control(struct device *dev, struct device_attribute *attr,
+ 		    const char *buf, size_t count)
+diff --git a/kernel/events/core.c b/kernel/events/core.c
+index 8f66a4833ded..6c829e22bad3 100644
+--- a/kernel/events/core.c
++++ b/kernel/events/core.c
+@@ -11182,8 +11182,10 @@ SYSCALL_DEFINE5(perf_event_open,
+ 		}
+ 	}
+ 
+-	if (event->attr.aux_output && !perf_get_aux_event(event, group_leader))
++	if (event->attr.aux_output && !perf_get_aux_event(event, group_leader)) {
++		err = -EINVAL;
+ 		goto err_locked;
++	}
+ 
+ 	/*
+ 	 * Must be under the same ctx::mutex as perf_install_in_context(),
+diff --git a/kernel/locking/lockdep.c b/kernel/locking/lockdep.c
+index 233459c03b5a..35d3b6925b1e 100644
+--- a/kernel/locking/lockdep.c
++++ b/kernel/locking/lockdep.c
+@@ -482,7 +482,7 @@ static struct lock_trace *save_trace(void)
+ 	struct lock_trace *trace, *t2;
+ 	struct hlist_head *hash_head;
+ 	u32 hash;
+-	unsigned int max_entries;
++	int max_entries;
+ 
+ 	BUILD_BUG_ON_NOT_POWER_OF_2(STACK_TRACE_HASH_SIZE);
+ 	BUILD_BUG_ON(LOCK_TRACE_SIZE_IN_LONGS >= MAX_STACK_TRACE_ENTRIES);
+@@ -490,10 +490,8 @@ static struct lock_trace *save_trace(void)
+ 	trace = (struct lock_trace *)(stack_trace + nr_stack_trace_entries);
+ 	max_entries = MAX_STACK_TRACE_ENTRIES - nr_stack_trace_entries -
+ 		LOCK_TRACE_SIZE_IN_LONGS;
+-	trace->nr_entries = stack_trace_save(trace->entries, max_entries, 3);
+ 
+-	if (nr_stack_trace_entries >= MAX_STACK_TRACE_ENTRIES -
+-	    LOCK_TRACE_SIZE_IN_LONGS - 1) {
++	if (max_entries <= 0) {
+ 		if (!debug_locks_off_graph_unlock())
+ 			return NULL;
+ 
+@@ -502,6 +500,7 @@ static struct lock_trace *save_trace(void)
+ 
+ 		return NULL;
+ 	}
++	trace->nr_entries = stack_trace_save(trace->entries, max_entries, 3);
+ 
+ 	hash = jhash(trace->entries, trace->nr_entries *
+ 		     sizeof(trace->entries[0]), 0);
+diff --git a/kernel/locking/rwsem.c b/kernel/locking/rwsem.c
+index eef04551eae7..baafa1dd9fcc 100644
+--- a/kernel/locking/rwsem.c
++++ b/kernel/locking/rwsem.c
+@@ -1226,8 +1226,8 @@ wait:
+ 		 * In this case, we attempt to acquire the lock again
+ 		 * without sleeping.
+ 		 */
+-		if ((wstate == WRITER_HANDOFF) &&
+-		    (rwsem_spin_on_owner(sem, 0) == OWNER_NULL))
++		if (wstate == WRITER_HANDOFF &&
++		    rwsem_spin_on_owner(sem, RWSEM_NONSPINNABLE) == OWNER_NULL)
+ 			goto trylock_again;
+ 
+ 		/* Block until there are no active lockers. */
+diff --git a/kernel/ptrace.c b/kernel/ptrace.c
+index cb9ddcc08119..43d6179508d6 100644
+--- a/kernel/ptrace.c
++++ b/kernel/ptrace.c
+@@ -264,12 +264,17 @@ static int ptrace_check_attach(struct task_struct *child, bool ignore_state)
+ 	return ret;
+ }
+ 
+-static int ptrace_has_cap(struct user_namespace *ns, unsigned int mode)
++static bool ptrace_has_cap(const struct cred *cred, struct user_namespace *ns,
++			   unsigned int mode)
+ {
++	int ret;
++
+ 	if (mode & PTRACE_MODE_NOAUDIT)
+-		return has_ns_capability_noaudit(current, ns, CAP_SYS_PTRACE);
++		ret = security_capable(cred, ns, CAP_SYS_PTRACE, CAP_OPT_NOAUDIT);
+ 	else
+-		return has_ns_capability(current, ns, CAP_SYS_PTRACE);
++		ret = security_capable(cred, ns, CAP_SYS_PTRACE, CAP_OPT_NONE);
++
++	return ret == 0;
+ }
+ 
+ /* Returns 0 on success, -errno on denial. */
+@@ -321,7 +326,7 @@ static int __ptrace_may_access(struct task_struct *task, unsigned int mode)
+ 	    gid_eq(caller_gid, tcred->sgid) &&
+ 	    gid_eq(caller_gid, tcred->gid))
+ 		goto ok;
+-	if (ptrace_has_cap(tcred->user_ns, mode))
++	if (ptrace_has_cap(cred, tcred->user_ns, mode))
+ 		goto ok;
+ 	rcu_read_unlock();
+ 	return -EPERM;
+@@ -340,7 +345,7 @@ ok:
+ 	mm = task->mm;
+ 	if (mm &&
+ 	    ((get_dumpable(mm) != SUID_DUMP_USER) &&
+-	     !ptrace_has_cap(mm->user_ns, mode)))
++	     !ptrace_has_cap(cred, mm->user_ns, mode)))
+ 	    return -EPERM;
+ 
+ 	return security_ptrace_access_check(task, mode);
+diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
+index 955851748dc3..5c9fcc72460d 100644
+--- a/kernel/time/tick-sched.c
++++ b/kernel/time/tick-sched.c
+@@ -58,8 +58,9 @@ static void tick_do_update_jiffies64(ktime_t now)
+ 
+ 	/*
+ 	 * Do a quick check without holding jiffies_lock:
++	 * The READ_ONCE() pairs with two updates done later in this function.
+ 	 */
+-	delta = ktime_sub(now, last_jiffies_update);
++	delta = ktime_sub(now, READ_ONCE(last_jiffies_update));
+ 	if (delta < tick_period)
+ 		return;
+ 
+@@ -70,8 +71,9 @@ static void tick_do_update_jiffies64(ktime_t now)
+ 	if (delta >= tick_period) {
+ 
+ 		delta = ktime_sub(delta, tick_period);
+-		last_jiffies_update = ktime_add(last_jiffies_update,
+-						tick_period);
++		/* Pairs with the lockless read in this function. */
++		WRITE_ONCE(last_jiffies_update,
++			   ktime_add(last_jiffies_update, tick_period));
+ 
+ 		/* Slow path for long timeouts */
+ 		if (unlikely(delta >= tick_period)) {
+@@ -79,8 +81,10 @@ static void tick_do_update_jiffies64(ktime_t now)
+ 
+ 			ticks = ktime_divns(delta, incr);
+ 
+-			last_jiffies_update = ktime_add_ns(last_jiffies_update,
+-							   incr * ticks);
++			/* Pairs with the lockless read in this function. */
++			WRITE_ONCE(last_jiffies_update,
++				   ktime_add_ns(last_jiffies_update,
++						incr * ticks));
+ 		}
+ 		do_timer(++ticks);
+ 
+diff --git a/mm/huge_memory.c b/mm/huge_memory.c
+index 13cc93785006..1de7f53621a0 100644
+--- a/mm/huge_memory.c
++++ b/mm/huge_memory.c
+@@ -527,13 +527,13 @@ void prep_transhuge_page(struct page *page)
+ 	set_compound_page_dtor(page, TRANSHUGE_PAGE_DTOR);
+ }
+ 
+-static unsigned long __thp_get_unmapped_area(struct file *filp, unsigned long len,
++static unsigned long __thp_get_unmapped_area(struct file *filp,
++		unsigned long addr, unsigned long len,
+ 		loff_t off, unsigned long flags, unsigned long size)
+ {
+-	unsigned long addr;
+ 	loff_t off_end = off + len;
+ 	loff_t off_align = round_up(off, size);
+-	unsigned long len_pad;
++	unsigned long len_pad, ret;
+ 
+ 	if (off_end <= off_align || (off_end - off_align) < size)
+ 		return 0;
+@@ -542,30 +542,40 @@ static unsigned long __thp_get_unmapped_area(struct file *filp, unsigned long le
+ 	if (len_pad < len || (off + len_pad) < off)
+ 		return 0;
+ 
+-	addr = current->mm->get_unmapped_area(filp, 0, len_pad,
++	ret = current->mm->get_unmapped_area(filp, addr, len_pad,
+ 					      off >> PAGE_SHIFT, flags);
+-	if (IS_ERR_VALUE(addr))
++
++	/*
++	 * The failure might be due to length padding. The caller will retry
++	 * without the padding.
++	 */
++	if (IS_ERR_VALUE(ret))
+ 		return 0;
+ 
+-	addr += (off - addr) & (size - 1);
+-	return addr;
++	/*
++	 * Do not try to align to THP boundary if allocation at the address
++	 * hint succeeds.
++	 */
++	if (ret == addr)
++		return addr;
++
++	ret += (off - ret) & (size - 1);
++	return ret;
+ }
+ 
+ unsigned long thp_get_unmapped_area(struct file *filp, unsigned long addr,
+ 		unsigned long len, unsigned long pgoff, unsigned long flags)
+ {
++	unsigned long ret;
+ 	loff_t off = (loff_t)pgoff << PAGE_SHIFT;
+ 
+-	if (addr)
+-		goto out;
+ 	if (!IS_DAX(filp->f_mapping->host) || !IS_ENABLED(CONFIG_FS_DAX_PMD))
+ 		goto out;
+ 
+-	addr = __thp_get_unmapped_area(filp, len, off, flags, PMD_SIZE);
+-	if (addr)
+-		return addr;
+-
+- out:
++	ret = __thp_get_unmapped_area(filp, addr, len, off, flags, PMD_SIZE);
++	if (ret)
++		return ret;
++out:
+ 	return current->mm->get_unmapped_area(filp, addr, len, pgoff, flags);
+ }
+ EXPORT_SYMBOL_GPL(thp_get_unmapped_area);
+diff --git a/mm/memcontrol.c b/mm/memcontrol.c
+index 46ad252e6d6a..ef4e9eb572a4 100644
+--- a/mm/memcontrol.c
++++ b/mm/memcontrol.c
+@@ -3404,49 +3404,34 @@ static u64 mem_cgroup_read_u64(struct cgroup_subsys_state *css,
+ 	}
+ }
+ 
+-static void memcg_flush_percpu_vmstats(struct mem_cgroup *memcg, bool slab_only)
++static void memcg_flush_percpu_vmstats(struct mem_cgroup *memcg)
+ {
+-	unsigned long stat[MEMCG_NR_STAT];
++	unsigned long stat[MEMCG_NR_STAT] = {0};
+ 	struct mem_cgroup *mi;
+ 	int node, cpu, i;
+-	int min_idx, max_idx;
+-
+-	if (slab_only) {
+-		min_idx = NR_SLAB_RECLAIMABLE;
+-		max_idx = NR_SLAB_UNRECLAIMABLE;
+-	} else {
+-		min_idx = 0;
+-		max_idx = MEMCG_NR_STAT;
+-	}
+-
+-	for (i = min_idx; i < max_idx; i++)
+-		stat[i] = 0;
+ 
+ 	for_each_online_cpu(cpu)
+-		for (i = min_idx; i < max_idx; i++)
++		for (i = 0; i < MEMCG_NR_STAT; i++)
+ 			stat[i] += per_cpu(memcg->vmstats_percpu->stat[i], cpu);
+ 
+ 	for (mi = memcg; mi; mi = parent_mem_cgroup(mi))
+-		for (i = min_idx; i < max_idx; i++)
++		for (i = 0; i < MEMCG_NR_STAT; i++)
+ 			atomic_long_add(stat[i], &mi->vmstats[i]);
+ 
+-	if (!slab_only)
+-		max_idx = NR_VM_NODE_STAT_ITEMS;
+-
+ 	for_each_node(node) {
+ 		struct mem_cgroup_per_node *pn = memcg->nodeinfo[node];
+ 		struct mem_cgroup_per_node *pi;
+ 
+-		for (i = min_idx; i < max_idx; i++)
++		for (i = 0; i < NR_VM_NODE_STAT_ITEMS; i++)
+ 			stat[i] = 0;
+ 
+ 		for_each_online_cpu(cpu)
+-			for (i = min_idx; i < max_idx; i++)
++			for (i = 0; i < NR_VM_NODE_STAT_ITEMS; i++)
+ 				stat[i] += per_cpu(
+ 					pn->lruvec_stat_cpu->count[i], cpu);
+ 
+ 		for (pi = pn; pi; pi = parent_nodeinfo(pi, node))
+-			for (i = min_idx; i < max_idx; i++)
++			for (i = 0; i < NR_VM_NODE_STAT_ITEMS; i++)
+ 				atomic_long_add(stat[i], &pi->lruvec_stat[i]);
+ 	}
+ }
+@@ -3520,13 +3505,9 @@ static void memcg_offline_kmem(struct mem_cgroup *memcg)
+ 		parent = root_mem_cgroup;
+ 
+ 	/*
+-	 * Deactivate and reparent kmem_caches. Then flush percpu
+-	 * slab statistics to have precise values at the parent and
+-	 * all ancestor levels. It's required to keep slab stats
+-	 * accurate after the reparenting of kmem_caches.
++	 * Deactivate and reparent kmem_caches.
+ 	 */
+ 	memcg_deactivate_kmem_caches(memcg, parent);
+-	memcg_flush_percpu_vmstats(memcg, true);
+ 
+ 	kmemcg_id = memcg->kmemcg_id;
+ 	BUG_ON(kmemcg_id < 0);
+@@ -5037,7 +5018,7 @@ static void mem_cgroup_free(struct mem_cgroup *memcg)
+ 	 * Flush percpu vmstats and vmevents to guarantee the value correctness
+ 	 * on parent's and all ancestor levels.
+ 	 */
+-	memcg_flush_percpu_vmstats(memcg, false);
++	memcg_flush_percpu_vmstats(memcg);
+ 	memcg_flush_percpu_vmevents(memcg);
+ 	__mem_cgroup_free(memcg);
+ }
+diff --git a/mm/page-writeback.c b/mm/page-writeback.c
+index 50055d2e4ea8..2d658b208319 100644
+--- a/mm/page-writeback.c
++++ b/mm/page-writeback.c
+@@ -201,11 +201,11 @@ static void wb_min_max_ratio(struct bdi_writeback *wb,
+ 	if (this_bw < tot_bw) {
+ 		if (min) {
+ 			min *= this_bw;
+-			do_div(min, tot_bw);
++			min = div64_ul(min, tot_bw);
+ 		}
+ 		if (max < 100) {
+ 			max *= this_bw;
+-			do_div(max, tot_bw);
++			max = div64_ul(max, tot_bw);
+ 		}
+ 	}
+ 
+diff --git a/mm/page_alloc.c b/mm/page_alloc.c
+index f391c0c4ed1d..45e39131a716 100644
+--- a/mm/page_alloc.c
++++ b/mm/page_alloc.c
+@@ -694,34 +694,27 @@ void prep_compound_page(struct page *page, unsigned int order)
+ #ifdef CONFIG_DEBUG_PAGEALLOC
+ unsigned int _debug_guardpage_minorder;
+ 
+-#ifdef CONFIG_DEBUG_PAGEALLOC_ENABLE_DEFAULT
+-DEFINE_STATIC_KEY_TRUE(_debug_pagealloc_enabled);
+-#else
++bool _debug_pagealloc_enabled_early __read_mostly
++			= IS_ENABLED(CONFIG_DEBUG_PAGEALLOC_ENABLE_DEFAULT);
++EXPORT_SYMBOL(_debug_pagealloc_enabled_early);
+ DEFINE_STATIC_KEY_FALSE(_debug_pagealloc_enabled);
+-#endif
+ EXPORT_SYMBOL(_debug_pagealloc_enabled);
+ 
+ DEFINE_STATIC_KEY_FALSE(_debug_guardpage_enabled);
+ 
+ static int __init early_debug_pagealloc(char *buf)
+ {
+-	bool enable = false;
+-
+-	if (kstrtobool(buf, &enable))
+-		return -EINVAL;
+-
+-	if (enable)
+-		static_branch_enable(&_debug_pagealloc_enabled);
+-
+-	return 0;
++	return kstrtobool(buf, &_debug_pagealloc_enabled_early);
+ }
+ early_param("debug_pagealloc", early_debug_pagealloc);
+ 
+-static void init_debug_guardpage(void)
++void init_debug_pagealloc(void)
+ {
+ 	if (!debug_pagealloc_enabled())
+ 		return;
+ 
++	static_branch_enable(&_debug_pagealloc_enabled);
++
+ 	if (!debug_guardpage_minorder())
+ 		return;
+ 
+@@ -1186,7 +1179,7 @@ static __always_inline bool free_pages_prepare(struct page *page,
+ 	 */
+ 	arch_free_page(page, order);
+ 
+-	if (debug_pagealloc_enabled())
++	if (debug_pagealloc_enabled_static())
+ 		kernel_map_pages(page, 1 << order, 0);
+ 
+ 	kasan_free_nondeferred_pages(page, order);
+@@ -1207,7 +1200,7 @@ static bool free_pcp_prepare(struct page *page)
+ 
+ static bool bulkfree_pcp_prepare(struct page *page)
+ {
+-	if (debug_pagealloc_enabled())
++	if (debug_pagealloc_enabled_static())
+ 		return free_pages_check(page);
+ 	else
+ 		return false;
+@@ -1221,7 +1214,7 @@ static bool bulkfree_pcp_prepare(struct page *page)
+  */
+ static bool free_pcp_prepare(struct page *page)
+ {
+-	if (debug_pagealloc_enabled())
++	if (debug_pagealloc_enabled_static())
+ 		return free_pages_prepare(page, 0, true);
+ 	else
+ 		return free_pages_prepare(page, 0, false);
+@@ -1973,10 +1966,6 @@ void __init page_alloc_init_late(void)
+ 
+ 	for_each_populated_zone(zone)
+ 		set_zone_contiguous(zone);
+-
+-#ifdef CONFIG_DEBUG_PAGEALLOC
+-	init_debug_guardpage();
+-#endif
+ }
+ 
+ #ifdef CONFIG_CMA
+@@ -2106,7 +2095,7 @@ static inline bool free_pages_prezeroed(void)
+  */
+ static inline bool check_pcp_refill(struct page *page)
+ {
+-	if (debug_pagealloc_enabled())
++	if (debug_pagealloc_enabled_static())
+ 		return check_new_page(page);
+ 	else
+ 		return false;
+@@ -2128,7 +2117,7 @@ static inline bool check_pcp_refill(struct page *page)
+ }
+ static inline bool check_new_pcp(struct page *page)
+ {
+-	if (debug_pagealloc_enabled())
++	if (debug_pagealloc_enabled_static())
+ 		return check_new_page(page);
+ 	else
+ 		return false;
+@@ -2155,7 +2144,7 @@ inline void post_alloc_hook(struct page *page, unsigned int order,
+ 	set_page_refcounted(page);
+ 
+ 	arch_alloc_page(page, order);
+-	if (debug_pagealloc_enabled())
++	if (debug_pagealloc_enabled_static())
+ 		kernel_map_pages(page, 1 << order, 1);
+ 	kasan_alloc_pages(page, order);
+ 	kernel_poison_pages(page, 1 << order, 1);
+diff --git a/mm/shmem.c b/mm/shmem.c
+index 6074714fdbd4..312e31196720 100644
+--- a/mm/shmem.c
++++ b/mm/shmem.c
+@@ -2106,9 +2106,10 @@ unsigned long shmem_get_unmapped_area(struct file *file,
+ 	/*
+ 	 * Our priority is to support MAP_SHARED mapped hugely;
+ 	 * and support MAP_PRIVATE mapped hugely too, until it is COWed.
+-	 * But if caller specified an address hint, respect that as before.
++	 * But if caller specified an address hint and we allocated area there
++	 * successfully, respect that as before.
+ 	 */
+-	if (uaddr)
++	if (uaddr == addr)
+ 		return addr;
+ 
+ 	if (shmem_huge != SHMEM_HUGE_FORCE) {
+@@ -2142,7 +2143,7 @@ unsigned long shmem_get_unmapped_area(struct file *file,
+ 	if (inflated_len < len)
+ 		return addr;
+ 
+-	inflated_addr = get_area(NULL, 0, inflated_len, 0, flags);
++	inflated_addr = get_area(NULL, uaddr, inflated_len, 0, flags);
+ 	if (IS_ERR_VALUE(inflated_addr))
+ 		return addr;
+ 	if (inflated_addr & ~PAGE_MASK)
+diff --git a/mm/slab.c b/mm/slab.c
+index 66e5d8032bae..d1d7624cec4a 100644
+--- a/mm/slab.c
++++ b/mm/slab.c
+@@ -1415,7 +1415,7 @@ static void kmem_rcu_free(struct rcu_head *head)
+ #if DEBUG
+ static bool is_debug_pagealloc_cache(struct kmem_cache *cachep)
+ {
+-	if (debug_pagealloc_enabled() && OFF_SLAB(cachep) &&
++	if (debug_pagealloc_enabled_static() && OFF_SLAB(cachep) &&
+ 		(cachep->size % PAGE_SIZE) == 0)
+ 		return true;
+ 
+@@ -2007,7 +2007,7 @@ int __kmem_cache_create(struct kmem_cache *cachep, slab_flags_t flags)
+ 	 * to check size >= 256. It guarantees that all necessary small
+ 	 * sized slab is initialized in current slab initialization sequence.
+ 	 */
+-	if (debug_pagealloc_enabled() && (flags & SLAB_POISON) &&
++	if (debug_pagealloc_enabled_static() && (flags & SLAB_POISON) &&
+ 		size >= 256 && cachep->object_size > cache_line_size()) {
+ 		if (size < PAGE_SIZE || size % PAGE_SIZE == 0) {
+ 			size_t tmp_size = ALIGN(size, PAGE_SIZE);
+diff --git a/mm/slab_common.c b/mm/slab_common.c
+index 78402b362df9..ade6c257d4b4 100644
+--- a/mm/slab_common.c
++++ b/mm/slab_common.c
+@@ -903,7 +903,8 @@ static void flush_memcg_workqueue(struct kmem_cache *s)
+ 	 * deactivates the memcg kmem_caches through workqueue. Make sure all
+ 	 * previous workitems on workqueue are processed.
+ 	 */
+-	flush_workqueue(memcg_kmem_cache_wq);
++	if (likely(memcg_kmem_cache_wq))
++		flush_workqueue(memcg_kmem_cache_wq);
+ 
+ 	/*
+ 	 * If we're racing with children kmem_cache deactivation, it might
+diff --git a/mm/slub.c b/mm/slub.c
+index e72e802fc569..20d72cb20515 100644
+--- a/mm/slub.c
++++ b/mm/slub.c
+@@ -290,7 +290,7 @@ static inline void *get_freepointer_safe(struct kmem_cache *s, void *object)
+ 	unsigned long freepointer_addr;
+ 	void *p;
+ 
+-	if (!debug_pagealloc_enabled())
++	if (!debug_pagealloc_enabled_static())
+ 		return get_freepointer(s, object);
+ 
+ 	freepointer_addr = (unsigned long)object + s->offset;
+diff --git a/mm/sparse.c b/mm/sparse.c
+index c2c01b6330af..1100fdb9649c 100644
+--- a/mm/sparse.c
++++ b/mm/sparse.c
+@@ -775,7 +775,14 @@ static void section_deactivate(unsigned long pfn, unsigned long nr_pages,
+ 	if (bitmap_empty(subsection_map, SUBSECTIONS_PER_SECTION)) {
+ 		unsigned long section_nr = pfn_to_section_nr(pfn);
+ 
+-		if (!section_is_early) {
++		/*
++		 * When removing an early section, the usage map is kept (as the
++		 * usage maps of other sections fall into the same page). It
++		 * will be re-used when re-adding the section - which is then no
++		 * longer an early section. If the usage map is PageReserved, it
++		 * was allocated during boot.
++		 */
++		if (!PageReserved(virt_to_page(ms->usage))) {
+ 			kfree(ms->usage);
+ 			ms->usage = NULL;
+ 		}
+diff --git a/mm/vmalloc.c b/mm/vmalloc.c
+index a3c70e275f4e..61bdbaf20cde 100644
+--- a/mm/vmalloc.c
++++ b/mm/vmalloc.c
+@@ -1349,7 +1349,7 @@ static void free_unmap_vmap_area(struct vmap_area *va)
+ {
+ 	flush_cache_vunmap(va->va_start, va->va_end);
+ 	unmap_vmap_area(va);
+-	if (debug_pagealloc_enabled())
++	if (debug_pagealloc_enabled_static())
+ 		flush_tlb_kernel_range(va->va_start, va->va_end);
+ 
+ 	free_vmap_area_noflush(va);
+@@ -1647,7 +1647,7 @@ static void vb_free(const void *addr, unsigned long size)
+ 
+ 	vunmap_page_range((unsigned long)addr, (unsigned long)addr + size);
+ 
+-	if (debug_pagealloc_enabled())
++	if (debug_pagealloc_enabled_static())
+ 		flush_tlb_kernel_range((unsigned long)addr,
+ 					(unsigned long)addr + size);
+ 
+diff --git a/net/batman-adv/distributed-arp-table.c b/net/batman-adv/distributed-arp-table.c
+index b0af3a11d406..ec7bf5a4a9fc 100644
+--- a/net/batman-adv/distributed-arp-table.c
++++ b/net/batman-adv/distributed-arp-table.c
+@@ -285,6 +285,7 @@ static u32 batadv_hash_dat(const void *data, u32 size)
+ 	u32 hash = 0;
+ 	const struct batadv_dat_entry *dat = data;
+ 	const unsigned char *key;
++	__be16 vid;
+ 	u32 i;
+ 
+ 	key = (const unsigned char *)&dat->ip;
+@@ -294,7 +295,8 @@ static u32 batadv_hash_dat(const void *data, u32 size)
+ 		hash ^= (hash >> 6);
+ 	}
+ 
+-	key = (const unsigned char *)&dat->vid;
++	vid = htons(dat->vid);
++	key = (__force const unsigned char *)&vid;
+ 	for (i = 0; i < sizeof(dat->vid); i++) {
+ 		hash += key[i];
+ 		hash += (hash << 10);
+diff --git a/net/core/dev.c b/net/core/dev.c
+index 3e11c6bb4dd6..3098c90d60e2 100644
+--- a/net/core/dev.c
++++ b/net/core/dev.c
+@@ -8953,22 +8953,10 @@ static void netdev_unregister_lockdep_key(struct net_device *dev)
+ 
+ void netdev_update_lockdep_key(struct net_device *dev)
+ {
+-	struct netdev_queue *queue;
+-	int i;
+-
+-	lockdep_unregister_key(&dev->qdisc_xmit_lock_key);
+ 	lockdep_unregister_key(&dev->addr_list_lock_key);
+-
+-	lockdep_register_key(&dev->qdisc_xmit_lock_key);
+ 	lockdep_register_key(&dev->addr_list_lock_key);
+ 
+ 	lockdep_set_class(&dev->addr_list_lock, &dev->addr_list_lock_key);
+-	for (i = 0; i < dev->num_tx_queues; i++) {
+-		queue = netdev_get_tx_queue(dev, i);
+-
+-		lockdep_set_class(&queue->_xmit_lock,
+-				  &dev->qdisc_xmit_lock_key);
+-	}
+ }
+ EXPORT_SYMBOL(netdev_update_lockdep_key);
+ 
+diff --git a/net/core/devlink.c b/net/core/devlink.c
+index 93905dc7c179..ae614965c8c2 100644
+--- a/net/core/devlink.c
++++ b/net/core/devlink.c
+@@ -6280,7 +6280,7 @@ static bool devlink_port_type_should_warn(struct devlink_port *devlink_port)
+ 	       devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_DSA;
+ }
+ 
+-#define DEVLINK_PORT_TYPE_WARN_TIMEOUT (HZ * 30)
++#define DEVLINK_PORT_TYPE_WARN_TIMEOUT (HZ * 3600)
+ 
+ static void devlink_port_type_warn_schedule(struct devlink_port *devlink_port)
+ {
+diff --git a/net/core/filter.c b/net/core/filter.c
+index 2f76461c120d..1a78d64096bb 100644
+--- a/net/core/filter.c
++++ b/net/core/filter.c
+@@ -2231,10 +2231,10 @@ BPF_CALL_4(bpf_msg_pull_data, struct sk_msg *, msg, u32, start,
+ 	/* First find the starting scatterlist element */
+ 	i = msg->sg.start;
+ 	do {
++		offset += len;
+ 		len = sk_msg_elem(msg, i)->length;
+ 		if (start < offset + len)
+ 			break;
+-		offset += len;
+ 		sk_msg_iter_var_next(i);
+ 	} while (i != msg->sg.end);
+ 
+@@ -2346,7 +2346,7 @@ BPF_CALL_4(bpf_msg_push_data, struct sk_msg *, msg, u32, start,
+ 	   u32, len, u64, flags)
+ {
+ 	struct scatterlist sge, nsge, nnsge, rsge = {0}, *psge;
+-	u32 new, i = 0, l, space, copy = 0, offset = 0;
++	u32 new, i = 0, l = 0, space, copy = 0, offset = 0;
+ 	u8 *raw, *to, *from;
+ 	struct page *page;
+ 
+@@ -2356,11 +2356,11 @@ BPF_CALL_4(bpf_msg_push_data, struct sk_msg *, msg, u32, start,
+ 	/* First find the starting scatterlist element */
+ 	i = msg->sg.start;
+ 	do {
++		offset += l;
+ 		l = sk_msg_elem(msg, i)->length;
+ 
+ 		if (start < offset + l)
+ 			break;
+-		offset += l;
+ 		sk_msg_iter_var_next(i);
+ 	} while (i != msg->sg.end);
+ 
+@@ -2415,6 +2415,7 @@ BPF_CALL_4(bpf_msg_push_data, struct sk_msg *, msg, u32, start,
+ 
+ 		sk_msg_iter_var_next(i);
+ 		sg_unmark_end(psge);
++		sg_unmark_end(&rsge);
+ 		sk_msg_iter_next(msg, end);
+ 	}
+ 
+@@ -2506,7 +2507,7 @@ static void sk_msg_shift_right(struct sk_msg *msg, int i)
+ BPF_CALL_4(bpf_msg_pop_data, struct sk_msg *, msg, u32, start,
+ 	   u32, len, u64, flags)
+ {
+-	u32 i = 0, l, space, offset = 0;
++	u32 i = 0, l = 0, space, offset = 0;
+ 	u64 last = start + len;
+ 	int pop;
+ 
+@@ -2516,11 +2517,11 @@ BPF_CALL_4(bpf_msg_pop_data, struct sk_msg *, msg, u32, start,
+ 	/* First find the starting scatterlist element */
+ 	i = msg->sg.start;
+ 	do {
++		offset += l;
+ 		l = sk_msg_elem(msg, i)->length;
+ 
+ 		if (start < offset + l)
+ 			break;
+-		offset += l;
+ 		sk_msg_iter_var_next(i);
+ 	} while (i != msg->sg.end);
+ 
+@@ -5305,8 +5306,7 @@ __bpf_sk_lookup(struct sk_buff *skb, struct bpf_sock_tuple *tuple, u32 len,
+ 	if (sk) {
+ 		sk = sk_to_full_sk(sk);
+ 		if (!sk_fullsock(sk)) {
+-			if (!sock_flag(sk, SOCK_RCU_FREE))
+-				sock_gen_put(sk);
++			sock_gen_put(sk);
+ 			return NULL;
+ 		}
+ 	}
+@@ -5343,8 +5343,7 @@ bpf_sk_lookup(struct sk_buff *skb, struct bpf_sock_tuple *tuple, u32 len,
+ 	if (sk) {
+ 		sk = sk_to_full_sk(sk);
+ 		if (!sk_fullsock(sk)) {
+-			if (!sock_flag(sk, SOCK_RCU_FREE))
+-				sock_gen_put(sk);
++			sock_gen_put(sk);
+ 			return NULL;
+ 		}
+ 	}
+@@ -5411,7 +5410,8 @@ static const struct bpf_func_proto bpf_sk_lookup_udp_proto = {
+ 
+ BPF_CALL_1(bpf_sk_release, struct sock *, sk)
+ {
+-	if (!sock_flag(sk, SOCK_RCU_FREE))
++	/* Only full sockets have sk->sk_flags. */
++	if (!sk_fullsock(sk) || !sock_flag(sk, SOCK_RCU_FREE))
+ 		sock_gen_put(sk);
+ 	return 0;
+ }
+diff --git a/net/core/skmsg.c b/net/core/skmsg.c
+index ded2d5227678..3866d7e20c07 100644
+--- a/net/core/skmsg.c
++++ b/net/core/skmsg.c
+@@ -594,6 +594,8 @@ EXPORT_SYMBOL_GPL(sk_psock_destroy);
+ 
+ void sk_psock_drop(struct sock *sk, struct sk_psock *psock)
+ {
++	sock_owned_by_me(sk);
++
+ 	sk_psock_cork_free(psock);
+ 	sk_psock_zap_ingress(psock);
+ 
+diff --git a/net/core/sock_map.c b/net/core/sock_map.c
+index eb114ee419b6..8998e356f423 100644
+--- a/net/core/sock_map.c
++++ b/net/core/sock_map.c
+@@ -241,8 +241,11 @@ static void sock_map_free(struct bpf_map *map)
+ 		struct sock *sk;
+ 
+ 		sk = xchg(psk, NULL);
+-		if (sk)
++		if (sk) {
++			lock_sock(sk);
+ 			sock_map_unref(sk, psk);
++			release_sock(sk);
++		}
+ 	}
+ 	raw_spin_unlock_bh(&stab->lock);
+ 	rcu_read_unlock();
+@@ -862,7 +865,9 @@ static void sock_hash_free(struct bpf_map *map)
+ 		raw_spin_lock_bh(&bucket->lock);
+ 		hlist_for_each_entry_safe(elem, node, &bucket->head, node) {
+ 			hlist_del_rcu(&elem->node);
++			lock_sock(elem->sk);
+ 			sock_map_unref(elem->sk, elem);
++			release_sock(elem->sk);
+ 		}
+ 		raw_spin_unlock_bh(&bucket->lock);
+ 	}
+diff --git a/net/dsa/tag_gswip.c b/net/dsa/tag_gswip.c
+index b678160bbd66..408d4af390a0 100644
+--- a/net/dsa/tag_gswip.c
++++ b/net/dsa/tag_gswip.c
+@@ -104,7 +104,7 @@ static struct sk_buff *gswip_tag_rcv(struct sk_buff *skb,
+ }
+ 
+ static const struct dsa_device_ops gswip_netdev_ops = {
+-	.name = "gwsip",
++	.name = "gswip",
+ 	.proto	= DSA_TAG_PROTO_GSWIP,
+ 	.xmit = gswip_tag_xmit,
+ 	.rcv = gswip_tag_rcv,
+diff --git a/net/dsa/tag_qca.c b/net/dsa/tag_qca.c
+index c95885215525..c8a128c9e5e0 100644
+--- a/net/dsa/tag_qca.c
++++ b/net/dsa/tag_qca.c
+@@ -33,9 +33,6 @@ static struct sk_buff *qca_tag_xmit(struct sk_buff *skb, struct net_device *dev)
+ 	struct dsa_port *dp = dsa_slave_to_port(dev);
+ 	u16 *phdr, hdr;
+ 
+-	dev->stats.tx_packets++;
+-	dev->stats.tx_bytes += skb->len;
+-
+ 	if (skb_cow_head(skb, 0) < 0)
+ 		return NULL;
+ 
+diff --git a/net/ipv4/netfilter/arp_tables.c b/net/ipv4/netfilter/arp_tables.c
+index 069f72edb264..f1f78a742b36 100644
+--- a/net/ipv4/netfilter/arp_tables.c
++++ b/net/ipv4/netfilter/arp_tables.c
+@@ -496,12 +496,13 @@ static inline int check_entry_size_and_hooks(struct arpt_entry *e,
+ 	return 0;
+ }
+ 
+-static inline void cleanup_entry(struct arpt_entry *e)
++static void cleanup_entry(struct arpt_entry *e, struct net *net)
+ {
+ 	struct xt_tgdtor_param par;
+ 	struct xt_entry_target *t;
+ 
+ 	t = arpt_get_target(e);
++	par.net      = net;
+ 	par.target   = t->u.kernel.target;
+ 	par.targinfo = t->data;
+ 	par.family   = NFPROTO_ARP;
+@@ -584,7 +585,7 @@ static int translate_table(struct net *net,
+ 		xt_entry_foreach(iter, entry0, newinfo->size) {
+ 			if (i-- == 0)
+ 				break;
+-			cleanup_entry(iter);
++			cleanup_entry(iter, net);
+ 		}
+ 		return ret;
+ 	}
+@@ -927,7 +928,7 @@ static int __do_replace(struct net *net, const char *name,
+ 	/* Decrease module usage counts and free resource */
+ 	loc_cpu_old_entry = oldinfo->entries;
+ 	xt_entry_foreach(iter, loc_cpu_old_entry, oldinfo->size)
+-		cleanup_entry(iter);
++		cleanup_entry(iter, net);
+ 
+ 	xt_free_table_info(oldinfo);
+ 	if (copy_to_user(counters_ptr, counters,
+@@ -990,7 +991,7 @@ static int do_replace(struct net *net, const void __user *user,
+ 
+  free_newinfo_untrans:
+ 	xt_entry_foreach(iter, loc_cpu_entry, newinfo->size)
+-		cleanup_entry(iter);
++		cleanup_entry(iter, net);
+  free_newinfo:
+ 	xt_free_table_info(newinfo);
+ 	return ret;
+@@ -1287,7 +1288,7 @@ static int compat_do_replace(struct net *net, void __user *user,
+ 
+  free_newinfo_untrans:
+ 	xt_entry_foreach(iter, loc_cpu_entry, newinfo->size)
+-		cleanup_entry(iter);
++		cleanup_entry(iter, net);
+  free_newinfo:
+ 	xt_free_table_info(newinfo);
+ 	return ret;
+@@ -1514,7 +1515,7 @@ static int do_arpt_get_ctl(struct sock *sk, int cmd, void __user *user, int *len
+ 	return ret;
+ }
+ 
+-static void __arpt_unregister_table(struct xt_table *table)
++static void __arpt_unregister_table(struct net *net, struct xt_table *table)
+ {
+ 	struct xt_table_info *private;
+ 	void *loc_cpu_entry;
+@@ -1526,7 +1527,7 @@ static void __arpt_unregister_table(struct xt_table *table)
+ 	/* Decrease module usage counts and free resources */
+ 	loc_cpu_entry = private->entries;
+ 	xt_entry_foreach(iter, loc_cpu_entry, private->size)
+-		cleanup_entry(iter);
++		cleanup_entry(iter, net);
+ 	if (private->number > private->initial_entries)
+ 		module_put(table_owner);
+ 	xt_free_table_info(private);
+@@ -1566,7 +1567,7 @@ int arpt_register_table(struct net *net,
+ 
+ 	ret = nf_register_net_hooks(net, ops, hweight32(table->valid_hooks));
+ 	if (ret != 0) {
+-		__arpt_unregister_table(new_table);
++		__arpt_unregister_table(net, new_table);
+ 		*res = NULL;
+ 	}
+ 
+@@ -1581,7 +1582,7 @@ void arpt_unregister_table(struct net *net, struct xt_table *table,
+ 			   const struct nf_hook_ops *ops)
+ {
+ 	nf_unregister_net_hooks(net, ops, hweight32(table->valid_hooks));
+-	__arpt_unregister_table(table);
++	__arpt_unregister_table(net, table);
+ }
+ 
+ /* The built-in targets: standard (NULL) and error. */
+diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
+index e537a4b6531b..84115577d3dc 100644
+--- a/net/ipv4/tcp.c
++++ b/net/ipv4/tcp.c
+@@ -1087,8 +1087,7 @@ do_error:
+ 		goto out;
+ out_err:
+ 	/* make sure we wake any epoll edge trigger waiter */
+-	if (unlikely(skb_queue_len(&sk->sk_write_queue) == 0 &&
+-		     err == -EAGAIN)) {
++	if (unlikely(tcp_rtx_and_write_queues_empty(sk) && err == -EAGAIN)) {
+ 		sk->sk_write_space(sk);
+ 		tcp_chrono_stop(sk, TCP_CHRONO_SNDBUF_LIMITED);
+ 	}
+@@ -1419,8 +1418,7 @@ out_err:
+ 	sock_zerocopy_put_abort(uarg, true);
+ 	err = sk_stream_error(sk, flags, err);
+ 	/* make sure we wake any epoll edge trigger waiter */
+-	if (unlikely(skb_queue_len(&sk->sk_write_queue) == 0 &&
+-		     err == -EAGAIN)) {
++	if (unlikely(tcp_rtx_and_write_queues_empty(sk) && err == -EAGAIN)) {
+ 		sk->sk_write_space(sk);
+ 		tcp_chrono_stop(sk, TCP_CHRONO_SNDBUF_LIMITED);
+ 	}
+diff --git a/net/ipv4/tcp_bpf.c b/net/ipv4/tcp_bpf.c
+index e38705165ac9..8a01428f80c1 100644
+--- a/net/ipv4/tcp_bpf.c
++++ b/net/ipv4/tcp_bpf.c
+@@ -121,14 +121,14 @@ int tcp_bpf_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
+ 	struct sk_psock *psock;
+ 	int copied, ret;
+ 
+-	if (unlikely(flags & MSG_ERRQUEUE))
+-		return inet_recv_error(sk, msg, len, addr_len);
+-	if (!skb_queue_empty(&sk->sk_receive_queue))
+-		return tcp_recvmsg(sk, msg, len, nonblock, flags, addr_len);
+-
+ 	psock = sk_psock_get(sk);
+ 	if (unlikely(!psock))
+ 		return tcp_recvmsg(sk, msg, len, nonblock, flags, addr_len);
++	if (unlikely(flags & MSG_ERRQUEUE))
++		return inet_recv_error(sk, msg, len, addr_len);
++	if (!skb_queue_empty(&sk->sk_receive_queue) &&
++	    sk_psock_queue_empty(psock))
++		return tcp_recvmsg(sk, msg, len, nonblock, flags, addr_len);
+ 	lock_sock(sk);
+ msg_bytes_ready:
+ 	copied = __tcp_bpf_recvmsg(sk, psock, msg, len, flags);
+@@ -139,7 +139,7 @@ msg_bytes_ready:
+ 		timeo = sock_rcvtimeo(sk, nonblock);
+ 		data = tcp_bpf_wait_data(sk, psock, flags, timeo, &err);
+ 		if (data) {
+-			if (skb_queue_empty(&sk->sk_receive_queue))
++			if (!sk_psock_queue_empty(psock))
+ 				goto msg_bytes_ready;
+ 			release_sock(sk);
+ 			sk_psock_put(sk, psock);
+@@ -315,10 +315,7 @@ more_data:
+ 		 */
+ 		delta = msg->sg.size;
+ 		psock->eval = sk_psock_msg_verdict(sk, psock, msg);
+-		if (msg->sg.size < delta)
+-			delta -= msg->sg.size;
+-		else
+-			delta = 0;
++		delta -= msg->sg.size;
+ 	}
+ 
+ 	if (msg->cork_bytes &&
+diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
+index 67e44e6717b0..59b78ce2ce2e 100644
+--- a/net/ipv4/tcp_input.c
++++ b/net/ipv4/tcp_input.c
+@@ -915,9 +915,10 @@ static void tcp_check_sack_reordering(struct sock *sk, const u32 low_seq,
+ /* This must be called before lost_out is incremented */
+ static void tcp_verify_retransmit_hint(struct tcp_sock *tp, struct sk_buff *skb)
+ {
+-	if (!tp->retransmit_skb_hint ||
+-	    before(TCP_SKB_CB(skb)->seq,
+-		   TCP_SKB_CB(tp->retransmit_skb_hint)->seq))
++	if ((!tp->retransmit_skb_hint && tp->retrans_out >= tp->lost_out) ||
++	    (tp->retransmit_skb_hint &&
++	     before(TCP_SKB_CB(skb)->seq,
++		    TCP_SKB_CB(tp->retransmit_skb_hint)->seq)))
+ 		tp->retransmit_skb_hint = skb;
+ }
+ 
+diff --git a/net/ipv4/tcp_ulp.c b/net/ipv4/tcp_ulp.c
+index 4849edb62d52..9168645b760e 100644
+--- a/net/ipv4/tcp_ulp.c
++++ b/net/ipv4/tcp_ulp.c
+@@ -96,17 +96,19 @@ void tcp_get_available_ulp(char *buf, size_t maxlen)
+ 	rcu_read_unlock();
+ }
+ 
+-void tcp_update_ulp(struct sock *sk, struct proto *proto)
++void tcp_update_ulp(struct sock *sk, struct proto *proto,
++		    void (*write_space)(struct sock *sk))
+ {
+ 	struct inet_connection_sock *icsk = inet_csk(sk);
+ 
+ 	if (!icsk->icsk_ulp_ops) {
++		sk->sk_write_space = write_space;
+ 		sk->sk_prot = proto;
+ 		return;
+ 	}
+ 
+ 	if (icsk->icsk_ulp_ops->update)
+-		icsk->icsk_ulp_ops->update(sk, proto);
++		icsk->icsk_ulp_ops->update(sk, proto, write_space);
+ }
+ 
+ void tcp_cleanup_ulp(struct sock *sk)
+diff --git a/net/netfilter/ipset/ip_set_bitmap_gen.h b/net/netfilter/ipset/ip_set_bitmap_gen.h
+index 063df74b4647..e1f271a1b2c1 100644
+--- a/net/netfilter/ipset/ip_set_bitmap_gen.h
++++ b/net/netfilter/ipset/ip_set_bitmap_gen.h
+@@ -60,9 +60,9 @@ mtype_destroy(struct ip_set *set)
+ 	if (SET_WITH_TIMEOUT(set))
+ 		del_timer_sync(&map->gc);
+ 
+-	ip_set_free(map->members);
+ 	if (set->dsize && set->extensions & IPSET_EXT_DESTROY)
+ 		mtype_ext_cleanup(set);
++	ip_set_free(map->members);
+ 	ip_set_free(map);
+ 
+ 	set->data = NULL;
+diff --git a/net/netfilter/nf_nat_proto.c b/net/netfilter/nf_nat_proto.c
+index 0a59c14b5177..64eedc17037a 100644
+--- a/net/netfilter/nf_nat_proto.c
++++ b/net/netfilter/nf_nat_proto.c
+@@ -233,6 +233,19 @@ icmp_manip_pkt(struct sk_buff *skb,
+ 		return false;
+ 
+ 	hdr = (struct icmphdr *)(skb->data + hdroff);
++	switch (hdr->type) {
++	case ICMP_ECHO:
++	case ICMP_ECHOREPLY:
++	case ICMP_TIMESTAMP:
++	case ICMP_TIMESTAMPREPLY:
++	case ICMP_INFO_REQUEST:
++	case ICMP_INFO_REPLY:
++	case ICMP_ADDRESS:
++	case ICMP_ADDRESSREPLY:
++		break;
++	default:
++		return true;
++	}
+ 	inet_proto_csum_replace2(&hdr->checksum, skb,
+ 				 hdr->un.echo.id, tuple->src.u.icmp.id, false);
+ 	hdr->un.echo.id = tuple->src.u.icmp.id;
+diff --git a/net/netfilter/nf_tables_api.c b/net/netfilter/nf_tables_api.c
+index 67ca47c7ce54..9fefd0150091 100644
+--- a/net/netfilter/nf_tables_api.c
++++ b/net/netfilter/nf_tables_api.c
+@@ -22,6 +22,8 @@
+ #include <net/net_namespace.h>
+ #include <net/sock.h>
+ 
++#define NFT_MODULE_AUTOLOAD_LIMIT (MODULE_NAME_LEN - sizeof("nft-expr-255-"))
++
+ static LIST_HEAD(nf_tables_expressions);
+ static LIST_HEAD(nf_tables_objects);
+ static LIST_HEAD(nf_tables_flowtables);
+@@ -500,33 +502,34 @@ __nf_tables_chain_type_lookup(const struct nlattr *nla, u8 family)
+ }
+ 
+ /*
+- * Loading a module requires dropping mutex that guards the
+- * transaction.
+- * We first need to abort any pending transactions as once
+- * mutex is unlocked a different client could start a new
+- * transaction.  It must not see any 'future generation'
+- * changes * as these changes will never happen.
++ * Loading a module requires dropping mutex that guards the transaction.
++ * A different client might race to start a new transaction meanwhile. Zap the
++ * list of pending transaction and then restore it once the mutex is grabbed
++ * again. Users of this function return EAGAIN which implicitly triggers the
++ * transaction abort path to clean up the list of pending transactions.
+  */
+ #ifdef CONFIG_MODULES
+-static int __nf_tables_abort(struct net *net);
+-
+ static void nft_request_module(struct net *net, const char *fmt, ...)
+ {
+ 	char module_name[MODULE_NAME_LEN];
++	LIST_HEAD(commit_list);
+ 	va_list args;
+ 	int ret;
+ 
+-	__nf_tables_abort(net);
++	list_splice_init(&net->nft.commit_list, &commit_list);
+ 
+ 	va_start(args, fmt);
+ 	ret = vsnprintf(module_name, MODULE_NAME_LEN, fmt, args);
+ 	va_end(args);
+-	if (WARN(ret >= MODULE_NAME_LEN, "truncated: '%s' (len %d)", module_name, ret))
++	if (ret >= MODULE_NAME_LEN)
+ 		return;
+ 
+ 	mutex_unlock(&net->nft.commit_mutex);
+ 	request_module("%s", module_name);
+ 	mutex_lock(&net->nft.commit_mutex);
++
++	WARN_ON_ONCE(!list_empty(&net->nft.commit_list));
++	list_splice(&commit_list, &net->nft.commit_list);
+ }
+ #endif
+ 
+@@ -978,12 +981,18 @@ static int nft_flush_table(struct nft_ctx *ctx)
+ 	}
+ 
+ 	list_for_each_entry_safe(flowtable, nft, &ctx->table->flowtables, list) {
++		if (!nft_is_active_next(ctx->net, flowtable))
++			continue;
++
+ 		err = nft_delflowtable(ctx, flowtable);
+ 		if (err < 0)
+ 			goto out;
+ 	}
+ 
+ 	list_for_each_entry_safe(obj, ne, &ctx->table->objects, list) {
++		if (!nft_is_active_next(ctx->net, obj))
++			continue;
++
+ 		err = nft_delobj(ctx, obj);
+ 		if (err < 0)
+ 			goto out;
+@@ -1174,7 +1183,8 @@ static const struct nla_policy nft_chain_policy[NFTA_CHAIN_MAX + 1] = {
+ 				    .len = NFT_CHAIN_MAXNAMELEN - 1 },
+ 	[NFTA_CHAIN_HOOK]	= { .type = NLA_NESTED },
+ 	[NFTA_CHAIN_POLICY]	= { .type = NLA_U32 },
+-	[NFTA_CHAIN_TYPE]	= { .type = NLA_STRING },
++	[NFTA_CHAIN_TYPE]	= { .type = NLA_STRING,
++				    .len = NFT_MODULE_AUTOLOAD_LIMIT },
+ 	[NFTA_CHAIN_COUNTERS]	= { .type = NLA_NESTED },
+ 	[NFTA_CHAIN_FLAGS]	= { .type = NLA_U32 },
+ };
+@@ -2088,7 +2098,8 @@ static const struct nft_expr_type *nft_expr_type_get(struct net *net,
+ }
+ 
+ static const struct nla_policy nft_expr_policy[NFTA_EXPR_MAX + 1] = {
+-	[NFTA_EXPR_NAME]	= { .type = NLA_STRING },
++	[NFTA_EXPR_NAME]	= { .type = NLA_STRING,
++				    .len = NFT_MODULE_AUTOLOAD_LIMIT },
+ 	[NFTA_EXPR_DATA]	= { .type = NLA_NESTED },
+ };
+ 
+@@ -3931,7 +3942,8 @@ static const struct nla_policy nft_set_elem_policy[NFTA_SET_ELEM_MAX + 1] = {
+ 	[NFTA_SET_ELEM_USERDATA]	= { .type = NLA_BINARY,
+ 					    .len = NFT_USERDATA_MAXLEN },
+ 	[NFTA_SET_ELEM_EXPR]		= { .type = NLA_NESTED },
+-	[NFTA_SET_ELEM_OBJREF]		= { .type = NLA_STRING },
++	[NFTA_SET_ELEM_OBJREF]		= { .type = NLA_STRING,
++					    .len = NFT_OBJ_MAXNAMELEN - 1 },
+ };
+ 
+ static const struct nla_policy nft_set_elem_list_policy[NFTA_SET_ELEM_LIST_MAX + 1] = {
+diff --git a/net/netfilter/nft_tunnel.c b/net/netfilter/nft_tunnel.c
+index 3d4c2ae605a8..5284fcf16be7 100644
+--- a/net/netfilter/nft_tunnel.c
++++ b/net/netfilter/nft_tunnel.c
+@@ -76,7 +76,7 @@ static int nft_tunnel_get_init(const struct nft_ctx *ctx,
+ 	struct nft_tunnel *priv = nft_expr_priv(expr);
+ 	u32 len;
+ 
+-	if (!tb[NFTA_TUNNEL_KEY] &&
++	if (!tb[NFTA_TUNNEL_KEY] ||
+ 	    !tb[NFTA_TUNNEL_DREG])
+ 		return -EINVAL;
+ 
+@@ -266,6 +266,9 @@ static int nft_tunnel_obj_erspan_init(const struct nlattr *attr,
+ 	if (err < 0)
+ 		return err;
+ 
++	if (!tb[NFTA_TUNNEL_KEY_ERSPAN_VERSION])
++		 return -EINVAL;
++
+ 	version = ntohl(nla_get_be32(tb[NFTA_TUNNEL_KEY_ERSPAN_VERSION]));
+ 	switch (version) {
+ 	case ERSPAN_VERSION:
+diff --git a/net/sched/act_ctinfo.c b/net/sched/act_ctinfo.c
+index 0dbcfd1dca7b..f45995a6237a 100644
+--- a/net/sched/act_ctinfo.c
++++ b/net/sched/act_ctinfo.c
+@@ -360,6 +360,16 @@ static int tcf_ctinfo_search(struct net *net, struct tc_action **a, u32 index)
+ 	return tcf_idr_search(tn, a, index);
+ }
+ 
++static void tcf_ctinfo_cleanup(struct tc_action *a)
++{
++	struct tcf_ctinfo *ci = to_ctinfo(a);
++	struct tcf_ctinfo_params *cp;
++
++	cp = rcu_dereference_protected(ci->params, 1);
++	if (cp)
++		kfree_rcu(cp, rcu);
++}
++
+ static struct tc_action_ops act_ctinfo_ops = {
+ 	.kind	= "ctinfo",
+ 	.id	= TCA_ID_CTINFO,
+@@ -367,6 +377,7 @@ static struct tc_action_ops act_ctinfo_ops = {
+ 	.act	= tcf_ctinfo_act,
+ 	.dump	= tcf_ctinfo_dump,
+ 	.init	= tcf_ctinfo_init,
++	.cleanup= tcf_ctinfo_cleanup,
+ 	.walk	= tcf_ctinfo_walker,
+ 	.lookup	= tcf_ctinfo_search,
+ 	.size	= sizeof(struct tcf_ctinfo),
+diff --git a/net/sched/act_ife.c b/net/sched/act_ife.c
+index 3a31e241c647..a0cfb4793c93 100644
+--- a/net/sched/act_ife.c
++++ b/net/sched/act_ife.c
+@@ -536,6 +536,9 @@ static int tcf_ife_init(struct net *net, struct nlattr *nla,
+ 	}
+ 
+ 	ife = to_ife(*a);
++	if (ret == ACT_P_CREATED)
++		INIT_LIST_HEAD(&ife->metalist);
++
+ 	err = tcf_action_check_ctrlact(parm->action, tp, &goto_ch, extack);
+ 	if (err < 0)
+ 		goto release_idr;
+@@ -565,10 +568,6 @@ static int tcf_ife_init(struct net *net, struct nlattr *nla,
+ 		p->eth_type = ife_type;
+ 	}
+ 
+-
+-	if (ret == ACT_P_CREATED)
+-		INIT_LIST_HEAD(&ife->metalist);
+-
+ 	if (tb[TCA_IFE_METALST]) {
+ 		err = nla_parse_nested_deprecated(tb2, IFE_META_MAX,
+ 						  tb[TCA_IFE_METALST], NULL,
+diff --git a/net/tipc/bcast.c b/net/tipc/bcast.c
+index 6ef1abdd525f..885ecf6ea65a 100644
+--- a/net/tipc/bcast.c
++++ b/net/tipc/bcast.c
+@@ -305,17 +305,17 @@ static int tipc_rcast_xmit(struct net *net, struct sk_buff_head *pkts,
+  * @skb: socket buffer to copy
+  * @method: send method to be used
+  * @dests: destination nodes for message.
+- * @cong_link_cnt: returns number of encountered congested destination links
+  * Returns 0 if success, otherwise errno
+  */
+ static int tipc_mcast_send_sync(struct net *net, struct sk_buff *skb,
+ 				struct tipc_mc_method *method,
+-				struct tipc_nlist *dests,
+-				u16 *cong_link_cnt)
++				struct tipc_nlist *dests)
+ {
+ 	struct tipc_msg *hdr, *_hdr;
+ 	struct sk_buff_head tmpq;
+ 	struct sk_buff *_skb;
++	u16 cong_link_cnt;
++	int rc = 0;
+ 
+ 	/* Is a cluster supporting with new capabilities ? */
+ 	if (!(tipc_net(net)->capabilities & TIPC_MCAST_RBCTL))
+@@ -343,18 +343,19 @@ static int tipc_mcast_send_sync(struct net *net, struct sk_buff *skb,
+ 	_hdr = buf_msg(_skb);
+ 	msg_set_size(_hdr, MCAST_H_SIZE);
+ 	msg_set_is_rcast(_hdr, !msg_is_rcast(hdr));
++	msg_set_errcode(_hdr, TIPC_ERR_NO_PORT);
+ 
+ 	__skb_queue_head_init(&tmpq);
+ 	__skb_queue_tail(&tmpq, _skb);
+ 	if (method->rcast)
+-		tipc_bcast_xmit(net, &tmpq, cong_link_cnt);
++		rc = tipc_bcast_xmit(net, &tmpq, &cong_link_cnt);
+ 	else
+-		tipc_rcast_xmit(net, &tmpq, dests, cong_link_cnt);
++		rc = tipc_rcast_xmit(net, &tmpq, dests, &cong_link_cnt);
+ 
+ 	/* This queue should normally be empty by now */
+ 	__skb_queue_purge(&tmpq);
+ 
+-	return 0;
++	return rc;
+ }
+ 
+ /* tipc_mcast_xmit - deliver message to indicated destination nodes
+@@ -396,9 +397,14 @@ int tipc_mcast_xmit(struct net *net, struct sk_buff_head *pkts,
+ 		msg_set_is_rcast(hdr, method->rcast);
+ 
+ 		/* Switch method ? */
+-		if (rcast != method->rcast)
+-			tipc_mcast_send_sync(net, skb, method,
+-					     dests, cong_link_cnt);
++		if (rcast != method->rcast) {
++			rc = tipc_mcast_send_sync(net, skb, method, dests);
++			if (unlikely(rc)) {
++				pr_err("Unable to send SYN: method %d, rc %d\n",
++				       rcast, rc);
++				goto exit;
++			}
++		}
+ 
+ 		if (method->rcast)
+ 			rc = tipc_rcast_xmit(net, pkts, dests, cong_link_cnt);
+diff --git a/net/tipc/socket.c b/net/tipc/socket.c
+index 4b92b196cfa6..79d06c21ebe3 100644
+--- a/net/tipc/socket.c
++++ b/net/tipc/socket.c
+@@ -1306,8 +1306,8 @@ static int __tipc_sendmsg(struct socket *sock, struct msghdr *m, size_t dlen)
+ 	struct tipc_msg *hdr = &tsk->phdr;
+ 	struct tipc_name_seq *seq;
+ 	struct sk_buff_head pkts;
+-	u32 dport, dnode = 0;
+-	u32 type, inst;
++	u32 dport = 0, dnode = 0;
++	u32 type = 0, inst = 0;
+ 	int mtu, rc;
+ 
+ 	if (unlikely(dlen > TIPC_MAX_USER_MSG_SIZE))
+@@ -1360,23 +1360,11 @@ static int __tipc_sendmsg(struct socket *sock, struct msghdr *m, size_t dlen)
+ 		type = dest->addr.name.name.type;
+ 		inst = dest->addr.name.name.instance;
+ 		dnode = dest->addr.name.domain;
+-		msg_set_type(hdr, TIPC_NAMED_MSG);
+-		msg_set_hdr_sz(hdr, NAMED_H_SIZE);
+-		msg_set_nametype(hdr, type);
+-		msg_set_nameinst(hdr, inst);
+-		msg_set_lookup_scope(hdr, tipc_node2scope(dnode));
+ 		dport = tipc_nametbl_translate(net, type, inst, &dnode);
+-		msg_set_destnode(hdr, dnode);
+-		msg_set_destport(hdr, dport);
+ 		if (unlikely(!dport && !dnode))
+ 			return -EHOSTUNREACH;
+ 	} else if (dest->addrtype == TIPC_ADDR_ID) {
+ 		dnode = dest->addr.id.node;
+-		msg_set_type(hdr, TIPC_DIRECT_MSG);
+-		msg_set_lookup_scope(hdr, 0);
+-		msg_set_destnode(hdr, dnode);
+-		msg_set_destport(hdr, dest->addr.id.ref);
+-		msg_set_hdr_sz(hdr, BASIC_H_SIZE);
+ 	} else {
+ 		return -EINVAL;
+ 	}
+@@ -1387,6 +1375,22 @@ static int __tipc_sendmsg(struct socket *sock, struct msghdr *m, size_t dlen)
+ 	if (unlikely(rc))
+ 		return rc;
+ 
++	if (dest->addrtype == TIPC_ADDR_NAME) {
++		msg_set_type(hdr, TIPC_NAMED_MSG);
++		msg_set_hdr_sz(hdr, NAMED_H_SIZE);
++		msg_set_nametype(hdr, type);
++		msg_set_nameinst(hdr, inst);
++		msg_set_lookup_scope(hdr, tipc_node2scope(dnode));
++		msg_set_destnode(hdr, dnode);
++		msg_set_destport(hdr, dport);
++	} else { /* TIPC_ADDR_ID */
++		msg_set_type(hdr, TIPC_DIRECT_MSG);
++		msg_set_lookup_scope(hdr, 0);
++		msg_set_destnode(hdr, dnode);
++		msg_set_destport(hdr, dest->addr.id.ref);
++		msg_set_hdr_sz(hdr, BASIC_H_SIZE);
++	}
++
+ 	__skb_queue_head_init(&pkts);
+ 	mtu = tipc_node_get_mtu(net, dnode, tsk->portid);
+ 	rc = tipc_msg_build(hdr, m, 0, dlen, mtu, &pkts);
+diff --git a/net/tls/tls_main.c b/net/tls/tls_main.c
+index 82d0beed8f07..7aba4ee77aba 100644
+--- a/net/tls/tls_main.c
++++ b/net/tls/tls_main.c
+@@ -798,15 +798,19 @@ out:
+ 	return rc;
+ }
+ 
+-static void tls_update(struct sock *sk, struct proto *p)
++static void tls_update(struct sock *sk, struct proto *p,
++		       void (*write_space)(struct sock *sk))
+ {
+ 	struct tls_context *ctx;
+ 
+ 	ctx = tls_get_ctx(sk);
+-	if (likely(ctx))
++	if (likely(ctx)) {
++		ctx->sk_write_space = write_space;
+ 		ctx->sk_proto = p;
+-	else
++	} else {
+ 		sk->sk_prot = p;
++		sk->sk_write_space = write_space;
++	}
+ }
+ 
+ static int tls_get_info(const struct sock *sk, struct sk_buff *skb)
+diff --git a/net/tls/tls_sw.c b/net/tls/tls_sw.c
+index c70cf30c5492..a80920f261ca 100644
+--- a/net/tls/tls_sw.c
++++ b/net/tls/tls_sw.c
+@@ -677,12 +677,32 @@ static int tls_push_record(struct sock *sk, int flags,
+ 
+ 	split_point = msg_pl->apply_bytes;
+ 	split = split_point && split_point < msg_pl->sg.size;
++	if (unlikely((!split &&
++		      msg_pl->sg.size +
++		      prot->overhead_size > msg_en->sg.size) ||
++		     (split &&
++		      split_point +
++		      prot->overhead_size > msg_en->sg.size))) {
++		split = true;
++		split_point = msg_en->sg.size;
++	}
+ 	if (split) {
+ 		rc = tls_split_open_record(sk, rec, &tmp, msg_pl, msg_en,
+ 					   split_point, prot->overhead_size,
+ 					   &orig_end);
+ 		if (rc < 0)
+ 			return rc;
++		/* This can happen if above tls_split_open_record allocates
++		 * a single large encryption buffer instead of two smaller
++		 * ones. In this case adjust pointers and continue without
++		 * split.
++		 */
++		if (!msg_pl->sg.size) {
++			tls_merge_open_record(sk, rec, tmp, orig_end);
++			msg_pl = &rec->msg_plaintext;
++			msg_en = &rec->msg_encrypted;
++			split = false;
++		}
+ 		sk_msg_trim(sk, msg_en, msg_pl->sg.size +
+ 			    prot->overhead_size);
+ 	}
+@@ -704,6 +724,12 @@ static int tls_push_record(struct sock *sk, int flags,
+ 		sg_mark_end(sk_msg_elem(msg_pl, i));
+ 	}
+ 
++	if (msg_pl->sg.end < msg_pl->sg.start) {
++		sg_chain(&msg_pl->sg.data[msg_pl->sg.start],
++			 MAX_SKB_FRAGS - msg_pl->sg.start + 1,
++			 msg_pl->sg.data);
++	}
++
+ 	i = msg_pl->sg.start;
+ 	sg_chain(rec->sg_aead_in, 2, &msg_pl->sg.data[i]);
+ 
+@@ -778,10 +804,7 @@ more_data:
+ 	if (psock->eval == __SK_NONE) {
+ 		delta = msg->sg.size;
+ 		psock->eval = sk_psock_msg_verdict(sk, psock, msg);
+-		if (delta < msg->sg.size)
+-			delta -= msg->sg.size;
+-		else
+-			delta = 0;
++		delta -= msg->sg.size;
+ 	}
+ 	if (msg->cork_bytes && msg->cork_bytes > msg->sg.size &&
+ 	    !enospc && !full_record) {
+diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
+index 7b72286922f7..c74646b7a751 100644
+--- a/net/wireless/nl80211.c
++++ b/net/wireless/nl80211.c
+@@ -10834,6 +10834,7 @@ static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device *rdev,
+ 		if (err)
+ 			return err;
+ 
++		cfg80211_sinfo_release_content(&sinfo);
+ 		if (sinfo.filled & BIT_ULL(NL80211_STA_INFO_BEACON_SIGNAL_AVG))
+ 			wdev->cqm_config->last_rssi_event_value =
+ 				(s8) sinfo.rx_beacon_signal_avg;
+@@ -13787,6 +13788,8 @@ static int nl80211_probe_mesh_link(struct sk_buff *skb, struct genl_info *info)
+ 	if (err)
+ 		return err;
+ 
++	cfg80211_sinfo_release_content(&sinfo);
++
+ 	return rdev_probe_mesh_link(rdev, dev, dest, buf, len);
+ }
+ 
+diff --git a/net/wireless/rdev-ops.h b/net/wireless/rdev-ops.h
+index e853a4fe6f97..3dd9515c836b 100644
+--- a/net/wireless/rdev-ops.h
++++ b/net/wireless/rdev-ops.h
+@@ -538,6 +538,10 @@ static inline int
+ rdev_set_wiphy_params(struct cfg80211_registered_device *rdev, u32 changed)
+ {
+ 	int ret;
++
++	if (!rdev->ops->set_wiphy_params)
++		return -EOPNOTSUPP;
++
+ 	trace_rdev_set_wiphy_params(&rdev->wiphy, changed);
+ 	ret = rdev->ops->set_wiphy_params(&rdev->wiphy, changed);
+ 	trace_rdev_return_int(&rdev->wiphy, ret);
+diff --git a/net/wireless/sme.c b/net/wireless/sme.c
+index 7a6c38ddc65a..d32a2ec4d96a 100644
+--- a/net/wireless/sme.c
++++ b/net/wireless/sme.c
+@@ -1307,14 +1307,14 @@ void cfg80211_autodisconnect_wk(struct work_struct *work)
+ 	if (wdev->conn_owner_nlportid) {
+ 		switch (wdev->iftype) {
+ 		case NL80211_IFTYPE_ADHOC:
+-			cfg80211_leave_ibss(rdev, wdev->netdev, false);
++			__cfg80211_leave_ibss(rdev, wdev->netdev, false);
+ 			break;
+ 		case NL80211_IFTYPE_AP:
+ 		case NL80211_IFTYPE_P2P_GO:
+-			cfg80211_stop_ap(rdev, wdev->netdev, false);
++			__cfg80211_stop_ap(rdev, wdev->netdev, false);
+ 			break;
+ 		case NL80211_IFTYPE_MESH_POINT:
+-			cfg80211_leave_mesh(rdev, wdev->netdev);
++			__cfg80211_leave_mesh(rdev, wdev->netdev);
+ 			break;
+ 		case NL80211_IFTYPE_STATION:
+ 		case NL80211_IFTYPE_P2P_CLIENT:
+diff --git a/net/wireless/util.c b/net/wireless/util.c
+index 5b4ed5bbc542..8481e9ac33da 100644
+--- a/net/wireless/util.c
++++ b/net/wireless/util.c
+@@ -564,7 +564,7 @@ __frame_add_frag(struct sk_buff *skb, struct page *page,
+ 	struct skb_shared_info *sh = skb_shinfo(skb);
+ 	int page_offset;
+ 
+-	page_ref_inc(page);
++	get_page(page);
+ 	page_offset = ptr - page_address(page);
+ 	skb_add_rx_frag(skb, sh->nr_frags, page, page_offset, len, size);
+ }
+diff --git a/sound/core/seq/seq_timer.c b/sound/core/seq/seq_timer.c
+index 161f3170bd7e..3bc6095df44d 100644
+--- a/sound/core/seq/seq_timer.c
++++ b/sound/core/seq/seq_timer.c
+@@ -465,15 +465,19 @@ void snd_seq_info_timer_read(struct snd_info_entry *entry,
+ 		q = queueptr(idx);
+ 		if (q == NULL)
+ 			continue;
+-		if ((tmr = q->timer) == NULL ||
+-		    (ti = tmr->timeri) == NULL) {
+-			queuefree(q);
+-			continue;
+-		}
++		mutex_lock(&q->timer_mutex);
++		tmr = q->timer;
++		if (!tmr)
++			goto unlock;
++		ti = tmr->timeri;
++		if (!ti)
++			goto unlock;
+ 		snd_iprintf(buffer, "Timer for queue %i : %s\n", q->queue, ti->timer->name);
+ 		resolution = snd_timer_resolution(ti) * tmr->ticks;
+ 		snd_iprintf(buffer, "  Period time : %lu.%09lu\n", resolution / 1000000000, resolution % 1000000000);
+ 		snd_iprintf(buffer, "  Skew : %u / %u\n", tmr->skew, tmr->skew_base);
++unlock:
++		mutex_unlock(&q->timer_mutex);
+ 		queuefree(q);
+  	}
+ }
+diff --git a/sound/firewire/dice/dice-extension.c b/sound/firewire/dice/dice-extension.c
+index a63fcbc875ad..02f4a8318e38 100644
+--- a/sound/firewire/dice/dice-extension.c
++++ b/sound/firewire/dice/dice-extension.c
+@@ -159,8 +159,11 @@ int snd_dice_detect_extension_formats(struct snd_dice *dice)
+ 		int j;
+ 
+ 		for (j = i + 1; j < 9; ++j) {
+-			if (pointers[i * 2] == pointers[j * 2])
++			if (pointers[i * 2] == pointers[j * 2]) {
++				// Fallback to limited functionality.
++				err = -ENXIO;
+ 				goto end;
++			}
+ 		}
+ 	}
+ 
+diff --git a/sound/firewire/tascam/amdtp-tascam.c b/sound/firewire/tascam/amdtp-tascam.c
+index e80bb84c43f6..f823a2ab3544 100644
+--- a/sound/firewire/tascam/amdtp-tascam.c
++++ b/sound/firewire/tascam/amdtp-tascam.c
+@@ -157,14 +157,15 @@ static void read_status_messages(struct amdtp_stream *s,
+ 			if ((before ^ after) & mask) {
+ 				struct snd_firewire_tascam_change *entry =
+ 						&tscm->queue[tscm->push_pos];
++				unsigned long flag;
+ 
+-				spin_lock_irq(&tscm->lock);
++				spin_lock_irqsave(&tscm->lock, flag);
+ 				entry->index = index;
+ 				entry->before = before;
+ 				entry->after = after;
+ 				if (++tscm->push_pos >= SND_TSCM_QUEUE_COUNT)
+ 					tscm->push_pos = 0;
+-				spin_unlock_irq(&tscm->lock);
++				spin_unlock_irqrestore(&tscm->lock, flag);
+ 
+ 				wake_up(&tscm->hwdep_wait);
+ 			}
+diff --git a/sound/soc/codecs/msm8916-wcd-analog.c b/sound/soc/codecs/msm8916-wcd-analog.c
+index e3d311fb510e..84289ebeae87 100644
+--- a/sound/soc/codecs/msm8916-wcd-analog.c
++++ b/sound/soc/codecs/msm8916-wcd-analog.c
+@@ -391,9 +391,6 @@ static int pm8916_wcd_analog_enable_micbias_int(struct snd_soc_component
+ 
+ 	switch (event) {
+ 	case SND_SOC_DAPM_PRE_PMU:
+-		snd_soc_component_update_bits(component, CDC_A_MICB_1_INT_RBIAS,
+-				    MICB_1_INT_TX2_INT_RBIAS_EN_MASK,
+-				    MICB_1_INT_TX2_INT_RBIAS_EN_ENABLE);
+ 		snd_soc_component_update_bits(component, reg, MICB_1_EN_PULL_DOWN_EN_MASK, 0);
+ 		snd_soc_component_update_bits(component, CDC_A_MICB_1_EN,
+ 				    MICB_1_EN_OPA_STG2_TAIL_CURR_MASK,
+@@ -443,6 +440,14 @@ static int pm8916_wcd_analog_enable_micbias_int1(struct
+ 	struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
+ 	struct pm8916_wcd_analog_priv *wcd = snd_soc_component_get_drvdata(component);
+ 
++	switch (event) {
++	case SND_SOC_DAPM_PRE_PMU:
++		snd_soc_component_update_bits(component, CDC_A_MICB_1_INT_RBIAS,
++				    MICB_1_INT_TX1_INT_RBIAS_EN_MASK,
++				    MICB_1_INT_TX1_INT_RBIAS_EN_ENABLE);
++		break;
++	}
++
+ 	return pm8916_wcd_analog_enable_micbias_int(component, event, w->reg,
+ 						     wcd->micbias1_cap_mode);
+ }
+@@ -553,6 +558,11 @@ static int pm8916_wcd_analog_enable_micbias_int2(struct
+ 	struct pm8916_wcd_analog_priv *wcd = snd_soc_component_get_drvdata(component);
+ 
+ 	switch (event) {
++	case SND_SOC_DAPM_PRE_PMU:
++		snd_soc_component_update_bits(component, CDC_A_MICB_1_INT_RBIAS,
++				    MICB_1_INT_TX2_INT_RBIAS_EN_MASK,
++				    MICB_1_INT_TX2_INT_RBIAS_EN_ENABLE);
++		break;
+ 	case SND_SOC_DAPM_POST_PMU:
+ 		pm8916_mbhc_configure_bias(wcd, true);
+ 		break;
+@@ -888,10 +898,10 @@ static const struct snd_soc_dapm_widget pm8916_wcd_analog_dapm_widgets[] = {
+ 
+ 	SND_SOC_DAPM_SUPPLY("MIC BIAS External1", CDC_A_MICB_1_EN, 7, 0,
+ 			    pm8916_wcd_analog_enable_micbias_ext1,
+-			    SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
++			    SND_SOC_DAPM_POST_PMU),
+ 	SND_SOC_DAPM_SUPPLY("MIC BIAS External2", CDC_A_MICB_2_EN, 7, 0,
+ 			    pm8916_wcd_analog_enable_micbias_ext2,
+-			    SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
++			    SND_SOC_DAPM_POST_PMU),
+ 
+ 	SND_SOC_DAPM_ADC_E("ADC1", NULL, CDC_A_TX_1_EN, 7, 0,
+ 			   pm8916_wcd_analog_enable_adc,
+diff --git a/sound/soc/codecs/msm8916-wcd-digital.c b/sound/soc/codecs/msm8916-wcd-digital.c
+index 58b2468fb2a7..09fccacadd6b 100644
+--- a/sound/soc/codecs/msm8916-wcd-digital.c
++++ b/sound/soc/codecs/msm8916-wcd-digital.c
+@@ -586,6 +586,12 @@ static int msm8916_wcd_digital_enable_interpolator(
+ 		snd_soc_component_write(component, rx_gain_reg[w->shift],
+ 			      snd_soc_component_read32(component, rx_gain_reg[w->shift]));
+ 		break;
++	case SND_SOC_DAPM_POST_PMD:
++		snd_soc_component_update_bits(component, LPASS_CDC_CLK_RX_RESET_CTL,
++					      1 << w->shift, 1 << w->shift);
++		snd_soc_component_update_bits(component, LPASS_CDC_CLK_RX_RESET_CTL,
++					      1 << w->shift, 0x0);
++		break;
+ 	}
+ 	return 0;
+ }
+diff --git a/sound/soc/intel/boards/bytcht_es8316.c b/sound/soc/intel/boards/bytcht_es8316.c
+index 46612331f5ea..54e97455d7f6 100644
+--- a/sound/soc/intel/boards/bytcht_es8316.c
++++ b/sound/soc/intel/boards/bytcht_es8316.c
+@@ -442,7 +442,8 @@ static const struct dmi_system_id byt_cht_es8316_quirk_table[] = {
+ 			DMI_MATCH(DMI_SYS_VENDOR, "IRBIS"),
+ 			DMI_MATCH(DMI_PRODUCT_NAME, "NB41"),
+ 		},
+-		.driver_data = (void *)(BYT_CHT_ES8316_INTMIC_IN2_MAP
++		.driver_data = (void *)(BYT_CHT_ES8316_SSP0
++					| BYT_CHT_ES8316_INTMIC_IN2_MAP
+ 					| BYT_CHT_ES8316_JD_INVERTED),
+ 	},
+ 	{	/* Teclast X98 Plus II */
+diff --git a/sound/soc/stm/stm32_adfsdm.c b/sound/soc/stm/stm32_adfsdm.c
+index 3c9a9deec9af..4ecea4913f42 100644
+--- a/sound/soc/stm/stm32_adfsdm.c
++++ b/sound/soc/stm/stm32_adfsdm.c
+@@ -153,13 +153,13 @@ static const struct snd_soc_component_driver stm32_adfsdm_dai_component = {
+ 	.name = "stm32_dfsdm_audio",
+ };
+ 
+-static void memcpy_32to16(void *dest, const void *src, size_t n)
++static void stm32_memcpy_32to16(void *dest, const void *src, size_t n)
+ {
+ 	unsigned int i = 0;
+ 	u16 *d = (u16 *)dest, *s = (u16 *)src;
+ 
+ 	s++;
+-	for (i = n; i > 0; i--) {
++	for (i = n >> 1; i > 0; i--) {
+ 		*d++ = *s++;
+ 		s++;
+ 	}
+@@ -186,8 +186,8 @@ static int stm32_afsdm_pcm_cb(const void *data, size_t size, void *private)
+ 
+ 	if ((priv->pos + src_size) > buff_size) {
+ 		if (format == SNDRV_PCM_FORMAT_S16_LE)
+-			memcpy_32to16(&pcm_buff[priv->pos], src_buff,
+-				      buff_size - priv->pos);
++			stm32_memcpy_32to16(&pcm_buff[priv->pos], src_buff,
++					    buff_size - priv->pos);
+ 		else
+ 			memcpy(&pcm_buff[priv->pos], src_buff,
+ 			       buff_size - priv->pos);
+@@ -196,8 +196,8 @@ static int stm32_afsdm_pcm_cb(const void *data, size_t size, void *private)
+ 	}
+ 
+ 	if (format == SNDRV_PCM_FORMAT_S16_LE)
+-		memcpy_32to16(&pcm_buff[priv->pos],
+-			      &src_buff[src_size - cur_size], cur_size);
++		stm32_memcpy_32to16(&pcm_buff[priv->pos],
++				    &src_buff[src_size - cur_size], cur_size);
+ 	else
+ 		memcpy(&pcm_buff[priv->pos], &src_buff[src_size - cur_size],
+ 		       cur_size);
+diff --git a/sound/soc/stm/stm32_sai_sub.c b/sound/soc/stm/stm32_sai_sub.c
+index 48e629ac2d88..30bcd5d3a32a 100644
+--- a/sound/soc/stm/stm32_sai_sub.c
++++ b/sound/soc/stm/stm32_sai_sub.c
+@@ -184,6 +184,56 @@ static bool stm32_sai_sub_writeable_reg(struct device *dev, unsigned int reg)
+ 	}
+ }
+ 
++static int stm32_sai_sub_reg_up(struct stm32_sai_sub_data *sai,
++				unsigned int reg, unsigned int mask,
++				unsigned int val)
++{
++	int ret;
++
++	ret = clk_enable(sai->pdata->pclk);
++	if (ret < 0)
++		return ret;
++
++	ret = regmap_update_bits(sai->regmap, reg, mask, val);
++
++	clk_disable(sai->pdata->pclk);
++
++	return ret;
++}
++
++static int stm32_sai_sub_reg_wr(struct stm32_sai_sub_data *sai,
++				unsigned int reg, unsigned int mask,
++				unsigned int val)
++{
++	int ret;
++
++	ret = clk_enable(sai->pdata->pclk);
++	if (ret < 0)
++		return ret;
++
++	ret = regmap_write_bits(sai->regmap, reg, mask, val);
++
++	clk_disable(sai->pdata->pclk);
++
++	return ret;
++}
++
++static int stm32_sai_sub_reg_rd(struct stm32_sai_sub_data *sai,
++				unsigned int reg, unsigned int *val)
++{
++	int ret;
++
++	ret = clk_enable(sai->pdata->pclk);
++	if (ret < 0)
++		return ret;
++
++	ret = regmap_read(sai->regmap, reg, val);
++
++	clk_disable(sai->pdata->pclk);
++
++	return ret;
++}
++
+ static const struct regmap_config stm32_sai_sub_regmap_config_f4 = {
+ 	.reg_bits = 32,
+ 	.reg_stride = 4,
+@@ -295,7 +345,7 @@ static int stm32_sai_set_clk_div(struct stm32_sai_sub_data *sai,
+ 
+ 	mask = SAI_XCR1_MCKDIV_MASK(SAI_XCR1_MCKDIV_WIDTH(version));
+ 	cr1 = SAI_XCR1_MCKDIV_SET(div);
+-	ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, mask, cr1);
++	ret = stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX, mask, cr1);
+ 	if (ret < 0)
+ 		dev_err(&sai->pdev->dev, "Failed to update CR1 register\n");
+ 
+@@ -372,8 +422,8 @@ static int stm32_sai_mclk_enable(struct clk_hw *hw)
+ 
+ 	dev_dbg(&sai->pdev->dev, "Enable master clock\n");
+ 
+-	return regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
+-				  SAI_XCR1_MCKEN, SAI_XCR1_MCKEN);
++	return stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX,
++				    SAI_XCR1_MCKEN, SAI_XCR1_MCKEN);
+ }
+ 
+ static void stm32_sai_mclk_disable(struct clk_hw *hw)
+@@ -383,7 +433,7 @@ static void stm32_sai_mclk_disable(struct clk_hw *hw)
+ 
+ 	dev_dbg(&sai->pdev->dev, "Disable master clock\n");
+ 
+-	regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, SAI_XCR1_MCKEN, 0);
++	stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX, SAI_XCR1_MCKEN, 0);
+ }
+ 
+ static const struct clk_ops mclk_ops = {
+@@ -446,15 +496,15 @@ static irqreturn_t stm32_sai_isr(int irq, void *devid)
+ 	unsigned int sr, imr, flags;
+ 	snd_pcm_state_t status = SNDRV_PCM_STATE_RUNNING;
+ 
+-	regmap_read(sai->regmap, STM_SAI_IMR_REGX, &imr);
+-	regmap_read(sai->regmap, STM_SAI_SR_REGX, &sr);
++	stm32_sai_sub_reg_rd(sai, STM_SAI_IMR_REGX, &imr);
++	stm32_sai_sub_reg_rd(sai, STM_SAI_SR_REGX, &sr);
+ 
+ 	flags = sr & imr;
+ 	if (!flags)
+ 		return IRQ_NONE;
+ 
+-	regmap_write_bits(sai->regmap, STM_SAI_CLRFR_REGX, SAI_XCLRFR_MASK,
+-			  SAI_XCLRFR_MASK);
++	stm32_sai_sub_reg_wr(sai, STM_SAI_CLRFR_REGX, SAI_XCLRFR_MASK,
++			     SAI_XCLRFR_MASK);
+ 
+ 	if (!sai->substream) {
+ 		dev_err(&pdev->dev, "Device stopped. Spurious IRQ 0x%x\n", sr);
+@@ -503,8 +553,8 @@ static int stm32_sai_set_sysclk(struct snd_soc_dai *cpu_dai,
+ 	int ret;
+ 
+ 	if (dir == SND_SOC_CLOCK_OUT && sai->sai_mclk) {
+-		ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
+-					 SAI_XCR1_NODIV,
++		ret = stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX,
++					   SAI_XCR1_NODIV,
+ 					 freq ? 0 : SAI_XCR1_NODIV);
+ 		if (ret < 0)
+ 			return ret;
+@@ -583,7 +633,7 @@ static int stm32_sai_set_dai_tdm_slot(struct snd_soc_dai *cpu_dai, u32 tx_mask,
+ 
+ 	slotr_mask |= SAI_XSLOTR_SLOTEN_MASK;
+ 
+-	regmap_update_bits(sai->regmap, STM_SAI_SLOTR_REGX, slotr_mask, slotr);
++	stm32_sai_sub_reg_up(sai, STM_SAI_SLOTR_REGX, slotr_mask, slotr);
+ 
+ 	sai->slot_width = slot_width;
+ 	sai->slots = slots;
+@@ -665,7 +715,7 @@ static int stm32_sai_set_dai_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt)
+ 	cr1_mask |= SAI_XCR1_CKSTR;
+ 	frcr_mask |= SAI_XFRCR_FSPOL;
+ 
+-	regmap_update_bits(sai->regmap, STM_SAI_FRCR_REGX, frcr_mask, frcr);
++	stm32_sai_sub_reg_up(sai, STM_SAI_FRCR_REGX, frcr_mask, frcr);
+ 
+ 	/* DAI clock master masks */
+ 	switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+@@ -693,7 +743,7 @@ static int stm32_sai_set_dai_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt)
+ 	cr1_mask |= SAI_XCR1_SLAVE;
+ 
+ conf_update:
+-	ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, cr1_mask, cr1);
++	ret = stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX, cr1_mask, cr1);
+ 	if (ret < 0) {
+ 		dev_err(cpu_dai->dev, "Failed to update CR1 register\n");
+ 		return ret;
+@@ -730,12 +780,12 @@ static int stm32_sai_startup(struct snd_pcm_substream *substream,
+ 	}
+ 
+ 	/* Enable ITs */
+-	regmap_write_bits(sai->regmap, STM_SAI_CLRFR_REGX,
+-			  SAI_XCLRFR_MASK, SAI_XCLRFR_MASK);
++	stm32_sai_sub_reg_wr(sai, STM_SAI_CLRFR_REGX,
++			     SAI_XCLRFR_MASK, SAI_XCLRFR_MASK);
+ 
+ 	imr = SAI_XIMR_OVRUDRIE;
+ 	if (STM_SAI_IS_CAPTURE(sai)) {
+-		regmap_read(sai->regmap, STM_SAI_CR2_REGX, &cr2);
++		stm32_sai_sub_reg_rd(sai, STM_SAI_CR2_REGX, &cr2);
+ 		if (cr2 & SAI_XCR2_MUTECNT_MASK)
+ 			imr |= SAI_XIMR_MUTEDETIE;
+ 	}
+@@ -745,8 +795,8 @@ static int stm32_sai_startup(struct snd_pcm_substream *substream,
+ 	else
+ 		imr |= SAI_XIMR_AFSDETIE | SAI_XIMR_LFSDETIE;
+ 
+-	regmap_update_bits(sai->regmap, STM_SAI_IMR_REGX,
+-			   SAI_XIMR_MASK, imr);
++	stm32_sai_sub_reg_up(sai, STM_SAI_IMR_REGX,
++			     SAI_XIMR_MASK, imr);
+ 
+ 	return 0;
+ }
+@@ -763,10 +813,10 @@ static int stm32_sai_set_config(struct snd_soc_dai *cpu_dai,
+ 	 * SAI fifo threshold is set to half fifo, to keep enough space
+ 	 * for DMA incoming bursts.
+ 	 */
+-	regmap_write_bits(sai->regmap, STM_SAI_CR2_REGX,
+-			  SAI_XCR2_FFLUSH | SAI_XCR2_FTH_MASK,
+-			  SAI_XCR2_FFLUSH |
+-			  SAI_XCR2_FTH_SET(STM_SAI_FIFO_TH_HALF));
++	stm32_sai_sub_reg_wr(sai, STM_SAI_CR2_REGX,
++			     SAI_XCR2_FFLUSH | SAI_XCR2_FTH_MASK,
++			     SAI_XCR2_FFLUSH |
++			     SAI_XCR2_FTH_SET(STM_SAI_FIFO_TH_HALF));
+ 
+ 	/* DS bits in CR1 not set for SPDIF (size forced to 24 bits).*/
+ 	if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
+@@ -795,7 +845,7 @@ static int stm32_sai_set_config(struct snd_soc_dai *cpu_dai,
+ 	if ((sai->slots == 2) && (params_channels(params) == 1))
+ 		cr1 |= SAI_XCR1_MONO;
+ 
+-	ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, cr1_mask, cr1);
++	ret = stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX, cr1_mask, cr1);
+ 	if (ret < 0) {
+ 		dev_err(cpu_dai->dev, "Failed to update CR1 register\n");
+ 		return ret;
+@@ -809,7 +859,7 @@ static int stm32_sai_set_slots(struct snd_soc_dai *cpu_dai)
+ 	struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
+ 	int slotr, slot_sz;
+ 
+-	regmap_read(sai->regmap, STM_SAI_SLOTR_REGX, &slotr);
++	stm32_sai_sub_reg_rd(sai, STM_SAI_SLOTR_REGX, &slotr);
+ 
+ 	/*
+ 	 * If SLOTSZ is set to auto in SLOTR, align slot width on data size
+@@ -831,16 +881,16 @@ static int stm32_sai_set_slots(struct snd_soc_dai *cpu_dai)
+ 		sai->slots = 2;
+ 
+ 	/* The number of slots in the audio frame is equal to NBSLOT[3:0] + 1*/
+-	regmap_update_bits(sai->regmap, STM_SAI_SLOTR_REGX,
+-			   SAI_XSLOTR_NBSLOT_MASK,
+-			   SAI_XSLOTR_NBSLOT_SET((sai->slots - 1)));
++	stm32_sai_sub_reg_up(sai, STM_SAI_SLOTR_REGX,
++			     SAI_XSLOTR_NBSLOT_MASK,
++			     SAI_XSLOTR_NBSLOT_SET((sai->slots - 1)));
+ 
+ 	/* Set default slots mask if not already set from DT */
+ 	if (!(slotr & SAI_XSLOTR_SLOTEN_MASK)) {
+ 		sai->slot_mask = (1 << sai->slots) - 1;
+-		regmap_update_bits(sai->regmap,
+-				   STM_SAI_SLOTR_REGX, SAI_XSLOTR_SLOTEN_MASK,
+-				   SAI_XSLOTR_SLOTEN_SET(sai->slot_mask));
++		stm32_sai_sub_reg_up(sai,
++				     STM_SAI_SLOTR_REGX, SAI_XSLOTR_SLOTEN_MASK,
++				     SAI_XSLOTR_SLOTEN_SET(sai->slot_mask));
+ 	}
+ 
+ 	dev_dbg(cpu_dai->dev, "Slots %d, slot width %d\n",
+@@ -870,14 +920,14 @@ static void stm32_sai_set_frame(struct snd_soc_dai *cpu_dai)
+ 	dev_dbg(cpu_dai->dev, "Frame length %d, frame active %d\n",
+ 		sai->fs_length, fs_active);
+ 
+-	regmap_update_bits(sai->regmap, STM_SAI_FRCR_REGX, frcr_mask, frcr);
++	stm32_sai_sub_reg_up(sai, STM_SAI_FRCR_REGX, frcr_mask, frcr);
+ 
+ 	if ((sai->fmt & SND_SOC_DAIFMT_FORMAT_MASK) == SND_SOC_DAIFMT_LSB) {
+ 		offset = sai->slot_width - sai->data_size;
+ 
+-		regmap_update_bits(sai->regmap, STM_SAI_SLOTR_REGX,
+-				   SAI_XSLOTR_FBOFF_MASK,
+-				   SAI_XSLOTR_FBOFF_SET(offset));
++		stm32_sai_sub_reg_up(sai, STM_SAI_SLOTR_REGX,
++				     SAI_XSLOTR_FBOFF_MASK,
++				     SAI_XSLOTR_FBOFF_SET(offset));
+ 	}
+ }
+ 
+@@ -994,9 +1044,9 @@ static int stm32_sai_configure_clock(struct snd_soc_dai *cpu_dai,
+ 					return -EINVAL;
+ 				}
+ 
+-				regmap_update_bits(sai->regmap,
+-						   STM_SAI_CR1_REGX,
+-						   SAI_XCR1_OSR, cr1);
++				stm32_sai_sub_reg_up(sai,
++						     STM_SAI_CR1_REGX,
++						     SAI_XCR1_OSR, cr1);
+ 
+ 				div = stm32_sai_get_clk_div(sai, sai_clk_rate,
+ 							    sai->mclk_rate);
+@@ -1058,12 +1108,12 @@ static int stm32_sai_trigger(struct snd_pcm_substream *substream, int cmd,
+ 	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+ 		dev_dbg(cpu_dai->dev, "Enable DMA and SAI\n");
+ 
+-		regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
+-				   SAI_XCR1_DMAEN, SAI_XCR1_DMAEN);
++		stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX,
++				     SAI_XCR1_DMAEN, SAI_XCR1_DMAEN);
+ 
+ 		/* Enable SAI */
+-		ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
+-					 SAI_XCR1_SAIEN, SAI_XCR1_SAIEN);
++		ret = stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX,
++					   SAI_XCR1_SAIEN, SAI_XCR1_SAIEN);
+ 		if (ret < 0)
+ 			dev_err(cpu_dai->dev, "Failed to update CR1 register\n");
+ 		break;
+@@ -1072,16 +1122,16 @@ static int stm32_sai_trigger(struct snd_pcm_substream *substream, int cmd,
+ 	case SNDRV_PCM_TRIGGER_STOP:
+ 		dev_dbg(cpu_dai->dev, "Disable DMA and SAI\n");
+ 
+-		regmap_update_bits(sai->regmap, STM_SAI_IMR_REGX,
+-				   SAI_XIMR_MASK, 0);
++		stm32_sai_sub_reg_up(sai, STM_SAI_IMR_REGX,
++				     SAI_XIMR_MASK, 0);
+ 
+-		regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
+-				   SAI_XCR1_SAIEN,
+-				   (unsigned int)~SAI_XCR1_SAIEN);
++		stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX,
++				     SAI_XCR1_SAIEN,
++				     (unsigned int)~SAI_XCR1_SAIEN);
+ 
+-		ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
+-					 SAI_XCR1_DMAEN,
+-					 (unsigned int)~SAI_XCR1_DMAEN);
++		ret = stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX,
++					   SAI_XCR1_DMAEN,
++					   (unsigned int)~SAI_XCR1_DMAEN);
+ 		if (ret < 0)
+ 			dev_err(cpu_dai->dev, "Failed to update CR1 register\n");
+ 
+@@ -1101,7 +1151,7 @@ static void stm32_sai_shutdown(struct snd_pcm_substream *substream,
+ 	struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
+ 	unsigned long flags;
+ 
+-	regmap_update_bits(sai->regmap, STM_SAI_IMR_REGX, SAI_XIMR_MASK, 0);
++	stm32_sai_sub_reg_up(sai, STM_SAI_IMR_REGX, SAI_XIMR_MASK, 0);
+ 
+ 	clk_disable_unprepare(sai->sai_ck);
+ 
+@@ -1169,7 +1219,7 @@ static int stm32_sai_dai_probe(struct snd_soc_dai *cpu_dai)
+ 	cr1_mask |= SAI_XCR1_SYNCEN_MASK;
+ 	cr1 |= SAI_XCR1_SYNCEN_SET(sai->sync);
+ 
+-	return regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, cr1_mask, cr1);
++	return stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX, cr1_mask, cr1);
+ }
+ 
+ static const struct snd_soc_dai_ops stm32_sai_pcm_dai_ops = {
+@@ -1322,8 +1372,13 @@ static int stm32_sai_sub_parse_of(struct platform_device *pdev,
+ 	if (STM_SAI_HAS_PDM(sai) && STM_SAI_IS_SUB_A(sai))
+ 		sai->regmap_config = &stm32_sai_sub_regmap_config_h7;
+ 
+-	sai->regmap = devm_regmap_init_mmio_clk(&pdev->dev, "sai_ck",
+-						base, sai->regmap_config);
++	/*
++	 * Do not manage peripheral clock through regmap framework as this
++	 * can lead to circular locking issue with sai master clock provider.
++	 * Manage peripheral clock directly in driver instead.
++	 */
++	sai->regmap = devm_regmap_init_mmio(&pdev->dev, base,
++					    sai->regmap_config);
+ 	if (IS_ERR(sai->regmap)) {
+ 		dev_err(&pdev->dev, "Failed to initialize MMIO\n");
+ 		return PTR_ERR(sai->regmap);
+@@ -1420,6 +1475,10 @@ static int stm32_sai_sub_parse_of(struct platform_device *pdev,
+ 		return PTR_ERR(sai->sai_ck);
+ 	}
+ 
++	ret = clk_prepare(sai->pdata->pclk);
++	if (ret < 0)
++		return ret;
++
+ 	if (STM_SAI_IS_F4(sai->pdata))
+ 		return 0;
+ 
+@@ -1501,22 +1560,48 @@ static int stm32_sai_sub_probe(struct platform_device *pdev)
+ 	return 0;
+ }
+ 
++static int stm32_sai_sub_remove(struct platform_device *pdev)
++{
++	struct stm32_sai_sub_data *sai = dev_get_drvdata(&pdev->dev);
++
++	clk_unprepare(sai->pdata->pclk);
++
++	return 0;
++}
++
+ #ifdef CONFIG_PM_SLEEP
+ static int stm32_sai_sub_suspend(struct device *dev)
+ {
+ 	struct stm32_sai_sub_data *sai = dev_get_drvdata(dev);
++	int ret;
++
++	ret = clk_enable(sai->pdata->pclk);
++	if (ret < 0)
++		return ret;
+ 
+ 	regcache_cache_only(sai->regmap, true);
+ 	regcache_mark_dirty(sai->regmap);
++
++	clk_disable(sai->pdata->pclk);
++
+ 	return 0;
+ }
+ 
+ static int stm32_sai_sub_resume(struct device *dev)
+ {
+ 	struct stm32_sai_sub_data *sai = dev_get_drvdata(dev);
++	int ret;
++
++	ret = clk_enable(sai->pdata->pclk);
++	if (ret < 0)
++		return ret;
+ 
+ 	regcache_cache_only(sai->regmap, false);
+-	return regcache_sync(sai->regmap);
++	ret = regcache_sync(sai->regmap);
++
++	clk_disable(sai->pdata->pclk);
++
++	return ret;
+ }
+ #endif /* CONFIG_PM_SLEEP */
+ 
+@@ -1531,6 +1616,7 @@ static struct platform_driver stm32_sai_sub_driver = {
+ 		.pm = &stm32_sai_sub_pm_ops,
+ 	},
+ 	.probe = stm32_sai_sub_probe,
++	.remove = stm32_sai_sub_remove,
+ };
+ 
+ module_platform_driver(stm32_sai_sub_driver);
+diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c
+index a04c727dcd19..fa24bd491cf6 100644
+--- a/sound/usb/pcm.c
++++ b/sound/usb/pcm.c
+@@ -370,7 +370,7 @@ static int set_sync_ep_implicit_fb_quirk(struct snd_usb_substream *subs,
+ add_sync_ep_from_ifnum:
+ 	iface = usb_ifnum_to_if(dev, ifnum);
+ 
+-	if (!iface || iface->num_altsetting == 0)
++	if (!iface || iface->num_altsetting < 2)
+ 		return -EINVAL;
+ 
+ 	alts = &iface->altsetting[1];
+diff --git a/tools/bpf/bpftool/btf_dumper.c b/tools/bpf/bpftool/btf_dumper.c
+index d66131f69689..397e5716ab6d 100644
+--- a/tools/bpf/bpftool/btf_dumper.c
++++ b/tools/bpf/bpftool/btf_dumper.c
+@@ -26,7 +26,7 @@ static void btf_dumper_ptr(const void *data, json_writer_t *jw,
+ 			   bool is_plain_text)
+ {
+ 	if (is_plain_text)
+-		jsonw_printf(jw, "%p", data);
++		jsonw_printf(jw, "%p", *(void **)data);
+ 	else
+ 		jsonw_printf(jw, "%lu", *(unsigned long *)data);
+ }
+diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
+index 7accaf8ef689..ea3f0745d7ad 100644
+--- a/tools/perf/builtin-report.c
++++ b/tools/perf/builtin-report.c
+@@ -1031,6 +1031,7 @@ int cmd_report(int argc, const char **argv)
+ 	struct stat st;
+ 	bool has_br_stack = false;
+ 	int branch_mode = -1;
++	int last_key = 0;
+ 	bool branch_call_mode = false;
+ #define CALLCHAIN_DEFAULT_OPT  "graph,0.5,caller,function,percent"
+ 	static const char report_callchain_help[] = "Display call graph (stack chain/backtrace):\n\n"
+@@ -1396,7 +1397,8 @@ repeat:
+ 		sort_order = sort_tmp;
+ 	}
+ 
+-	if (setup_sorting(session->evlist) < 0) {
++	if ((last_key != K_SWITCH_INPUT_DATA) &&
++	    (setup_sorting(session->evlist) < 0)) {
+ 		if (sort_order)
+ 			parse_options_usage(report_usage, options, "s", 1);
+ 		if (field_order)
+@@ -1475,6 +1477,7 @@ repeat:
+ 	ret = __cmd_report(&report);
+ 	if (ret == K_SWITCH_INPUT_DATA) {
+ 		perf_session__delete(session);
++		last_key = K_SWITCH_INPUT_DATA;
+ 		goto repeat;
+ 	} else
+ 		ret = 0;
+diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
+index 3983d6ccd14d..da016f398aa8 100644
+--- a/tools/perf/builtin-script.c
++++ b/tools/perf/builtin-script.c
+@@ -3605,11 +3605,6 @@ int cmd_script(int argc, const char **argv)
+ 		}
+ 	}
+ 
+-	if (script.time_str && reltime) {
+-		fprintf(stderr, "Don't combine --reltime with --time\n");
+-		return -1;
+-	}
+-
+ 	if (itrace_synth_opts.callchain &&
+ 	    itrace_synth_opts.callchain_sz > scripting_max_stack)
+ 		scripting_max_stack = itrace_synth_opts.callchain_sz;
+@@ -3869,10 +3864,11 @@ int cmd_script(int argc, const char **argv)
+ 		goto out_delete;
+ 
+ 	if (script.time_str) {
+-		err = perf_time__parse_for_ranges(script.time_str, session,
++		err = perf_time__parse_for_ranges_reltime(script.time_str, session,
+ 						  &script.ptime_range,
+ 						  &script.range_size,
+-						  &script.range_num);
++						  &script.range_num,
++						  reltime);
+ 		if (err < 0)
+ 			goto out_delete;
+ 
+diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
+index 6a186b668303..479273130794 100644
+--- a/tools/perf/util/hist.h
++++ b/tools/perf/util/hist.h
+@@ -339,10 +339,10 @@ static inline void perf_hpp__prepend_sort_field(struct perf_hpp_fmt *format)
+ 	list_for_each_entry_safe(format, tmp, &(_list)->sorts, sort_list)
+ 
+ #define hists__for_each_format(hists, format) \
+-	perf_hpp_list__for_each_format((hists)->hpp_list, fmt)
++	perf_hpp_list__for_each_format((hists)->hpp_list, format)
+ 
+ #define hists__for_each_sort_list(hists, format) \
+-	perf_hpp_list__for_each_sort_list((hists)->hpp_list, fmt)
++	perf_hpp_list__for_each_sort_list((hists)->hpp_list, format)
+ 
+ extern struct perf_hpp_fmt perf_hpp__format[];
+ 
+diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
+index 08cccd86447c..9ecea45da4ca 100644
+--- a/tools/perf/util/probe-finder.c
++++ b/tools/perf/util/probe-finder.c
+@@ -604,38 +604,26 @@ static int convert_to_trace_point(Dwarf_Die *sp_die, Dwfl_Module *mod,
+ 				  const char *function,
+ 				  struct probe_trace_point *tp)
+ {
+-	Dwarf_Addr eaddr, highaddr;
++	Dwarf_Addr eaddr;
+ 	GElf_Sym sym;
+ 	const char *symbol;
+ 
+ 	/* Verify the address is correct */
+-	if (dwarf_entrypc(sp_die, &eaddr) != 0) {
+-		pr_warning("Failed to get entry address of %s\n",
+-			   dwarf_diename(sp_die));
+-		return -ENOENT;
+-	}
+-	if (dwarf_highpc(sp_die, &highaddr) != 0) {
+-		pr_warning("Failed to get end address of %s\n",
+-			   dwarf_diename(sp_die));
+-		return -ENOENT;
+-	}
+-	if (paddr > highaddr) {
+-		pr_warning("Offset specified is greater than size of %s\n",
++	if (!dwarf_haspc(sp_die, paddr)) {
++		pr_warning("Specified offset is out of %s\n",
+ 			   dwarf_diename(sp_die));
+ 		return -EINVAL;
+ 	}
+ 
+-	symbol = dwarf_diename(sp_die);
++	/* Try to get actual symbol name from symtab */
++	symbol = dwfl_module_addrsym(mod, paddr, &sym, NULL);
+ 	if (!symbol) {
+-		/* Try to get the symbol name from symtab */
+-		symbol = dwfl_module_addrsym(mod, paddr, &sym, NULL);
+-		if (!symbol) {
+-			pr_warning("Failed to find symbol at 0x%lx\n",
+-				   (unsigned long)paddr);
+-			return -ENOENT;
+-		}
+-		eaddr = sym.st_value;
++		pr_warning("Failed to find symbol at 0x%lx\n",
++			   (unsigned long)paddr);
++		return -ENOENT;
+ 	}
++	eaddr = sym.st_value;
++
+ 	tp->offset = (unsigned long)(paddr - eaddr);
+ 	tp->address = (unsigned long)paddr;
+ 	tp->symbol = strdup(symbol);
+diff --git a/tools/perf/util/time-utils.c b/tools/perf/util/time-utils.c
+index 9796a2e43f67..302443921681 100644
+--- a/tools/perf/util/time-utils.c
++++ b/tools/perf/util/time-utils.c
+@@ -458,10 +458,11 @@ bool perf_time__ranges_skip_sample(struct perf_time_interval *ptime_buf,
+ 	return true;
+ }
+ 
+-int perf_time__parse_for_ranges(const char *time_str,
++int perf_time__parse_for_ranges_reltime(const char *time_str,
+ 				struct perf_session *session,
+ 				struct perf_time_interval **ranges,
+-				int *range_size, int *range_num)
++				int *range_size, int *range_num,
++				bool reltime)
+ {
+ 	bool has_percent = strchr(time_str, '%');
+ 	struct perf_time_interval *ptime_range;
+@@ -471,7 +472,7 @@ int perf_time__parse_for_ranges(const char *time_str,
+ 	if (!ptime_range)
+ 		return -ENOMEM;
+ 
+-	if (has_percent) {
++	if (has_percent || reltime) {
+ 		if (session->evlist->first_sample_time == 0 &&
+ 		    session->evlist->last_sample_time == 0) {
+ 			pr_err("HINT: no first/last sample time found in perf data.\n"
+@@ -479,7 +480,9 @@ int perf_time__parse_for_ranges(const char *time_str,
+ 			       "(if '--buildid-all' is enabled, please set '--timestamp-boundary').\n");
+ 			goto error;
+ 		}
++	}
+ 
++	if (has_percent) {
+ 		num = perf_time__percent_parse_str(
+ 				ptime_range, size,
+ 				time_str,
+@@ -492,6 +495,15 @@ int perf_time__parse_for_ranges(const char *time_str,
+ 	if (num < 0)
+ 		goto error_invalid;
+ 
++	if (reltime) {
++		int i;
++
++		for (i = 0; i < num; i++) {
++			ptime_range[i].start += session->evlist->first_sample_time;
++			ptime_range[i].end += session->evlist->first_sample_time;
++		}
++	}
++
+ 	*range_size = size;
+ 	*range_num = num;
+ 	*ranges = ptime_range;
+@@ -504,6 +516,15 @@ error:
+ 	return ret;
+ }
+ 
++int perf_time__parse_for_ranges(const char *time_str,
++				struct perf_session *session,
++				struct perf_time_interval **ranges,
++				int *range_size, int *range_num)
++{
++	return perf_time__parse_for_ranges_reltime(time_str, session, ranges,
++					range_size, range_num, false);
++}
++
+ int timestamp__scnprintf_usec(u64 timestamp, char *buf, size_t sz)
+ {
+ 	u64  sec = timestamp / NSEC_PER_SEC;
+diff --git a/tools/perf/util/time-utils.h b/tools/perf/util/time-utils.h
+index 4f42988eb2f7..1142b0bddd5e 100644
+--- a/tools/perf/util/time-utils.h
++++ b/tools/perf/util/time-utils.h
+@@ -26,6 +26,11 @@ bool perf_time__ranges_skip_sample(struct perf_time_interval *ptime_buf,
+ 
+ struct perf_session;
+ 
++int perf_time__parse_for_ranges_reltime(const char *str, struct perf_session *session,
++				struct perf_time_interval **ranges,
++				int *range_size, int *range_num,
++				bool reltime);
++
+ int perf_time__parse_for_ranges(const char *str, struct perf_session *session,
+ 				struct perf_time_interval **ranges,
+ 				int *range_size, int *range_num);
+diff --git a/tools/testing/selftests/drivers/net/mlxsw/qos_mc_aware.sh b/tools/testing/selftests/drivers/net/mlxsw/qos_mc_aware.sh
+index 47315fe48d5a..24dd8ed48580 100755
+--- a/tools/testing/selftests/drivers/net/mlxsw/qos_mc_aware.sh
++++ b/tools/testing/selftests/drivers/net/mlxsw/qos_mc_aware.sh
+@@ -232,7 +232,7 @@ test_mc_aware()
+ 	stop_traffic
+ 	local ucth1=${uc_rate[1]}
+ 
+-	start_traffic $h1 own bc bc
++	start_traffic $h1 192.0.2.65 bc bc
+ 
+ 	local d0=$(date +%s)
+ 	local t0=$(ethtool_stats_get $h3 rx_octets_prio_0)
+@@ -254,7 +254,11 @@ test_mc_aware()
+ 			ret = 100 * ($ucth1 - $ucth2) / $ucth1
+ 			if (ret > 0) { ret } else { 0 }
+ 		    ")
+-	check_err $(bc <<< "$deg > 25")
++
++	# Minimum shaper of 200Mbps on MC TCs should cause about 20% of
++	# degradation on 1Gbps link.
++	check_err $(bc <<< "$deg < 15") "Minimum shaper not in effect"
++	check_err $(bc <<< "$deg > 25") "MC traffic degrades UC performance too much"
+ 
+ 	local interval=$((d1 - d0))
+ 	local mc_ir=$(rate $u0 $u1 $interval)