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 54B3113933E for ; Tue, 20 Jul 2021 15:39:59 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id 89341E09DA; Tue, 20 Jul 2021 15:39:58 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [140.211.166.183]) (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 352FDE09DA for ; Tue, 20 Jul 2021 15:39:58 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (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 C4379340FD8 for ; Tue, 20 Jul 2021 15:39:56 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 5D90673A for ; Tue, 20 Jul 2021 15:39:55 +0000 (UTC) From: "Alice Ferrazzi" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Alice Ferrazzi" Message-ID: <1626795574.63c2061e30aca5ea598cbaf56e4f62e346ce9ab0.alicef@gentoo> Subject: [gentoo-commits] proj/linux-patches:5.4 commit in: / X-VCS-Repository: proj/linux-patches X-VCS-Files: 0000_README 1133_linux-5.4.134.patch X-VCS-Directories: / X-VCS-Committer: alicef X-VCS-Committer-Name: Alice Ferrazzi X-VCS-Revision: 63c2061e30aca5ea598cbaf56e4f62e346ce9ab0 X-VCS-Branch: 5.4 Date: Tue, 20 Jul 2021 15:39:55 +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: 3d9f6dea-4235-4c5e-b706-c441b745207d X-Archives-Hash: 0bf887c9f598aff46452e19589e21143 commit: 63c2061e30aca5ea598cbaf56e4f62e346ce9ab0 Author: Alice Ferrazzi gentoo org> AuthorDate: Tue Jul 20 15:39:20 2021 +0000 Commit: Alice Ferrazzi gentoo org> CommitDate: Tue Jul 20 15:39:34 2021 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=63c2061e Linux patch 5.4.134 Signed-off-by: Alice Ferrazzi gentoo.org> 0000_README | 4 + 1133_linux-5.4.134.patch | 4584 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 4588 insertions(+) diff --git a/0000_README b/0000_README index d108419..3895a61 100644 --- a/0000_README +++ b/0000_README @@ -575,6 +575,10 @@ Patch: 1132_linux-5.4.133.patch From: http://www.kernel.org Desc: Linux 5.4.133 +Patch: 1133_linux-5.4.134.patch +From: http://www.kernel.org +Desc: Linux 5.4.134 + 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/1133_linux-5.4.134.patch b/1133_linux-5.4.134.patch new file mode 100644 index 0000000..706e989 --- /dev/null +++ b/1133_linux-5.4.134.patch @@ -0,0 +1,4584 @@ +diff --git a/Makefile b/Makefile +index c0a064eea2b77..02ea9378161eb 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 4 +-SUBLEVEL = 133 ++SUBLEVEL = 134 + EXTRAVERSION = + NAME = Kleptomaniac Octopus + +diff --git a/arch/arm/boot/dts/am335x-cm-t335.dts b/arch/arm/boot/dts/am335x-cm-t335.dts +index 1fe3b566ba3df..09b36df140e5a 100644 +--- a/arch/arm/boot/dts/am335x-cm-t335.dts ++++ b/arch/arm/boot/dts/am335x-cm-t335.dts +@@ -516,7 +516,7 @@ status = "okay"; + status = "okay"; + pinctrl-names = "default"; + pinctrl-0 = <&spi0_pins>; +- ti,pindir-d0-out-d1-in = <1>; ++ ti,pindir-d0-out-d1-in; + /* WLS1271 WiFi */ + wlcore: wlcore@1 { + compatible = "ti,wl1271"; +diff --git a/arch/arm/boot/dts/am43x-epos-evm.dts b/arch/arm/boot/dts/am43x-epos-evm.dts +index a6fbc088daa86..a9f191d78b544 100644 +--- a/arch/arm/boot/dts/am43x-epos-evm.dts ++++ b/arch/arm/boot/dts/am43x-epos-evm.dts +@@ -848,7 +848,7 @@ + pinctrl-names = "default", "sleep"; + pinctrl-0 = <&spi0_pins_default>; + pinctrl-1 = <&spi0_pins_sleep>; +- ti,pindir-d0-out-d1-in = <1>; ++ ti,pindir-d0-out-d1-in; + }; + + &spi1 { +@@ -856,7 +856,7 @@ + pinctrl-names = "default", "sleep"; + pinctrl-0 = <&spi1_pins_default>; + pinctrl-1 = <&spi1_pins_sleep>; +- ti,pindir-d0-out-d1-in = <1>; ++ ti,pindir-d0-out-d1-in; + }; + + &usb2_phy1 { +diff --git a/arch/arm/boot/dts/bcm5301x.dtsi b/arch/arm/boot/dts/bcm5301x.dtsi +index 0016720ce5300..9711170649b69 100644 +--- a/arch/arm/boot/dts/bcm5301x.dtsi ++++ b/arch/arm/boot/dts/bcm5301x.dtsi +@@ -494,27 +494,27 @@ + <0x1811b408 0x004>, + <0x180293a0 0x01c>; + reg-names = "mspi", "bspi", "intr_regs", "intr_status_reg"; +- interrupts = , ++ interrupts = , ++ , ++ , + , + , + , +- , +- , +- ; +- interrupt-names = "spi_lr_fullness_reached", ++ ; ++ interrupt-names = "mspi_done", ++ "mspi_halted", ++ "spi_lr_fullness_reached", + "spi_lr_session_aborted", + "spi_lr_impatient", + "spi_lr_session_done", +- "spi_lr_overhead", +- "mspi_done", +- "mspi_halted"; ++ "spi_lr_overread"; + clocks = <&iprocmed>; + clock-names = "iprocmed"; + num-cs = <2>; + #address-cells = <1>; + #size-cells = <0>; + +- spi_nor: spi-nor@0 { ++ spi_nor: flash@0 { + compatible = "jedec,spi-nor"; + reg = <0>; + spi-max-frequency = <20000000>; +diff --git a/arch/arm/boot/dts/exynos5422-odroidhc1.dts b/arch/arm/boot/dts/exynos5422-odroidhc1.dts +index d271e75488262..fce5a4579693e 100644 +--- a/arch/arm/boot/dts/exynos5422-odroidhc1.dts ++++ b/arch/arm/boot/dts/exynos5422-odroidhc1.dts +@@ -22,7 +22,7 @@ + label = "blue:heartbeat"; + pwms = <&pwm 2 2000000 0>; + pwm-names = "pwm2"; +- max_brightness = <255>; ++ max-brightness = <255>; + linux,default-trigger = "heartbeat"; + }; + }; +diff --git a/arch/arm/boot/dts/exynos5422-odroidxu4.dts b/arch/arm/boot/dts/exynos5422-odroidxu4.dts +index 892d389d6d091..1fc3544854030 100644 +--- a/arch/arm/boot/dts/exynos5422-odroidxu4.dts ++++ b/arch/arm/boot/dts/exynos5422-odroidxu4.dts +@@ -24,7 +24,7 @@ + label = "blue:heartbeat"; + pwms = <&pwm 2 2000000 0>; + pwm-names = "pwm2"; +- max_brightness = <255>; ++ max-brightness = <255>; + linux,default-trigger = "heartbeat"; + }; + }; +diff --git a/arch/arm/boot/dts/exynos54xx-odroidxu-leds.dtsi b/arch/arm/boot/dts/exynos54xx-odroidxu-leds.dtsi +index 56acd832f0b3c..16e1087ec7172 100644 +--- a/arch/arm/boot/dts/exynos54xx-odroidxu-leds.dtsi ++++ b/arch/arm/boot/dts/exynos54xx-odroidxu-leds.dtsi +@@ -22,7 +22,7 @@ + * Green LED is much brighter than the others + * so limit its max brightness + */ +- max_brightness = <127>; ++ max-brightness = <127>; + linux,default-trigger = "mmc0"; + }; + +@@ -30,7 +30,7 @@ + label = "blue:heartbeat"; + pwms = <&pwm 2 2000000 0>; + pwm-names = "pwm2"; +- max_brightness = <255>; ++ max-brightness = <255>; + linux,default-trigger = "heartbeat"; + }; + }; +diff --git a/arch/arm/boot/dts/gemini-rut1xx.dts b/arch/arm/boot/dts/gemini-rut1xx.dts +index 9611ddf067927..08091d2a64e15 100644 +--- a/arch/arm/boot/dts/gemini-rut1xx.dts ++++ b/arch/arm/boot/dts/gemini-rut1xx.dts +@@ -125,18 +125,6 @@ + }; + }; + +- ethernet@60000000 { +- status = "okay"; +- +- ethernet-port@0 { +- phy-mode = "rgmii"; +- phy-handle = <&phy0>; +- }; +- ethernet-port@1 { +- /* Not used in this platform */ +- }; +- }; +- + usb@68000000 { + status = "okay"; + }; +diff --git a/arch/arm/boot/dts/imx6q-dhcom-som.dtsi b/arch/arm/boot/dts/imx6q-dhcom-som.dtsi +index 621894d13dcbc..3233927d33b4c 100644 +--- a/arch/arm/boot/dts/imx6q-dhcom-som.dtsi ++++ b/arch/arm/boot/dts/imx6q-dhcom-som.dtsi +@@ -98,30 +98,40 @@ + reg = <0>; + max-speed = <100>; + reset-gpios = <&gpio5 0 GPIO_ACTIVE_LOW>; +- reset-delay-us = <1000>; +- reset-post-delay-us = <1000>; ++ reset-assert-us = <1000>; ++ reset-deassert-us = <1000>; ++ smsc,disable-energy-detect; /* Make plugin detection reliable */ + }; + }; + }; + + &i2c1 { + clock-frequency = <100000>; +- pinctrl-names = "default"; ++ pinctrl-names = "default", "gpio"; + pinctrl-0 = <&pinctrl_i2c1>; ++ pinctrl-1 = <&pinctrl_i2c1_gpio>; ++ scl-gpios = <&gpio3 21 (GPIO_ACTIVE_HIGH | GPIO_OPEN_DRAIN)>; ++ sda-gpios = <&gpio3 28 (GPIO_ACTIVE_HIGH | GPIO_OPEN_DRAIN)>; + status = "okay"; + }; + + &i2c2 { + clock-frequency = <100000>; +- pinctrl-names = "default"; ++ pinctrl-names = "default", "gpio"; + pinctrl-0 = <&pinctrl_i2c2>; ++ pinctrl-1 = <&pinctrl_i2c2_gpio>; ++ scl-gpios = <&gpio4 12 (GPIO_ACTIVE_HIGH | GPIO_OPEN_DRAIN)>; ++ sda-gpios = <&gpio4 13 (GPIO_ACTIVE_HIGH | GPIO_OPEN_DRAIN)>; + status = "okay"; + }; + + &i2c3 { + clock-frequency = <100000>; +- pinctrl-names = "default"; ++ pinctrl-names = "default", "gpio"; + pinctrl-0 = <&pinctrl_i2c3>; ++ pinctrl-1 = <&pinctrl_i2c3_gpio>; ++ scl-gpios = <&gpio1 3 (GPIO_ACTIVE_HIGH | GPIO_OPEN_DRAIN)>; ++ sda-gpios = <&gpio1 6 (GPIO_ACTIVE_HIGH | GPIO_OPEN_DRAIN)>; + status = "okay"; + + ltc3676: pmic@3c { +@@ -287,6 +297,13 @@ + >; + }; + ++ pinctrl_i2c1_gpio: i2c1-gpio-grp { ++ fsl,pins = < ++ MX6QDL_PAD_EIM_D21__GPIO3_IO21 0x4001b8b1 ++ MX6QDL_PAD_EIM_D28__GPIO3_IO28 0x4001b8b1 ++ >; ++ }; ++ + pinctrl_i2c2: i2c2-grp { + fsl,pins = < + MX6QDL_PAD_KEY_COL3__I2C2_SCL 0x4001b8b1 +@@ -294,6 +311,13 @@ + >; + }; + ++ pinctrl_i2c2_gpio: i2c2-gpio-grp { ++ fsl,pins = < ++ MX6QDL_PAD_KEY_COL3__GPIO4_IO12 0x4001b8b1 ++ MX6QDL_PAD_KEY_ROW3__GPIO4_IO13 0x4001b8b1 ++ >; ++ }; ++ + pinctrl_i2c3: i2c3-grp { + fsl,pins = < + MX6QDL_PAD_GPIO_3__I2C3_SCL 0x4001b8b1 +@@ -301,6 +325,13 @@ + >; + }; + ++ pinctrl_i2c3_gpio: i2c3-gpio-grp { ++ fsl,pins = < ++ MX6QDL_PAD_GPIO_3__GPIO1_IO03 0x4001b8b1 ++ MX6QDL_PAD_GPIO_6__GPIO1_IO06 0x4001b8b1 ++ >; ++ }; ++ + pinctrl_pmic_hw300: pmic-hw300-grp { + fsl,pins = < + MX6QDL_PAD_EIM_A25__GPIO5_IO02 0x1B0B0 +diff --git a/arch/arm/boot/dts/r8a7779-marzen.dts b/arch/arm/boot/dts/r8a7779-marzen.dts +index c755f0b8fd0d7..29599adea2aba 100644 +--- a/arch/arm/boot/dts/r8a7779-marzen.dts ++++ b/arch/arm/boot/dts/r8a7779-marzen.dts +@@ -146,7 +146,7 @@ + status = "okay"; + + clocks = <&mstp1_clks R8A7779_CLK_DU>, <&x3_clk>; +- clock-names = "du", "dclkin.0"; ++ clock-names = "du.0", "dclkin.0"; + + ports { + port@0 { +diff --git a/arch/arm/boot/dts/r8a7779.dtsi b/arch/arm/boot/dts/r8a7779.dtsi +index 63341635bddf8..b3cb6492fc27e 100644 +--- a/arch/arm/boot/dts/r8a7779.dtsi ++++ b/arch/arm/boot/dts/r8a7779.dtsi +@@ -463,6 +463,7 @@ + reg = <0xfff80000 0x40000>; + interrupts = ; + clocks = <&mstp1_clks R8A7779_CLK_DU>; ++ clock-names = "du.0"; + power-domains = <&sysc R8A7779_PD_ALWAYS_ON>; + status = "disabled"; + +diff --git a/arch/arm/mach-exynos/exynos.c b/arch/arm/mach-exynos/exynos.c +index 9aa483366ebcb..f226d4f57bf41 100644 +--- a/arch/arm/mach-exynos/exynos.c ++++ b/arch/arm/mach-exynos/exynos.c +@@ -46,6 +46,7 @@ void __init exynos_sysram_init(void) + sysram_base_addr = of_iomap(node, 0); + sysram_base_phys = of_translate_address(node, + of_get_address(node, 0, NULL, NULL)); ++ of_node_put(node); + break; + } + +@@ -53,6 +54,7 @@ void __init exynos_sysram_init(void) + if (!of_device_is_available(node)) + continue; + sysram_ns_base_addr = of_iomap(node, 0); ++ of_node_put(node); + break; + } + } +diff --git a/arch/arm/probes/kprobes/test-thumb.c b/arch/arm/probes/kprobes/test-thumb.c +index 456c181a7bfe8..4e11f0b760f89 100644 +--- a/arch/arm/probes/kprobes/test-thumb.c ++++ b/arch/arm/probes/kprobes/test-thumb.c +@@ -441,21 +441,21 @@ void kprobe_thumb32_test_cases(void) + "3: mvn r0, r0 \n\t" + "2: nop \n\t") + +- TEST_RX("tbh [pc, r",7, (9f-(1f+4))>>1,"]", ++ TEST_RX("tbh [pc, r",7, (9f-(1f+4))>>1,", lsl #1]", + "9: \n\t" + ".short (2f-1b-4)>>1 \n\t" + ".short (3f-1b-4)>>1 \n\t" + "3: mvn r0, r0 \n\t" + "2: nop \n\t") + +- TEST_RX("tbh [pc, r",12, ((9f-(1f+4))>>1)+1,"]", ++ TEST_RX("tbh [pc, r",12, ((9f-(1f+4))>>1)+1,", lsl #1]", + "9: \n\t" + ".short (2f-1b-4)>>1 \n\t" + ".short (3f-1b-4)>>1 \n\t" + "3: mvn r0, r0 \n\t" + "2: nop \n\t") + +- TEST_RRX("tbh [r",1,9f, ", r",14,1,"]", ++ TEST_RRX("tbh [r",1,9f, ", r",14,1,", lsl #1]", + "9: \n\t" + ".short (2f-1b-4)>>1 \n\t" + ".short (3f-1b-4)>>1 \n\t" +@@ -468,10 +468,10 @@ void kprobe_thumb32_test_cases(void) + + TEST_UNSUPPORTED("strexb r0, r1, [r2]") + TEST_UNSUPPORTED("strexh r0, r1, [r2]") +- TEST_UNSUPPORTED("strexd r0, r1, [r2]") ++ TEST_UNSUPPORTED("strexd r0, r1, r2, [r2]") + TEST_UNSUPPORTED("ldrexb r0, [r1]") + TEST_UNSUPPORTED("ldrexh r0, [r1]") +- TEST_UNSUPPORTED("ldrexd r0, [r1]") ++ TEST_UNSUPPORTED("ldrexd r0, r1, [r1]") + + TEST_GROUP("Data-processing (shifted register) and (modified immediate)") + +diff --git a/arch/arm64/boot/dts/renesas/r8a77970-v3msk.dts b/arch/arm64/boot/dts/renesas/r8a77970-v3msk.dts +index d7c7b9156e082..5c391248ddb31 100644 +--- a/arch/arm64/boot/dts/renesas/r8a77970-v3msk.dts ++++ b/arch/arm64/boot/dts/renesas/r8a77970-v3msk.dts +@@ -59,7 +59,7 @@ + memory@48000000 { + device_type = "memory"; + /* first 128MB is reserved for secure area. */ +- reg = <0x0 0x48000000 0x0 0x38000000>; ++ reg = <0x0 0x48000000 0x0 0x78000000>; + }; + + osc5_clk: osc5-clock { +diff --git a/arch/hexagon/kernel/vmlinux.lds.S b/arch/hexagon/kernel/vmlinux.lds.S +index 78f2418e97c84..3c6b7abf0080e 100644 +--- a/arch/hexagon/kernel/vmlinux.lds.S ++++ b/arch/hexagon/kernel/vmlinux.lds.S +@@ -60,13 +60,8 @@ SECTIONS + + _end = .; + +- /DISCARD/ : { +- EXIT_TEXT +- EXIT_DATA +- EXIT_CALL +- } +- + STABS_DEBUG + DWARF_DEBUG + ++ DISCARDS + } +diff --git a/arch/mips/boot/compressed/Makefile b/arch/mips/boot/compressed/Makefile +index 378cbfb31ee70..1d6ebbc2a5d02 100644 +--- a/arch/mips/boot/compressed/Makefile ++++ b/arch/mips/boot/compressed/Makefile +@@ -33,7 +33,7 @@ KBUILD_AFLAGS := $(KBUILD_AFLAGS) -D__ASSEMBLY__ \ + KCOV_INSTRUMENT := n + + # decompressor objects (linked with vmlinuz) +-vmlinuzobjs-y := $(obj)/head.o $(obj)/decompress.o $(obj)/string.o ++vmlinuzobjs-y := $(obj)/head.o $(obj)/decompress.o $(obj)/string.o $(obj)/bswapsi.o + + ifdef CONFIG_DEBUG_ZBOOT + vmlinuzobjs-$(CONFIG_DEBUG_ZBOOT) += $(obj)/dbg.o +@@ -47,7 +47,7 @@ extra-y += uart-ath79.c + $(obj)/uart-ath79.c: $(srctree)/arch/mips/ath79/early_printk.c + $(call cmd,shipped) + +-vmlinuzobjs-$(CONFIG_KERNEL_XZ) += $(obj)/ashldi3.o $(obj)/bswapsi.o ++vmlinuzobjs-$(CONFIG_KERNEL_XZ) += $(obj)/ashldi3.o + + extra-y += ashldi3.c + $(obj)/ashldi3.c: $(obj)/%.c: $(srctree)/lib/%.c FORCE +diff --git a/arch/mips/boot/compressed/decompress.c b/arch/mips/boot/compressed/decompress.c +index a52e929381ea4..281e922e5c652 100644 +--- a/arch/mips/boot/compressed/decompress.c ++++ b/arch/mips/boot/compressed/decompress.c +@@ -7,6 +7,8 @@ + * Author: Wu Zhangjin + */ + ++#define DISABLE_BRANCH_PROFILING ++ + #include + #include + #include +diff --git a/arch/mips/include/asm/vdso/vdso.h b/arch/mips/include/asm/vdso/vdso.h +index 737ddfc3411cb..a327ca21270ec 100644 +--- a/arch/mips/include/asm/vdso/vdso.h ++++ b/arch/mips/include/asm/vdso/vdso.h +@@ -67,7 +67,7 @@ static inline const struct vdso_data *get_vdso_data(void) + + static inline void __iomem *get_gic(const struct vdso_data *data) + { +- return (void __iomem *)data - PAGE_SIZE; ++ return (void __iomem *)((unsigned long)data & PAGE_MASK) - PAGE_SIZE; + } + + #endif /* CONFIG_CLKSRC_MIPS_GIC */ +diff --git a/arch/powerpc/boot/devtree.c b/arch/powerpc/boot/devtree.c +index 5d91036ad626d..58fbcfcc98c9e 100644 +--- a/arch/powerpc/boot/devtree.c ++++ b/arch/powerpc/boot/devtree.c +@@ -13,6 +13,7 @@ + #include "string.h" + #include "stdio.h" + #include "ops.h" ++#include "of.h" + + void dt_fixup_memory(u64 start, u64 size) + { +@@ -23,21 +24,25 @@ void dt_fixup_memory(u64 start, u64 size) + root = finddevice("/"); + if (getprop(root, "#address-cells", &naddr, sizeof(naddr)) < 0) + naddr = 2; ++ else ++ naddr = be32_to_cpu(naddr); + if (naddr < 1 || naddr > 2) + fatal("Can't cope with #address-cells == %d in /\n\r", naddr); + + if (getprop(root, "#size-cells", &nsize, sizeof(nsize)) < 0) + nsize = 1; ++ else ++ nsize = be32_to_cpu(nsize); + if (nsize < 1 || nsize > 2) + fatal("Can't cope with #size-cells == %d in /\n\r", nsize); + + i = 0; + if (naddr == 2) +- memreg[i++] = start >> 32; +- memreg[i++] = start & 0xffffffff; ++ memreg[i++] = cpu_to_be32(start >> 32); ++ memreg[i++] = cpu_to_be32(start & 0xffffffff); + if (nsize == 2) +- memreg[i++] = size >> 32; +- memreg[i++] = size & 0xffffffff; ++ memreg[i++] = cpu_to_be32(size >> 32); ++ memreg[i++] = cpu_to_be32(size & 0xffffffff); + + memory = finddevice("/memory"); + if (! memory) { +@@ -45,9 +50,9 @@ void dt_fixup_memory(u64 start, u64 size) + setprop_str(memory, "device_type", "memory"); + } + +- printf("Memory <- <0x%x", memreg[0]); ++ printf("Memory <- <0x%x", be32_to_cpu(memreg[0])); + for (i = 1; i < (naddr + nsize); i++) +- printf(" 0x%x", memreg[i]); ++ printf(" 0x%x", be32_to_cpu(memreg[i])); + printf("> (%ldMB)\n\r", (unsigned long)(size >> 20)); + + setprop(memory, "reg", memreg, (naddr + nsize)*sizeof(u32)); +@@ -65,10 +70,10 @@ void dt_fixup_cpu_clocks(u32 cpu, u32 tb, u32 bus) + printf("CPU bus-frequency <- 0x%x (%dMHz)\n\r", bus, MHZ(bus)); + + while ((devp = find_node_by_devtype(devp, "cpu"))) { +- setprop_val(devp, "clock-frequency", cpu); +- setprop_val(devp, "timebase-frequency", tb); ++ setprop_val(devp, "clock-frequency", cpu_to_be32(cpu)); ++ setprop_val(devp, "timebase-frequency", cpu_to_be32(tb)); + if (bus > 0) +- setprop_val(devp, "bus-frequency", bus); ++ setprop_val(devp, "bus-frequency", cpu_to_be32(bus)); + } + + timebase_period_ns = 1000000000 / tb; +@@ -80,7 +85,7 @@ void dt_fixup_clock(const char *path, u32 freq) + + if (devp) { + printf("%s: clock-frequency <- %x (%dMHz)\n\r", path, freq, MHZ(freq)); +- setprop_val(devp, "clock-frequency", freq); ++ setprop_val(devp, "clock-frequency", cpu_to_be32(freq)); + } + } + +@@ -133,8 +138,12 @@ void dt_get_reg_format(void *node, u32 *naddr, u32 *nsize) + { + if (getprop(node, "#address-cells", naddr, 4) != 4) + *naddr = 2; ++ else ++ *naddr = be32_to_cpu(*naddr); + if (getprop(node, "#size-cells", nsize, 4) != 4) + *nsize = 1; ++ else ++ *nsize = be32_to_cpu(*nsize); + } + + static void copy_val(u32 *dest, u32 *src, int naddr) +@@ -163,9 +172,9 @@ static int add_reg(u32 *reg, u32 *add, int naddr) + int i, carry = 0; + + for (i = MAX_ADDR_CELLS - 1; i >= MAX_ADDR_CELLS - naddr; i--) { +- u64 tmp = (u64)reg[i] + add[i] + carry; ++ u64 tmp = (u64)be32_to_cpu(reg[i]) + be32_to_cpu(add[i]) + carry; + carry = tmp >> 32; +- reg[i] = (u32)tmp; ++ reg[i] = cpu_to_be32((u32)tmp); + } + + return !carry; +@@ -180,18 +189,18 @@ static int compare_reg(u32 *reg, u32 *range, u32 *rangesize) + u32 end; + + for (i = 0; i < MAX_ADDR_CELLS; i++) { +- if (reg[i] < range[i]) ++ if (be32_to_cpu(reg[i]) < be32_to_cpu(range[i])) + return 0; +- if (reg[i] > range[i]) ++ if (be32_to_cpu(reg[i]) > be32_to_cpu(range[i])) + break; + } + + for (i = 0; i < MAX_ADDR_CELLS; i++) { +- end = range[i] + rangesize[i]; ++ end = be32_to_cpu(range[i]) + be32_to_cpu(rangesize[i]); + +- if (reg[i] < end) ++ if (be32_to_cpu(reg[i]) < end) + break; +- if (reg[i] > end) ++ if (be32_to_cpu(reg[i]) > end) + return 0; + } + +@@ -240,7 +249,6 @@ static int dt_xlate(void *node, int res, int reglen, unsigned long *addr, + return 0; + + dt_get_reg_format(parent, &naddr, &nsize); +- + if (nsize > 2) + return 0; + +@@ -252,10 +260,10 @@ static int dt_xlate(void *node, int res, int reglen, unsigned long *addr, + + copy_val(last_addr, prop_buf + offset, naddr); + +- ret_size = prop_buf[offset + naddr]; ++ ret_size = be32_to_cpu(prop_buf[offset + naddr]); + if (nsize == 2) { + ret_size <<= 32; +- ret_size |= prop_buf[offset + naddr + 1]; ++ ret_size |= be32_to_cpu(prop_buf[offset + naddr + 1]); + } + + for (;;) { +@@ -278,7 +286,6 @@ static int dt_xlate(void *node, int res, int reglen, unsigned long *addr, + + offset = find_range(last_addr, prop_buf, prev_naddr, + naddr, prev_nsize, buflen / 4); +- + if (offset < 0) + return 0; + +@@ -296,8 +303,7 @@ static int dt_xlate(void *node, int res, int reglen, unsigned long *addr, + if (naddr > 2) + return 0; + +- ret_addr = ((u64)last_addr[2] << 32) | last_addr[3]; +- ++ ret_addr = ((u64)be32_to_cpu(last_addr[2]) << 32) | be32_to_cpu(last_addr[3]); + if (sizeof(void *) == 4 && + (ret_addr >= 0x100000000ULL || ret_size > 0x100000000ULL || + ret_addr + ret_size > 0x100000000ULL)) +@@ -350,11 +356,14 @@ int dt_is_compatible(void *node, const char *compat) + int dt_get_virtual_reg(void *node, void **addr, int nres) + { + unsigned long xaddr; +- int n; ++ int n, i; + + n = getprop(node, "virtual-reg", addr, nres * 4); +- if (n > 0) ++ if (n > 0) { ++ for (i = 0; i < n/4; i ++) ++ ((u32 *)addr)[i] = be32_to_cpu(((u32 *)addr)[i]); + return n / 4; ++ } + + for (n = 0; n < nres; n++) { + if (!dt_xlate_reg(node, n, &xaddr, NULL)) +diff --git a/arch/powerpc/boot/ns16550.c b/arch/powerpc/boot/ns16550.c +index b0da4466d4198..f16d2be1d0f31 100644 +--- a/arch/powerpc/boot/ns16550.c ++++ b/arch/powerpc/boot/ns16550.c +@@ -15,6 +15,7 @@ + #include "stdio.h" + #include "io.h" + #include "ops.h" ++#include "of.h" + + #define UART_DLL 0 /* Out: Divisor Latch Low */ + #define UART_DLM 1 /* Out: Divisor Latch High */ +@@ -58,16 +59,20 @@ int ns16550_console_init(void *devp, struct serial_console_data *scdp) + int n; + u32 reg_offset; + +- if (dt_get_virtual_reg(devp, (void **)®_base, 1) < 1) ++ if (dt_get_virtual_reg(devp, (void **)®_base, 1) < 1) { ++ printf("virt reg parse fail...\r\n"); + return -1; ++ } + + n = getprop(devp, "reg-offset", ®_offset, sizeof(reg_offset)); + if (n == sizeof(reg_offset)) +- reg_base += reg_offset; ++ reg_base += be32_to_cpu(reg_offset); + + n = getprop(devp, "reg-shift", ®_shift, sizeof(reg_shift)); + if (n != sizeof(reg_shift)) + reg_shift = 0; ++ else ++ reg_shift = be32_to_cpu(reg_shift); + + scdp->open = ns16550_open; + scdp->putc = ns16550_putc; +diff --git a/arch/powerpc/include/asm/ps3.h b/arch/powerpc/include/asm/ps3.h +index cb89e4bf55cef..964063765662b 100644 +--- a/arch/powerpc/include/asm/ps3.h ++++ b/arch/powerpc/include/asm/ps3.h +@@ -71,6 +71,7 @@ struct ps3_dma_region_ops; + * @bus_addr: The 'translated' bus address of the region. + * @len: The length in bytes of the region. + * @offset: The offset from the start of memory of the region. ++ * @dma_mask: Device dma_mask. + * @ioid: The IOID of the device who owns this region + * @chunk_list: Opaque variable used by the ioc page manager. + * @region_ops: struct ps3_dma_region_ops - dma region operations +@@ -85,6 +86,7 @@ struct ps3_dma_region { + enum ps3_dma_region_type region_type; + unsigned long len; + unsigned long offset; ++ u64 dma_mask; + + /* driver variables (set by ps3_dma_region_create) */ + unsigned long bus_addr; +diff --git a/arch/powerpc/platforms/ps3/mm.c b/arch/powerpc/platforms/ps3/mm.c +index f42fe4e86ce52..c3e3746694003 100644 +--- a/arch/powerpc/platforms/ps3/mm.c ++++ b/arch/powerpc/platforms/ps3/mm.c +@@ -6,6 +6,7 @@ + * Copyright 2006 Sony Corp. + */ + ++#include + #include + #include + #include +@@ -1118,6 +1119,7 @@ int ps3_dma_region_init(struct ps3_system_bus_device *dev, + enum ps3_dma_region_type region_type, void *addr, unsigned long len) + { + unsigned long lpar_addr; ++ int result; + + lpar_addr = addr ? ps3_mm_phys_to_lpar(__pa(addr)) : 0; + +@@ -1129,6 +1131,16 @@ int ps3_dma_region_init(struct ps3_system_bus_device *dev, + r->offset -= map.r1.offset; + r->len = len ? len : _ALIGN_UP(map.total, 1 << r->page_size); + ++ dev->core.dma_mask = &r->dma_mask; ++ ++ result = dma_set_mask_and_coherent(&dev->core, DMA_BIT_MASK(32)); ++ ++ if (result < 0) { ++ dev_err(&dev->core, "%s:%d: dma_set_mask_and_coherent failed: %d\n", ++ __func__, __LINE__, result); ++ return result; ++ } ++ + switch (dev->dev_type) { + case PS3_DEVICE_TYPE_SB: + r->region_ops = (USE_DYNAMIC_DMA) +diff --git a/arch/s390/boot/ipl_parm.c b/arch/s390/boot/ipl_parm.c +index 24ef67eb1ceff..75905b548f69d 100644 +--- a/arch/s390/boot/ipl_parm.c ++++ b/arch/s390/boot/ipl_parm.c +@@ -27,22 +27,25 @@ static inline int __diag308(unsigned long subcode, void *addr) + register unsigned long _addr asm("0") = (unsigned long)addr; + register unsigned long _rc asm("1") = 0; + unsigned long reg1, reg2; +- psw_t old = S390_lowcore.program_new_psw; ++ psw_t old; + + asm volatile( ++ " mvc 0(16,%[psw_old]),0(%[psw_pgm])\n" + " epsw %0,%1\n" +- " st %0,%[psw_pgm]\n" +- " st %1,%[psw_pgm]+4\n" ++ " st %0,0(%[psw_pgm])\n" ++ " st %1,4(%[psw_pgm])\n" + " larl %0,1f\n" +- " stg %0,%[psw_pgm]+8\n" ++ " stg %0,8(%[psw_pgm])\n" + " diag %[addr],%[subcode],0x308\n" +- "1: nopr %%r7\n" ++ "1: mvc 0(16,%[psw_pgm]),0(%[psw_old])\n" + : "=&d" (reg1), "=&a" (reg2), +- [psw_pgm] "=Q" (S390_lowcore.program_new_psw), ++ "+Q" (S390_lowcore.program_new_psw), ++ "=Q" (old), + [addr] "+d" (_addr), "+d" (_rc) +- : [subcode] "d" (subcode) ++ : [subcode] "d" (subcode), ++ [psw_old] "a" (&old), ++ [psw_pgm] "a" (&S390_lowcore.program_new_psw) + : "cc", "memory"); +- S390_lowcore.program_new_psw = old; + return _rc; + } + +diff --git a/arch/s390/boot/mem_detect.c b/arch/s390/boot/mem_detect.c +index 62e7c13ce85c7..85049541c191e 100644 +--- a/arch/s390/boot/mem_detect.c ++++ b/arch/s390/boot/mem_detect.c +@@ -70,24 +70,27 @@ static int __diag260(unsigned long rx1, unsigned long rx2) + register unsigned long _ry asm("4") = 0x10; /* storage configuration */ + int rc = -1; /* fail */ + unsigned long reg1, reg2; +- psw_t old = S390_lowcore.program_new_psw; ++ psw_t old; + + asm volatile( ++ " mvc 0(16,%[psw_old]),0(%[psw_pgm])\n" + " epsw %0,%1\n" +- " st %0,%[psw_pgm]\n" +- " st %1,%[psw_pgm]+4\n" ++ " st %0,0(%[psw_pgm])\n" ++ " st %1,4(%[psw_pgm])\n" + " larl %0,1f\n" +- " stg %0,%[psw_pgm]+8\n" ++ " stg %0,8(%[psw_pgm])\n" + " diag %[rx],%[ry],0x260\n" + " ipm %[rc]\n" + " srl %[rc],28\n" +- "1:\n" ++ "1: mvc 0(16,%[psw_pgm]),0(%[psw_old])\n" + : "=&d" (reg1), "=&a" (reg2), +- [psw_pgm] "=Q" (S390_lowcore.program_new_psw), ++ "+Q" (S390_lowcore.program_new_psw), ++ "=Q" (old), + [rc] "+&d" (rc), [ry] "+d" (_ry) +- : [rx] "d" (_rx1), "d" (_rx2) ++ : [rx] "d" (_rx1), "d" (_rx2), ++ [psw_old] "a" (&old), ++ [psw_pgm] "a" (&S390_lowcore.program_new_psw) + : "cc", "memory"); +- S390_lowcore.program_new_psw = old; + return rc == 0 ? _ry : -1; + } + +@@ -112,24 +115,30 @@ static int diag260(void) + + static int tprot(unsigned long addr) + { +- unsigned long pgm_addr; ++ unsigned long reg1, reg2; + int rc = -EFAULT; +- psw_t old = S390_lowcore.program_new_psw; ++ psw_t old; + +- S390_lowcore.program_new_psw.mask = __extract_psw(); + asm volatile( +- " larl %[pgm_addr],1f\n" +- " stg %[pgm_addr],%[psw_pgm_addr]\n" ++ " mvc 0(16,%[psw_old]),0(%[psw_pgm])\n" ++ " epsw %[reg1],%[reg2]\n" ++ " st %[reg1],0(%[psw_pgm])\n" ++ " st %[reg2],4(%[psw_pgm])\n" ++ " larl %[reg1],1f\n" ++ " stg %[reg1],8(%[psw_pgm])\n" + " tprot 0(%[addr]),0\n" + " ipm %[rc]\n" + " srl %[rc],28\n" +- "1:\n" +- : [pgm_addr] "=&d"(pgm_addr), +- [psw_pgm_addr] "=Q"(S390_lowcore.program_new_psw.addr), +- [rc] "+&d"(rc) +- : [addr] "a"(addr) ++ "1: mvc 0(16,%[psw_pgm]),0(%[psw_old])\n" ++ : [reg1] "=&d" (reg1), ++ [reg2] "=&a" (reg2), ++ [rc] "+&d" (rc), ++ "=Q" (S390_lowcore.program_new_psw.addr), ++ "=Q" (old) ++ : [psw_old] "a" (&old), ++ [psw_pgm] "a" (&S390_lowcore.program_new_psw), ++ [addr] "a" (addr) + : "cc", "memory"); +- S390_lowcore.program_new_psw = old; + return rc; + } + +diff --git a/arch/s390/include/asm/processor.h b/arch/s390/include/asm/processor.h +index 560d8b77b1d17..48d6ccdef5f77 100644 +--- a/arch/s390/include/asm/processor.h ++++ b/arch/s390/include/asm/processor.h +@@ -215,7 +215,7 @@ static inline unsigned long current_stack_pointer(void) + return sp; + } + +-static __no_kasan_or_inline unsigned short stap(void) ++static __always_inline unsigned short stap(void) + { + unsigned short cpu_address; + +@@ -254,7 +254,7 @@ static inline void __load_psw(psw_t psw) + * Set PSW mask to specified value, while leaving the + * PSW addr pointing to the next instruction. + */ +-static __no_kasan_or_inline void __load_psw_mask(unsigned long mask) ++static __always_inline void __load_psw_mask(unsigned long mask) + { + unsigned long addr; + psw_t psw; +diff --git a/arch/s390/kernel/setup.c b/arch/s390/kernel/setup.c +index 3588f4c65a4d4..f661f176966f5 100644 +--- a/arch/s390/kernel/setup.c ++++ b/arch/s390/kernel/setup.c +@@ -162,7 +162,7 @@ static void __init set_preferred_console(void) + else if (CONSOLE_IS_3270) + add_preferred_console("tty3270", 0, NULL); + else if (CONSOLE_IS_VT220) +- add_preferred_console("ttyS", 1, NULL); ++ add_preferred_console("ttysclp", 0, NULL); + else if (CONSOLE_IS_HVC) + add_preferred_console("hvc", 0, NULL); + } +diff --git a/arch/um/drivers/chan_user.c b/arch/um/drivers/chan_user.c +index d8845d4aac6a7..6040817c036f3 100644 +--- a/arch/um/drivers/chan_user.c ++++ b/arch/um/drivers/chan_user.c +@@ -256,7 +256,8 @@ static int winch_tramp(int fd, struct tty_port *port, int *fd_out, + goto out_close; + } + +- if (os_set_fd_block(*fd_out, 0)) { ++ err = os_set_fd_block(*fd_out, 0); ++ if (err) { + printk(UM_KERN_ERR "winch_tramp: failed to set thread_fd " + "non-blocking.\n"); + goto out_close; +diff --git a/arch/um/drivers/slip_user.c b/arch/um/drivers/slip_user.c +index 8016d32b68092..8d736eb629614 100644 +--- a/arch/um/drivers/slip_user.c ++++ b/arch/um/drivers/slip_user.c +@@ -145,7 +145,8 @@ static int slip_open(void *data) + } + sfd = err; + +- if (set_up_tty(sfd)) ++ err = set_up_tty(sfd); ++ if (err) + goto out_close2; + + pri->slave = sfd; +diff --git a/arch/x86/include/asm/fpu/internal.h b/arch/x86/include/asm/fpu/internal.h +index 9f135e5b9cf51..a9d1dd82d8208 100644 +--- a/arch/x86/include/asm/fpu/internal.h ++++ b/arch/x86/include/asm/fpu/internal.h +@@ -102,6 +102,7 @@ static inline void fpstate_init_fxstate(struct fxregs_state *fx) + } + extern void fpstate_sanitize_xstate(struct fpu *fpu); + ++/* Returns 0 or the negated trap number, which results in -EFAULT for #PF */ + #define user_insn(insn, output, input...) \ + ({ \ + int err; \ +@@ -109,14 +110,14 @@ extern void fpstate_sanitize_xstate(struct fpu *fpu); + might_fault(); \ + \ + asm volatile(ASM_STAC "\n" \ +- "1:" #insn "\n\t" \ ++ "1: " #insn "\n" \ + "2: " ASM_CLAC "\n" \ + ".section .fixup,\"ax\"\n" \ +- "3: movl $-1,%[err]\n" \ ++ "3: negl %%eax\n" \ + " jmp 2b\n" \ + ".previous\n" \ +- _ASM_EXTABLE(1b, 3b) \ +- : [err] "=r" (err), output \ ++ _ASM_EXTABLE_FAULT(1b, 3b) \ ++ : [err] "=a" (err), output \ + : "0"(0), input); \ + err; \ + }) +@@ -210,16 +211,20 @@ static inline void copy_fxregs_to_kernel(struct fpu *fpu) + #define XRSTOR ".byte " REX_PREFIX "0x0f,0xae,0x2f" + #define XRSTORS ".byte " REX_PREFIX "0x0f,0xc7,0x1f" + ++/* ++ * After this @err contains 0 on success or the negated trap number when ++ * the operation raises an exception. For faults this results in -EFAULT. ++ */ + #define XSTATE_OP(op, st, lmask, hmask, err) \ + asm volatile("1:" op "\n\t" \ + "xor %[err], %[err]\n" \ + "2:\n\t" \ + ".pushsection .fixup,\"ax\"\n\t" \ +- "3: movl $-2,%[err]\n\t" \ ++ "3: negl %%eax\n\t" \ + "jmp 2b\n\t" \ + ".popsection\n\t" \ +- _ASM_EXTABLE(1b, 3b) \ +- : [err] "=r" (err) \ ++ _ASM_EXTABLE_FAULT(1b, 3b) \ ++ : [err] "=a" (err) \ + : "D" (st), "m" (*st), "a" (lmask), "d" (hmask) \ + : "memory") + +diff --git a/arch/x86/kernel/fpu/regset.c b/arch/x86/kernel/fpu/regset.c +index d652b939ccfb5..68e1fb66e701b 100644 +--- a/arch/x86/kernel/fpu/regset.c ++++ b/arch/x86/kernel/fpu/regset.c +@@ -124,7 +124,7 @@ int xstateregs_set(struct task_struct *target, const struct user_regset *regset, + /* + * A whole standard-format XSAVE buffer is needed: + */ +- if ((pos != 0) || (count < fpu_user_xstate_size)) ++ if (pos != 0 || count != fpu_user_xstate_size) + return -EFAULT; + + xsave = &fpu->state.xsave; +diff --git a/arch/x86/kernel/signal.c b/arch/x86/kernel/signal.c +index 2fdbf5ef8c39c..026ce06a24c03 100644 +--- a/arch/x86/kernel/signal.c ++++ b/arch/x86/kernel/signal.c +@@ -241,10 +241,11 @@ get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size, + void __user **fpstate) + { + /* Default to using normal stack */ ++ bool nested_altstack = on_sig_stack(regs->sp); ++ bool entering_altstack = false; + unsigned long math_size = 0; + unsigned long sp = regs->sp; + unsigned long buf_fx = 0; +- int onsigstack = on_sig_stack(sp); + int ret; + + /* redzone */ +@@ -253,15 +254,23 @@ get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size, + + /* This is the X/Open sanctioned signal stack switching. */ + if (ka->sa.sa_flags & SA_ONSTACK) { +- if (sas_ss_flags(sp) == 0) ++ /* ++ * This checks nested_altstack via sas_ss_flags(). Sensible ++ * programs use SS_AUTODISARM, which disables that check, and ++ * programs that don't use SS_AUTODISARM get compatible. ++ */ ++ if (sas_ss_flags(sp) == 0) { + sp = current->sas_ss_sp + current->sas_ss_size; ++ entering_altstack = true; ++ } + } else if (IS_ENABLED(CONFIG_X86_32) && +- !onsigstack && ++ !nested_altstack && + regs->ss != __USER_DS && + !(ka->sa.sa_flags & SA_RESTORER) && + ka->sa.sa_restorer) { + /* This is the legacy signal stack switching. */ + sp = (unsigned long) ka->sa.sa_restorer; ++ entering_altstack = true; + } + + sp = fpu__alloc_mathframe(sp, IS_ENABLED(CONFIG_X86_32), +@@ -274,8 +283,15 @@ get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size, + * If we are on the alternate signal stack and would overflow it, don't. + * Return an always-bogus address instead so we will die with SIGSEGV. + */ +- if (onsigstack && !likely(on_sig_stack(sp))) ++ if (unlikely((nested_altstack || entering_altstack) && ++ !__on_sig_stack(sp))) { ++ ++ if (show_unhandled_signals && printk_ratelimit()) ++ pr_info("%s[%d] overflowed sigaltstack\n", ++ current->comm, task_pid_nr(current)); ++ + return (void __user *)-1L; ++ } + + /* save i387 and extended state */ + ret = copy_fpstate_to_sigframe(*fpstate, (void __user *)buf_fx, math_size); +diff --git a/arch/x86/kvm/cpuid.c b/arch/x86/kvm/cpuid.c +index 6fa946f983c92..6a8db8eb0e943 100644 +--- a/arch/x86/kvm/cpuid.c ++++ b/arch/x86/kvm/cpuid.c +@@ -745,8 +745,14 @@ static inline int __do_cpuid_func(struct kvm_cpuid_entry2 *entry, u32 function, + unsigned virt_as = max((entry->eax >> 8) & 0xff, 48U); + unsigned phys_as = entry->eax & 0xff; + +- if (!g_phys_as) ++ /* ++ * Use bare metal's MAXPHADDR if the CPU doesn't report guest ++ * MAXPHYADDR separately, or if TDP (NPT) is disabled, as the ++ * guest version "applies only to guests using nested paging". ++ */ ++ if (!g_phys_as || !tdp_enabled) + g_phys_as = phys_as; ++ + entry->eax = g_phys_as | (virt_as << 8); + entry->edx = 0; + entry->ebx &= kvm_cpuid_8000_0008_ebx_x86_features; +diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c +index 4cc052108f156..377157656a8b6 100644 +--- a/arch/x86/kvm/x86.c ++++ b/arch/x86/kvm/x86.c +@@ -8271,6 +8271,8 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) + set_debugreg(vcpu->arch.eff_db[3], 3); + set_debugreg(vcpu->arch.dr6, 6); + vcpu->arch.switch_db_regs &= ~KVM_DEBUGREG_RELOAD; ++ } else if (unlikely(hw_breakpoint_active())) { ++ set_debugreg(0, 7); + } + + kvm_x86_ops->run(vcpu); +diff --git a/drivers/acpi/acpi_amba.c b/drivers/acpi/acpi_amba.c +index 49b781a9cd979..ab8a4e0191b19 100644 +--- a/drivers/acpi/acpi_amba.c ++++ b/drivers/acpi/acpi_amba.c +@@ -76,6 +76,7 @@ static int amba_handler_attach(struct acpi_device *adev, + case IORESOURCE_MEM: + if (!address_found) { + dev->res = *rentry->res; ++ dev->res.name = dev_name(&dev->dev); + address_found = true; + } + break; +diff --git a/drivers/acpi/acpi_video.c b/drivers/acpi/acpi_video.c +index 4f325e47519f5..81cd47d299320 100644 +--- a/drivers/acpi/acpi_video.c ++++ b/drivers/acpi/acpi_video.c +@@ -543,6 +543,15 @@ static const struct dmi_system_id video_dmi_table[] = { + DMI_MATCH(DMI_PRODUCT_NAME, "Vostro V131"), + }, + }, ++ { ++ .callback = video_set_report_key_events, ++ .driver_data = (void *)((uintptr_t)REPORT_BRIGHTNESS_KEY_EVENTS), ++ .ident = "Dell Vostro 3350", ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), ++ DMI_MATCH(DMI_PRODUCT_NAME, "Vostro 3350"), ++ }, ++ }, + /* + * Some machines change the brightness themselves when a brightness + * hotkey gets pressed, despite us telling them not to. In this case +diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c +index 2eeb2bcb488d4..816eb2db73080 100644 +--- a/drivers/block/virtio_blk.c ++++ b/drivers/block/virtio_blk.c +@@ -1057,6 +1057,8 @@ static int virtblk_freeze(struct virtio_device *vdev) + blk_mq_quiesce_queue(vblk->disk->queue); + + vdev->config->del_vqs(vdev); ++ kfree(vblk->vqs); ++ + return 0; + } + +diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c +index 5eabbf73fdef7..b453029487a12 100644 +--- a/drivers/char/virtio_console.c ++++ b/drivers/char/virtio_console.c +@@ -475,7 +475,7 @@ static struct port_buffer *get_inbuf(struct port *port) + + buf = virtqueue_get_buf(port->in_vq, &len); + if (buf) { +- buf->len = len; ++ buf->len = min_t(size_t, len, buf->size); + buf->offset = 0; + port->stats.bytes_received += len; + } +@@ -1714,7 +1714,7 @@ static void control_work_handler(struct work_struct *work) + while ((buf = virtqueue_get_buf(vq, &len))) { + spin_unlock(&portdev->c_ivq_lock); + +- buf->len = len; ++ buf->len = min_t(size_t, len, buf->size); + buf->offset = 0; + + handle_control_message(vq->vdev, portdev, buf); +diff --git a/drivers/dma/fsl-qdma.c b/drivers/dma/fsl-qdma.c +index 95cc0256b3878..f5a1ae164193f 100644 +--- a/drivers/dma/fsl-qdma.c ++++ b/drivers/dma/fsl-qdma.c +@@ -1184,7 +1184,11 @@ static int fsl_qdma_probe(struct platform_device *pdev) + fsl_qdma->dma_dev.device_synchronize = fsl_qdma_synchronize; + fsl_qdma->dma_dev.device_terminate_all = fsl_qdma_terminate_all; + +- dma_set_mask(&pdev->dev, DMA_BIT_MASK(40)); ++ ret = dma_set_mask(&pdev->dev, DMA_BIT_MASK(40)); ++ if (ret) { ++ dev_err(&pdev->dev, "dma_set_mask failure.\n"); ++ return ret; ++ } + + platform_set_drvdata(pdev, fsl_qdma); + +diff --git a/drivers/firmware/arm_scmi/driver.c b/drivers/firmware/arm_scmi/driver.c +index 11078199abed3..7b6903bad4085 100644 +--- a/drivers/firmware/arm_scmi/driver.c ++++ b/drivers/firmware/arm_scmi/driver.c +@@ -370,6 +370,10 @@ static void scmi_rx_callback(struct mbox_client *cl, void *m) + + xfer = &minfo->xfer_block[xfer_id]; + ++ /* rx.len could be shrunk in the sync do_xfer, so reset to maxsz */ ++ if (msg_type == MSG_TYPE_DELAYED_RESP) ++ xfer->rx.len = info->desc->max_msg_size; ++ + scmi_dump_header_dbg(dev, &xfer->hdr); + + scmi_fetch_response(xfer, mem); +diff --git a/drivers/firmware/tegra/bpmp-tegra210.c b/drivers/firmware/tegra/bpmp-tegra210.c +index ae15940a078e3..c32754055c60b 100644 +--- a/drivers/firmware/tegra/bpmp-tegra210.c ++++ b/drivers/firmware/tegra/bpmp-tegra210.c +@@ -210,7 +210,7 @@ static int tegra210_bpmp_init(struct tegra_bpmp *bpmp) + priv->tx_irq_data = irq_get_irq_data(err); + if (!priv->tx_irq_data) { + dev_err(&pdev->dev, "failed to get IRQ data for TX IRQ\n"); +- return err; ++ return -ENOENT; + } + + err = platform_get_irq_byname(pdev, "rx"); +diff --git a/drivers/firmware/turris-mox-rwtm.c b/drivers/firmware/turris-mox-rwtm.c +index 72be58960e540..9a6cf5af27a3d 100644 +--- a/drivers/firmware/turris-mox-rwtm.c ++++ b/drivers/firmware/turris-mox-rwtm.c +@@ -134,11 +134,14 @@ MOX_ATTR_RO(pubkey, "%s\n", pubkey); + + static int mox_get_status(enum mbox_cmd cmd, u32 retval) + { +- if (MBOX_STS_CMD(retval) != cmd || +- MBOX_STS_ERROR(retval) != MBOX_STS_SUCCESS) ++ if (MBOX_STS_CMD(retval) != cmd) + return -EIO; + else if (MBOX_STS_ERROR(retval) == MBOX_STS_FAIL) + return -(int)MBOX_STS_VALUE(retval); ++ else if (MBOX_STS_ERROR(retval) == MBOX_STS_BADCMD) ++ return -ENOSYS; ++ else if (MBOX_STS_ERROR(retval) != MBOX_STS_SUCCESS) ++ return -EIO; + else + return MBOX_STS_VALUE(retval); + } +@@ -188,11 +191,14 @@ static int mox_get_board_info(struct mox_rwtm *rwtm) + return ret; + + ret = mox_get_status(MBOX_CMD_BOARD_INFO, reply->retval); +- if (ret < 0 && ret != -ENODATA) { +- return ret; +- } else if (ret == -ENODATA) { ++ if (ret == -ENODATA) { + dev_warn(rwtm->dev, + "Board does not have manufacturing information burned!\n"); ++ } else if (ret == -ENOSYS) { ++ dev_notice(rwtm->dev, ++ "Firmware does not support the BOARD_INFO command\n"); ++ } else if (ret < 0) { ++ return ret; + } else { + rwtm->serial_number = reply->status[1]; + rwtm->serial_number <<= 32; +@@ -221,10 +227,13 @@ static int mox_get_board_info(struct mox_rwtm *rwtm) + return ret; + + ret = mox_get_status(MBOX_CMD_ECDSA_PUB_KEY, reply->retval); +- if (ret < 0 && ret != -ENODATA) { +- return ret; +- } else if (ret == -ENODATA) { ++ if (ret == -ENODATA) { + dev_warn(rwtm->dev, "Board has no public key burned!\n"); ++ } else if (ret == -ENOSYS) { ++ dev_notice(rwtm->dev, ++ "Firmware does not support the ECDSA_PUB_KEY command\n"); ++ } else if (ret < 0) { ++ return ret; + } else { + u32 *s = reply->status; + +@@ -238,6 +247,27 @@ static int mox_get_board_info(struct mox_rwtm *rwtm) + return 0; + } + ++static int check_get_random_support(struct mox_rwtm *rwtm) ++{ ++ struct armada_37xx_rwtm_tx_msg msg; ++ int ret; ++ ++ msg.command = MBOX_CMD_GET_RANDOM; ++ msg.args[0] = 1; ++ msg.args[1] = rwtm->buf_phys; ++ msg.args[2] = 4; ++ ++ ret = mbox_send_message(rwtm->mbox, &msg); ++ if (ret < 0) ++ return ret; ++ ++ ret = wait_for_completion_timeout(&rwtm->cmd_done, HZ / 2); ++ if (ret < 0) ++ return ret; ++ ++ return mox_get_status(MBOX_CMD_GET_RANDOM, rwtm->reply.retval); ++} ++ + static int mox_hwrng_read(struct hwrng *rng, void *data, size_t max, bool wait) + { + struct mox_rwtm *rwtm = (struct mox_rwtm *) rng->priv; +@@ -329,6 +359,13 @@ static int turris_mox_rwtm_probe(struct platform_device *pdev) + if (ret < 0) + dev_warn(dev, "Cannot read board information: %i\n", ret); + ++ ret = check_get_random_support(rwtm); ++ if (ret < 0) { ++ dev_notice(dev, ++ "Firmware does not support the GET_RANDOM command\n"); ++ goto free_channel; ++ } ++ + rwtm->hwrng.name = DRIVER_NAME "_hwrng"; + rwtm->hwrng.read = mox_hwrng_read; + rwtm->hwrng.priv = (unsigned long) rwtm; +diff --git a/drivers/gpio/gpio-pca953x.c b/drivers/gpio/gpio-pca953x.c +index 9a24dce3c2628..d9193ffa17a1e 100644 +--- a/drivers/gpio/gpio-pca953x.c ++++ b/drivers/gpio/gpio-pca953x.c +@@ -1272,6 +1272,7 @@ static const struct of_device_id pca953x_dt_ids[] = { + + { .compatible = "onnn,cat9554", .data = OF_953X( 8, PCA_INT), }, + { .compatible = "onnn,pca9654", .data = OF_953X( 8, PCA_INT), }, ++ { .compatible = "onnn,pca9655", .data = OF_953X(16, PCA_INT), }, + + { .compatible = "exar,xra1202", .data = OF_953X( 8, 0), }, + { } +diff --git a/drivers/gpio/gpio-zynq.c b/drivers/gpio/gpio-zynq.c +index 88b04d8a7fa7d..25a42605aa811 100644 +--- a/drivers/gpio/gpio-zynq.c ++++ b/drivers/gpio/gpio-zynq.c +@@ -938,8 +938,11 @@ err_pm_dis: + static int zynq_gpio_remove(struct platform_device *pdev) + { + struct zynq_gpio *gpio = platform_get_drvdata(pdev); ++ int ret; + +- pm_runtime_get_sync(&pdev->dev); ++ ret = pm_runtime_get_sync(&pdev->dev); ++ if (ret < 0) ++ dev_warn(&pdev->dev, "pm_runtime_get_sync() Failed\n"); + gpiochip_remove(&gpio->chip); + clk_disable_unprepare(gpio->clk); + device_set_wakeup_capable(&pdev->dev, 0); +diff --git a/drivers/hwtracing/intel_th/core.c b/drivers/hwtracing/intel_th/core.c +index c9ac3dc651135..9cb8c7d13d46b 100644 +--- a/drivers/hwtracing/intel_th/core.c ++++ b/drivers/hwtracing/intel_th/core.c +@@ -215,6 +215,22 @@ static ssize_t port_show(struct device *dev, struct device_attribute *attr, + + static DEVICE_ATTR_RO(port); + ++static void intel_th_trace_prepare(struct intel_th_device *thdev) ++{ ++ struct intel_th_device *hub = to_intel_th_hub(thdev); ++ struct intel_th_driver *hubdrv = to_intel_th_driver(hub->dev.driver); ++ ++ if (hub->type != INTEL_TH_SWITCH) ++ return; ++ ++ if (thdev->type != INTEL_TH_OUTPUT) ++ return; ++ ++ pm_runtime_get_sync(&thdev->dev); ++ hubdrv->prepare(hub, &thdev->output); ++ pm_runtime_put(&thdev->dev); ++} ++ + static int intel_th_output_activate(struct intel_th_device *thdev) + { + struct intel_th_driver *thdrv = +@@ -235,6 +251,7 @@ static int intel_th_output_activate(struct intel_th_device *thdev) + if (ret) + goto fail_put; + ++ intel_th_trace_prepare(thdev); + if (thdrv->activate) + ret = thdrv->activate(thdev); + else +diff --git a/drivers/hwtracing/intel_th/gth.c b/drivers/hwtracing/intel_th/gth.c +index 28509b02a0b56..b3308934a687d 100644 +--- a/drivers/hwtracing/intel_th/gth.c ++++ b/drivers/hwtracing/intel_th/gth.c +@@ -564,6 +564,21 @@ static void gth_tscu_resync(struct gth_device *gth) + iowrite32(reg, gth->base + REG_TSCU_TSUCTRL); + } + ++static void intel_th_gth_prepare(struct intel_th_device *thdev, ++ struct intel_th_output *output) ++{ ++ struct gth_device *gth = dev_get_drvdata(&thdev->dev); ++ int count; ++ ++ /* ++ * Wait until the output port is in reset before we start ++ * programming it. ++ */ ++ for (count = GTH_PLE_WAITLOOP_DEPTH; ++ count && !(gth_output_get(gth, output->port) & BIT(5)); count--) ++ cpu_relax(); ++} ++ + /** + * intel_th_gth_enable() - enable tracing to an output device + * @thdev: GTH device +@@ -815,6 +830,7 @@ static struct intel_th_driver intel_th_gth_driver = { + .assign = intel_th_gth_assign, + .unassign = intel_th_gth_unassign, + .set_output = intel_th_gth_set_output, ++ .prepare = intel_th_gth_prepare, + .enable = intel_th_gth_enable, + .trig_switch = intel_th_gth_switch, + .disable = intel_th_gth_disable, +diff --git a/drivers/hwtracing/intel_th/intel_th.h b/drivers/hwtracing/intel_th/intel_th.h +index 5fe694708b7a3..595615b791086 100644 +--- a/drivers/hwtracing/intel_th/intel_th.h ++++ b/drivers/hwtracing/intel_th/intel_th.h +@@ -143,6 +143,7 @@ intel_th_output_assigned(struct intel_th_device *thdev) + * @remove: remove method + * @assign: match a given output type device against available outputs + * @unassign: deassociate an output type device from an output port ++ * @prepare: prepare output port for tracing + * @enable: enable tracing for a given output device + * @disable: disable tracing for a given output device + * @irq: interrupt callback +@@ -164,6 +165,8 @@ struct intel_th_driver { + struct intel_th_device *othdev); + void (*unassign)(struct intel_th_device *thdev, + struct intel_th_device *othdev); ++ void (*prepare)(struct intel_th_device *thdev, ++ struct intel_th_output *output); + void (*enable)(struct intel_th_device *thdev, + struct intel_th_output *output); + void (*trig_switch)(struct intel_th_device *thdev, +diff --git a/drivers/i2c/i2c-core-base.c b/drivers/i2c/i2c-core-base.c +index 840f59650c7c4..1b93fae58ec75 100644 +--- a/drivers/i2c/i2c-core-base.c ++++ b/drivers/i2c/i2c-core-base.c +@@ -24,6 +24,7 @@ + #include + #include + #include ++#include + #include + #include + #include +@@ -459,6 +460,8 @@ static void i2c_device_shutdown(struct device *dev) + driver = to_i2c_driver(dev->driver); + if (driver->shutdown) + driver->shutdown(client); ++ else if (client->irq > 0) ++ disable_irq(client->irq); + } + + static void i2c_client_dev_release(struct device *dev) +diff --git a/drivers/iio/gyro/fxas21002c_core.c b/drivers/iio/gyro/fxas21002c_core.c +index 958cf8b6002ca..45e2b5b330726 100644 +--- a/drivers/iio/gyro/fxas21002c_core.c ++++ b/drivers/iio/gyro/fxas21002c_core.c +@@ -300,14 +300,7 @@ out_unlock: + + static int fxas21002c_pm_get(struct fxas21002c_data *data) + { +- struct device *dev = regmap_get_device(data->regmap); +- int ret; +- +- ret = pm_runtime_get_sync(dev); +- if (ret < 0) +- pm_runtime_put_noidle(dev); +- +- return ret; ++ return pm_runtime_resume_and_get(regmap_get_device(data->regmap)); + } + + static int fxas21002c_pm_put(struct fxas21002c_data *data) +@@ -940,7 +933,6 @@ int fxas21002c_core_probe(struct device *dev, struct regmap *regmap, int irq, + pm_disable: + pm_runtime_disable(dev); + pm_runtime_set_suspended(dev); +- pm_runtime_put_noidle(dev); + + return ret; + } +@@ -954,7 +946,6 @@ void fxas21002c_core_remove(struct device *dev) + + pm_runtime_disable(dev); + pm_runtime_set_suspended(dev); +- pm_runtime_put_noidle(dev); + } + EXPORT_SYMBOL_GPL(fxas21002c_core_remove); + +diff --git a/drivers/iio/magnetometer/bmc150_magn.c b/drivers/iio/magnetometer/bmc150_magn.c +index 48685d785c1b6..087dc16c2185c 100644 +--- a/drivers/iio/magnetometer/bmc150_magn.c ++++ b/drivers/iio/magnetometer/bmc150_magn.c +@@ -263,7 +263,7 @@ static int bmc150_magn_set_power_state(struct bmc150_magn_data *data, bool on) + int ret; + + if (on) { +- ret = pm_runtime_get_sync(data->dev); ++ ret = pm_runtime_resume_and_get(data->dev); + } else { + pm_runtime_mark_last_busy(data->dev); + ret = pm_runtime_put_autosuspend(data->dev); +@@ -272,9 +272,6 @@ static int bmc150_magn_set_power_state(struct bmc150_magn_data *data, bool on) + if (ret < 0) { + dev_err(data->dev, + "failed to change power state to %d\n", on); +- if (on) +- pm_runtime_put_noidle(data->dev); +- + return ret; + } + #endif +@@ -947,12 +944,14 @@ int bmc150_magn_probe(struct device *dev, struct regmap *regmap, + ret = iio_device_register(indio_dev); + if (ret < 0) { + dev_err(dev, "unable to register iio device\n"); +- goto err_buffer_cleanup; ++ goto err_disable_runtime_pm; + } + + dev_dbg(dev, "Registered device %s\n", name); + return 0; + ++err_disable_runtime_pm: ++ pm_runtime_disable(dev); + err_buffer_cleanup: + iio_triggered_buffer_cleanup(indio_dev); + err_free_irq: +@@ -976,7 +975,6 @@ int bmc150_magn_remove(struct device *dev) + + pm_runtime_disable(dev); + pm_runtime_set_suspended(dev); +- pm_runtime_put_noidle(dev); + + iio_triggered_buffer_cleanup(indio_dev); + +diff --git a/drivers/input/touchscreen/hideep.c b/drivers/input/touchscreen/hideep.c +index ddad4a82a5e55..e9547ee297564 100644 +--- a/drivers/input/touchscreen/hideep.c ++++ b/drivers/input/touchscreen/hideep.c +@@ -361,13 +361,16 @@ static int hideep_enter_pgm(struct hideep_ts *ts) + return -EIO; + } + +-static void hideep_nvm_unlock(struct hideep_ts *ts) ++static int hideep_nvm_unlock(struct hideep_ts *ts) + { + u32 unmask_code; ++ int error; + + hideep_pgm_w_reg(ts, HIDEEP_FLASH_CFG, HIDEEP_NVM_SFR_RPAGE); +- hideep_pgm_r_reg(ts, 0x0000000C, &unmask_code); ++ error = hideep_pgm_r_reg(ts, 0x0000000C, &unmask_code); + hideep_pgm_w_reg(ts, HIDEEP_FLASH_CFG, HIDEEP_NVM_DEFAULT_PAGE); ++ if (error) ++ return error; + + /* make it unprotected code */ + unmask_code &= ~HIDEEP_PROT_MODE; +@@ -384,6 +387,8 @@ static void hideep_nvm_unlock(struct hideep_ts *ts) + NVM_W_SFR(HIDEEP_NVM_MASK_OFS, ts->nvm_mask); + SET_FLASH_HWCONTROL(); + hideep_pgm_w_reg(ts, HIDEEP_FLASH_CFG, HIDEEP_NVM_DEFAULT_PAGE); ++ ++ return 0; + } + + static int hideep_check_status(struct hideep_ts *ts) +@@ -462,7 +467,9 @@ static int hideep_program_nvm(struct hideep_ts *ts, + u32 addr = 0; + int error; + +- hideep_nvm_unlock(ts); ++ error = hideep_nvm_unlock(ts); ++ if (error) ++ return error; + + while (ucode_len > 0) { + xfer_len = min_t(size_t, ucode_len, HIDEEP_NVM_PAGE_SIZE); +diff --git a/drivers/iommu/arm-smmu.c b/drivers/iommu/arm-smmu.c +index 7c503a6bc5854..2185ea5191c15 100644 +--- a/drivers/iommu/arm-smmu.c ++++ b/drivers/iommu/arm-smmu.c +@@ -114,7 +114,7 @@ static bool using_legacy_binding, using_generic_binding; + static inline int arm_smmu_rpm_get(struct arm_smmu_device *smmu) + { + if (pm_runtime_enabled(smmu->dev)) +- return pm_runtime_get_sync(smmu->dev); ++ return pm_runtime_resume_and_get(smmu->dev); + + return 0; + } +@@ -1231,6 +1231,7 @@ static phys_addr_t arm_smmu_iova_to_phys_hard(struct iommu_domain *domain, + u64 phys; + unsigned long va, flags; + int ret, idx = cfg->cbndx; ++ phys_addr_t addr = 0; + + ret = arm_smmu_rpm_get(smmu); + if (ret < 0) +@@ -1249,6 +1250,7 @@ static phys_addr_t arm_smmu_iova_to_phys_hard(struct iommu_domain *domain, + dev_err(dev, + "iova to phys timed out on %pad. Falling back to software table walk.\n", + &iova); ++ arm_smmu_rpm_put(smmu); + return ops->iova_to_phys(ops, iova); + } + +@@ -1257,12 +1259,14 @@ static phys_addr_t arm_smmu_iova_to_phys_hard(struct iommu_domain *domain, + if (phys & CB_PAR_F) { + dev_err(dev, "translation fault!\n"); + dev_err(dev, "PAR = 0x%llx\n", phys); +- return 0; ++ goto out; + } + ++ addr = (phys & GENMASK_ULL(39, 12)) | (iova & 0xfff); ++out: + arm_smmu_rpm_put(smmu); + +- return (phys & GENMASK_ULL(39, 12)) | (iova & 0xfff); ++ return addr; + } + + static phys_addr_t arm_smmu_iova_to_phys(struct iommu_domain *domain, +diff --git a/drivers/memory/atmel-ebi.c b/drivers/memory/atmel-ebi.c +index 0322df9dc2497..89646896a1833 100644 +--- a/drivers/memory/atmel-ebi.c ++++ b/drivers/memory/atmel-ebi.c +@@ -601,8 +601,10 @@ static int atmel_ebi_probe(struct platform_device *pdev) + child); + + ret = atmel_ebi_dev_disable(ebi, child); +- if (ret) ++ if (ret) { ++ of_node_put(child); + return ret; ++ } + } + } + +diff --git a/drivers/memory/fsl_ifc.c b/drivers/memory/fsl_ifc.c +index a2c971743ffe6..2790258346070 100644 +--- a/drivers/memory/fsl_ifc.c ++++ b/drivers/memory/fsl_ifc.c +@@ -96,7 +96,6 @@ static int fsl_ifc_ctrl_remove(struct platform_device *dev) + iounmap(ctrl->gregs); + + dev_set_drvdata(&dev->dev, NULL); +- kfree(ctrl); + + return 0; + } +@@ -208,7 +207,8 @@ static int fsl_ifc_ctrl_probe(struct platform_device *dev) + + dev_info(&dev->dev, "Freescale Integrated Flash Controller\n"); + +- fsl_ifc_ctrl_dev = kzalloc(sizeof(*fsl_ifc_ctrl_dev), GFP_KERNEL); ++ fsl_ifc_ctrl_dev = devm_kzalloc(&dev->dev, sizeof(*fsl_ifc_ctrl_dev), ++ GFP_KERNEL); + if (!fsl_ifc_ctrl_dev) + return -ENOMEM; + +@@ -218,8 +218,7 @@ static int fsl_ifc_ctrl_probe(struct platform_device *dev) + fsl_ifc_ctrl_dev->gregs = of_iomap(dev->dev.of_node, 0); + if (!fsl_ifc_ctrl_dev->gregs) { + dev_err(&dev->dev, "failed to get memory region\n"); +- ret = -ENODEV; +- goto err; ++ return -ENODEV; + } + + if (of_property_read_bool(dev->dev.of_node, "little-endian")) { +@@ -295,6 +294,7 @@ err_irq: + free_irq(fsl_ifc_ctrl_dev->irq, fsl_ifc_ctrl_dev); + irq_dispose_mapping(fsl_ifc_ctrl_dev->irq); + err: ++ iounmap(fsl_ifc_ctrl_dev->gregs); + return ret; + } + +diff --git a/drivers/memory/pl353-smc.c b/drivers/memory/pl353-smc.c +index b42804b1801e6..cc01979780d87 100644 +--- a/drivers/memory/pl353-smc.c ++++ b/drivers/memory/pl353-smc.c +@@ -407,6 +407,7 @@ static int pl353_smc_probe(struct amba_device *adev, const struct amba_id *id) + break; + } + if (!match) { ++ err = -ENODEV; + dev_err(&adev->dev, "no matching children\n"); + goto out_clk_disable; + } +diff --git a/drivers/mfd/da9052-i2c.c b/drivers/mfd/da9052-i2c.c +index 47556d2d9abe2..8ebfc7bbe4e01 100644 +--- a/drivers/mfd/da9052-i2c.c ++++ b/drivers/mfd/da9052-i2c.c +@@ -113,6 +113,7 @@ static const struct i2c_device_id da9052_i2c_id[] = { + {"da9053-bc", DA9053_BC}, + {} + }; ++MODULE_DEVICE_TABLE(i2c, da9052_i2c_id); + + #ifdef CONFIG_OF + static const struct of_device_id dialog_dt_ids[] = { +diff --git a/drivers/mfd/motorola-cpcap.c b/drivers/mfd/motorola-cpcap.c +index 52f38e57cdc19..1ae58c977e1b5 100644 +--- a/drivers/mfd/motorola-cpcap.c ++++ b/drivers/mfd/motorola-cpcap.c +@@ -305,6 +305,10 @@ static int cpcap_probe(struct spi_device *spi) + if (ret) + return ret; + ++ /* Parent SPI controller uses DMA, CPCAP and child devices do not */ ++ spi->dev.coherent_dma_mask = 0; ++ spi->dev.dma_mask = &spi->dev.coherent_dma_mask; ++ + return devm_mfd_add_devices(&spi->dev, 0, cpcap_mfd_devices, + ARRAY_SIZE(cpcap_mfd_devices), NULL, 0, NULL); + } +diff --git a/drivers/mfd/stmpe-i2c.c b/drivers/mfd/stmpe-i2c.c +index 61aa020199f57..cd2f45257dc16 100644 +--- a/drivers/mfd/stmpe-i2c.c ++++ b/drivers/mfd/stmpe-i2c.c +@@ -109,7 +109,7 @@ static const struct i2c_device_id stmpe_i2c_id[] = { + { "stmpe2403", STMPE2403 }, + { } + }; +-MODULE_DEVICE_TABLE(i2c, stmpe_id); ++MODULE_DEVICE_TABLE(i2c, stmpe_i2c_id); + + static struct i2c_driver stmpe_i2c_driver = { + .driver = { +diff --git a/drivers/misc/cardreader/alcor_pci.c b/drivers/misc/cardreader/alcor_pci.c +index 259fe1dfec039..1fadb95b85b09 100644 +--- a/drivers/misc/cardreader/alcor_pci.c ++++ b/drivers/misc/cardreader/alcor_pci.c +@@ -133,7 +133,13 @@ static void alcor_pci_init_check_aspm(struct alcor_pci_priv *priv) + u32 val32; + + priv->pdev_cap_off = alcor_pci_find_cap_offset(priv, priv->pdev); +- priv->parent_cap_off = alcor_pci_find_cap_offset(priv, ++ /* ++ * A device might be attached to root complex directly and ++ * priv->parent_pdev will be NULL. In this case we don't check its ++ * capability and disable ASPM completely. ++ */ ++ if (priv->parent_pdev) ++ priv->parent_cap_off = alcor_pci_find_cap_offset(priv, + priv->parent_pdev); + + if ((priv->pdev_cap_off == 0) || (priv->parent_cap_off == 0)) { +diff --git a/drivers/misc/ibmasm/module.c b/drivers/misc/ibmasm/module.c +index 4edad6c445d37..dc8a06c06c637 100644 +--- a/drivers/misc/ibmasm/module.c ++++ b/drivers/misc/ibmasm/module.c +@@ -111,7 +111,7 @@ static int ibmasm_init_one(struct pci_dev *pdev, const struct pci_device_id *id) + result = ibmasm_init_remote_input_dev(sp); + if (result) { + dev_err(sp->dev, "Failed to initialize remote queue\n"); +- goto error_send_message; ++ goto error_init_remote; + } + + result = ibmasm_send_driver_vpd(sp); +@@ -131,8 +131,9 @@ static int ibmasm_init_one(struct pci_dev *pdev, const struct pci_device_id *id) + return 0; + + error_send_message: +- disable_sp_interrupts(sp->base_address); + ibmasm_free_remote_input_dev(sp); ++error_init_remote: ++ disable_sp_interrupts(sp->base_address); + free_irq(sp->irq, (void *)sp); + error_request_irq: + iounmap(sp->base_address); +diff --git a/drivers/net/ethernet/moxa/moxart_ether.c b/drivers/net/ethernet/moxa/moxart_ether.c +index f70bb81e1ed65..caf7051302725 100644 +--- a/drivers/net/ethernet/moxa/moxart_ether.c ++++ b/drivers/net/ethernet/moxa/moxart_ether.c +@@ -481,6 +481,10 @@ static int moxart_mac_probe(struct platform_device *pdev) + priv->pdev = pdev; + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); ++ if (!res) { ++ ret = -EINVAL; ++ goto init_fail; ++ } + ndev->base_addr = res->start; + priv->base = devm_ioremap_resource(p_dev, res); + if (IS_ERR(priv->base)) { +diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c +index 5cd55f950032a..15453d6fcc232 100644 +--- a/drivers/net/virtio_net.c ++++ b/drivers/net/virtio_net.c +@@ -1504,6 +1504,8 @@ static int virtnet_poll_tx(struct napi_struct *napi, int budget) + struct virtnet_info *vi = sq->vq->vdev->priv; + unsigned int index = vq2txq(sq->vq); + struct netdev_queue *txq; ++ int opaque; ++ bool done; + + if (unlikely(is_xdp_raw_buffer_queue(vi, index))) { + /* We don't need to enable cb for XDP */ +@@ -1513,10 +1515,28 @@ static int virtnet_poll_tx(struct napi_struct *napi, int budget) + + txq = netdev_get_tx_queue(vi->dev, index); + __netif_tx_lock(txq, raw_smp_processor_id()); ++ virtqueue_disable_cb(sq->vq); + free_old_xmit_skbs(sq, true); ++ ++ opaque = virtqueue_enable_cb_prepare(sq->vq); ++ ++ done = napi_complete_done(napi, 0); ++ ++ if (!done) ++ virtqueue_disable_cb(sq->vq); ++ + __netif_tx_unlock(txq); + +- virtqueue_napi_complete(napi, sq->vq, 0); ++ if (done) { ++ if (unlikely(virtqueue_poll(sq->vq, opaque))) { ++ if (napi_schedule_prep(napi)) { ++ __netif_tx_lock(txq, raw_smp_processor_id()); ++ virtqueue_disable_cb(sq->vq); ++ __netif_tx_unlock(txq); ++ __napi_schedule(napi); ++ } ++ } ++ } + + if (sq->vq->num_free >= 2 + MAX_SKB_FRAGS) + netif_tx_wake_queue(txq); +@@ -3282,8 +3302,11 @@ static __maybe_unused int virtnet_restore(struct virtio_device *vdev) + virtnet_set_queues(vi, vi->curr_queue_pairs); + + err = virtnet_cpu_notif_add(vi); +- if (err) ++ if (err) { ++ virtnet_freeze_down(vdev); ++ remove_vq_common(vi); + return err; ++ } + + return 0; + } +diff --git a/drivers/nvme/target/tcp.c b/drivers/nvme/target/tcp.c +index 9bfd92b6677b0..2ae846297d7ca 100644 +--- a/drivers/nvme/target/tcp.c ++++ b/drivers/nvme/target/tcp.c +@@ -1412,7 +1412,6 @@ static void nvmet_tcp_state_change(struct sock *sk) + case TCP_CLOSE_WAIT: + case TCP_CLOSE: + /* FALLTHRU */ +- sk->sk_user_data = NULL; + nvmet_tcp_schedule_release_queue(queue); + break; + default: +diff --git a/drivers/pci/controller/pci-tegra.c b/drivers/pci/controller/pci-tegra.c +index cfa3c83d6cc74..99d505a85067b 100644 +--- a/drivers/pci/controller/pci-tegra.c ++++ b/drivers/pci/controller/pci-tegra.c +@@ -2613,6 +2613,7 @@ static const struct of_device_id tegra_pcie_of_match[] = { + { .compatible = "nvidia,tegra20-pcie", .data = &tegra20_pcie }, + { }, + }; ++MODULE_DEVICE_TABLE(of, tegra_pcie_of_match); + + static void *tegra_pcie_ports_seq_start(struct seq_file *s, loff_t *pos) + { +diff --git a/drivers/pci/controller/pcie-iproc-msi.c b/drivers/pci/controller/pcie-iproc-msi.c +index f40d17b285c5e..0cb2fa1e0af4f 100644 +--- a/drivers/pci/controller/pcie-iproc-msi.c ++++ b/drivers/pci/controller/pcie-iproc-msi.c +@@ -171,7 +171,7 @@ static struct irq_chip iproc_msi_irq_chip = { + + static struct msi_domain_info iproc_msi_domain_info = { + .flags = MSI_FLAG_USE_DEF_DOM_OPS | MSI_FLAG_USE_DEF_CHIP_OPS | +- MSI_FLAG_MULTI_PCI_MSI | MSI_FLAG_PCI_MSIX, ++ MSI_FLAG_PCI_MSIX, + .chip = &iproc_msi_irq_chip, + }; + +@@ -250,20 +250,23 @@ static int iproc_msi_irq_domain_alloc(struct irq_domain *domain, + struct iproc_msi *msi = domain->host_data; + int hwirq, i; + ++ if (msi->nr_cpus > 1 && nr_irqs > 1) ++ return -EINVAL; ++ + mutex_lock(&msi->bitmap_lock); + +- /* Allocate 'nr_cpus' number of MSI vectors each time */ +- hwirq = bitmap_find_next_zero_area(msi->bitmap, msi->nr_msi_vecs, 0, +- msi->nr_cpus, 0); +- if (hwirq < msi->nr_msi_vecs) { +- bitmap_set(msi->bitmap, hwirq, msi->nr_cpus); +- } else { +- mutex_unlock(&msi->bitmap_lock); +- return -ENOSPC; +- } ++ /* ++ * Allocate 'nr_irqs' multiplied by 'nr_cpus' number of MSI vectors ++ * each time ++ */ ++ hwirq = bitmap_find_free_region(msi->bitmap, msi->nr_msi_vecs, ++ order_base_2(msi->nr_cpus * nr_irqs)); + + mutex_unlock(&msi->bitmap_lock); + ++ if (hwirq < 0) ++ return -ENOSPC; ++ + for (i = 0; i < nr_irqs; i++) { + irq_domain_set_info(domain, virq + i, hwirq + i, + &iproc_msi_bottom_irq_chip, +@@ -284,7 +287,8 @@ static void iproc_msi_irq_domain_free(struct irq_domain *domain, + mutex_lock(&msi->bitmap_lock); + + hwirq = hwirq_to_canonical_hwirq(msi, data->hwirq); +- bitmap_clear(msi->bitmap, hwirq, msi->nr_cpus); ++ bitmap_release_region(msi->bitmap, hwirq, ++ order_base_2(msi->nr_cpus * nr_irqs)); + + mutex_unlock(&msi->bitmap_lock); + +@@ -538,6 +542,9 @@ int iproc_msi_init(struct iproc_pcie *pcie, struct device_node *node) + mutex_init(&msi->bitmap_lock); + msi->nr_cpus = num_possible_cpus(); + ++ if (msi->nr_cpus == 1) ++ iproc_msi_domain_info.flags |= MSI_FLAG_MULTI_PCI_MSI; ++ + msi->nr_irqs = of_irq_count(node); + if (!msi->nr_irqs) { + dev_err(pcie->dev, "found no MSI GIC interrupt\n"); +diff --git a/drivers/pci/p2pdma.c b/drivers/pci/p2pdma.c +index 0608aae72cccc..0153abdbbc8dd 100644 +--- a/drivers/pci/p2pdma.c ++++ b/drivers/pci/p2pdma.c +@@ -292,10 +292,41 @@ static const struct pci_p2pdma_whitelist_entry { + {} + }; + ++/* ++ * This lookup function tries to find the PCI device corresponding to a given ++ * host bridge. ++ * ++ * It assumes the host bridge device is the first PCI device in the ++ * bus->devices list and that the devfn is 00.0. These assumptions should hold ++ * for all the devices in the whitelist above. ++ * ++ * This function is equivalent to pci_get_slot(host->bus, 0), however it does ++ * not take the pci_bus_sem lock seeing __host_bridge_whitelist() must not ++ * sleep. ++ * ++ * For this to be safe, the caller should hold a reference to a device on the ++ * bridge, which should ensure the host_bridge device will not be freed ++ * or removed from the head of the devices list. ++ */ ++static struct pci_dev *pci_host_bridge_dev(struct pci_host_bridge *host) ++{ ++ struct pci_dev *root; ++ ++ root = list_first_entry_or_null(&host->bus->devices, ++ struct pci_dev, bus_list); ++ ++ if (!root) ++ return NULL; ++ if (root->devfn != PCI_DEVFN(0, 0)) ++ return NULL; ++ ++ return root; ++} ++ + static bool __host_bridge_whitelist(struct pci_host_bridge *host, + bool same_host_bridge) + { +- struct pci_dev *root = pci_get_slot(host->bus, PCI_DEVFN(0, 0)); ++ struct pci_dev *root = pci_host_bridge_dev(host); + const struct pci_p2pdma_whitelist_entry *entry; + unsigned short vendor, device; + +@@ -304,7 +335,6 @@ static bool __host_bridge_whitelist(struct pci_host_bridge *host, + + vendor = root->vendor; + device = root->device; +- pci_dev_put(root); + + for (entry = pci_p2pdma_whitelist; entry->vendor; entry++) { + if (vendor != entry->vendor || device != entry->device) +diff --git a/drivers/pci/pci-label.c b/drivers/pci/pci-label.c +index a5910f9428576..9fb4ef568f405 100644 +--- a/drivers/pci/pci-label.c ++++ b/drivers/pci/pci-label.c +@@ -162,7 +162,7 @@ static void dsm_label_utf16s_to_utf8s(union acpi_object *obj, char *buf) + len = utf16s_to_utf8s((const wchar_t *)obj->buffer.pointer, + obj->buffer.length, + UTF16_LITTLE_ENDIAN, +- buf, PAGE_SIZE); ++ buf, PAGE_SIZE - 1); + buf[len] = '\n'; + } + +diff --git a/drivers/power/reset/gpio-poweroff.c b/drivers/power/reset/gpio-poweroff.c +index 6a4bbb5065510..97d1f58efef40 100644 +--- a/drivers/power/reset/gpio-poweroff.c ++++ b/drivers/power/reset/gpio-poweroff.c +@@ -90,6 +90,7 @@ static const struct of_device_id of_gpio_poweroff_match[] = { + { .compatible = "gpio-poweroff", }, + {}, + }; ++MODULE_DEVICE_TABLE(of, of_gpio_poweroff_match); + + static struct platform_driver gpio_poweroff_driver = { + .probe = gpio_poweroff_probe, +diff --git a/drivers/power/supply/Kconfig b/drivers/power/supply/Kconfig +index d6fdc10c29f0b..ffdb15278c109 100644 +--- a/drivers/power/supply/Kconfig ++++ b/drivers/power/supply/Kconfig +@@ -643,7 +643,8 @@ config BATTERY_GOLDFISH + + config BATTERY_RT5033 + tristate "RT5033 fuel gauge support" +- depends on MFD_RT5033 ++ depends on I2C ++ select REGMAP_I2C + help + This adds support for battery fuel gauge in Richtek RT5033 PMIC. + The fuelgauge calculates and determines the battery state of charge +diff --git a/drivers/power/supply/ab8500_btemp.c b/drivers/power/supply/ab8500_btemp.c +index 8fe81259bfd96..c8a22df650364 100644 +--- a/drivers/power/supply/ab8500_btemp.c ++++ b/drivers/power/supply/ab8500_btemp.c +@@ -1120,6 +1120,7 @@ static const struct of_device_id ab8500_btemp_match[] = { + { .compatible = "stericsson,ab8500-btemp", }, + { }, + }; ++MODULE_DEVICE_TABLE(of, ab8500_btemp_match); + + static struct platform_driver ab8500_btemp_driver = { + .probe = ab8500_btemp_probe, +diff --git a/drivers/power/supply/ab8500_charger.c b/drivers/power/supply/ab8500_charger.c +index e51d0e72beead..28e9d4f9ab8c4 100644 +--- a/drivers/power/supply/ab8500_charger.c ++++ b/drivers/power/supply/ab8500_charger.c +@@ -407,6 +407,14 @@ disable_otp: + static void ab8500_power_supply_changed(struct ab8500_charger *di, + struct power_supply *psy) + { ++ /* ++ * This happens if we get notifications or interrupts and ++ * the platform has been configured not to support one or ++ * other type of charging. ++ */ ++ if (!psy) ++ return; ++ + if (di->autopower_cfg) { + if (!di->usb.charger_connected && + !di->ac.charger_connected && +@@ -433,7 +441,15 @@ static void ab8500_charger_set_usb_connected(struct ab8500_charger *di, + if (!connected) + di->flags.vbus_drop_end = false; + +- sysfs_notify(&di->usb_chg.psy->dev.kobj, NULL, "present"); ++ /* ++ * Sometimes the platform is configured not to support ++ * USB charging and no psy has been created, but we still ++ * will get these notifications. ++ */ ++ if (di->usb_chg.psy) { ++ sysfs_notify(&di->usb_chg.psy->dev.kobj, NULL, ++ "present"); ++ } + + if (connected) { + mutex_lock(&di->charger_attached_mutex); +@@ -3617,6 +3633,7 @@ static const struct of_device_id ab8500_charger_match[] = { + { .compatible = "stericsson,ab8500-charger", }, + { }, + }; ++MODULE_DEVICE_TABLE(of, ab8500_charger_match); + + static struct platform_driver ab8500_charger_driver = { + .probe = ab8500_charger_probe, +diff --git a/drivers/power/supply/ab8500_fg.c b/drivers/power/supply/ab8500_fg.c +index 6fc4bc30644cd..69452fc085b99 100644 +--- a/drivers/power/supply/ab8500_fg.c ++++ b/drivers/power/supply/ab8500_fg.c +@@ -3230,6 +3230,7 @@ static const struct of_device_id ab8500_fg_match[] = { + { .compatible = "stericsson,ab8500-fg", }, + { }, + }; ++MODULE_DEVICE_TABLE(of, ab8500_fg_match); + + static struct platform_driver ab8500_fg_driver = { + .probe = ab8500_fg_probe, +diff --git a/drivers/power/supply/charger-manager.c b/drivers/power/supply/charger-manager.c +index a21e1a2673f80..1a215b6d94471 100644 +--- a/drivers/power/supply/charger-manager.c ++++ b/drivers/power/supply/charger-manager.c +@@ -1470,6 +1470,7 @@ static const struct of_device_id charger_manager_match[] = { + }, + {}, + }; ++MODULE_DEVICE_TABLE(of, charger_manager_match); + + static struct charger_desc *of_cm_parse_desc(struct device *dev) + { +diff --git a/drivers/power/supply/max17042_battery.c b/drivers/power/supply/max17042_battery.c +index 0dfad2cf13fe0..fa862f0380c41 100644 +--- a/drivers/power/supply/max17042_battery.c ++++ b/drivers/power/supply/max17042_battery.c +@@ -1076,7 +1076,7 @@ static int max17042_probe(struct i2c_client *client, + } + + if (client->irq) { +- unsigned int flags = IRQF_TRIGGER_FALLING | IRQF_ONESHOT; ++ unsigned int flags = IRQF_ONESHOT; + + /* + * On ACPI systems the IRQ may be handled by ACPI-event code, +diff --git a/drivers/power/supply/rt5033_battery.c b/drivers/power/supply/rt5033_battery.c +index d8667a9fc49b1..6609f8cb8ca01 100644 +--- a/drivers/power/supply/rt5033_battery.c ++++ b/drivers/power/supply/rt5033_battery.c +@@ -164,9 +164,16 @@ static const struct i2c_device_id rt5033_battery_id[] = { + }; + MODULE_DEVICE_TABLE(i2c, rt5033_battery_id); + ++static const struct of_device_id rt5033_battery_of_match[] = { ++ { .compatible = "richtek,rt5033-battery", }, ++ { } ++}; ++MODULE_DEVICE_TABLE(of, rt5033_battery_of_match); ++ + static struct i2c_driver rt5033_battery_driver = { + .driver = { + .name = "rt5033-battery", ++ .of_match_table = rt5033_battery_of_match, + }, + .probe = rt5033_battery_probe, + .remove = rt5033_battery_remove, +diff --git a/drivers/power/supply/sc2731_charger.c b/drivers/power/supply/sc2731_charger.c +index 335cb857ef307..288b79836c139 100644 +--- a/drivers/power/supply/sc2731_charger.c ++++ b/drivers/power/supply/sc2731_charger.c +@@ -524,6 +524,7 @@ static const struct of_device_id sc2731_charger_of_match[] = { + { .compatible = "sprd,sc2731-charger", }, + { } + }; ++MODULE_DEVICE_TABLE(of, sc2731_charger_of_match); + + static struct platform_driver sc2731_charger_driver = { + .driver = { +diff --git a/drivers/power/supply/sc27xx_fuel_gauge.c b/drivers/power/supply/sc27xx_fuel_gauge.c +index bc8f5bda5762f..5e5bcdbf2e695 100644 +--- a/drivers/power/supply/sc27xx_fuel_gauge.c ++++ b/drivers/power/supply/sc27xx_fuel_gauge.c +@@ -1215,6 +1215,7 @@ static const struct of_device_id sc27xx_fgu_of_match[] = { + { .compatible = "sprd,sc2731-fgu", }, + { } + }; ++MODULE_DEVICE_TABLE(of, sc27xx_fgu_of_match); + + static struct platform_driver sc27xx_fgu_driver = { + .probe = sc27xx_fgu_probe, +diff --git a/drivers/pwm/pwm-img.c b/drivers/pwm/pwm-img.c +index a34d95ed70b20..22c002e685b34 100644 +--- a/drivers/pwm/pwm-img.c ++++ b/drivers/pwm/pwm-img.c +@@ -156,7 +156,7 @@ static int img_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm) + struct img_pwm_chip *pwm_chip = to_img_pwm_chip(chip); + int ret; + +- ret = pm_runtime_get_sync(chip->dev); ++ ret = pm_runtime_resume_and_get(chip->dev); + if (ret < 0) + return ret; + +diff --git a/drivers/pwm/pwm-imx1.c b/drivers/pwm/pwm-imx1.c +index f8b2c2e001a7a..c17652c40e142 100644 +--- a/drivers/pwm/pwm-imx1.c ++++ b/drivers/pwm/pwm-imx1.c +@@ -180,8 +180,6 @@ static int pwm_imx1_remove(struct platform_device *pdev) + { + struct pwm_imx1_chip *imx = platform_get_drvdata(pdev); + +- pwm_imx1_clk_disable_unprepare(&imx->chip); +- + return pwmchip_remove(&imx->chip); + } + +diff --git a/drivers/pwm/pwm-spear.c b/drivers/pwm/pwm-spear.c +index 6c6b44fd3f438..2d11ac277de8d 100644 +--- a/drivers/pwm/pwm-spear.c ++++ b/drivers/pwm/pwm-spear.c +@@ -231,10 +231,6 @@ static int spear_pwm_probe(struct platform_device *pdev) + static int spear_pwm_remove(struct platform_device *pdev) + { + struct spear_pwm_chip *pc = platform_get_drvdata(pdev); +- int i; +- +- for (i = 0; i < NUM_PWM; i++) +- pwm_disable(&pc->chip.pwms[i]); + + /* clk was prepared in probe, hence unprepare it here */ + clk_unprepare(pc->clk); +diff --git a/drivers/pwm/pwm-tegra.c b/drivers/pwm/pwm-tegra.c +index aa12fb3ed92e3..3d55e30a68662 100644 +--- a/drivers/pwm/pwm-tegra.c ++++ b/drivers/pwm/pwm-tegra.c +@@ -232,7 +232,6 @@ static int tegra_pwm_probe(struct platform_device *pdev) + static int tegra_pwm_remove(struct platform_device *pdev) + { + struct tegra_pwm_chip *pc = platform_get_drvdata(pdev); +- unsigned int i; + int err; + + if (WARN_ON(!pc)) +@@ -242,18 +241,6 @@ static int tegra_pwm_remove(struct platform_device *pdev) + if (err < 0) + return err; + +- for (i = 0; i < pc->chip.npwm; i++) { +- struct pwm_device *pwm = &pc->chip.pwms[i]; +- +- if (!pwm_is_enabled(pwm)) +- if (clk_prepare_enable(pc->clk) < 0) +- continue; +- +- pwm_writel(pc, i, 0); +- +- clk_disable_unprepare(pc->clk); +- } +- + reset_control_assert(pc->rst); + clk_disable_unprepare(pc->clk); + +diff --git a/drivers/reset/core.c b/drivers/reset/core.c +index 76c0dc7f165df..688b4f6227fcb 100644 +--- a/drivers/reset/core.c ++++ b/drivers/reset/core.c +@@ -565,7 +565,10 @@ static struct reset_control *__reset_control_get_internal( + if (!rstc) + return ERR_PTR(-ENOMEM); + +- try_module_get(rcdev->owner); ++ if (!try_module_get(rcdev->owner)) { ++ kfree(rstc); ++ return ERR_PTR(-ENODEV); ++ } + + rstc->rcdev = rcdev; + list_add(&rstc->list, &rcdev->reset_control_head); +diff --git a/drivers/reset/reset-a10sr.c b/drivers/reset/reset-a10sr.c +index 7eacc89382f8a..99b3bc8382f35 100644 +--- a/drivers/reset/reset-a10sr.c ++++ b/drivers/reset/reset-a10sr.c +@@ -118,6 +118,7 @@ static struct platform_driver a10sr_reset_driver = { + .probe = a10sr_reset_probe, + .driver = { + .name = "altr_a10sr_reset", ++ .of_match_table = a10sr_reset_of_match, + }, + }; + module_platform_driver(a10sr_reset_driver); +diff --git a/drivers/reset/reset-brcmstb.c b/drivers/reset/reset-brcmstb.c +index f213264c8567b..42c9d5241c530 100644 +--- a/drivers/reset/reset-brcmstb.c ++++ b/drivers/reset/reset-brcmstb.c +@@ -111,6 +111,7 @@ static const struct of_device_id brcmstb_reset_of_match[] = { + { .compatible = "brcm,brcmstb-reset" }, + { /* sentinel */ } + }; ++MODULE_DEVICE_TABLE(of, brcmstb_reset_of_match); + + static struct platform_driver brcmstb_reset_driver = { + .probe = brcmstb_reset_probe, +diff --git a/drivers/rtc/proc.c b/drivers/rtc/proc.c +index 73344598fc1be..cbcdbb19d848e 100644 +--- a/drivers/rtc/proc.c ++++ b/drivers/rtc/proc.c +@@ -23,8 +23,8 @@ static bool is_rtc_hctosys(struct rtc_device *rtc) + int size; + char name[NAME_SIZE]; + +- size = scnprintf(name, NAME_SIZE, "rtc%d", rtc->id); +- if (size > NAME_SIZE) ++ size = snprintf(name, NAME_SIZE, "rtc%d", rtc->id); ++ if (size >= NAME_SIZE) + return false; + + return !strncmp(name, CONFIG_RTC_HCTOSYS_DEVICE, NAME_SIZE); +diff --git a/drivers/s390/char/sclp_vt220.c b/drivers/s390/char/sclp_vt220.c +index 3f9a6ef650fac..3c2ed6d013873 100644 +--- a/drivers/s390/char/sclp_vt220.c ++++ b/drivers/s390/char/sclp_vt220.c +@@ -35,8 +35,8 @@ + #define SCLP_VT220_MINOR 65 + #define SCLP_VT220_DRIVER_NAME "sclp_vt220" + #define SCLP_VT220_DEVICE_NAME "ttysclp" +-#define SCLP_VT220_CONSOLE_NAME "ttyS" +-#define SCLP_VT220_CONSOLE_INDEX 1 /* console=ttyS1 */ ++#define SCLP_VT220_CONSOLE_NAME "ttysclp" ++#define SCLP_VT220_CONSOLE_INDEX 0 /* console=ttysclp0 */ + + /* Representation of a single write request */ + struct sclp_vt220_request { +diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c +index 0760d0bd8a10b..53b33f146f825 100644 +--- a/drivers/scsi/be2iscsi/be_main.c ++++ b/drivers/scsi/be2iscsi/be_main.c +@@ -416,7 +416,7 @@ static struct beiscsi_hba *beiscsi_hba_alloc(struct pci_dev *pcidev) + "beiscsi_hba_alloc - iscsi_host_alloc failed\n"); + return NULL; + } +- shost->max_id = BE2_MAX_SESSIONS; ++ shost->max_id = BE2_MAX_SESSIONS - 1; + shost->max_channel = 0; + shost->max_cmd_len = BEISCSI_MAX_CMD_LEN; + shost->max_lun = BEISCSI_NUM_MAX_LUN; +@@ -5318,7 +5318,7 @@ static int beiscsi_enable_port(struct beiscsi_hba *phba) + /* Re-enable UER. If different TPE occurs then it is recoverable. */ + beiscsi_set_uer_feature(phba); + +- phba->shost->max_id = phba->params.cxns_per_ctrl; ++ phba->shost->max_id = phba->params.cxns_per_ctrl - 1; + phba->shost->can_queue = phba->params.ios_per_ctrl; + ret = beiscsi_init_port(phba); + if (ret < 0) { +@@ -5745,6 +5745,7 @@ free_hba: + pci_disable_msix(phba->pcidev); + pci_dev_put(phba->pcidev); + iscsi_host_free(phba->shost); ++ pci_disable_pcie_error_reporting(pcidev); + pci_set_drvdata(pcidev, NULL); + disable_pci: + pci_release_regions(pcidev); +diff --git a/drivers/scsi/bnx2i/bnx2i_iscsi.c b/drivers/scsi/bnx2i/bnx2i_iscsi.c +index 0b28d44d35738..949d20b72ec44 100644 +--- a/drivers/scsi/bnx2i/bnx2i_iscsi.c ++++ b/drivers/scsi/bnx2i/bnx2i_iscsi.c +@@ -793,7 +793,7 @@ struct bnx2i_hba *bnx2i_alloc_hba(struct cnic_dev *cnic) + return NULL; + shost->dma_boundary = cnic->pcidev->dma_mask; + shost->transportt = bnx2i_scsi_xport_template; +- shost->max_id = ISCSI_MAX_CONNS_PER_HBA; ++ shost->max_id = ISCSI_MAX_CONNS_PER_HBA - 1; + shost->max_channel = 0; + shost->max_lun = 512; + shost->max_cmd_len = 16; +diff --git a/drivers/scsi/cxgbi/libcxgbi.c b/drivers/scsi/cxgbi/libcxgbi.c +index 2cd2761bd2492..40d93fadd206c 100644 +--- a/drivers/scsi/cxgbi/libcxgbi.c ++++ b/drivers/scsi/cxgbi/libcxgbi.c +@@ -337,7 +337,7 @@ void cxgbi_hbas_remove(struct cxgbi_device *cdev) + EXPORT_SYMBOL_GPL(cxgbi_hbas_remove); + + int cxgbi_hbas_add(struct cxgbi_device *cdev, u64 max_lun, +- unsigned int max_id, struct scsi_host_template *sht, ++ unsigned int max_conns, struct scsi_host_template *sht, + struct scsi_transport_template *stt) + { + struct cxgbi_hba *chba; +@@ -357,7 +357,7 @@ int cxgbi_hbas_add(struct cxgbi_device *cdev, u64 max_lun, + + shost->transportt = stt; + shost->max_lun = max_lun; +- shost->max_id = max_id; ++ shost->max_id = max_conns - 1; + shost->max_channel = 0; + shost->max_cmd_len = 16; + +diff --git a/drivers/scsi/device_handler/scsi_dh_alua.c b/drivers/scsi/device_handler/scsi_dh_alua.c +index df5a3bbeba5eb..fe8a5e5c0df84 100644 +--- a/drivers/scsi/device_handler/scsi_dh_alua.c ++++ b/drivers/scsi/device_handler/scsi_dh_alua.c +@@ -508,7 +508,8 @@ static int alua_rtpg(struct scsi_device *sdev, struct alua_port_group *pg) + struct alua_port_group *tmp_pg; + int len, k, off, bufflen = ALUA_RTPG_SIZE; + unsigned char *desc, *buff; +- unsigned err, retval; ++ unsigned err; ++ int retval; + unsigned int tpg_desc_tbl_off; + unsigned char orig_transition_tmo; + unsigned long flags; +@@ -548,12 +549,12 @@ static int alua_rtpg(struct scsi_device *sdev, struct alua_port_group *pg) + kfree(buff); + return SCSI_DH_OK; + } +- if (!scsi_sense_valid(&sense_hdr)) { ++ if (retval < 0 || !scsi_sense_valid(&sense_hdr)) { + sdev_printk(KERN_INFO, sdev, + "%s: rtpg failed, result %d\n", + ALUA_DH_NAME, retval); + kfree(buff); +- if (driver_byte(retval) == DRIVER_ERROR) ++ if (retval < 0) + return SCSI_DH_DEV_TEMP_BUSY; + return SCSI_DH_IO; + } +@@ -775,11 +776,11 @@ static unsigned alua_stpg(struct scsi_device *sdev, struct alua_port_group *pg) + retval = submit_stpg(sdev, pg->group_id, &sense_hdr); + + if (retval) { +- if (!scsi_sense_valid(&sense_hdr)) { ++ if (retval < 0 || !scsi_sense_valid(&sense_hdr)) { + sdev_printk(KERN_INFO, sdev, + "%s: stpg failed, result %d", + ALUA_DH_NAME, retval); +- if (driver_byte(retval) == DRIVER_ERROR) ++ if (retval < 0) + return SCSI_DH_DEV_TEMP_BUSY; + } else { + sdev_printk(KERN_INFO, sdev, "%s: stpg failed\n", +diff --git a/drivers/scsi/hisi_sas/hisi_sas_v1_hw.c b/drivers/scsi/hisi_sas/hisi_sas_v1_hw.c +index 3364ae0b9bfe6..9f6534bd354bc 100644 +--- a/drivers/scsi/hisi_sas/hisi_sas_v1_hw.c ++++ b/drivers/scsi/hisi_sas/hisi_sas_v1_hw.c +@@ -1648,7 +1648,7 @@ static int interrupt_init_v1_hw(struct hisi_hba *hisi_hba) + if (irq < 0) { + dev_err(dev, "irq init: fail map phy interrupt %d\n", + idx); +- return -ENOENT; ++ return irq; + } + + rc = devm_request_irq(dev, irq, phy_interrupts[j], 0, +@@ -1656,7 +1656,7 @@ static int interrupt_init_v1_hw(struct hisi_hba *hisi_hba) + if (rc) { + dev_err(dev, "irq init: could not request phy interrupt %d, rc=%d\n", + irq, rc); +- return -ENOENT; ++ return rc; + } + } + } +@@ -1667,7 +1667,7 @@ static int interrupt_init_v1_hw(struct hisi_hba *hisi_hba) + if (irq < 0) { + dev_err(dev, "irq init: could not map cq interrupt %d\n", + idx); +- return -ENOENT; ++ return irq; + } + + rc = devm_request_irq(dev, irq, cq_interrupt_v1_hw, 0, +@@ -1675,7 +1675,7 @@ static int interrupt_init_v1_hw(struct hisi_hba *hisi_hba) + if (rc) { + dev_err(dev, "irq init: could not request cq interrupt %d, rc=%d\n", + irq, rc); +- return -ENOENT; ++ return rc; + } + } + +@@ -1685,7 +1685,7 @@ static int interrupt_init_v1_hw(struct hisi_hba *hisi_hba) + if (irq < 0) { + dev_err(dev, "irq init: could not map fatal interrupt %d\n", + idx); +- return -ENOENT; ++ return irq; + } + + rc = devm_request_irq(dev, irq, fatal_interrupts[i], 0, +@@ -1693,7 +1693,7 @@ static int interrupt_init_v1_hw(struct hisi_hba *hisi_hba) + if (rc) { + dev_err(dev, "irq init: could not request fatal interrupt %d, rc=%d\n", + irq, rc); +- return -ENOENT; ++ return rc; + } + } + +diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c +index ff36432c8fbc2..7c736e4ddafe7 100644 +--- a/drivers/scsi/hosts.c ++++ b/drivers/scsi/hosts.c +@@ -219,6 +219,9 @@ int scsi_add_host_with_dma(struct Scsi_Host *shost, struct device *dev, + goto fail; + } + ++ shost->cmd_per_lun = min_t(short, shost->cmd_per_lun, ++ shost->can_queue); ++ + error = scsi_init_sense_cache(shost); + if (error) + goto fail; +@@ -486,6 +489,7 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize) + shost_printk(KERN_WARNING, shost, + "error handler thread failed to spawn, error = %ld\n", + PTR_ERR(shost->ehandler)); ++ shost->ehandler = NULL; + goto fail; + } + +diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c +index c5b7d18513b66..eeba6180711cd 100644 +--- a/drivers/scsi/libiscsi.c ++++ b/drivers/scsi/libiscsi.c +@@ -230,11 +230,11 @@ static int iscsi_prep_ecdb_ahs(struct iscsi_task *task) + */ + static int iscsi_check_tmf_restrictions(struct iscsi_task *task, int opcode) + { +- struct iscsi_conn *conn = task->conn; +- struct iscsi_tm *tmf = &conn->tmhdr; ++ struct iscsi_session *session = task->conn->session; ++ struct iscsi_tm *tmf = &session->tmhdr; + u64 hdr_lun; + +- if (conn->tmf_state == TMF_INITIAL) ++ if (session->tmf_state == TMF_INITIAL) + return 0; + + if ((tmf->opcode & ISCSI_OPCODE_MASK) != ISCSI_OP_SCSI_TMFUNC) +@@ -254,24 +254,19 @@ static int iscsi_check_tmf_restrictions(struct iscsi_task *task, int opcode) + * Fail all SCSI cmd PDUs + */ + if (opcode != ISCSI_OP_SCSI_DATA_OUT) { +- iscsi_conn_printk(KERN_INFO, conn, +- "task [op %x itt " +- "0x%x/0x%x] " +- "rejected.\n", +- opcode, task->itt, +- task->hdr_itt); ++ iscsi_session_printk(KERN_INFO, session, ++ "task [op %x itt 0x%x/0x%x] rejected.\n", ++ opcode, task->itt, task->hdr_itt); + return -EACCES; + } + /* + * And also all data-out PDUs in response to R2T + * if fast_abort is set. + */ +- if (conn->session->fast_abort) { +- iscsi_conn_printk(KERN_INFO, conn, +- "task [op %x itt " +- "0x%x/0x%x] fast abort.\n", +- opcode, task->itt, +- task->hdr_itt); ++ if (session->fast_abort) { ++ iscsi_session_printk(KERN_INFO, session, ++ "task [op %x itt 0x%x/0x%x] fast abort.\n", ++ opcode, task->itt, task->hdr_itt); + return -EACCES; + } + break; +@@ -284,7 +279,7 @@ static int iscsi_check_tmf_restrictions(struct iscsi_task *task, int opcode) + */ + if (opcode == ISCSI_OP_SCSI_DATA_OUT && + task->hdr_itt == tmf->rtt) { +- ISCSI_DBG_SESSION(conn->session, ++ ISCSI_DBG_SESSION(session, + "Preventing task %x/%x from sending " + "data-out due to abort task in " + "progress\n", task->itt, +@@ -923,20 +918,21 @@ iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, + static void iscsi_tmf_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr) + { + struct iscsi_tm_rsp *tmf = (struct iscsi_tm_rsp *)hdr; ++ struct iscsi_session *session = conn->session; + + conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; + conn->tmfrsp_pdus_cnt++; + +- if (conn->tmf_state != TMF_QUEUED) ++ if (session->tmf_state != TMF_QUEUED) + return; + + if (tmf->response == ISCSI_TMF_RSP_COMPLETE) +- conn->tmf_state = TMF_SUCCESS; ++ session->tmf_state = TMF_SUCCESS; + else if (tmf->response == ISCSI_TMF_RSP_NO_TASK) +- conn->tmf_state = TMF_NOT_FOUND; ++ session->tmf_state = TMF_NOT_FOUND; + else +- conn->tmf_state = TMF_FAILED; +- wake_up(&conn->ehwait); ++ session->tmf_state = TMF_FAILED; ++ wake_up(&session->ehwait); + } + + static int iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr) +@@ -1348,7 +1344,6 @@ void iscsi_session_failure(struct iscsi_session *session, + enum iscsi_err err) + { + struct iscsi_conn *conn; +- struct device *dev; + + spin_lock_bh(&session->frwd_lock); + conn = session->leadconn; +@@ -1357,10 +1352,8 @@ void iscsi_session_failure(struct iscsi_session *session, + return; + } + +- dev = get_device(&conn->cls_conn->dev); ++ iscsi_get_conn(conn->cls_conn); + spin_unlock_bh(&session->frwd_lock); +- if (!dev) +- return; + /* + * if the host is being removed bypass the connection + * recovery initialization because we are going to kill +@@ -1370,7 +1363,7 @@ void iscsi_session_failure(struct iscsi_session *session, + iscsi_conn_error_event(conn->cls_conn, err); + else + iscsi_conn_failure(conn, err); +- put_device(dev); ++ iscsi_put_conn(conn->cls_conn); + } + EXPORT_SYMBOL_GPL(iscsi_session_failure); + +@@ -1787,15 +1780,14 @@ EXPORT_SYMBOL_GPL(iscsi_target_alloc); + + static void iscsi_tmf_timedout(struct timer_list *t) + { +- struct iscsi_conn *conn = from_timer(conn, t, tmf_timer); +- struct iscsi_session *session = conn->session; ++ struct iscsi_session *session = from_timer(session, t, tmf_timer); + + spin_lock(&session->frwd_lock); +- if (conn->tmf_state == TMF_QUEUED) { +- conn->tmf_state = TMF_TIMEDOUT; ++ if (session->tmf_state == TMF_QUEUED) { ++ session->tmf_state = TMF_TIMEDOUT; + ISCSI_DBG_EH(session, "tmf timedout\n"); + /* unblock eh_abort() */ +- wake_up(&conn->ehwait); ++ wake_up(&session->ehwait); + } + spin_unlock(&session->frwd_lock); + } +@@ -1818,8 +1810,8 @@ static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn, + return -EPERM; + } + conn->tmfcmd_pdus_cnt++; +- conn->tmf_timer.expires = timeout * HZ + jiffies; +- add_timer(&conn->tmf_timer); ++ session->tmf_timer.expires = timeout * HZ + jiffies; ++ add_timer(&session->tmf_timer); + ISCSI_DBG_EH(session, "tmf set timeout\n"); + + spin_unlock_bh(&session->frwd_lock); +@@ -1833,12 +1825,12 @@ static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn, + * 3) session is terminated or restarted or userspace has + * given up on recovery + */ +- wait_event_interruptible(conn->ehwait, age != session->age || ++ wait_event_interruptible(session->ehwait, age != session->age || + session->state != ISCSI_STATE_LOGGED_IN || +- conn->tmf_state != TMF_QUEUED); ++ session->tmf_state != TMF_QUEUED); + if (signal_pending(current)) + flush_signals(current); +- del_timer_sync(&conn->tmf_timer); ++ del_timer_sync(&session->tmf_timer); + + mutex_lock(&session->eh_mutex); + spin_lock_bh(&session->frwd_lock); +@@ -2198,17 +2190,17 @@ int iscsi_eh_abort(struct scsi_cmnd *sc) + } + + /* only have one tmf outstanding at a time */ +- if (conn->tmf_state != TMF_INITIAL) ++ if (session->tmf_state != TMF_INITIAL) + goto failed; +- conn->tmf_state = TMF_QUEUED; ++ session->tmf_state = TMF_QUEUED; + +- hdr = &conn->tmhdr; ++ hdr = &session->tmhdr; + iscsi_prep_abort_task_pdu(task, hdr); + + if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) + goto failed; + +- switch (conn->tmf_state) { ++ switch (session->tmf_state) { + case TMF_SUCCESS: + spin_unlock_bh(&session->frwd_lock); + /* +@@ -2223,7 +2215,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc) + */ + spin_lock_bh(&session->frwd_lock); + fail_scsi_task(task, DID_ABORT); +- conn->tmf_state = TMF_INITIAL; ++ session->tmf_state = TMF_INITIAL; + memset(hdr, 0, sizeof(*hdr)); + spin_unlock_bh(&session->frwd_lock); + iscsi_start_tx(conn); +@@ -2234,7 +2226,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc) + goto failed_unlocked; + case TMF_NOT_FOUND: + if (!sc->SCp.ptr) { +- conn->tmf_state = TMF_INITIAL; ++ session->tmf_state = TMF_INITIAL; + memset(hdr, 0, sizeof(*hdr)); + /* task completed before tmf abort response */ + ISCSI_DBG_EH(session, "sc completed while abort in " +@@ -2243,7 +2235,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc) + } + /* fall through */ + default: +- conn->tmf_state = TMF_INITIAL; ++ session->tmf_state = TMF_INITIAL; + goto failed; + } + +@@ -2300,11 +2292,11 @@ int iscsi_eh_device_reset(struct scsi_cmnd *sc) + conn = session->leadconn; + + /* only have one tmf outstanding at a time */ +- if (conn->tmf_state != TMF_INITIAL) ++ if (session->tmf_state != TMF_INITIAL) + goto unlock; +- conn->tmf_state = TMF_QUEUED; ++ session->tmf_state = TMF_QUEUED; + +- hdr = &conn->tmhdr; ++ hdr = &session->tmhdr; + iscsi_prep_lun_reset_pdu(sc, hdr); + + if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, +@@ -2313,7 +2305,7 @@ int iscsi_eh_device_reset(struct scsi_cmnd *sc) + goto unlock; + } + +- switch (conn->tmf_state) { ++ switch (session->tmf_state) { + case TMF_SUCCESS: + break; + case TMF_TIMEDOUT: +@@ -2321,7 +2313,7 @@ int iscsi_eh_device_reset(struct scsi_cmnd *sc) + iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); + goto done; + default: +- conn->tmf_state = TMF_INITIAL; ++ session->tmf_state = TMF_INITIAL; + goto unlock; + } + +@@ -2333,7 +2325,7 @@ int iscsi_eh_device_reset(struct scsi_cmnd *sc) + spin_lock_bh(&session->frwd_lock); + memset(hdr, 0, sizeof(*hdr)); + fail_scsi_tasks(conn, sc->device->lun, DID_ERROR); +- conn->tmf_state = TMF_INITIAL; ++ session->tmf_state = TMF_INITIAL; + spin_unlock_bh(&session->frwd_lock); + + iscsi_start_tx(conn); +@@ -2356,8 +2348,7 @@ void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session) + spin_lock_bh(&session->frwd_lock); + if (session->state != ISCSI_STATE_LOGGED_IN) { + session->state = ISCSI_STATE_RECOVERY_FAILED; +- if (session->leadconn) +- wake_up(&session->leadconn->ehwait); ++ wake_up(&session->ehwait); + } + spin_unlock_bh(&session->frwd_lock); + } +@@ -2402,7 +2393,7 @@ failed: + iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); + + ISCSI_DBG_EH(session, "wait for relogin\n"); +- wait_event_interruptible(conn->ehwait, ++ wait_event_interruptible(session->ehwait, + session->state == ISCSI_STATE_TERMINATE || + session->state == ISCSI_STATE_LOGGED_IN || + session->state == ISCSI_STATE_RECOVERY_FAILED); +@@ -2463,11 +2454,11 @@ static int iscsi_eh_target_reset(struct scsi_cmnd *sc) + conn = session->leadconn; + + /* only have one tmf outstanding at a time */ +- if (conn->tmf_state != TMF_INITIAL) ++ if (session->tmf_state != TMF_INITIAL) + goto unlock; +- conn->tmf_state = TMF_QUEUED; ++ session->tmf_state = TMF_QUEUED; + +- hdr = &conn->tmhdr; ++ hdr = &session->tmhdr; + iscsi_prep_tgt_reset_pdu(sc, hdr); + + if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, +@@ -2476,7 +2467,7 @@ static int iscsi_eh_target_reset(struct scsi_cmnd *sc) + goto unlock; + } + +- switch (conn->tmf_state) { ++ switch (session->tmf_state) { + case TMF_SUCCESS: + break; + case TMF_TIMEDOUT: +@@ -2484,7 +2475,7 @@ static int iscsi_eh_target_reset(struct scsi_cmnd *sc) + iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); + goto done; + default: +- conn->tmf_state = TMF_INITIAL; ++ session->tmf_state = TMF_INITIAL; + goto unlock; + } + +@@ -2496,7 +2487,7 @@ static int iscsi_eh_target_reset(struct scsi_cmnd *sc) + spin_lock_bh(&session->frwd_lock); + memset(hdr, 0, sizeof(*hdr)); + fail_scsi_tasks(conn, -1, DID_ERROR); +- conn->tmf_state = TMF_INITIAL; ++ session->tmf_state = TMF_INITIAL; + spin_unlock_bh(&session->frwd_lock); + + iscsi_start_tx(conn); +@@ -2801,7 +2792,10 @@ iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost, + session->tt = iscsit; + session->dd_data = cls_session->dd_data + sizeof(*session); + ++ session->tmf_state = TMF_INITIAL; ++ timer_setup(&session->tmf_timer, iscsi_tmf_timedout, 0); + mutex_init(&session->eh_mutex); ++ + spin_lock_init(&session->frwd_lock); + spin_lock_init(&session->back_lock); + +@@ -2905,7 +2899,6 @@ iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size, + conn->c_stage = ISCSI_CONN_INITIAL_STAGE; + conn->id = conn_idx; + conn->exp_statsn = 0; +- conn->tmf_state = TMF_INITIAL; + + timer_setup(&conn->transport_timer, iscsi_check_transport_timeouts, 0); + +@@ -2931,8 +2924,7 @@ iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size, + goto login_task_data_alloc_fail; + conn->login_task->data = conn->data = data; + +- timer_setup(&conn->tmf_timer, iscsi_tmf_timedout, 0); +- init_waitqueue_head(&conn->ehwait); ++ init_waitqueue_head(&session->ehwait); + + return cls_conn; + +@@ -2967,7 +2959,7 @@ void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn) + * leading connection? then give up on recovery. + */ + session->state = ISCSI_STATE_TERMINATE; +- wake_up(&conn->ehwait); ++ wake_up(&session->ehwait); + } + spin_unlock_bh(&session->frwd_lock); + +@@ -3042,7 +3034,7 @@ int iscsi_conn_start(struct iscsi_cls_conn *cls_conn) + * commands after successful recovery + */ + conn->stop_stage = 0; +- conn->tmf_state = TMF_INITIAL; ++ session->tmf_state = TMF_INITIAL; + session->age++; + if (session->age == 16) + session->age = 0; +@@ -3056,7 +3048,7 @@ int iscsi_conn_start(struct iscsi_cls_conn *cls_conn) + spin_unlock_bh(&session->frwd_lock); + + iscsi_unblock_session(session->cls_session); +- wake_up(&conn->ehwait); ++ wake_up(&session->ehwait); + return 0; + } + EXPORT_SYMBOL_GPL(iscsi_conn_start); +@@ -3143,7 +3135,7 @@ static void iscsi_start_session_recovery(struct iscsi_session *session, + spin_lock_bh(&session->frwd_lock); + fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED); + fail_mgmt_tasks(session, conn); +- memset(&conn->tmhdr, 0, sizeof(conn->tmhdr)); ++ memset(&session->tmhdr, 0, sizeof(session->tmhdr)); + spin_unlock_bh(&session->frwd_lock); + mutex_unlock(&session->eh_mutex); + } +diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c +index 4e994a693e3f5..2040affa08874 100644 +--- a/drivers/scsi/lpfc/lpfc_els.c ++++ b/drivers/scsi/lpfc/lpfc_els.c +@@ -1179,6 +1179,15 @@ stop_rr_fcf_flogi: + phba->fcf.fcf_redisc_attempted = 0; /* reset */ + goto out; + } ++ } else if (vport->port_state > LPFC_FLOGI && ++ vport->fc_flag & FC_PT2PT) { ++ /* ++ * In a p2p topology, it is possible that discovery has ++ * already progressed, and this completion can be ignored. ++ * Recheck the indicated topology. ++ */ ++ if (!sp->cmn.fPort) ++ goto out; + } + + flogifail: +diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c +index 795460eda6a59..4a7ceaa34341c 100644 +--- a/drivers/scsi/lpfc/lpfc_sli.c ++++ b/drivers/scsi/lpfc/lpfc_sli.c +@@ -7602,7 +7602,7 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba) + "0393 Error %d during rpi post operation\n", + rc); + rc = -ENODEV; +- goto out_destroy_queue; ++ goto out_free_iocblist; + } + lpfc_sli4_node_prep(phba); + +@@ -7765,8 +7765,9 @@ out_io_buff_free: + out_unset_queue: + /* Unset all the queues set up in this routine when error out */ + lpfc_sli4_queue_unset(phba); +-out_destroy_queue: ++out_free_iocblist: + lpfc_free_iocb_list(phba); ++out_destroy_queue: + lpfc_sli4_queue_destroy(phba); + out_stop_timers: + lpfc_stop_hba_timers(phba); +diff --git a/drivers/scsi/megaraid/megaraid_sas.h b/drivers/scsi/megaraid/megaraid_sas.h +index a6e788c02ff4f..3d43ac9772f7e 100644 +--- a/drivers/scsi/megaraid/megaraid_sas.h ++++ b/drivers/scsi/megaraid/megaraid_sas.h +@@ -2256,6 +2256,15 @@ enum MR_PERF_MODE { + (mode) == MR_LATENCY_PERF_MODE ? "Latency" : \ + "Unknown") + ++enum MEGASAS_LD_TARGET_ID_STATUS { ++ LD_TARGET_ID_INITIAL, ++ LD_TARGET_ID_ACTIVE, ++ LD_TARGET_ID_DELETED, ++}; ++ ++#define MEGASAS_TARGET_ID(sdev) \ ++ (((sdev->channel % 2) * MEGASAS_MAX_DEV_PER_CHANNEL) + sdev->id) ++ + struct megasas_instance { + + unsigned int *reply_map; +@@ -2320,6 +2329,9 @@ struct megasas_instance { + struct megasas_pd_list pd_list[MEGASAS_MAX_PD]; + struct megasas_pd_list local_pd_list[MEGASAS_MAX_PD]; + u8 ld_ids[MEGASAS_MAX_LD_IDS]; ++ u8 ld_tgtid_status[MEGASAS_MAX_LD_IDS]; ++ u8 ld_ids_prev[MEGASAS_MAX_LD_IDS]; ++ u8 ld_ids_from_raidmap[MEGASAS_MAX_LD_IDS]; + s8 init_id; + + u16 max_num_sge; +diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c +index b9c1f722f1ded..6700d43b12ff5 100644 +--- a/drivers/scsi/megaraid/megaraid_sas_base.c ++++ b/drivers/scsi/megaraid/megaraid_sas_base.c +@@ -127,6 +127,8 @@ static int megasas_register_aen(struct megasas_instance *instance, + u32 seq_num, u32 class_locale_word); + static void megasas_get_pd_info(struct megasas_instance *instance, + struct scsi_device *sdev); ++static void ++megasas_set_ld_removed_by_fw(struct megasas_instance *instance); + + /* + * PCI ID table for all supported controllers +@@ -425,6 +427,12 @@ megasas_decode_evt(struct megasas_instance *instance) + (class_locale.members.locale), + format_class(class_locale.members.class), + evt_detail->description); ++ ++ if (megasas_dbg_lvl & LD_PD_DEBUG) ++ dev_info(&instance->pdev->dev, ++ "evt_detail.args.ld.target_id/index %d/%d\n", ++ evt_detail->args.ld.target_id, evt_detail->args.ld.ld_index); ++ + } + + /** +@@ -1759,6 +1767,7 @@ megasas_queue_command(struct Scsi_Host *shost, struct scsi_cmnd *scmd) + { + struct megasas_instance *instance; + struct MR_PRIV_DEVICE *mr_device_priv_data; ++ u32 ld_tgt_id; + + instance = (struct megasas_instance *) + scmd->device->host->hostdata; +@@ -1785,17 +1794,21 @@ megasas_queue_command(struct Scsi_Host *shost, struct scsi_cmnd *scmd) + } + } + +- if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) { ++ mr_device_priv_data = scmd->device->hostdata; ++ if (!mr_device_priv_data || ++ (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)) { + scmd->result = DID_NO_CONNECT << 16; + scmd->scsi_done(scmd); + return 0; + } + +- mr_device_priv_data = scmd->device->hostdata; +- if (!mr_device_priv_data) { +- scmd->result = DID_NO_CONNECT << 16; +- scmd->scsi_done(scmd); +- return 0; ++ if (MEGASAS_IS_LOGICAL(scmd->device)) { ++ ld_tgt_id = MEGASAS_TARGET_ID(scmd->device); ++ if (instance->ld_tgtid_status[ld_tgt_id] == LD_TARGET_ID_DELETED) { ++ scmd->result = DID_NO_CONNECT << 16; ++ scmd->scsi_done(scmd); ++ return 0; ++ } + } + + if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) +@@ -2071,7 +2084,7 @@ static int megasas_slave_configure(struct scsi_device *sdev) + + static int megasas_slave_alloc(struct scsi_device *sdev) + { +- u16 pd_index = 0; ++ u16 pd_index = 0, ld_tgt_id; + struct megasas_instance *instance ; + struct MR_PRIV_DEVICE *mr_device_priv_data; + +@@ -2096,6 +2109,14 @@ scan_target: + GFP_KERNEL); + if (!mr_device_priv_data) + return -ENOMEM; ++ ++ if (MEGASAS_IS_LOGICAL(sdev)) { ++ ld_tgt_id = MEGASAS_TARGET_ID(sdev); ++ instance->ld_tgtid_status[ld_tgt_id] = LD_TARGET_ID_ACTIVE; ++ if (megasas_dbg_lvl & LD_PD_DEBUG) ++ sdev_printk(KERN_INFO, sdev, "LD target ID %d created.\n", ld_tgt_id); ++ } ++ + sdev->hostdata = mr_device_priv_data; + + atomic_set(&mr_device_priv_data->r1_ldio_hint, +@@ -2105,6 +2126,19 @@ scan_target: + + static void megasas_slave_destroy(struct scsi_device *sdev) + { ++ u16 ld_tgt_id; ++ struct megasas_instance *instance; ++ ++ instance = megasas_lookup_instance(sdev->host->host_no); ++ ++ if (MEGASAS_IS_LOGICAL(sdev)) { ++ ld_tgt_id = MEGASAS_TARGET_ID(sdev); ++ instance->ld_tgtid_status[ld_tgt_id] = LD_TARGET_ID_DELETED; ++ if (megasas_dbg_lvl & LD_PD_DEBUG) ++ sdev_printk(KERN_INFO, sdev, ++ "LD target ID %d removed from OS stack\n", ld_tgt_id); ++ } ++ + kfree(sdev->hostdata); + sdev->hostdata = NULL; + } +@@ -3456,6 +3490,22 @@ megasas_complete_abort(struct megasas_instance *instance, + } + } + ++static void ++megasas_set_ld_removed_by_fw(struct megasas_instance *instance) ++{ ++ uint i; ++ ++ for (i = 0; (i < MEGASAS_MAX_LD_IDS); i++) { ++ if (instance->ld_ids_prev[i] != 0xff && ++ instance->ld_ids_from_raidmap[i] == 0xff) { ++ if (megasas_dbg_lvl & LD_PD_DEBUG) ++ dev_info(&instance->pdev->dev, ++ "LD target ID %d removed from RAID map\n", i); ++ instance->ld_tgtid_status[i] = LD_TARGET_ID_DELETED; ++ } ++ } ++} ++ + /** + * megasas_complete_cmd - Completes a command + * @instance: Adapter soft state +@@ -3618,9 +3668,13 @@ megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd, + fusion->fast_path_io = 0; + } + ++ if (instance->adapter_type >= INVADER_SERIES) ++ megasas_set_ld_removed_by_fw(instance); ++ + megasas_sync_map_info(instance); + spin_unlock_irqrestore(instance->host->host_lock, + flags); ++ + break; + } + if (opcode == MR_DCMD_CTRL_EVENT_GET_INFO || +@@ -7415,11 +7469,16 @@ static int megasas_probe_one(struct pci_dev *pdev, + return 0; + + fail_start_aen: ++ instance->unload = 1; ++ scsi_remove_host(instance->host); + fail_io_attach: + megasas_mgmt_info.count--; + megasas_mgmt_info.max_index--; + megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = NULL; + ++ if (instance->requestorId && !instance->skip_heartbeat_timer_del) ++ del_timer_sync(&instance->sriov_heartbeat_timer); ++ + instance->instancet->disable_intr(instance); + megasas_destroy_irqs(instance); + +@@ -7427,8 +7486,16 @@ fail_io_attach: + megasas_release_fusion(instance); + else + megasas_release_mfi(instance); ++ + if (instance->msix_vectors) + pci_free_irq_vectors(instance->pdev); ++ instance->msix_vectors = 0; ++ ++ if (instance->fw_crash_state != UNAVAILABLE) ++ megasas_free_host_crash_buffer(instance); ++ ++ if (instance->adapter_type != MFI_SERIES) ++ megasas_fusion_stop_watchdog(instance); + fail_init_mfi: + scsi_host_put(host); + fail_alloc_instance: +@@ -8698,8 +8765,10 @@ megasas_aen_polling(struct work_struct *work) + union megasas_evt_class_locale class_locale; + int event_type = 0; + u32 seq_num; ++ u16 ld_target_id; + int error; + u8 dcmd_ret = DCMD_SUCCESS; ++ struct scsi_device *sdev1; + + if (!instance) { + printk(KERN_ERR "invalid instance!\n"); +@@ -8722,12 +8791,23 @@ megasas_aen_polling(struct work_struct *work) + break; + + case MR_EVT_LD_OFFLINE: +- case MR_EVT_CFG_CLEARED: + case MR_EVT_LD_DELETED: ++ ld_target_id = instance->evt_detail->args.ld.target_id; ++ sdev1 = scsi_device_lookup(instance->host, ++ MEGASAS_MAX_PD_CHANNELS + ++ (ld_target_id / MEGASAS_MAX_DEV_PER_CHANNEL), ++ (ld_target_id - MEGASAS_MAX_DEV_PER_CHANNEL), ++ 0); ++ if (sdev1) ++ megasas_remove_scsi_device(sdev1); ++ ++ event_type = SCAN_VD_CHANNEL; ++ break; + case MR_EVT_LD_CREATED: + event_type = SCAN_VD_CHANNEL; + break; + ++ case MR_EVT_CFG_CLEARED: + case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED: + case MR_EVT_FOREIGN_CFG_IMPORTED: + case MR_EVT_LD_STATE_CHANGE: +diff --git a/drivers/scsi/megaraid/megaraid_sas_fp.c b/drivers/scsi/megaraid/megaraid_sas_fp.c +index 50b8c1b127671..8bfb46dbbed3a 100644 +--- a/drivers/scsi/megaraid/megaraid_sas_fp.c ++++ b/drivers/scsi/megaraid/megaraid_sas_fp.c +@@ -350,6 +350,10 @@ u8 MR_ValidateMapInfo(struct megasas_instance *instance, u64 map_id) + + num_lds = le16_to_cpu(drv_map->raidMap.ldCount); + ++ memcpy(instance->ld_ids_prev, ++ instance->ld_ids_from_raidmap, ++ sizeof(instance->ld_ids_from_raidmap)); ++ memset(instance->ld_ids_from_raidmap, 0xff, MEGASAS_MAX_LD_IDS); + /*Convert Raid capability values to CPU arch */ + for (i = 0; (num_lds > 0) && (i < MAX_LOGICAL_DRIVES_EXT); i++) { + ld = MR_TargetIdToLdGet(i, drv_map); +@@ -360,7 +364,7 @@ u8 MR_ValidateMapInfo(struct megasas_instance *instance, u64 map_id) + + raid = MR_LdRaidGet(ld, drv_map); + le32_to_cpus((u32 *)&raid->capability); +- ++ instance->ld_ids_from_raidmap[i] = i; + num_lds--; + } + +diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.c b/drivers/scsi/megaraid/megaraid_sas_fusion.c +index 5dcd7b9b72ced..a78a702511faa 100644 +--- a/drivers/scsi/megaraid/megaraid_sas_fusion.c ++++ b/drivers/scsi/megaraid/megaraid_sas_fusion.c +@@ -3716,6 +3716,7 @@ static void megasas_sync_irqs(unsigned long instance_addr) + if (irq_ctx->irq_poll_scheduled) { + irq_ctx->irq_poll_scheduled = false; + enable_irq(irq_ctx->os_irq); ++ complete_cmd_fusion(instance, irq_ctx->MSIxIndex, irq_ctx); + } + } + } +@@ -3747,6 +3748,7 @@ int megasas_irqpoll(struct irq_poll *irqpoll, int budget) + irq_poll_complete(irqpoll); + irq_ctx->irq_poll_scheduled = false; + enable_irq(irq_ctx->os_irq); ++ complete_cmd_fusion(instance, irq_ctx->MSIxIndex, irq_ctx); + } + + return num_entries; +@@ -3763,6 +3765,7 @@ megasas_complete_cmd_dpc_fusion(unsigned long instance_addr) + { + struct megasas_instance *instance = + (struct megasas_instance *)instance_addr; ++ struct megasas_irq_context *irq_ctx = NULL; + u32 count, MSIxIndex; + + count = instance->msix_vectors > 0 ? instance->msix_vectors : 1; +@@ -3771,8 +3774,10 @@ megasas_complete_cmd_dpc_fusion(unsigned long instance_addr) + if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) + return; + +- for (MSIxIndex = 0 ; MSIxIndex < count; MSIxIndex++) +- complete_cmd_fusion(instance, MSIxIndex, NULL); ++ for (MSIxIndex = 0 ; MSIxIndex < count; MSIxIndex++) { ++ irq_ctx = &instance->irq_context[MSIxIndex]; ++ complete_cmd_fusion(instance, MSIxIndex, irq_ctx); ++ } + } + + /** +@@ -5177,6 +5182,7 @@ megasas_alloc_fusion_context(struct megasas_instance *instance) + if (!fusion->log_to_span) { + dev_err(&instance->pdev->dev, "Failed from %s %d\n", + __func__, __LINE__); ++ kfree(instance->ctrl_context); + return -ENOMEM; + } + } +diff --git a/drivers/scsi/qedi/qedi_fw.c b/drivers/scsi/qedi/qedi_fw.c +index 90aa64604ad78..37b8f08d5020f 100644 +--- a/drivers/scsi/qedi/qedi_fw.c ++++ b/drivers/scsi/qedi/qedi_fw.c +@@ -1451,7 +1451,7 @@ abort_ret: + + ldel_exit: + spin_lock_bh(&qedi_conn->tmf_work_lock); +- if (!qedi_cmd->list_tmf_work) { ++ if (qedi_cmd->list_tmf_work) { + list_del_init(&list_work->list); + qedi_cmd->list_tmf_work = NULL; + kfree(list_work); +diff --git a/drivers/scsi/qedi/qedi_main.c b/drivers/scsi/qedi/qedi_main.c +index 4498add3d4d66..1ec42c5f0b2a0 100644 +--- a/drivers/scsi/qedi/qedi_main.c ++++ b/drivers/scsi/qedi/qedi_main.c +@@ -631,7 +631,7 @@ static struct qedi_ctx *qedi_host_alloc(struct pci_dev *pdev) + goto exit_setup_shost; + } + +- shost->max_id = QEDI_MAX_ISCSI_CONNS_PER_HBA; ++ shost->max_id = QEDI_MAX_ISCSI_CONNS_PER_HBA - 1; + shost->max_channel = 0; + shost->max_lun = ~0; + shost->max_cmd_len = 16; +diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c +index a26df7d6d5d18..2f1553d0a10ed 100644 +--- a/drivers/scsi/scsi_transport_iscsi.c ++++ b/drivers/scsi/scsi_transport_iscsi.c +@@ -2308,6 +2308,18 @@ int iscsi_destroy_conn(struct iscsi_cls_conn *conn) + } + EXPORT_SYMBOL_GPL(iscsi_destroy_conn); + ++void iscsi_put_conn(struct iscsi_cls_conn *conn) ++{ ++ put_device(&conn->dev); ++} ++EXPORT_SYMBOL_GPL(iscsi_put_conn); ++ ++void iscsi_get_conn(struct iscsi_cls_conn *conn) ++{ ++ get_device(&conn->dev); ++} ++EXPORT_SYMBOL_GPL(iscsi_get_conn); ++ + /* + * iscsi interface functions + */ +diff --git a/drivers/staging/rtl8723bs/hal/odm.h b/drivers/staging/rtl8723bs/hal/odm.h +index fba3b9e1491b4..ee867621aed9f 100644 +--- a/drivers/staging/rtl8723bs/hal/odm.h ++++ b/drivers/staging/rtl8723bs/hal/odm.h +@@ -197,10 +197,7 @@ typedef struct _ODM_RATE_ADAPTIVE { + + #define AVG_THERMAL_NUM 8 + #define IQK_Matrix_REG_NUM 8 +-#define IQK_Matrix_Settings_NUM (14 + 24 + 21) /* Channels_2_4G_NUM +- * + Channels_5G_20M_NUM +- * + Channels_5G +- */ ++#define IQK_Matrix_Settings_NUM 14 /* Channels_2_4G_NUM */ + + #define DM_Type_ByFW 0 + #define DM_Type_ByDriver 1 +diff --git a/drivers/thermal/rcar_gen3_thermal.c b/drivers/thermal/rcar_gen3_thermal.c +index 1ab2ffff4e7c7..a0673059bd4ae 100644 +--- a/drivers/thermal/rcar_gen3_thermal.c ++++ b/drivers/thermal/rcar_gen3_thermal.c +@@ -143,7 +143,7 @@ static void rcar_gen3_thermal_calc_coefs(struct rcar_gen3_thermal_tsc *tsc, + * Division is not scaled in BSP and if scaled it might overflow + * the dividend (4095 * 4095 << 14 > INT_MAX) so keep it unscaled + */ +- tsc->tj_t = (FIXPT_INT((ptat[1] - ptat[2]) * 157) ++ tsc->tj_t = (FIXPT_INT((ptat[1] - ptat[2]) * (ths_tj_1 - TJ_3)) + / (ptat[0] - ptat[2])) + FIXPT_INT(TJ_3); + + tsc->coef.a1 = FIXPT_DIV(FIXPT_INT(thcode[1] - thcode[2]), +diff --git a/drivers/tty/serial/8250/serial_cs.c b/drivers/tty/serial/8250/serial_cs.c +index ccd1a615305b5..a05c2b652040c 100644 +--- a/drivers/tty/serial/8250/serial_cs.c ++++ b/drivers/tty/serial/8250/serial_cs.c +@@ -306,6 +306,7 @@ static int serial_resume(struct pcmcia_device *link) + static int serial_probe(struct pcmcia_device *link) + { + struct serial_info *info; ++ int ret; + + dev_dbg(&link->dev, "serial_attach()\n"); + +@@ -320,7 +321,15 @@ static int serial_probe(struct pcmcia_device *link) + if (do_sound) + link->config_flags |= CONF_ENABLE_SPKR; + +- return serial_config(link); ++ ret = serial_config(link); ++ if (ret) ++ goto free_info; ++ ++ return 0; ++ ++free_info: ++ kfree(info); ++ return ret; + } + + static void serial_detach(struct pcmcia_device *link) +diff --git a/drivers/tty/serial/fsl_lpuart.c b/drivers/tty/serial/fsl_lpuart.c +index 6ad985e8dc653..b053345dfd1ae 100644 +--- a/drivers/tty/serial/fsl_lpuart.c ++++ b/drivers/tty/serial/fsl_lpuart.c +@@ -2253,6 +2253,9 @@ lpuart32_console_get_options(struct lpuart_port *sport, int *baud, + + bd = lpuart32_read(&sport->port, UARTBAUD); + bd &= UARTBAUD_SBR_MASK; ++ if (!bd) ++ return; ++ + sbr = bd; + uartclk = lpuart_get_baud_clk_rate(sport); + /* +diff --git a/drivers/tty/serial/uartlite.c b/drivers/tty/serial/uartlite.c +index 06e79c11141d4..56066d93a65b8 100644 +--- a/drivers/tty/serial/uartlite.c ++++ b/drivers/tty/serial/uartlite.c +@@ -508,21 +508,23 @@ static void ulite_console_write(struct console *co, const char *s, + + static int ulite_console_setup(struct console *co, char *options) + { +- struct uart_port *port; ++ struct uart_port *port = NULL; + int baud = 9600; + int bits = 8; + int parity = 'n'; + int flow = 'n'; + +- +- port = console_port; ++ if (co->index >= 0 && co->index < ULITE_NR_UARTS) ++ port = ulite_ports + co->index; + + /* Has the device been initialized yet? */ +- if (!port->mapbase) { ++ if (!port || !port->mapbase) { + pr_debug("console on ttyUL%i not present\n", co->index); + return -ENODEV; + } + ++ console_port = port; ++ + /* not initialized yet? */ + if (!port->membase) { + if (ulite_request_port(port)) +@@ -658,17 +660,6 @@ static int ulite_assign(struct device *dev, int id, u32 base, int irq, + + dev_set_drvdata(dev, port); + +-#ifdef CONFIG_SERIAL_UARTLITE_CONSOLE +- /* +- * If console hasn't been found yet try to assign this port +- * because it is required to be assigned for console setup function. +- * If register_console() don't assign value, then console_port pointer +- * is cleanup. +- */ +- if (ulite_uart_driver.cons->index == -1) +- console_port = port; +-#endif +- + /* Register the port */ + rc = uart_add_one_port(&ulite_uart_driver, port); + if (rc) { +@@ -678,12 +669,6 @@ static int ulite_assign(struct device *dev, int id, u32 base, int irq, + return rc; + } + +-#ifdef CONFIG_SERIAL_UARTLITE_CONSOLE +- /* This is not port which is used for console that's why clean it up */ +- if (ulite_uart_driver.cons->index == -1) +- console_port = NULL; +-#endif +- + return 0; + } + +diff --git a/drivers/usb/gadget/function/f_hid.c b/drivers/usb/gadget/function/f_hid.c +index 0586229ac83de..3d540b0d93687 100644 +--- a/drivers/usb/gadget/function/f_hid.c ++++ b/drivers/usb/gadget/function/f_hid.c +@@ -88,7 +88,7 @@ static struct usb_interface_descriptor hidg_interface_desc = { + static struct hid_descriptor hidg_desc = { + .bLength = sizeof hidg_desc, + .bDescriptorType = HID_DT_HID, +- .bcdHID = 0x0101, ++ .bcdHID = cpu_to_le16(0x0101), + .bCountryCode = 0x00, + .bNumDescriptors = 0x1, + /*.desc[0].bDescriptorType = DYNAMIC */ +diff --git a/drivers/usb/gadget/legacy/hid.c b/drivers/usb/gadget/legacy/hid.c +index c4eda7fe7ab45..5b27d289443fe 100644 +--- a/drivers/usb/gadget/legacy/hid.c ++++ b/drivers/usb/gadget/legacy/hid.c +@@ -171,8 +171,10 @@ static int hid_bind(struct usb_composite_dev *cdev) + struct usb_descriptor_header *usb_desc; + + usb_desc = usb_otg_descriptor_alloc(gadget); +- if (!usb_desc) ++ if (!usb_desc) { ++ status = -ENOMEM; + goto put; ++ } + usb_otg_descriptor_init(gadget, usb_desc); + otg_desc[0] = usb_desc; + otg_desc[1] = NULL; +diff --git a/drivers/video/backlight/lm3630a_bl.c b/drivers/video/backlight/lm3630a_bl.c +index f03ffe2bb2376..8096202fbe5d5 100644 +--- a/drivers/video/backlight/lm3630a_bl.c ++++ b/drivers/video/backlight/lm3630a_bl.c +@@ -188,7 +188,7 @@ static int lm3630a_bank_a_update_status(struct backlight_device *bl) + if ((pwm_ctrl & LM3630A_PWM_BANK_A) != 0) { + lm3630a_pwm_ctrl(pchip, bl->props.brightness, + bl->props.max_brightness); +- return bl->props.brightness; ++ return 0; + } + + /* disable sleep */ +@@ -208,8 +208,8 @@ static int lm3630a_bank_a_update_status(struct backlight_device *bl) + return 0; + + out_i2c_err: +- dev_err(pchip->dev, "i2c failed to access\n"); +- return bl->props.brightness; ++ dev_err(pchip->dev, "i2c failed to access (%pe)\n", ERR_PTR(ret)); ++ return ret; + } + + static int lm3630a_bank_a_get_brightness(struct backlight_device *bl) +@@ -265,7 +265,7 @@ static int lm3630a_bank_b_update_status(struct backlight_device *bl) + if ((pwm_ctrl & LM3630A_PWM_BANK_B) != 0) { + lm3630a_pwm_ctrl(pchip, bl->props.brightness, + bl->props.max_brightness); +- return bl->props.brightness; ++ return 0; + } + + /* disable sleep */ +@@ -285,8 +285,8 @@ static int lm3630a_bank_b_update_status(struct backlight_device *bl) + return 0; + + out_i2c_err: +- dev_err(pchip->dev, "i2c failed to access REG_CTRL\n"); +- return bl->props.brightness; ++ dev_err(pchip->dev, "i2c failed to access (%pe)\n", ERR_PTR(ret)); ++ return ret; + } + + static int lm3630a_bank_b_get_brightness(struct backlight_device *bl) +diff --git a/drivers/video/fbdev/core/fbmem.c b/drivers/video/fbdev/core/fbmem.c +index bf76dadbed87f..d87de5d467189 100644 +--- a/drivers/video/fbdev/core/fbmem.c ++++ b/drivers/video/fbdev/core/fbmem.c +@@ -965,13 +965,11 @@ fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var) + fb_var_to_videomode(&mode2, &info->var); + /* make sure we don't delete the videomode of current var */ + ret = fb_mode_is_equal(&mode1, &mode2); +- +- if (!ret) +- fbcon_mode_deleted(info, &mode1); +- +- if (!ret) +- fb_delete_videomode(&mode1, &info->modelist); +- ++ if (!ret) { ++ ret = fbcon_mode_deleted(info, &mode1); ++ if (!ret) ++ fb_delete_videomode(&mode1, &info->modelist); ++ } + + return ret ? -EINVAL : 0; + } +diff --git a/drivers/w1/slaves/w1_ds2438.c b/drivers/w1/slaves/w1_ds2438.c +index d199e5a25cc00..404dacb150046 100644 +--- a/drivers/w1/slaves/w1_ds2438.c ++++ b/drivers/w1/slaves/w1_ds2438.c +@@ -62,13 +62,13 @@ static int w1_ds2438_get_page(struct w1_slave *sl, int pageno, u8 *buf) + if (w1_reset_select_slave(sl)) + continue; + w1_buf[0] = W1_DS2438_RECALL_MEMORY; +- w1_buf[1] = 0x00; ++ w1_buf[1] = (u8)pageno; + w1_write_block(sl->master, w1_buf, 2); + + if (w1_reset_select_slave(sl)) + continue; + w1_buf[0] = W1_DS2438_READ_SCRATCH; +- w1_buf[1] = 0x00; ++ w1_buf[1] = (u8)pageno; + w1_write_block(sl->master, w1_buf, 2); + + count = w1_read_block(sl->master, buf, DS2438_PAGE_SIZE + 1); +diff --git a/drivers/watchdog/aspeed_wdt.c b/drivers/watchdog/aspeed_wdt.c +index 7e00960651fa2..507fd815d7679 100644 +--- a/drivers/watchdog/aspeed_wdt.c ++++ b/drivers/watchdog/aspeed_wdt.c +@@ -147,7 +147,7 @@ static int aspeed_wdt_set_timeout(struct watchdog_device *wdd, + + wdd->timeout = timeout; + +- actual = min(timeout, wdd->max_hw_heartbeat_ms * 1000); ++ actual = min(timeout, wdd->max_hw_heartbeat_ms / 1000); + + writel(actual * WDT_RATE_1MHZ, wdt->base + WDT_RELOAD_VALUE); + writel(WDT_RESTART_MAGIC, wdt->base + WDT_RESTART); +diff --git a/drivers/watchdog/iTCO_wdt.c b/drivers/watchdog/iTCO_wdt.c +index e707c4797f76e..08e534fba1bf0 100644 +--- a/drivers/watchdog/iTCO_wdt.c ++++ b/drivers/watchdog/iTCO_wdt.c +@@ -72,6 +72,8 @@ + #define TCOBASE(p) ((p)->tco_res->start) + /* SMI Control and Enable Register */ + #define SMI_EN(p) ((p)->smi_res->start) ++#define TCO_EN (1 << 13) ++#define GBL_SMI_EN (1 << 0) + + #define TCO_RLD(p) (TCOBASE(p) + 0x00) /* TCO Timer Reload/Curr. Value */ + #define TCOv1_TMR(p) (TCOBASE(p) + 0x01) /* TCOv1 Timer Initial Value*/ +@@ -344,8 +346,12 @@ static int iTCO_wdt_set_timeout(struct watchdog_device *wd_dev, unsigned int t) + + tmrval = seconds_to_ticks(p, t); + +- /* For TCO v1 the timer counts down twice before rebooting */ +- if (p->iTCO_version == 1) ++ /* ++ * If TCO SMIs are off, the timer counts down twice before rebooting. ++ * Otherwise, the BIOS generally reboots when the SMI triggers. ++ */ ++ if (p->smi_res && ++ (SMI_EN(p) & (TCO_EN | GBL_SMI_EN)) != (TCO_EN | GBL_SMI_EN)) + tmrval /= 2; + + /* from the specs: */ +@@ -510,7 +516,7 @@ static int iTCO_wdt_probe(struct platform_device *pdev) + * Disables TCO logic generating an SMI# + */ + val32 = inl(SMI_EN(p)); +- val32 &= 0xffffdfff; /* Turn off SMI clearing watchdog */ ++ val32 &= ~TCO_EN; /* Turn off SMI clearing watchdog */ + outl(val32, SMI_EN(p)); + } + +diff --git a/drivers/watchdog/imx_sc_wdt.c b/drivers/watchdog/imx_sc_wdt.c +index e0e62149a6f48..8c9936e78bee0 100644 +--- a/drivers/watchdog/imx_sc_wdt.c ++++ b/drivers/watchdog/imx_sc_wdt.c +@@ -185,16 +185,12 @@ static int imx_sc_wdt_probe(struct platform_device *pdev) + watchdog_stop_on_reboot(wdog); + watchdog_stop_on_unregister(wdog); + +- ret = devm_watchdog_register_device(dev, wdog); +- if (ret) +- return ret; +- + ret = imx_scu_irq_group_enable(SC_IRQ_GROUP_WDOG, + SC_IRQ_WDOG, + true); + if (ret) { + dev_warn(dev, "Enable irq failed, pretimeout NOT supported\n"); +- return 0; ++ goto register_device; + } + + imx_sc_wdd->wdt_notifier.notifier_call = imx_sc_wdt_notify; +@@ -205,7 +201,7 @@ static int imx_sc_wdt_probe(struct platform_device *pdev) + false); + dev_warn(dev, + "Register irq notifier failed, pretimeout NOT supported\n"); +- return 0; ++ goto register_device; + } + + ret = devm_add_action_or_reset(dev, imx_sc_wdt_action, +@@ -215,7 +211,8 @@ static int imx_sc_wdt_probe(struct platform_device *pdev) + else + dev_warn(dev, "Add action failed, pretimeout NOT supported\n"); + +- return 0; ++register_device: ++ return devm_watchdog_register_device(dev, wdog); + } + + static int __maybe_unused imx_sc_wdt_suspend(struct device *dev) +diff --git a/drivers/watchdog/lpc18xx_wdt.c b/drivers/watchdog/lpc18xx_wdt.c +index 78cf11c949416..60b6d74f267dd 100644 +--- a/drivers/watchdog/lpc18xx_wdt.c ++++ b/drivers/watchdog/lpc18xx_wdt.c +@@ -292,7 +292,7 @@ static int lpc18xx_wdt_remove(struct platform_device *pdev) + struct lpc18xx_wdt_dev *lpc18xx_wdt = platform_get_drvdata(pdev); + + dev_warn(&pdev->dev, "I quit now, hardware will probably reboot!\n"); +- del_timer(&lpc18xx_wdt->timer); ++ del_timer_sync(&lpc18xx_wdt->timer); + + return 0; + } +diff --git a/drivers/watchdog/sbc60xxwdt.c b/drivers/watchdog/sbc60xxwdt.c +index c3151642694c9..de1f7add05c3d 100644 +--- a/drivers/watchdog/sbc60xxwdt.c ++++ b/drivers/watchdog/sbc60xxwdt.c +@@ -146,7 +146,7 @@ static void wdt_startup(void) + static void wdt_turnoff(void) + { + /* Stop the timer */ +- del_timer(&timer); ++ del_timer_sync(&timer); + inb_p(wdt_stop); + pr_info("Watchdog timer is now disabled...\n"); + } +diff --git a/drivers/watchdog/sc520_wdt.c b/drivers/watchdog/sc520_wdt.c +index a612128c5f808..57969564c7f9d 100644 +--- a/drivers/watchdog/sc520_wdt.c ++++ b/drivers/watchdog/sc520_wdt.c +@@ -186,7 +186,7 @@ static int wdt_startup(void) + static int wdt_turnoff(void) + { + /* Stop the timer */ +- del_timer(&timer); ++ del_timer_sync(&timer); + + /* Stop the watchdog */ + wdt_config(0); +diff --git a/drivers/watchdog/w83877f_wdt.c b/drivers/watchdog/w83877f_wdt.c +index 6eb5185d6ea68..d9addf06b44d6 100644 +--- a/drivers/watchdog/w83877f_wdt.c ++++ b/drivers/watchdog/w83877f_wdt.c +@@ -166,7 +166,7 @@ static void wdt_startup(void) + static void wdt_turnoff(void) + { + /* Stop the timer */ +- del_timer(&timer); ++ del_timer_sync(&timer); + + wdt_change(WDT_DISABLE); + +diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c +index a02e845eb0fbf..34ab7b892b700 100644 +--- a/fs/ceph/addr.c ++++ b/fs/ceph/addr.c +@@ -76,10 +76,6 @@ static int ceph_set_page_dirty(struct page *page) + struct inode *inode; + struct ceph_inode_info *ci; + struct ceph_snap_context *snapc; +- int ret; +- +- if (unlikely(!mapping)) +- return !TestSetPageDirty(page); + + if (PageDirty(page)) { + dout("%p set_page_dirty %p idx %lu -- already dirty\n", +@@ -125,11 +121,7 @@ static int ceph_set_page_dirty(struct page *page) + page->private = (unsigned long)snapc; + SetPagePrivate(page); + +- ret = __set_page_dirty_nobuffers(page); +- WARN_ON(!PageLocked(page)); +- WARN_ON(!page->mapping); +- +- return ret; ++ return __set_page_dirty_nobuffers(page); + } + + /* +diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c +index a9a083232bcfc..6d904dc9bd199 100644 +--- a/fs/f2fs/super.c ++++ b/fs/f2fs/super.c +@@ -3804,4 +3804,5 @@ module_exit(exit_f2fs_fs) + MODULE_AUTHOR("Samsung Electronics's Praesto Team"); + MODULE_DESCRIPTION("Flash Friendly File System"); + MODULE_LICENSE("GPL"); ++MODULE_SOFTDEP("pre: crc32"); + +diff --git a/fs/jfs/jfs_logmgr.c b/fs/jfs/jfs_logmgr.c +index 9330eff210e0c..78fd136ac13b9 100644 +--- a/fs/jfs/jfs_logmgr.c ++++ b/fs/jfs/jfs_logmgr.c +@@ -1324,6 +1324,7 @@ int lmLogInit(struct jfs_log * log) + } else { + if (!uuid_equal(&logsuper->uuid, &log->uuid)) { + jfs_warn("wrong uuid on JFS log device"); ++ rc = -EINVAL; + goto errout20; + } + log->size = le32_to_cpu(logsuper->size); +diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c +index 8c0f916380c4e..209263c0c5377 100644 +--- a/fs/nfs/inode.c ++++ b/fs/nfs/inode.c +@@ -1048,6 +1048,7 @@ EXPORT_SYMBOL_GPL(nfs_inode_attach_open_context); + void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx) + { + filp->private_data = get_nfs_open_context(ctx); ++ set_bit(NFS_CONTEXT_FILE_OPEN, &ctx->flags); + if (list_empty(&ctx->list)) + nfs_inode_attach_open_context(ctx); + } +@@ -1067,6 +1068,8 @@ struct nfs_open_context *nfs_find_open_context(struct inode *inode, const struct + continue; + if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode) + continue; ++ if (!test_bit(NFS_CONTEXT_FILE_OPEN, &pos->flags)) ++ continue; + ctx = get_nfs_open_context(pos); + if (ctx) + break; +@@ -1082,6 +1085,7 @@ void nfs_file_clear_open_context(struct file *filp) + if (ctx) { + struct inode *inode = d_inode(ctx->dentry); + ++ clear_bit(NFS_CONTEXT_FILE_OPEN, &ctx->flags); + /* + * We fatal error on write before. Try to writeback + * every page again. +diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c +index 9eb2f1a503ab0..01a03ca36659e 100644 +--- a/fs/nfs/nfs3proc.c ++++ b/fs/nfs/nfs3proc.c +@@ -350,7 +350,7 @@ nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, + break; + + case NFS3_CREATE_UNCHECKED: +- goto out; ++ goto out_release_acls; + } + nfs_fattr_init(data->res.dir_attr); + nfs_fattr_init(data->res.fattr); +@@ -717,7 +717,7 @@ nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr, + break; + default: + status = -EINVAL; +- goto out; ++ goto out_release_acls; + } + + d_alias = nfs3_do_create(dir, dentry, data); +diff --git a/fs/nfs/nfs4client.c b/fs/nfs/nfs4client.c +index 5a69dbd01a6cf..8cace8350fa3d 100644 +--- a/fs/nfs/nfs4client.c ++++ b/fs/nfs/nfs4client.c +@@ -197,8 +197,11 @@ void nfs40_shutdown_client(struct nfs_client *clp) + + struct nfs_client *nfs4_alloc_client(const struct nfs_client_initdata *cl_init) + { +- int err; ++ char buf[INET6_ADDRSTRLEN + 1]; ++ const char *ip_addr = cl_init->ip_addr; + struct nfs_client *clp = nfs_alloc_client(cl_init); ++ int err; ++ + if (IS_ERR(clp)) + return clp; + +@@ -222,6 +225,44 @@ struct nfs_client *nfs4_alloc_client(const struct nfs_client_initdata *cl_init) + init_waitqueue_head(&clp->cl_lock_waitq); + #endif + INIT_LIST_HEAD(&clp->pending_cb_stateids); ++ ++ if (cl_init->minorversion != 0) ++ __set_bit(NFS_CS_INFINITE_SLOTS, &clp->cl_flags); ++ __set_bit(NFS_CS_DISCRTRY, &clp->cl_flags); ++ __set_bit(NFS_CS_NO_RETRANS_TIMEOUT, &clp->cl_flags); ++ ++ /* ++ * Set up the connection to the server before we add add to the ++ * global list. ++ */ ++ err = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_GSS_KRB5I); ++ if (err == -EINVAL) ++ err = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_UNIX); ++ if (err < 0) ++ goto error; ++ ++ /* If no clientaddr= option was specified, find a usable cb address */ ++ if (ip_addr == NULL) { ++ struct sockaddr_storage cb_addr; ++ struct sockaddr *sap = (struct sockaddr *)&cb_addr; ++ ++ err = rpc_localaddr(clp->cl_rpcclient, sap, sizeof(cb_addr)); ++ if (err < 0) ++ goto error; ++ err = rpc_ntop(sap, buf, sizeof(buf)); ++ if (err < 0) ++ goto error; ++ ip_addr = (const char *)buf; ++ } ++ strlcpy(clp->cl_ipaddr, ip_addr, sizeof(clp->cl_ipaddr)); ++ ++ err = nfs_idmap_new(clp); ++ if (err < 0) { ++ dprintk("%s: failed to create idmapper. Error = %d\n", ++ __func__, err); ++ goto error; ++ } ++ __set_bit(NFS_CS_IDMAP, &clp->cl_res_state); + return clp; + + error: +@@ -372,8 +413,6 @@ static int nfs4_init_client_minor_version(struct nfs_client *clp) + struct nfs_client *nfs4_init_client(struct nfs_client *clp, + const struct nfs_client_initdata *cl_init) + { +- char buf[INET6_ADDRSTRLEN + 1]; +- const char *ip_addr = cl_init->ip_addr; + struct nfs_client *old; + int error; + +@@ -381,43 +420,6 @@ struct nfs_client *nfs4_init_client(struct nfs_client *clp, + /* the client is initialised already */ + return clp; + +- /* Check NFS protocol revision and initialize RPC op vector */ +- clp->rpc_ops = &nfs_v4_clientops; +- +- if (clp->cl_minorversion != 0) +- __set_bit(NFS_CS_INFINITE_SLOTS, &clp->cl_flags); +- __set_bit(NFS_CS_DISCRTRY, &clp->cl_flags); +- __set_bit(NFS_CS_NO_RETRANS_TIMEOUT, &clp->cl_flags); +- +- error = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_GSS_KRB5I); +- if (error == -EINVAL) +- error = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_UNIX); +- if (error < 0) +- goto error; +- +- /* If no clientaddr= option was specified, find a usable cb address */ +- if (ip_addr == NULL) { +- struct sockaddr_storage cb_addr; +- struct sockaddr *sap = (struct sockaddr *)&cb_addr; +- +- error = rpc_localaddr(clp->cl_rpcclient, sap, sizeof(cb_addr)); +- if (error < 0) +- goto error; +- error = rpc_ntop(sap, buf, sizeof(buf)); +- if (error < 0) +- goto error; +- ip_addr = (const char *)buf; +- } +- strlcpy(clp->cl_ipaddr, ip_addr, sizeof(clp->cl_ipaddr)); +- +- error = nfs_idmap_new(clp); +- if (error < 0) { +- dprintk("%s: failed to create idmapper. Error = %d\n", +- __func__, error); +- goto error; +- } +- __set_bit(NFS_CS_IDMAP, &clp->cl_res_state); +- + error = nfs4_init_client_minor_version(clp); + if (error < 0) + goto error; +diff --git a/fs/nfs/pnfs_nfs.c b/fs/nfs/pnfs_nfs.c +index 8b37e7f8e789f..249cf9037dbd7 100644 +--- a/fs/nfs/pnfs_nfs.c ++++ b/fs/nfs/pnfs_nfs.c +@@ -556,19 +556,16 @@ out: + } + EXPORT_SYMBOL_GPL(nfs4_pnfs_ds_add); + +-static void nfs4_wait_ds_connect(struct nfs4_pnfs_ds *ds) ++static int nfs4_wait_ds_connect(struct nfs4_pnfs_ds *ds) + { + might_sleep(); +- wait_on_bit(&ds->ds_state, NFS4DS_CONNECTING, +- TASK_KILLABLE); ++ return wait_on_bit(&ds->ds_state, NFS4DS_CONNECTING, TASK_KILLABLE); + } + + static void nfs4_clear_ds_conn_bit(struct nfs4_pnfs_ds *ds) + { + smp_mb__before_atomic(); +- clear_bit(NFS4DS_CONNECTING, &ds->ds_state); +- smp_mb__after_atomic(); +- wake_up_bit(&ds->ds_state, NFS4DS_CONNECTING); ++ clear_and_wake_up_bit(NFS4DS_CONNECTING, &ds->ds_state); + } + + static struct nfs_client *(*get_v3_ds_connect)( +@@ -734,30 +731,33 @@ int nfs4_pnfs_ds_connect(struct nfs_server *mds_srv, struct nfs4_pnfs_ds *ds, + { + int err; + +-again: +- err = 0; +- if (test_and_set_bit(NFS4DS_CONNECTING, &ds->ds_state) == 0) { +- if (version == 3) { +- err = _nfs4_pnfs_v3_ds_connect(mds_srv, ds, timeo, +- retrans); +- } else if (version == 4) { +- err = _nfs4_pnfs_v4_ds_connect(mds_srv, ds, timeo, +- retrans, minor_version); +- } else { +- dprintk("%s: unsupported DS version %d\n", __func__, +- version); +- err = -EPROTONOSUPPORT; +- } ++ do { ++ err = nfs4_wait_ds_connect(ds); ++ if (err || ds->ds_clp) ++ goto out; ++ if (nfs4_test_deviceid_unavailable(devid)) ++ return -ENODEV; ++ } while (test_and_set_bit(NFS4DS_CONNECTING, &ds->ds_state) != 0); + +- nfs4_clear_ds_conn_bit(ds); +- } else { +- nfs4_wait_ds_connect(ds); ++ if (ds->ds_clp) ++ goto connect_done; + +- /* what was waited on didn't connect AND didn't mark unavail */ +- if (!ds->ds_clp && !nfs4_test_deviceid_unavailable(devid)) +- goto again; ++ switch (version) { ++ case 3: ++ err = _nfs4_pnfs_v3_ds_connect(mds_srv, ds, timeo, retrans); ++ break; ++ case 4: ++ err = _nfs4_pnfs_v4_ds_connect(mds_srv, ds, timeo, retrans, ++ minor_version); ++ break; ++ default: ++ dprintk("%s: unsupported DS version %d\n", __func__, version); ++ err = -EPROTONOSUPPORT; + } + ++connect_done: ++ nfs4_clear_ds_conn_bit(ds); ++out: + /* + * At this point the ds->ds_clp should be ready, but it might have + * hit an error. +diff --git a/fs/orangefs/super.c b/fs/orangefs/super.c +index ee5efdc35cc1e..2f2e430461b21 100644 +--- a/fs/orangefs/super.c ++++ b/fs/orangefs/super.c +@@ -209,7 +209,7 @@ static int orangefs_statfs(struct dentry *dentry, struct kstatfs *buf) + buf->f_bavail = (sector_t) new_op->downcall.resp.statfs.blocks_avail; + buf->f_files = (sector_t) new_op->downcall.resp.statfs.files_total; + buf->f_ffree = (sector_t) new_op->downcall.resp.statfs.files_avail; +- buf->f_frsize = sb->s_blocksize; ++ buf->f_frsize = 0; + + out_op_release: + op_release(new_op); +diff --git a/fs/seq_file.c b/fs/seq_file.c +index 1600034a929bb..c19ecc1f2d502 100644 +--- a/fs/seq_file.c ++++ b/fs/seq_file.c +@@ -29,6 +29,9 @@ static void seq_set_overflow(struct seq_file *m) + + static void *seq_buf_alloc(unsigned long size) + { ++ if (unlikely(size > MAX_RW_COUNT)) ++ return NULL; ++ + return kvmalloc(size, GFP_KERNEL_ACCOUNT); + } + +diff --git a/fs/ubifs/dir.c b/fs/ubifs/dir.c +index a5e5e9b9d4e31..eeb93f009b282 100644 +--- a/fs/ubifs/dir.c ++++ b/fs/ubifs/dir.c +@@ -1343,7 +1343,10 @@ static int do_rename(struct inode *old_dir, struct dentry *old_dentry, + goto out_release; + } + ++ spin_lock(&whiteout->i_lock); + whiteout->i_state |= I_LINKABLE; ++ spin_unlock(&whiteout->i_lock); ++ + whiteout_ui = ubifs_inode(whiteout); + whiteout_ui->data = dev; + whiteout_ui->data_len = ubifs_encode_dev(dev, MKDEV(0, 0)); +@@ -1436,7 +1439,11 @@ static int do_rename(struct inode *old_dir, struct dentry *old_dentry, + + inc_nlink(whiteout); + mark_inode_dirty(whiteout); ++ ++ spin_lock(&whiteout->i_lock); + whiteout->i_state &= ~I_LINKABLE; ++ spin_unlock(&whiteout->i_lock); ++ + iput(whiteout); + } + +diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h +index ad09c0cc54645..978ef674f0388 100644 +--- a/include/linux/nfs_fs.h ++++ b/include/linux/nfs_fs.h +@@ -79,6 +79,7 @@ struct nfs_open_context { + #define NFS_CONTEXT_RESEND_WRITES (1) + #define NFS_CONTEXT_BAD (2) + #define NFS_CONTEXT_UNLOCK (3) ++#define NFS_CONTEXT_FILE_OPEN (4) + int error; + + struct list_head list; +diff --git a/include/linux/sched/signal.h b/include/linux/sched/signal.h +index baf58f4cb0578..b3f88470cbb58 100644 +--- a/include/linux/sched/signal.h ++++ b/include/linux/sched/signal.h +@@ -509,6 +509,17 @@ static inline int kill_cad_pid(int sig, int priv) + #define SEND_SIG_NOINFO ((struct kernel_siginfo *) 0) + #define SEND_SIG_PRIV ((struct kernel_siginfo *) 1) + ++static inline int __on_sig_stack(unsigned long sp) ++{ ++#ifdef CONFIG_STACK_GROWSUP ++ return sp >= current->sas_ss_sp && ++ sp - current->sas_ss_sp < current->sas_ss_size; ++#else ++ return sp > current->sas_ss_sp && ++ sp - current->sas_ss_sp <= current->sas_ss_size; ++#endif ++} ++ + /* + * True if we are on the alternate signal stack. + */ +@@ -526,13 +537,7 @@ static inline int on_sig_stack(unsigned long sp) + if (current->sas_ss_flags & SS_AUTODISARM) + return 0; + +-#ifdef CONFIG_STACK_GROWSUP +- return sp >= current->sas_ss_sp && +- sp - current->sas_ss_sp < current->sas_ss_size; +-#else +- return sp > current->sas_ss_sp && +- sp - current->sas_ss_sp <= current->sas_ss_size; +-#endif ++ return __on_sig_stack(sp); + } + + static inline int sas_ss_flags(unsigned long sp) +diff --git a/include/scsi/libiscsi.h b/include/scsi/libiscsi.h +index b3bbd10eb3f07..2b5f97224f693 100644 +--- a/include/scsi/libiscsi.h ++++ b/include/scsi/libiscsi.h +@@ -195,12 +195,6 @@ struct iscsi_conn { + unsigned long suspend_tx; /* suspend Tx */ + unsigned long suspend_rx; /* suspend Rx */ + +- /* abort */ +- wait_queue_head_t ehwait; /* used in eh_abort() */ +- struct iscsi_tm tmhdr; +- struct timer_list tmf_timer; +- int tmf_state; /* see TMF_INITIAL, etc.*/ +- + /* negotiated params */ + unsigned max_recv_dlength; /* initiator_max_recv_dsl*/ + unsigned max_xmit_dlength; /* target_max_recv_dsl */ +@@ -270,6 +264,11 @@ struct iscsi_session { + * and recv lock. + */ + struct mutex eh_mutex; ++ /* abort */ ++ wait_queue_head_t ehwait; /* used in eh_abort() */ ++ struct iscsi_tm tmhdr; ++ struct timer_list tmf_timer; ++ int tmf_state; /* see TMF_INITIAL, etc.*/ + + /* iSCSI session-wide sequencing */ + uint32_t cmdsn; +diff --git a/include/scsi/scsi_transport_iscsi.h b/include/scsi/scsi_transport_iscsi.h +index 325ae731d9ad8..71c78410e6ab3 100644 +--- a/include/scsi/scsi_transport_iscsi.h ++++ b/include/scsi/scsi_transport_iscsi.h +@@ -423,6 +423,8 @@ extern void iscsi_remove_session(struct iscsi_cls_session *session); + extern void iscsi_free_session(struct iscsi_cls_session *session); + extern struct iscsi_cls_conn *iscsi_create_conn(struct iscsi_cls_session *sess, + int dd_size, uint32_t cid); ++extern void iscsi_put_conn(struct iscsi_cls_conn *conn); ++extern void iscsi_get_conn(struct iscsi_cls_conn *conn); + extern int iscsi_destroy_conn(struct iscsi_cls_conn *conn); + extern void iscsi_unblock_session(struct iscsi_cls_session *session); + extern void iscsi_block_session(struct iscsi_cls_session *session); +diff --git a/kernel/cgroup/cgroup-v1.c b/kernel/cgroup/cgroup-v1.c +index ae31b158baf73..9329f725d22b6 100644 +--- a/kernel/cgroup/cgroup-v1.c ++++ b/kernel/cgroup/cgroup-v1.c +@@ -918,6 +918,8 @@ int cgroup1_parse_param(struct fs_context *fc, struct fs_parameter *param) + opt = fs_parse(fc, &cgroup1_fs_parameters, param, &result); + if (opt == -ENOPARAM) { + if (strcmp(param->key, "source") == 0) { ++ if (param->type != fs_value_is_string) ++ return invalf(fc, "Non-string source"); + if (fc->source) + return invalf(fc, "Multiple sources not supported"); + fc->source = param->string; +diff --git a/kernel/rcu/rcu.h b/kernel/rcu/rcu.h +index 8fd4f82c9b3d7..7fd1c18b7cf15 100644 +--- a/kernel/rcu/rcu.h ++++ b/kernel/rcu/rcu.h +@@ -316,6 +316,8 @@ static inline void rcu_init_levelspread(int *levelspread, const int *levelcnt) + } + } + ++extern void rcu_init_geometry(void); ++ + /* Returns a pointer to the first leaf rcu_node structure. */ + #define rcu_first_leaf_node() (rcu_state.level[rcu_num_lvls - 1]) + +diff --git a/kernel/rcu/srcutree.c b/kernel/rcu/srcutree.c +index 21acdff3bd278..21115ffb6c446 100644 +--- a/kernel/rcu/srcutree.c ++++ b/kernel/rcu/srcutree.c +@@ -90,6 +90,9 @@ static void init_srcu_struct_nodes(struct srcu_struct *ssp, bool is_static) + struct srcu_node *snp; + struct srcu_node *snp_first; + ++ /* Initialize geometry if it has not already been initialized. */ ++ rcu_init_geometry(); ++ + /* Work out the overall tree geometry. */ + ssp->level[0] = &ssp->node[0]; + for (i = 1; i < rcu_num_lvls; i++) +diff --git a/kernel/rcu/tree.c b/kernel/rcu/tree.c +index fd37827eca5b0..11ae2747701b5 100644 +--- a/kernel/rcu/tree.c ++++ b/kernel/rcu/tree.c +@@ -3425,11 +3425,25 @@ static void __init rcu_init_one(void) + * replace the definitions in tree.h because those are needed to size + * the ->node array in the rcu_state structure. + */ +-static void __init rcu_init_geometry(void) ++void rcu_init_geometry(void) + { + ulong d; + int i; ++ static unsigned long old_nr_cpu_ids; + int rcu_capacity[RCU_NUM_LVLS]; ++ static bool initialized; ++ ++ if (initialized) { ++ /* ++ * Warn if setup_nr_cpu_ids() had not yet been invoked, ++ * unless nr_cpus_ids == NR_CPUS, in which case who cares? ++ */ ++ WARN_ON_ONCE(old_nr_cpu_ids != nr_cpu_ids); ++ return; ++ } ++ ++ old_nr_cpu_ids = nr_cpu_ids; ++ initialized = true; + + /* + * Initialize any unspecified boot parameters. +diff --git a/kernel/trace/trace_events_hist.c b/kernel/trace/trace_events_hist.c +index b05376a01091d..f136449821bfe 100644 +--- a/kernel/trace/trace_events_hist.c ++++ b/kernel/trace/trace_events_hist.c +@@ -2571,7 +2571,9 @@ static struct hist_field *create_hist_field(struct hist_trigger_data *hist_data, + if (WARN_ON_ONCE(!field)) + goto out; + +- if (is_string_field(field)) { ++ /* Pointers to strings are just pointers and dangerous to dereference */ ++ if (is_string_field(field) && ++ (field->filter_type != FILTER_PTR_STRING)) { + flags |= HIST_FIELD_FL_STRING; + + hist_field->size = MAX_FILTER_STR_VAL; +@@ -5326,8 +5328,6 @@ static inline void add_to_key(char *compound_key, void *key, + field = key_field->field; + if (field->filter_type == FILTER_DYN_STRING) + size = *(u32 *)(rec + field->offset) >> 16; +- else if (field->filter_type == FILTER_PTR_STRING) +- size = strlen(key); + else if (field->filter_type == FILTER_STATIC_STRING) + size = field->size; + +diff --git a/lib/decompress_unlz4.c b/lib/decompress_unlz4.c +index c0cfcfd486be0..e6327391b6b66 100644 +--- a/lib/decompress_unlz4.c ++++ b/lib/decompress_unlz4.c +@@ -112,6 +112,9 @@ STATIC inline int INIT unlz4(u8 *input, long in_len, + error("data corrupted"); + goto exit_2; + } ++ } else if (size < 4) { ++ /* empty or end-of-file */ ++ goto exit_3; + } + + chunksize = get_unaligned_le32(inp); +@@ -125,6 +128,10 @@ STATIC inline int INIT unlz4(u8 *input, long in_len, + continue; + } + ++ if (!fill && chunksize == 0) { ++ /* empty or end-of-file */ ++ goto exit_3; ++ } + + if (posp) + *posp += 4; +@@ -184,6 +191,7 @@ STATIC inline int INIT unlz4(u8 *input, long in_len, + } + } + ++exit_3: + ret = 0; + exit_2: + if (!input) +diff --git a/sound/ac97/bus.c b/sound/ac97/bus.c +index 7985dd8198b6c..99e1728b52ae4 100644 +--- a/sound/ac97/bus.c ++++ b/sound/ac97/bus.c +@@ -520,7 +520,7 @@ static int ac97_bus_remove(struct device *dev) + struct ac97_codec_driver *adrv = to_ac97_driver(dev->driver); + int ret; + +- ret = pm_runtime_get_sync(dev); ++ ret = pm_runtime_resume_and_get(dev); + if (ret < 0) + return ret; + +diff --git a/sound/firewire/Kconfig b/sound/firewire/Kconfig +index e6b4ca469b2aa..e469375e2f2af 100644 +--- a/sound/firewire/Kconfig ++++ b/sound/firewire/Kconfig +@@ -38,7 +38,7 @@ config SND_OXFW + * Mackie(Loud) Onyx 1640i (former model) + * Mackie(Loud) Onyx Satellite + * Mackie(Loud) Tapco Link.Firewire +- * Mackie(Loud) d.4 pro ++ * Mackie(Loud) d.2 pro/d.4 pro (built-in FireWire card with OXFW971 ASIC) + * Mackie(Loud) U.420/U.420d + * TASCAM FireOne + * Stanton Controllers & Systems 1 Deck/Mixer +@@ -84,7 +84,7 @@ config SND_BEBOB + * PreSonus FIREBOX/FIREPOD/FP10/Inspire1394 + * BridgeCo RDAudio1/Audio5 + * Mackie Onyx 1220/1620/1640 (FireWire I/O Card) +- * Mackie d.2 (FireWire Option) and d.2 Pro ++ * Mackie d.2 (optional FireWire card with DM1000 ASIC) + * Stanton FinalScratch 2 (ScratchAmp) + * Tascam IF-FW/DM + * Behringer XENIX UFX 1204/1604 +@@ -110,6 +110,7 @@ config SND_BEBOB + * M-Audio Ozonic/NRV10/ProfireLightBridge + * M-Audio FireWire 1814/ProjectMix IO + * Digidesign Mbox 2 Pro ++ * ToneWeal FW66 + + To compile this driver as a module, choose M here: the module + will be called snd-bebob. +diff --git a/sound/firewire/bebob/bebob.c b/sound/firewire/bebob/bebob.c +index 441c58283b47e..d58f4fe2be8c1 100644 +--- a/sound/firewire/bebob/bebob.c ++++ b/sound/firewire/bebob/bebob.c +@@ -59,6 +59,7 @@ static DECLARE_BITMAP(devices_used, SNDRV_CARDS); + #define VEN_MAUDIO1 0x00000d6c + #define VEN_MAUDIO2 0x000007f5 + #define VEN_DIGIDESIGN 0x00a07e ++#define OUI_SHOUYO 0x002327 + + #define MODEL_FOCUSRITE_SAFFIRE_BOTH 0x00000000 + #define MODEL_MAUDIO_AUDIOPHILE_BOTH 0x00010060 +@@ -387,7 +388,7 @@ static const struct ieee1394_device_id bebob_id_table[] = { + SND_BEBOB_DEV_ENTRY(VEN_BRIDGECO, 0x00010049, &spec_normal), + /* Mackie, Onyx 1220/1620/1640 (Firewire I/O Card) */ + SND_BEBOB_DEV_ENTRY(VEN_MACKIE2, 0x00010065, &spec_normal), +- // Mackie, d.2 (Firewire option card) and d.2 Pro (the card is built-in). ++ // Mackie, d.2 (optional Firewire card with DM1000). + SND_BEBOB_DEV_ENTRY(VEN_MACKIE1, 0x00010067, &spec_normal), + /* Stanton, ScratchAmp */ + SND_BEBOB_DEV_ENTRY(VEN_STANTON, 0x00000001, &spec_normal), +@@ -486,6 +487,8 @@ static const struct ieee1394_device_id bebob_id_table[] = { + &maudio_special_spec), + /* Digidesign Mbox 2 Pro */ + SND_BEBOB_DEV_ENTRY(VEN_DIGIDESIGN, 0x0000a9, &spec_normal), ++ // Toneweal FW66. ++ SND_BEBOB_DEV_ENTRY(OUI_SHOUYO, 0x020002, &spec_normal), + /* IDs are unknown but able to be supported */ + /* Apogee, Mini-ME Firewire */ + /* Apogee, Mini-DAC Firewire */ +diff --git a/sound/firewire/oxfw/oxfw.c b/sound/firewire/oxfw/oxfw.c +index 6184a7c8f2b34..bebb2b8296cb2 100644 +--- a/sound/firewire/oxfw/oxfw.c ++++ b/sound/firewire/oxfw/oxfw.c +@@ -350,7 +350,7 @@ static const struct ieee1394_device_id oxfw_id_table[] = { + * Onyx-i series (former models): 0x081216 + * Mackie Onyx Satellite: 0x00200f + * Tapco LINK.firewire 4x6: 0x000460 +- * d.4 pro: Unknown ++ * d.2 pro/d.4 pro (built-in card): Unknown + * U.420: Unknown + * U.420d: Unknown + */ +diff --git a/sound/isa/cmi8330.c b/sound/isa/cmi8330.c +index bb7d4940ac25f..281ecd0eea48d 100644 +--- a/sound/isa/cmi8330.c ++++ b/sound/isa/cmi8330.c +@@ -549,7 +549,7 @@ static int snd_cmi8330_probe(struct snd_card *card, int dev) + } + if (acard->sb->hardware != SB_HW_16) { + snd_printk(KERN_ERR PFX "SB16 not found during probe\n"); +- return err; ++ return -ENODEV; + } + + snd_wss_out(acard->wss, CS4231_MISC_INFO, 0x40); /* switch on MODE2 */ +diff --git a/sound/isa/sb/sb16_csp.c b/sound/isa/sb/sb16_csp.c +index 69960cf1bb51d..ef1289cc78a48 100644 +--- a/sound/isa/sb/sb16_csp.c ++++ b/sound/isa/sb/sb16_csp.c +@@ -1072,10 +1072,14 @@ static void snd_sb_qsound_destroy(struct snd_sb_csp * p) + card = p->chip->card; + + down_write(&card->controls_rwsem); +- if (p->qsound_switch) ++ if (p->qsound_switch) { + snd_ctl_remove(card, p->qsound_switch); +- if (p->qsound_space) ++ p->qsound_switch = NULL; ++ } ++ if (p->qsound_space) { + snd_ctl_remove(card, p->qsound_space); ++ p->qsound_space = NULL; ++ } + up_write(&card->controls_rwsem); + + /* cancel pending transfer of QSound parameters */ +diff --git a/sound/pci/hda/hda_tegra.c b/sound/pci/hda/hda_tegra.c +index e378cb33c69df..2971b34c87c1a 100644 +--- a/sound/pci/hda/hda_tegra.c ++++ b/sound/pci/hda/hda_tegra.c +@@ -292,6 +292,9 @@ static int hda_tegra_first_init(struct azx *chip, struct platform_device *pdev) + const char *sname, *drv_name = "tegra-hda"; + struct device_node *np = pdev->dev.of_node; + ++ if (irq_id < 0) ++ return irq_id; ++ + err = hda_tegra_init_chip(chip, pdev); + if (err) + return err; +diff --git a/sound/ppc/powermac.c b/sound/ppc/powermac.c +index 96ef55082bf9a..b135d114ce893 100644 +--- a/sound/ppc/powermac.c ++++ b/sound/ppc/powermac.c +@@ -77,7 +77,11 @@ static int snd_pmac_probe(struct platform_device *devptr) + sprintf(card->shortname, "PowerMac %s", name_ext); + sprintf(card->longname, "%s (Dev %d) Sub-frame %d", + card->shortname, chip->device_id, chip->subframe); +- if ( snd_pmac_tumbler_init(chip) < 0 || snd_pmac_tumbler_post_init() < 0) ++ err = snd_pmac_tumbler_init(chip); ++ if (err < 0) ++ goto __error; ++ err = snd_pmac_tumbler_post_init(); ++ if (err < 0) + goto __error; + break; + case PMAC_AWACS: +diff --git a/sound/soc/img/img-i2s-in.c b/sound/soc/img/img-i2s-in.c +index bb668551dd4b2..243f916355eeb 100644 +--- a/sound/soc/img/img-i2s-in.c ++++ b/sound/soc/img/img-i2s-in.c +@@ -464,7 +464,7 @@ static int img_i2s_in_probe(struct platform_device *pdev) + if (ret) + goto err_pm_disable; + } +- ret = pm_runtime_get_sync(&pdev->dev); ++ ret = pm_runtime_resume_and_get(&pdev->dev); + if (ret < 0) + goto err_suspend; + +diff --git a/sound/soc/intel/boards/kbl_da7219_max98357a.c b/sound/soc/intel/boards/kbl_da7219_max98357a.c +index 537a88932bb69..69362eae65be5 100644 +--- a/sound/soc/intel/boards/kbl_da7219_max98357a.c ++++ b/sound/soc/intel/boards/kbl_da7219_max98357a.c +@@ -607,7 +607,7 @@ static int kabylake_audio_probe(struct platform_device *pdev) + + static const struct platform_device_id kbl_board_ids[] = { + { +- .name = "kbl_da7219_max98357a", ++ .name = "kbl_da7219_mx98357a", + .driver_data = + (kernel_ulong_t)&kabylake_audio_card_da7219_m98357a, + }, +@@ -629,4 +629,4 @@ module_platform_driver(kabylake_audio) + MODULE_DESCRIPTION("Audio Machine driver-DA7219 & MAX98357A in I2S mode"); + MODULE_AUTHOR("Naveen Manohar "); + MODULE_LICENSE("GPL v2"); +-MODULE_ALIAS("platform:kbl_da7219_max98357a"); ++MODULE_ALIAS("platform:kbl_da7219_mx98357a"); +diff --git a/sound/soc/intel/common/soc-acpi-intel-kbl-match.c b/sound/soc/intel/common/soc-acpi-intel-kbl-match.c +index e200baa110118..df7f82e55a5a7 100644 +--- a/sound/soc/intel/common/soc-acpi-intel-kbl-match.c ++++ b/sound/soc/intel/common/soc-acpi-intel-kbl-match.c +@@ -113,7 +113,7 @@ struct snd_soc_acpi_mach snd_soc_acpi_intel_kbl_machines[] = { + }, + { + .id = "DLGS7219", +- .drv_name = "kbl_da7219_max98373", ++ .drv_name = "kbl_da7219_mx98373", + .fw_filename = "intel/dsp_fw_kbl.bin", + .machine_quirk = snd_soc_acpi_codec_list, + .quirk_data = &kbl_7219_98373_codecs, +diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c +index 9df20768a8f29..c0e03cc8ea822 100644 +--- a/sound/soc/soc-core.c ++++ b/sound/soc/soc-core.c +@@ -3178,7 +3178,7 @@ int snd_soc_of_parse_audio_routing(struct snd_soc_card *card, + if (!routes) { + dev_err(card->dev, + "ASoC: Could not allocate DAPM route table\n"); +- return -EINVAL; ++ return -ENOMEM; + } + + for (i = 0; i < num_routes; i++) { +diff --git a/sound/usb/mixer_scarlett_gen2.c b/sound/usb/mixer_scarlett_gen2.c +index 54bcf1c14bc24..ab7abe360fcfe 100644 +--- a/sound/usb/mixer_scarlett_gen2.c ++++ b/sound/usb/mixer_scarlett_gen2.c +@@ -254,10 +254,10 @@ static const struct scarlett2_device_info s6i6_gen2_info = { + .pad_input_count = 2, + + .line_out_descrs = { +- "Monitor L", +- "Monitor R", +- "Headphones L", +- "Headphones R", ++ "Headphones 1 L", ++ "Headphones 1 R", ++ "Headphones 2 L", ++ "Headphones 2 R", + }, + + .ports = { +@@ -356,7 +356,7 @@ static const struct scarlett2_device_info s18i8_gen2_info = { + }, + [SCARLETT2_PORT_TYPE_PCM] = { + .id = 0x600, +- .num = { 20, 18, 18, 14, 10 }, ++ .num = { 8, 18, 18, 14, 10 }, + .src_descr = "PCM %d", + .src_num_offset = 1, + .dst_descr = "PCM %02d Capture" +@@ -1033,11 +1033,10 @@ static int scarlett2_master_volume_ctl_get(struct snd_kcontrol *kctl, + struct usb_mixer_interface *mixer = elem->head.mixer; + struct scarlett2_mixer_data *private = mixer->private_data; + +- if (private->vol_updated) { +- mutex_lock(&private->data_mutex); ++ mutex_lock(&private->data_mutex); ++ if (private->vol_updated) + scarlett2_update_volumes(mixer); +- mutex_unlock(&private->data_mutex); +- } ++ mutex_unlock(&private->data_mutex); + + ucontrol->value.integer.value[0] = private->master_vol; + return 0; +@@ -1051,11 +1050,10 @@ static int scarlett2_volume_ctl_get(struct snd_kcontrol *kctl, + struct scarlett2_mixer_data *private = mixer->private_data; + int index = elem->control; + +- if (private->vol_updated) { +- mutex_lock(&private->data_mutex); ++ mutex_lock(&private->data_mutex); ++ if (private->vol_updated) + scarlett2_update_volumes(mixer); +- mutex_unlock(&private->data_mutex); +- } ++ mutex_unlock(&private->data_mutex); + + ucontrol->value.integer.value[0] = private->vol[index]; + return 0; +@@ -1186,6 +1184,8 @@ static int scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol *kctl, + /* Send SW/HW switch change to the device */ + err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH, + index, val); ++ if (err == 0) ++ err = 1; + + unlock: + mutex_unlock(&private->data_mutex); +@@ -1246,6 +1246,8 @@ static int scarlett2_level_enum_ctl_put(struct snd_kcontrol *kctl, + /* Send switch change to the device */ + err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LEVEL_SWITCH, + index, val); ++ if (err == 0) ++ err = 1; + + unlock: + mutex_unlock(&private->data_mutex); +@@ -1296,6 +1298,8 @@ static int scarlett2_pad_ctl_put(struct snd_kcontrol *kctl, + /* Send switch change to the device */ + err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PAD_SWITCH, + index, val); ++ if (err == 0) ++ err = 1; + + unlock: + mutex_unlock(&private->data_mutex); +@@ -1319,11 +1323,10 @@ static int scarlett2_button_ctl_get(struct snd_kcontrol *kctl, + struct usb_mixer_interface *mixer = elem->head.mixer; + struct scarlett2_mixer_data *private = mixer->private_data; + +- if (private->vol_updated) { +- mutex_lock(&private->data_mutex); ++ mutex_lock(&private->data_mutex); ++ if (private->vol_updated) + scarlett2_update_volumes(mixer); +- mutex_unlock(&private->data_mutex); +- } ++ mutex_unlock(&private->data_mutex); + + ucontrol->value.enumerated.item[0] = private->buttons[elem->control]; + return 0; +@@ -1352,6 +1355,8 @@ static int scarlett2_button_ctl_put(struct snd_kcontrol *kctl, + /* Send switch change to the device */ + err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_BUTTONS, + index, val); ++ if (err == 0) ++ err = 1; + + unlock: + mutex_unlock(&private->data_mutex); +diff --git a/sound/usb/usx2y/usb_stream.c b/sound/usb/usx2y/usb_stream.c +index 091c071b270af..cff684942c4f0 100644 +--- a/sound/usb/usx2y/usb_stream.c ++++ b/sound/usb/usx2y/usb_stream.c +@@ -142,8 +142,11 @@ void usb_stream_free(struct usb_stream_kernel *sk) + if (!s) + return; + +- free_pages_exact(sk->write_page, s->write_size); +- sk->write_page = NULL; ++ if (sk->write_page) { ++ free_pages_exact(sk->write_page, s->write_size); ++ sk->write_page = NULL; ++ } ++ + free_pages_exact(s, s->read_size); + sk->s = NULL; + } +diff --git a/tools/testing/selftests/powerpc/pmu/ebb/no_handler_test.c b/tools/testing/selftests/powerpc/pmu/ebb/no_handler_test.c +index fc5bf4870d8e6..01e827c31169d 100644 +--- a/tools/testing/selftests/powerpc/pmu/ebb/no_handler_test.c ++++ b/tools/testing/selftests/powerpc/pmu/ebb/no_handler_test.c +@@ -50,8 +50,6 @@ static int no_handler_test(void) + + event_close(&event); + +- dump_ebb_state(); +- + /* The real test is that we never took an EBB at 0x0 */ + + return 0; +diff --git a/tools/testing/selftests/timers/rtcpie.c b/tools/testing/selftests/timers/rtcpie.c +index 47b5bad1b3933..4ef2184f15588 100644 +--- a/tools/testing/selftests/timers/rtcpie.c ++++ b/tools/testing/selftests/timers/rtcpie.c +@@ -18,6 +18,8 @@ + #include + #include + ++#include "../kselftest.h" ++ + /* + * This expects the new RTC class driver framework, working with + * clocks that will often not be clones of what the PC-AT had. +@@ -35,8 +37,14 @@ int main(int argc, char **argv) + switch (argc) { + case 2: + rtc = argv[1]; +- /* FALLTHROUGH */ ++ break; + case 1: ++ fd = open(default_rtc, O_RDONLY); ++ if (fd == -1) { ++ printf("Default RTC %s does not exist. Test Skipped!\n", default_rtc); ++ exit(KSFT_SKIP); ++ } ++ close(fd); + break; + default: + fprintf(stderr, "usage: rtctest [rtcdev] [d]\n"); +diff --git a/virt/kvm/coalesced_mmio.c b/virt/kvm/coalesced_mmio.c +index 6b870e4b9b972..8d606997c2993 100644 +--- a/virt/kvm/coalesced_mmio.c ++++ b/virt/kvm/coalesced_mmio.c +@@ -190,7 +190,6 @@ int kvm_vm_ioctl_unregister_coalesced_mmio(struct kvm *kvm, + coalesced_mmio_in_range(dev, zone->addr, zone->size)) { + r = kvm_io_bus_unregister_dev(kvm, + zone->pio ? KVM_PIO_BUS : KVM_MMIO_BUS, &dev->dev); +- kvm_iodevice_destructor(&dev->dev); + + /* + * On failure, unregister destroys all devices on the +@@ -200,6 +199,7 @@ int kvm_vm_ioctl_unregister_coalesced_mmio(struct kvm *kvm, + */ + if (r) + break; ++ kvm_iodevice_destructor(&dev->dev); + } + } +