From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id 2E836138350 for ; Thu, 23 Jan 2020 11:09:54 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id 40C11E0949; Thu, 23 Jan 2020 11:09:53 +0000 (UTC) Received: from smtp.gentoo.org (mail.gentoo.org [IPv6:2001:470:ea4a:1:5054:ff:fec7:86e4]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by pigeon.gentoo.org (Postfix) with ESMTPS id 05F13E0949 for ; Thu, 23 Jan 2020 11:09:53 +0000 (UTC) Received: from oystercatcher.gentoo.org (unknown [IPv6:2a01:4f8:202:4333:225:90ff:fed9:fc84]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id CFDD834E430 for ; Thu, 23 Jan 2020 11:09:51 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 291863E for ; Thu, 23 Jan 2020 11:09:50 +0000 (UTC) From: "Mike Pagano" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Mike Pagano" Message-ID: <1579777773.bc50c812f636e7a351f6b1fba8cef0b99c7886ae.mpagano@gentoo> Subject: [gentoo-commits] proj/linux-patches:5.4 commit in: / X-VCS-Repository: proj/linux-patches X-VCS-Files: 0000_README 1013_linux-5.4.14.patch X-VCS-Directories: / X-VCS-Committer: mpagano X-VCS-Committer-Name: Mike Pagano X-VCS-Revision: bc50c812f636e7a351f6b1fba8cef0b99c7886ae X-VCS-Branch: 5.4 Date: Thu, 23 Jan 2020 11:09:50 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: 81848d50-471d-4e65-a37e-72f0081cc65a X-Archives-Hash: 5084f216a5cff87e05525b2aaaef476c commit: bc50c812f636e7a351f6b1fba8cef0b99c7886ae Author: Mike Pagano gentoo org> AuthorDate: Thu Jan 23 11:09:33 2020 +0000 Commit: Mike Pagano gentoo 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 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 = <®_3p3v>; +- VDDIO-supply = <®_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>; + }; + +-®_vdd3p0 { +- vin-supply = <&sw2_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>; + }; + +-®_vdd3p0 { +- vin-supply = <&sw2_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"; + }; + +-®_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>; + }; + +-®_vdd3p0 { +- vin-supply = <&sw2_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>; + }; + +-®_vdd3p0 { +- vin-supply = <&sw2_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 = , + , +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 = <®_dcdc1>; +- vqmmc-supply = <®_dcdc1>; ++ vqmmc-supply = <®_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 = <®_aldo2>; ++ vmmc-supply = <®_dcdc1>; + vqmmc-supply = <®_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 = , ++ , ++ , ++ ; ++ 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 = ; +@@ -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 = ; +@@ -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 = ; +@@ -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 = ; +@@ -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 = ; +@@ -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 = ; +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 = ; +@@ -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 = ; +@@ -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 = ; +@@ -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 = ; +@@ -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 = ; +@@ -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 = ; +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 = ; + 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 = ; + 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 = <®_3v3_p>; + vddio-supply = <®_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=:[:] ++ * virtio_uml.device=:[:] + * where: + * := vhost-user socket path to connect + * := 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 + #include + #include ++#include + + #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 + #include + + #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 + + #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 + + #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 + #include + ++#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)