lael-labs/linux

CREDITS+4−0

@@ -2452,6 +2452,10 @@ S: 482 Shadowgraph Dr. · 2451 unmodified lines
2452	S: San Jose, CA 95110	2452	S: San Jose, CA 95110
2453	S: USA	2453	S: USA
2454		2454
		2455	N: Michal Marek
		2456	E: michal.lkml@markovi.net
		2457	D: Kbuild Maintainer 2009-2017
		2458
2455	N: Martin Mares	2459	N: Martin Mares
2456	E: mj@ucw.cz	2460	E: mj@ucw.cz
2457	W: http://www.ucw.cz/~mj/	2461	W: http://www.ucw.cz/~mj/

Documentation/devicetree/bindings/input/goodix,gt7375p.yaml+4−1

 properties:
   compatible:
-    items:
+    oneOf:
       - const: goodix,gt7375p
+      - items:
+          - const: goodix,gt7986u
+          - const: goodix,gt7375p
   reg:
     enum:

Documentation/driver-api/miscellaneous.rst+2−3

 16x50 UART Driver
 =================
-.. kernel-doc:: drivers/tty/serial/serial_core.c
-   :export:
 .. kernel-doc:: drivers/tty/serial/8250/8250_core.c
    :export:
+See serial/driver.rst for related APIs.
 Pulse-Width Modulation (PWM)
 ============================

Documentation/process/code-of-conduct-interpretation.rst+1−1

@@ -51,7 +51,7 @@ the Technical Advisory Board (TAB) or other maintainers if you're · 50 unmodified lines
51	uncertain how to handle situations that come up. It will not be	51	uncertain how to handle situations that come up. It will not be
52	considered a violation report unless you want it to be. If you are	52	considered a violation report unless you want it to be. If you are
53	uncertain about approaching the TAB or any other maintainers, please	53	uncertain about approaching the TAB or any other maintainers, please
54	reach out to our conflict mediator, Joanna Lee <joanna.lee@gesmer.com>.	54	reach out to our conflict mediator, Joanna Lee <jlee@linuxfoundation.org>.
55		55
56	In the end, "be kind to each other" is really what the end goal is for	56	In the end, "be kind to each other" is really what the end goal is for
57	everybody. We know everyone is human and we all fail at times, but the	57	everybody. We know everyone is human and we all fail at times, but the

MAINTAINERS+38−9

@@ -2197,7 +2197,7 @@ M: Wei Xu <xuwei5@hisilicon.com> · 2196 unmodified lines
2197	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)	2197	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
2198	S: Supported	2198	S: Supported
2199	W: http://www.hisilicon.com	2199	W: http://www.hisilicon.com
2200	T: git git://github.com/hisilicon/linux-hisi.git	2200	T: git https://github.com/hisilicon/linux-hisi.git
2201	F: arch/arm/boot/dts/hi3*	2201	F: arch/arm/boot/dts/hi3*
2202	F: arch/arm/boot/dts/hip*	2202	F: arch/arm/boot/dts/hip*
2203	F: arch/arm/boot/dts/hisi*	2203	F: arch/arm/boot/dts/hisi*
@@ -4809,7 +4809,7 @@ R: Jeff Layton <jlayton@kernel.org> · 2605 unmodified lines
4809	L: ceph-devel@vger.kernel.org	4809	L: ceph-devel@vger.kernel.org
4810	S: Supported	4810	S: Supported
4811	W: http://ceph.com/	4811	W: http://ceph.com/
4812	T: git git://github.com/ceph/ceph-client.git	4812	T: git https://github.com/ceph/ceph-client.git
4813	F: include/linux/ceph/	4813	F: include/linux/ceph/
4814	F: include/linux/crush/	4814	F: include/linux/crush/
4815	F: net/ceph/	4815	F: net/ceph/
@@ -4821,7 +4821,7 @@ R: Jeff Layton <jlayton@kernel.org> · 5 unmodified lines
4821	L: ceph-devel@vger.kernel.org	4821	L: ceph-devel@vger.kernel.org
4822	S: Supported	4822	S: Supported
4823	W: http://ceph.com/	4823	W: http://ceph.com/
4824	T: git git://github.com/ceph/ceph-client.git	4824	T: git https://github.com/ceph/ceph-client.git
4825	F: Documentation/filesystems/ceph.rst	4825	F: Documentation/filesystems/ceph.rst
4826	F: fs/ceph/	4826	F: fs/ceph/
4827		4827
@@ -11035,6 +11035,7 @@ KCONFIG · 6207 unmodified lines
11035	M: Masahiro Yamada <masahiroy@kernel.org>	11035	M: Masahiro Yamada <masahiroy@kernel.org>
11036	L: linux-kbuild@vger.kernel.org	11036	L: linux-kbuild@vger.kernel.org
11037	S: Maintained	11037	S: Maintained
		11038	Q: https://patchwork.kernel.org/project/linux-kbuild/list/
11038	T: git git://git.kernel.org/pub/scm/linux/kernel/git/masahiroy/linux-kbuild.git kconfig	11039	T: git git://git.kernel.org/pub/scm/linux/kernel/git/masahiroy/linux-kbuild.git kconfig
11039	F: Documentation/kbuild/kconfig*	11040	F: Documentation/kbuild/kconfig*
11040	F: scripts/Kconfig.include	11041	F: scripts/Kconfig.include
@@ -11092,10 +11093,12 @@ F: fs/autofs/ · 51 unmodified lines
11092		11093
11093	KERNEL BUILD + files below scripts/ (unless maintained elsewhere)	11094	KERNEL BUILD + files below scripts/ (unless maintained elsewhere)
11094	M: Masahiro Yamada <masahiroy@kernel.org>	11095	M: Masahiro Yamada <masahiroy@kernel.org>
11095	M: Michal Marek <michal.lkml@markovi.net>	11096	R: Nathan Chancellor <nathan@kernel.org>
11096	R: Nick Desaulniers <ndesaulniers@google.com>	11097	R: Nick Desaulniers <ndesaulniers@google.com>
		11098	R: Nicolas Schier <nicolas@fjasle.eu>
11097	L: linux-kbuild@vger.kernel.org	11099	L: linux-kbuild@vger.kernel.org
11098	S: Maintained	11100	S: Maintained
		11101	Q: https://patchwork.kernel.org/project/linux-kbuild/list/
11099	T: git git://git.kernel.org/pub/scm/linux/kernel/git/masahiroy/linux-kbuild.git	11102	T: git git://git.kernel.org/pub/scm/linux/kernel/git/masahiroy/linux-kbuild.git
11100	F: Documentation/kbuild/	11103	F: Documentation/kbuild/
11101	F: Makefile	11104	F: Makefile
@@ -13625,6 +13628,12 @@ S: Supported · 2523 unmodified lines
13625	F: drivers/misc/atmel-ssc.c	13628	F: drivers/misc/atmel-ssc.c
13626	F: include/linux/atmel-ssc.h	13629	F: include/linux/atmel-ssc.h
13627		13630
		13631	MICROCHIP SOC DRIVERS
		13632	M: Conor Dooley <conor@kernel.org>
		13633	S: Supported
		13634	T: git https://git.kernel.org/pub/scm/linux/kernel/git/conor/linux.git/
		13635	F: drivers/soc/microchip/
		13636
13628	MICROCHIP USB251XB DRIVER	13637	MICROCHIP USB251XB DRIVER
13629	M: Richard Leitner <richard.leitner@skidata.com>	13638	M: Richard Leitner <richard.leitner@skidata.com>
13630	L: linux-usb@vger.kernel.org	13639	L: linux-usb@vger.kernel.org
@@ -17222,7 +17231,7 @@ R: Dongsheng Yang <dongsheng.yang@easystack.cn> · 3591 unmodified lines
17222	L: ceph-devel@vger.kernel.org	17231	L: ceph-devel@vger.kernel.org
17223	S: Supported	17232	S: Supported
17224	W: http://ceph.com/	17233	W: http://ceph.com/
17225	T: git git://github.com/ceph/ceph-client.git	17234	T: git https://github.com/ceph/ceph-client.git
17226	F: Documentation/ABI/testing/sysfs-bus-rbd	17235	F: Documentation/ABI/testing/sysfs-bus-rbd
17227	F: drivers/block/rbd.c	17236	F: drivers/block/rbd.c
17228	F: drivers/block/rbd_types.h	17237	F: drivers/block/rbd_types.h
@@ -17723,7 +17732,7 @@ F: arch/riscv/ · 494 unmodified lines
17723	N: riscv	17732	N: riscv
17724	K: riscv	17733	K: riscv
17725		17734
17726	RISC-V/MICROCHIP POLARFIRE SOC SUPPORT	17735	RISC-V MICROCHIP FPGA SUPPORT
17727	M: Conor Dooley <conor.dooley@microchip.com>	17736	M: Conor Dooley <conor.dooley@microchip.com>
17728	M: Daire McNamara <daire.mcnamara@microchip.com>	17737	M: Daire McNamara <daire.mcnamara@microchip.com>
17729	L: linux-riscv@lists.infradead.org	17738	L: linux-riscv@lists.infradead.org
@@ -17741,17 +17750,26 @@ F: Documentation/devicetree/bindings/usb/microchip,mpfs-musb.yaml · 11 unmodified lines
17741	F: arch/riscv/boot/dts/microchip/	17750	F: arch/riscv/boot/dts/microchip/
17742	F: drivers/char/hw_random/mpfs-rng.c	17751	F: drivers/char/hw_random/mpfs-rng.c
17743	F: drivers/clk/microchip/clk-mpfs.c	17752	F: drivers/clk/microchip/clk-mpfs.c
17744	F: drivers/i2c/busses/i2c-microchip-core.c	17753	F: drivers/i2c/busses/i2c-microchip-corei2c.c
17745	F: drivers/mailbox/mailbox-mpfs.c	17754	F: drivers/mailbox/mailbox-mpfs.c
17746	F: drivers/pci/controller/pcie-microchip-host.c	17755	F: drivers/pci/controller/pcie-microchip-host.c
17747	F: drivers/reset/reset-mpfs.c	17756	F: drivers/reset/reset-mpfs.c
17748	F: drivers/rtc/rtc-mpfs.c	17757	F: drivers/rtc/rtc-mpfs.c
17749	F: drivers/soc/microchip/	17758	F: drivers/soc/microchip/mpfs-sys-controller.c
17750	F: drivers/spi/spi-microchip-core-qspi.c	17759	F: drivers/spi/spi-microchip-core-qspi.c
17751	F: drivers/spi/spi-microchip-core.c	17760	F: drivers/spi/spi-microchip-core.c
17752	F: drivers/usb/musb/mpfs.c	17761	F: drivers/usb/musb/mpfs.c
17753	F: include/soc/microchip/mpfs.h	17762	F: include/soc/microchip/mpfs.h
17754		17763
		17764	RISC-V MISC SOC SUPPORT
		17765	M: Conor Dooley <conor@kernel.org>
		17766	L: linux-riscv@lists.infradead.org
		17767	S: Maintained
		17768	Q: https://patchwork.kernel.org/project/linux-riscv/list/
		17769	T: git https://git.kernel.org/pub/scm/linux/kernel/git/conor/linux.git/
		17770	F: Documentation/devicetree/bindings/riscv/
		17771	F: arch/riscv/boot/dts/
		17772
17755	RNBD BLOCK DRIVERS	17773	RNBD BLOCK DRIVERS
17756	M: Md. Haris Iqbal <haris.iqbal@ionos.com>	17774	M: Md. Haris Iqbal <haris.iqbal@ionos.com>
17757	M: Jack Wang <jinpu.wang@ionos.com>	17775	M: Jack Wang <jinpu.wang@ionos.com>
@@ -18778,7 +18796,6 @@ M: Palmer Dabbelt <palmer@dabbelt.com> · 1020 unmodified lines
18778	M: Paul Walmsley <paul.walmsley@sifive.com>	18796	M: Paul Walmsley <paul.walmsley@sifive.com>
18779	L: linux-riscv@lists.infradead.org	18797	L: linux-riscv@lists.infradead.org
18780	S: Supported	18798	S: Supported
18781	T: git https://github.com/sifive/riscv-linux.git
18782	N: sifive	18799	N: sifive
18783	K: [^@]sifive	18800	K: [^@]sifive
18784		18801
@@ -18797,6 +18814,13 @@ S: Maintained · 12 unmodified lines
18797	F: Documentation/devicetree/bindings/dma/sifive,fu540-c000-pdma.yaml	18814	F: Documentation/devicetree/bindings/dma/sifive,fu540-c000-pdma.yaml
18798	F: drivers/dma/sf-pdma/	18815	F: drivers/dma/sf-pdma/
18799		18816
		18817	SIFIVE SOC DRIVERS
		18818	M: Conor Dooley <conor@kernel.org>
		18819	L: linux-riscv@lists.infradead.org
		18820	S: Maintained
		18821	T: git https://git.kernel.org/pub/scm/linux/kernel/git/conor/linux.git/
		18822	F: drivers/soc/sifive/
		18823
18800	SILEAD TOUCHSCREEN DRIVER	18824	SILEAD TOUCHSCREEN DRIVER
18801	M: Hans de Goede <hdegoede@redhat.com>	18825	M: Hans de Goede <hdegoede@redhat.com>
18802	L: linux-input@vger.kernel.org	18826	L: linux-input@vger.kernel.org
@@ -19598,6 +19622,11 @@ M: Ion Badulescu <ionut@badula.org> · 795 unmodified lines
19598	S: Odd Fixes	19622	S: Odd Fixes
19599	F: drivers/net/ethernet/adaptec/starfire*	19623	F: drivers/net/ethernet/adaptec/starfire*
19600		19624
		19625	STARFIVE DEVICETREES
		19626	M: Emil Renner Berthing <kernel@esmil.dk>
		19627	S: Maintained
		19628	F: arch/riscv/boot/dts/starfive/
		19629
19601	STARFIVE JH7100 CLOCK DRIVERS	19630	STARFIVE JH7100 CLOCK DRIVERS
19602	M: Emil Renner Berthing <kernel@esmil.dk>	19631	M: Emil Renner Berthing <kernel@esmil.dk>
19603	S: Maintained	19632	S: Maintained

Makefile+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	VERSION = 6	2	VERSION = 6
3	PATCHLEVEL = 1	3	PATCHLEVEL = 1
4	SUBLEVEL = 0	4	SUBLEVEL = 0
5	EXTRAVERSION = -rc5	5	EXTRAVERSION = -rc6
6	NAME = Hurr durr I'ma ninja sloth	6	NAME = Hurr durr I'ma ninja sloth
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION

arch/arm/boot/dts/imx7s.dtsi+2−2

@@ -1270,10 +1270,10 @@ · 1269 unmodified lines
1270	clocks = <&clks IMX7D_NAND_USDHC_BUS_RAWNAND_CLK>;	1270	clocks = <&clks IMX7D_NAND_USDHC_BUS_RAWNAND_CLK>;
1271	};	1271	};
1272		1272
1273	gpmi: nand-controller@33002000{	1273	gpmi: nand-controller@33002000 {
1274	compatible = "fsl,imx7d-gpmi-nand";	1274	compatible = "fsl,imx7d-gpmi-nand";
1275	#address-cells = <1>;	1275	#address-cells = <1>;
1276	#size-cells = <1>;	1276	#size-cells = <0>;
1277	reg = <0x33002000 0x2000>, <0x33004000 0x4000>;	1277	reg = <0x33002000 0x2000>, <0x33004000 0x4000>;
1278	reg-names = "gpmi-nand", "bch";	1278	reg-names = "gpmi-nand", "bch";
1279	interrupts = <GIC_SPI 14 IRQ_TYPE_LEVEL_HIGH>;	1279	interrupts = <GIC_SPI 14 IRQ_TYPE_LEVEL_HIGH>;

arch/arm/boot/dts/lan966x-pcb8291.dts+20−0

@@ -69,6 +69,12 @@ · 68 unmodified lines
69	pins = "GPIO_35", "GPIO_36";	69	pins = "GPIO_35", "GPIO_36";
70	function = "can0_b";	70	function = "can0_b";
71	};	71	};
		72
		73	sgpio_a_pins: sgpio-a-pins {
		74	/* SCK, D0, D1, LD */
		75	pins = "GPIO_32", "GPIO_33", "GPIO_34", "GPIO_35";
		76	function = "sgpio_a";
		77	};
72	};	78	};
73		79
74	&can0 {	80	&can0 {
@@ -118,6 +124,20 @@ · 43 unmodified lines
118	status = "okay";	124	status = "okay";
119	};	125	};
120		126
		127	&sgpio {
		128	pinctrl-0 = <&sgpio_a_pins>;
		129	pinctrl-names = "default";
		130	microchip,sgpio-port-ranges = <0 3>, <8 11>;
		131	status = "okay";
		132
		133	gpio@0 {
		134	ngpios = <64>;
		135	};
		136	gpio@1 {
		137	ngpios = <64>;
		138	};
		139	};
		140
121	&switch {	141	&switch {
122	status = "okay";	142	status = "okay";
123	};	143	};

arch/arm/boot/dts/sama7g5-pinfunc.h+1−1

@@ -261,7 +261,7 @@ · 260 unmodified lines
261	#define PIN_PB2__FLEXCOM6_IO0 PINMUX_PIN(PIN_PB2, 2, 1)	261	#define PIN_PB2__FLEXCOM6_IO0 PINMUX_PIN(PIN_PB2, 2, 1)
262	#define PIN_PB2__ADTRG PINMUX_PIN(PIN_PB2, 3, 1)	262	#define PIN_PB2__ADTRG PINMUX_PIN(PIN_PB2, 3, 1)
263	#define PIN_PB2__A20 PINMUX_PIN(PIN_PB2, 4, 1)	263	#define PIN_PB2__A20 PINMUX_PIN(PIN_PB2, 4, 1)
264	#define PIN_PB2__FLEXCOM11_IO0 PINMUX_PIN(PIN_PB2, 6, 3)	264	#define PIN_PB2__FLEXCOM11_IO1 PINMUX_PIN(PIN_PB2, 6, 3)
265	#define PIN_PB3 35	265	#define PIN_PB3 35
266	#define PIN_PB3__GPIO PINMUX_PIN(PIN_PB3, 0, 0)	266	#define PIN_PB3__GPIO PINMUX_PIN(PIN_PB3, 0, 0)
267	#define PIN_PB3__RF1 PINMUX_PIN(PIN_PB3, 1, 1)	267	#define PIN_PB3__RF1 PINMUX_PIN(PIN_PB3, 1, 1)

arch/arm/mach-at91/pm_suspend.S+6−1

 	cmp	tmp1, #UDDRC_STAT_SELFREF_TYPE_SW
 	bne	sr_ena_2
-	/* Put DDR PHY's DLL in bypass mode for non-backup modes. */
+	/* Disable DX DLLs for non-backup modes. */
 	cmp	r7, #AT91_PM_BACKUP
 	beq	sr_ena_3
+	/* Do not soft reset the AC DLL. */
+	ldr	tmp1, [r3, DDR3PHY_ACDLLCR]
+	bic	tmp1, tmp1, DDR3PHY_ACDLLCR_DLLSRST
+	str	tmp1, [r3, DDR3PHY_ACDLLCR]
 	/* Disable DX DLLs. */
 	ldr	tmp1, [r3, #DDR3PHY_DX0DLLCR]
 	orr	tmp1, tmp1, #DDR3PHY_DXDLLCR_DLLDIS

arch/arm64/boot/dts/freescale/imx8mm-tqma8mqml-mba8mx.dts+26−6

 		off-on-delay-us = <12000>;
 	};
-	extcon_usbotg1: extcon-usbotg1 {
+	connector {
-		compatible = "linux,extcon-usb-gpio";
+		compatible = "gpio-usb-b-connector", "usb-b-connector";
+		type = "micro";
+		label = "X19";
 		pinctrl-names = "default";
-		pinctrl-0 = <&pinctrl_usb1_extcon>;
+		pinctrl-0 = <&pinctrl_usb1_connector>;
-		id-gpio = <&gpio1 10 GPIO_ACTIVE_HIGH>;
+		id-gpios = <&gpio1 10 GPIO_ACTIVE_HIGH>;
+		ports {
+			#address-cells = <1>;
+			#size-cells = <0>;
+			port@0 {
+				reg = <0>;
+				usb_dr_connector: endpoint {
+					remote-endpoint = <&usb1_drd_sw>;
+				};
+			};
+		};
 	};
 };
 	pinctrl-names = "default";
 	pinctrl-0 = <&pinctrl_usbotg1>;
 	dr_mode = "otg";
-	extcon = <&extcon_usbotg1>;
 	srp-disable;
 	hnp-disable;
 	adp-disable;
 	power-active-high;
 	over-current-active-low;
+	usb-role-switch;
 	status = "okay";
+	port {
+		usb1_drd_sw: endpoint {
+			remote-endpoint = <&usb_dr_connector>;
+		};
+	};
 };
 &usbotg2 {
 			   <MX8MM_IOMUXC_GPIO1_IO13_USB1_OTG_OC		0x84>;
 	};
-	pinctrl_usb1_extcon: usb1-extcongrp {
+	pinctrl_usb1_connector: usb1-connectorgrp {
 		fsl,pins = <MX8MM_IOMUXC_GPIO1_IO10_GPIO1_IO10		0x1c0>;
 	};

arch/arm64/boot/dts/freescale/imx8mm.dtsi+2−2

@@ -1244,10 +1244,10 @@ · 1243 unmodified lines
1244	clocks = <&clk IMX8MM_CLK_NAND_USDHC_BUS_RAWNAND_CLK>;	1244	clocks = <&clk IMX8MM_CLK_NAND_USDHC_BUS_RAWNAND_CLK>;
1245	};	1245	};
1246		1246
1247	gpmi: nand-controller@33002000{	1247	gpmi: nand-controller@33002000 {
1248	compatible = "fsl,imx8mm-gpmi-nand", "fsl,imx7d-gpmi-nand";	1248	compatible = "fsl,imx8mm-gpmi-nand", "fsl,imx7d-gpmi-nand";
1249	#address-cells = <1>;	1249	#address-cells = <1>;
1250	#size-cells = <1>;	1250	#size-cells = <0>;
1251	reg = <0x33002000 0x2000>, <0x33004000 0x4000>;	1251	reg = <0x33002000 0x2000>, <0x33004000 0x4000>;
1252	reg-names = "gpmi-nand", "bch";	1252	reg-names = "gpmi-nand", "bch";
1253	interrupts = <GIC_SPI 14 IRQ_TYPE_LEVEL_HIGH>;	1253	interrupts = <GIC_SPI 14 IRQ_TYPE_LEVEL_HIGH>;

arch/arm64/boot/dts/freescale/imx8mn.dtsi+1−1

@@ -1102,7 +1102,7 @@ · 1101 unmodified lines
1102	gpmi: nand-controller@33002000 {	1102	gpmi: nand-controller@33002000 {
1103	compatible = "fsl,imx8mn-gpmi-nand", "fsl,imx7d-gpmi-nand";	1103	compatible = "fsl,imx8mn-gpmi-nand", "fsl,imx7d-gpmi-nand";
1104	#address-cells = <1>;	1104	#address-cells = <1>;
1105	#size-cells = <1>;	1105	#size-cells = <0>;
1106	reg = <0x33002000 0x2000>, <0x33004000 0x4000>;	1106	reg = <0x33002000 0x2000>, <0x33004000 0x4000>;
1107	reg-names = "gpmi-nand", "bch";	1107	reg-names = "gpmi-nand", "bch";
1108	interrupts = <GIC_SPI 14 IRQ_TYPE_LEVEL_HIGH>;	1108	interrupts = <GIC_SPI 14 IRQ_TYPE_LEVEL_HIGH>;

arch/arm64/boot/dts/freescale/imx93-pinfunc.h+0−0

File mode changed from 100755 to 100644.

arch/arm64/boot/dts/qcom/ipq8074.dtsi+1−1

@@ -668,7 +668,7 @@ · 667 unmodified lines
668		668
669	apcs_glb: mailbox@b111000 {	669	apcs_glb: mailbox@b111000 {
670	compatible = "qcom,ipq8074-apcs-apps-global";	670	compatible = "qcom,ipq8074-apcs-apps-global";
671	reg = <0x0b111000 0x6000>;	671	reg = <0x0b111000 0x1000>;
672		672
673	#clock-cells = <1>;	673	#clock-cells = <1>;
674	#mbox-cells = <1>;	674	#mbox-cells = <1>;

arch/arm64/boot/dts/qcom/msm8996.dtsi+1−1

@@ -3504,7 +3504,7 @@ · 3503 unmodified lines
3504	};	3504	};
3505		3505
3506	saw3: syscon@9a10000 {	3506	saw3: syscon@9a10000 {
3507	compatible = "qcom,tcsr-msm8996", "syscon";	3507	compatible = "syscon";
3508	reg = <0x09a10000 0x1000>;	3508	reg = <0x09a10000 0x1000>;
3509	};	3509	};
3510		3510

arch/arm64/boot/dts/qcom/sa8155p-adp.dts+12−1

 		regulator-always-on;
 		regulator-boot-on;
-		regulator-allow-set-load;
 		vin-supply = <&vreg_3p3>;
 	};
 			regulator-max-microvolt = <880000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 		vreg_l7a_1p8: ldo7 {
 			regulator-max-microvolt = <2960000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 		vreg_l11a_0p8: ldo11 {
 			regulator-max-microvolt = <1200000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 		vreg_l7c_1p8: ldo7 {
 			regulator-max-microvolt = <1200000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 		vreg_l10c_3p3: ldo10 {

arch/arm64/boot/dts/qcom/sa8295p-adp.dts+12−0

 			regulator-max-microvolt = <1200000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 		vreg_l4c: ldo4 {
 			regulator-max-microvolt = <1200000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 		vreg_l7c: ldo7 {
 			regulator-max-microvolt = <2504000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 		vreg_l17c: ldo17 {
 			regulator-max-microvolt = <2504000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 	};

arch/arm64/boot/dts/qcom/sc7280.dtsi+2−1

@@ -2296,7 +2296,8 @@ · 2295 unmodified lines
2296		2296
2297	lpass_audiocc: clock-controller@3300000 {	2297	lpass_audiocc: clock-controller@3300000 {
2298	compatible = "qcom,sc7280-lpassaudiocc";	2298	compatible = "qcom,sc7280-lpassaudiocc";
2299	reg = <0 0x03300000 0 0x30000>;	2299	reg = <0 0x03300000 0 0x30000>,
		2300	<0 0x032a9000 0 0x1000>;
2300	clocks = <&rpmhcc RPMH_CXO_CLK>,	2301	clocks = <&rpmhcc RPMH_CXO_CLK>,
2301	<&lpass_aon LPASS_AON_CC_MAIN_RCG_CLK_SRC>;	2302	<&lpass_aon LPASS_AON_CC_MAIN_RCG_CLK_SRC>;
2302	clock-names = "bi_tcxo", "lpass_aon_cc_main_rcg_clk_src";	2303	clock-names = "bi_tcxo", "lpass_aon_cc_main_rcg_clk_src";

arch/arm64/boot/dts/qcom/sc8280xp-crd.dts+6−0

 			regulator-max-microvolt = <2504000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 		vreg_l13c: ldo13 {
 			regulator-max-microvolt = <1200000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 		vreg_l4d: ldo4 {

arch/arm64/boot/dts/qcom/sc8280xp.dtsi+8−28

 		ufs_mem_phy: phy@1d87000 {
 			compatible = "qcom,sc8280xp-qmp-ufs-phy";
-			reg = <0 0x01d87000 0 0xe10>;
+			reg = <0 0x01d87000 0 0x1c8>;
 			#address-cells = <2>;
 			#size-cells = <2>;
 			ranges;
 			clock-names = "ref",
 				      "ref_aux";
-			clocks = <&rpmhcc RPMH_CXO_CLK>,
+			clocks = <&gcc GCC_UFS_REF_CLKREF_CLK>,
 				 <&gcc GCC_UFS_PHY_PHY_AUX_CLK>;
 			resets = <&ufs_mem_hc 0>;
 		ufs_card_phy: phy@1da7000 {
 			compatible = "qcom,sc8280xp-qmp-ufs-phy";
-			reg = <0 0x01da7000 0 0xe10>;
+			reg = <0 0x01da7000 0 0x1c8>;
 			#address-cells = <2>;
 			#size-cells = <2>;
 			ranges;
 			clock-names = "ref",
 				      "ref_aux";
-			clocks = <&gcc GCC_UFS_1_CARD_CLKREF_CLK>,
+			clocks = <&gcc GCC_UFS_REF_CLKREF_CLK>,
 				 <&gcc GCC_UFS_CARD_PHY_AUX_CLK>;
 			resets = <&ufs_card_hc 0>;
 			usb_0_ssphy: usb3-phy@88eb400 {
 				reg = <0 0x088eb400 0 0x100>,
 				      <0 0x088eb600 0 0x3ec>,
-				      <0 0x088ec400 0 0x1f0>,
+				      <0 0x088ec400 0 0x364>,
 				      <0 0x088eba00 0 0x100>,
 				      <0 0x088ebc00 0 0x3ec>,
-				      <0 0x088ec700 0 0x64>;
+				      <0 0x088ec200 0 0x18>;
 				#phy-cells = <0>;
 				#clock-cells = <0>;
 				clocks = <&gcc GCC_USB3_PRIM_PHY_PIPE_CLK>;
 				clock-names = "pipe0";
 				clock-output-names = "usb0_phy_pipe_clk_src";
 			};
-			usb_0_dpphy: dp-phy@88ed200 {
-				reg = <0 0x088ed200 0 0x200>,
-				      <0 0x088ed400 0 0x200>,
-				      <0 0x088eda00 0 0x200>,
-				      <0 0x088ea600 0 0x200>,
-				      <0 0x088ea800 0 0x200>;
-				#clock-cells = <1>;
-				#phy-cells = <0>;
-			};
 		};
 		usb_1_hsphy: phy@8902000 {
 			usb_1_ssphy: usb3-phy@8903400 {
 				reg = <0 0x08903400 0 0x100>,
-				      <0 0x08903c00 0 0x3ec>,
+				      <0 0x08903600 0 0x3ec>,
-				      <0 0x08904400 0 0x1f0>,
+				      <0 0x08904400 0 0x364>,
 				      <0 0x08903a00 0 0x100>,
 				      <0 0x08903c00 0 0x3ec>,
 				      <0 0x08904200 0 0x18>;
 				clock-names = "pipe0";
 				clock-output-names = "usb1_phy_pipe_clk_src";
 			};
-			usb_1_dpphy: dp-phy@8904200 {
-				reg = <0 0x08904200 0 0x200>,
-				      <0 0x08904400 0 0x200>,
-				      <0 0x08904a00 0 0x200>,
-				      <0 0x08904600 0 0x200>,
-				      <0 0x08904800 0 0x200>;
-				#clock-cells = <1>;
-				#phy-cells = <0>;
-			};
 		};
 		system-cache-controller@9200000 {

arch/arm64/boot/dts/qcom/sm8150-sony-xperia-kumano.dtsi+6−0

 			regulator-max-microvolt = <2960000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 		vreg_l7c_3p0: ldo7 {
 			regulator-max-microvolt = <2960000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 		vreg_l10c_3p3: ldo10 {

arch/arm64/boot/dts/qcom/sm8250-sony-xperia-edo.dtsi+6−0

 			regulator-max-microvolt = <2960000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 		vreg_l7c_2p85: ldo7 {
 			regulator-max-microvolt = <2960000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 		vreg_l10c_3p3: ldo10 {

arch/arm64/boot/dts/qcom/sm8250.dtsi+1−0

@@ -334,6 +334,7 @@ · 333 unmodified lines
334	exit-latency-us = <6562>;	334	exit-latency-us = <6562>;
335	min-residency-us = <9987>;	335	min-residency-us = <9987>;
336	local-timer-stop;	336	local-timer-stop;
		337	status = "disabled";
337	};	338	};
338	};	339	};
339	};	340	};

arch/arm64/boot/dts/qcom/sm8350-hdk.dts+12−0

 			regulator-max-microvolt = <888000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 		vreg_l6b_1p2: ldo6 {
 			regulator-max-microvolt = <1208000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 		vreg_l7b_2p96: ldo7 {
 			regulator-max-microvolt = <2504000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 		vreg_l9b_1p2: ldo9 {
 			regulator-max-microvolt = <1200000>;
 			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
 			regulator-allow-set-load;
+			regulator-allowed-modes =
+			    <RPMH_REGULATOR_MODE_LPM
+			     RPMH_REGULATOR_MODE_HPM>;
 		};
 	};

arch/arm64/include/asm/pgtable.h+2−2

@@ -863,12 +863,12 @@ static inline bool pte_user_accessible_page(pte_t pte) · 862 unmodified lines
863		863
864	static inline bool pmd_user_accessible_page(pmd_t pmd)	864	static inline bool pmd_user_accessible_page(pmd_t pmd)
865	{	865	{
866	return pmd_present(pmd) && (pmd_user(pmd) \|\| pmd_user_exec(pmd));	866	return pmd_leaf(pmd) && (pmd_user(pmd) \|\| pmd_user_exec(pmd));
867	}	867	}
868		868
869	static inline bool pud_user_accessible_page(pud_t pud)	869	static inline bool pud_user_accessible_page(pud_t pud)
870	{	870	{
871	return pud_present(pud) && pud_user(pud);	871	return pud_leaf(pud) && pud_user(pud);
872	}	872	}
873	#endif	873	#endif
874		874

arch/arm64/kernel/entry-ftrace.S+1−1

 	ret
 SYM_FUNC_END(ftrace_stub)
+#ifdef CONFIG_FUNCTION_GRAPH_TRACER
 SYM_TYPED_FUNC_START(ftrace_stub_graph)
 	ret
 SYM_FUNC_END(ftrace_stub_graph)
-#ifdef CONFIG_FUNCTION_GRAPH_TRACER
 /*
  * void return_to_handler(void)
  *

arch/powerpc/kernel/vmlinux.lds.S+1−1

@@ -142,7 +142,7 @@ SECTIONS · 141 unmodified lines
142	#endif	142	#endif
143		143
144	.data.rel.ro : AT(ADDR(.data.rel.ro) - LOAD_OFFSET) {	144	.data.rel.ro : AT(ADDR(.data.rel.ro) - LOAD_OFFSET) {
145	(.data.rel.ro)	145	(.data.rel.ro .data.rel.ro.)
146	}	146	}
147		147
148	.branch_lt : AT(ADDR(.branch_lt) - LOAD_OFFSET) {	148	.branch_lt : AT(ADDR(.branch_lt) - LOAD_OFFSET) {

arch/s390/include/asm/processor.h+10−1

@@ -199,7 +199,16 @@ unsigned long __get_wchan(struct task_struct *p); · 198 unmodified lines
199	/* Has task runtime instrumentation enabled ? */	199	/* Has task runtime instrumentation enabled ? */
200	#define is_ri_task(tsk) (!!(tsk)->thread.ri_cb)	200	#define is_ri_task(tsk) (!!(tsk)->thread.ri_cb)
201		201
202	register unsigned long current_stack_pointer asm("r15");	202	/* avoid using global register due to gcc bug in versions < 8.4 */
		203	#define current_stack_pointer (__current_stack_pointer())
		204
		205	static __always_inline unsigned long __current_stack_pointer(void)
		206	{
		207	unsigned long sp;
		208
		209	asm volatile("lgr %0,15" : "=d" (sp));
		210	return sp;
		211	}
203		212
204	static __always_inline unsigned short stap(void)	213	static __always_inline unsigned short stap(void)
205	{	214	{

arch/x86/events/amd/core.c+2−3

 	pmu_enabled = cpuc->enabled;
 	cpuc->enabled = 0;
-	/* stop everything (includes BRS) */
+	amd_brs_disable_all();
-	amd_pmu_disable_all();
 	/* Drain BRS is in use (could be inactive) */
 	if (cpuc->lbr_users)
 	cpuc->enabled = pmu_enabled;
 	if (pmu_enabled)
-		amd_pmu_enable_all(0);
+		amd_brs_enable_all();
 	return amd_pmu_adjust_nmi_window(handled);
 }

arch/x86/events/amd/uncore.c+1−0

@@ -553,6 +553,7 @@ static void uncore_clean_online(void) · 552 unmodified lines
553		553
554	hlist_for_each_entry_safe(uncore, n, &uncore_unused_list, node) {	554	hlist_for_each_entry_safe(uncore, n, &uncore_unused_list, node) {
555	hlist_del(&uncore->node);	555	hlist_del(&uncore->node);
		556	kfree(uncore->events);
556	kfree(uncore);	557	kfree(uncore);
557	}	558	}
558	}	559	}

arch/x86/events/intel/pt.c+9−0

@@ -1263,6 +1263,15 @@ static int pt_buffer_try_single(struct pt_buffer *buf, int nr_pages) · 1262 unmodified lines
1263	if (1 << order != nr_pages)	1263	if (1 << order != nr_pages)
1264	goto out;	1264	goto out;
1265		1265
		1266	/*
		1267	* Some processors cannot always support single range for more than
		1268	* 4KB - refer errata TGL052, ADL037 and RPL017. Future processors might
		1269	* also be affected, so for now rather than trying to keep track of
		1270	* which ones, just disable it for all.
		1271	*/
		1272	if (nr_pages > 1)
		1273	goto out;
		1274
1266	buf->single = true;	1275	buf->single = true;
1267	buf->nr_pages = nr_pages;	1276	buf->nr_pages = nr_pages;
1268	ret = 0;	1277	ret = 0;

arch/x86/include/asm/msr-index.h+5−3

 #define MSR_AMD64_CPUID_FN_1		0xc0011004
 #define MSR_AMD64_LS_CFG		0xc0011020
 #define MSR_AMD64_DC_CFG		0xc0011022
+#define MSR_AMD64_DE_CFG		0xc0011029
+#define MSR_AMD64_DE_CFG_LFENCE_SERIALIZE_BIT	 1
+#define MSR_AMD64_DE_CFG_LFENCE_SERIALIZE	BIT_ULL(MSR_AMD64_DE_CFG_LFENCE_SERIALIZE_BIT)
 #define MSR_AMD64_BU_CFG2		0xc001102a
 #define MSR_AMD64_IBSFETCHCTL		0xc0011030
 #define MSR_AMD64_IBSFETCHLINAD		0xc0011031
 #define FAM10H_MMIO_CONF_BASE_MASK	0xfffffffULL
 #define FAM10H_MMIO_CONF_BASE_SHIFT	20
 #define MSR_FAM10H_NODE_ID		0xc001100c
-#define MSR_F10H_DECFG			0xc0011029
-#define MSR_F10H_DECFG_LFENCE_SERIALIZE_BIT	1
-#define MSR_F10H_DECFG_LFENCE_SERIALIZE		BIT_ULL(MSR_F10H_DECFG_LFENCE_SERIALIZE_BIT)
 /* K8 MSRs */
 #define MSR_K8_TOP_MEM1			0xc001001a

arch/x86/include/asm/qspinlock_paravirt.h+1−1

@@ -37,7 +37,7 @@ __PV_CALLEE_SAVE_REGS_THUNK(__pv_queued_spin_unlock_slowpath, ".spinlock.text"); · 36 unmodified lines
37	* rsi = lockval (second argument)	37	* rsi = lockval (second argument)
38	* rdx = internal variable (set to 0)	38	* rdx = internal variable (set to 0)
39	*/	39	*/
40	asm (".pushsection .spinlock.text;"	40	asm (".pushsection .spinlock.text, \"ax\";"
41	".globl " PV_UNLOCK ";"	41	".globl " PV_UNLOCK ";"
42	".type " PV_UNLOCK ", @function;"	42	".type " PV_UNLOCK ", @function;"
43	".align 4,0x90;"	43	".align 4,0x90;"

arch/x86/kernel/cpu/amd.c+2−4

 		set_cpu_bug(c, X86_BUG_AMD_TLB_MMATCH);
 }
-#define MSR_AMD64_DE_CFG	0xC0011029
 static void init_amd_ln(struct cpuinfo_x86 *c)
 {
 	/*
 		 * msr_set_bit() uses the safe accessors, too, even if the MSR
 		 * is not present.
 		 */
-		msr_set_bit(MSR_F10H_DECFG,
+		msr_set_bit(MSR_AMD64_DE_CFG,
-			    MSR_F10H_DECFG_LFENCE_SERIALIZE_BIT);
+			    MSR_AMD64_DE_CFG_LFENCE_SERIALIZE_BIT);
 		/* A serializing LFENCE stops RDTSC speculation */
 		set_cpu_cap(c, X86_FEATURE_LFENCE_RDTSC);

arch/x86/kernel/cpu/hygon.c+2−2

@@ -326,8 +326,8 @@ static void init_hygon(struct cpuinfo_x86 *c) · 325 unmodified lines
326	* msr_set_bit() uses the safe accessors, too, even if the MSR	326	* msr_set_bit() uses the safe accessors, too, even if the MSR
327	* is not present.	327	* is not present.
328	*/	328	*/
329	msr_set_bit(MSR_F10H_DECFG,	329	msr_set_bit(MSR_AMD64_DE_CFG,
330	MSR_F10H_DECFG_LFENCE_SERIALIZE_BIT);	330	MSR_AMD64_DE_CFG_LFENCE_SERIALIZE_BIT);
331		331
332	/* A serializing LFENCE stops RDTSC speculation */	332	/* A serializing LFENCE stops RDTSC speculation */
333	set_cpu_cap(c, X86_FEATURE_LFENCE_RDTSC);	333	set_cpu_cap(c, X86_FEATURE_LFENCE_RDTSC);

arch/x86/kernel/cpu/sgx/ioctl.c+3−0

@@ -356,6 +356,9 @@ static int sgx_validate_offset_length(struct sgx_encl *encl, · 355 unmodified lines
356	if (!length \|\| !IS_ALIGNED(length, PAGE_SIZE))	356	if (!length \|\| !IS_ALIGNED(length, PAGE_SIZE))
357	return -EINVAL;	357	return -EINVAL;
358		358
		359	if (offset + length < offset)
		360	return -EINVAL;
		361
359	if (offset + length - PAGE_SIZE >= encl->size)	362	if (offset + length - PAGE_SIZE >= encl->size)
360	return -EINVAL;	363	return -EINVAL;
361		364

arch/x86/kernel/fpu/core.c+1−1

 	if (test_thread_flag(TIF_NEED_FPU_LOAD))
 		fpregs_restore_userregs();
 	save_fpregs_to_fpstate(dst_fpu);
+	fpregs_unlock();
 	if (!(clone_flags & CLONE_THREAD))
 		fpu_inherit_perms(dst_fpu);
-	fpregs_unlock();
 	/*
 	 * Children never inherit PASID state.

arch/x86/kvm/svm/svm.c+5−5

@@ -2709,9 +2709,9 @@ static int svm_get_msr_feature(struct kvm_msr_entry *msr) · 2708 unmodified lines
2709	msr->data = 0;	2709	msr->data = 0;
2710		2710
2711	switch (msr->index) {	2711	switch (msr->index) {
2712	case MSR_F10H_DECFG:	2712	case MSR_AMD64_DE_CFG:
2713	if (boot_cpu_has(X86_FEATURE_LFENCE_RDTSC))	2713	if (cpu_feature_enabled(X86_FEATURE_LFENCE_RDTSC))
2714	msr->data \|= MSR_F10H_DECFG_LFENCE_SERIALIZE;	2714	msr->data \|= MSR_AMD64_DE_CFG_LFENCE_SERIALIZE;
2715	break;	2715	break;
2716	case MSR_IA32_PERF_CAPABILITIES:	2716	case MSR_IA32_PERF_CAPABILITIES:
2717	return 0;	2717	return 0;
@@ -2812,7 +2812,7 @@ static int svm_get_msr(struct kvm_vcpu vcpu, struct msr_data msr_info) · 94 unmodified lines
2812	msr_info->data = 0x1E;	2812	msr_info->data = 0x1E;
2813	}	2813	}
2814	break;	2814	break;
2815	case MSR_F10H_DECFG:	2815	case MSR_AMD64_DE_CFG:
2816	msr_info->data = svm->msr_decfg;	2816	msr_info->data = svm->msr_decfg;
2817	break;	2817	break;
2818	default:	2818	default:
@@ -3041,7 +3041,7 @@ static int svm_set_msr(struct kvm_vcpu vcpu, struct msr_data msr) · 222 unmodified lines
3041	case MSR_VM_IGNNE:	3041	case MSR_VM_IGNNE:
3042	vcpu_unimpl(vcpu, "unimplemented wrmsr: 0x%x data 0x%llx\n", ecx, data);	3042	vcpu_unimpl(vcpu, "unimplemented wrmsr: 0x%x data 0x%llx\n", ecx, data);
3043	break;	3043	break;
3044	case MSR_F10H_DECFG: {	3044	case MSR_AMD64_DE_CFG: {
3045	struct kvm_msr_entry msr_entry;	3045	struct kvm_msr_entry msr_entry;
3046		3046
3047	msr_entry.index = msr->index;	3047	msr_entry.index = msr->index;

arch/x86/kvm/x86.c+1−1

@@ -1557,7 +1557,7 @@ static const u32 msr_based_features_all[] = { · 1556 unmodified lines
1557	MSR_IA32_VMX_EPT_VPID_CAP,	1557	MSR_IA32_VMX_EPT_VPID_CAP,
1558	MSR_IA32_VMX_VMFUNC,	1558	MSR_IA32_VMX_VMFUNC,
1559		1559
1560	MSR_F10H_DECFG,	1560	MSR_AMD64_DE_CFG,
1561	MSR_IA32_UCODE_REV,	1561	MSR_IA32_UCODE_REV,
1562	MSR_IA32_ARCH_CAPABILITIES,	1562	MSR_IA32_ARCH_CAPABILITIES,
1563	MSR_IA32_PERF_CAPABILITIES,	1563	MSR_IA32_PERF_CAPABILITIES,

arch/x86/net/bpf_jit_comp.c+0−13

@@ -11,7 +11,6 @@ · 10 unmodified lines
11	#include <linux/bpf.h>	11	#include <linux/bpf.h>
12	#include <linux/memory.h>	12	#include <linux/memory.h>
13	#include <linux/sort.h>	13	#include <linux/sort.h>
14	#include <linux/init.h>
15	#include <asm/extable.h>	14	#include <asm/extable.h>
16	#include <asm/set_memory.h>	15	#include <asm/set_memory.h>
17	#include <asm/nospec-branch.h>	16	#include <asm/nospec-branch.h>
@@ -389,18 +388,6 @@ out: · 371 unmodified lines
389	return ret;	388	return ret;
390	}	389	}
391		390
392	int __init bpf_arch_init_dispatcher_early(void *ip)
393	{
394	const u8 *nop_insn = x86_nops[5];
395
396	if (is_endbr((u32 )ip))
397	ip += ENDBR_INSN_SIZE;
398
399	if (memcmp(ip, nop_insn, X86_PATCH_SIZE))
400	text_poke_early(ip, nop_insn, X86_PATCH_SIZE);
401	return 0;
402	}
403
404	int bpf_arch_text_poke(void *ip, enum bpf_text_poke_type t,	391	int bpf_arch_text_poke(void *ip, enum bpf_text_poke_type t,
405	void old_addr, void new_addr)	392	void old_addr, void new_addr)
406	{	393	{

arch/x86/power/cpu.c+1−0

@@ -519,6 +519,7 @@ static void pm_save_spec_msr(void) · 518 unmodified lines
519	MSR_TSX_FORCE_ABORT,	519	MSR_TSX_FORCE_ABORT,
520	MSR_IA32_MCU_OPT_CTRL,	520	MSR_IA32_MCU_OPT_CTRL,
521	MSR_AMD64_LS_CFG,	521	MSR_AMD64_LS_CFG,
		522	MSR_AMD64_DE_CFG,
522	};	523	};
523		524
524	msr_build_context(spec_msr_id, ARRAY_SIZE(spec_msr_id));	525	msr_build_context(spec_msr_id, ARRAY_SIZE(spec_msr_id));

arch/x86/xen/enlighten_pv.c+2−1

 #include <linux/start_kernel.h>
 #include <linux/sched.h>
 #include <linux/kprobes.h>
+#include <linux/kstrtox.h>
 #include <linux/memblock.h>
 #include <linux/export.h>
 #include <linux/mm.h>
 static int __init parse_xen_msr_safe(char *str)
 {
 	if (str)
-		return strtobool(str, &xen_msr_safe);
+		return kstrtobool(str, &xen_msr_safe);
 	return -EINVAL;
 }
 early_param("xen_msr_safe", parse_xen_msr_safe);

arch/x86/xen/setup.c+2−1

 #include <linux/init.h>
 #include <linux/sched.h>
+#include <linux/kstrtox.h>
 #include <linux/mm.h>
 #include <linux/pm.h>
 #include <linux/memblock.h>
 	arg = strstr(xen_start_info->cmd_line, "xen_512gb_limit=");
 	if (!arg)
 		val = true;
-	else if (strtobool(arg + strlen("xen_512gb_limit="), &val))
+	else if (kstrtobool(arg + strlen("xen_512gb_limit="), &val))
 		return;
 	xen_512gb_limit = val;

block/blk-cgroup.c+1−1

@@ -1213,7 +1213,7 @@ static int blkcg_css_online(struct cgroup_subsys_state *css) · 1212 unmodified lines
1213	* parent so that offline always happens towards the root.	1213	* parent so that offline always happens towards the root.
1214	*/	1214	*/
1215	if (parent)	1215	if (parent)
1216	blkcg_pin_online(css);	1216	blkcg_pin_online(&parent->css);
1217	return 0;	1217	return 0;
1218	}	1218	}
1219		1219

block/blk-core.c+0−1

@@ -425,7 +425,6 @@ struct request_queue *blk_alloc_queue(int node_id, bool alloc_srcu) · 424 unmodified lines
425	PERCPU_REF_INIT_ATOMIC, GFP_KERNEL))	425	PERCPU_REF_INIT_ATOMIC, GFP_KERNEL))
426	goto fail_stats;	426	goto fail_stats;
427		427
428	blk_queue_dma_alignment(q, 511);
429	blk_set_default_limits(&q->limits);	428	blk_set_default_limits(&q->limits);
430	q->nr_requests = BLKDEV_DEFAULT_RQ;	429	q->nr_requests = BLKDEV_DEFAULT_RQ;
431		430

block/blk-settings.c+5−4

 	lim->misaligned = 0;
 	lim->zoned = BLK_ZONED_NONE;
 	lim->zone_write_granularity = 0;
+	lim->dma_alignment = 511;
 }
-EXPORT_SYMBOL(blk_set_default_limits);
 /**
  * blk_set_stacking_limits - set default limits for stacking devices
 	t->io_min = max(t->io_min, b->io_min);
 	t->io_opt = lcm_not_zero(t->io_opt, b->io_opt);
+	t->dma_alignment = max(t->dma_alignment, b->dma_alignment);
 	/* Set non-power-of-2 compatible chunk_sectors boundary */
 	if (b->chunk_sectors)
  **/
 void blk_queue_dma_alignment(struct request_queue *q, int mask)
 {
-	q->dma_alignment = mask;
+	q->limits.dma_alignment = mask;
 }
 EXPORT_SYMBOL(blk_queue_dma_alignment);
 {
 	BUG_ON(mask > PAGE_SIZE);
-	if (mask > q->dma_alignment)
+	if (mask > q->limits.dma_alignment)
-		q->dma_alignment = mask;
+		q->limits.dma_alignment = mask;
 }
 EXPORT_SYMBOL(blk_queue_update_dma_alignment);

block/blk.h+1−0

@@ -331,6 +331,7 @@ void blk_rq_set_mixed_merge(struct request *rq); · 330 unmodified lines
331	bool blk_rq_merge_ok(struct request rq, struct bio bio);	331	bool blk_rq_merge_ok(struct request rq, struct bio bio);
332	enum elv_merge blk_try_merge(struct request rq, struct bio bio);	332	enum elv_merge blk_try_merge(struct request rq, struct bio bio);
333		333
		334	void blk_set_default_limits(struct queue_limits *lim);
334	int blk_dev_init(void);	335	int blk_dev_init(void);
335		336
336	/*	337	/*

drivers/accessibility/speakup/main.c+1−1

@@ -1778,7 +1778,7 @@ static void speakup_con_update(struct vc_data *vc) · 1777 unmodified lines
1778	{	1778	{
1779	unsigned long flags;	1779	unsigned long flags;
1780		1780
1781	if (!speakup_console[vc->vc_num] \|\| spk_parked)	1781	if (!speakup_console[vc->vc_num] \|\| spk_parked \|\| !synth)
1782	return;	1782	return;
1783	if (!spin_trylock_irqsave(&speakup_info.spinlock, flags))	1783	if (!spin_trylock_irqsave(&speakup_info.spinlock, flags))
1784	/* Speakup output, discard */	1784	/* Speakup output, discard */

drivers/accessibility/speakup/utils.h+1−1

@@ -54,7 +54,7 @@ static inline int oops(const char msg, const char info) · 53 unmodified lines
54		54
55	static inline struct st_key hash_name(char name)	55	static inline struct st_key hash_name(char name)
56	{	56	{
57	u_char pn = (u_char )name;	57	unsigned char pn = (unsigned char )name;
58	int hash = 0;	58	int hash = 0;
59		59
60	while (*pn) {	60	while (*pn) {

drivers/android/binder_alloc.c+7−0

 	const char *failure_string;
 	struct binder_buffer *buffer;
+	if (unlikely(vma->vm_mm != alloc->mm)) {
+		ret = -EINVAL;
+		failure_string = "invalid vma->vm_mm";
+		goto err_invalid_mm;
+	}
 	mutex_lock(&binder_alloc_mmap_lock);
 	if (alloc->buffer_size) {
 		ret = -EBUSY;
 	alloc->buffer_size = 0;
 err_already_mapped:
 	mutex_unlock(&binder_alloc_mmap_lock);
+err_invalid_mm:
 	binder_alloc_debug(BINDER_DEBUG_USER_ERROR,
 			   "%s: %d %lx-%lx %s failed %d\n", __func__,
 			   alloc->pid, vma->vm_start, vma->vm_end,

drivers/block/drbd/drbd_main.c+2−2

@@ -2672,7 +2672,7 @@ static int init_submitter(struct drbd_device *device) · 2671 unmodified lines
2672	enum drbd_ret_code drbd_create_device(struct drbd_config_context *adm_ctx, unsigned int minor)	2672	enum drbd_ret_code drbd_create_device(struct drbd_config_context *adm_ctx, unsigned int minor)
2673	{	2673	{
2674	struct drbd_resource *resource = adm_ctx->resource;	2674	struct drbd_resource *resource = adm_ctx->resource;
2675	struct drbd_connection *connection;	2675	struct drbd_connection connection, n;
2676	struct drbd_device *device;	2676	struct drbd_device *device;
2677	struct drbd_peer_device peer_device, tmp_peer_device;	2677	struct drbd_peer_device peer_device, tmp_peer_device;
2678	struct gendisk *disk;	2678	struct gendisk *disk;
@@ -2789,7 +2789,7 @@ enum drbd_ret_code drbd_create_device(struct drbd_config_context *adm_ctx, unsig · 110 unmodified lines
2789	return NO_ERROR;	2789	return NO_ERROR;
2790		2790
2791	out_idr_remove_from_resource:	2791	out_idr_remove_from_resource:
2792	for_each_connection(connection, resource) {	2792	for_each_connection_safe(connection, n, resource) {
2793	peer_device = idr_remove(&connection->peer_devices, vnr);	2793	peer_device = idr_remove(&connection->peer_devices, vnr);
2794	if (peer_device)	2794	if (peer_device)
2795	kref_put(&connection->kref, drbd_destroy_connection);	2795	kref_put(&connection->kref, drbd_destroy_connection);

drivers/extcon/extcon-usbc-tusb320.c+7−1

@@ -327,7 +327,13 @@ static irqreturn_t tusb320_irq_handler(int irq, void *dev_id) · 326 unmodified lines
327	return IRQ_NONE;	327	return IRQ_NONE;
328		328
329	tusb320_extcon_irq_handler(priv, reg);	329	tusb320_extcon_irq_handler(priv, reg);
330	tusb320_typec_irq_handler(priv, reg);	330
		331	/*
		332	* Type-C support is optional. Only call the Type-C handler if a
		333	* port had been registered previously.
		334	*/
		335	if (priv->port)
		336	tusb320_typec_irq_handler(priv, reg);
331		337
332	regmap_write(priv->regmap, TUSB320_REG9, reg);	338	regmap_write(priv->regmap, TUSB320_REG9, reg);
333		339

drivers/firmware/google/coreboot_table.c+29−8

@@ -149,12 +149,8 @@ static int coreboot_table_probe(struct platform_device *pdev) · 148 unmodified lines
149	if (!ptr)	149	if (!ptr)
150	return -ENOMEM;	150	return -ENOMEM;
151		151
152	ret = bus_register(&coreboot_bus_type);	152	ret = coreboot_table_populate(dev, ptr);
153	if (!ret) {	153
154	ret = coreboot_table_populate(dev, ptr);
155	if (ret)
156	bus_unregister(&coreboot_bus_type);
157	}
158	memunmap(ptr);	154	memunmap(ptr);
159		155
160	return ret;	156	return ret;
@@ -169,7 +165,6 @@ static int __cb_dev_unregister(struct device dev, void dummy) · 8 unmodified lines
169	static int coreboot_table_remove(struct platform_device *pdev)	165	static int coreboot_table_remove(struct platform_device *pdev)
170	{	166	{
171	bus_for_each_dev(&coreboot_bus_type, NULL, NULL, __cb_dev_unregister);	167	bus_for_each_dev(&coreboot_bus_type, NULL, NULL, __cb_dev_unregister);
172	bus_unregister(&coreboot_bus_type);
173	return 0;	168	return 0;
174	}	169	}
175		170
@@ -199,6 +194,32 @@ static struct platform_driver coreboot_table_driver = { · 23 unmodified lines
199	.of_match_table = of_match_ptr(coreboot_of_match),	194	.of_match_table = of_match_ptr(coreboot_of_match),
200	},	195	},
201	};	196	};
202	module_platform_driver(coreboot_table_driver);	197
		198	static int __init coreboot_table_driver_init(void)
		199	{
		200	int ret;
		201
		202	ret = bus_register(&coreboot_bus_type);
		203	if (ret)
		204	return ret;
		205
		206	ret = platform_driver_register(&coreboot_table_driver);
		207	if (ret) {
		208	bus_unregister(&coreboot_bus_type);
		209	return ret;
		210	}
		211
		212	return 0;
		213	}
		214
		215	static void __exit coreboot_table_driver_exit(void)
		216	{
		217	platform_driver_unregister(&coreboot_table_driver);
		218	bus_unregister(&coreboot_bus_type);
		219	}
		220
		221	module_init(coreboot_table_driver_init);
		222	module_exit(coreboot_table_driver_exit);
		223
203	MODULE_AUTHOR("Google, Inc.");	224	MODULE_AUTHOR("Google, Inc.");
204	MODULE_LICENSE("GPL");	225	MODULE_LICENSE("GPL");

drivers/gpu/drm/amd/amdgpu/amdgpu.h+1−0

@@ -1293,6 +1293,7 @@ void amdgpu_device_pcie_port_wreg(struct amdgpu_device *adev, · 1292 unmodified lines
1293	u32 reg, u32 v);	1293	u32 reg, u32 v);
1294	struct dma_fence amdgpu_device_switch_gang(struct amdgpu_device adev,	1294	struct dma_fence amdgpu_device_switch_gang(struct amdgpu_device adev,
1295	struct dma_fence *gang);	1295	struct dma_fence *gang);
		1296	bool amdgpu_device_has_display_hardware(struct amdgpu_device *adev);
1296		1297
1297	/* atpx handler */	1298	/* atpx handler */
1298	#if defined(CONFIG_VGA_SWITCHEROO)	1299	#if defined(CONFIG_VGA_SWITCHEROO)

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c+1−3

 	    (kfd_mem_limit.ttm_mem_used + ttm_mem_needed >
 	     kfd_mem_limit.max_ttm_mem_limit) ||
 	    (adev && adev->kfd.vram_used + vram_needed >
-	     adev->gmc.real_vram_size -
+	     adev->gmc.real_vram_size - reserved_for_pt)) {
-	     atomic64_read(&adev->vram_pin_size) -
-	     reserved_for_pt)) {
 		ret = -ENOMEM;
 		goto release;
 	}

drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c+20−9

 		return r;
 	++(num_ibs[r]);
+	p->gang_leader_idx = r;
 	return 0;
 }
 		}
 	}
-	if (!p->gang_size)
+	if (!p->gang_size) {
-		return -EINVAL;
+		ret = -EINVAL;
+		goto free_partial_kdata;
+	}
 	for (i = 0; i < p->gang_size; ++i) {
 		ret = amdgpu_job_alloc(p->adev, num_ibs[i], &p->jobs[i], vm);
 		if (ret)
 			goto free_all_kdata;
 	}
-	p->gang_leader = p->jobs[p->gang_size - 1];
+	p->gang_leader = p->jobs[p->gang_leader_idx];
 	if (p->ctx->vram_lost_counter != p->gang_leader->vram_lost_counter) {
 		ret = -ECANCELED;
 			return r;
 	}
-	for (i = 0; i < p->gang_size - 1; ++i) {
+	for (i = 0; i < p->gang_size; ++i) {
+		if (p->jobs[i] == leader)
+			continue;
 		r = amdgpu_sync_clone(&leader->sync, &p->jobs[i]->sync);
 		if (r)
 			return r;
 	}
-	r = amdgpu_ctx_wait_prev_fence(p->ctx, p->entities[p->gang_size - 1]);
+	r = amdgpu_ctx_wait_prev_fence(p->ctx, p->entities[p->gang_leader_idx]);
 	if (r && r != -ERESTARTSYS)
 		DRM_ERROR("amdgpu_ctx_wait_prev_fence failed.\n");
 	return r;
 }
 	for (i = 0; i < p->gang_size; ++i)
 		drm_sched_job_arm(&p->jobs[i]->base);
-	for (i = 0; i < (p->gang_size - 1); ++i) {
+	for (i = 0; i < p->gang_size; ++i) {
 		struct dma_fence *fence;
+		if (p->jobs[i] == leader)
+			continue;
 		fence = &p->jobs[i]->base.s_fence->scheduled;
 		r = amdgpu_sync_fence(&leader->sync, fence);
 		if (r)
 	list_for_each_entry(e, &p->validated, tv.head) {
 		/* Everybody except for the gang leader uses READ */
-		for (i = 0; i < (p->gang_size - 1); ++i) {
+		for (i = 0; i < p->gang_size; ++i) {
+			if (p->jobs[i] == leader)
+				continue;
 			dma_resv_add_fence(e->tv.bo->base.resv,
 					   &p->jobs[i]->base.s_fence->finished,
 					   DMA_RESV_USAGE_READ);
 		e->tv.num_shared = 0;
 	}
-	seq = amdgpu_ctx_add_fence(p->ctx, p->entities[p->gang_size - 1],
+	seq = amdgpu_ctx_add_fence(p->ctx, p->entities[p->gang_leader_idx],
 				   p->fence);
 	amdgpu_cs_post_dependencies(p);

drivers/gpu/drm/amd/amdgpu/amdgpu_cs.h+1−0

@@ -54,6 +54,7 @@ struct amdgpu_cs_parser { · 53 unmodified lines
54		54
55	/* scheduler job objects */	55	/* scheduler job objects */
56	unsigned int gang_size;	56	unsigned int gang_size;
		57	unsigned int gang_leader_idx;
57	struct drm_sched_entity *entities[AMDGPU_CS_GANG_SIZE];	58	struct drm_sched_entity *entities[AMDGPU_CS_GANG_SIZE];
58	struct amdgpu_job *jobs[AMDGPU_CS_GANG_SIZE];	59	struct amdgpu_job *jobs[AMDGPU_CS_GANG_SIZE];
59	struct amdgpu_job *gang_leader;	60	struct amdgpu_job *gang_leader;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c+41−0

@@ -6044,3 +6044,44 @@ struct dma_fence amdgpu_device_switch_gang(struct amdgpu_device adev, · 6043 unmodified lines
6044	dma_fence_put(old);	6044	dma_fence_put(old);
6045	return NULL;	6045	return NULL;
6046	}	6046	}
		6047
		6048	bool amdgpu_device_has_display_hardware(struct amdgpu_device *adev)
		6049	{
		6050	switch (adev->asic_type) {
		6051	#ifdef CONFIG_DRM_AMDGPU_SI
		6052	case CHIP_HAINAN:
		6053	#endif
		6054	case CHIP_TOPAZ:
		6055	/* chips with no display hardware */
		6056	return false;
		6057	#ifdef CONFIG_DRM_AMDGPU_SI
		6058	case CHIP_TAHITI:
		6059	case CHIP_PITCAIRN:
		6060	case CHIP_VERDE:
		6061	case CHIP_OLAND:
		6062	#endif
		6063	#ifdef CONFIG_DRM_AMDGPU_CIK
		6064	case CHIP_BONAIRE:
		6065	case CHIP_HAWAII:
		6066	case CHIP_KAVERI:
		6067	case CHIP_KABINI:
		6068	case CHIP_MULLINS:
		6069	#endif
		6070	case CHIP_TONGA:
		6071	case CHIP_FIJI:
		6072	case CHIP_POLARIS10:
		6073	case CHIP_POLARIS11:
		6074	case CHIP_POLARIS12:
		6075	case CHIP_VEGAM:
		6076	case CHIP_CARRIZO:
		6077	case CHIP_STONEY:
		6078	/* chips with display hardware */
		6079	return true;
		6080	default:
		6081	/* IP discovery */
		6082	if (!adev->ip_versions[DCE_HWIP][0] \|\|
		6083	(adev->harvest_ip_mask & AMD_HARVEST_IP_DMU_MASK))
		6084	return false;
		6085	return true;
		6086	}
		6087	}

drivers/gpu/drm/amd/amdgpu/amdgpu_gmc.c+1−1

@@ -656,7 +656,7 @@ void amdgpu_gmc_get_vbios_allocations(struct amdgpu_device *adev) · 655 unmodified lines
656	}	656	}
657		657
658	if (amdgpu_sriov_vf(adev) \|\|	658	if (amdgpu_sriov_vf(adev) \|\|
659	!amdgpu_device_ip_get_ip_block(adev, AMD_IP_BLOCK_TYPE_DCE)) {	659	!amdgpu_device_has_display_hardware(adev)) {
660	size = 0;	660	size = 0;
661	} else {	661	} else {
662	size = amdgpu_gmc_get_vbios_fb_size(adev);	662	size = amdgpu_gmc_get_vbios_fb_size(adev);

drivers/gpu/drm/amd/amdgpu/psp_v13_0.c+1−0

@@ -45,6 +45,7 @@ MODULE_FIRMWARE("amdgpu/psp_13_0_0_ta.bin"); · 44 unmodified lines
45	MODULE_FIRMWARE("amdgpu/psp_13_0_7_sos.bin");	45	MODULE_FIRMWARE("amdgpu/psp_13_0_7_sos.bin");
46	MODULE_FIRMWARE("amdgpu/psp_13_0_7_ta.bin");	46	MODULE_FIRMWARE("amdgpu/psp_13_0_7_ta.bin");
47	MODULE_FIRMWARE("amdgpu/psp_13_0_10_sos.bin");	47	MODULE_FIRMWARE("amdgpu/psp_13_0_10_sos.bin");
		48	MODULE_FIRMWARE("amdgpu/psp_13_0_10_ta.bin");
48		49
49	/* For large FW files the time to complete can be very long */	50	/* For large FW files the time to complete can be very long */
50	#define USBC_PD_POLLING_LIMIT_S 240	51	#define USBC_PD_POLLING_LIMIT_S 240

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c+26−6

 /* Number of bytes in PSP footer for firmware. */
 #define PSP_FOOTER_BYTES 0x100
+/*
+ * DMUB Async to Sync Mechanism Status
+ */
+#define DMUB_ASYNC_TO_SYNC_ACCESS_FAIL 1
+#define DMUB_ASYNC_TO_SYNC_ACCESS_TIMEOUT 2
+#define DMUB_ASYNC_TO_SYNC_ACCESS_SUCCESS 3
+#define DMUB_ASYNC_TO_SYNC_ACCESS_INVALID 4
 /**
  * DOC: overview
  *
 		}
 	}
-	if (amdgpu_dm_initialize_drm_device(adev)) {
-		DRM_ERROR(
-		"amdgpu: failed to initialize sw for display support.\n");
-		goto error;
-	}
 	/* Enable outbox notification only after IRQ handlers are registered and DMUB is alive.
 	 * It is expected that DMUB will resend any pending notifications at this point, for
 	 * example HPD from DPIA.
 	if (dc_is_dmub_outbox_supported(adev->dm.dc))
 		dc_enable_dmub_outbox(adev->dm.dc);
+	if (amdgpu_dm_initialize_drm_device(adev)) {
+		DRM_ERROR(
+		"amdgpu: failed to initialize sw for display support.\n");
+		goto error;
+	}
 	/* create fake encoders for MST */
 	dm_dp_create_fake_mst_encoders(adev);
 			*operation_result = AUX_RET_ERROR_TIMEOUT;
 		} else if (status_type == DMUB_ASYNC_TO_SYNC_ACCESS_FAIL) {
 			*operation_result = AUX_RET_ERROR_ENGINE_ACQUIRE;
+		} else if (status_type == DMUB_ASYNC_TO_SYNC_ACCESS_INVALID) {
+			*operation_result = AUX_RET_ERROR_INVALID_REPLY;
 		} else {
 			*operation_result = AUX_RET_ERROR_UNKNOWN;
 		}
 			payload->reply[0] = adev->dm.dmub_notify->aux_reply.command;
 			if (!payload->write && adev->dm.dmub_notify->aux_reply.length &&
 			    payload->reply[0] == AUX_TRANSACTION_REPLY_AUX_ACK) {
+				if (payload->length != adev->dm.dmub_notify->aux_reply.length) {
+					DRM_WARN("invalid read from DPIA AUX %x(%d) got length %d!\n",
+							payload->address, payload->length,
+							adev->dm.dmub_notify->aux_reply.length);
+					return amdgpu_dm_set_dmub_async_sync_status(is_cmd_aux, ctx,
+							DMUB_ASYNC_TO_SYNC_ACCESS_INVALID,
+							(uint32_t *)operation_result);
+				}
 				memcpy(payload->data, adev->dm.dmub_notify->aux_reply.data,
 				       adev->dm.dmub_notify->aux_reply.length);
 			}

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.h+0−6

 #define AMDGPU_DMUB_NOTIFICATION_MAX 5
-/*
- * DMUB Async to Sync Mechanism Status
- */
-#define DMUB_ASYNC_TO_SYNC_ACCESS_FAIL 1
-#define DMUB_ASYNC_TO_SYNC_ACCESS_TIMEOUT 2
-#define DMUB_ASYNC_TO_SYNC_ACCESS_SUCCESS 3
 /*
 #include "include/amdgpu_dal_power_if.h"
 #include "amdgpu_dm_irq.h"

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crtc.c+8−2

@@ -412,7 +412,7 @@ int amdgpu_dm_crtc_init(struct amdgpu_display_manager *dm, · 411 unmodified lines
412	{	412	{
413	struct amdgpu_crtc *acrtc = NULL;	413	struct amdgpu_crtc *acrtc = NULL;
414	struct drm_plane *cursor_plane;	414	struct drm_plane *cursor_plane;
415		415	bool is_dcn;
416	int res = -ENOMEM;	416	int res = -ENOMEM;
417		417
418	cursor_plane = kzalloc(sizeof(*cursor_plane), GFP_KERNEL);	418	cursor_plane = kzalloc(sizeof(*cursor_plane), GFP_KERNEL);
@@ -450,8 +450,14 @@ int amdgpu_dm_crtc_init(struct amdgpu_display_manager *dm, · 31 unmodified lines
450	acrtc->otg_inst = -1;	450	acrtc->otg_inst = -1;
451		451
452	dm->adev->mode_info.crtcs[crtc_index] = acrtc;	452	dm->adev->mode_info.crtcs[crtc_index] = acrtc;
453	drm_crtc_enable_color_mgmt(&acrtc->base, MAX_COLOR_LUT_ENTRIES,	453
		454	/* Don't enable DRM CRTC degamma property for DCE since it doesn't
		455	* support programmable degamma anywhere.
		456	*/
		457	is_dcn = dm->adev->dm.dc->caps.color.dpp.dcn_arch;
		458	drm_crtc_enable_color_mgmt(&acrtc->base, is_dcn ? MAX_COLOR_LUT_ENTRIES : 0,
454	true, MAX_COLOR_LUT_ENTRIES);	459	true, MAX_COLOR_LUT_ENTRIES);
		460
455	drm_mode_crtc_set_gamma_size(&acrtc->base, MAX_COLOR_LEGACY_LUT_ENTRIES);	461	drm_mode_crtc_set_gamma_size(&acrtc->base, MAX_COLOR_LEGACY_LUT_ENTRIES);
456		462
457	return 0;	463	return 0;

drivers/gpu/drm/amd/display/dc/bios/bios_parser2.c+30−0

@@ -2393,6 +2393,26 @@ static enum bp_result get_vram_info_v25( · 2392 unmodified lines
2393	return result;	2393	return result;
2394	}	2394	}
2395		2395
		2396	static enum bp_result get_vram_info_v30(
		2397	struct bios_parser *bp,
		2398	struct dc_vram_info *info)
		2399	{
		2400	struct atom_vram_info_header_v3_0 *info_v30;
		2401	enum bp_result result = BP_RESULT_OK;
		2402
		2403	info_v30 = GET_IMAGE(struct atom_vram_info_header_v3_0,
		2404	DATA_TABLES(vram_info));
		2405
		2406	if (info_v30 == NULL)
		2407	return BP_RESULT_BADBIOSTABLE;
		2408
		2409	info->num_chans = info_v30->channel_num;
		2410	info->dram_channel_width_bytes = (1 << info_v30->channel_width) / 8;
		2411
		2412	return result;
		2413	}
		2414
		2415
2396	/*	2416	/*
2397	* get_integrated_info_v11	2417	* get_integrated_info_v11
2398	*	2418	*
@@ -3060,6 +3080,16 @@ static enum bp_result bios_parser_get_vram_info( · 661 unmodified lines
3060	}	3080	}
3061	break;	3081	break;
3062		3082
		3083	case 3:
		3084	switch (revision.minor) {
		3085	case 0:
		3086	result = get_vram_info_v30(bp, info);
		3087	break;
		3088	default:
		3089	break;
		3090	}
		3091	break;
		3092
3063	default:	3093	default:
3064	return result;	3094	return result;
3065	}	3095	}

drivers/gpu/drm/amd/display/dc/dcn31/dcn31_hubp.c+1−0

@@ -87,6 +87,7 @@ static struct hubp_funcs dcn31_hubp_funcs = { · 86 unmodified lines
87	.hubp_init = hubp3_init,	87	.hubp_init = hubp3_init,
88	.set_unbounded_requesting = hubp31_set_unbounded_requesting,	88	.set_unbounded_requesting = hubp31_set_unbounded_requesting,
89	.hubp_soft_reset = hubp31_soft_reset,	89	.hubp_soft_reset = hubp31_soft_reset,
		90	.hubp_set_flip_int = hubp1_set_flip_int,
90	.hubp_in_blank = hubp1_in_blank,	91	.hubp_in_blank = hubp1_in_blank,
91	.program_extended_blank = hubp31_program_extended_blank,	92	.program_extended_blank = hubp31_program_extended_blank,
92	};	93	};

drivers/gpu/drm/amd/display/dc/dcn314/dcn314_optc.c+1−1

@@ -237,7 +237,7 @@ static struct timing_generator_funcs dcn314_tg_funcs = { · 236 unmodified lines
237	.clear_optc_underflow = optc1_clear_optc_underflow,	237	.clear_optc_underflow = optc1_clear_optc_underflow,
238	.setup_global_swap_lock = NULL,	238	.setup_global_swap_lock = NULL,
239	.get_crc = optc1_get_crc,	239	.get_crc = optc1_get_crc,
240	.configure_crc = optc2_configure_crc,	240	.configure_crc = optc1_configure_crc,
241	.set_dsc_config = optc3_set_dsc_config,	241	.set_dsc_config = optc3_set_dsc_config,
242	.get_dsc_status = optc2_get_dsc_status,	242	.get_dsc_status = optc2_get_dsc_status,
243	.set_dwb_source = NULL,	243	.set_dwb_source = NULL,

drivers/gpu/drm/amd/display/dc/dcn32/dcn32_hwseq.c+5−9

 			using the max for calculation */
 		if (hubp->curs_attr.width > 0) {
-				// Round cursor width to next multiple of 64
+				cursor_size = hubp->curs_attr.pitch * hubp->curs_attr.height;
-				cursor_size = (((hubp->curs_attr.width + 63) / 64) * 64) * hubp->curs_attr.height;
 				switch (pipe->stream->cursor_attributes.color_format) {
 				case CURSOR_MODE_MONO:
 						cursor_size > 16384) {
 					/* cursor_num_mblk = CEILING(num_cursors*cursor_width*cursor_width*cursor_Bpe/mblk_bytes, 1)
 					 */
-					cache_lines_used += (((hubp->curs_attr.width * hubp->curs_attr.height * cursor_bpp +
+					cache_lines_used += (((cursor_size + DCN3_2_MALL_MBLK_SIZE_BYTES - 1) /
-										DCN3_2_MALL_MBLK_SIZE_BYTES - 1) / DCN3_2_MALL_MBLK_SIZE_BYTES) *
+							DCN3_2_MALL_MBLK_SIZE_BYTES) * DCN3_2_MALL_MBLK_SIZE_BYTES) /
-										DCN3_2_MALL_MBLK_SIZE_BYTES) / dc->caps.cache_line_size + 2;
+							dc->caps.cache_line_size + 2;
 				}
 				break;
 			}
 		struct hubp *hubp = pipe->plane_res.hubp;
 		if (pipe->stream && pipe->plane_state && hubp && hubp->funcs->hubp_update_mall_sel) {
-			//Round cursor width up to next multiple of 64
+			int cursor_size = hubp->curs_attr.pitch * hubp->curs_attr.height;
-			int cursor_width = ((hubp->curs_attr.width + 63) / 64) * 64;
-			int cursor_height = hubp->curs_attr.height;
-			int cursor_size = cursor_width * cursor_height;
 			switch (hubp->curs_attr.color_format) {
 			case CURSOR_MODE_MONO:

drivers/gpu/drm/amd/display/dc/dml/dcn32/dcn32_fpu.c+15−1

 			 */
 			context->bw_ctx.dml.soc.dram_clock_change_latency_us =
 					dc->clk_mgr->bw_params->wm_table.nv_entries[WM_A].dml_input.pstate_latency_us;
+			/* For DCN32/321 need to validate with fclk pstate change latency equal to dummy so
+			 * prefetch is scheduled correctly to account for dummy pstate.
+			 */
+			if (dummy_latency_index == 0)
+				context->bw_ctx.dml.soc.fclk_change_latency_us =
+						dc->clk_mgr->bw_params->dummy_pstate_table[dummy_latency_index].dummy_pstate_latency_us;
 			dcn32_internal_validate_bw(dc, context, pipes, &pipe_cnt, &vlevel, false);
 			maxMpcComb = context->bw_ctx.dml.vba.maxMpcComb;
 			dcfclk_from_fw_based_mclk_switching = context->bw_ctx.dml.vba.DCFCLKState[vlevel][context->bw_ctx.dml.vba.maxMpcComb];
 	context->perf_params.stutter_period_us = context->bw_ctx.dml.vba.StutterPeriod;
+	if (context->bw_ctx.bw.dcn.clk.fw_based_mclk_switching && dummy_latency_index == 0)
+		context->bw_ctx.dml.soc.fclk_change_latency_us =
+				dc->clk_mgr->bw_params->dummy_pstate_table[dummy_latency_index].dummy_pstate_latency_us;
 	dcn32_calculate_dlg_params(dc, context, pipes, pipe_cnt, vlevel);
 	if (!pstate_en)
 		context->bw_ctx.dml.soc.dram_clock_change_latency_us =
 				dc->clk_mgr->bw_params->wm_table.nv_entries[WM_A].dml_input.pstate_latency_us;
-	if (context->bw_ctx.bw.dcn.clk.fw_based_mclk_switching)
+	if (context->bw_ctx.bw.dcn.clk.fw_based_mclk_switching) {
 		dcn30_setup_mclk_switch_using_fw_based_vblank_stretch(dc, context);
+		if (dummy_latency_index == 0)
+			context->bw_ctx.dml.soc.fclk_change_latency_us =
+					dc->clk_mgr->bw_params->wm_table.nv_entries[WM_A].dml_input.fclk_change_latency_us;
+	}
 }
 static void dcn32_get_optimal_dcfclk_fclk_for_uclk(unsigned int uclk_mts,

drivers/gpu/drm/amd/display/dc/dml/dcn32/display_mode_vba_32.c+2−0

@@ -718,6 +718,8 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman · 717 unmodified lines
718		718
719	do {	719	do {
720	MaxTotalRDBandwidth = 0;	720	MaxTotalRDBandwidth = 0;
		721	DestinationLineTimesForPrefetchLessThan2 = false;
		722	VRatioPrefetchMoreThanMax = false;
721	#ifdef __DML_VBA_DEBUG__	723	#ifdef __DML_VBA_DEBUG__
722	dml_print("DML::%s: Start loop: VStartup = %d\n", __func__, mode_lib->vba.VStartupLines);	724	dml_print("DML::%s: Start loop: VStartup = %d\n", __func__, mode_lib->vba.VStartupLines);
723	#endif	725	#endif

drivers/gpu/drm/amd/display/dc/dml/dcn32/display_mode_vba_32.h+2−0

@@ -46,6 +46,8 @@ · 45 unmodified lines
46	// Prefetch schedule max vratio	46	// Prefetch schedule max vratio
47	#define __DML_MAX_VRATIO_PRE__ 4.0	47	#define __DML_MAX_VRATIO_PRE__ 4.0
48		48
		49	#define __DML_VBA_MAX_DST_Y_PRE__ 63.75
		50
49	#define BPP_INVALID 0	51	#define BPP_INVALID 0
50	#define BPP_BLENDED_PIPE 0xffffffff	52	#define BPP_BLENDED_PIPE 0xffffffff
51		53

drivers/gpu/drm/amd/display/dc/dml/dcn32/display_mode_vba_util_32.c+3−4

 	double  min_Lsw;
 	double  Tsw_est1 = 0;
 	double  Tsw_est3 = 0;
-	double  TPreMargin = 0;
 	if (v->GPUVMEnable == true && v->HostVMEnable == true)
 		HostVMDynamicLevelsTrips = v->HostVMMaxNonCachedPageTableLevels;
 	dst_y_prefetch_equ = VStartup - (*TSetup + dml_max(TWait + TCalc, *Tdmdl)) / LineTime -
 			(*DSTYAfterScaler + (double) *DSTXAfterScaler / (double) myPipe->HTotal);
+	dst_y_prefetch_equ = dml_min(dst_y_prefetch_equ, __DML_VBA_MAX_DST_Y_PRE__);
 #ifdef __DML_VBA_DEBUG__
 	dml_print("DML::%s: HTotal = %d\n", __func__, myPipe->HTotal);
 	dml_print("DML::%s: min_Lsw = %f\n", __func__, min_Lsw);
 	dst_y_prefetch_equ = dml_floor(4.0 * (dst_y_prefetch_equ + 0.125), 1) / 4.0;
 	Tpre_rounded = dst_y_prefetch_equ * LineTime;
-	TPreMargin = Tpre_rounded - TPreReq;
 #ifdef __DML_VBA_DEBUG__
 	dml_print("DML::%s: dst_y_prefetch_equ: %f (after round)\n", __func__, dst_y_prefetch_equ);
 	dml_print("DML::%s: LineTime: %f\n", __func__, LineTime);
 	*VRatioPrefetchY = 0;
 	*VRatioPrefetchC = 0;
 	*RequiredPrefetchPixDataBWLuma = 0;
-	if (dst_y_prefetch_equ > 1 && TPreMargin > 0.0) {
+	if (dst_y_prefetch_equ > 1 &&
+			(Tpre_rounded >= TPreReq || dst_y_prefetch_equ == __DML_VBA_MAX_DST_Y_PRE__)) {
 		double PrefetchBandwidth1;
 		double PrefetchBandwidth2;
 		double PrefetchBandwidth3;

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c+11−12

@@ -1156,22 +1156,21 @@ static int smu_smc_hw_setup(struct smu_context *smu) · 1155 unmodified lines
1156	uint64_t features_supported;	1156	uint64_t features_supported;
1157	int ret = 0;	1157	int ret = 0;
1158		1158
1159	if (adev->in_suspend && smu_is_dpm_running(smu)) {	1159	switch (adev->ip_versions[MP1_HWIP][0]) {
1160	dev_info(adev->dev, "dpm has been enabled\n");	1160	case IP_VERSION(11, 0, 7):
1161	/* this is needed specifically */	1161	case IP_VERSION(11, 0, 11):
1162	switch (adev->ip_versions[MP1_HWIP][0]) {	1162	case IP_VERSION(11, 5, 0):
1163	case IP_VERSION(11, 0, 7):	1163	case IP_VERSION(11, 0, 12):
1164	case IP_VERSION(11, 0, 11):	1164	if (adev->in_suspend && smu_is_dpm_running(smu)) {
1165	case IP_VERSION(11, 5, 0):	1165	dev_info(adev->dev, "dpm has been enabled\n");
1166	case IP_VERSION(11, 0, 12):
1167	ret = smu_system_features_control(smu, true);	1166	ret = smu_system_features_control(smu, true);
1168	if (ret)	1167	if (ret)
1169	dev_err(adev->dev, "Failed system features control!\n");	1168	dev_err(adev->dev, "Failed system features control!\n");
1170	break;	1169	return ret;
1171	default:
1172	break;
1173	}	1170	}
1174	return ret;	1171	break;
		1172	default:
		1173	break;
1175	}	1174	}
1176		1175
1177	ret = smu_init_display_count(smu, 0);	1176	ret = smu_init_display_count(smu, 0);

drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h+8−0

@@ -1388,6 +1388,14 @@ enum smu_cmn2asic_mapping_type { · 1387 unmodified lines
1388	CMN2ASIC_MAPPING_WORKLOAD,	1388	CMN2ASIC_MAPPING_WORKLOAD,
1389	};	1389	};
1390		1390
		1391	enum smu_baco_seq {
		1392	BACO_SEQ_BACO = 0,
		1393	BACO_SEQ_MSR,
		1394	BACO_SEQ_BAMACO,
		1395	BACO_SEQ_ULPS,
		1396	BACO_SEQ_COUNT,
		1397	};
		1398
1391	#define MSG_MAP(msg, index, valid_in_vf) \	1399	#define MSG_MAP(msg, index, valid_in_vf) \
1392	[SMU_MSG_##msg] = {1, (index), (valid_in_vf)}	1400	[SMU_MSG_##msg] = {1, (index), (valid_in_vf)}
1393		1401

drivers/gpu/drm/amd/pm/swsmu/inc/smu_v11_0.h+1−9

 	uint32_t	max_fast_ppt_limit;
 };
-enum smu_v11_0_baco_seq {
-	BACO_SEQ_BACO = 0,
-	BACO_SEQ_MSR,
-	BACO_SEQ_BAMACO,
-	BACO_SEQ_ULPS,
-	BACO_SEQ_COUNT,
-};
 #if defined(SWSMU_CODE_LAYER_L2) || defined(SWSMU_CODE_LAYER_L3)
 int smu_v11_0_init_microcode(struct smu_context *smu);
 int smu_v11_0_baco_exit(struct smu_context *smu);
 int smu_v11_0_baco_set_armd3_sequence(struct smu_context *smu,
-				      enum smu_v11_0_baco_seq baco_seq);
+				      enum smu_baco_seq baco_seq);
 int smu_v11_0_mode1_reset(struct smu_context *smu);

drivers/gpu/drm/amd/pm/swsmu/inc/smu_v13_0.h+3−8

 	enum smu_13_0_power_state power_state;
 };
-enum smu_v13_0_baco_seq {
-	BACO_SEQ_BACO = 0,
-	BACO_SEQ_MSR,
-	BACO_SEQ_BAMACO,
-	BACO_SEQ_ULPS,
-	BACO_SEQ_COUNT,
-};
 #if defined(SWSMU_CODE_LAYER_L2) || defined(SWSMU_CODE_LAYER_L3)
 int smu_v13_0_init_microcode(struct smu_context *smu);
 int smu_v13_0_get_max_sustainable_clocks_by_dc(struct smu_context *smu,
 					       struct pp_smu_nv_clock_table *max_clocks);
+int smu_v13_0_baco_set_armd3_sequence(struct smu_context *smu,
+				      enum smu_baco_seq baco_seq);
 bool smu_v13_0_baco_is_support(struct smu_context *smu);
 enum smu_baco_state smu_v13_0_baco_get_state(struct smu_context *smu);

drivers/gpu/drm/amd/pm/swsmu/smu11/sienna_cichlid_ppt.c+4−0

 		    ((adev->pdev->device == 0x73BF) &&
 		    (adev->pdev->revision == 0xCF)) ||
 		    ((adev->pdev->device == 0x7422) &&
+		    (adev->pdev->revision == 0x00)) ||
+		    ((adev->pdev->device == 0x73A3) &&
+		    (adev->pdev->revision == 0x00)) ||
+		    ((adev->pdev->device == 0x73E3) &&
 		    (adev->pdev->revision == 0x00)))
 			smu_baco->platform_support = false;

drivers/gpu/drm/amd/pm/swsmu/smu11/smu_v11_0.c+1−1

@@ -1576,7 +1576,7 @@ int smu_v11_0_set_azalia_d3_pme(struct smu_context *smu) · 1575 unmodified lines
1576	}	1576	}
1577		1577
1578	int smu_v11_0_baco_set_armd3_sequence(struct smu_context *smu,	1578	int smu_v11_0_baco_set_armd3_sequence(struct smu_context *smu,
1579	enum smu_v11_0_baco_seq baco_seq)	1579	enum smu_baco_seq baco_seq)
1580	{	1580	{
1581	return smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_ArmD3, baco_seq, NULL);	1581	return smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_ArmD3, baco_seq, NULL);
1582	}	1582	}

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0.c+9−0

@@ -2230,6 +2230,15 @@ int smu_v13_0_gfx_ulv_control(struct smu_context *smu, · 2229 unmodified lines
2230	return ret;	2230	return ret;
2231	}	2231	}
2232		2232
		2233	int smu_v13_0_baco_set_armd3_sequence(struct smu_context *smu,
		2234	enum smu_baco_seq baco_seq)
		2235	{
		2236	return smu_cmn_send_smc_msg_with_param(smu,
		2237	SMU_MSG_ArmD3,
		2238	baco_seq,
		2239	NULL);
		2240	}
		2241
2233	bool smu_v13_0_baco_is_support(struct smu_context *smu)	2242	bool smu_v13_0_baco_is_support(struct smu_context *smu)
2234	{	2243	{
2235	struct smu_baco_context *smu_baco = &smu->smu_baco;	2244	struct smu_baco_context *smu_baco = &smu->smu_baco;

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_0_ppt.c+28−2

@@ -120,6 +120,7 @@ static struct cmn2asic_msg_mapping smu_v13_0_0_message_map[SMU_MSG_MAX_COUNT] = · 119 unmodified lines
120	MSG_MAP(Mode1Reset, PPSMC_MSG_Mode1Reset, 0),	120	MSG_MAP(Mode1Reset, PPSMC_MSG_Mode1Reset, 0),
121	MSG_MAP(PrepareMp1ForUnload, PPSMC_MSG_PrepareMp1ForUnload, 0),	121	MSG_MAP(PrepareMp1ForUnload, PPSMC_MSG_PrepareMp1ForUnload, 0),
122	MSG_MAP(DFCstateControl, PPSMC_MSG_SetExternalClientDfCstateAllow, 0),	122	MSG_MAP(DFCstateControl, PPSMC_MSG_SetExternalClientDfCstateAllow, 0),
		123	MSG_MAP(ArmD3, PPSMC_MSG_ArmD3, 0),
123	};	124	};
124		125
125	static struct cmn2asic_mapping smu_v13_0_0_clk_map[SMU_CLK_COUNT] = {	126	static struct cmn2asic_mapping smu_v13_0_0_clk_map[SMU_CLK_COUNT] = {
@@ -1566,6 +1567,31 @@ static int smu_v13_0_0_set_power_profile_mode(struct smu_context *smu, · 1440 unmodified lines
1566	NULL);	1567	NULL);
1567	}	1568	}
1568		1569
		1570	static int smu_v13_0_0_baco_enter(struct smu_context *smu)
		1571	{
		1572	struct smu_baco_context *smu_baco = &smu->smu_baco;
		1573	struct amdgpu_device *adev = smu->adev;
		1574
		1575	if (adev->in_runpm && smu_cmn_is_audio_func_enabled(adev))
		1576	return smu_v13_0_baco_set_armd3_sequence(smu,
		1577	smu_baco->maco_support ? BACO_SEQ_BAMACO : BACO_SEQ_BACO);
		1578	else
		1579	return smu_v13_0_baco_enter(smu);
		1580	}
		1581
		1582	static int smu_v13_0_0_baco_exit(struct smu_context *smu)
		1583	{
		1584	struct amdgpu_device *adev = smu->adev;
		1585
		1586	if (adev->in_runpm && smu_cmn_is_audio_func_enabled(adev)) {
		1587	/* Wait for PMFW handling for the Dstate change */
		1588	usleep_range(10000, 11000);
		1589	return smu_v13_0_baco_set_armd3_sequence(smu, BACO_SEQ_ULPS);
		1590	} else {
		1591	return smu_v13_0_baco_exit(smu);
		1592	}
		1593	}
		1594
1569	static bool smu_v13_0_0_is_mode1_reset_supported(struct smu_context *smu)	1595	static bool smu_v13_0_0_is_mode1_reset_supported(struct smu_context *smu)
1570	{	1596	{
1571	struct amdgpu_device *adev = smu->adev;	1597	struct amdgpu_device *adev = smu->adev;
@@ -1827,8 +1853,8 @@ static const struct pptable_funcs smu_v13_0_0_ppt_funcs = { · 255 unmodified lines
1827	.baco_is_support = smu_v13_0_baco_is_support,	1853	.baco_is_support = smu_v13_0_baco_is_support,
1828	.baco_get_state = smu_v13_0_baco_get_state,	1854	.baco_get_state = smu_v13_0_baco_get_state,
1829	.baco_set_state = smu_v13_0_baco_set_state,	1855	.baco_set_state = smu_v13_0_baco_set_state,
1830	.baco_enter = smu_v13_0_baco_enter,	1856	.baco_enter = smu_v13_0_0_baco_enter,
1831	.baco_exit = smu_v13_0_baco_exit,	1857	.baco_exit = smu_v13_0_0_baco_exit,
1832	.mode1_reset_is_support = smu_v13_0_0_is_mode1_reset_supported,	1858	.mode1_reset_is_support = smu_v13_0_0_is_mode1_reset_supported,
1833	.mode1_reset = smu_v13_0_mode1_reset,	1859	.mode1_reset = smu_v13_0_mode1_reset,
1834	.set_mp1_state = smu_v13_0_0_set_mp1_state,	1860	.set_mp1_state = smu_v13_0_0_set_mp1_state,

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_7_ppt.c+28−2

@@ -122,6 +122,7 @@ static struct cmn2asic_msg_mapping smu_v13_0_7_message_map[SMU_MSG_MAX_COUNT] = · 121 unmodified lines
122	MSG_MAP(PrepareMp1ForUnload, PPSMC_MSG_PrepareMp1ForUnload, 0),	122	MSG_MAP(PrepareMp1ForUnload, PPSMC_MSG_PrepareMp1ForUnload, 0),
123	MSG_MAP(SetMGpuFanBoostLimitRpm, PPSMC_MSG_SetMGpuFanBoostLimitRpm, 0),	123	MSG_MAP(SetMGpuFanBoostLimitRpm, PPSMC_MSG_SetMGpuFanBoostLimitRpm, 0),
124	MSG_MAP(DFCstateControl, PPSMC_MSG_SetExternalClientDfCstateAllow, 0),	124	MSG_MAP(DFCstateControl, PPSMC_MSG_SetExternalClientDfCstateAllow, 0),
		125	MSG_MAP(ArmD3, PPSMC_MSG_ArmD3, 0),
125	};	126	};
126		127
127	static struct cmn2asic_mapping smu_v13_0_7_clk_map[SMU_CLK_COUNT] = {	128	static struct cmn2asic_mapping smu_v13_0_7_clk_map[SMU_CLK_COUNT] = {
@@ -1578,6 +1579,31 @@ static int smu_v13_0_7_set_mp1_state(struct smu_context *smu, · 1450 unmodified lines
1578	return ret;	1579	return ret;
1579	}	1580	}
1580		1581
		1582	static int smu_v13_0_7_baco_enter(struct smu_context *smu)
		1583	{
		1584	struct smu_baco_context *smu_baco = &smu->smu_baco;
		1585	struct amdgpu_device *adev = smu->adev;
		1586
		1587	if (adev->in_runpm && smu_cmn_is_audio_func_enabled(adev))
		1588	return smu_v13_0_baco_set_armd3_sequence(smu,
		1589	smu_baco->maco_support ? BACO_SEQ_BAMACO : BACO_SEQ_BACO);
		1590	else
		1591	return smu_v13_0_baco_enter(smu);
		1592	}
		1593
		1594	static int smu_v13_0_7_baco_exit(struct smu_context *smu)
		1595	{
		1596	struct amdgpu_device *adev = smu->adev;
		1597
		1598	if (adev->in_runpm && smu_cmn_is_audio_func_enabled(adev)) {
		1599	/* Wait for PMFW handling for the Dstate change */
		1600	usleep_range(10000, 11000);
		1601	return smu_v13_0_baco_set_armd3_sequence(smu, BACO_SEQ_ULPS);
		1602	} else {
		1603	return smu_v13_0_baco_exit(smu);
		1604	}
		1605	}
		1606
1581	static bool smu_v13_0_7_is_mode1_reset_supported(struct smu_context *smu)	1607	static bool smu_v13_0_7_is_mode1_reset_supported(struct smu_context *smu)
1582	{	1608	{
1583	struct amdgpu_device *adev = smu->adev;	1609	struct amdgpu_device *adev = smu->adev;
@@ -1655,8 +1681,8 @@ static const struct pptable_funcs smu_v13_0_7_ppt_funcs = { · 71 unmodified lines
1655	.baco_is_support = smu_v13_0_baco_is_support,	1681	.baco_is_support = smu_v13_0_baco_is_support,
1656	.baco_get_state = smu_v13_0_baco_get_state,	1682	.baco_get_state = smu_v13_0_baco_get_state,
1657	.baco_set_state = smu_v13_0_baco_set_state,	1683	.baco_set_state = smu_v13_0_baco_set_state,
1658	.baco_enter = smu_v13_0_baco_enter,	1684	.baco_enter = smu_v13_0_7_baco_enter,
1659	.baco_exit = smu_v13_0_baco_exit,	1685	.baco_exit = smu_v13_0_7_baco_exit,
1660	.mode1_reset_is_support = smu_v13_0_7_is_mode1_reset_supported,	1686	.mode1_reset_is_support = smu_v13_0_7_is_mode1_reset_supported,
1661	.mode1_reset = smu_v13_0_mode1_reset,	1687	.mode1_reset = smu_v13_0_mode1_reset,
1662	.set_mp1_state = smu_v13_0_7_set_mp1_state,	1688	.set_mp1_state = smu_v13_0_7_set_mp1_state,

drivers/gpu/drm/display/drm_dp_dual_mode_helper.c+29−22

 ssize_t drm_dp_dual_mode_read(struct i2c_adapter *adapter,
 			      u8 offset, void *buffer, size_t size)
 {
+	u8 zero = 0;
+	char *tmpbuf = NULL;
+	/*
+	 * As sub-addressing is not supported by all adaptors,
+	 * always explicitly read from the start and discard
+	 * any bytes that come before the requested offset.
+	 * This way, no matter whether the adaptor supports it
+	 * or not, we'll end up reading the proper data.
+	 */
 	struct i2c_msg msgs[] = {
 		{
 			.addr = DP_DUAL_MODE_SLAVE_ADDRESS,
 			.flags = 0,
 			.len = 1,
-			.buf = &offset,
+			.buf = &zero,
 		},
 		{
 			.addr = DP_DUAL_MODE_SLAVE_ADDRESS,
 			.flags = I2C_M_RD,
-			.len = size,
+			.len = size + offset,
 			.buf = buffer,
 		},
 	};
 	int ret;
+	if (offset) {
+		tmpbuf = kmalloc(size + offset, GFP_KERNEL);
+		if (!tmpbuf)
+			return -ENOMEM;
+		msgs[1].buf = tmpbuf;
+	}
 	ret = i2c_transfer(adapter, msgs, ARRAY_SIZE(msgs));
+	if (tmpbuf)
+		memcpy(buffer, tmpbuf + offset, size);
+	kfree(tmpbuf);
 	if (ret < 0)
 		return ret;
 	if (ret != ARRAY_SIZE(msgs))
 	if (ret)
 		return DRM_DP_DUAL_MODE_UNKNOWN;
-	/*
-	 * Sigh. Some (maybe all?) type 1 adaptors are broken and ack
-	 * the offset but ignore it, and instead they just always return
-	 * data from the start of the HDMI ID buffer. So for a broken
-	 * type 1 HDMI adaptor a single byte read will always give us
-	 * 0x44, and for a type 1 DVI adaptor it should give 0x00
-	 * (assuming it implements any registers). Fortunately neither
-	 * of those values will match the type 2 signature of the
-	 * DP_DUAL_MODE_ADAPTOR_ID register so we can proceed with
-	 * the type 2 adaptor detection safely even in the presence
-	 * of broken type 1 adaptors.
-	 */
 	ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_ADAPTOR_ID,
 				    &adaptor_id, sizeof(adaptor_id));
 	drm_dbg_kms(dev, "DP dual mode adaptor ID: %02x (err %zd)\n", adaptor_id, ret);
 				return DRM_DP_DUAL_MODE_TYPE2_DVI;
 		}
 		/*
-		 * If neither a proper type 1 ID nor a broken type 1 adaptor
+		 * If not a proper type 1 ID, still assume type 1, but let
-		 * as described above, assume type 1, but let the user know
+		 * the user know that we may have misdetected the type.
-		 * that we may have misdetected the type.
 		 */
-		if (!is_type1_adaptor(adaptor_id) && adaptor_id != hdmi_id[0])
+		if (!is_type1_adaptor(adaptor_id))
 			drm_err(dev, "Unexpected DP dual mode adaptor ID %02x\n", adaptor_id);
 	}
  * @enable: enable (as opposed to disable) the TMDS output buffers
  *
  * Set the state of the TMDS output buffers in the adaptor. For
- * type2 this is set via the DP_DUAL_MODE_TMDS_OEN register. As
+ * type2 this is set via the DP_DUAL_MODE_TMDS_OEN register.
- * some type 1 adaptors have problems with registers (see comments
+ * Type1 adaptors do not support any register writes.
- * in drm_dp_dual_mode_detect()) we avoid touching the register,
- * making this function a no-op on type 1 adaptors.
  *
  * Returns:
  * 0 on success, negative error code on failure

drivers/gpu/drm/drm_drv.c+1−1

@@ -615,7 +615,7 @@ static int drm_dev_init(struct drm_device *dev, · 614 unmodified lines
615	mutex_init(&dev->clientlist_mutex);	615	mutex_init(&dev->clientlist_mutex);
616	mutex_init(&dev->master_mutex);	616	mutex_init(&dev->master_mutex);
617		617
618	ret = drmm_add_action(dev, drm_dev_init_release, NULL);	618	ret = drmm_add_action_or_reset(dev, drm_dev_init_release, NULL);
619	if (ret)	619	if (ret)
620	return ret;	620	return ret;
621		621

drivers/gpu/drm/drm_internal.h+2−1

@@ -104,7 +104,8 @@ static inline void drm_vblank_flush_worker(struct drm_vblank_crtc *vblank) · 103 unmodified lines
104		104
105	static inline void drm_vblank_destroy_worker(struct drm_vblank_crtc *vblank)	105	static inline void drm_vblank_destroy_worker(struct drm_vblank_crtc *vblank)
106	{	106	{
107	kthread_destroy_worker(vblank->worker);	107	if (vblank->worker)
		108	kthread_destroy_worker(vblank->worker);
108	}	109	}
109		110
110	int drm_vblank_worker_init(struct drm_vblank_crtc *vblank);	111	int drm_vblank_worker_init(struct drm_vblank_crtc *vblank);

drivers/gpu/drm/drm_mode_config.c+0−3

 	count = 0;
 	connector_id = u64_to_user_ptr(card_res->connector_id_ptr);
 	drm_for_each_connector_iter(connector, &conn_iter) {
-		if (connector->registration_state != DRM_CONNECTOR_REGISTERED)
-			continue;
 		/* only expose writeback connectors if userspace understands them */
 		if (!file_priv->writeback_connectors &&
 		    (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK))

drivers/gpu/drm/i2c/tda998x_drv.c+2−0

@@ -1174,6 +1174,8 @@ static int tda998x_audio_codec_init(struct tda998x_priv *priv, · 1173 unmodified lines
1174	struct hdmi_codec_pdata codec_data = {	1174	struct hdmi_codec_pdata codec_data = {
1175	.ops = &audio_codec_ops,	1175	.ops = &audio_codec_ops,
1176	.max_i2s_channels = 2,	1176	.max_i2s_channels = 2,
		1177	.no_i2s_capture = 1,
		1178	.no_spdif_capture = 1,
1177	};	1179	};
1178		1180
1179	if (priv->audio_port_enable[AUDIO_ROUTE_I2S])	1181	if (priv->audio_port_enable[AUDIO_ROUTE_I2S])

drivers/gpu/drm/i915/gem/i915_gem_ttm.c+3−3

 		return VM_FAULT_SIGBUS;
 	}
-	if (i915_ttm_cpu_maps_iomem(bo->resource))
-		wakeref = intel_runtime_pm_get(&to_i915(obj->base.dev)->runtime_pm);
 	if (!i915_ttm_resource_mappable(bo->resource)) {
 		int err = -ENODEV;
 		int i;
 		}
 	}
+	if (i915_ttm_cpu_maps_iomem(bo->resource))
+		wakeref = intel_runtime_pm_get(&to_i915(obj->base.dev)->runtime_pm);
 	if (drm_dev_enter(dev, &idx)) {
 		ret = ttm_bo_vm_fault_reserved(vmf, vmf->vma->vm_page_prot,
 					       TTM_BO_VM_NUM_PREFAULT);

drivers/gpu/drm/lima/lima_devfreq.c+9−6

 	unsigned long cur_freq;
 	int ret;
 	const char *regulator_names[] = { "mali", NULL };
-	const char *clk_names[] = { "core", NULL };
-	struct dev_pm_opp_config config = {
-		.regulator_names = regulator_names,
-		.clk_names = clk_names,
-	};
 	if (!device_property_present(dev, "operating-points-v2"))
 		/* Optional, continue without devfreq */
 	spin_lock_init(&ldevfreq->lock);
-	ret = devm_pm_opp_set_config(dev, &config);
+	/*
+	 * clkname is set separately so it is not affected by the optional
+	 * regulator setting which may return error.
+	 */
+	ret = devm_pm_opp_set_clkname(dev, "core");
+	if (ret)
+		return ret;
+	ret = devm_pm_opp_set_regulators(dev, regulator_names);
 	if (ret) {
 		/* Continue if the optional regulator is missing */
 		if (ret != -ENODEV)

drivers/gpu/drm/panel/panel-simple.c+2−0

 static const struct panel_desc logictechno_lt161010_2nh = {
 	.timings = &logictechno_lt161010_2nh_timing,
 	.num_timings = 1,
+	.bpc = 6,
 	.size = {
 		.width = 154,
 		.height = 86,
 static const struct panel_desc logictechno_lt170410_2whc = {
 	.timings = &logictechno_lt170410_2whc_timing,
 	.num_timings = 1,
+	.bpc = 8,
 	.size = {
 		.width = 217,
 		.height = 136,

drivers/gpu/drm/tegra/drm.c+4−0

 	struct host1x *host1x = dev_get_drvdata(dev->dev.parent);
 	struct iommu_domain *domain;
+	/* Our IOMMU usage policy doesn't currently play well with GART */
+	if (of_machine_is_compatible("nvidia,tegra20"))
+		return false;
 	/*
 	 * If the Tegra DRM clients are backed by an IOMMU, push buffers are
 	 * likely to be allocated beyond the 32-bit boundary if sufficient

drivers/gpu/drm/vc4/vc4_kms.c+4−4

@@ -197,8 +197,8 @@ vc4_hvs_get_new_global_state(struct drm_atomic_state *state) · 196 unmodified lines
197	struct drm_private_state *priv_state;	197	struct drm_private_state *priv_state;
198		198
199	priv_state = drm_atomic_get_new_private_obj_state(state, &vc4->hvs_channels);	199	priv_state = drm_atomic_get_new_private_obj_state(state, &vc4->hvs_channels);
200	if (IS_ERR(priv_state))	200	if (!priv_state)
201	return ERR_CAST(priv_state);	201	return ERR_PTR(-EINVAL);
202		202
203	return to_vc4_hvs_state(priv_state);	203	return to_vc4_hvs_state(priv_state);
204	}	204	}
@@ -210,8 +210,8 @@ vc4_hvs_get_old_global_state(struct drm_atomic_state *state) · 5 unmodified lines
210	struct drm_private_state *priv_state;	210	struct drm_private_state *priv_state;
211		211
212	priv_state = drm_atomic_get_old_private_obj_state(state, &vc4->hvs_channels);	212	priv_state = drm_atomic_get_old_private_obj_state(state, &vc4->hvs_channels);
213	if (IS_ERR(priv_state))	213	if (!priv_state)
214	return ERR_CAST(priv_state);	214	return ERR_PTR(-EINVAL);
215		215
216	return to_vc4_hvs_state(priv_state);	216	return to_vc4_hvs_state(priv_state);
217	}	217	}

drivers/gpu/host1x/dev.c+4−0

 static bool host1x_wants_iommu(struct host1x *host1x)
 {
+	/* Our IOMMU usage policy doesn't currently play well with GART */
+	if (of_machine_is_compatible("nvidia,tegra20"))
+		return false;
 	/*
 	 * If we support addressing a maximum of 32 bits of physical memory
 	 * and if the host1x firewall is enabled, there's no need to enable

drivers/iio/accel/bma400_core.c+12−12

 	unsigned int val;
 	int ret;
-	/* Try to read chip_id register. It must return 0x90. */
-	ret = regmap_read(data->regmap, BMA400_CHIP_ID_REG, &val);
-	if (ret) {
-		dev_err(data->dev, "Failed to read chip id register\n");
-		return ret;
-	}
-	if (val != BMA400_ID_REG_VAL) {
-		dev_err(data->dev, "Chip ID mismatch\n");
-		return -ENODEV;
-	}
 	data->regulators[BMA400_VDD_REGULATOR].supply = "vdd";
 	data->regulators[BMA400_VDDIO_REGULATOR].supply = "vddio";
 	ret = devm_regulator_bulk_get(data->dev,
 	if (ret)
 		return ret;
+	/* Try to read chip_id register. It must return 0x90. */
+	ret = regmap_read(data->regmap, BMA400_CHIP_ID_REG, &val);
+	if (ret) {
+		dev_err(data->dev, "Failed to read chip id register\n");
+		return ret;
+	}
+	if (val != BMA400_ID_REG_VAL) {
+		dev_err(data->dev, "Chip ID mismatch\n");
+		return -ENODEV;
+	}
 	ret = bma400_get_power_mode(data);
 	if (ret) {
 		dev_err(data->dev, "Failed to get the initial power-mode\n");

drivers/iio/adc/at91-sama5d2_adc.c+2−4

 	clb->p6 = buf[AT91_ADC_TS_CLB_IDX_P6];
 	/*
-	 * We prepare here the conversion to milli and also add constant
+	 * We prepare here the conversion to milli to avoid doing it on hotpath.
-	 * factor (5 degrees Celsius) to p1 here to avoid doing it on
-	 * hotpath.
 	 */
-	clb->p1 = clb->p1 * 1000 + 5000;
+	clb->p1 = clb->p1 * 1000;
 free_buf:
 	kfree(buf);

drivers/iio/adc/at91_adc.c+3−1

 	trig->ops = &at91_adc_trigger_ops;
 	ret = iio_trigger_register(trig);
-	if (ret)
+	if (ret) {
+		iio_trigger_free(trig);
 		return NULL;
+	}
 	return trig;
 }

drivers/iio/adc/mp2629_adc.c+3−2

 	MP2629_MAP(SYSTEM_VOLT, "system-volt"),
 	MP2629_MAP(INPUT_VOLT, "input-volt"),
 	MP2629_MAP(BATT_CURRENT, "batt-current"),
-	MP2629_MAP(INPUT_CURRENT, "input-current")
+	MP2629_MAP(INPUT_CURRENT, "input-current"),
+	{ }
 };
 static int mp2629_read_raw(struct iio_dev *indio_dev,
 		if (ret)
 			return ret;
-		if (chan->address == MP2629_INPUT_VOLT)
+		if (chan->channel == MP2629_INPUT_VOLT)
 			rval &= GENMASK(6, 0);
 		*val = rval;
 		return IIO_VAL_INT;

drivers/iio/imu/bno055/bno055.c+1−1

@@ -632,7 +632,7 @@ static int bno055_set_regmask(struct bno055_priv *priv, int val, int val2, · 631 unmodified lines
632	return -EINVAL;	632	return -EINVAL;
633	}	633	}
634	delta = abs(tbl_val - req_val);	634	delta = abs(tbl_val - req_val);
635	if (delta < best_delta \|\| first) {	635	if (first \|\| delta < best_delta) {
636	best_delta = delta;	636	best_delta = delta;
637	hwval = i;	637	hwval = i;
638	first = false;	638	first = false;

drivers/iio/pressure/ms5611.h+4−8

 	MS5607,
 };
-struct ms5611_chip_info {
-	u16 prom[MS5611_PROM_WORDS_NB];
-	int (*temp_and_pressure_compensate)(struct ms5611_chip_info *chip_info,
-					    s32 *temp, s32 *pressure);
-};
 /*
  * OverSampling Rate descriptor.
  * Warning: cmd MUST be kept aligned on a word boundary (see
 	const struct ms5611_osr *pressure_osr;
 	const struct ms5611_osr *temp_osr;
+	u16 prom[MS5611_PROM_WORDS_NB];
 	int (*reset)(struct ms5611_state *st);
 	int (*read_prom_word)(struct ms5611_state *st, int index, u16 *word);
 	int (*read_adc_temp_and_pressure)(struct ms5611_state *st,
 					  s32 *temp, s32 *pressure);
-	struct ms5611_chip_info *chip_info;
+	int (*compensate_temp_and_pressure)(struct ms5611_state *st, s32 *temp,
+					  s32 *pressure);
 	struct regulator *vdd;
 };

drivers/iio/pressure/ms5611_core.c+27−24

@@ -85,7 +85,7 @@ static int ms5611_read_prom(struct iio_dev *indio_dev) · 84 unmodified lines
85	struct ms5611_state *st = iio_priv(indio_dev);	85	struct ms5611_state *st = iio_priv(indio_dev);
86		86
87	for (i = 0; i < MS5611_PROM_WORDS_NB; i++) {	87	for (i = 0; i < MS5611_PROM_WORDS_NB; i++) {
88	ret = st->read_prom_word(st, i, &st->chip_info->prom[i]);	88	ret = st->read_prom_word(st, i, &st->prom[i]);
89	if (ret < 0) {	89	if (ret < 0) {
90	dev_err(&indio_dev->dev,	90	dev_err(&indio_dev->dev,
91	"failed to read prom at %d\n", i);	91	"failed to read prom at %d\n", i);
@@ -93,7 +93,7 @@ static int ms5611_read_prom(struct iio_dev *indio_dev) · 1 unmodified line
93	}	93	}
94	}	94	}
95		95
96	if (!ms5611_prom_is_valid(st->chip_info->prom, MS5611_PROM_WORDS_NB)) {	96	if (!ms5611_prom_is_valid(st->prom, MS5611_PROM_WORDS_NB)) {
97	dev_err(&indio_dev->dev, "PROM integrity check failed\n");	97	dev_err(&indio_dev->dev, "PROM integrity check failed\n");
98	return -ENODEV;	98	return -ENODEV;
99	}	99	}
@@ -114,21 +114,20 @@ static int ms5611_read_temp_and_pressure(struct iio_dev *indio_dev, · 14 unmodified lines
114	return ret;	114	return ret;
115	}	115	}
116		116
117	return st->chip_info->temp_and_pressure_compensate(st->chip_info,	117	return st->compensate_temp_and_pressure(st, temp, pressure);
118	temp, pressure);
119	}	118	}
120		119
121	static int ms5611_temp_and_pressure_compensate(struct ms5611_chip_info *chip_info,	120	static int ms5611_temp_and_pressure_compensate(struct ms5611_state *st,
122	s32 temp, s32 pressure)	121	s32 temp, s32 pressure)
123	{	122	{
124	s32 t = temp, p = pressure;	123	s32 t = temp, p = pressure;
125	s64 off, sens, dt;	124	s64 off, sens, dt;
126		125
127	dt = t - (chip_info->prom[5] << 8);	126	dt = t - (st->prom[5] << 8);
128	off = ((s64)chip_info->prom[2] << 16) + ((chip_info->prom[4] * dt) >> 7);	127	off = ((s64)st->prom[2] << 16) + ((st->prom[4] * dt) >> 7);
129	sens = ((s64)chip_info->prom[1] << 15) + ((chip_info->prom[3] * dt) >> 8);	128	sens = ((s64)st->prom[1] << 15) + ((st->prom[3] * dt) >> 8);
130		129
131	t = 2000 + ((chip_info->prom[6] * dt) >> 23);	130	t = 2000 + ((st->prom[6] * dt) >> 23);
132	if (t < 2000) {	131	if (t < 2000) {
133	s64 off2, sens2, t2;	132	s64 off2, sens2, t2;
134		133
@@ -154,17 +153,17 @@ static int ms5611_temp_and_pressure_compensate(struct ms5611_chip_info *chip_inf · 19 unmodified lines
154	return 0;	153	return 0;
155	}	154	}
156		155
157	static int ms5607_temp_and_pressure_compensate(struct ms5611_chip_info *chip_info,	156	static int ms5607_temp_and_pressure_compensate(struct ms5611_state *st,
158	s32 temp, s32 pressure)	157	s32 temp, s32 pressure)
159	{	158	{
160	s32 t = temp, p = pressure;	159	s32 t = temp, p = pressure;
161	s64 off, sens, dt;	160	s64 off, sens, dt;
162		161
163	dt = t - (chip_info->prom[5] << 8);	162	dt = t - (st->prom[5] << 8);
164	off = ((s64)chip_info->prom[2] << 17) + ((chip_info->prom[4] * dt) >> 6);	163	off = ((s64)st->prom[2] << 17) + ((st->prom[4] * dt) >> 6);
165	sens = ((s64)chip_info->prom[1] << 16) + ((chip_info->prom[3] * dt) >> 7);	164	sens = ((s64)st->prom[1] << 16) + ((st->prom[3] * dt) >> 7);
166		165
167	t = 2000 + ((chip_info->prom[6] * dt) >> 23);	166	t = 2000 + ((st->prom[6] * dt) >> 23);
168	if (t < 2000) {	167	if (t < 2000) {
169	s64 off2, sens2, t2, tmp;	168	s64 off2, sens2, t2, tmp;
170		169
@@ -342,15 +341,6 @@ static int ms5611_write_raw(struct iio_dev *indio_dev, · 171 unmodified lines
342		341
343	static const unsigned long ms5611_scan_masks[] = {0x3, 0};	342	static const unsigned long ms5611_scan_masks[] = {0x3, 0};
344		343
345	static struct ms5611_chip_info chip_info_tbl[] = {
346	[MS5611] = {
347	.temp_and_pressure_compensate = ms5611_temp_and_pressure_compensate,
348	},
349	[MS5607] = {
350	.temp_and_pressure_compensate = ms5607_temp_and_pressure_compensate,
351	}
352	};
353
354	static const struct iio_chan_spec ms5611_channels[] = {	344	static const struct iio_chan_spec ms5611_channels[] = {
355	{	345	{
356	.type = IIO_PRESSURE,	346	.type = IIO_PRESSURE,
@@ -433,7 +423,20 @@ int ms5611_probe(struct iio_dev indio_dev, struct device dev, · 76 unmodified lines
433	struct ms5611_state *st = iio_priv(indio_dev);	423	struct ms5611_state *st = iio_priv(indio_dev);
434		424
435	mutex_init(&st->lock);	425	mutex_init(&st->lock);
436	st->chip_info = &chip_info_tbl[type];	426
		427	switch (type) {
		428	case MS5611:
		429	st->compensate_temp_and_pressure =
		430	ms5611_temp_and_pressure_compensate;
		431	break;
		432	case MS5607:
		433	st->compensate_temp_and_pressure =
		434	ms5607_temp_and_pressure_compensate;
		435	break;
		436	default:
		437	return -EINVAL;
		438	}
		439
437	st->temp_osr =	440	st->temp_osr =
438	&ms5611_avail_temp_osr[ARRAY_SIZE(ms5611_avail_temp_osr) - 1];	441	&ms5611_avail_temp_osr[ARRAY_SIZE(ms5611_avail_temp_osr) - 1];
439	st->pressure_osr =	442	st->pressure_osr =

drivers/iio/pressure/ms5611_spi.c+1−1

@@ -91,7 +91,7 @@ static int ms5611_spi_probe(struct spi_device *spi) · 90 unmodified lines
91	spi_set_drvdata(spi, indio_dev);	91	spi_set_drvdata(spi, indio_dev);
92		92
93	spi->mode = SPI_MODE_0;	93	spi->mode = SPI_MODE_0;
94	spi->max_speed_hz = 20000000;	94	spi->max_speed_hz = min(spi->max_speed_hz, 20000000U);
95	spi->bits_per_word = 8;	95	spi->bits_per_word = 8;
96	ret = spi_setup(spi);	96	ret = spi_setup(spi);
97	if (ret < 0)	97	if (ret < 0)

drivers/iio/trigger/iio-trig-sysfs.c+5−1

 static int __init iio_sysfs_trig_init(void)
 {
+	int ret;
 	device_initialize(&iio_sysfs_trig_dev);
 	dev_set_name(&iio_sysfs_trig_dev, "iio_sysfs_trigger");
-	return device_add(&iio_sysfs_trig_dev);
+	ret = device_add(&iio_sysfs_trig_dev);
+	if (ret)
+		put_device(&iio_sysfs_trig_dev);
+	return ret;
 }
 module_init(iio_sysfs_trig_init);

drivers/input/joystick/iforce/iforce-main.c+4−4

@@ -273,22 +273,22 @@ int iforce_init_device(struct device *parent, u16 bustype, · 272 unmodified lines
273	* Get device info.	273	* Get device info.
274	*/	274	*/
275		275
276	if (!iforce_get_id_packet(iforce, 'M', buf, &len) \|\| len < 3)	276	if (!iforce_get_id_packet(iforce, 'M', buf, &len) && len >= 3)
277	input_dev->id.vendor = get_unaligned_le16(buf + 1);	277	input_dev->id.vendor = get_unaligned_le16(buf + 1);
278	else	278	else
279	dev_warn(&iforce->dev->dev, "Device does not respond to id packet M\n");	279	dev_warn(&iforce->dev->dev, "Device does not respond to id packet M\n");
280		280
281	if (!iforce_get_id_packet(iforce, 'P', buf, &len) \|\| len < 3)	281	if (!iforce_get_id_packet(iforce, 'P', buf, &len) && len >= 3)
282	input_dev->id.product = get_unaligned_le16(buf + 1);	282	input_dev->id.product = get_unaligned_le16(buf + 1);
283	else	283	else
284	dev_warn(&iforce->dev->dev, "Device does not respond to id packet P\n");	284	dev_warn(&iforce->dev->dev, "Device does not respond to id packet P\n");
285		285
286	if (!iforce_get_id_packet(iforce, 'B', buf, &len) \|\| len < 3)	286	if (!iforce_get_id_packet(iforce, 'B', buf, &len) && len >= 3)
287	iforce->device_memory.end = get_unaligned_le16(buf + 1);	287	iforce->device_memory.end = get_unaligned_le16(buf + 1);
288	else	288	else
289	dev_warn(&iforce->dev->dev, "Device does not respond to id packet B\n");	289	dev_warn(&iforce->dev->dev, "Device does not respond to id packet B\n");
290		290
291	if (!iforce_get_id_packet(iforce, 'N', buf, &len) \|\| len < 2)	291	if (!iforce_get_id_packet(iforce, 'N', buf, &len) && len >= 2)
292	ff_effects = buf[1];	292	ff_effects = buf[1];
293	else	293	else
294	dev_warn(&iforce->dev->dev, "Device does not respond to id packet N\n");	294	dev_warn(&iforce->dev->dev, "Device does not respond to id packet N\n");

drivers/input/misc/soc_button_array.c+13−1

 #include <linux/gpio.h>
 #include <linux/platform_device.h>
+static bool use_low_level_irq;
+module_param(use_low_level_irq, bool, 0444);
+MODULE_PARM_DESC(use_low_level_irq, "Use low-level triggered IRQ instead of edge triggered");
 struct soc_button_info {
 	const char *name;
 	int acpi_index;
 			DMI_MATCH(DMI_PRODUCT_NAME, "Aspire SW5-012"),
 		},
 	},
+	{
+		/* Acer Switch V 10 SW5-017, same issue as Acer Switch 10 SW5-012. */
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "SW5-017"),
+		},
+	},
 	{
 		/*
 		 * Acer One S1003. _LID method messes with power-button GPIO
 		}
 		/* See dmi_use_low_level_irq[] comment */
-		if (!autorepeat && dmi_check_system(dmi_use_low_level_irq)) {
+		if (!autorepeat && (use_low_level_irq ||
+				    dmi_check_system(dmi_use_low_level_irq))) {
 			irq_set_irq_type(irq, IRQ_TYPE_LEVEL_LOW);
 			gpio_keys[n_buttons].irq = irq;
 			gpio_keys[n_buttons].gpio = -ENOENT;

drivers/input/mouse/synaptics.c+1−0

@@ -192,6 +192,7 @@ static const char * const smbus_pnp_ids[] = { · 191 unmodified lines
192	"SYN3221", /* HP 15-ay000 */	192	"SYN3221", /* HP 15-ay000 */
193	"SYN323d", /* HP Spectre X360 13-w013dx */	193	"SYN323d", /* HP Spectre X360 13-w013dx */
194	"SYN3257", /* HP Envy 13-ad105ng */	194	"SYN3257", /* HP Envy 13-ad105ng */
		195	"SYN3286", /* HP Laptop 15-da3001TU */
195	NULL	196	NULL
196	};	197	};
197		198

drivers/input/serio/i8042-acpipnpio.h+4−4

@@ -115,18 +115,18 @@ static const struct dmi_system_id i8042_dmi_quirk_table[] __initconst = { · 114 unmodified lines
115	.driver_data = (void *)(SERIO_QUIRK_NOMUX \| SERIO_QUIRK_RESET_NEVER)	115	.driver_data = (void *)(SERIO_QUIRK_NOMUX \| SERIO_QUIRK_RESET_NEVER)
116	},	116	},
117	{	117	{
118	/* ASUS ZenBook UX425UA */	118	/* ASUS ZenBook UX425UA/QA */
119	.matches = {	119	.matches = {
120	DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),	120	DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
121	DMI_MATCH(DMI_PRODUCT_NAME, "ZenBook UX425UA"),	121	DMI_MATCH(DMI_PRODUCT_NAME, "ZenBook UX425"),
122	},	122	},
123	.driver_data = (void *)(SERIO_QUIRK_PROBE_DEFER \| SERIO_QUIRK_RESET_NEVER)	123	.driver_data = (void *)(SERIO_QUIRK_PROBE_DEFER \| SERIO_QUIRK_RESET_NEVER)
124	},	124	},
125	{	125	{
126	/* ASUS ZenBook UM325UA */	126	/* ASUS ZenBook UM325UA/QA */
127	.matches = {	127	.matches = {
128	DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),	128	DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
129	DMI_MATCH(DMI_PRODUCT_NAME, "ZenBook UX325UA_UM325UA"),	129	DMI_MATCH(DMI_PRODUCT_NAME, "ZenBook UX325"),
130	},	130	},
131	.driver_data = (void *)(SERIO_QUIRK_PROBE_DEFER \| SERIO_QUIRK_RESET_NEVER)	131	.driver_data = (void *)(SERIO_QUIRK_PROBE_DEFER \| SERIO_QUIRK_RESET_NEVER)
132	},	132	},

drivers/input/serio/i8042.c+0−4

 {
 	int error;
-	i8042_platform_device = dev;
 	if (i8042_reset == I8042_RESET_ALWAYS) {
 		error = i8042_controller_selftest();
 		if (error)
 	i8042_free_aux_ports();	/* in case KBD failed but AUX not */
 	i8042_free_irqs();
 	i8042_controller_reset(false);
-	i8042_platform_device = NULL;
 	return error;
 }
 	i8042_unregister_ports();
 	i8042_free_irqs();
 	i8042_controller_reset(false);
-	i8042_platform_device = NULL;
 	return 0;
 }

drivers/input/touchscreen/goodix.c+11−0

 	input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
 	input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
+retry_read_config:
 	/* Read configuration and apply touchscreen parameters */
 	goodix_read_config(ts);
 	touchscreen_parse_properties(ts->input_dev, true, &ts->prop);
 	if (!ts->prop.max_x || !ts->prop.max_y || !ts->max_touch_num) {
+		if (!ts->reset_controller_at_probe &&
+		    ts->irq_pin_access_method != IRQ_PIN_ACCESS_NONE) {
+			dev_info(&ts->client->dev, "Config not set, resetting controller\n");
+			/* Retry after a controller reset */
+			ts->reset_controller_at_probe = true;
+			error = goodix_reset(ts);
+			if (error)
+				return error;
+			goto retry_read_config;
+		}
 		dev_err(&ts->client->dev,
 			"Invalid config (%d, %d, %d), using defaults\n",
 			ts->prop.max_x, ts->prop.max_y, ts->max_touch_num);

drivers/iommu/intel/iommu.c+3−5

@@ -959,11 +959,9 @@ static struct dma_pte pfn_to_dma_pte(struct dmar_domain domain, · 958 unmodified lines
959		959
960	domain_flush_cache(domain, tmp_page, VTD_PAGE_SIZE);	960	domain_flush_cache(domain, tmp_page, VTD_PAGE_SIZE);
961	pteval = ((uint64_t)virt_to_dma_pfn(tmp_page) << VTD_PAGE_SHIFT) \| DMA_PTE_READ \| DMA_PTE_WRITE;	961	pteval = ((uint64_t)virt_to_dma_pfn(tmp_page) << VTD_PAGE_SHIFT) \| DMA_PTE_READ \| DMA_PTE_WRITE;
962	if (domain_use_first_level(domain)) {	962	if (domain_use_first_level(domain))
963	pteval \|= DMA_FL_PTE_XD \| DMA_FL_PTE_US;	963	pteval \|= DMA_FL_PTE_XD \| DMA_FL_PTE_US \| DMA_FL_PTE_ACCESS;
964	if (iommu_is_dma_domain(&domain->domain))	964
965	pteval \|= DMA_FL_PTE_ACCESS;
966	}
967	if (cmpxchg64(&pte->val, 0ULL, pteval))	965	if (cmpxchg64(&pte->val, 0ULL, pteval))
968	/* Someone else set it while we were thinking; use theirs. */	966	/* Someone else set it while we were thinking; use theirs. */
969	free_pgtable_page(tmp_page);	967	free_pgtable_page(tmp_page);

drivers/iommu/intel/pasid.c+3−2

 	 * Since it is a second level only translation setup, we should
 	 * set SRE bit as well (addresses are expected to be GPAs).
 	 */
-	if (pasid != PASID_RID2PASID)
+	if (pasid != PASID_RID2PASID && ecap_srs(iommu->ecap))
 		pasid_set_sre(pte);
 	pasid_set_present(pte);
 	spin_unlock(&iommu->lock);
 	 * We should set SRE bit as well since the addresses are expected
 	 * to be GPAs.
 	 */
-	pasid_set_sre(pte);
+	if (ecap_srs(iommu->ecap))
+		pasid_set_sre(pte);
 	pasid_set_present(pte);
 	spin_unlock(&iommu->lock);

drivers/isdn/mISDN/core.c+1−1

@@ -222,7 +222,7 @@ mISDN_register_device(struct mISDNdevice *dev, · 221 unmodified lines
222		222
223	err = get_free_devid();	223	err = get_free_devid();
224	if (err < 0)	224	if (err < 0)
225	goto error1;	225	return err;
226	dev->id = err;	226	dev->id = err;
227		227
228	device_initialize(&dev->dev);	228	device_initialize(&dev->dev);

drivers/isdn/mISDN/dsp_pipeline.c+2−1

 	if (!entry)
 		return -ENOMEM;
+	INIT_LIST_HEAD(&entry->list);
 	entry->elem = elem;
 	entry->dev.class = elements_class;
 	device_unregister(&entry->dev);
 	return ret;
 err1:
-	kfree(entry);
+	put_device(&entry->dev);
 	return ret;
 }
 EXPORT_SYMBOL(mISDN_dsp_element_register);

drivers/md/dm-bufio.c+2−0

 	dm_io_client_destroy(c->dm_io);
 bad_dm_io:
 	mutex_destroy(&c->lock);
+	if (c->no_sleep)
+		static_branch_dec(&no_sleep_enabled);
 	kfree(c);
 bad_client:
 	return ERR_PTR(r);

drivers/md/dm-crypt.c+1−0

@@ -3630,6 +3630,7 @@ static void crypt_io_hints(struct dm_target ti, struct queue_limits limits) · 3629 unmodified lines
3630	limits->physical_block_size =	3630	limits->physical_block_size =
3631	max_t(unsigned, limits->physical_block_size, cc->sector_size);	3631	max_t(unsigned, limits->physical_block_size, cc->sector_size);
3632	limits->io_min = max_t(unsigned, limits->io_min, cc->sector_size);	3632	limits->io_min = max_t(unsigned, limits->io_min, cc->sector_size);
		3633	limits->dma_alignment = limits->logical_block_size - 1;
3633	}	3634	}
3634		3635
3635	static struct target_type crypt_target = {	3636	static struct target_type crypt_target = {

drivers/md/dm-integrity.c+15−6

 	struct completion crypto_backoff;
+	bool wrote_to_journal;
 	bool journal_uptodate;
 	bool just_formatted;
 	bool recalculate_flag;
 	if (!commit_sections)
 		goto release_flush_bios;
+	ic->wrote_to_journal = true;
 	i = commit_start;
 	for (n = 0; n < commit_sections; n++) {
 		for (j = 0; j < ic->journal_section_entries; j++) {
 	unsigned prev_free_sectors;
-	/* the following test is not needed, but it tests the replay code */
-	if (unlikely(dm_post_suspending(ic->ti)) && !ic->meta_dev)
-		return;
 	spin_lock_irq(&ic->endio_wait.lock);
 	write_start = ic->committed_section;
 	write_sections = ic->n_committed_sections;
 	drain_workqueue(ic->commit_wq);
 	if (ic->mode == 'J') {
-		if (ic->meta_dev)
+		queue_work(ic->writer_wq, &ic->writer_work);
-			queue_work(ic->writer_wq, &ic->writer_work);
 		drain_workqueue(ic->writer_wq);
 		dm_integrity_flush_buffers(ic, true);
+		if (ic->wrote_to_journal) {
+			init_journal(ic, ic->free_section,
+				     ic->journal_sections - ic->free_section, ic->commit_seq);
+			if (ic->free_section) {
+				init_journal(ic, 0, ic->free_section,
+					     next_commit_seq(ic->commit_seq));
+			}
+		}
 	}
 	if (ic->mode == 'B') {
 	DEBUG_print("resume\n");
+	ic->wrote_to_journal = false;
 	if (ic->provided_data_sectors != old_provided_data_sectors) {
 		if (ic->provided_data_sectors > old_provided_data_sectors &&
 		    ic->mode == 'B' &&
 		limits->logical_block_size = ic->sectors_per_block << SECTOR_SHIFT;
 		limits->physical_block_size = ic->sectors_per_block << SECTOR_SHIFT;
 		blk_limits_io_min(limits, ic->sectors_per_block << SECTOR_SHIFT);
+		limits->dma_alignment = limits->logical_block_size - 1;
 	}
 }

drivers/md/dm-ioctl.c+2−2

@@ -655,7 +655,7 @@ static void list_version_get_needed(struct target_type tt, void needed_param) · 654 unmodified lines
655	size_t *needed = needed_param;	655	size_t *needed = needed_param;
656		656
657	*needed += sizeof(struct dm_target_versions);	657	*needed += sizeof(struct dm_target_versions);
658	*needed += strlen(tt->name);	658	*needed += strlen(tt->name) + 1;
659	*needed += ALIGN_MASK;	659	*needed += ALIGN_MASK;
660	}	660	}
661		661
@@ -720,7 +720,7 @@ static int __list_versions(struct dm_ioctl *param, size_t param_size, const char · 58 unmodified lines
720	iter_info.old_vers = NULL;	720	iter_info.old_vers = NULL;
721	iter_info.vers = vers;	721	iter_info.vers = vers;
722	iter_info.flags = 0;	722	iter_info.flags = 0;
723	iter_info.end = (char *)vers+len;	723	iter_info.end = (char *)vers + needed;
724		724
725	/*	725	/*
726	* Now loop through filling out the names & versions.	726	* Now loop through filling out the names & versions.

drivers/md/dm-log-writes.c+1−0

@@ -875,6 +875,7 @@ static void log_writes_io_hints(struct dm_target ti, struct queue_limits limit · 874 unmodified lines
875	limits->logical_block_size = bdev_logical_block_size(lc->dev->bdev);	875	limits->logical_block_size = bdev_logical_block_size(lc->dev->bdev);
876	limits->physical_block_size = bdev_physical_block_size(lc->dev->bdev);	876	limits->physical_block_size = bdev_physical_block_size(lc->dev->bdev);
877	limits->io_min = limits->physical_block_size;	877	limits->io_min = limits->physical_block_size;
		878	limits->dma_alignment = limits->logical_block_size - 1;
878	}	879	}
879		880
880	#if IS_ENABLED(CONFIG_FS_DAX)	881	#if IS_ENABLED(CONFIG_FS_DAX)

drivers/misc/vmw_vmci/vmci_queue_pair.c+2−0

 	u32 context_id = vmci_get_context_id();
 	struct vmci_event_qp ev;
+	memset(&ev, 0, sizeof(ev));
 	ev.msg.hdr.dst = vmci_make_handle(context_id, VMCI_EVENT_HANDLER);
 	ev.msg.hdr.src = vmci_make_handle(VMCI_HYPERVISOR_CONTEXT_ID,
 					  VMCI_CONTEXT_RESOURCE_ID);
 	 * kernel.
 	 */
+	memset(&ev, 0, sizeof(ev));
 	ev.msg.hdr.dst = vmci_make_handle(peer_id, VMCI_EVENT_HANDLER);
 	ev.msg.hdr.src = vmci_make_handle(VMCI_HYPERVISOR_CONTEXT_ID,
 					  VMCI_CONTEXT_RESOURCE_ID);

drivers/mmc/core/core.c+7−1

 		mmc_power_cycle(host, ocr);
 	} else {
 		bit = fls(ocr) - 1;
-		ocr &= 3 << bit;
+		/*
+		 * The bit variable represents the highest voltage bit set in
+		 * the OCR register.
+		 * To keep a range of 2 values (e.g. 3.2V/3.3V and 3.3V/3.4V),
+		 * we must shift the mask '3' with (bit - 1).
+		 */
+		ocr &= 3 << (bit - 1);
 		if (bit != host->ios.vdd)
 			dev_warn(mmc_dev(host), "exceeding card's volts\n");
 	}

drivers/mmc/host/sdhci-pci-core.c+2−0

@@ -1749,6 +1749,8 @@ static int amd_probe(struct sdhci_pci_chip *chip) · 1748 unmodified lines
1749	}	1749	}
1750	}	1750	}
1751		1751
		1752	pci_dev_put(smbus_dev);
		1753
1752	if (gen == AMD_CHIPSET_BEFORE_ML \|\| gen == AMD_CHIPSET_CZ)	1754	if (gen == AMD_CHIPSET_BEFORE_ML \|\| gen == AMD_CHIPSET_CZ)
1753	chip->quirks2 \|= SDHCI_QUIRK2_CLEAR_TRANSFERMODE_REG_BEFORE_CMD;	1755	chip->quirks2 \|= SDHCI_QUIRK2_CLEAR_TRANSFERMODE_REG_BEFORE_CMD;
1754		1756

drivers/mmc/host/sdhci-pci-o2micro.c+7−0

 #define O2_SD_CAPS		0xE0
 #define O2_SD_ADMA1		0xE2
 #define O2_SD_ADMA2		0xE7
+#define O2_SD_MISC_CTRL2	0xF0
 #define O2_SD_INF_MOD		0xF1
 #define O2_SD_MISC_CTRL4	0xFC
 #define O2_SD_MISC_CTRL		0x1C0
 		/* Set Tuning Windows to 5 */
 		pci_write_config_byte(chip->pdev,
 				O2_SD_TUNING_CTRL, 0x55);
+		//Adjust 1st and 2nd CD debounce time
+		pci_read_config_dword(chip->pdev, O2_SD_MISC_CTRL2, &scratch_32);
+		scratch_32 &= 0xFFE7FFFF;
+		scratch_32 |= 0x00180000;
+		pci_write_config_dword(chip->pdev, O2_SD_MISC_CTRL2, scratch_32);
+		pci_write_config_dword(chip->pdev, O2_SD_DETECT_SETTING, 1);
 		/* Lock WP */
 		ret = pci_read_config_byte(chip->pdev,
 					   O2_SD_LOCK_WP, &scratch);

drivers/mtd/nand/onenand/Kconfig+1−0

@@ -26,6 +26,7 @@ config MTD_ONENAND_OMAP2 · 25 unmodified lines
26	tristate "OneNAND on OMAP2/OMAP3 support"	26	tristate "OneNAND on OMAP2/OMAP3 support"
27	depends on ARCH_OMAP2 \|\| ARCH_OMAP3 \|\| (COMPILE_TEST && ARM)	27	depends on ARCH_OMAP2 \|\| ARCH_OMAP3 \|\| (COMPILE_TEST && ARM)
28	depends on OF \|\| COMPILE_TEST	28	depends on OF \|\| COMPILE_TEST
		29	depends on OMAP_GPMC
29	help	30	help
30	Support for a OneNAND flash device connected to an OMAP2/OMAP3 SoC	31	Support for a OneNAND flash device connected to an OMAP2/OMAP3 SoC
31	via the GPMC memory controller.	32	via the GPMC memory controller.

drivers/mtd/nand/raw/nand_base.c+2−2

@@ -5834,7 +5834,7 @@ nand_match_ecc_req(struct nand_chip *chip, · 5833 unmodified lines
5834	int req_step = requirements->step_size;	5834	int req_step = requirements->step_size;
5835	int req_strength = requirements->strength;	5835	int req_strength = requirements->strength;
5836	int req_corr, step_size, strength, nsteps, ecc_bytes, ecc_bytes_total;	5836	int req_corr, step_size, strength, nsteps, ecc_bytes, ecc_bytes_total;
5837	int best_step, best_strength, best_ecc_bytes;	5837	int best_step = 0, best_strength = 0, best_ecc_bytes = 0;
5838	int best_ecc_bytes_total = INT_MAX;	5838	int best_ecc_bytes_total = INT_MAX;
5839	int i, j;	5839	int i, j;
5840		5840
@@ -5915,7 +5915,7 @@ nand_maximize_ecc(struct nand_chip *chip, · 74 unmodified lines
5915	int step_size, strength, nsteps, ecc_bytes, corr;	5915	int step_size, strength, nsteps, ecc_bytes, corr;
5916	int best_corr = 0;	5916	int best_corr = 0;
5917	int best_step = 0;	5917	int best_step = 0;
5918	int best_strength, best_ecc_bytes;	5918	int best_strength = 0, best_ecc_bytes = 0;
5919	int i, j;	5919	int i, j;
5920		5920
5921	for (i = 0; i < caps->nstepinfos; i++) {	5921	for (i = 0; i < caps->nstepinfos; i++) {

drivers/mtd/nand/raw/qcom_nandc.c+7−5

 	ret = mtd_device_parse_register(mtd, probes, NULL, NULL, 0);
 	if (ret)
-		nand_cleanup(chip);
+		goto err;
 	if (nandc->props->use_codeword_fixup) {
 		ret = qcom_nand_host_parse_boot_partitions(nandc, host, dn);
-		if (ret) {
+		if (ret)
-			nand_cleanup(chip);
+			goto err;
-			return ret;
-		}
 	}
+	return 0;
+err:
+	nand_cleanup(chip);
 	return ret;
 }

drivers/net/ethernet/amazon/ena/ena_netdev.c+7−1

 static int __init ena_init(void)
 {
+	int ret;
 	ena_wq = create_singlethread_workqueue(DRV_MODULE_NAME);
 	if (!ena_wq) {
 		pr_err("Failed to create workqueue\n");
 		return -ENOMEM;
 	}
-	return pci_register_driver(&ena_pci_driver);
+	ret = pci_register_driver(&ena_pci_driver);
+	if (ret)
+		destroy_workqueue(ena_wq);
+	return ret;
 }
 static void __exit ena_cleanup(void)

drivers/net/ethernet/atheros/ag71xx.c+2−1

 	if (ret) {
 		netif_err(ag, link, ndev, "phylink_of_phy_connect filed with err: %i\n",
 			  ret);
-		goto err;
+		return ret;
 	}
 	max_frame_len = ag71xx_max_frame_len(ndev->mtu);
 err:
 	ag71xx_rings_cleanup(ag);
+	phylink_disconnect_phy(ag->phylink);
 	return ret;
 }

drivers/net/ethernet/broadcom/bgmac.c+0−1

@@ -1568,7 +1568,6 @@ void bgmac_enet_remove(struct bgmac *bgmac) · 1567 unmodified lines
1568	phy_disconnect(bgmac->net_dev->phydev);	1568	phy_disconnect(bgmac->net_dev->phydev);
1569	netif_napi_del(&bgmac->napi);	1569	netif_napi_del(&bgmac->napi);
1570	bgmac_dma_free(bgmac);	1570	bgmac_dma_free(bgmac);
1571	free_netdev(bgmac->net_dev);
1572	}	1571	}
1573	EXPORT_SYMBOL_GPL(bgmac_enet_remove);	1572	EXPORT_SYMBOL_GPL(bgmac_enet_remove);
1574		1573

drivers/net/ethernet/broadcom/bnxt/bnxt.c+9−1

 static int __init bnxt_init(void)
 {
+	int err;
 	bnxt_debug_init();
-	return pci_register_driver(&bnxt_pci_driver);
+	err = pci_register_driver(&bnxt_pci_driver);
+	if (err) {
+		bnxt_debug_exit();
+		return err;
+	}
+	return 0;
 }
 static void __exit bnxt_exit(void)

drivers/net/ethernet/cavium/liquidio/lio_main.c+26−8

 	ifstate_set(lio, LIO_IFSTATE_RUNNING);
-	if (OCTEON_CN23XX_PF(oct)) {
+	if (!OCTEON_CN23XX_PF(oct) || (OCTEON_CN23XX_PF(oct) && !oct->msix_on)) {
-		if (!oct->msix_on)
+		ret = setup_tx_poll_fn(netdev);
-			if (setup_tx_poll_fn(netdev))
+		if (ret)
-				return -1;
+			goto err_poll;
-	} else {
-		if (setup_tx_poll_fn(netdev))
-			return -1;
 	}
 	netif_tx_start_all_queues(netdev);
 	/* tell Octeon to start forwarding packets to host */
 	ret = send_rx_ctrl_cmd(lio, 1);
 	if (ret)
-		return ret;
+		goto err_rx_ctrl;
 	/* start periodical statistics fetch */
 	INIT_DELAYED_WORK(&lio->stats_wk.work, lio_fetch_stats);
 	dev_info(&oct->pci_dev->dev, "%s interface is opened\n",
 		 netdev->name);
+	return 0;
+err_rx_ctrl:
+	if (!OCTEON_CN23XX_PF(oct) || (OCTEON_CN23XX_PF(oct) && !oct->msix_on))
+		cleanup_tx_poll_fn(netdev);
+err_poll:
+	if (lio->ptp_clock) {
+		ptp_clock_unregister(lio->ptp_clock);
+		lio->ptp_clock = NULL;
+	}
+	if (oct->props[lio->ifidx].napi_enabled == 1) {
+		list_for_each_entry_safe(napi, n, &netdev->napi_list, dev_list)
+			napi_disable(napi);
+		oct->props[lio->ifidx].napi_enabled = 0;
+		if (OCTEON_CN23XX_PF(oct))
+			oct->droq[0]->ops.poll_mode = 0;
+	}
 	return ret;
 }

drivers/net/ethernet/hisilicon/hns3/hnae3.h+0−1

@@ -819,7 +819,6 @@ struct hnae3_knic_private_info { · 818 unmodified lines
819	const struct hnae3_dcb_ops *dcb_ops;	819	const struct hnae3_dcb_ops *dcb_ops;
820		820
821	u16 int_rl_setting;	821	u16 int_rl_setting;
822	enum pkt_hash_types rss_type;
823	void __iomem *io_base;	822	void __iomem *io_base;
824	};	823	};
825		824

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.c+0−20

@@ -191,23 +191,6 @@ u32 hclge_comm_get_rss_key_size(struct hnae3_handle *handle) · 190 unmodified lines
191	return HCLGE_COMM_RSS_KEY_SIZE;	191	return HCLGE_COMM_RSS_KEY_SIZE;
192	}	192	}
193		193
194	void hclge_comm_get_rss_type(struct hnae3_handle *nic,
195	struct hclge_comm_rss_tuple_cfg *rss_tuple_sets)
196	{
197	if (rss_tuple_sets->ipv4_tcp_en \|\|
198	rss_tuple_sets->ipv4_udp_en \|\|
199	rss_tuple_sets->ipv4_sctp_en \|\|
200	rss_tuple_sets->ipv6_tcp_en \|\|
201	rss_tuple_sets->ipv6_udp_en \|\|
202	rss_tuple_sets->ipv6_sctp_en)
203	nic->kinfo.rss_type = PKT_HASH_TYPE_L4;
204	else if (rss_tuple_sets->ipv4_fragment_en \|\|
205	rss_tuple_sets->ipv6_fragment_en)
206	nic->kinfo.rss_type = PKT_HASH_TYPE_L3;
207	else
208	nic->kinfo.rss_type = PKT_HASH_TYPE_NONE;
209	}
210
211	int hclge_comm_parse_rss_hfunc(struct hclge_comm_rss_cfg *rss_cfg,	194	int hclge_comm_parse_rss_hfunc(struct hclge_comm_rss_cfg *rss_cfg,
212	const u8 hfunc, u8 *hash_algo)	195	const u8 hfunc, u8 *hash_algo)
213	{	196	{
@@ -344,9 +327,6 @@ int hclge_comm_set_rss_input_tuple(struct hnae3_handle *nic, · 130 unmodified lines
344	req->ipv6_sctp_en = rss_cfg->rss_tuple_sets.ipv6_sctp_en;	327	req->ipv6_sctp_en = rss_cfg->rss_tuple_sets.ipv6_sctp_en;
345	req->ipv6_fragment_en = rss_cfg->rss_tuple_sets.ipv6_fragment_en;	328	req->ipv6_fragment_en = rss_cfg->rss_tuple_sets.ipv6_fragment_en;
346		329
347	if (is_pf)
348	hclge_comm_get_rss_type(nic, &rss_cfg->rss_tuple_sets);
349
350	ret = hclge_comm_cmd_send(hw, &desc, 1);	330	ret = hclge_comm_cmd_send(hw, &desc, 1);
351	if (ret)	331	if (ret)
352	dev_err(&hw->cmq.csq.pdev->dev,	332	dev_err(&hw->cmq.csq.pdev->dev,

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.h+0−2

@@ -95,8 +95,6 @@ struct hclge_comm_rss_tc_mode_cmd { · 94 unmodified lines
95	};	95	};
96		96
97	u32 hclge_comm_get_rss_key_size(struct hnae3_handle *handle);	97	u32 hclge_comm_get_rss_key_size(struct hnae3_handle *handle);
98	void hclge_comm_get_rss_type(struct hnae3_handle *nic,
99	struct hclge_comm_rss_tuple_cfg *rss_tuple_sets);
100	void hclge_comm_rss_indir_init_cfg(struct hnae3_ae_dev *ae_dev,	98	void hclge_comm_rss_indir_init_cfg(struct hnae3_ae_dev *ae_dev,
101	struct hclge_comm_rss_cfg *rss_cfg);	99	struct hclge_comm_rss_cfg *rss_cfg);
102	int hclge_comm_get_rss_tuple(struct hclge_comm_rss_cfg *rss_cfg, int flow_type,	100	int hclge_comm_get_rss_tuple(struct hclge_comm_rss_cfg *rss_cfg, int flow_type,

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c+95−72

drivers/net/ethernet/hisilicon/hns3/hns3_enet.h+1−0

@@ -404,6 +404,7 @@ struct hns3_rx_ptype { · 403 unmodified lines
404	u32 ip_summed : 2;	404	u32 ip_summed : 2;
405	u32 l3_type : 4;	405	u32 l3_type : 4;
406	u32 valid : 1;	406	u32 valid : 1;
		407	u32 hash_type: 3;
407	};	408	};
408		409
409	struct ring_stats {	410	struct ring_stats {

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c+7−4

 	hdev->hw.mac.autoneg = cmd.base.autoneg;
 	hdev->hw.mac.speed = cmd.base.speed;
 	hdev->hw.mac.duplex = cmd.base.duplex;
+	linkmode_copy(hdev->hw.mac.advertising, cmd.link_modes.advertising);
 	return 0;
 }
 		return ret;
 	}
-	hclge_comm_get_rss_type(&vport->nic, &hdev->rss_cfg.rss_tuple_sets);
 	return 0;
 }
 	if (ret)
 		goto err_msi_irq_uninit;
-	if (hdev->hw.mac.media_type == HNAE3_MEDIA_TYPE_COPPER &&
+	if (hdev->hw.mac.media_type == HNAE3_MEDIA_TYPE_COPPER) {
-	    !hnae3_dev_phy_imp_supported(hdev)) {
+		if (hnae3_dev_phy_imp_supported(hdev))
-		ret = hclge_mac_mdio_config(hdev);
+			ret = hclge_update_tp_port_info(hdev);
+		else
+			ret = hclge_mac_mdio_config(hdev);
 		if (ret)
 			goto err_msi_irq_uninit;
 	}

drivers/net/ethernet/huawei/hinic/hinic_main.c+8−1

@@ -1474,8 +1474,15 @@ static struct pci_driver hinic_driver = { · 1473 unmodified lines
1474		1474
1475	static int __init hinic_module_init(void)	1475	static int __init hinic_module_init(void)
1476	{	1476	{
		1477	int ret;
		1478
1477	hinic_dbg_register_debugfs(HINIC_DRV_NAME);	1479	hinic_dbg_register_debugfs(HINIC_DRV_NAME);
1478	return pci_register_driver(&hinic_driver);	1480
		1481	ret = pci_register_driver(&hinic_driver);
		1482	if (ret)
		1483	hinic_dbg_unregister_debugfs();
		1484
		1485	return ret;
1479	}	1486	}
1480		1487
1481	static void __exit hinic_module_exit(void)	1488	static void __exit hinic_module_exit(void)

drivers/net/ethernet/marvell/octeon_ep/octep_main.c+11−5

 	octep_oq_dbell_init(oct);
 	ret = octep_get_link_status(oct);
-	if (ret)
+	if (ret > 0)
 		octep_link_up(netdev);
 	return 0;
 set_queues_err:
-	octep_napi_disable(oct);
-	octep_napi_delete(oct);
 	octep_clean_irqs(oct);
 setup_irq_err:
 	octep_free_oqs(oct);
 	ret = octep_ctrl_mbox_init(ctrl_mbox);
 	if (ret) {
 		dev_err(&pdev->dev, "Failed to initialize control mbox\n");
-		return -1;
+		goto unsupported_dev;
 	}
 	oct->ctrl_mbox_ifstats_offset = OCTEP_CTRL_MBOX_SZ(ctrl_mbox->h2fq.elem_sz,
 							   ctrl_mbox->h2fq.elem_cnt,
 	return 0;
 unsupported_dev:
+	for (i = 0; i < OCTEP_MMIO_REGIONS; i++)
+		iounmap(oct->mmio[i].hw_addr);
+	kfree(oct->conf);
 	return -1;
 }
 	netdev->max_mtu = OCTEP_MAX_MTU;
 	netdev->mtu = OCTEP_DEFAULT_MTU;
-	octep_get_mac_addr(octep_dev, octep_dev->mac_addr);
+	err = octep_get_mac_addr(octep_dev, octep_dev->mac_addr);
+	if (err) {
+		dev_err(&pdev->dev, "Failed to get mac address\n");
+		goto register_dev_err;
+	}
 	eth_hw_addr_set(netdev, octep_dev->mac_addr);
 	err = register_netdev(netdev);

drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c+2−0

@@ -3470,6 +3470,8 @@ mlxsw_sp_switchdev_vxlan_fdb_del(struct mlxsw_sp *mlxsw_sp, · 3469 unmodified lines
3470	u16 vid;	3470	u16 vid;
3471		3471
3472	vxlan_fdb_info = &switchdev_work->vxlan_fdb_info;	3472	vxlan_fdb_info = &switchdev_work->vxlan_fdb_info;
		3473	if (!vxlan_fdb_info->offloaded)
		3474	return;
3473		3475
3474	bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);	3476	bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
3475	if (!bridge_device)	3477	if (!bridge_device)

drivers/net/ethernet/microchip/lan966x/lan966x_ethtool.c+3−0

 	snprintf(queue_name, sizeof(queue_name), "%s-stats",
 		 dev_name(lan966x->dev));
 	lan966x->stats_queue = create_singlethread_workqueue(queue_name);
+	if (!lan966x->stats_queue)
+		return -ENOMEM;
 	INIT_DELAYED_WORK(&lan966x->stats_work, lan966x_check_stats_work);
 	queue_delayed_work(lan966x->stats_queue, &lan966x->stats_work,
 			   LAN966X_STATS_CHECK_DELAY);

drivers/net/ethernet/microchip/sparx5/sparx5_ethtool.c+3−0

 	snprintf(queue_name, sizeof(queue_name), "%s-stats",
 		 dev_name(sparx5->dev));
 	sparx5->stats_queue = create_singlethread_workqueue(queue_name);
+	if (!sparx5->stats_queue)
+		return -ENOMEM;
 	INIT_DELAYED_WORK(&sparx5->stats_work, sparx5_check_stats_work);
 	queue_delayed_work(sparx5->stats_queue, &sparx5->stats_work,
 			   SPX5_STATS_CHECK_DELAY);

drivers/net/ethernet/microchip/sparx5/sparx5_main.c+3−0

 	snprintf(queue_name, sizeof(queue_name), "%s-mact",
 		 dev_name(sparx5->dev));
 	sparx5->mact_queue = create_singlethread_workqueue(queue_name);
+	if (!sparx5->mact_queue)
+		return -ENOMEM;
 	INIT_DELAYED_WORK(&sparx5->mact_work, sparx5_mact_pull_work);
 	queue_delayed_work(sparx5->mact_queue, &sparx5->mact_work,
 			   SPX5_MACT_PULL_DELAY);

drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.c+3−3

@@ -1477,15 +1477,15 @@ nfp_port_get_module_info(struct net_device *netdev, · 1476 unmodified lines
1477		1477
1478	if (data < 0x3) {	1478	if (data < 0x3) {
1479	modinfo->type = ETH_MODULE_SFF_8436;	1479	modinfo->type = ETH_MODULE_SFF_8436;
1480	modinfo->eeprom_len = ETH_MODULE_SFF_8436_LEN;	1480	modinfo->eeprom_len = ETH_MODULE_SFF_8436_MAX_LEN;
1481	} else {	1481	} else {
1482	modinfo->type = ETH_MODULE_SFF_8636;	1482	modinfo->type = ETH_MODULE_SFF_8636;
1483	modinfo->eeprom_len = ETH_MODULE_SFF_8636_LEN;	1483	modinfo->eeprom_len = ETH_MODULE_SFF_8636_MAX_LEN;
1484	}	1484	}
1485	break;	1485	break;
1486	case NFP_INTERFACE_QSFP28:	1486	case NFP_INTERFACE_QSFP28:
1487	modinfo->type = ETH_MODULE_SFF_8636;	1487	modinfo->type = ETH_MODULE_SFF_8636;
1488	modinfo->eeprom_len = ETH_MODULE_SFF_8636_LEN;	1488	modinfo->eeprom_len = ETH_MODULE_SFF_8636_MAX_LEN;
1489	break;	1489	break;
1490	default:	1490	default:
1491	netdev_err(netdev, "Unsupported module 0x%x detected\n",	1491	netdev_err(netdev, "Unsupported module 0x%x detected\n",

drivers/net/ethernet/pensando/ionic/ionic_main.c+7−1

 static int __init ionic_init_module(void)
 {
+	int ret;
 	ionic_debugfs_create();
-	return ionic_bus_register_driver();
+	ret = ionic_bus_register_driver();
+	if (ret)
+		ionic_debugfs_destroy();
+	return ret;
 }
 static void __exit ionic_cleanup_module(void)

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c+3−0

@@ -6548,6 +6548,9 @@ void stmmac_xdp_release(struct net_device *dev) · 6547 unmodified lines
6548	struct stmmac_priv *priv = netdev_priv(dev);	6548	struct stmmac_priv *priv = netdev_priv(dev);
6549	u32 chan;	6549	u32 chan;
6550		6550
		6551	/* Ensure tx function is not running */
		6552	netif_tx_disable(dev);
		6553
6551	/* Disable NAPI process */	6554	/* Disable NAPI process */
6552	stmmac_disable_all_queues(priv);	6555	stmmac_disable_all_queues(priv);
6553		6556

drivers/net/macvlan.c+2−2

@@ -141,7 +141,7 @@ static struct macvlan_source_entry *macvlan_hash_lookup_source( · 140 unmodified lines
141	u32 idx = macvlan_eth_hash(addr);	141	u32 idx = macvlan_eth_hash(addr);
142	struct hlist_head *h = &vlan->port->vlan_source_hash[idx];	142	struct hlist_head *h = &vlan->port->vlan_source_hash[idx];
143		143
144	hlist_for_each_entry_rcu(entry, h, hlist) {	144	hlist_for_each_entry_rcu(entry, h, hlist, lockdep_rtnl_is_held()) {
145	if (ether_addr_equal_64bits(entry->addr, addr) &&	145	if (ether_addr_equal_64bits(entry->addr, addr) &&
146	entry->vlan == vlan)	146	entry->vlan == vlan)
147	return entry;	147	return entry;
@@ -1647,7 +1647,7 @@ static int macvlan_fill_info_macaddr(struct sk_buff *skb, · 1499 unmodified lines
1647	struct hlist_head *h = &vlan->port->vlan_source_hash[i];	1647	struct hlist_head *h = &vlan->port->vlan_source_hash[i];
1648	struct macvlan_source_entry *entry;	1648	struct macvlan_source_entry *entry;
1649		1649
1650	hlist_for_each_entry_rcu(entry, h, hlist) {	1650	hlist_for_each_entry_rcu(entry, h, hlist, lockdep_rtnl_is_held()) {
1651	if (entry->vlan != vlan)	1651	if (entry->vlan != vlan)
1652	continue;	1652	continue;
1653	if (nla_put(skb, IFLA_MACVLAN_MACADDR, ETH_ALEN, entry->addr))	1653	if (nla_put(skb, IFLA_MACVLAN_MACADDR, ETH_ALEN, entry->addr))

drivers/net/mctp/mctp-i2c.c+32−15

 enum {
 	MCTP_I2C_FLOW_STATE_NEW = 0,
 	MCTP_I2C_FLOW_STATE_ACTIVE,
+	MCTP_I2C_FLOW_STATE_INVALID,
 };
 /* List of all struct mctp_i2c_client
 	 */
 	if (!key->valid) {
 		state = MCTP_I2C_TX_FLOW_INVALID;
-	} else if (key->dev_flow_state == MCTP_I2C_FLOW_STATE_NEW) {
-		key->dev_flow_state = MCTP_I2C_FLOW_STATE_ACTIVE;
-		state = MCTP_I2C_TX_FLOW_NEW;
 	} else {
-		state = MCTP_I2C_TX_FLOW_EXISTING;
+		switch (key->dev_flow_state) {
+		case MCTP_I2C_FLOW_STATE_NEW:
+			key->dev_flow_state = MCTP_I2C_FLOW_STATE_ACTIVE;
+			state = MCTP_I2C_TX_FLOW_NEW;
+			break;
+		case MCTP_I2C_FLOW_STATE_ACTIVE:
+			state = MCTP_I2C_TX_FLOW_EXISTING;
+			break;
+		default:
+			state = MCTP_I2C_TX_FLOW_INVALID;
+		}
 	}
 	spin_unlock_irqrestore(&key->lock, flags);
 {
 	struct mctp_i2c_dev *midev = netdev_priv(mdev->dev);
+	bool queue_release = false;
 	unsigned long flags;
 	spin_lock_irqsave(&midev->lock, flags);
-	midev->release_count++;
+	/* if we have seen the flow/key previously, we need to pair the
-	spin_unlock_irqrestore(&midev->lock, flags);
+	 * original lock with a release
-	/* Ensure we have a release operation queued, through the fake
-	 * marker skb
 	 */
-	spin_lock(&midev->tx_queue.lock);
+	if (key->dev_flow_state == MCTP_I2C_FLOW_STATE_ACTIVE) {
-	if (!midev->unlock_marker.next)
+		midev->release_count++;
-		__skb_queue_tail(&midev->tx_queue, &midev->unlock_marker);
+		queue_release = true;
-	spin_unlock(&midev->tx_queue.lock);
+	}
+	key->dev_flow_state = MCTP_I2C_FLOW_STATE_INVALID;
+	spin_unlock_irqrestore(&midev->lock, flags);
-	wake_up(&midev->tx_wq);
+	if (queue_release) {
+		/* Ensure we have a release operation queued, through the fake
+		 * marker skb
+		 */
+		spin_lock(&midev->tx_queue.lock);
+		if (!midev->unlock_marker.next)
+			__skb_queue_tail(&midev->tx_queue,
+					 &midev->unlock_marker);
+		spin_unlock(&midev->tx_queue.lock);
+		wake_up(&midev->tx_wq);
+	}
 }
 static const struct net_device_ops mctp_i2c_ops = {

drivers/net/mhi_net.c+2−0

@@ -343,6 +343,8 @@ static void mhi_net_dellink(struct mhi_device mhi_dev, struct net_device ndev) · 342 unmodified lines
343		343
344	kfree_skb(mhi_netdev->skbagg_head);	344	kfree_skb(mhi_netdev->skbagg_head);
345		345
		346	free_netdev(ndev);
		347
346	dev_set_drvdata(&mhi_dev->dev, NULL);	348	dev_set_drvdata(&mhi_dev->dev, NULL);
347	}	349	}
348		350

drivers/net/netdevsim/dev.c+1−0

@@ -1683,6 +1683,7 @@ void nsim_drv_remove(struct nsim_bus_dev *nsim_bus_dev) · 1682 unmodified lines
1683	ARRAY_SIZE(nsim_devlink_params));	1683	ARRAY_SIZE(nsim_devlink_params));
1684	devl_resources_unregister(devlink);	1684	devl_resources_unregister(devlink);
1685	kfree(nsim_dev->vfconfigs);	1685	kfree(nsim_dev->vfconfigs);
		1686	kfree(nsim_dev->fa_cookie);
1686	devl_unlock(devlink);	1687	devl_unlock(devlink);
1687	devlink_free(devlink);	1688	devlink_free(devlink);
1688	dev_set_drvdata(&nsim_bus_dev->dev, NULL);	1689	dev_set_drvdata(&nsim_bus_dev->dev, NULL);

drivers/net/phy/dp83867.c+7−0

@@ -682,6 +682,13 @@ static int dp83867_of_init(struct phy_device *phydev) · 681 unmodified lines
682	*/	682	*/
683	dp83867->io_impedance = DP83867_IO_MUX_CFG_IO_IMPEDANCE_MIN / 2;	683	dp83867->io_impedance = DP83867_IO_MUX_CFG_IO_IMPEDANCE_MIN / 2;
684		684
		685	/* For non-OF device, the RX and TX FIFO depths are taken from
		686	* default value. So, we init RX & TX FIFO depths here
		687	* so that it is configured correctly later in dp83867_config_init();
		688	*/
		689	dp83867->tx_fifo_depth = DP83867_PHYCR_FIFO_DEPTH_4_B_NIB;
		690	dp83867->rx_fifo_depth = DP83867_PHYCR_FIFO_DEPTH_4_B_NIB;
		691
685	return 0;	692	return 0;
686	}	693	}
687	#endif /* CONFIG_OF_MDIO */	694	#endif /* CONFIG_OF_MDIO */

drivers/net/phy/marvell.c+9−7

 		if (err < 0)
 			return err;
-		/* FIXME: Based on trial and error test, it seem 1G need to have
+		err = phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK,
-		 * delay between soft reset and loopback enablement.
+				 BMCR_LOOPBACK);
-		 */
-		if (phydev->speed == SPEED_1000)
-			msleep(1000);
-		return phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK,
+		if (!err) {
-				  BMCR_LOOPBACK);
+			/* It takes some time for PHY device to switch
+			 * into/out-of loopback mode.
+			 */
+			msleep(1000);
+		}
+		return err;
 	} else {
 		err = phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK, 0);
 		if (err < 0)

drivers/net/thunderbolt.c+14−5

@@ -1391,12 +1391,21 @@ static int __init tbnet_init(void) · 1390 unmodified lines
1391	tb_property_add_immediate(tbnet_dir, "prtcstns", flags);	1391	tb_property_add_immediate(tbnet_dir, "prtcstns", flags);
1392		1392
1393	ret = tb_register_property_dir("network", tbnet_dir);	1393	ret = tb_register_property_dir("network", tbnet_dir);
1394	if (ret) {	1394	if (ret)
1395	tb_property_free_dir(tbnet_dir);	1395	goto err_free_dir;
1396	return ret;	1396
1397	}	1397	ret = tb_register_service_driver(&tbnet_driver);
		1398	if (ret)
		1399	goto err_unregister;
1398		1400
1399	return tb_register_service_driver(&tbnet_driver);	1401	return 0;
		1402
		1403	err_unregister:
		1404	tb_unregister_property_dir("network", tbnet_dir);
		1405	err_free_dir:
		1406	tb_property_free_dir(tbnet_dir);
		1407
		1408	return ret;
1400	}	1409	}
1401	module_init(tbnet_init);	1410	module_init(tbnet_init);
1402		1411

drivers/net/usb/qmi_wwan.c+1−0

@@ -1357,6 +1357,7 @@ static const struct usb_device_id products[] = { · 1356 unmodified lines
1357	{QMI_FIXED_INTF(0x2357, 0x0201, 4)}, /* TP-LINK HSUPA Modem MA180 */	1357	{QMI_FIXED_INTF(0x2357, 0x0201, 4)}, /* TP-LINK HSUPA Modem MA180 */
1358	{QMI_FIXED_INTF(0x2357, 0x9000, 4)}, /* TP-LINK MA260 */	1358	{QMI_FIXED_INTF(0x2357, 0x9000, 4)}, /* TP-LINK MA260 */
1359	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1031, 3)}, /* Telit LE910C1-EUX */	1359	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1031, 3)}, /* Telit LE910C1-EUX */
		1360	{QMI_QUIRK_SET_DTR(0x1bc7, 0x103a, 0)}, /* Telit LE910C4-WWX */
1360	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1040, 2)}, /* Telit LE922A */	1361	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1040, 2)}, /* Telit LE922A */
1361	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1050, 2)}, /* Telit FN980 */	1362	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1050, 2)}, /* Telit FN980 */
1362	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1057, 2)}, /* Telit FN980 */	1363	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1057, 2)}, /* Telit FN980 */

drivers/net/usb/smsc95xx.c+42−4

 	spinlock_t mac_cr_lock;
 	u8 features;
 	u8 suspend_flags;
+	bool is_internal_phy;
 	struct irq_chip irqchip;
 	struct irq_domain *irqdomain;
 	struct fwnode_handle *irqfwnode;
 	mutex_unlock(&dev->phy_mutex);
 }
+static int smsc95xx_mdiobus_reset(struct mii_bus *bus)
+{
+	struct smsc95xx_priv *pdata;
+	struct usbnet *dev;
+	u32 val;
+	int ret;
+	dev = bus->priv;
+	pdata = dev->driver_priv;
+	if (pdata->is_internal_phy)
+		return 0;
+	mutex_lock(&dev->phy_mutex);
+	ret = smsc95xx_read_reg(dev, PM_CTRL, &val);
+	if (ret < 0)
+		goto reset_out;
+	val |= PM_CTL_PHY_RST_;
+	ret = smsc95xx_write_reg(dev, PM_CTRL, val);
+	if (ret < 0)
+		goto reset_out;
+	/* Driver has no knowledge at this point about the external PHY.
+	 * The 802.3 specifies that the reset process shall
+	 * be completed within 0.5 s.
+	 */
+	fsleep(500000);
+reset_out:
+	mutex_unlock(&dev->phy_mutex);
+	return 0;
+}
 static int smsc95xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)
 {
 	struct usbnet *dev = bus->priv;
 static int smsc95xx_bind(struct usbnet *dev, struct usb_interface *intf)
 {
 	struct smsc95xx_priv *pdata;
-	bool is_internal_phy;
 	char usb_path[64];
 	int ret, phy_irq;
 	u32 val;
 	if (ret < 0)
 		goto free_mdio;
-	is_internal_phy = !(val & HW_CFG_PSEL_);
+	pdata->is_internal_phy = !(val & HW_CFG_PSEL_);
-	if (is_internal_phy)
+	if (pdata->is_internal_phy)
 		pdata->mdiobus->phy_mask = ~(1u << SMSC95XX_INTERNAL_PHY_ID);
 	pdata->mdiobus->priv = dev;
 	pdata->mdiobus->read = smsc95xx_mdiobus_read;
 	pdata->mdiobus->write = smsc95xx_mdiobus_write;
+	pdata->mdiobus->reset = smsc95xx_mdiobus_reset;
 	pdata->mdiobus->name = "smsc95xx-mdiobus";
 	pdata->mdiobus->parent = &dev->udev->dev;
 	}
 	pdata->phydev->irq = phy_irq;
-	pdata->phydev->is_internal = is_internal_phy;
+	pdata->phydev->is_internal = pdata->is_internal_phy;
 	/* detect device revision as different features may be available */
 	ret = smsc95xx_read_reg(dev, ID_REV, &val);

drivers/nvme/host/pci.c+4−0

 				NVME_QUIRK_IGNORE_DEV_SUBNQN, },
 	 { PCI_DEVICE(0x1344, 0x5407), /* Micron Technology Inc NVMe SSD */
 		.driver_data = NVME_QUIRK_IGNORE_DEV_SUBNQN },
+	 { PCI_DEVICE(0x1344, 0x6001),   /* Micron Nitro NVMe */
+		 .driver_data = NVME_QUIRK_BOGUS_NID, },
 	{ PCI_DEVICE(0x1c5c, 0x1504),   /* SK Hynix PC400 */
 		.driver_data = NVME_QUIRK_DISABLE_WRITE_ZEROES, },
 	{ PCI_DEVICE(0x1c5c, 0x174a),   /* SK Hynix P31 SSD */
 		.driver_data = NVME_QUIRK_DISABLE_WRITE_ZEROES, },
 	{ PCI_DEVICE(0x2646, 0x501E),   /* KINGSTON OM3PGP4xxxxQ OS21011 NVMe SSD */
 		.driver_data = NVME_QUIRK_DISABLE_WRITE_ZEROES, },
+	{ PCI_DEVICE(0x1f40, 0x5236),   /* Netac Technologies Co. NV7000 NVMe SSD */
+		.driver_data = NVME_QUIRK_BOGUS_NID, },
 	{ PCI_DEVICE(0x1e4B, 0x1001),   /* MAXIO MAP1001 */
 		.driver_data = NVME_QUIRK_BOGUS_NID, },
 	{ PCI_DEVICE(0x1e4B, 0x1002),   /* MAXIO MAP1002 */

drivers/nvme/target/auth.c+2−0

 	if (!dhchap_secret)
 		return -ENOMEM;
 	if (set_ctrl) {
+		kfree(host->dhchap_ctrl_secret);
 		host->dhchap_ctrl_secret = strim(dhchap_secret);
 		host->dhchap_ctrl_key_hash = key_hash;
 	} else {
+		kfree(host->dhchap_secret);
 		host->dhchap_secret = strim(dhchap_secret);
 		host->dhchap_key_hash = key_hash;
 	}

drivers/nvmem/lan9662-otpc.c+1−1

@@ -203,7 +203,7 @@ static int lan9662_otp_probe(struct platform_device *pdev) · 202 unmodified lines
203	}	203	}
204		204
205	static const struct of_device_id lan9662_otp_match[] = {	205	static const struct of_device_id lan9662_otp_match[] = {
206	{ .compatible = "microchip,lan9662-otp", },	206	{ .compatible = "microchip,lan9662-otpc", },
207	{ },	207	{ },
208	};	208	};
209	MODULE_DEVICE_TABLE(of, lan9662_otp_match);	209	MODULE_DEVICE_TABLE(of, lan9662_otp_match);

drivers/nvmem/u-boot-env.c+1−1

@@ -135,7 +135,7 @@ static int u_boot_env_parse(struct u_boot_env *priv) · 134 unmodified lines
135	break;	135	break;
136	case U_BOOT_FORMAT_REDUNDANT:	136	case U_BOOT_FORMAT_REDUNDANT:
137	crc32_offset = offsetof(struct u_boot_env_image_redundant, crc32);	137	crc32_offset = offsetof(struct u_boot_env_image_redundant, crc32);
138	crc32_data_offset = offsetof(struct u_boot_env_image_redundant, mark);	138	crc32_data_offset = offsetof(struct u_boot_env_image_redundant, data);
139	data_offset = offsetof(struct u_boot_env_image_redundant, data);	139	data_offset = offsetof(struct u_boot_env_image_redundant, data);
140	break;	140	break;
141	}	141	}

drivers/parport/parport_pc.c+1−1

@@ -468,7 +468,7 @@ static size_t parport_pc_fifo_write_block_pio(struct parport *port, · 467 unmodified lines
468	const unsigned char *bufp = buf;	468	const unsigned char *bufp = buf;
469	size_t left = length;	469	size_t left = length;
470	unsigned long expire = jiffies + port->physport->cad->timeout;	470	unsigned long expire = jiffies + port->physport->cad->timeout;
471	const int fifo = FIFO(port);	471	const unsigned long fifo = FIFO(port);
472	int poll_for = 8; /* 80 usecs */	472	int poll_for = 8; /* 80 usecs */
473	const struct parport_pc_private *priv = port->physport->private_data;	473	const struct parport_pc_private *priv = port->physport->private_data;
474	const int fifo_depth = priv->fifo_depth;	474	const int fifo_depth = priv->fifo_depth;

drivers/pinctrl/devicetree.c+2−0

 	for (state = 0; ; state++) {
 		/* Retrieve the pinctrl-* property */
 		propname = kasprintf(GFP_KERNEL, "pinctrl-%d", state);
+		if (!propname)
+			return -ENOMEM;
 		prop = of_find_property(np, propname, &size);
 		kfree(propname);
 		if (!prop) {

drivers/pinctrl/mediatek/mtk-eint.c+29−5

 #define MTK_EINT_EDGE_SENSITIVE           0
 #define MTK_EINT_LEVEL_SENSITIVE          1
 #define MTK_EINT_DBNC_SET_DBNC_BITS	  4
+#define MTK_EINT_DBNC_MAX		  16
 #define MTK_EINT_DBNC_RST_BIT		  (0x1 << 1)
 #define MTK_EINT_DBNC_SET_EN		  (0x1 << 0)
 	.dbnc_clr  = 0x700,
 };
+const unsigned int debounce_time_mt2701[] = {
+	500, 1000, 16000, 32000, 64000, 128000, 256000, 0
+};
+EXPORT_SYMBOL_GPL(debounce_time_mt2701);
+const unsigned int debounce_time_mt6765[] = {
+	125, 250, 500, 1000, 16000, 32000, 64000, 128000, 256000, 512000, 0
+};
+EXPORT_SYMBOL_GPL(debounce_time_mt6765);
+const unsigned int debounce_time_mt6795[] = {
+	500, 1000, 16000, 32000, 64000, 128000, 256000, 512000, 0
+};
+EXPORT_SYMBOL_GPL(debounce_time_mt6795);
 static void __iomem *mtk_eint_get_offset(struct mtk_eint *eint,
 					 unsigned int eint_num,
 					 unsigned int offset)
 	int virq, eint_offset;
 	unsigned int set_offset, bit, clr_bit, clr_offset, rst, i, unmask,
 		     dbnc;
-	static const unsigned int debounce_time[] = {500, 1000, 16000, 32000,
-						     64000, 128000, 256000};
 	struct irq_data *d;
+	if (!eint->hw->db_time)
+		return -EOPNOTSUPP;
 	virq = irq_find_mapping(eint->domain, eint_num);
 	eint_offset = (eint_num % 4) * 8;
 	d = irq_get_irq_data(virq);
 	if (!mtk_eint_can_en_debounce(eint, eint_num))
 		return -EINVAL;
-	dbnc = ARRAY_SIZE(debounce_time);
+	dbnc = eint->num_db_time;
-	for (i = 0; i < ARRAY_SIZE(debounce_time); i++) {
+	for (i = 0; i < eint->num_db_time; i++) {
-		if (debounce <= debounce_time[i]) {
+		if (debounce <= eint->hw->db_time[i]) {
 			dbnc = i;
 			break;
 		}
 	if (!eint->domain)
 		return -ENOMEM;
+	if (eint->hw->db_time) {
+		for (i = 0; i < MTK_EINT_DBNC_MAX; i++)
+			if (eint->hw->db_time[i] == 0)
+				break;
+		eint->num_db_time = i;
+	}
 	mtk_eint_hw_init(eint);
 	for (i = 0; i < eint->hw->ap_num; i++) {
 		int virq = irq_create_mapping(eint->domain, i);

drivers/pinctrl/mediatek/mtk-eint.h+6−0

 	u8		ports;
 	unsigned int	ap_num;
 	unsigned int	db_cnt;
+	const unsigned int *db_time;
 };
+extern const unsigned int debounce_time_mt2701[];
+extern const unsigned int debounce_time_mt6765[];
+extern const unsigned int debounce_time_mt6795[];
 struct mtk_eint;
 struct mtk_eint_xt {
 	/* Used to fit into various EINT device */
 	const struct mtk_eint_hw *hw;
 	const struct mtk_eint_regs *regs;
+	u16 num_db_time;
 	/* Used to fit into various pinctrl device */
 	void *pctl;

drivers/pinctrl/mediatek/pinctrl-mt2701.c+1−0

@@ -518,6 +518,7 @@ static const struct mtk_pinctrl_devdata mt2701_pinctrl_data = { · 517 unmodified lines
518	.ports = 6,	518	.ports = 6,
519	.ap_num = 169,	519	.ap_num = 169,
520	.db_cnt = 16,	520	.db_cnt = 16,
		521	.db_time = debounce_time_mt2701,
521	},	522	},
522	};	523	};
523		524

drivers/pinctrl/mediatek/pinctrl-mt2712.c+1−0

@@ -567,6 +567,7 @@ static const struct mtk_pinctrl_devdata mt2712_pinctrl_data = { · 566 unmodified lines
567	.ports = 8,	567	.ports = 8,
568	.ap_num = 229,	568	.ap_num = 229,
569	.db_cnt = 40,	569	.db_cnt = 40,
		570	.db_time = debounce_time_mt2701,
570	},	571	},
571	};	572	};
572		573

drivers/pinctrl/mediatek/pinctrl-mt6765.c+1−0

@@ -1062,6 +1062,7 @@ static const struct mtk_eint_hw mt6765_eint_hw = { · 1061 unmodified lines
1062	.ports = 6,	1062	.ports = 6,
1063	.ap_num = 160,	1063	.ap_num = 160,
1064	.db_cnt = 13,	1064	.db_cnt = 13,
		1065	.db_time = debounce_time_mt6765,
1065	};	1066	};
1066		1067
1067	static const struct mtk_pin_soc mt6765_data = {	1068	static const struct mtk_pin_soc mt6765_data = {

drivers/pinctrl/mediatek/pinctrl-mt6779.c+1−0

@@ -737,6 +737,7 @@ static const struct mtk_eint_hw mt6779_eint_hw = { · 736 unmodified lines
737	.ports = 6,	737	.ports = 6,
738	.ap_num = 195,	738	.ap_num = 195,
739	.db_cnt = 13,	739	.db_cnt = 13,
		740	.db_time = debounce_time_mt2701,
740	};	741	};
741		742
742	static const struct mtk_pin_soc mt6779_data = {	743	static const struct mtk_pin_soc mt6779_data = {

drivers/pinctrl/mediatek/pinctrl-mt6795.c+1−0

@@ -475,6 +475,7 @@ static const struct mtk_eint_hw mt6795_eint_hw = { · 474 unmodified lines
475	.ports = 7,	475	.ports = 7,
476	.ap_num = 224,	476	.ap_num = 224,
477	.db_cnt = 32,	477	.db_cnt = 32,
		478	.db_time = debounce_time_mt6795,
478	};	479	};
479		480
480	static const unsigned int mt6795_pull_type[] = {	481	static const unsigned int mt6795_pull_type[] = {

drivers/pinctrl/mediatek/pinctrl-mt7622.c+1−0

@@ -846,6 +846,7 @@ static const struct mtk_eint_hw mt7622_eint_hw = { · 845 unmodified lines
846	.ports = 7,	846	.ports = 7,
847	.ap_num = ARRAY_SIZE(mt7622_pins),	847	.ap_num = ARRAY_SIZE(mt7622_pins),
848	.db_cnt = 20,	848	.db_cnt = 20,
		849	.db_time = debounce_time_mt6765,
849	};	850	};
850		851
851	static const struct mtk_pin_soc mt7622_data = {	852	static const struct mtk_pin_soc mt7622_data = {

drivers/pinctrl/mediatek/pinctrl-mt7623.c+1−0

@@ -1369,6 +1369,7 @@ static const struct mtk_eint_hw mt7623_eint_hw = { · 1368 unmodified lines
1369	.ports = 6,	1369	.ports = 6,
1370	.ap_num = 169,	1370	.ap_num = 169,
1371	.db_cnt = 20,	1371	.db_cnt = 20,
		1372	.db_time = debounce_time_mt2701,
1372	};	1373	};
1373		1374
1374	static struct mtk_pin_soc mt7623_data = {	1375	static struct mtk_pin_soc mt7623_data = {

drivers/pinctrl/mediatek/pinctrl-mt7629.c+1−0

@@ -402,6 +402,7 @@ static const struct mtk_eint_hw mt7629_eint_hw = { · 401 unmodified lines
402	.ports = 7,	402	.ports = 7,
403	.ap_num = ARRAY_SIZE(mt7629_pins),	403	.ap_num = ARRAY_SIZE(mt7629_pins),
404	.db_cnt = 16,	404	.db_cnt = 16,
		405	.db_time = debounce_time_mt2701,
405	};	406	};
406		407
407	static struct mtk_pin_soc mt7629_data = {	408	static struct mtk_pin_soc mt7629_data = {

drivers/pinctrl/mediatek/pinctrl-mt7986.c+2−0

 	.ports = 7,
 	.ap_num = ARRAY_SIZE(mt7986a_pins),
 	.db_cnt = 16,
+	.db_time = debounce_time_mt6765,
 };
 static const struct mtk_eint_hw mt7986b_eint_hw = {
 	.ports = 7,
 	.ap_num = ARRAY_SIZE(mt7986b_pins),
 	.db_cnt = 16,
+	.db_time = debounce_time_mt6765,
 };
 static struct mtk_pin_soc mt7986a_data = {

drivers/pinctrl/mediatek/pinctrl-mt8127.c+1−0

@@ -286,6 +286,7 @@ static const struct mtk_pinctrl_devdata mt8127_pinctrl_data = { · 285 unmodified lines
286	.ports = 6,	286	.ports = 6,
287	.ap_num = 143,	287	.ap_num = 143,
288	.db_cnt = 16,	288	.db_cnt = 16,
		289	.db_time = debounce_time_mt2701,
289	},	290	},
290	};	291	};
291		292

drivers/pinctrl/mediatek/pinctrl-mt8135.c+1−0

@@ -315,6 +315,7 @@ static const struct mtk_pinctrl_devdata mt8135_pinctrl_data = { · 314 unmodified lines
315	.ports = 6,	315	.ports = 6,
316	.ap_num = 192,	316	.ap_num = 192,
317	.db_cnt = 16,	317	.db_cnt = 16,
		318	.db_time = debounce_time_mt2701,
318	},	319	},
319	};	320	};
320		321

drivers/pinctrl/mediatek/pinctrl-mt8167.c+1−0

@@ -319,6 +319,7 @@ static const struct mtk_pinctrl_devdata mt8167_pinctrl_data = { · 318 unmodified lines
319	.ports = 6,	319	.ports = 6,
320	.ap_num = 169,	320	.ap_num = 169,
321	.db_cnt = 64,	321	.db_cnt = 64,
		322	.db_time = debounce_time_mt6795,
322	},	323	},
323	};	324	};
324		325

drivers/pinctrl/mediatek/pinctrl-mt8173.c+1−0

@@ -327,6 +327,7 @@ static const struct mtk_pinctrl_devdata mt8173_pinctrl_data = { · 326 unmodified lines
327	.ports = 6,	327	.ports = 6,
328	.ap_num = 224,	328	.ap_num = 224,
329	.db_cnt = 16,	329	.db_cnt = 16,
		330	.db_time = debounce_time_mt2701,
330	},	331	},
331	};	332	};
332		333

drivers/pinctrl/mediatek/pinctrl-mt8183.c+1−0

@@ -545,6 +545,7 @@ static const struct mtk_eint_hw mt8183_eint_hw = { · 544 unmodified lines
545	.ports = 6,	545	.ports = 6,
546	.ap_num = 212,	546	.ap_num = 212,
547	.db_cnt = 13,	547	.db_cnt = 13,
		548	.db_time = debounce_time_mt6765,
548	};	549	};
549		550
550	static const struct mtk_pin_soc mt8183_data = {	551	static const struct mtk_pin_soc mt8183_data = {

drivers/pinctrl/mediatek/pinctrl-mt8186.c+1−0

@@ -1222,6 +1222,7 @@ static const struct mtk_eint_hw mt8186_eint_hw = { · 1221 unmodified lines
1222	.ports = 7,	1222	.ports = 7,
1223	.ap_num = 217,	1223	.ap_num = 217,
1224	.db_cnt = 32,	1224	.db_cnt = 32,
		1225	.db_time = debounce_time_mt6765,
1225	};	1226	};
1226		1227
1227	static const struct mtk_pin_soc mt8186_data = {	1228	static const struct mtk_pin_soc mt8186_data = {

drivers/pinctrl/mediatek/pinctrl-mt8188.c+1−0

@@ -1625,6 +1625,7 @@ static const struct mtk_eint_hw mt8188_eint_hw = { · 1624 unmodified lines
1625	.ports = 7,	1625	.ports = 7,
1626	.ap_num = 225,	1626	.ap_num = 225,
1627	.db_cnt = 32,	1627	.db_cnt = 32,
		1628	.db_time = debounce_time_mt6765,
1628	};	1629	};
1629		1630
1630	static const struct mtk_pin_soc mt8188_data = {	1631	static const struct mtk_pin_soc mt8188_data = {

drivers/pinctrl/mediatek/pinctrl-mt8192.c+1−0

@@ -1371,6 +1371,7 @@ static const struct mtk_eint_hw mt8192_eint_hw = { · 1370 unmodified lines
1371	.ports = 7,	1371	.ports = 7,
1372	.ap_num = 224,	1372	.ap_num = 224,
1373	.db_cnt = 32,	1373	.db_cnt = 32,
		1374	.db_time = debounce_time_mt6765,
1374	};	1375	};
1375		1376
1376	static const struct mtk_pin_reg_calc mt8192_reg_cals[PINCTRL_PIN_REG_MAX] = {	1377	static const struct mtk_pin_reg_calc mt8192_reg_cals[PINCTRL_PIN_REG_MAX] = {

drivers/pinctrl/mediatek/pinctrl-mt8195.c+1−0

@@ -935,6 +935,7 @@ static const struct mtk_eint_hw mt8195_eint_hw = { · 934 unmodified lines
935	.ports = 7,	935	.ports = 7,
936	.ap_num = 225,	936	.ap_num = 225,
937	.db_cnt = 32,	937	.db_cnt = 32,
		938	.db_time = debounce_time_mt6765,
938	};	939	};
939		940
940	static const struct mtk_pin_soc mt8195_data = {	941	static const struct mtk_pin_soc mt8195_data = {

drivers/pinctrl/mediatek/pinctrl-mt8365.c+1−0

@@ -453,6 +453,7 @@ static const struct mtk_pinctrl_devdata mt8365_pinctrl_data = { · 452 unmodified lines
453	.ports = 5,	453	.ports = 5,
454	.ap_num = 160,	454	.ap_num = 160,
455	.db_cnt = 160,	455	.db_cnt = 160,
		456	.db_time = debounce_time_mt6765,
456	},	457	},
457	};	458	};
458		459

drivers/pinctrl/mediatek/pinctrl-mt8516.c+1−0

@@ -319,6 +319,7 @@ static const struct mtk_pinctrl_devdata mt8516_pinctrl_data = { · 318 unmodified lines
319	.ports = 6,	319	.ports = 6,
320	.ap_num = 169,	320	.ap_num = 169,
321	.db_cnt = 64,	321	.db_cnt = 64,
		322	.db_time = debounce_time_mt6795,
322	},	323	},
323	};	324	};
324		325

drivers/pinctrl/mediatek/pinctrl-mtk-common-v2.c+3−0

@@ -709,6 +709,9 @@ static int mtk_pinconf_bias_set_rsel(struct mtk_pinctrl *hw, · 708 unmodified lines
709	{	709	{
710	int err, rsel_val;	710	int err, rsel_val;
711		711
		712	if (!pullup && arg == MTK_DISABLE)
		713	return 0;
		714
712	if (hw->rsel_si_unit) {	715	if (hw->rsel_si_unit) {
713	/* find pin rsel_index from pin_rsel array*/	716	/* find pin rsel_index from pin_rsel array*/
714	err = mtk_hw_pin_rsel_lookup(hw, desc, pullup, arg, &rsel_val);	717	err = mtk_hw_pin_rsel_lookup(hw, desc, pullup, arg, &rsel_val);

drivers/pinctrl/pinctrl-rockchip.c+40−0

@@ -679,14 +679,54 @@ static void rockchip_get_recalced_mux(struct rockchip_pin_bank *bank, int pin, · 678 unmodified lines
679	}	679	}
680		680
681	static struct rockchip_mux_route_data px30_mux_route_data[] = {	681	static struct rockchip_mux_route_data px30_mux_route_data[] = {
		682	RK_MUXROUTE_SAME(2, RK_PB4, 1, 0x184, BIT(16 + 7)), /* cif-d0m0 */
		683	RK_MUXROUTE_SAME(3, RK_PA1, 3, 0x184, BIT(16 + 7) \| BIT(7)), /* cif-d0m1 */
		684	RK_MUXROUTE_SAME(2, RK_PB6, 1, 0x184, BIT(16 + 7)), /* cif-d1m0 */
		685	RK_MUXROUTE_SAME(3, RK_PA2, 3, 0x184, BIT(16 + 7) \| BIT(7)), /* cif-d1m1 */
682	RK_MUXROUTE_SAME(2, RK_PA0, 1, 0x184, BIT(16 + 7)), /* cif-d2m0 */	686	RK_MUXROUTE_SAME(2, RK_PA0, 1, 0x184, BIT(16 + 7)), /* cif-d2m0 */
683	RK_MUXROUTE_SAME(3, RK_PA3, 3, 0x184, BIT(16 + 7) \| BIT(7)), /* cif-d2m1 */	687	RK_MUXROUTE_SAME(3, RK_PA3, 3, 0x184, BIT(16 + 7) \| BIT(7)), /* cif-d2m1 */
		688	RK_MUXROUTE_SAME(2, RK_PA1, 1, 0x184, BIT(16 + 7)), /* cif-d3m0 */
		689	RK_MUXROUTE_SAME(3, RK_PA5, 3, 0x184, BIT(16 + 7) \| BIT(7)), /* cif-d3m1 */
		690	RK_MUXROUTE_SAME(2, RK_PA2, 1, 0x184, BIT(16 + 7)), /* cif-d4m0 */
		691	RK_MUXROUTE_SAME(3, RK_PA7, 3, 0x184, BIT(16 + 7) \| BIT(7)), /* cif-d4m1 */
		692	RK_MUXROUTE_SAME(2, RK_PA3, 1, 0x184, BIT(16 + 7)), /* cif-d5m0 */
		693	RK_MUXROUTE_SAME(3, RK_PB0, 3, 0x184, BIT(16 + 7) \| BIT(7)), /* cif-d5m1 */
		694	RK_MUXROUTE_SAME(2, RK_PA4, 1, 0x184, BIT(16 + 7)), /* cif-d6m0 */
		695	RK_MUXROUTE_SAME(3, RK_PB1, 3, 0x184, BIT(16 + 7) \| BIT(7)), /* cif-d6m1 */
		696	RK_MUXROUTE_SAME(2, RK_PA5, 1, 0x184, BIT(16 + 7)), /* cif-d7m0 */
		697	RK_MUXROUTE_SAME(3, RK_PB4, 3, 0x184, BIT(16 + 7) \| BIT(7)), /* cif-d7m1 */
		698	RK_MUXROUTE_SAME(2, RK_PA6, 1, 0x184, BIT(16 + 7)), /* cif-d8m0 */
		699	RK_MUXROUTE_SAME(3, RK_PB6, 3, 0x184, BIT(16 + 7) \| BIT(7)), /* cif-d8m1 */
		700	RK_MUXROUTE_SAME(2, RK_PA7, 1, 0x184, BIT(16 + 7)), /* cif-d9m0 */
		701	RK_MUXROUTE_SAME(3, RK_PB7, 3, 0x184, BIT(16 + 7) \| BIT(7)), /* cif-d9m1 */
		702	RK_MUXROUTE_SAME(2, RK_PB7, 1, 0x184, BIT(16 + 7)), /* cif-d10m0 */
		703	RK_MUXROUTE_SAME(3, RK_PC6, 3, 0x184, BIT(16 + 7) \| BIT(7)), /* cif-d10m1 */
		704	RK_MUXROUTE_SAME(2, RK_PC0, 1, 0x184, BIT(16 + 7)), /* cif-d11m0 */
		705	RK_MUXROUTE_SAME(3, RK_PC7, 3, 0x184, BIT(16 + 7) \| BIT(7)), /* cif-d11m1 */
		706	RK_MUXROUTE_SAME(2, RK_PB0, 1, 0x184, BIT(16 + 7)), /* cif-vsyncm0 */
		707	RK_MUXROUTE_SAME(3, RK_PD1, 3, 0x184, BIT(16 + 7) \| BIT(7)), /* cif-vsyncm1 */
		708	RK_MUXROUTE_SAME(2, RK_PB1, 1, 0x184, BIT(16 + 7)), /* cif-hrefm0 */
		709	RK_MUXROUTE_SAME(3, RK_PD2, 3, 0x184, BIT(16 + 7) \| BIT(7)), /* cif-hrefm1 */
		710	RK_MUXROUTE_SAME(2, RK_PB2, 1, 0x184, BIT(16 + 7)), /* cif-clkinm0 */
		711	RK_MUXROUTE_SAME(3, RK_PD3, 3, 0x184, BIT(16 + 7) \| BIT(7)), /* cif-clkinm1 */
		712	RK_MUXROUTE_SAME(2, RK_PB3, 1, 0x184, BIT(16 + 7)), /* cif-clkoutm0 */
		713	RK_MUXROUTE_SAME(3, RK_PD0, 3, 0x184, BIT(16 + 7) \| BIT(7)), /* cif-clkoutm1 */
684	RK_MUXROUTE_SAME(3, RK_PC6, 2, 0x184, BIT(16 + 8)), /* pdm-m0 */	714	RK_MUXROUTE_SAME(3, RK_PC6, 2, 0x184, BIT(16 + 8)), /* pdm-m0 */
685	RK_MUXROUTE_SAME(2, RK_PC6, 1, 0x184, BIT(16 + 8) \| BIT(8)), /* pdm-m1 */	715	RK_MUXROUTE_SAME(2, RK_PC6, 1, 0x184, BIT(16 + 8) \| BIT(8)), /* pdm-m1 */
		716	RK_MUXROUTE_SAME(3, RK_PD3, 2, 0x184, BIT(16 + 8)), /* pdm-sdi0m0 */
		717	RK_MUXROUTE_SAME(2, RK_PC5, 2, 0x184, BIT(16 + 8) \| BIT(8)), /* pdm-sdi0m1 */
686	RK_MUXROUTE_SAME(1, RK_PD3, 2, 0x184, BIT(16 + 10)), /* uart2-rxm0 */	718	RK_MUXROUTE_SAME(1, RK_PD3, 2, 0x184, BIT(16 + 10)), /* uart2-rxm0 */
687	RK_MUXROUTE_SAME(2, RK_PB6, 2, 0x184, BIT(16 + 10) \| BIT(10)), /* uart2-rxm1 */	719	RK_MUXROUTE_SAME(2, RK_PB6, 2, 0x184, BIT(16 + 10) \| BIT(10)), /* uart2-rxm1 */
		720	RK_MUXROUTE_SAME(1, RK_PD2, 2, 0x184, BIT(16 + 10)), /* uart2-txm0 */
		721	RK_MUXROUTE_SAME(2, RK_PB4, 2, 0x184, BIT(16 + 10) \| BIT(10)), /* uart2-txm1 */
688	RK_MUXROUTE_SAME(0, RK_PC1, 2, 0x184, BIT(16 + 9)), /* uart3-rxm0 */	722	RK_MUXROUTE_SAME(0, RK_PC1, 2, 0x184, BIT(16 + 9)), /* uart3-rxm0 */
689	RK_MUXROUTE_SAME(1, RK_PB7, 2, 0x184, BIT(16 + 9) \| BIT(9)), /* uart3-rxm1 */	723	RK_MUXROUTE_SAME(1, RK_PB7, 2, 0x184, BIT(16 + 9) \| BIT(9)), /* uart3-rxm1 */
		724	RK_MUXROUTE_SAME(0, RK_PC0, 2, 0x184, BIT(16 + 9)), /* uart3-txm0 */
		725	RK_MUXROUTE_SAME(1, RK_PB6, 2, 0x184, BIT(16 + 9) \| BIT(9)), /* uart3-txm1 */
		726	RK_MUXROUTE_SAME(0, RK_PC2, 2, 0x184, BIT(16 + 9)), /* uart3-ctsm0 */
		727	RK_MUXROUTE_SAME(1, RK_PB4, 2, 0x184, BIT(16 + 9) \| BIT(9)), /* uart3-ctsm1 */
		728	RK_MUXROUTE_SAME(0, RK_PC3, 2, 0x184, BIT(16 + 9)), /* uart3-rtsm0 */
		729	RK_MUXROUTE_SAME(1, RK_PB5, 2, 0x184, BIT(16 + 9) \| BIT(9)), /* uart3-rtsm1 */
690	};	730	};
691		731
692	static struct rockchip_mux_route_data rv1126_mux_route_data[] = {	732	static struct rockchip_mux_route_data rv1126_mux_route_data[] = {

drivers/pinctrl/qcom/pinctrl-sc8280xp.c+2−2

@@ -1873,8 +1873,8 @@ static const struct msm_pingroup sc8280xp_groups[] = { · 1872 unmodified lines
1873	[225] = PINGROUP(225, hs3_mi2s, phase_flag, _, _, _, _, egpio),	1873	[225] = PINGROUP(225, hs3_mi2s, phase_flag, _, _, _, _, egpio),
1874	[226] = PINGROUP(226, hs3_mi2s, phase_flag, _, _, _, _, egpio),	1874	[226] = PINGROUP(226, hs3_mi2s, phase_flag, _, _, _, _, egpio),
1875	[227] = PINGROUP(227, hs3_mi2s, phase_flag, _, _, _, _, egpio),	1875	[227] = PINGROUP(227, hs3_mi2s, phase_flag, _, _, _, _, egpio),
1876	[228] = UFS_RESET(ufs_reset, 0xf1004),	1876	[228] = UFS_RESET(ufs_reset, 0xf1000),
1877	[229] = UFS_RESET(ufs1_reset, 0xf3004),	1877	[229] = UFS_RESET(ufs1_reset, 0xf3000),
1878	[230] = SDC_QDSD_PINGROUP(sdc2_clk, 0xe8000, 14, 6),	1878	[230] = SDC_QDSD_PINGROUP(sdc2_clk, 0xe8000, 14, 6),
1879	[231] = SDC_QDSD_PINGROUP(sdc2_cmd, 0xe8000, 11, 3),	1879	[231] = SDC_QDSD_PINGROUP(sdc2_cmd, 0xe8000, 11, 3),
1880	[232] = SDC_QDSD_PINGROUP(sdc2_data, 0xe8000, 9, 0),	1880	[232] = SDC_QDSD_PINGROUP(sdc2_data, 0xe8000, 9, 0),

drivers/platform/surface/aggregator/ssh_packet_layer.c+20−4

 		ssh_ptl_tx_wakeup_packet(ptl);
 }
-static bool ssh_ptl_rx_retransmit_check(struct ssh_ptl *ptl, u8 seq)
+static bool ssh_ptl_rx_retransmit_check(struct ssh_ptl *ptl, const struct ssh_frame *frame)
 {
 	int i;
+	/*
+	 * Ignore unsequenced packets. On some devices (notably Surface Pro 9),
+	 * unsequenced events will always be sent with SEQ=0x00. Attempting to
+	 * detect retransmission would thus just block all events.
+	 *
+	 * While sequence numbers would also allow detection of retransmitted
+	 * packets in unsequenced communication, they have only ever been used
+	 * to cover edge-cases in sequenced transmission. In particular, the
+	 * only instance of packets being retransmitted (that we are aware of)
+	 * is due to an ACK timeout. As this does not happen in unsequenced
+	 * communication, skip the retransmission check for those packets
+	 * entirely.
+	 */
+	if (frame->type == SSH_FRAME_TYPE_DATA_NSQ)
+		return false;
 	/*
 	 * Check if SEQ has been seen recently (i.e. packet was
 	 * re-transmitted and we should ignore it).
 	 */
 	for (i = 0; i < ARRAY_SIZE(ptl->rx.blocked.seqs); i++) {
-		if (likely(ptl->rx.blocked.seqs[i] != seq))
+		if (likely(ptl->rx.blocked.seqs[i] != frame->seq))
 			continue;
 		ptl_dbg(ptl, "ptl: ignoring repeated data packet\n");
 	}
 	/* Update list of blocked sequence IDs. */
-	ptl->rx.blocked.seqs[ptl->rx.blocked.offset] = seq;
+	ptl->rx.blocked.seqs[ptl->rx.blocked.offset] = frame->seq;
 	ptl->rx.blocked.offset = (ptl->rx.blocked.offset + 1)
 				  % ARRAY_SIZE(ptl->rx.blocked.seqs);
 				 const struct ssh_frame *frame,
 				 const struct ssam_span *payload)
 {
-	if (ssh_ptl_rx_retransmit_check(ptl, frame->seq))
+	if (ssh_ptl_rx_retransmit_check(ptl, frame))
 		return;
 	ptl->ops.data_received(ptl, payload);

drivers/platform/surface/surface_aggregator_registry.c+37−0

@@ -234,6 +234,19 @@ static const struct software_node *ssam_node_group_sl3[] = { · 233 unmodified lines
234	NULL,	234	NULL,
235	};	235	};
236		236
		237	/* Devices for Surface Laptop 5. */
		238	static const struct software_node *ssam_node_group_sl5[] = {
		239	&ssam_node_root,
		240	&ssam_node_bat_ac,
		241	&ssam_node_bat_main,
		242	&ssam_node_tmp_pprof,
		243	&ssam_node_hid_main_keyboard,
		244	&ssam_node_hid_main_touchpad,
		245	&ssam_node_hid_main_iid5,
		246	&ssam_node_hid_sam_ucm_ucsi,
		247	NULL,
		248	};
		249
237	/* Devices for Surface Laptop Studio. */	250	/* Devices for Surface Laptop Studio. */
238	static const struct software_node *ssam_node_group_sls[] = {	251	static const struct software_node *ssam_node_group_sls[] = {
239	&ssam_node_root,	252	&ssam_node_root,
@@ -268,6 +281,7 @@ static const struct software_node *ssam_node_group_sp7[] = { · 28 unmodified lines
268	NULL,	281	NULL,
269	};	282	};
270		283
		284	/* Devices for Surface Pro 8 */
271	static const struct software_node *ssam_node_group_sp8[] = {	285	static const struct software_node *ssam_node_group_sp8[] = {
272	&ssam_node_root,	286	&ssam_node_root,
273	&ssam_node_hub_kip,	287	&ssam_node_hub_kip,
@@ -284,6 +298,23 @@ static const struct software_node *ssam_node_group_sp8[] = { · 10 unmodified lines
284	NULL,	298	NULL,
285	};	299	};
286		300
		301	/* Devices for Surface Pro 9 */
		302	static const struct software_node *ssam_node_group_sp9[] = {
		303	&ssam_node_root,
		304	&ssam_node_hub_kip,
		305	&ssam_node_bat_ac,
		306	&ssam_node_bat_main,
		307	&ssam_node_tmp_pprof,
		308	/* TODO: Tablet mode switch (via POS subsystem) */
		309	&ssam_node_hid_kip_keyboard,
		310	&ssam_node_hid_kip_penstash,
		311	&ssam_node_hid_kip_touchpad,
		312	&ssam_node_hid_kip_fwupd,
		313	&ssam_node_hid_sam_sensors,
		314	&ssam_node_hid_sam_ucm_ucsi,
		315	NULL,
		316	};
		317
287		318
288	/* -- SSAM platform/meta-hub driver. ---------------------------------------- */	319	/* -- SSAM platform/meta-hub driver. ---------------------------------------- */
289		320
@@ -303,6 +334,9 @@ static const struct acpi_device_id ssam_platform_hub_match[] = { · 13 unmodified lines
303	/* Surface Pro 8 */	334	/* Surface Pro 8 */
304	{ "MSHW0263", (unsigned long)ssam_node_group_sp8 },	335	{ "MSHW0263", (unsigned long)ssam_node_group_sp8 },
305		336
		337	/* Surface Pro 9 */
		338	{ "MSHW0343", (unsigned long)ssam_node_group_sp9 },
		339
306	/* Surface Book 2 */	340	/* Surface Book 2 */
307	{ "MSHW0107", (unsigned long)ssam_node_group_gen5 },	341	{ "MSHW0107", (unsigned long)ssam_node_group_gen5 },
308		342
@@ -324,6 +358,9 @@ static const struct acpi_device_id ssam_platform_hub_match[] = { · 15 unmodified lines
324	/* Surface Laptop 4 (13", Intel) */	358	/* Surface Laptop 4 (13", Intel) */
325	{ "MSHW0250", (unsigned long)ssam_node_group_sl3 },	359	{ "MSHW0250", (unsigned long)ssam_node_group_sl3 },
326		360
		361	/* Surface Laptop 5 */
		362	{ "MSHW0350", (unsigned long)ssam_node_group_sl5 },
		363
327	/* Surface Laptop Go 1 */	364	/* Surface Laptop Go 1 */
328	{ "MSHW0118", (unsigned long)ssam_node_group_slg1 },	365	{ "MSHW0118", (unsigned long)ssam_node_group_slg1 },
329		366

drivers/platform/x86/acer-wmi.c+9−0

@@ -564,6 +564,15 @@ static const struct dmi_system_id acer_quirks[] __initconst = { · 563 unmodified lines
564	},	564	},
565	.driver_data = (void *)ACER_CAP_KBD_DOCK,	565	.driver_data = (void *)ACER_CAP_KBD_DOCK,
566	},	566	},
		567	{
		568	.callback = set_force_caps,
		569	.ident = "Acer Aspire Switch V 10 SW5-017",
		570	.matches = {
		571	DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Acer"),
		572	DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "SW5-017"),
		573	},
		574	.driver_data = (void *)ACER_CAP_KBD_DOCK,
		575	},
567	{	576	{
568	.callback = set_force_caps,	577	.callback = set_force_caps,
569	.ident = "Acer One 10 (S1003)",	578	.ident = "Acer One 10 (S1003)",

drivers/platform/x86/amd/pmc.c+1−2

 	.release = amd_pmc_stb_debugfs_release_v2,
 };
-#if defined(CONFIG_SUSPEND) || defined(CONFIG_DEBUG_FS)
 static int amd_pmc_setup_smu_logging(struct amd_pmc_dev *dev)
 {
 	if (dev->cpu_id == AMD_CPU_ID_PCO) {
 	memcpy_fromio(table, pdev->smu_virt_addr, sizeof(struct smu_metrics));
 	return 0;
 }
-#endif /* CONFIG_SUSPEND || CONFIG_DEBUG_FS */
 #ifdef CONFIG_SUSPEND
 static void amd_pmc_validate_deepest(struct amd_pmc_dev *pdev)
 	{"AMDI0006", 0},
 	{"AMDI0007", 0},
 	{"AMDI0008", 0},
+	{"AMDI0009", 0},
 	{"AMD0004", 0},
 	{"AMD0005", 0},
 	{ }

drivers/platform/x86/asus-wmi.c+2−0

@@ -1738,6 +1738,8 @@ static void asus_wmi_set_xusb2pr(struct asus_wmi *asus) · 1737 unmodified lines
1738	pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,	1738	pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
1739	cpu_to_le32(ports_available));	1739	cpu_to_le32(ports_available));
1740		1740
		1741	pci_dev_put(xhci_pdev);
		1742
1741	pr_info("set USB_INTEL_XUSB2PR old: 0x%04x, new: 0x%04x\n",	1743	pr_info("set USB_INTEL_XUSB2PR old: 0x%04x, new: 0x%04x\n",
1742	orig_ports_available, ports_available);	1744	orig_ports_available, ports_available);
1743	}	1745	}

drivers/platform/x86/hp-wmi.c+3−0

 	HPWMI_PEAKSHIFT_PERIOD		= 0x0F,
 	HPWMI_BATTERY_CHARGE_PERIOD	= 0x10,
 	HPWMI_SANITIZATION_MODE		= 0x17,
+	HPWMI_SMART_EXPERIENCE_APP	= 0x21,
 };
 /*
 		break;
 	case HPWMI_SANITIZATION_MODE:
 		break;
+	case HPWMI_SMART_EXPERIENCE_APP:
+		break;
 	default:
 		pr_info("Unknown event_id - %d - 0x%x\n", event_id, event_data);
 		break;

drivers/platform/x86/ideapad-laptop.c+35−2

@@ -136,6 +136,7 @@ struct ideapad_private { · 135 unmodified lines
136	bool dytc : 1;	136	bool dytc : 1;
137	bool fan_mode : 1;	137	bool fan_mode : 1;
138	bool fn_lock : 1;	138	bool fn_lock : 1;
		139	bool set_fn_lock_led : 1;
139	bool hw_rfkill_switch : 1;	140	bool hw_rfkill_switch : 1;
140	bool kbd_bl : 1;	141	bool kbd_bl : 1;
141	bool touchpad_ctrl_via_ec : 1;	142	bool touchpad_ctrl_via_ec : 1;
@@ -154,7 +155,21 @@ MODULE_PARM_DESC(no_bt_rfkill, "No rfkill for bluetooth."); · 12 unmodified lines
154		155
155	static bool allow_v4_dytc;	156	static bool allow_v4_dytc;
156	module_param(allow_v4_dytc, bool, 0444);	157	module_param(allow_v4_dytc, bool, 0444);
157	MODULE_PARM_DESC(allow_v4_dytc, "Enable DYTC version 4 platform-profile support.");	158	MODULE_PARM_DESC(allow_v4_dytc,
		159	"Enable DYTC version 4 platform-profile support. "
		160	"If you need this please report this to: platform-driver-x86@vger.kernel.org");
		161
		162	static bool hw_rfkill_switch;
		163	module_param(hw_rfkill_switch, bool, 0444);
		164	MODULE_PARM_DESC(hw_rfkill_switch,
		165	"Enable rfkill support for laptops with a hw on/off wifi switch/slider. "
		166	"If you need this please report this to: platform-driver-x86@vger.kernel.org");
		167
		168	static bool set_fn_lock_led;
		169	module_param(set_fn_lock_led, bool, 0444);
		170	MODULE_PARM_DESC(set_fn_lock_led,
		171	"Enable driver based updates of the fn-lock LED on fn-lock changes. "
		172	"If you need this please report this to: platform-driver-x86@vger.kernel.org");
158		173
159	/*	174	/*
160	* ACPI Helpers	175	* ACPI Helpers
@@ -1501,6 +1516,9 @@ static void ideapad_wmi_notify(u32 value, void *context) · 1340 unmodified lines
1501	ideapad_input_report(priv, value);	1516	ideapad_input_report(priv, value);
1502	break;	1517	break;
1503	case 208:	1518	case 208:
		1519	if (!priv->features.set_fn_lock_led)
		1520	break;
		1521
1504	if (!eval_hals(priv->adev->handle, &result)) {	1522	if (!eval_hals(priv->adev->handle, &result)) {
1505	bool state = test_bit(HALS_FNLOCK_STATE_BIT, &result);	1523	bool state = test_bit(HALS_FNLOCK_STATE_BIT, &result);
1506		1524
@@ -1514,6 +1532,18 @@ static void ideapad_wmi_notify(u32 value, void *context) · 7 unmodified lines
1514	}	1532	}
1515	#endif	1533	#endif
1516		1534
		1535	/* On some models we need to call exec_sals(SALS_FNLOCK_ON/OFF) to set the LED */
		1536	static const struct dmi_system_id set_fn_lock_led_list[] = {
		1537	{
		1538	/* https://bugzilla.kernel.org/show_bug.cgi?id=212671 */
		1539	.matches = {
		1540	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
		1541	DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Legion R7000P2020H"),
		1542	}
		1543	},
		1544	{}
		1545	};
		1546
1517	/*	1547	/*
1518	* Some ideapads have a hardware rfkill switch, but most do not have one.	1548	* Some ideapads have a hardware rfkill switch, but most do not have one.
1519	* Reading VPCCMD_R_RF always results in 0 on models without a hardware rfkill,	1549	* Reading VPCCMD_R_RF always results in 0 on models without a hardware rfkill,
@@ -1556,7 +1586,10 @@ static void ideapad_check_features(struct ideapad_private *priv) · 36 unmodified lines
1556	acpi_handle handle = priv->adev->handle;	1586	acpi_handle handle = priv->adev->handle;
1557	unsigned long val;	1587	unsigned long val;
1558		1588
1559	priv->features.hw_rfkill_switch = dmi_check_system(hw_rfkill_list);	1589	priv->features.set_fn_lock_led =
		1590	set_fn_lock_led \|\| dmi_check_system(set_fn_lock_led_list);
		1591	priv->features.hw_rfkill_switch =
		1592	hw_rfkill_switch \|\| dmi_check_system(hw_rfkill_list);
1560		1593
1561	/* Most ideapads with ELAN0634 touchpad don't use EC touchpad switch */	1594	/* Most ideapads with ELAN0634 touchpad don't use EC touchpad switch */
1562	if (acpi_dev_present("ELAN0634", NULL, -1))	1595	if (acpi_dev_present("ELAN0634", NULL, -1))

drivers/platform/x86/intel/pmc/pltdrv.c+9−0

 #include <asm/cpu_device_id.h>
 #include <asm/intel-family.h>
+#include <xen/xen.h>
 static void intel_pmc_core_release(struct device *dev)
 {
 	kfree(dev);
 	if (acpi_dev_present("INT33A1", NULL, -1))
 		return -ENODEV;
+	/*
+	 * Skip forcefully attaching the device for VMs. Make an exception for
+	 * Xen dom0, which does have full hardware access.
+	 */
+	if (cpu_feature_enabled(X86_FEATURE_HYPERVISOR) && !xen_initial_domain())
+		return -ENODEV;
 	if (!x86_match_cpu(intel_pmc_core_platform_ids))
 		return -ENODEV;

drivers/platform/x86/thinkpad_acpi.c+8−0

@@ -4497,6 +4497,14 @@ static const struct dmi_system_id fwbug_list[] __initconst = { · 4496 unmodified lines
4497	DMI_MATCH(DMI_PRODUCT_NAME, "21A0"),	4497	DMI_MATCH(DMI_PRODUCT_NAME, "21A0"),
4498	}	4498	}
4499	},	4499	},
		4500	{
		4501	.ident = "P14s Gen2 AMD",
		4502	.driver_data = &quirk_s2idle_bug,
		4503	.matches = {
		4504	DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
		4505	DMI_MATCH(DMI_PRODUCT_NAME, "21A1"),
		4506	}
		4507	},
4500	{}	4508	{}
4501	};	4509	};
4502		4510

drivers/s390/block/dcssblk.c+1−0

@@ -636,6 +636,7 @@ dcssblk_add_store(struct device dev, struct device_attribute attr, const char · 635 unmodified lines
636	dev_info->gd->minors = DCSSBLK_MINORS_PER_DISK;	636	dev_info->gd->minors = DCSSBLK_MINORS_PER_DISK;
637	dev_info->gd->fops = &dcssblk_devops;	637	dev_info->gd->fops = &dcssblk_devops;
638	dev_info->gd->private_data = dev_info;	638	dev_info->gd->private_data = dev_info;
		639	dev_info->gd->flags \|= GENHD_FL_NO_PART;
639	blk_queue_logical_block_size(dev_info->gd->queue, 4096);	640	blk_queue_logical_block_size(dev_info->gd->queue, 4096);
640	blk_queue_flag_set(QUEUE_FLAG_DAX, dev_info->gd->queue);	641	blk_queue_flag_set(QUEUE_FLAG_DAX, dev_info->gd->queue);
641		642

drivers/s390/scsi/zfcp_fsf.c+1−1

@@ -884,7 +884,7 @@ static int zfcp_fsf_req_send(struct zfcp_fsf_req *req) · 883 unmodified lines
884	const bool is_srb = zfcp_fsf_req_is_status_read_buffer(req);	884	const bool is_srb = zfcp_fsf_req_is_status_read_buffer(req);
885	struct zfcp_adapter *adapter = req->adapter;	885	struct zfcp_adapter *adapter = req->adapter;
886	struct zfcp_qdio *qdio = adapter->qdio;	886	struct zfcp_qdio *qdio = adapter->qdio;
887	int req_id = req->req_id;	887	unsigned long req_id = req->req_id;
888		888
889	zfcp_reqlist_add(adapter->req_list, req);	889	zfcp_reqlist_add(adapter->req_list, req);
890		890

drivers/scsi/mpi3mr/mpi3mr_os.c+2−1

@@ -3265,7 +3265,8 @@ void mpi3mr_process_op_reply_desc(struct mpi3mr_ioc *mrioc, · 3264 unmodified lines
3265	}	3265	}
3266		3266
3267	if (scmd->result != (DID_OK << 16) && (scmd->cmnd[0] != ATA_12) &&	3267	if (scmd->result != (DID_OK << 16) && (scmd->cmnd[0] != ATA_12) &&
3268	(scmd->cmnd[0] != ATA_16)) {	3268	(scmd->cmnd[0] != ATA_16) &&
		3269	mrioc->logging_level & MPI3_DEBUG_SCSI_ERROR) {
3269	ioc_info(mrioc, "%s :scmd->result 0x%x\n", __func__,	3270	ioc_info(mrioc, "%s :scmd->result 0x%x\n", __func__,
3270	scmd->result);	3271	scmd->result);
3271	scsi_print_command(scmd);	3272	scsi_print_command(scmd);

drivers/scsi/scsi_debug.c+5−1

 	dev_set_name(&sdbg_host->dev, "adapter%d", sdebug_num_hosts);
 	error = device_register(&sdbg_host->dev);
-	if (error)
+	if (error) {
+		spin_lock(&sdebug_host_list_lock);
+		list_del(&sdbg_host->host_list);
+		spin_unlock(&sdebug_host_list_lock);
 		goto clean;
+	}
 	++sdebug_num_hosts;
 	return 0;

drivers/scsi/scsi_transport_iscsi.c+16−15

 	dev_set_name(&ep->dev, "ep-%d", id);
 	err = device_register(&ep->dev);
         if (err)
-		goto free_id;
+		goto put_dev;
 	err = sysfs_create_group(&ep->dev.kobj, &iscsi_endpoint_group);
 	if (err)
 	device_unregister(&ep->dev);
 	return NULL;
-free_id:
+put_dev:
 	mutex_lock(&iscsi_ep_idr_mutex);
 	idr_remove(&iscsi_ep_idr, id);
 	mutex_unlock(&iscsi_ep_idr_mutex);
+	put_device(&ep->dev);
+	return NULL;
 free_ep:
 	kfree(ep);
 	return NULL;
 	err = device_register(&iface->dev);
 	if (err)
-		goto free_iface;
+		goto put_dev;
 	err = sysfs_create_group(&iface->dev.kobj, &iscsi_iface_group);
 	if (err)
 	device_unregister(&iface->dev);
 	return NULL;
-free_iface:
+put_dev:
-	put_device(iface->dev.parent);
+	put_device(&iface->dev);
-	kfree(iface);
 	return NULL;
 }
 EXPORT_SYMBOL_GPL(iscsi_create_iface);
 	err = device_register(&fnode_sess->dev);
 	if (err)
-		goto free_fnode_sess;
+		goto put_dev;
 	if (dd_size)
 		fnode_sess->dd_data = &fnode_sess[1];
 	return fnode_sess;
-free_fnode_sess:
+put_dev:
-	kfree(fnode_sess);
+	put_device(&fnode_sess->dev);
 	return NULL;
 }
 EXPORT_SYMBOL_GPL(iscsi_create_flashnode_sess);
 	err = device_register(&fnode_conn->dev);
 	if (err)
-		goto free_fnode_conn;
+		goto put_dev;
 	if (dd_size)
 		fnode_conn->dd_data = &fnode_conn[1];
 	return fnode_conn;
-free_fnode_conn:
+put_dev:
-	kfree(fnode_conn);
+	put_device(&fnode_conn->dev);
 	return NULL;
 }
 EXPORT_SYMBOL_GPL(iscsi_create_flashnode_conn);
 	dev_set_name(&priv->dev, "%s", tt->name);
 	err = device_register(&priv->dev);
 	if (err)
-		goto free_priv;
+		goto put_dev;
 	err = sysfs_create_group(&priv->dev.kobj, &iscsi_transport_group);
 	if (err)
 unregister_dev:
 	device_unregister(&priv->dev);
 	return NULL;
-free_priv:
+put_dev:
-	kfree(priv);
+	put_device(&priv->dev);
 	return NULL;
 }
 EXPORT_SYMBOL_GPL(iscsi_register_transport);

drivers/siox/siox-core.c+2−0

@@ -839,6 +839,8 @@ static struct siox_device siox_device_add(struct siox_master smaster, · 838 unmodified lines
839		839
840	err_device_register:	840	err_device_register:
841	/* don't care to make the buffer smaller again */	841	/* don't care to make the buffer smaller again */
		842	put_device(&sdevice->dev);
		843	sdevice = NULL;
842		844
843	err_buf_alloc:	845	err_buf_alloc:
844	siox_master_unlock(smaster);	846	siox_master_unlock(smaster);

drivers/slimbus/Kconfig+1−1

@@ -23,7 +23,7 @@ config SLIM_QCOM_CTRL · 22 unmodified lines
23	config SLIM_QCOM_NGD_CTRL	23	config SLIM_QCOM_NGD_CTRL
24	tristate "Qualcomm SLIMbus Satellite Non-Generic Device Component"	24	tristate "Qualcomm SLIMbus Satellite Non-Generic Device Component"
25	depends on HAS_IOMEM && DMA_ENGINE && NET	25	depends on HAS_IOMEM && DMA_ENGINE && NET
26	depends on QCOM_RPROC_COMMON \|\| COMPILE_TEST	26	depends on QCOM_RPROC_COMMON \|\| (COMPILE_TEST && !QCOM_RPROC_COMMON)
27	depends on ARCH_QCOM \|\| COMPILE_TEST	27	depends on ARCH_QCOM \|\| COMPILE_TEST
28	select QCOM_QMI_HELPERS	28	select QCOM_QMI_HELPERS
29	select QCOM_PDR_HELPERS	29	select QCOM_PDR_HELPERS

drivers/slimbus/stream.c+4−4

@@ -67,10 +67,10 @@ static const int slim_presence_rate_table[] = { · 66 unmodified lines
67	384000,	67	384000,
68	768000,	68	768000,
69	0, /* Reserved */	69	0, /* Reserved */
70	110250,	70	11025,
71	220500,	71	22050,
72	441000,	72	44100,
73	882000,	73	88200,
74	176400,	74	176400,
75	352800,	75	352800,
76	705600,	76	705600,

drivers/soc/imx/soc-imx8m.c+11−0

 #include <linux/platform_device.h>
 #include <linux/arm-smccc.h>
 #include <linux/of.h>
+#include <linux/clk.h>
 #define REV_B1				0x21
 	void __iomem *ocotp_base;
 	u32 magic;
 	u32 rev;
+	struct clk *clk;
 	np = of_find_compatible_node(NULL, NULL, "fsl,imx8mq-ocotp");
 	if (!np)
 	ocotp_base = of_iomap(np, 0);
 	WARN_ON(!ocotp_base);
+	clk = of_clk_get_by_name(np, NULL);
+	if (!clk) {
+		WARN_ON(!clk);
+		return 0;
+	}
+	clk_prepare_enable(clk);
 	/*
 	 * SOC revision on older imx8mq is not available in fuses so query
 	soc_uid <<= 32;
 	soc_uid |= readl_relaxed(ocotp_base + OCOTP_UID_LOW);
+	clk_disable_unprepare(clk);
+	clk_put(clk);
 	iounmap(ocotp_base);
 	of_node_put(np);

drivers/staging/rtl8192e/rtllib_softmac_wx.c+1−8

 			union iwreq_data *wrqu, char *extra)
 {
-	int ret = 0, len, i;
+	int ret = 0, len;
 	short proto_started;
 	unsigned long flags;
 		goto out;
 	}
-	for (i = 0; i < len; i++) {
-		if (extra[i] < 0) {
-			ret = -1;
-			goto out;
-		}
-	}
 	if (proto_started)
 		rtllib_stop_protocol(ieee, true);

drivers/target/loopback/tcm_loop.c+2−1

 	ret = device_register(&tl_hba->dev);
 	if (ret) {
 		pr_err("device_register() failed for tl_hba->dev: %d\n", ret);
+		put_device(&tl_hba->dev);
 		return -ENODEV;
 	}
 	 */
 	ret = tcm_loop_setup_hba_bus(tl_hba, tcm_loop_hba_no_cnt);
 	if (ret)
-		goto out;
+		return ERR_PTR(ret);
 	sh = tl_hba->sh;
 	tcm_loop_hba_no_cnt++;

drivers/tty/n_gsm.c+38−33

 	bool constipated;		/* Asked by remote to shut up */
 	bool has_devices;		/* Devices were registered */
-	struct mutex tx_mutex;
+	spinlock_t tx_lock;
 	unsigned int tx_bytes;		/* TX data outstanding */
 #define TX_THRESH_HI		8192
 #define TX_THRESH_LO		2048
 	struct list_head tx_data_list;	/* Pending data packets */
 	/* Control messages */
-	struct delayed_work kick_timeout;	/* Kick TX queuing on timeout */
+	struct timer_list kick_timer;	/* Kick TX queuing on timeout */
 	struct timer_list t2_timer;	/* Retransmit timer for commands */
 	int cretries;			/* Command retry counter */
 	struct gsm_control *pending_cmd;/* Our current pending command */
 	struct gsm_msg *msg;
 	u8 *dp;
 	int ocr;
+	unsigned long flags;
 	msg = gsm_data_alloc(gsm, addr, 0, control);
 	if (!msg)
 	gsm_print_packet("Q->", addr, cr, control, NULL, 0);
-	mutex_lock(&gsm->tx_mutex);
+	spin_lock_irqsave(&gsm->tx_lock, flags);
 	list_add_tail(&msg->list, &gsm->tx_ctrl_list);
 	gsm->tx_bytes += msg->len;
-	mutex_unlock(&gsm->tx_mutex);
+	spin_unlock_irqrestore(&gsm->tx_lock, flags);
 	gsmld_write_trigger(gsm);
 	return 0;
 	spin_unlock_irqrestore(&dlci->lock, flags);
 	/* Clear data packets in MUX write queue */
-	mutex_lock(&gsm->tx_mutex);
+	spin_lock_irqsave(&gsm->tx_lock, flags);
 	list_for_each_entry_safe(msg, nmsg, &gsm->tx_data_list, list) {
 		if (msg->addr != addr)
 			continue;
 		list_del(&msg->list);
 		kfree(msg);
 	}
-	mutex_unlock(&gsm->tx_mutex);
+	spin_unlock_irqrestore(&gsm->tx_lock, flags);
 }
 /**
 	gsm->tx_bytes += msg->len;
 	gsmld_write_trigger(gsm);
-	schedule_delayed_work(&gsm->kick_timeout, 10 * gsm->t1 * HZ / 100);
+	mod_timer(&gsm->kick_timer, jiffies + 10 * gsm->t1 * HZ / 100);
 }
 /**
 static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
 {
-	mutex_lock(&dlci->gsm->tx_mutex);
+	unsigned long flags;
+	spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
 	__gsm_data_queue(dlci, msg);
-	mutex_unlock(&dlci->gsm->tx_mutex);
+	spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
 }
 /**
  *	is data. Keep to the MRU of the mux. This path handles the usual tty
  *	interface which is a byte stream with optional modem data.
  *
- *	Caller must hold the tx_mutex of the mux.
+ *	Caller must hold the tx_lock of the mux.
  */
 static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci)
  *	is data. Keep to the MRU of the mux. This path handles framed data
  *	queued as skbuffs to the DLCI.
  *
- *	Caller must hold the tx_mutex of the mux.
+ *	Caller must hold the tx_lock of the mux.
  */
 static int gsm_dlci_data_output_framed(struct gsm_mux *gsm,
 	if (dlci->adaption == 4)
 		overhead = 1;
-	/* dlci->skb is locked by tx_mutex */
+	/* dlci->skb is locked by tx_lock */
 	if (dlci->skb == NULL) {
 		dlci->skb = skb_dequeue_tail(&dlci->skb_list);
 		if (dlci->skb == NULL)
  *	Push an empty frame in to the transmit queue to update the modem status
  *	bits and to transmit an optional break.
  *
- *	Caller must hold the tx_mutex of the mux.
+ *	Caller must hold the tx_lock of the mux.
  */
 static int gsm_dlci_modem_output(struct gsm_mux *gsm, struct gsm_dlci *dlci,
 static void gsm_dlci_data_kick(struct gsm_dlci *dlci)
 {
+	unsigned long flags;
 	int sweep;
 	if (dlci->constipated)
 		return;
-	mutex_lock(&dlci->gsm->tx_mutex);
+	spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
 	/* If we have nothing running then we need to fire up */
 	sweep = (dlci->gsm->tx_bytes < TX_THRESH_LO);
 	if (dlci->gsm->tx_bytes == 0) {
 	}
 	if (sweep)
 		gsm_dlci_data_sweep(dlci->gsm);
-	mutex_unlock(&dlci->gsm->tx_mutex);
+	spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
 }
 /*
 		unsigned int command, u8 *data, int clen)
 {
 	struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control),
-						GFP_KERNEL);
+						GFP_ATOMIC);
 	unsigned long flags;
 	if (ctrl == NULL)
 		return NULL;
 }
 /**
- *	gsm_kick_timeout	-	transmit if possible
+ *	gsm_kick_timer	-	transmit if possible
- *	@work: work contained in our gsm object
+ *	@t: timer contained in our gsm object
  *
  *	Transmit data from DLCIs if the queue is empty. We can't rely on
  *	a tty wakeup except when we filled the pipe so we need to fire off
  *	new data ourselves in other cases.
  */
-static void gsm_kick_timeout(struct work_struct *work)
+static void gsm_kick_timer(struct timer_list *t)
 {
-	struct gsm_mux *gsm = container_of(work, struct gsm_mux, kick_timeout.work);
+	struct gsm_mux *gsm = from_timer(gsm, t, kick_timer);
+	unsigned long flags;
 	int sent = 0;
-	mutex_lock(&gsm->tx_mutex);
+	spin_lock_irqsave(&gsm->tx_lock, flags);
 	/* If we have nothing running then we need to fire up */
 	if (gsm->tx_bytes < TX_THRESH_LO)
 		sent = gsm_dlci_data_sweep(gsm);
-	mutex_unlock(&gsm->tx_mutex);
+	spin_unlock_irqrestore(&gsm->tx_lock, flags);
 	if (sent && debug & DBG_DATA)
 		pr_info("%s TX queue stalled\n", __func__);
 	}
 	/* Finish outstanding timers, making sure they are done */
-	cancel_delayed_work_sync(&gsm->kick_timeout);
+	del_timer_sync(&gsm->kick_timer);
 	del_timer_sync(&gsm->t2_timer);
 	/* Finish writing to ldisc */
 			break;
 		}
 	}
-	mutex_destroy(&gsm->tx_mutex);
 	mutex_destroy(&gsm->mutex);
 	kfree(gsm->txframe);
 	kfree(gsm->buf);
 	}
 	spin_lock_init(&gsm->lock);
 	mutex_init(&gsm->mutex);
-	mutex_init(&gsm->tx_mutex);
 	kref_init(&gsm->ref);
 	INIT_LIST_HEAD(&gsm->tx_ctrl_list);
 	INIT_LIST_HEAD(&gsm->tx_data_list);
-	INIT_DELAYED_WORK(&gsm->kick_timeout, gsm_kick_timeout);
+	timer_setup(&gsm->kick_timer, gsm_kick_timer, 0);
 	timer_setup(&gsm->t2_timer, gsm_control_retransmit, 0);
 	INIT_WORK(&gsm->tx_work, gsmld_write_task);
 	init_waitqueue_head(&gsm->event);
 	spin_lock_init(&gsm->control_lock);
+	spin_lock_init(&gsm->tx_lock);
 	gsm->t1 = T1;
 	gsm->t2 = T2;
 	}
 	spin_unlock(&gsm_mux_lock);
 	if (i == MAX_MUX) {
-		mutex_destroy(&gsm->tx_mutex);
 		mutex_destroy(&gsm->mutex);
 		kfree(gsm->txframe);
 		kfree(gsm->buf);
 static void gsmld_write_task(struct work_struct *work)
 {
 	struct gsm_mux *gsm = container_of(work, struct gsm_mux, tx_work);
+	unsigned long flags;
 	int i, ret;
 	/* All outstanding control channel and control messages and one data
 	 * frame is sent.
 	 */
 	ret = -ENODEV;
-	mutex_lock(&gsm->tx_mutex);
+	spin_lock_irqsave(&gsm->tx_lock, flags);
 	if (gsm->tty)
 		ret = gsm_data_kick(gsm);
-	mutex_unlock(&gsm->tx_mutex);
+	spin_unlock_irqrestore(&gsm->tx_lock, flags);
 	if (ret >= 0)
 		for (i = 0; i < NUM_DLCI; i++)
 			   const unsigned char *buf, size_t nr)
 {
 	struct gsm_mux *gsm = tty->disc_data;
+	unsigned long flags;
 	int space;
 	int ret;
 		return -ENODEV;
 	ret = -ENOBUFS;
-	mutex_lock(&gsm->tx_mutex);
+	spin_lock_irqsave(&gsm->tx_lock, flags);
 	space = tty_write_room(tty);
 	if (space >= nr)
 		ret = tty->ops->write(tty, buf, nr);
 	else
 		set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
-	mutex_unlock(&gsm->tx_mutex);
+	spin_unlock_irqrestore(&gsm->tx_lock, flags);
 	return ret;
 }
 static void gsm_modem_upd_via_data(struct gsm_dlci *dlci, u8 brk)
 {
 	struct gsm_mux *gsm = dlci->gsm;
+	unsigned long flags;
 	if (dlci->state != DLCI_OPEN || dlci->adaption != 2)
 		return;
-	mutex_lock(&gsm->tx_mutex);
+	spin_lock_irqsave(&gsm->tx_lock, flags);
 	gsm_dlci_modem_output(gsm, dlci, brk);
-	mutex_unlock(&gsm->tx_mutex);
+	spin_unlock_irqrestore(&gsm->tx_lock, flags);
 }
 /**

drivers/tty/serial/8250/8250_lpss.c+13−4

 	 */
 	up->dma = dma;
+	lpss->dma_maxburst = 16;
 	port->set_termios = dw8250_do_set_termios;
 	return 0;
 	struct dw_dma_slave *rx_param, *tx_param;
 	struct device *dev = port->port.dev;
-	if (!lpss->dma_param.dma_dev)
+	if (!lpss->dma_param.dma_dev) {
+		dma = port->dma;
+		if (dma)
+			goto out_configuration_only;
 		return 0;
+	}
 	rx_param = devm_kzalloc(dev, sizeof(*rx_param), GFP_KERNEL);
 	if (!rx_param)
 		return -ENOMEM;
 	*rx_param = lpss->dma_param;
-	dma->rxconf.src_maxburst = lpss->dma_maxburst;
 	*tx_param = lpss->dma_param;
-	dma->txconf.dst_maxburst = lpss->dma_maxburst;
 	dma->fn = lpss8250_dma_filter;
 	dma->rx_param = rx_param;
 	dma->tx_param = tx_param;
 	port->dma = dma;
+out_configuration_only:
+	dma->rxconf.src_maxburst = lpss->dma_maxburst;
+	dma->txconf.dst_maxburst = lpss->dma_maxburst;
 	return 0;
 }

drivers/tty/serial/8250/8250_omap.c+30−22

 	return readl(up->port.membase + (reg << up->port.regshift));
 }
-static void omap8250_set_mctrl(struct uart_port *port, unsigned int mctrl)
+/*
+ * Called on runtime PM resume path from omap8250_restore_regs(), and
+ * omap8250_set_mctrl().
+ */
+static void __omap8250_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	struct omap8250_priv *priv = up->port.private_data;
 	}
 }
+static void omap8250_set_mctrl(struct uart_port *port, unsigned int mctrl)
+{
+	int err;
+	err = pm_runtime_resume_and_get(port->dev);
+	if (err)
+		return;
+	__omap8250_set_mctrl(port, mctrl);
+	pm_runtime_mark_last_busy(port->dev);
+	pm_runtime_put_autosuspend(port->dev);
+}
 /*
  * Work Around for Errata i202 (2430, 3430, 3630, 4430 and 4460)
  * The access to uart register after MDR1 Access
 static void omap_8250_mdr1_errataset(struct uart_8250_port *up,
 				     struct omap8250_priv *priv)
 {
-	u8 timeout = 255;
 	serial_out(up, UART_OMAP_MDR1, priv->mdr1);
 	udelay(2);
 	serial_out(up, UART_FCR, up->fcr | UART_FCR_CLEAR_XMIT |
 			UART_FCR_CLEAR_RCVR);
-	/*
-	 * Wait for FIFO to empty: when empty, RX_FIFO_E bit is 0 and
-	 * TX_FIFO_E bit is 1.
-	 */
-	while (UART_LSR_THRE != (serial_in(up, UART_LSR) &
-				(UART_LSR_THRE | UART_LSR_DR))) {
-		timeout--;
-		if (!timeout) {
-			/* Should *never* happen. we warn and carry on */
-			dev_crit(up->port.dev, "Errata i202: timedout %x\n",
-				 serial_in(up, UART_LSR));
-			break;
-		}
-		udelay(1);
-	}
 }
 static void omap_8250_get_divisor(struct uart_port *port, unsigned int baud,
 {
 	struct omap8250_priv *priv = up->port.private_data;
 	struct uart_8250_dma	*dma = up->dma;
+	u8 mcr = serial8250_in_MCR(up);
 	if (dma && dma->tx_running) {
 		/*
 	serial_out(up, UART_EFR, UART_EFR_ECB);
 	serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
-	serial8250_out_MCR(up, UART_MCR_TCRTLR);
+	serial8250_out_MCR(up, mcr | UART_MCR_TCRTLR);
 	serial_out(up, UART_FCR, up->fcr);
 	omap8250_update_scr(up, priv);
 	serial_out(up, UART_LCR, 0);
 	/* drop TCR + TLR access, we setup XON/XOFF later */
-	serial8250_out_MCR(up, up->mcr);
+	serial8250_out_MCR(up, mcr);
 	serial_out(up, UART_IER, up->ier);
 	serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
 	omap8250_update_mdr1(up, priv);
-	up->port.ops->set_mctrl(&up->port, up->port.mctrl);
+	__omap8250_set_mctrl(&up->port, up->port.mctrl);
 	if (up->port.rs485.flags & SER_RS485_ENABLED)
 		serial8250_em485_stop_tx(up);
 	pm_runtime_get_sync(port->dev);
-	up->mcr = 0;
 	serial_out(up, UART_FCR, UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
 	serial_out(up, UART_LCR, UART_LCR_WLEN8);
 static int omap8250_remove(struct platform_device *pdev)
 {
 	struct omap8250_priv *priv = platform_get_drvdata(pdev);
+	int err;
+	err = pm_runtime_resume_and_get(&pdev->dev);
+	if (err)
+		return err;
 	pm_runtime_dont_use_autosuspend(&pdev->dev);
 	pm_runtime_put_sync(&pdev->dev);
+	flush_work(&priv->qos_work);
 	pm_runtime_disable(&pdev->dev);
 	serial8250_unregister_port(priv->line);
 	cpu_latency_qos_remove_request(&priv->pm_qos_request);

drivers/tty/serial/8250/8250_port.c+5−2

 static bool handle_rx_dma(struct uart_8250_port *up, unsigned int iir)
 {
 	switch (iir & 0x3f) {
-	case UART_IIR_RX_TIMEOUT:
+	case UART_IIR_RDI:
-		serial8250_rx_dma_flush(up);
+		if (!up->dma->rx_running)
+			break;
 		fallthrough;
 	case UART_IIR_RLSI:
+	case UART_IIR_RX_TIMEOUT:
+		serial8250_rx_dma_flush(up);
 		return true;
 	}
 	return up->dma->rx_dma(up);

drivers/tty/serial/fsl_lpuart.c+49−27

@@ -12,6 +12,7 @@ · 11 unmodified lines
12	#include <linux/dmaengine.h>	12	#include <linux/dmaengine.h>
13	#include <linux/dmapool.h>	13	#include <linux/dmapool.h>
14	#include <linux/io.h>	14	#include <linux/io.h>
		15	#include <linux/iopoll.h>
15	#include <linux/irq.h>	16	#include <linux/irq.h>
16	#include <linux/module.h>	17	#include <linux/module.h>
17	#include <linux/of.h>	18	#include <linux/of.h>
@@ -404,33 +405,6 @@ static unsigned int lpuart_get_baud_clk_rate(struct lpuart_port *sport) · 386 unmodified lines
404	#define lpuart_enable_clks(x) __lpuart_enable_clks(x, true)	405	#define lpuart_enable_clks(x) __lpuart_enable_clks(x, true)
405	#define lpuart_disable_clks(x) __lpuart_enable_clks(x, false)	406	#define lpuart_disable_clks(x) __lpuart_enable_clks(x, false)
406		407
407	static int lpuart_global_reset(struct lpuart_port *sport)
408	{
409	struct uart_port *port = &sport->port;
410	void __iomem *global_addr;
411	int ret;
412
413	if (uart_console(port))
414	return 0;
415
416	ret = clk_prepare_enable(sport->ipg_clk);
417	if (ret) {
418	dev_err(sport->port.dev, "failed to enable uart ipg clk: %d\n", ret);
419	return ret;
420	}
421
422	if (is_imx7ulp_lpuart(sport) \|\| is_imx8qxp_lpuart(sport)) {
423	global_addr = port->membase + UART_GLOBAL - IMX_REG_OFF;
424	writel(UART_GLOBAL_RST, global_addr);
425	usleep_range(GLOBAL_RST_MIN_US, GLOBAL_RST_MAX_US);
426	writel(0, global_addr);
427	usleep_range(GLOBAL_RST_MIN_US, GLOBAL_RST_MAX_US);
428	}
429
430	clk_disable_unprepare(sport->ipg_clk);
431	return 0;
432	}
433
434	static void lpuart_stop_tx(struct uart_port *port)	408	static void lpuart_stop_tx(struct uart_port *port)
435	{	409	{
436	unsigned char temp;	410	unsigned char temp;
@@ -2636,6 +2610,54 @@ static const struct serial_rs485 lpuart_rs485_supported = { · 2199 unmodified lines
2636	/* delay_rts_* and RX_DURING_TX are not supported */	2610	/* delay_rts_* and RX_DURING_TX are not supported */
2637	};	2611	};
2638		2612
		2613	static int lpuart_global_reset(struct lpuart_port *sport)
		2614	{
		2615	struct uart_port *port = &sport->port;
		2616	void __iomem *global_addr;
		2617	unsigned long ctrl, bd;
		2618	unsigned int val = 0;
		2619	int ret;
		2620
		2621	ret = clk_prepare_enable(sport->ipg_clk);
		2622	if (ret) {
		2623	dev_err(sport->port.dev, "failed to enable uart ipg clk: %d\n", ret);
		2624	return ret;
		2625	}
		2626
		2627	if (is_imx7ulp_lpuart(sport) \|\| is_imx8qxp_lpuart(sport)) {
		2628	/*
		2629	* If the transmitter is used by earlycon, wait for transmit engine to
		2630	* complete and then reset.
		2631	*/
		2632	ctrl = lpuart32_read(port, UARTCTRL);
		2633	if (ctrl & UARTCTRL_TE) {
		2634	bd = lpuart32_read(&sport->port, UARTBAUD);
		2635	if (read_poll_timeout(lpuart32_tx_empty, val, val, 1, 100000, false,
		2636	port)) {
		2637	dev_warn(sport->port.dev,
		2638	"timeout waiting for transmit engine to complete\n");
		2639	clk_disable_unprepare(sport->ipg_clk);
		2640	return 0;
		2641	}
		2642	}
		2643
		2644	global_addr = port->membase + UART_GLOBAL - IMX_REG_OFF;
		2645	writel(UART_GLOBAL_RST, global_addr);
		2646	usleep_range(GLOBAL_RST_MIN_US, GLOBAL_RST_MAX_US);
		2647	writel(0, global_addr);
		2648	usleep_range(GLOBAL_RST_MIN_US, GLOBAL_RST_MAX_US);
		2649
		2650	/* Recover the transmitter for earlycon. */
		2651	if (ctrl & UARTCTRL_TE) {
		2652	lpuart32_write(port, bd, UARTBAUD);
		2653	lpuart32_write(port, ctrl, UARTCTRL);
		2654	}
		2655	}
		2656
		2657	clk_disable_unprepare(sport->ipg_clk);
		2658	return 0;
		2659	}
		2660
2639	static int lpuart_probe(struct platform_device *pdev)	2661	static int lpuart_probe(struct platform_device *pdev)
2640	{	2662	{
2641	const struct lpuart_soc_data *sdata = of_device_get_match_data(&pdev->dev);	2663	const struct lpuart_soc_data *sdata = of_device_get_match_data(&pdev->dev);

drivers/tty/serial/imx.c+1−0

@@ -2594,6 +2594,7 @@ static const struct dev_pm_ops imx_uart_pm_ops = { · 2593 unmodified lines
2594	.suspend_noirq = imx_uart_suspend_noirq,	2594	.suspend_noirq = imx_uart_suspend_noirq,
2595	.resume_noirq = imx_uart_resume_noirq,	2595	.resume_noirq = imx_uart_resume_noirq,
2596	.freeze_noirq = imx_uart_suspend_noirq,	2596	.freeze_noirq = imx_uart_suspend_noirq,
		2597	.thaw_noirq = imx_uart_resume_noirq,
2597	.restore_noirq = imx_uart_resume_noirq,	2598	.restore_noirq = imx_uart_resume_noirq,
2598	.suspend = imx_uart_suspend,	2599	.suspend = imx_uart_suspend,
2599	.resume = imx_uart_resume,	2600	.resume = imx_uart_resume,

drivers/usb/cdns3/host.c+28−28

 #define CFG_RXDET_P3_EN		BIT(15)
 #define LPM_2_STB_SWITCH_EN	BIT(25)
-static int xhci_cdns3_suspend_quirk(struct usb_hcd *hcd);
+static void xhci_cdns3_plat_start(struct usb_hcd *hcd)
+{
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	u32 value;
+	/* set usbcmd.EU3S */
+	value = readl(&xhci->op_regs->command);
+	value |= CMD_PM_INDEX;
+	writel(value, &xhci->op_regs->command);
+	if (hcd->regs) {
+		value = readl(hcd->regs + XECP_AUX_CTRL_REG1);
+		value |= CFG_RXDET_P3_EN;
+		writel(value, hcd->regs + XECP_AUX_CTRL_REG1);
+		value = readl(hcd->regs + XECP_PORT_CAP_REG);
+		value |= LPM_2_STB_SWITCH_EN;
+		writel(value, hcd->regs + XECP_PORT_CAP_REG);
+	}
+}
+static int xhci_cdns3_resume_quirk(struct usb_hcd *hcd)
+{
+	xhci_cdns3_plat_start(hcd);
+	return 0;
+}
 static const struct xhci_plat_priv xhci_plat_cdns3_xhci = {
 	.quirks = XHCI_SKIP_PHY_INIT | XHCI_AVOID_BEI,
-	.suspend_quirk = xhci_cdns3_suspend_quirk,
+	.plat_start = xhci_cdns3_plat_start,
+	.resume_quirk = xhci_cdns3_resume_quirk,
 };
 static int __cdns_host_init(struct cdns *cdns)
 	return ret;
 }
-static int xhci_cdns3_suspend_quirk(struct usb_hcd *hcd)
-{
-	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
-	u32 value;
-	if (pm_runtime_status_suspended(hcd->self.controller))
-		return 0;
-	/* set usbcmd.EU3S */
-	value = readl(&xhci->op_regs->command);
-	value |= CMD_PM_INDEX;
-	writel(value, &xhci->op_regs->command);
-	if (hcd->regs) {
-		value = readl(hcd->regs + XECP_AUX_CTRL_REG1);
-		value |= CFG_RXDET_P3_EN;
-		writel(value, hcd->regs + XECP_AUX_CTRL_REG1);
-		value = readl(hcd->regs + XECP_PORT_CAP_REG);
-		value |= LPM_2_STB_SWITCH_EN;
-		writel(value, hcd->regs + XECP_PORT_CAP_REG);
-	}
-	return 0;
-}
 static void cdns_host_exit(struct cdns *cdns)
 {
 	kfree(cdns->xhci_plat_data);

drivers/usb/chipidea/otg_fsm.c+2−0

 	ci->enabled_otg_timer_bits &= ~(1 << t);
 	if (ci->next_otg_timer == t) {
 		if (ci->enabled_otg_timer_bits == 0) {
+			spin_unlock_irqrestore(&ci->lock, flags);
 			/* No enabled timers after delete it */
 			hrtimer_cancel(&ci->otg_fsm_hrtimer);
+			spin_lock_irqsave(&ci->lock, flags);
 			ci->next_otg_timer = NUM_OTG_FSM_TIMERS;
 		} else {
 			/* Find the next timer */

drivers/usb/core/quirks.c+3−0

@@ -362,6 +362,9 @@ static const struct usb_device_id usb_quirk_list[] = { · 361 unmodified lines
362	{ USB_DEVICE(0x0781, 0x5583), .driver_info = USB_QUIRK_NO_LPM },	362	{ USB_DEVICE(0x0781, 0x5583), .driver_info = USB_QUIRK_NO_LPM },
363	{ USB_DEVICE(0x0781, 0x5591), .driver_info = USB_QUIRK_NO_LPM },	363	{ USB_DEVICE(0x0781, 0x5591), .driver_info = USB_QUIRK_NO_LPM },
364		364
		365	/* Realforce 87U Keyboard */
		366	{ USB_DEVICE(0x0853, 0x011b), .driver_info = USB_QUIRK_NO_LPM },
		367
365	/* M-Systems Flash Disk Pioneers */	368	/* M-Systems Flash Disk Pioneers */
366	{ USB_DEVICE(0x08ec, 0x1000), .driver_info = USB_QUIRK_RESET_RESUME },	369	{ USB_DEVICE(0x08ec, 0x1000), .driver_info = USB_QUIRK_RESET_RESUME },
367		370

drivers/usb/dwc3/core.c+10−0

@@ -1710,6 +1710,16 @@ static struct extcon_dev dwc3_get_extcon(struct dwc3 dwc) · 1709 unmodified lines
1710	if (device_property_read_string(dev, "linux,extcon-name", &name) == 0)	1710	if (device_property_read_string(dev, "linux,extcon-name", &name) == 0)
1711	return extcon_get_extcon_dev(name);	1711	return extcon_get_extcon_dev(name);
1712		1712
		1713	/*
		1714	* Check explicitly if "usb-role-switch" is used since
		1715	* extcon_find_edev_by_node() can not be used to check the absence of
		1716	* an extcon device. In the absence of an device it will always return
		1717	* EPROBE_DEFER.
		1718	*/
		1719	if (IS_ENABLED(CONFIG_USB_ROLE_SWITCH) &&
		1720	device_property_read_bool(dev, "usb-role-switch"))
		1721	return NULL;
		1722
1713	/*	1723	/*
1714	* Try to get an extcon device from the USB PHY controller's "port"	1724	* Try to get an extcon device from the USB PHY controller's "port"
1715	* node. Check if it has the "port" node first, to avoid printing the	1725	* node. Check if it has the "port" node first, to avoid printing the

drivers/usb/dwc3/gadget.c+1−1

@@ -1029,7 +1029,7 @@ static int __dwc3_gadget_ep_disable(struct dwc3_ep *dep) · 1028 unmodified lines
1029	dep->endpoint.desc = NULL;	1029	dep->endpoint.desc = NULL;
1030	}	1030	}
1031		1031
1032	dwc3_remove_requests(dwc, dep, -ECONNRESET);	1032	dwc3_remove_requests(dwc, dep, -ESHUTDOWN);
1033		1033
1034	dep->stream_capable = false;	1034	dep->stream_capable = false;
1035	dep->type = 0;	1035	dep->type = 0;

drivers/usb/dwc3/host.c+0−10

 #include <linux/of.h>
 #include <linux/platform_device.h>
-#include "../host/xhci-plat.h"
 #include "core.h"
-static const struct xhci_plat_priv dwc3_xhci_plat_priv = {
-	.quirks = XHCI_SKIP_PHY_INIT,
-};
 static void dwc3_host_fill_xhci_irq_res(struct dwc3 *dwc,
 					int irq, char *name)
 {
 		goto err;
 	}
-	ret = platform_device_add_data(xhci, &dwc3_xhci_plat_priv,
-					sizeof(dwc3_xhci_plat_priv));
-	if (ret)
-		goto err;
 	memset(props, 0, sizeof(struct property_entry) * ARRAY_SIZE(props));
 	if (dwc->usb3_lpm_capable)

drivers/usb/host/bcma-hcd.c+6−4

 {
 	struct bcma_hcd_device *usb_dev = bcma_get_drvdata(dev);
-	if (IS_ERR_OR_NULL(usb_dev->gpio_desc))
+	if (!usb_dev->gpio_desc)
 		return;
 	gpiod_set_value(usb_dev->gpio_desc, val);
 		return -ENOMEM;
 	usb_dev->core = core;
-	if (core->dev.of_node)
+	usb_dev->gpio_desc = devm_gpiod_get_optional(&core->dev, "vcc",
-		usb_dev->gpio_desc = devm_gpiod_get(&core->dev, "vcc",
+						     GPIOD_OUT_HIGH);
-						    GPIOD_OUT_HIGH);
+	if (IS_ERR(usb_dev->gpio_desc))
+		return dev_err_probe(&core->dev, PTR_ERR(usb_dev->gpio_desc),
+				     "error obtaining VCC GPIO");
 	switch (core->id.id) {
 	case BCMA_CORE_USB20_HOST:

drivers/usb/serial/option.c+17−2

 #define NOVATELWIRELESS_PRODUCT_G2		0xA010
 #define NOVATELWIRELESS_PRODUCT_MC551		0xB001
+#define UBLOX_VENDOR_ID				0x1546
 /* AMOI PRODUCTS */
 #define AMOI_VENDOR_ID				0x1614
 #define AMOI_PRODUCT_H01			0x0800
 #define QUECTEL_PRODUCT_UC15			0x9090
 /* These u-blox products use Qualcomm's vendor ID */
 #define UBLOX_PRODUCT_R410M			0x90b2
-#define UBLOX_PRODUCT_R6XX			0x90fa
 /* These Yuga products use Qualcomm's vendor ID */
 #define YUGA_PRODUCT_CLM920_NC5			0x9625
 #define OPPO_VENDOR_ID				0x22d9
 #define OPPO_PRODUCT_R11			0x276c
+/* Sierra Wireless products */
+#define SIERRA_VENDOR_ID			0x1199
+#define SIERRA_PRODUCT_EM9191			0x90d3
 /* Device flags */
 	/* u-blox products using Qualcomm vendor ID */
 	{ USB_DEVICE(QUALCOMM_VENDOR_ID, UBLOX_PRODUCT_R410M),
 	  .driver_info = RSVD(1) | RSVD(3) },
-	{ USB_DEVICE(QUALCOMM_VENDOR_ID, UBLOX_PRODUCT_R6XX),
+	{ USB_DEVICE(QUALCOMM_VENDOR_ID, 0x908b),	/* u-blox LARA-R6 00B */
+	  .driver_info = RSVD(4) },
+	{ USB_DEVICE(QUALCOMM_VENDOR_ID, 0x90fa),
 	  .driver_info = RSVD(3) },
+	/* u-blox products */
+	{ USB_DEVICE(UBLOX_VENDOR_ID, 0x1341) },	/* u-blox LARA-L6 */
+	{ USB_DEVICE(UBLOX_VENDOR_ID, 0x1342),		/* u-blox LARA-L6 (RMNET) */
+	  .driver_info = RSVD(4) },
+	{ USB_DEVICE(UBLOX_VENDOR_ID, 0x1343),		/* u-blox LARA-L6 (ECM) */
+	  .driver_info = RSVD(4) },
 	/* Quectel products using Quectel vendor ID */
 	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EC21, 0xff, 0xff, 0xff),
 	  .driver_info = NUMEP2 },
 	{ USB_DEVICE_INTERFACE_CLASS(0x2cb7, 0x010a, 0xff) },			/* Fibocom MA510 (ECM mode) */
 	{ USB_DEVICE_AND_INTERFACE_INFO(0x2cb7, 0x010b, 0xff, 0xff, 0x30) },	/* Fibocom FG150 Diag */
 	{ USB_DEVICE_AND_INTERFACE_INFO(0x2cb7, 0x010b, 0xff, 0, 0) },		/* Fibocom FG150 AT */
+	{ USB_DEVICE_INTERFACE_CLASS(0x2cb7, 0x0111, 0xff) },			/* Fibocom FM160 (MBIM mode) */
 	{ USB_DEVICE_INTERFACE_CLASS(0x2cb7, 0x01a0, 0xff) },			/* Fibocom NL668-AM/NL652-EU (laptop MBIM) */
 	{ USB_DEVICE_INTERFACE_CLASS(0x2cb7, 0x01a2, 0xff) },			/* Fibocom FM101-GL (laptop MBIM) */
 	{ USB_DEVICE_INTERFACE_CLASS(0x2cb7, 0x01a4, 0xff),			/* Fibocom FM101-GL (laptop MBIM) */
 	{ USB_DEVICE_INTERFACE_CLASS(0x305a, 0x1405, 0xff) },			/* GosunCn GM500 MBIM */
 	{ USB_DEVICE_INTERFACE_CLASS(0x305a, 0x1406, 0xff) },			/* GosunCn GM500 ECM/NCM */
 	{ USB_DEVICE_AND_INTERFACE_INFO(OPPO_VENDOR_ID, OPPO_PRODUCT_R11, 0xff, 0xff, 0x30) },
+	{ USB_DEVICE_AND_INTERFACE_INFO(SIERRA_VENDOR_ID, SIERRA_PRODUCT_EM9191, 0xff, 0xff, 0x30) },
+	{ USB_DEVICE_AND_INTERFACE_INFO(SIERRA_VENDOR_ID, SIERRA_PRODUCT_EM9191, 0xff, 0, 0) },
 	{ } /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, option_ids);

drivers/usb/typec/mux/intel_pmc_mux.c+13−2

 	return pmc_usb_command(port, (void *)&req, sizeof(req));
 }
-static int pmc_usb_mux_safe_state(struct pmc_usb_port *port)
+static int pmc_usb_mux_safe_state(struct pmc_usb_port *port,
+				  struct typec_mux_state *state)
 {
 	u8 msg;
 	if (IOM_PORT_ACTIVITY_IS(port->iom_status, SAFE_MODE))
 		return 0;
+	if ((IOM_PORT_ACTIVITY_IS(port->iom_status, DP) ||
+	     IOM_PORT_ACTIVITY_IS(port->iom_status, DP_MFD)) &&
+	     state->alt && state->alt->svid == USB_TYPEC_DP_SID)
+		return 0;
+	if ((IOM_PORT_ACTIVITY_IS(port->iom_status, TBT) ||
+	     IOM_PORT_ACTIVITY_IS(port->iom_status, ALT_MODE_TBT_USB)) &&
+	     state->alt && state->alt->svid == USB_TYPEC_TBT_SID)
+		return 0;
 	msg = PMC_USB_SAFE_MODE;
 	msg |= port->usb3_port << PMC_USB_MSG_USB3_PORT_SHIFT;
 		return 0;
 	if (state->mode == TYPEC_STATE_SAFE)
-		return pmc_usb_mux_safe_state(port);
+		return pmc_usb_mux_safe_state(port, state);
 	if (state->mode == TYPEC_STATE_USB)
 		return pmc_usb_connect(port, port->role);

drivers/usb/typec/tipd/core.c+3−3

@@ -474,7 +474,7 @@ static void tps6598x_handle_plug_event(struct tps6598x *tps, u32 status) · 473 unmodified lines
474	static irqreturn_t cd321x_interrupt(int irq, void *data)	474	static irqreturn_t cd321x_interrupt(int irq, void *data)
475	{	475	{
476	struct tps6598x *tps = data;	476	struct tps6598x *tps = data;
477	u64 event;	477	u64 event = 0;
478	u32 status;	478	u32 status;
479	int ret;	479	int ret;
480		480
@@ -519,8 +519,8 @@ err_unlock: · 38 unmodified lines
519	static irqreturn_t tps6598x_interrupt(int irq, void *data)	519	static irqreturn_t tps6598x_interrupt(int irq, void *data)
520	{	520	{
521	struct tps6598x *tps = data;	521	struct tps6598x *tps = data;
522	u64 event1;	522	u64 event1 = 0;
523	u64 event2;	523	u64 event2 = 0;
524	u32 status;	524	u32 status;
525	int ret;	525	int ret;
526		526

drivers/vfio/pci/vfio_pci_core.c+5−5

@@ -2488,12 +2488,12 @@ static bool vfio_pci_dev_set_needs_reset(struct vfio_device_set *dev_set) · 2487 unmodified lines
2488	struct vfio_pci_core_device *cur;	2488	struct vfio_pci_core_device *cur;
2489	bool needs_reset = false;	2489	bool needs_reset = false;
2490		2490
2491	list_for_each_entry(cur, &dev_set->device_list, vdev.dev_set_list) {	2491	/* No other VFIO device in the set can be open. */
2492	/* No VFIO device in the set can have an open device FD */	2492	if (vfio_device_set_open_count(dev_set) > 1)
2493	if (cur->vdev.open_count)	2493	return false;
2494	return false;	2494
		2495	list_for_each_entry(cur, &dev_set->device_list, vdev.dev_set_list)
2495	needs_reset \|= cur->needs_reset;	2496	needs_reset \|= cur->needs_reset;
2496	}
2497	return needs_reset;	2497	return needs_reset;
2498	}	2498	}
2499		2499

drivers/vfio/vfio_main.c+21−5

 	xa_unlock(&vfio_device_set_xa);
 }
+unsigned int vfio_device_set_open_count(struct vfio_device_set *dev_set)
+{
+	struct vfio_device *cur;
+	unsigned int open_count = 0;
+	lockdep_assert_held(&dev_set->lock);
+	list_for_each_entry(cur, &dev_set->device_list, dev_set_list)
+		open_count += cur->open_count;
+	return open_count;
+}
+EXPORT_SYMBOL_GPL(vfio_device_set_open_count);
 /*
  * Group objects - create, release, get, put, search
  */
 err_close_device:
 	mutex_lock(&device->dev_set->lock);
 	mutex_lock(&device->group->group_lock);
-	if (device->open_count == 1 && device->ops->close_device) {
+	if (device->open_count == 1) {
-		device->ops->close_device(device);
+		if (device->ops->close_device)
+			device->ops->close_device(device);
 		vfio_device_container_unregister(device);
 	}
 	mutex_lock(&device->dev_set->lock);
 	vfio_assert_device_open(device);
 	mutex_lock(&device->group->group_lock);
-	if (device->open_count == 1 && device->ops->close_device)
+	if (device->open_count == 1) {
-		device->ops->close_device(device);
+		if (device->ops->close_device)
+			device->ops->close_device(device);
-	vfio_device_container_unregister(device);
+		vfio_device_container_unregister(device);
+	}
 	mutex_unlock(&device->group->group_lock);
 	device->open_count--;
 	if (device->open_count == 0)

drivers/xen/pcpu.c+1−1

@@ -228,7 +228,7 @@ static int register_pcpu(struct pcpu *pcpu) · 227 unmodified lines
228		228
229	err = device_register(dev);	229	err = device_register(dev);
230	if (err) {	230	if (err) {
231	pcpu_release(dev);	231	put_device(dev);
232	return err;	232	return err;
233	}	233	}
234		234

drivers/xen/platform-pci.c+7−3

 	pin = pdev->pin;
 	/* We don't know the GSI. Specify the PCI INTx line instead. */
-	return ((uint64_t)0x01 << HVM_CALLBACK_VIA_TYPE_SHIFT) | /* PCI INTx identifier */
+	return ((uint64_t)HVM_PARAM_CALLBACK_TYPE_PCI_INTX <<
+			  HVM_CALLBACK_VIA_TYPE_SHIFT) |
 		((uint64_t)pci_domain_nr(pdev->bus) << 32) |
 		((uint64_t)pdev->bus->number << 16) |
 		((uint64_t)(pdev->devfn & 0xff) << 8) |
 		if (ret) {
 			dev_warn(&pdev->dev, "Unable to set the evtchn callback "
 					 "err=%d\n", ret);
-			goto out;
+			goto irq_out;
 		}
 	}
 	grant_frames = alloc_xen_mmio(PAGE_SIZE * max_nr_gframes);
 	ret = gnttab_setup_auto_xlat_frames(grant_frames);
 	if (ret)
-		goto out;
+		goto irq_out;
 	ret = gnttab_init();
 	if (ret)
 		goto grant_out;
 	return 0;
 grant_out:
 	gnttab_free_auto_xlat_frames();
+irq_out:
+	if (!xen_have_vector_callback)
+		free_irq(pdev->irq, pdev);
 out:
 	pci_release_region(pdev, 0);
 mem_out:

drivers/xen/xen-pciback/conf_space_capability.c+6−3

 };
 static struct msi_msix_field_config {
-	u16          enable_bit; /* bit for enabling MSI/MSI-X */
+	u16          enable_bit;   /* bit for enabling MSI/MSI-X */
-	unsigned int int_type;   /* interrupt type for exclusiveness check */
+	u16          allowed_bits; /* bits allowed to be changed */
+	unsigned int int_type;     /* interrupt type for exclusiveness check */
 } msi_field_config = {
 	.enable_bit	= PCI_MSI_FLAGS_ENABLE,
+	.allowed_bits	= PCI_MSI_FLAGS_ENABLE,
 	.int_type	= INTERRUPT_TYPE_MSI,
 }, msix_field_config = {
 	.enable_bit	= PCI_MSIX_FLAGS_ENABLE,
+	.allowed_bits	= PCI_MSIX_FLAGS_ENABLE | PCI_MSIX_FLAGS_MASKALL,
 	.int_type	= INTERRUPT_TYPE_MSIX,
 };
 		return 0;
 	if (!dev_data->allow_interrupt_control ||
-	    (new_value ^ old_value) & ~field_config->enable_bit)
+	    (new_value ^ old_value) & ~field_config->allowed_bits)
 		return PCIBIOS_SET_FAILED;
 	if (new_value & field_config->enable_bit) {

fs/ceph/caps.c+12−36

 	struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
 	struct ceph_inode_info *ci = ceph_inode(inode);
 	struct ceph_mds_request *req1 = NULL, *req2 = NULL;
-	unsigned int max_sessions;
 	int ret, err = 0;
 	spin_lock(&ci->i_unsafe_lock);
 	}
 	spin_unlock(&ci->i_unsafe_lock);
-	/*
-	 * The mdsc->max_sessions is unlikely to be changed
-	 * mostly, here we will retry it by reallocating the
-	 * sessions array memory to get rid of the mdsc->mutex
-	 * lock.
-	 */
-retry:
-	max_sessions = mdsc->max_sessions;
 	/*
 	 * Trigger to flush the journal logs in all the relevant MDSes
 	 * manually, or in the worst case we must wait at most 5 seconds
 	 * to wait the journal logs to be flushed by the MDSes periodically.
 	 */
-	if ((req1 || req2) && likely(max_sessions)) {
+	if (req1 || req2) {
-		struct ceph_mds_session **sessions = NULL;
-		struct ceph_mds_session *s;
 		struct ceph_mds_request *req;
+		struct ceph_mds_session **sessions;
+		struct ceph_mds_session *s;
+		unsigned int max_sessions;
 		int i;
+		mutex_lock(&mdsc->mutex);
+		max_sessions = mdsc->max_sessions;
 		sessions = kcalloc(max_sessions, sizeof(s), GFP_KERNEL);
 		if (!sessions) {
+			mutex_unlock(&mdsc->mutex);
 			err = -ENOMEM;
 			goto out;
 		}
 				s = req->r_session;
 				if (!s)
 					continue;
-				if (unlikely(s->s_mds >= max_sessions)) {
-					spin_unlock(&ci->i_unsafe_lock);
-					for (i = 0; i < max_sessions; i++) {
-						s = sessions[i];
-						if (s)
-							ceph_put_mds_session(s);
-					}
-					kfree(sessions);
-					goto retry;
-				}
 				if (!sessions[s->s_mds]) {
 					s = ceph_get_mds_session(s);
 					sessions[s->s_mds] = s;
 				s = req->r_session;
 				if (!s)
 					continue;
-				if (unlikely(s->s_mds >= max_sessions)) {
-					spin_unlock(&ci->i_unsafe_lock);
-					for (i = 0; i < max_sessions; i++) {
-						s = sessions[i];
-						if (s)
-							ceph_put_mds_session(s);
-					}
-					kfree(sessions);
-					goto retry;
-				}
 				if (!sessions[s->s_mds]) {
 					s = ceph_get_mds_session(s);
 					sessions[s->s_mds] = s;
 		/* the auth MDS */
 		spin_lock(&ci->i_ceph_lock);
 		if (ci->i_auth_cap) {
-		      s = ci->i_auth_cap->session;
+			s = ci->i_auth_cap->session;
-		      if (!sessions[s->s_mds])
+			if (!sessions[s->s_mds])
-			      sessions[s->s_mds] = ceph_get_mds_session(s);
+				sessions[s->s_mds] = ceph_get_mds_session(s);
 		}
 		spin_unlock(&ci->i_ceph_lock);
+		mutex_unlock(&mdsc->mutex);
 		/* send flush mdlog request to MDSes */
 		for (i = 0; i < max_sessions; i++) {

fs/ceph/inode.c+1−1

@@ -2492,7 +2492,7 @@ int ceph_getattr(struct user_namespace mnt_userns, const struct path path, · 2491 unmodified lines
2492	struct inode *parent;	2492	struct inode *parent;
2493		2493
2494	parent = ceph_lookup_inode(sb, ceph_ino(inode));	2494	parent = ceph_lookup_inode(sb, ceph_ino(inode));
2495	if (!parent)	2495	if (IS_ERR(parent))
2496	return PTR_ERR(parent);	2496	return PTR_ERR(parent);
2497		2497
2498	pci = ceph_inode(parent);	2498	pci = ceph_inode(parent);

fs/ceph/snap.c+2−1

 	struct ceph_mds_snap_realm *ri;    /* encoded */
 	__le64 *snaps;                     /* encoded */
 	__le64 *prior_parent_snaps;        /* encoded */
-	struct ceph_snap_realm *realm = NULL;
+	struct ceph_snap_realm *realm;
 	struct ceph_snap_realm *first_realm = NULL;
 	struct ceph_snap_realm *realm_to_rebuild = NULL;
 	int rebuild_snapcs;
 	dout("%s deletion=%d\n", __func__, deletion);
 more:
+	realm = NULL;
 	rebuild_snapcs = 0;
 	ceph_decode_need(&p, e, sizeof(*ri), bad);
 	ri = p;

fs/cifs/connect.c+11−3

 	uuid_copy(&cifs_sb->dfs_mount_id, &mnt_ctx.mount_id);
 out:
-	free_xid(mnt_ctx.xid);
 	cifs_try_adding_channels(cifs_sb, mnt_ctx.ses);
-	return mount_setup_tlink(cifs_sb, mnt_ctx.ses, mnt_ctx.tcon);
+	rc = mount_setup_tlink(cifs_sb, mnt_ctx.ses, mnt_ctx.tcon);
+	if (rc)
+		goto error;
+	free_xid(mnt_ctx.xid);
+	return rc;
 error:
 	dfs_cache_put_refsrv_sessions(&mnt_ctx.mount_id);
 			goto error;
 	}
+	rc = mount_setup_tlink(cifs_sb, mnt_ctx.ses, mnt_ctx.tcon);
+	if (rc)
+		goto error;
 	free_xid(mnt_ctx.xid);
-	return mount_setup_tlink(cifs_sb, mnt_ctx.ses, mnt_ctx.tcon);
+	return rc;
 error:
 	mount_put_conns(&mnt_ctx);

fs/cifs/ioctl.c+2−2

@@ -343,7 +343,7 @@ long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg) · 342 unmodified lines
343	rc = put_user(ExtAttrBits &	343	rc = put_user(ExtAttrBits &
344	FS_FL_USER_VISIBLE,	344	FS_FL_USER_VISIBLE,
345	(int __user *)arg);	345	(int __user *)arg);
346	if (rc != EOPNOTSUPP)	346	if (rc != -EOPNOTSUPP)
347	break;	347	break;
348	}	348	}
349	#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */	349	#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
@@ -373,7 +373,7 @@ long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg) · 23 unmodified lines
373	* pSMBFile->fid.netfid,	373	* pSMBFile->fid.netfid,
374	* extAttrBits,	374	* extAttrBits,
375	* &ExtAttrMask);	375	* &ExtAttrMask);
376	* if (rc != EOPNOTSUPP)	376	* if (rc != -EOPNOTSUPP)
377	* break;	377	* break;
378	*/	378	*/
379		379

fs/cifs/smb2ops.c+4−0

 				COMPOUND_FID, current->tgid,
 				FILE_FULL_EA_INFORMATION,
 				SMB2_O_INFO_FILE, 0, data, size);
+	if (rc)
+		goto sea_exit;
 	smb2_set_next_command(tcon, &rqst[1]);
 	smb2_set_related(&rqst[1]);
 	rqst[2].rq_nvec = 1;
 	rc = SMB2_close_init(tcon, server,
 			     &rqst[2], COMPOUND_FID, COMPOUND_FID, false);
+	if (rc)
+		goto sea_exit;
 	smb2_set_related(&rqst[2]);
 	rc = compound_send_recv(xid, ses, server,

fs/erofs/fscache.c+21−14

 	rcu_read_lock();
 	xas_for_each(&xas, folio, last_page) {
-		unsigned int pgpos =
+		unsigned int pgpos, pgend;
-			(folio_index(folio) - start_page) * PAGE_SIZE;
-		unsigned int pgend = pgpos + folio_size(folio);
 		bool pg_failed = false;
+		if (xas_retry(&xas, folio))
+			continue;
+		pgpos = (folio_index(folio) - start_page) * PAGE_SIZE;
+		pgend = pgpos + folio_size(folio);
 		for (;;) {
 			if (!subreq) {
 				pg_failed = true;
 			return PTR_ERR(src);
 		iov_iter_xarray(&iter, READ, &mapping->i_pages, pos, PAGE_SIZE);
-		if (copy_to_iter(src + offset, size, &iter) != size)
+		if (copy_to_iter(src + offset, size, &iter) != size) {
+			erofs_put_metabuf(&buf);
 			return -EFAULT;
+		}
 		iov_iter_zero(PAGE_SIZE - size, &iter);
 		erofs_put_metabuf(&buf);
 		return PAGE_SIZE;
 	}
-	count = min_t(size_t, map.m_llen - (pos - map.m_la), len);
-	DBG_BUGON(!count || count % PAGE_SIZE);
 	if (!(map.m_flags & EROFS_MAP_MAPPED)) {
+		count = len;
 		iov_iter_xarray(&iter, READ, &mapping->i_pages, pos, count);
 		iov_iter_zero(count, &iter);
 		return count;
 	}
+	count = min_t(size_t, map.m_llen - (pos - map.m_la), len);
+	DBG_BUGON(!count || count % PAGE_SIZE);
 	mdev = (struct erofs_map_dev) {
 		.m_deviceid = map.m_deviceid,
 		.m_pa = map.m_pa,
 static int erofs_fscache_register_volume(struct super_block *sb)
 {
 	struct erofs_sb_info *sbi = EROFS_SB(sb);
-	char *domain_id = sbi->opt.domain_id;
+	char *domain_id = sbi->domain_id;
 	struct fscache_volume *volume;
 	char *name;
 	int ret = 0;
 	name = kasprintf(GFP_KERNEL, "erofs,%s",
-			 domain_id ? domain_id : sbi->opt.fsid);
+			 domain_id ? domain_id : sbi->fsid);
 	if (!name)
 		return -ENOMEM;
 	if (!domain)
 		return -ENOMEM;
-	domain->domain_id = kstrdup(sbi->opt.domain_id, GFP_KERNEL);
+	domain->domain_id = kstrdup(sbi->domain_id, GFP_KERNEL);
 	if (!domain->domain_id) {
 		kfree(domain);
 		return -ENOMEM;
 	mutex_lock(&erofs_domain_list_lock);
 	list_for_each_entry(domain, &erofs_domain_list, list) {
-		if (!strcmp(domain->domain_id, sbi->opt.domain_id)) {
+		if (!strcmp(domain->domain_id, sbi->domain_id)) {
 			sbi->domain = domain;
 			sbi->volume = domain->volume;
 			refcount_inc(&domain->ref);
 struct erofs_fscache *erofs_fscache_register_cookie(struct super_block *sb,
 						    char *name, bool need_inode)
 {
-	if (EROFS_SB(sb)->opt.domain_id)
+	if (EROFS_SB(sb)->domain_id)
 		return erofs_domain_register_cookie(sb, name, need_inode);
 	return erofs_fscache_acquire_cookie(sb, name, need_inode);
 }
 	struct erofs_sb_info *sbi = EROFS_SB(sb);
 	struct erofs_fscache *fscache;
-	if (sbi->opt.domain_id)
+	if (sbi->domain_id)
 		ret = erofs_fscache_register_domain(sb);
 	else
 		ret = erofs_fscache_register_volume(sb);
 		return ret;
 	/* acquired domain/volume will be relinquished in kill_sb() on error */
-	fscache = erofs_fscache_register_cookie(sb, sbi->opt.fsid, true);
+	fscache = erofs_fscache_register_cookie(sb, sbi->fsid, true);
 	if (IS_ERR(fscache))
 		return PTR_ERR(fscache);

fs/erofs/internal.h+4−2

 	unsigned int max_sync_decompress_pages;
 #endif
 	unsigned int mount_opt;
-	char *fsid;
-	char *domain_id;
 };
 struct erofs_dev_context {
 struct erofs_fs_context {
 	struct erofs_mount_opts opt;
 	struct erofs_dev_context *devs;
+	char *fsid;
+	char *domain_id;
 };
 /* all filesystem-wide lz4 configurations */
 	struct fscache_volume *volume;
 	struct erofs_fscache *s_fscache;
 	struct erofs_domain *domain;
+	char *fsid;
+	char *domain_id;
 };
 #define EROFS_SB(sb) ((struct erofs_sb_info *)(sb)->s_fs_info)

fs/erofs/super.c+22−17

 		break;
 	case Opt_fsid:
 #ifdef CONFIG_EROFS_FS_ONDEMAND
-		kfree(ctx->opt.fsid);
+		kfree(ctx->fsid);
-		ctx->opt.fsid = kstrdup(param->string, GFP_KERNEL);
+		ctx->fsid = kstrdup(param->string, GFP_KERNEL);
-		if (!ctx->opt.fsid)
+		if (!ctx->fsid)
 			return -ENOMEM;
 #else
 		errorfc(fc, "fsid option not supported");
 		break;
 	case Opt_domain_id:
 #ifdef CONFIG_EROFS_FS_ONDEMAND
-		kfree(ctx->opt.domain_id);
+		kfree(ctx->domain_id);
-		ctx->opt.domain_id = kstrdup(param->string, GFP_KERNEL);
+		ctx->domain_id = kstrdup(param->string, GFP_KERNEL);
-		if (!ctx->opt.domain_id)
+		if (!ctx->domain_id)
 			return -ENOMEM;
 #else
 		errorfc(fc, "domain_id option not supported");
 	sb->s_fs_info = sbi;
 	sbi->opt = ctx->opt;
-	ctx->opt.fsid = NULL;
-	ctx->opt.domain_id = NULL;
 	sbi->devs = ctx->devs;
 	ctx->devs = NULL;
+	sbi->fsid = ctx->fsid;
+	ctx->fsid = NULL;
+	sbi->domain_id = ctx->domain_id;
+	ctx->domain_id = NULL;
 	if (erofs_is_fscache_mode(sb)) {
 		sb->s_blocksize = EROFS_BLKSIZ;
 {
 	struct erofs_fs_context *ctx = fc->fs_private;
-	if (IS_ENABLED(CONFIG_EROFS_FS_ONDEMAND) && ctx->opt.fsid)
+	if (IS_ENABLED(CONFIG_EROFS_FS_ONDEMAND) && ctx->fsid)
 		return get_tree_nodev(fc, erofs_fc_fill_super);
 	return get_tree_bdev(fc, erofs_fc_fill_super);
 	DBG_BUGON(!sb_rdonly(sb));
+	if (ctx->fsid || ctx->domain_id)
+		erofs_info(sb, "ignoring reconfiguration for fsid|domain_id.");
 	if (test_opt(&ctx->opt, POSIX_ACL))
 		fc->sb_flags |= SB_POSIXACL;
 	else
 	struct erofs_fs_context *ctx = fc->fs_private;
 	erofs_free_dev_context(ctx->devs);
-	kfree(ctx->opt.fsid);
+	kfree(ctx->fsid);
-	kfree(ctx->opt.domain_id);
+	kfree(ctx->domain_id);
 	kfree(ctx);
 }
 	erofs_free_dev_context(sbi->devs);
 	fs_put_dax(sbi->dax_dev, NULL);
 	erofs_fscache_unregister_fs(sb);
-	kfree(sbi->opt.fsid);
+	kfree(sbi->fsid);
-	kfree(sbi->opt.domain_id);
+	kfree(sbi->domain_id);
 	kfree(sbi);
 	sb->s_fs_info = NULL;
 }
 	if (test_opt(opt, DAX_NEVER))
 		seq_puts(seq, ",dax=never");
 #ifdef CONFIG_EROFS_FS_ONDEMAND
-	if (opt->fsid)
+	if (sbi->fsid)
-		seq_printf(seq, ",fsid=%s", opt->fsid);
+		seq_printf(seq, ",fsid=%s", sbi->fsid);
-	if (opt->domain_id)
+	if (sbi->domain_id)
-		seq_printf(seq, ",domain_id=%s", opt->domain_id);
+		seq_printf(seq, ",domain_id=%s", sbi->domain_id);
 #endif
 	return 0;
 }

fs/erofs/sysfs.c+4−4

@@ -210,14 +210,14 @@ int erofs_register_sysfs(struct super_block *sb) · 209 unmodified lines
210	int err;	210	int err;
211		211
212	if (erofs_is_fscache_mode(sb)) {	212	if (erofs_is_fscache_mode(sb)) {
213	if (sbi->opt.domain_id) {	213	if (sbi->domain_id) {
214	str = kasprintf(GFP_KERNEL, "%s,%s", sbi->opt.domain_id,	214	str = kasprintf(GFP_KERNEL, "%s,%s", sbi->domain_id,
215	sbi->opt.fsid);	215	sbi->fsid);
216	if (!str)	216	if (!str)
217	return -ENOMEM;	217	return -ENOMEM;
218	name = str;	218	name = str;
219	} else {	219	} else {
220	name = sbi->opt.fsid;	220	name = sbi->fsid;
221	}	221	}
222	} else {	222	} else {
223	name = sb->s_id;	223	name = sb->s_id;

fs/erofs/zdata.c+3−0

@@ -660,6 +660,9 @@ static int z_erofs_read_fragment(struct inode *inode, erofs_off_t pos, · 659 unmodified lines
660	u8 src, dst;	660	u8 src, dst;
661	unsigned int i, cnt;	661	unsigned int i, cnt;
662		662
		663	if (!packed_inode)
		664	return -EFSCORRUPTED;
		665
663	pos += EROFS_I(inode)->z_fragmentoff;	666	pos += EROFS_I(inode)->z_fragmentoff;
664	for (i = 0; i < len; i += cnt) {	667	for (i = 0; i < len; i += cnt) {
665	cnt = min_t(unsigned int, len - i,	668	cnt = min_t(unsigned int, len - i,

fs/kernfs/dir.c+12−2

 #define rb_to_kn(X) rb_entry((X), struct kernfs_node, rb)
+static bool __kernfs_active(struct kernfs_node *kn)
+{
+	return atomic_read(&kn->active) >= 0;
+}
 static bool kernfs_active(struct kernfs_node *kn)
 {
 	lockdep_assert_held(&kernfs_root(kn)->kernfs_rwsem);
-	return atomic_read(&kn->active) >= 0;
+	return __kernfs_active(kn);
 }
 static bool kernfs_lockdep(struct kernfs_node *kn)
 			goto err_unlock;
 	}
-	if (unlikely(!kernfs_active(kn) || !atomic_inc_not_zero(&kn->count)))
+	/*
+	 * We should fail if @kn has never been activated and guarantee success
+	 * if the caller knows that @kn is active. Both can be achieved by
+	 * __kernfs_active() which tests @kn->active without kernfs_rwsem.
+	 */
+	if (unlikely(!__kernfs_active(kn) || !atomic_inc_not_zero(&kn->count)))
 		goto err_unlock;
 	spin_unlock(&kernfs_idr_lock);

fs/netfs/buffered_read.c+13−7

@@ -17,9 +17,9 @@ void netfs_rreq_unlock_folios(struct netfs_io_request *rreq) · 16 unmodified lines
17	{	17	{
18	struct netfs_io_subrequest *subreq;	18	struct netfs_io_subrequest *subreq;
19	struct folio *folio;	19	struct folio *folio;
20	unsigned int iopos, account = 0;
21	pgoff_t start_page = rreq->start / PAGE_SIZE;	20	pgoff_t start_page = rreq->start / PAGE_SIZE;
22	pgoff_t last_page = ((rreq->start + rreq->len) / PAGE_SIZE) - 1;	21	pgoff_t last_page = ((rreq->start + rreq->len) / PAGE_SIZE) - 1;
		22	size_t account = 0;
23	bool subreq_failed = false;	23	bool subreq_failed = false;
24		24
25	XA_STATE(xas, &rreq->mapping->i_pages, start_page);	25	XA_STATE(xas, &rreq->mapping->i_pages, start_page);
@@ -39,18 +39,23 @@ void netfs_rreq_unlock_folios(struct netfs_io_request *rreq) · 13 unmodified lines
39	*/	39	*/
40	subreq = list_first_entry(&rreq->subrequests,	40	subreq = list_first_entry(&rreq->subrequests,
41	struct netfs_io_subrequest, rreq_link);	41	struct netfs_io_subrequest, rreq_link);
42	iopos = 0;
43	subreq_failed = (subreq->error < 0);	42	subreq_failed = (subreq->error < 0);
44		43
45	trace_netfs_rreq(rreq, netfs_rreq_trace_unlock);	44	trace_netfs_rreq(rreq, netfs_rreq_trace_unlock);
46		45
47	rcu_read_lock();	46	rcu_read_lock();
48	xas_for_each(&xas, folio, last_page) {	47	xas_for_each(&xas, folio, last_page) {
49	unsigned int pgpos = (folio_index(folio) - start_page) * PAGE_SIZE;	48	loff_t pg_end;
50	unsigned int pgend = pgpos + folio_size(folio);
51	bool pg_failed = false;	49	bool pg_failed = false;
52		50
		51	if (xas_retry(&xas, folio))
		52	continue;
		53
		54	pg_end = folio_pos(folio) + folio_size(folio) - 1;
		55
53	for (;;) {	56	for (;;) {
		57	loff_t sreq_end;
		58
54	if (!subreq) {	59	if (!subreq) {
55	pg_failed = true;	60	pg_failed = true;
56	break;	61	break;
@@ -58,11 +63,11 @@ void netfs_rreq_unlock_folios(struct netfs_io_request *rreq) · 1 unmodified line
58	if (test_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags))	63	if (test_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags))
59	folio_start_fscache(folio);	64	folio_start_fscache(folio);
60	pg_failed \|= subreq_failed;	65	pg_failed \|= subreq_failed;
61	if (pgend < iopos + subreq->len)	66	sreq_end = subreq->start + subreq->len - 1;
		67	if (pg_end < sreq_end)
62	break;	68	break;
63		69
64	account += subreq->transferred;	70	account += subreq->transferred;
65	iopos += subreq->len;
66	if (!list_is_last(&subreq->rreq_link, &rreq->subrequests)) {	71	if (!list_is_last(&subreq->rreq_link, &rreq->subrequests)) {
67	subreq = list_next_entry(subreq, rreq_link);	72	subreq = list_next_entry(subreq, rreq_link);
68	subreq_failed = (subreq->error < 0);	73	subreq_failed = (subreq->error < 0);
@@ -70,7 +75,8 @@ void netfs_rreq_unlock_folios(struct netfs_io_request *rreq) · 1 unmodified line
70	subreq = NULL;	75	subreq = NULL;
71	subreq_failed = false;	76	subreq_failed = false;
72	}	77	}
73	if (pgend == iopos)	78
		79	if (pg_end == sreq_end)
74	break;	80	break;
75	}	81	}
76		82

fs/netfs/io.c+3−0

@@ -121,6 +121,9 @@ static void netfs_rreq_unmark_after_write(struct netfs_io_request *rreq, · 120 unmodified lines
121	XA_STATE(xas, &rreq->mapping->i_pages, subreq->start / PAGE_SIZE);	121	XA_STATE(xas, &rreq->mapping->i_pages, subreq->start / PAGE_SIZE);
122		122
123	xas_for_each(&xas, folio, (subreq->start + subreq->len - 1) / PAGE_SIZE) {	123	xas_for_each(&xas, folio, (subreq->start + subreq->len - 1) / PAGE_SIZE) {
		124	if (xas_retry(&xas, folio))
		125	continue;
		126
124	/* We might have multiple writes from the same huge	127	/* We might have multiple writes from the same huge
125	* folio, but we mustn't unlock a folio more than once.	128	* folio, but we mustn't unlock a folio more than once.
126	*/	129	*/

fs/nfsd/trace.h+4−1

 				  rqstp->rq_xprt->xpt_remotelen);
 		__entry->xid = be32_to_cpu(rqstp->rq_xid);
 		__entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
-		__entry->inode = d_inode(fhp->fh_dentry);
+		if (fhp->fh_dentry)
+			__entry->inode = d_inode(fhp->fh_dentry);
+		else
+			__entry->inode = NULL;
 		__entry->type = type;
 		__entry->access = access;
 		__entry->error = be32_to_cpu(error);

fs/zonefs/super.c+27−10

 	struct super_block *sb = inode->i_sb;
 	struct zonefs_sb_info *sbi = ZONEFS_SB(sb);
 	unsigned int noio_flag;
-	unsigned int nr_zones =
+	unsigned int nr_zones = 1;
-		zi->i_zone_size >> (sbi->s_zone_sectors_shift + SECTOR_SHIFT);
 	struct zonefs_ioerr_data err = {
 		.inode = inode,
 		.write = write,
 	};
 	int ret;
+	/*
+	 * The only files that have more than one zone are conventional zone
+	 * files with aggregated conventional zones, for which the inode zone
+	 * size is always larger than the device zone size.
+	 */
+	if (zi->i_zone_size > bdev_zone_sectors(sb->s_bdev))
+		nr_zones = zi->i_zone_size >>
+			(sbi->s_zone_sectors_shift + SECTOR_SHIFT);
 	/*
 	 * Memory allocations in blkdev_report_zones() can trigger a memory
 	 * reclaim which may in turn cause a recursion into zonefs as well as
 	zi->i_ztype = type;
 	zi->i_zsector = zone->start;
 	zi->i_zone_size = zone->len << SECTOR_SHIFT;
+	if (zi->i_zone_size > bdev_zone_sectors(sb->s_bdev) << SECTOR_SHIFT &&
+	    !(sbi->s_features & ZONEFS_F_AGGRCNV)) {
+		zonefs_err(sb,
+			   "zone size %llu doesn't match device's zone sectors %llu\n",
+			   zi->i_zone_size,
+			   bdev_zone_sectors(sb->s_bdev) << SECTOR_SHIFT);
+		return -EINVAL;
+	}
 	zi->i_max_size = min_t(loff_t, MAX_LFS_FILESIZE,
 			       zone->capacity << SECTOR_SHIFT);
 	struct inode *dir = d_inode(parent);
 	struct dentry *dentry;
 	struct inode *inode;
-	int ret;
+	int ret = -ENOMEM;
 	dentry = d_alloc_name(parent, name);
 	if (!dentry)
-		return NULL;
+		return ERR_PTR(ret);
 	inode = new_inode(parent->d_sb);
 	if (!inode)
 dput:
 	dput(dentry);
-	return NULL;
+	return ERR_PTR(ret);
 }
 struct zonefs_zone_data {
 	struct blk_zone *zone, *next, *end;
 	const char *zgroup_name;
 	char *file_name;
-	struct dentry *dir;
+	struct dentry *dir, *dent;
 	unsigned int n = 0;
 	int ret;
 		zgroup_name = "seq";
 	dir = zonefs_create_inode(sb->s_root, zgroup_name, NULL, type);
-	if (!dir) {
+	if (IS_ERR(dir)) {
-		ret = -ENOMEM;
+		ret = PTR_ERR(dir);
 		goto free;
 	}
 		 * Use the file number within its group as file name.
 		 */
 		snprintf(file_name, ZONEFS_NAME_MAX - 1, "%u", n);
-		if (!zonefs_create_inode(dir, file_name, zone, type)) {
+		dent = zonefs_create_inode(dir, file_name, zone, type);
-			ret = -ENOMEM;
+		if (IS_ERR(dent)) {
+			ret = PTR_ERR(dent);
 			goto free;
 		}

fs/zonefs/sysfs.c+0−5

 	ssize_t (*show)(struct zonefs_sb_info *sbi, char *buf);
 };
-static inline struct zonefs_sysfs_attr *to_attr(struct attribute *attr)
-{
-	return container_of(attr, struct zonefs_sysfs_attr, attr);
-}
 #define ZONEFS_SYSFS_ATTR_RO(name) \
 static struct zonefs_sysfs_attr zonefs_sysfs_attr_##name = __ATTR_RO(name)

include/linux/blkdev.h+8−8

 	unsigned char		discard_misaligned;
 	unsigned char		raid_partial_stripes_expensive;
 	enum blk_zoned_model	zoned;
+	/*
+	 * Drivers that set dma_alignment to less than 511 must be prepared to
+	 * handle individual bvec's that are not a multiple of a SECTOR_SIZE
+	 * due to possible offsets.
+	 */
+	unsigned int		dma_alignment;
 };
 typedef int (*report_zones_cb)(struct blk_zone *zone, unsigned int idx,
 	unsigned long		nr_requests;	/* Max # of requests */
 	unsigned int		dma_pad_mask;
-	/*
-	 * Drivers that set dma_alignment to less than 511 must be prepared to
-	 * handle individual bvec's that are not a multiple of a SECTOR_SIZE
-	 * due to possible offsets.
-	 */
-	unsigned int		dma_alignment;
 #ifdef CONFIG_BLK_INLINE_ENCRYPTION
 	struct blk_crypto_profile *crypto_profile;
 extern void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt);
 extern void blk_queue_io_opt(struct request_queue *q, unsigned int opt);
 extern void blk_set_queue_depth(struct request_queue *q, unsigned int depth);
-extern void blk_set_default_limits(struct queue_limits *lim);
 extern void blk_set_stacking_limits(struct queue_limits *lim);
 extern int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
 			    sector_t offset);
 static inline int queue_dma_alignment(const struct request_queue *q)
 {
-	return q ? q->dma_alignment : 511;
+	return q ? q->limits.dma_alignment : 511;
 }
 static inline unsigned int bdev_dma_alignment(struct block_device *bdev)

include/linux/bpf.h+39−21

@@ -27,7 +27,7 @@ · 26 unmodified lines
27	#include <linux/bpfptr.h>	27	#include <linux/bpfptr.h>
28	#include <linux/btf.h>	28	#include <linux/btf.h>
29	#include <linux/rcupdate_trace.h>	29	#include <linux/rcupdate_trace.h>
30	#include <linux/init.h>	30	#include <linux/static_call.h>
31		31
32	struct bpf_verifier_env;	32	struct bpf_verifier_env;
33	struct bpf_verifier_log;	33	struct bpf_verifier_log;
@@ -315,7 +315,7 @@ static inline void __copy_map_value(struct bpf_map map, void dst, void *src, b · 281 unmodified lines
315	u32 next_off = map->off_arr->field_off[i];	315	u32 next_off = map->off_arr->field_off[i];
316		316
317	memcpy(dst + curr_off, src + curr_off, next_off - curr_off);	317	memcpy(dst + curr_off, src + curr_off, next_off - curr_off);
318	curr_off += map->off_arr->field_sz[i];	318	curr_off = next_off + map->off_arr->field_sz[i];
319	}	319	}
320	memcpy(dst + curr_off, src + curr_off, map->value_size - curr_off);	320	memcpy(dst + curr_off, src + curr_off, map->value_size - curr_off);
321	}	321	}
@@ -344,7 +344,7 @@ static inline void zero_map_value(struct bpf_map map, void dst) · 22 unmodified lines
344	u32 next_off = map->off_arr->field_off[i];	344	u32 next_off = map->off_arr->field_off[i];
345		345
346	memset(dst + curr_off, 0, next_off - curr_off);	346	memset(dst + curr_off, 0, next_off - curr_off);
347	curr_off += map->off_arr->field_sz[i];	347	curr_off = next_off + map->off_arr->field_sz[i];
348	}	348	}
349	memset(dst + curr_off, 0, map->value_size - curr_off);	349	memset(dst + curr_off, 0, map->value_size - curr_off);
350	}	350	}
@@ -954,6 +954,10 @@ struct bpf_dispatcher { · 603 unmodified lines
954	void *rw_image;	954	void *rw_image;
955	u32 image_off;	955	u32 image_off;
956	struct bpf_ksym ksym;	956	struct bpf_ksym ksym;
		957	#ifdef CONFIG_HAVE_STATIC_CALL
		958	struct static_call_key *sc_key;
		959	void *sc_tramp;
		960	#endif
957	};	961	};
958		962
959	static __always_inline __nocfi unsigned int bpf_dispatcher_nop_func(	963	static __always_inline __nocfi unsigned int bpf_dispatcher_nop_func(
@@ -971,7 +975,33 @@ struct bpf_trampoline *bpf_trampoline_get(u64 key, · 11 unmodified lines
971	struct bpf_attach_target_info *tgt_info);	975	struct bpf_attach_target_info *tgt_info);
972	void bpf_trampoline_put(struct bpf_trampoline *tr);	976	void bpf_trampoline_put(struct bpf_trampoline *tr);
973	int arch_prepare_bpf_dispatcher(void image, void buf, s64 *funcs, int num_funcs);	977	int arch_prepare_bpf_dispatcher(void image, void buf, s64 *funcs, int num_funcs);
974	int __init bpf_arch_init_dispatcher_early(void *ip);	978
		979	/*
		980	* When the architecture supports STATIC_CALL replace the bpf_dispatcher_fn
		981	* indirection with a direct call to the bpf program. If the architecture does
		982	* not have STATIC_CALL, avoid a double-indirection.
		983	*/
		984	#ifdef CONFIG_HAVE_STATIC_CALL
		985
		986	#define __BPF_DISPATCHER_SC_INIT(_name) \
		987	.sc_key = &STATIC_CALL_KEY(_name), \
		988	.sc_tramp = STATIC_CALL_TRAMP_ADDR(_name),
		989
		990	#define __BPF_DISPATCHER_SC(name) \
		991	DEFINE_STATIC_CALL(bpf_dispatcher_##name##_call, bpf_dispatcher_nop_func)
		992
		993	#define __BPF_DISPATCHER_CALL(name) \
		994	static_call(bpf_dispatcher_##name##_call)(ctx, insnsi, bpf_func)
		995
		996	#define __BPF_DISPATCHER_UPDATE(_d, _new) \
		997	__static_call_update((_d)->sc_key, (_d)->sc_tramp, (_new))
		998
		999	#else
		1000	#define __BPF_DISPATCHER_SC_INIT(name)
		1001	#define __BPF_DISPATCHER_SC(name)
		1002	#define __BPF_DISPATCHER_CALL(name) bpf_func(ctx, insnsi)
		1003	#define __BPF_DISPATCHER_UPDATE(_d, _new)
		1004	#endif
975		1005
976	#define BPF_DISPATCHER_INIT(_name) { \	1006	#define BPF_DISPATCHER_INIT(_name) { \
977	.mutex = __MUTEX_INITIALIZER(_name.mutex), \	1007	.mutex = __MUTEX_INITIALIZER(_name.mutex), \
@@ -984,34 +1014,21 @@ int __init bpf_arch_init_dispatcher_early(void *ip); · 6 unmodified lines
984	.name = #_name, \	1014	.name = #_name, \
985	.lnode = LIST_HEAD_INIT(_name.ksym.lnode), \	1015	.lnode = LIST_HEAD_INIT(_name.ksym.lnode), \
986	}, \	1016	}, \
		1017	__BPF_DISPATCHER_SC_INIT(_name##_call) \
987	}	1018	}
988		1019
989	#define BPF_DISPATCHER_INIT_CALL(_name) \
990	static int __init _name##_init(void) \
991	{ \
992	return bpf_arch_init_dispatcher_early(_name##_func); \
993	} \
994	early_initcall(_name##_init)
995
996	#ifdef CONFIG_X86_64
997	#define BPF_DISPATCHER_ATTRIBUTES __attribute__((patchable_function_entry(5)))
998	#else
999	#define BPF_DISPATCHER_ATTRIBUTES
1000	#endif
1001
1002	#define DEFINE_BPF_DISPATCHER(name) \	1020	#define DEFINE_BPF_DISPATCHER(name) \
1003	notrace BPF_DISPATCHER_ATTRIBUTES \	1021	__BPF_DISPATCHER_SC(name); \
1004	noinline __nocfi unsigned int bpf_dispatcher_##name##_func( \	1022	noinline __nocfi unsigned int bpf_dispatcher_##name##_func( \
1005	const void *ctx, \	1023	const void *ctx, \
1006	const struct bpf_insn *insnsi, \	1024	const struct bpf_insn *insnsi, \
1007	bpf_func_t bpf_func) \	1025	bpf_func_t bpf_func) \
1008	{ \	1026	{ \
1009	return bpf_func(ctx, insnsi); \	1027	return __BPF_DISPATCHER_CALL(name); \
1010	} \	1028	} \
1011	EXPORT_SYMBOL(bpf_dispatcher_##name##_func); \	1029	EXPORT_SYMBOL(bpf_dispatcher_##name##_func); \
1012	struct bpf_dispatcher bpf_dispatcher_##name = \	1030	struct bpf_dispatcher bpf_dispatcher_##name = \
1013	BPF_DISPATCHER_INIT(bpf_dispatcher_##name); \	1031	BPF_DISPATCHER_INIT(bpf_dispatcher_##name);
1014	BPF_DISPATCHER_INIT_CALL(bpf_dispatcher_##name);
1015		1032
1016	#define DECLARE_BPF_DISPATCHER(name) \	1033	#define DECLARE_BPF_DISPATCHER(name) \
1017	unsigned int bpf_dispatcher_##name##_func( \	1034	unsigned int bpf_dispatcher_##name##_func( \
@@ -1019,6 +1036,7 @@ int __init bpf_arch_init_dispatcher_early(void *ip); · 1 unmodified line
1019	const struct bpf_insn *insnsi, \	1036	const struct bpf_insn *insnsi, \
1020	bpf_func_t bpf_func); \	1037	bpf_func_t bpf_func); \
1021	extern struct bpf_dispatcher bpf_dispatcher_##name;	1038	extern struct bpf_dispatcher bpf_dispatcher_##name;
		1039
1022	#define BPF_DISPATCHER_FUNC(name) bpf_dispatcher_##name##_func	1040	#define BPF_DISPATCHER_FUNC(name) bpf_dispatcher_##name##_func
1023	#define BPF_DISPATCHER_PTR(name) (&bpf_dispatcher_##name)	1041	#define BPF_DISPATCHER_PTR(name) (&bpf_dispatcher_##name)
1024	void bpf_dispatcher_change_prog(struct bpf_dispatcher d, struct bpf_prog from,	1042	void bpf_dispatcher_change_prog(struct bpf_dispatcher d, struct bpf_prog from,

include/linux/io_uring.h+3−0

@@ -16,6 +16,9 @@ enum io_uring_cmd_flags { · 15 unmodified lines
16	IO_URING_F_SQE128 = 4,	16	IO_URING_F_SQE128 = 4,
17	IO_URING_F_CQE32 = 8,	17	IO_URING_F_CQE32 = 8,
18	IO_URING_F_IOPOLL = 16,	18	IO_URING_F_IOPOLL = 16,
		19
		20	/* the request is executed from poll, it should not be freed */
		21	IO_URING_F_MULTISHOT = 32,
19	};	22	};
20		23
21	struct io_uring_cmd {	24	struct io_uring_cmd {

include/linux/ring_buffer.h+1−1

@@ -100,7 +100,7 @@ __ring_buffer_alloc(unsigned long size, unsigned flags, struct lock_class_key *k · 99 unmodified lines
100		100
101	int ring_buffer_wait(struct trace_buffer *buffer, int cpu, int full);	101	int ring_buffer_wait(struct trace_buffer *buffer, int cpu, int full);
102	__poll_t ring_buffer_poll_wait(struct trace_buffer *buffer, int cpu,	102	__poll_t ring_buffer_poll_wait(struct trace_buffer *buffer, int cpu,
103	struct file filp, poll_table poll_table);	103	struct file filp, poll_table poll_table, int full);
104	void ring_buffer_wake_waiters(struct trace_buffer *buffer, int cpu);	104	void ring_buffer_wake_waiters(struct trace_buffer *buffer, int cpu);
105		105
106	#define RING_BUFFER_ALL_CPUS -1	106	#define RING_BUFFER_ALL_CPUS -1

include/linux/trace.h+2−2

 	int flags;
 };
+struct trace_array;
 #ifdef CONFIG_TRACING
 int register_ftrace_export(struct trace_export *export);
 int unregister_ftrace_export(struct trace_export *export);
-struct trace_array;
 void trace_printk_init_buffers(void);
 __printf(3, 4)
 int trace_array_printk(struct trace_array *tr, unsigned long ip,

include/linux/vfio.h+1−0

@@ -189,6 +189,7 @@ int vfio_register_emulated_iommu_dev(struct vfio_device *device); · 188 unmodified lines
189	void vfio_unregister_group_dev(struct vfio_device *device);	189	void vfio_unregister_group_dev(struct vfio_device *device);
190		190
191	int vfio_assign_device_set(struct vfio_device device, void set_id);	191	int vfio_assign_device_set(struct vfio_device device, void set_id);
		192	unsigned int vfio_device_set_open_count(struct vfio_device_set *dev_set);
192		193
193	int vfio_mig_get_next_state(struct vfio_device *device,	194	int vfio_mig_get_next_state(struct vfio_device *device,
194	enum vfio_device_mig_state cur_fsm,	195	enum vfio_device_mig_state cur_fsm,

include/net/ip.h+1−1

@@ -563,7 +563,7 @@ static inline void iph_to_flow_copy_v4addrs(struct flow_keys *flow, · 562 unmodified lines
563	BUILD_BUG_ON(offsetof(typeof(flow->addrs), v4addrs.dst) !=	563	BUILD_BUG_ON(offsetof(typeof(flow->addrs), v4addrs.dst) !=
564	offsetof(typeof(flow->addrs), v4addrs.src) +	564	offsetof(typeof(flow->addrs), v4addrs.src) +
565	sizeof(flow->addrs.v4addrs.src));	565	sizeof(flow->addrs.v4addrs.src));
566	memcpy(&flow->addrs.v4addrs, &iph->saddr, sizeof(flow->addrs.v4addrs));	566	memcpy(&flow->addrs.v4addrs, &iph->addrs, sizeof(flow->addrs.v4addrs));
567	flow->control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;	567	flow->control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
568	}	568	}
569		569

include/net/ipv6.h+1−1

@@ -897,7 +897,7 @@ static inline void iph_to_flow_copy_v6addrs(struct flow_keys *flow, · 896 unmodified lines
897	BUILD_BUG_ON(offsetof(typeof(flow->addrs), v6addrs.dst) !=	897	BUILD_BUG_ON(offsetof(typeof(flow->addrs), v6addrs.dst) !=
898	offsetof(typeof(flow->addrs), v6addrs.src) +	898	offsetof(typeof(flow->addrs), v6addrs.src) +
899	sizeof(flow->addrs.v6addrs.src));	899	sizeof(flow->addrs.v6addrs.src));
900	memcpy(&flow->addrs.v6addrs, &iph->saddr, sizeof(flow->addrs.v6addrs));	900	memcpy(&flow->addrs.v6addrs, &iph->addrs, sizeof(flow->addrs.v6addrs));
901	flow->control.addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS;	901	flow->control.addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS;
902	}	902	}
903		903

include/net/sock.h+1−1

@@ -323,7 +323,7 @@ struct sk_filter; · 322 unmodified lines
323	* @sk_tskey: counter to disambiguate concurrent tstamp requests	323	* @sk_tskey: counter to disambiguate concurrent tstamp requests
324	* @sk_zckey: counter to order MSG_ZEROCOPY notifications	324	* @sk_zckey: counter to order MSG_ZEROCOPY notifications
325	* @sk_socket: Identd and reporting IO signals	325	* @sk_socket: Identd and reporting IO signals
326	* @sk_user_data: RPC layer private data	326	* @sk_user_data: RPC layer private data. Write-protected by @sk_callback_lock.
327	* @sk_frag: cached page frag	327	* @sk_frag: cached page frag
328	* @sk_peek_off: current peek_offset value	328	* @sk_peek_off: current peek_offset value
329	* @sk_send_head: front of stuff to transmit	329	* @sk_send_head: front of stuff to transmit

include/soc/at91/sama7-ddr.h+4−1

 #define	DDR3PHY_PGSR				(0x0C)		/* DDR3PHY PHY General Status Register */
 #define		DDR3PHY_PGSR_IDONE		(1 << 0)	/* Initialization Done */
-#define DDR3PHY_ACIOCR				(0x24)		/*  DDR3PHY AC I/O Configuration Register */
+#define	DDR3PHY_ACDLLCR				(0x14)		/* DDR3PHY AC DLL Control Register */
+#define		DDR3PHY_ACDLLCR_DLLSRST		(1 << 30)	/* DLL Soft Reset */
+#define DDR3PHY_ACIOCR				(0x24)		/* DDR3PHY AC I/O Configuration Register */
 #define		DDR3PHY_ACIOCR_CSPDD_CS0	(1 << 18)	/* CS#[0] Power Down Driver */
 #define		DDR3PHY_ACIOCR_CKPDD_CK0	(1 << 8)	/* CK[0] Power Down Driver */
 #define		DDR3PHY_ACIORC_ACPDD		(1 << 3)	/* AC Power Down Driver */

include/sound/hdmi-codec.h+4−0

 struct hdmi_codec_pdata {
 	const struct hdmi_codec_ops *ops;
 	uint i2s:1;
+	uint no_i2s_playback:1;
+	uint no_i2s_capture:1;
 	uint spdif:1;
+	uint no_spdif_playback:1;
+	uint no_spdif_capture:1;
 	int max_i2s_channels;
 	void *data;
 };

include/uapi/linux/ip.h+4−2

 	__u8	ttl;
 	__u8	protocol;
 	__sum16	check;
-	__be32	saddr;
+	__struct_group(/* no tag */, addrs, /* no attrs */,
-	__be32	daddr;
+		__be32	saddr;
+		__be32	daddr;
+	);
 	/*The options start here. */
 };

include/uapi/linux/ipv6.h+4−2

@@ -130,8 +130,10 @@ struct ipv6hdr { · 129 unmodified lines
130	__u8 nexthdr;	130	__u8 nexthdr;
131	__u8 hop_limit;	131	__u8 hop_limit;
132		132
133	struct in6_addr saddr;	133	__struct_group(/* no tag /, addrs, / no attrs */,
134	struct in6_addr daddr;	134	struct in6_addr saddr;
		135	struct in6_addr daddr;
		136	);
135	};	137	};
136		138
137		139

io_uring/io_uring.c+1−1

@@ -1768,7 +1768,7 @@ int io_poll_issue(struct io_kiocb req, bool locked) · 1767 unmodified lines
1768	io_tw_lock(req->ctx, locked);	1768	io_tw_lock(req->ctx, locked);
1769	if (unlikely(req->task->flags & PF_EXITING))	1769	if (unlikely(req->task->flags & PF_EXITING))
1770	return -EFAULT;	1770	return -EFAULT;
1771	return io_issue_sqe(req, IO_URING_F_NONBLOCK);	1771	return io_issue_sqe(req, IO_URING_F_NONBLOCK\|IO_URING_F_MULTISHOT);
1772	}	1772	}
1773		1773
1774	struct io_wq_work io_wq_free_work(struct io_wq_work work)	1774	struct io_wq_work io_wq_free_work(struct io_wq_work work)

io_uring/io_uring.h+2−2

@@ -17,8 +17,8 @@ enum { · 16 unmodified lines
17	IOU_ISSUE_SKIP_COMPLETE = -EIOCBQUEUED,	17	IOU_ISSUE_SKIP_COMPLETE = -EIOCBQUEUED,
18		18
19	/*	19	/*
20	* Intended only when both REQ_F_POLLED and REQ_F_APOLL_MULTISHOT	20	* Intended only when both IO_URING_F_MULTISHOT is passed
21	* are set to indicate to the poll runner that multishot should be	21	* to indicate to the poll runner that multishot should be
22	* removed and the result is set on req->cqe.res.	22	* removed and the result is set on req->cqe.res.
23	*/	23	*/
24	IOU_STOP_MULTISHOT = -ECANCELED,	24	IOU_STOP_MULTISHOT = -ECANCELED,

io_uring/net.c+9−14

 	struct io_kiocb 		*notif;
 };
-#define IO_APOLL_MULTI_POLLED (REQ_F_APOLL_MULTISHOT | REQ_F_POLLED)
 int io_shutdown_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 {
 	struct io_shutdown *shutdown = io_kiocb_to_cmd(req, struct io_shutdown);
  * again (for multishot).
  */
 static inline bool io_recv_finish(struct io_kiocb *req, int *ret,
-				  unsigned int cflags, bool mshot_finished)
+				  unsigned int cflags, bool mshot_finished,
+				  unsigned issue_flags)
 {
 	if (!(req->flags & REQ_F_APOLL_MULTISHOT)) {
 		io_req_set_res(req, *ret, cflags);
 	io_req_set_res(req, *ret, cflags);
-	if (req->flags & REQ_F_POLLED)
+	if (issue_flags & IO_URING_F_MULTISHOT)
 		*ret = IOU_STOP_MULTISHOT;
 	else
 		*ret = IOU_OK;
 	if (ret < min_ret) {
 		if (ret == -EAGAIN && force_nonblock) {
 			ret = io_setup_async_msg(req, kmsg, issue_flags);
-			if (ret == -EAGAIN && (req->flags & IO_APOLL_MULTI_POLLED) ==
+			if (ret == -EAGAIN && (issue_flags & IO_URING_F_MULTISHOT)) {
-					       IO_APOLL_MULTI_POLLED) {
 				io_kbuf_recycle(req, issue_flags);
 				return IOU_ISSUE_SKIP_COMPLETE;
 			}
 	if (kmsg->msg.msg_inq)
 		cflags |= IORING_CQE_F_SOCK_NONEMPTY;
-	if (!io_recv_finish(req, &ret, cflags, mshot_finished))
+	if (!io_recv_finish(req, &ret, cflags, mshot_finished, issue_flags))
 		goto retry_multishot;
 	if (mshot_finished) {
 	ret = sock_recvmsg(sock, &msg, flags);
 	if (ret < min_ret) {
 		if (ret == -EAGAIN && force_nonblock) {
-			if ((req->flags & IO_APOLL_MULTI_POLLED) == IO_APOLL_MULTI_POLLED) {
+			if (issue_flags & IO_URING_F_MULTISHOT) {
 				io_kbuf_recycle(req, issue_flags);
 				return IOU_ISSUE_SKIP_COMPLETE;
 			}
 	if (msg.msg_inq)
 		cflags |= IORING_CQE_F_SOCK_NONEMPTY;
-	if (!io_recv_finish(req, &ret, cflags, ret <= 0))
+	if (!io_recv_finish(req, &ret, cflags, ret <= 0, issue_flags))
 		goto retry_multishot;
 	return ret;
 			 * return EAGAIN to arm the poll infra since it
 			 * has already been done
 			 */
-			if ((req->flags & IO_APOLL_MULTI_POLLED) ==
+			if (issue_flags & IO_URING_F_MULTISHOT)
-			    IO_APOLL_MULTI_POLLED)
 				ret = IOU_ISSUE_SKIP_COMPLETE;
 			return ret;
 		}
 		goto retry;
 	io_req_set_res(req, ret, 0);
-	if (req->flags & REQ_F_POLLED)
+	return (issue_flags & IO_URING_F_MULTISHOT) ? IOU_STOP_MULTISHOT : IOU_OK;
-		return IOU_STOP_MULTISHOT;
-	return IOU_OK;
 }
 int io_socket_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)

io_uring/poll.c+12−0

 			return IOU_POLL_DONE;
 		if (v & IO_POLL_CANCEL_FLAG)
 			return -ECANCELED;
+		/*
+		 * cqe.res contains only events of the first wake up
+		 * and all others are be lost. Redo vfs_poll() to get
+		 * up to date state.
+		 */
+		if ((v & IO_POLL_REF_MASK) != 1)
+			req->cqe.res = 0;
 		/* the mask was stashed in __io_poll_execute */
 		if (!req->cqe.res) {
 			continue;
 		if (req->apoll_events & EPOLLONESHOT)
 			return IOU_POLL_DONE;
+		if (io_is_uring_fops(req->file))
+			return IOU_POLL_DONE;
 		/* multishot, just fill a CQE and proceed */
 		if (!(req->flags & REQ_F_APOLL_MULTISHOT)) {
 				return ret;
 		}
+		/* force the next iteration to vfs_poll() */
+		req->cqe.res = 0;
 		/*
 		 * Release all references, retry if someone tried to restart
 		 * task_work while we were executing it.

kernel/bpf/dispatcher.c+8−20

@@ -4,7 +4,7 @@ · 3 unmodified lines
4	#include <linux/hash.h>	4	#include <linux/hash.h>
5	#include <linux/bpf.h>	5	#include <linux/bpf.h>
6	#include <linux/filter.h>	6	#include <linux/filter.h>
7	#include <linux/init.h>	7	#include <linux/static_call.h>
8		8
9	/* The BPF dispatcher is a multiway branch code generator. The	9	/* The BPF dispatcher is a multiway branch code generator. The
10	* dispatcher is a mechanism to avoid the performance penalty of an	10	* dispatcher is a mechanism to avoid the performance penalty of an
@@ -91,11 +91,6 @@ int __weak arch_prepare_bpf_dispatcher(void image, void buf, s64 *funcs, int n · 80 unmodified lines
91	return -ENOTSUPP;	91	return -ENOTSUPP;
92	}	92	}
93		93
94	int __weak __init bpf_arch_init_dispatcher_early(void *ip)
95	{
96	return -ENOTSUPP;
97	}
98
99	static int bpf_dispatcher_prepare(struct bpf_dispatcher d, void image, void *buf)	94	static int bpf_dispatcher_prepare(struct bpf_dispatcher d, void image, void *buf)
100	{	95	{
101	s64 ips[BPF_DISPATCHER_MAX] = {}, *ipsp = &ips[0];	96	s64 ips[BPF_DISPATCHER_MAX] = {}, *ipsp = &ips[0];
@@ -110,17 +105,11 @@ static int bpf_dispatcher_prepare(struct bpf_dispatcher d, void image, void *b · 8 unmodified lines
110		105
111	static void bpf_dispatcher_update(struct bpf_dispatcher *d, int prev_num_progs)	106	static void bpf_dispatcher_update(struct bpf_dispatcher *d, int prev_num_progs)
112	{	107	{
113	void old, new, *tmp;	108	void new, tmp;
114	u32 noff;	109	u32 noff = 0;
115	int err;	110
116		111	if (prev_num_progs)
117	if (!prev_num_progs) {
118	old = NULL;
119	noff = 0;
120	} else {
121	old = d->image + d->image_off;
122	noff = d->image_off ^ (PAGE_SIZE / 2);	112	noff = d->image_off ^ (PAGE_SIZE / 2);
123	}
124		113
125	new = d->num_progs ? d->image + noff : NULL;	114	new = d->num_progs ? d->image + noff : NULL;
126	tmp = d->num_progs ? d->rw_image + noff : NULL;	115	tmp = d->num_progs ? d->rw_image + noff : NULL;
@@ -134,11 +123,10 @@ static void bpf_dispatcher_update(struct bpf_dispatcher *d, int prev_num_progs) · 7 unmodified lines
134	return;	123	return;
135	}	124	}
136		125
137	err = bpf_arch_text_poke(d->func, BPF_MOD_JUMP, old, new);	126	__BPF_DISPATCHER_UPDATE(d, new ?: (void *)&bpf_dispatcher_nop_func);
138	if (err \|\| !new)
139	return;
140		127
141	d->image_off = noff;	128	if (new)
		129	d->image_off = noff;
142	}	130	}
143		131
144	void bpf_dispatcher_change_prog(struct bpf_dispatcher d, struct bpf_prog from,	132	void bpf_dispatcher_change_prog(struct bpf_dispatcher d, struct bpf_prog from,

kernel/bpf/percpu_freelist.c+11−12

@@ -100,22 +100,21 @@ void pcpu_freelist_populate(struct pcpu_freelist s, void buf, u32 elem_size, · 99 unmodified lines
100	u32 nr_elems)	100	u32 nr_elems)
101	{	101	{
102	struct pcpu_freelist_head *head;	102	struct pcpu_freelist_head *head;
103	int i, cpu, pcpu_entries;	103	unsigned int cpu, cpu_idx, i, j, n, m;
104		104
105	pcpu_entries = nr_elems / num_possible_cpus() + 1;	105	n = nr_elems / num_possible_cpus();
106	i = 0;	106	m = nr_elems % num_possible_cpus();
107		107
		108	cpu_idx = 0;
108	for_each_possible_cpu(cpu) {	109	for_each_possible_cpu(cpu) {
109	again:
110	head = per_cpu_ptr(s->freelist, cpu);	110	head = per_cpu_ptr(s->freelist, cpu);
111	/* No locking required as this is not visible yet. */	111	j = n + (cpu_idx < m ? 1 : 0);
112	pcpu_freelist_push_node(head, buf);	112	for (i = 0; i < j; i++) {
113	i++;	113	/* No locking required as this is not visible yet. */
114	buf += elem_size;	114	pcpu_freelist_push_node(head, buf);
115	if (i == nr_elems)	115	buf += elem_size;
116	break;	116	}
117	if (i % pcpu_entries)	117	cpu_idx++;
118	goto again;
119	}	118	}
120	}	119	}
121		120

kernel/bpf/verifier.c+9−5

 	/* Transfer references to the callee */
 	err = copy_reference_state(callee, caller);
 	if (err)
-		return err;
+		goto err_out;
 	err = set_callee_state_cb(env, caller, callee, *insn_idx);
 	if (err)
-		return err;
+		goto err_out;
 	clear_caller_saved_regs(env, caller->regs);
 		print_verifier_state(env, callee, true);
 	}
 	return 0;
+err_out:
+	free_func_state(callee);
+	state->frame[state->curframe + 1] = NULL;
+	return err;
 }
 int map_set_for_each_callback_args(struct bpf_verifier_env *env,
 		return -EINVAL;
 	}
-	state->curframe--;
+	caller = state->frame[state->curframe - 1];
-	caller = state->frame[state->curframe];
 	if (callee->in_callback_fn) {
 		/* enforce R0 return value range [0, 1]. */
 		struct tnum range = callee->callback_ret_range;
 	}
 	/* clear everything in the callee */
 	free_func_state(callee);
-	state->frame[state->curframe + 1] = NULL;
+	state->frame[state->curframe--] = NULL;
 	return 0;
 }

kernel/events/core.c+19−6

@@ -9306,14 +9306,27 @@ static int __perf_event_overflow(struct perf_event *event, · 9305 unmodified lines
9306	}	9306	}
9307		9307
9308	if (event->attr.sigtrap) {	9308	if (event->attr.sigtrap) {
9309	/*	9309	unsigned int pending_id = 1;
9310	* Should not be able to return to user space without processing	9310
9311	* pending_sigtrap (kernel events can overflow multiple times).	9311	if (regs)
9312	*/	9312	pending_id = hash32_ptr((void *)instruction_pointer(regs)) ?: 1;
9313	WARN_ON_ONCE(event->pending_sigtrap && event->attr.exclude_kernel);
9314	if (!event->pending_sigtrap) {	9313	if (!event->pending_sigtrap) {
9315	event->pending_sigtrap = 1;	9314	event->pending_sigtrap = pending_id;
9316	local_inc(&event->ctx->nr_pending);	9315	local_inc(&event->ctx->nr_pending);
		9316	} else if (event->attr.exclude_kernel) {
		9317	/*
		9318	* Should not be able to return to user space without
		9319	* consuming pending_sigtrap; with exceptions:
		9320	*
		9321	* 1. Where !exclude_kernel, events can overflow again
		9322	* in the kernel without returning to user space.
		9323	*
		9324	* 2. Events that can overflow again before the IRQ-
		9325	* work without user space progress (e.g. hrtimer).
		9326	* To approximate progress (with false negatives),
		9327	* check 32-bit hash of the current IP.
		9328	*/
		9329	WARN_ON_ONCE(event->pending_sigtrap != pending_id);
9317	}	9330	}
9318	event->pending_addr = data->addr;	9331	event->pending_addr = data->addr;
9319	irq_work_queue(&event->pending_irq);	9332	irq_work_queue(&event->pending_irq);

kernel/kprobes.c+7−1

 				if ((list_p != p) && (list_p->post_handler))
 					goto noclean;
 			}
-			ap->post_handler = NULL;
+			/*
+			 * For the kprobe-on-ftrace case, we keep the
+			 * post_handler setting to identify this aggrprobe
+			 * armed with kprobe_ipmodify_ops.
+			 */
+			if (!kprobe_ftrace(ap))
+				ap->post_handler = NULL;
 		}
 noclean:
 		/*

kernel/rseq.c+17−2

 	return 0;
 }
+static bool rseq_warn_flags(const char *str, u32 flags)
+{
+	u32 test_flags;
+	if (!flags)
+		return false;
+	test_flags = flags & RSEQ_CS_NO_RESTART_FLAGS;
+	if (test_flags)
+		pr_warn_once("Deprecated flags (%u) in %s ABI structure", test_flags, str);
+	test_flags = flags & ~RSEQ_CS_NO_RESTART_FLAGS;
+	if (test_flags)
+		pr_warn_once("Unknown flags (%u) in %s ABI structure", test_flags, str);
+	return true;
+}
 static int rseq_need_restart(struct task_struct *t, u32 cs_flags)
 {
 	u32 flags, event_mask;
 	int ret;
-	if (WARN_ON_ONCE(cs_flags & RSEQ_CS_NO_RESTART_FLAGS) || cs_flags)
+	if (rseq_warn_flags("rseq_cs", cs_flags))
 		return -EINVAL;
 	/* Get thread flags. */
 	if (ret)
 		return ret;
-	if (WARN_ON_ONCE(flags & RSEQ_CS_NO_RESTART_FLAGS) || flags)
+	if (rseq_warn_flags("rseq", flags))
 		return -EINVAL;
 	/*

kernel/sched/core.c+35−17

 	return success;
 }
+static bool __task_needs_rq_lock(struct task_struct *p)
+{
+	unsigned int state = READ_ONCE(p->__state);
+	/*
+	 * Since pi->lock blocks try_to_wake_up(), we don't need rq->lock when
+	 * the task is blocked. Make sure to check @state since ttwu() can drop
+	 * locks at the end, see ttwu_queue_wakelist().
+	 */
+	if (state == TASK_RUNNING || state == TASK_WAKING)
+		return true;
+	/*
+	 * Ensure we load p->on_rq after p->__state, otherwise it would be
+	 * possible to, falsely, observe p->on_rq == 0.
+	 *
+	 * See try_to_wake_up() for a longer comment.
+	 */
+	smp_rmb();
+	if (p->on_rq)
+		return true;
+#ifdef CONFIG_SMP
+	/*
+	 * Ensure the task has finished __schedule() and will not be referenced
+	 * anymore. Again, see try_to_wake_up() for a longer comment.
+	 */
+	smp_rmb();
+	smp_cond_load_acquire(&p->on_cpu, !VAL);
+#endif
+	return false;
+}
 /**
  * task_call_func - Invoke a function on task in fixed state
  * @p: Process for which the function is to be invoked, can be @current.
 int task_call_func(struct task_struct *p, task_call_f func, void *arg)
 {
 	struct rq *rq = NULL;
-	unsigned int state;
 	struct rq_flags rf;
 	int ret;
 	raw_spin_lock_irqsave(&p->pi_lock, rf.flags);
-	state = READ_ONCE(p->__state);
+	if (__task_needs_rq_lock(p))
-	/*
-	 * Ensure we load p->on_rq after p->__state, otherwise it would be
-	 * possible to, falsely, observe p->on_rq == 0.
-	 *
-	 * See try_to_wake_up() for a longer comment.
-	 */
-	smp_rmb();
-	/*
-	 * Since pi->lock blocks try_to_wake_up(), we don't need rq->lock when
-	 * the task is blocked. Make sure to check @state since ttwu() can drop
-	 * locks at the end, see ttwu_queue_wakelist().
-	 */
-	if (state == TASK_RUNNING || state == TASK_WAKING || p->on_rq)
 		rq = __task_rq_lock(p, &rf);
 	/*

kernel/trace/ftrace.c+3−2

 	if (!ftrace_mod)
 		return -ENOMEM;
+	INIT_LIST_HEAD(&ftrace_mod->list);
 	ftrace_mod->func = kstrdup(func, GFP_KERNEL);
 	ftrace_mod->module = kstrdup(module, GFP_KERNEL);
 	ftrace_mod->enable = enable;
 		/* if we can't allocate this size, try something smaller */
 		if (!order)
 			return -ENOMEM;
-		order >>= 1;
+		order--;
 		goto again;
 	}
 	}
 	pr_info("ftrace: allocating %ld entries in %ld pages\n",
-		count, count / ENTRIES_PER_PAGE + 1);
+		count, DIV_ROUND_UP(count, ENTRIES_PER_PAGE));
 	ret = ftrace_process_locs(NULL,
 				  __start_mcount_loc,

kernel/trace/kprobe_event_gen_test.c+32−16

 #define KPROBE_GEN_TEST_ARG3	NULL
 #endif
+static bool trace_event_file_is_valid(struct trace_event_file *input)
+{
+	return input && !IS_ERR(input);
+}
 /*
  * Test to make sure we can create a kprobe event, then add more
 	kfree(buf);
 	return ret;
  delete:
+	if (trace_event_file_is_valid(gen_kprobe_test))
+		gen_kprobe_test = NULL;
 	/* We got an error after creating the event, delete it */
 	ret = kprobe_event_delete("gen_kprobe_test");
 	goto out;
 	kfree(buf);
 	return ret;
  delete:
+	if (trace_event_file_is_valid(gen_kretprobe_test))
+		gen_kretprobe_test = NULL;
 	/* We got an error after creating the event, delete it */
 	ret = kprobe_event_delete("gen_kretprobe_test");
 	goto out;
 	ret = test_gen_kretprobe_cmd();
 	if (ret) {
-		WARN_ON(trace_array_set_clr_event(gen_kretprobe_test->tr,
+		if (trace_event_file_is_valid(gen_kretprobe_test)) {
-						  "kprobes",
+			WARN_ON(trace_array_set_clr_event(gen_kretprobe_test->tr,
-						  "gen_kretprobe_test", false));
+							  "kprobes",
-		trace_put_event_file(gen_kretprobe_test);
+							  "gen_kretprobe_test", false));
+			trace_put_event_file(gen_kretprobe_test);
+		}
 		WARN_ON(kprobe_event_delete("gen_kretprobe_test"));
 	}
 static void __exit kprobe_event_gen_test_exit(void)
 {
-	/* Disable the event or you can't remove it */
+	if (trace_event_file_is_valid(gen_kprobe_test)) {
-	WARN_ON(trace_array_set_clr_event(gen_kprobe_test->tr,
+		/* Disable the event or you can't remove it */
-					  "kprobes",
+		WARN_ON(trace_array_set_clr_event(gen_kprobe_test->tr,
-					  "gen_kprobe_test", false));
+						  "kprobes",
+						  "gen_kprobe_test", false));
+		/* Now give the file and instance back */
+		trace_put_event_file(gen_kprobe_test);
+	}
-	/* Now give the file and instance back */
-	trace_put_event_file(gen_kprobe_test);
 	/* Now unregister and free the event */
 	WARN_ON(kprobe_event_delete("gen_kprobe_test"));
-	/* Disable the event or you can't remove it */
+	if (trace_event_file_is_valid(gen_kretprobe_test)) {
-	WARN_ON(trace_array_set_clr_event(gen_kretprobe_test->tr,
+		/* Disable the event or you can't remove it */
-					  "kprobes",
+		WARN_ON(trace_array_set_clr_event(gen_kretprobe_test->tr,
-					  "gen_kretprobe_test", false));
+						  "kprobes",
+						  "gen_kretprobe_test", false));
+		/* Now give the file and instance back */
+		trace_put_event_file(gen_kretprobe_test);
+	}
-	/* Now give the file and instance back */
-	trace_put_event_file(gen_kretprobe_test);
 	/* Now unregister and free the event */
 	WARN_ON(kprobe_event_delete("gen_kretprobe_test"));

kernel/trace/rethook.c+3−1

 {
 	struct rethook *rh = kzalloc(sizeof(struct rethook), GFP_KERNEL);
-	if (!rh || !handler)
+	if (!rh || !handler) {
+		kfree(rh);
 		return NULL;
+	}
 	rh->data = data;
 	rh->handler = handler;

kernel/trace/ring_buffer.c+50−21

@@ -519,6 +519,7 @@ struct ring_buffer_per_cpu { · 518 unmodified lines
519	local_t committing;	519	local_t committing;
520	local_t commits;	520	local_t commits;
521	local_t pages_touched;	521	local_t pages_touched;
		522	local_t pages_lost;
522	local_t pages_read;	523	local_t pages_read;
523	long last_pages_touch;	524	long last_pages_touch;
524	size_t shortest_full;	525	size_t shortest_full;
@@ -894,10 +895,18 @@ size_t ring_buffer_nr_pages(struct trace_buffer *buffer, int cpu) · 369 unmodified lines
894	size_t ring_buffer_nr_dirty_pages(struct trace_buffer *buffer, int cpu)	895	size_t ring_buffer_nr_dirty_pages(struct trace_buffer *buffer, int cpu)
895	{	896	{
896	size_t read;	897	size_t read;
		898	size_t lost;
897	size_t cnt;	899	size_t cnt;
898		900
899	read = local_read(&buffer->buffers[cpu]->pages_read);	901	read = local_read(&buffer->buffers[cpu]->pages_read);
		902	lost = local_read(&buffer->buffers[cpu]->pages_lost);
900	cnt = local_read(&buffer->buffers[cpu]->pages_touched);	903	cnt = local_read(&buffer->buffers[cpu]->pages_touched);
		904
		905	if (WARN_ON_ONCE(cnt < lost))
		906	return 0;
		907
		908	cnt -= lost;
		909
901	/* The reader can read an empty page, but not more than that */	910	/* The reader can read an empty page, but not more than that */
902	if (cnt < read) {	911	if (cnt < read) {
903	WARN_ON_ONCE(read > cnt + 1);	912	WARN_ON_ONCE(read > cnt + 1);
@@ -907,6 +916,21 @@ size_t ring_buffer_nr_dirty_pages(struct trace_buffer *buffer, int cpu) · 3 unmodified lines
907	return cnt - read;	916	return cnt - read;
908	}	917	}
909		918
		919	static __always_inline bool full_hit(struct trace_buffer *buffer, int cpu, int full)
		920	{
		921	struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
		922	size_t nr_pages;
		923	size_t dirty;
		924
		925	nr_pages = cpu_buffer->nr_pages;
		926	if (!nr_pages \|\| !full)
		927	return true;
		928
		929	dirty = ring_buffer_nr_dirty_pages(buffer, cpu);
		930
		931	return (dirty * 100) > (full * nr_pages);
		932	}
		933
910	/*	934	/*
911	* rb_wake_up_waiters - wake up tasks waiting for ring buffer input	935	* rb_wake_up_waiters - wake up tasks waiting for ring buffer input
912	*	936	*
@@ -1046,22 +1070,20 @@ int ring_buffer_wait(struct trace_buffer *buffer, int cpu, int full) · 133 unmodified lines
1046	!ring_buffer_empty_cpu(buffer, cpu)) {	1070	!ring_buffer_empty_cpu(buffer, cpu)) {
1047	unsigned long flags;	1071	unsigned long flags;
1048	bool pagebusy;	1072	bool pagebusy;
1049	size_t nr_pages;	1073	bool done;
1050	size_t dirty;
1051		1074
1052	if (!full)	1075	if (!full)
1053	break;	1076	break;
1054		1077
1055	raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);	1078	raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
1056	pagebusy = cpu_buffer->reader_page == cpu_buffer->commit_page;	1079	pagebusy = cpu_buffer->reader_page == cpu_buffer->commit_page;
1057	nr_pages = cpu_buffer->nr_pages;	1080	done = !pagebusy && full_hit(buffer, cpu, full);
1058	dirty = ring_buffer_nr_dirty_pages(buffer, cpu);	1081
1059	if (!cpu_buffer->shortest_full \|\|	1082	if (!cpu_buffer->shortest_full \|\|
1060	cpu_buffer->shortest_full > full)	1083	cpu_buffer->shortest_full > full)
1061	cpu_buffer->shortest_full = full;	1084	cpu_buffer->shortest_full = full;
1062	raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);	1085	raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
1063	if (!pagebusy &&	1086	if (done)
1064	(!nr_pages \|\| (dirty * 100) > full * nr_pages))
1065	break;	1087	break;
1066	}	1088	}
1067		1089
@@ -1087,6 +1109,7 @@ int ring_buffer_wait(struct trace_buffer *buffer, int cpu, int full) · 19 unmodified lines
1087	* @cpu: the cpu buffer to wait on	1109	* @cpu: the cpu buffer to wait on
1088	* @filp: the file descriptor	1110	* @filp: the file descriptor
1089	* @poll_table: The poll descriptor	1111	* @poll_table: The poll descriptor
		1112	* @full: wait until the percentage of pages are available, if @cpu != RING_BUFFER_ALL_CPUS
1090	*	1113	*
1091	* If @cpu == RING_BUFFER_ALL_CPUS then the task will wake up as soon	1114	* If @cpu == RING_BUFFER_ALL_CPUS then the task will wake up as soon
1092	* as data is added to any of the @buffer's cpu buffers. Otherwise	1115	* as data is added to any of the @buffer's cpu buffers. Otherwise
@@ -1096,14 +1119,15 @@ int ring_buffer_wait(struct trace_buffer *buffer, int cpu, int full) · 3 unmodified lines
1096	* zero otherwise.	1119	* zero otherwise.
1097	*/	1120	*/
1098	__poll_t ring_buffer_poll_wait(struct trace_buffer *buffer, int cpu,	1121	__poll_t ring_buffer_poll_wait(struct trace_buffer *buffer, int cpu,
1099	struct file filp, poll_table poll_table)	1122	struct file filp, poll_table poll_table, int full)
1100	{	1123	{
1101	struct ring_buffer_per_cpu *cpu_buffer;	1124	struct ring_buffer_per_cpu *cpu_buffer;
1102	struct rb_irq_work *work;	1125	struct rb_irq_work *work;
1103		1126
1104	if (cpu == RING_BUFFER_ALL_CPUS)	1127	if (cpu == RING_BUFFER_ALL_CPUS) {
1105	work = &buffer->irq_work;	1128	work = &buffer->irq_work;
1106	else {	1129	full = 0;
		1130	} else {
1107	if (!cpumask_test_cpu(cpu, buffer->cpumask))	1131	if (!cpumask_test_cpu(cpu, buffer->cpumask))
1108	return -EINVAL;	1132	return -EINVAL;
1109		1133
@@ -1111,8 +1135,14 @@ __poll_t ring_buffer_poll_wait(struct trace_buffer *buffer, int cpu, · 1 unmodified line
1111	work = &cpu_buffer->irq_work;	1135	work = &cpu_buffer->irq_work;
1112	}	1136	}
1113		1137
1114	poll_wait(filp, &work->waiters, poll_table);	1138	if (full) {
1115	work->waiters_pending = true;	1139	poll_wait(filp, &work->full_waiters, poll_table);
		1140	work->full_waiters_pending = true;
		1141	} else {
		1142	poll_wait(filp, &work->waiters, poll_table);
		1143	work->waiters_pending = true;
		1144	}
		1145
1116	/*	1146	/*
1117	* There's a tight race between setting the waiters_pending and	1147	* There's a tight race between setting the waiters_pending and
1118	* checking if the ring buffer is empty. Once the waiters_pending bit	1148	* checking if the ring buffer is empty. Once the waiters_pending bit
@@ -1128,6 +1158,9 @@ __poll_t ring_buffer_poll_wait(struct trace_buffer *buffer, int cpu, · 9 unmodified lines
1128	*/	1158	*/
1129	smp_mb();	1159	smp_mb();
1130		1160
		1161	if (full)
		1162	return full_hit(buffer, cpu, full) ? EPOLLIN \| EPOLLRDNORM : 0;
		1163
1131	if ((cpu == RING_BUFFER_ALL_CPUS && !ring_buffer_empty(buffer)) \|\|	1164	if ((cpu == RING_BUFFER_ALL_CPUS && !ring_buffer_empty(buffer)) \|\|
1132	(cpu != RING_BUFFER_ALL_CPUS && !ring_buffer_empty_cpu(buffer, cpu)))	1165	(cpu != RING_BUFFER_ALL_CPUS && !ring_buffer_empty_cpu(buffer, cpu)))
1133	return EPOLLIN \| EPOLLRDNORM;	1166	return EPOLLIN \| EPOLLRDNORM;
@@ -1769,9 +1802,9 @@ static void rb_free_cpu_buffer(struct ring_buffer_per_cpu *cpu_buffer) · 635 unmodified lines
1769		1802
1770	free_buffer_page(cpu_buffer->reader_page);	1803	free_buffer_page(cpu_buffer->reader_page);
1771		1804
1772	rb_head_page_deactivate(cpu_buffer);
1773
1774	if (head) {	1805	if (head) {
		1806	rb_head_page_deactivate(cpu_buffer);
		1807
1775	list_for_each_entry_safe(bpage, tmp, head, list) {	1808	list_for_each_entry_safe(bpage, tmp, head, list) {
1776	list_del_init(&bpage->list);	1809	list_del_init(&bpage->list);
1777	free_buffer_page(bpage);	1810	free_buffer_page(bpage);
@@ -2007,6 +2040,7 @@ rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned long nr_pages) · 229 unmodified lines
2007	*/	2040	*/
2008	local_add(page_entries, &cpu_buffer->overrun);	2041	local_add(page_entries, &cpu_buffer->overrun);
2009	local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes);	2042	local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes);
		2043	local_inc(&cpu_buffer->pages_lost);
2010	}	2044	}
2011		2045
2012	/*	2046	/*
@@ -2491,6 +2525,7 @@ rb_handle_head_page(struct ring_buffer_per_cpu *cpu_buffer, · 478 unmodified lines
2491	*/	2525	*/
2492	local_add(entries, &cpu_buffer->overrun);	2526	local_add(entries, &cpu_buffer->overrun);
2493	local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes);	2527	local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes);
		2528	local_inc(&cpu_buffer->pages_lost);
2494		2529
2495	/*	2530	/*
2496	* The entries will be zeroed out when we move the	2531	* The entries will be zeroed out when we move the
@@ -3155,10 +3190,6 @@ static void rb_commit(struct ring_buffer_per_cpu *cpu_buffer, · 658 unmodified lines
3155	static __always_inline void	3190	static __always_inline void
3156	rb_wakeups(struct trace_buffer buffer, struct ring_buffer_per_cpu cpu_buffer)	3191	rb_wakeups(struct trace_buffer buffer, struct ring_buffer_per_cpu cpu_buffer)
3157	{	3192	{
3158	size_t nr_pages;
3159	size_t dirty;
3160	size_t full;
3161
3162	if (buffer->irq_work.waiters_pending) {	3193	if (buffer->irq_work.waiters_pending) {
3163	buffer->irq_work.waiters_pending = false;	3194	buffer->irq_work.waiters_pending = false;
3164	/* irq_work_queue() supplies it's own memory barriers */	3195	/* irq_work_queue() supplies it's own memory barriers */
@@ -3182,10 +3213,7 @@ rb_wakeups(struct trace_buffer buffer, struct ring_buffer_per_cpu cpu_buffer) · 17 unmodified lines
3182		3213
3183	cpu_buffer->last_pages_touch = local_read(&cpu_buffer->pages_touched);	3214	cpu_buffer->last_pages_touch = local_read(&cpu_buffer->pages_touched);
3184		3215
3185	full = cpu_buffer->shortest_full;	3216	if (!full_hit(buffer, cpu_buffer->cpu, cpu_buffer->shortest_full))
3186	nr_pages = cpu_buffer->nr_pages;
3187	dirty = ring_buffer_nr_dirty_pages(buffer, cpu_buffer->cpu);
3188	if (full && nr_pages && (dirty * 100) <= full * nr_pages)
3189	return;	3217	return;
3190		3218
3191	cpu_buffer->irq_work.wakeup_full = true;	3219	cpu_buffer->irq_work.wakeup_full = true;
@@ -5248,6 +5276,7 @@ rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer) · 2056 unmodified lines
5248	local_set(&cpu_buffer->committing, 0);	5276	local_set(&cpu_buffer->committing, 0);
5249	local_set(&cpu_buffer->commits, 0);	5277	local_set(&cpu_buffer->commits, 0);
5250	local_set(&cpu_buffer->pages_touched, 0);	5278	local_set(&cpu_buffer->pages_touched, 0);
		5279	local_set(&cpu_buffer->pages_lost, 0);
5251	local_set(&cpu_buffer->pages_read, 0);	5280	local_set(&cpu_buffer->pages_read, 0);
5252	cpu_buffer->last_pages_touch = 0;	5281	cpu_buffer->last_pages_touch = 0;
5253	cpu_buffer->shortest_full = 0;	5282	cpu_buffer->shortest_full = 0;

kernel/trace/synth_event_gen_test.c+6−10

 	/* Now generate a gen_synth_test event */
 	ret = synth_event_trace_array(gen_synth_test, vals, ARRAY_SIZE(vals));
- out:
+ free:
+	kfree(buf);
 	return ret;
  delete:
 	/* We got an error after creating the event, delete it */
 	synth_event_delete("gen_synth_test");
- free:
+	goto free;
-	kfree(buf);
-	goto out;
 }
 /*
 	/* Now trace an empty_synth_test event */
 	ret = synth_event_trace_array(empty_synth_test, vals, ARRAY_SIZE(vals));
- out:
+ free:
+	kfree(buf);
 	return ret;
  delete:
 	/* We got an error after creating the event, delete it */
 	synth_event_delete("empty_synth_test");
- free:
+	goto free;
-	kfree(buf);
-	goto out;
 }
 static struct synth_field_desc create_synth_test_fields[] = {

kernel/trace/trace.c+7−5

@@ -6657,6 +6657,7 @@ static int tracing_release_pipe(struct inode inode, struct file file) · 6656 unmodified lines
6657	mutex_unlock(&trace_types_lock);	6657	mutex_unlock(&trace_types_lock);
6658		6658
6659	free_cpumask_var(iter->started);	6659	free_cpumask_var(iter->started);
		6660	kfree(iter->fmt);
6660	mutex_destroy(&iter->mutex);	6661	mutex_destroy(&iter->mutex);
6661	kfree(iter);	6662	kfree(iter);
6662		6663
@@ -6681,7 +6682,7 @@ trace_poll(struct trace_iterator iter, struct file filp, poll_table *poll_tabl · 18 unmodified lines
6681	return EPOLLIN \| EPOLLRDNORM;	6682	return EPOLLIN \| EPOLLRDNORM;
6682	else	6683	else
6683	return ring_buffer_poll_wait(iter->array_buffer->buffer, iter->cpu_file,	6684	return ring_buffer_poll_wait(iter->array_buffer->buffer, iter->cpu_file,
6684	filp, poll_table);	6685	filp, poll_table, iter->tr->buffer_percent);
6685	}	6686	}
6686		6687
6687	static __poll_t	6688	static __poll_t
@@ -7802,6 +7803,7 @@ static struct tracing_log_err get_tracing_log_err(struct trace_array tr, · 1114 unmodified lines
7802	int len)	7803	int len)
7803	{	7804	{
7804	struct tracing_log_err *err;	7805	struct tracing_log_err *err;
		7806	char *cmd;
7805		7807
7806	if (tr->n_err_log_entries < TRACING_LOG_ERRS_MAX) {	7808	if (tr->n_err_log_entries < TRACING_LOG_ERRS_MAX) {
7807	err = alloc_tracing_log_err(len);	7809	err = alloc_tracing_log_err(len);
@@ -7810,12 +7812,12 @@ static struct tracing_log_err get_tracing_log_err(struct trace_array tr, · 2 unmodified lines
7810		7812
7811	return err;	7813	return err;
7812	}	7814	}
7813		7815	cmd = kzalloc(len, GFP_KERNEL);
		7816	if (!cmd)
		7817	return ERR_PTR(-ENOMEM);
7814	err = list_first_entry(&tr->err_log, struct tracing_log_err, list);	7818	err = list_first_entry(&tr->err_log, struct tracing_log_err, list);
7815	kfree(err->cmd);	7819	kfree(err->cmd);
7816	err->cmd = kzalloc(len, GFP_KERNEL);	7820	err->cmd = cmd;
7817	if (!err->cmd)
7818	return ERR_PTR(-ENOMEM);
7819	list_del(&err->list);	7821	list_del(&err->list);
7820		7822
7821	return err;	7823	return err;

kernel/trace/trace_eprobe.c+6−2

 	kfree(ep->event_system);
 	if (ep->event)
 		trace_event_put_ref(ep->event);
+	kfree(ep->filter_str);
 	kfree(ep);
 }
 {
 	struct eprobe_data *edata = data->private_data;
+	if (unlikely(!rec))
+		return;
 	__eprobe_trace_func(edata, rec);
 }
 	INIT_LIST_HEAD(&trigger->list);
 	if (ep->filter_str) {
-		ret = create_event_filter(file->tr, file->event_call,
+		ret = create_event_filter(file->tr, ep->event,
 					ep->filter_str, false, &filter);
 		if (ret)
 			goto error;
 static int trace_eprobe_parse_filter(struct trace_eprobe *ep, int argc, const char *argv[])
 {
-	struct event_filter *dummy;
+	struct event_filter *dummy = NULL;
 	int i, ret, len = 0;
 	char *p;

kernel/trace/trace_events_synth.c+2−3

 	}
 	ret = set_synth_event_print_fmt(call);
-	if (ret < 0) {
+	/* unregister_trace_event() will be called inside */
+	if (ret < 0)
 		trace_remove_event_call(call);
-		goto err;
-	}
  out:
 	return ret;
  err:

kernel/trace/trace_syscalls.c+0−2

@@ -201,8 +201,6 @@ print_syscall_exit(struct trace_iterator *iter, int flags, · 200 unmodified lines
201	return trace_handle_return(s);	201	return trace_handle_return(s);
202	}	202	}
203		203
204	extern char *__bad_type_size(void);
205
206	#define SYSCALL_FIELD(_type, _name) { \	204	#define SYSCALL_FIELD(_type, _name) { \
207	.type = #_type, .name = #_name, \	205	.type = #_type, .name = #_name, \
208	.size = sizeof(_type), .align = __alignof__(_type), \	206	.size = sizeof(_type), .align = __alignof__(_type), \

mm/maccess.c+1−1

@@ -97,7 +97,7 @@ long strncpy_from_kernel_nofault(char dst, const void unsafe_addr, long count) · 96 unmodified lines
97	return src - unsafe_addr;	97	return src - unsafe_addr;
98	Efault:	98	Efault:
99	pagefault_enable();	99	pagefault_enable();
100	dst[-1] = '\0';	100	dst[0] = '\0';
101	return -EFAULT;	101	return -EFAULT;
102	}	102	}
103		103

net/bpf/test_run.c+1−0

@@ -774,6 +774,7 @@ static void bpf_test_init(const union bpf_attr kattr, u32 user_size, · 773 unmodified lines
774	if (user_size > size)	774	if (user_size > size)
775	return ERR_PTR(-EMSGSIZE);	775	return ERR_PTR(-EMSGSIZE);
776		776
		777	size = SKB_DATA_ALIGN(size);
777	data = kzalloc(size + headroom + tailroom, GFP_USER);	778	data = kzalloc(size + headroom + tailroom, GFP_USER);
778	if (!data)	779	if (!data)
779	return ERR_PTR(-ENOMEM);	780	return ERR_PTR(-ENOMEM);

net/bridge/br_vlan.c+14−3

 	list_for_each_entry(p, &br->port_list, list) {
 		vg = nbp_vlan_group(p);
 		list_for_each_entry(vlan, &vg->vlan_list, vlist) {
+			if (vlan->priv_flags & BR_VLFLAG_ADDED_BY_SWITCHDEV)
+				continue;
 			err = vlan_vid_add(p->dev, proto, vlan->vid);
 			if (err)
 				goto err_filt;
 	/* Delete VLANs for the old proto from the device filter. */
 	list_for_each_entry(p, &br->port_list, list) {
 		vg = nbp_vlan_group(p);
-		list_for_each_entry(vlan, &vg->vlan_list, vlist)
+		list_for_each_entry(vlan, &vg->vlan_list, vlist) {
+			if (vlan->priv_flags & BR_VLFLAG_ADDED_BY_SWITCHDEV)
+				continue;
 			vlan_vid_del(p->dev, oldproto, vlan->vid);
+		}
 	}
 	return 0;
 	attr.u.vlan_protocol = ntohs(oldproto);
 	switchdev_port_attr_set(br->dev, &attr, NULL);
-	list_for_each_entry_continue_reverse(vlan, &vg->vlan_list, vlist)
+	list_for_each_entry_continue_reverse(vlan, &vg->vlan_list, vlist) {
+		if (vlan->priv_flags & BR_VLFLAG_ADDED_BY_SWITCHDEV)
+			continue;
 		vlan_vid_del(p->dev, proto, vlan->vid);
+	}
 	list_for_each_entry_continue_reverse(p, &br->port_list, list) {
 		vg = nbp_vlan_group(p);
-		list_for_each_entry(vlan, &vg->vlan_list, vlist)
+		list_for_each_entry(vlan, &vg->vlan_list, vlist) {
+			if (vlan->priv_flags & BR_VLFLAG_ADDED_BY_SWITCHDEV)
+				continue;
 			vlan_vid_del(p->dev, proto, vlan->vid);
+		}
 	}
 	return err;

net/caif/chnl_net.c+0−3

 	if (result == 0) {
 		pr_debug("connect timeout\n");
-		caif_disconnect_client(dev_net(dev), &priv->chnl);
-		priv->state = CAIF_DISCONNECTED;
-		pr_debug("state disconnected\n");
 		result = -ETIMEDOUT;
 		goto error;
 	}

net/dsa/dsa2.c+10−0

 	return err;
 }
+static void dsa_switch_teardown_tag_protocol(struct dsa_switch *ds)
+{
+	const struct dsa_device_ops *tag_ops = ds->dst->tag_ops;
+	if (tag_ops->disconnect)
+		tag_ops->disconnect(ds);
+}
 static int dsa_switch_setup(struct dsa_switch *ds)
 {
 	struct dsa_devlink_priv *dl_priv;
 		ds->slave_mii_bus = NULL;
 	}
+	dsa_switch_teardown_tag_protocol(ds);
 	if (ds->ops->teardown)
 		ds->ops->teardown(ds);

net/dsa/dsa_priv.h+1−0

@@ -210,6 +210,7 @@ static inline struct net_device dsa_master_find_slave(struct net_device dev, · 209 unmodified lines
210	extern struct rtnl_link_ops dsa_link_ops __read_mostly;	210	extern struct rtnl_link_ops dsa_link_ops __read_mostly;
211		211
212	/* port.c */	212	/* port.c */
		213	bool dsa_port_supports_hwtstamp(struct dsa_port dp, struct ifreq ifr);
213	void dsa_port_set_tag_protocol(struct dsa_port *cpu_dp,	214	void dsa_port_set_tag_protocol(struct dsa_port *cpu_dp,
214	const struct dsa_device_ops *tag_ops);	215	const struct dsa_device_ops *tag_ops);
215	int dsa_port_set_state(struct dsa_port *dp, u8 state, bool do_fast_age);	216	int dsa_port_set_state(struct dsa_port *dp, u8 state, bool do_fast_age);

net/dsa/master.c+1−2

 		 * switch in the tree that is PTP capable.
 		 */
 		list_for_each_entry(dp, &dst->ports, list)
-			if (dp->ds->ops->port_hwtstamp_get ||
+			if (dsa_port_supports_hwtstamp(dp, ifr))
-			    dp->ds->ops->port_hwtstamp_set)
 				return -EBUSY;
 		break;
 	}

net/dsa/port.c+16−0

@@ -110,6 +110,22 @@ static bool dsa_port_can_configure_learning(struct dsa_port *dp) · 109 unmodified lines
110	return !err;	110	return !err;
111	}	111	}
112		112
		113	bool dsa_port_supports_hwtstamp(struct dsa_port dp, struct ifreq ifr)
		114	{
		115	struct dsa_switch *ds = dp->ds;
		116	int err;
		117
		118	if (!ds->ops->port_hwtstamp_get \|\| !ds->ops->port_hwtstamp_set)
		119	return false;
		120
		121	/* "See through" shim implementations of the "get" method.
		122	* This will clobber the ifreq structure, but we will either return an
		123	* error, or the master will overwrite it with proper values.
		124	*/
		125	err = ds->ops->port_hwtstamp_get(ds, dp->index, ifr);
		126	return err != -EOPNOTSUPP;
		127	}
		128
113	int dsa_port_set_state(struct dsa_port *dp, u8 state, bool do_fast_age)	129	int dsa_port_set_state(struct dsa_port *dp, u8 state, bool do_fast_age)
114	{	130	{
115	struct dsa_switch *ds = dp->ds;	131	struct dsa_switch *ds = dp->ds;

net/ipv4/Kconfig+10−0

@@ -402,6 +402,16 @@ config INET_IPCOMP · 401 unmodified lines
402		402
403	If unsure, say Y.	403	If unsure, say Y.
404		404
		405	config INET_TABLE_PERTURB_ORDER
		406	int "INET: Source port perturbation table size (as power of 2)" if EXPERT
		407	default 16
		408	help
		409	Source port perturbation table size (as power of 2) for
		410	RFC 6056 3.3.4. Algorithm 4: Double-Hash Port Selection Algorithm.
		411
		412	The default is almost always what you want.
		413	Only change this if you know what you are doing.
		414
405	config INET_XFRM_TUNNEL	415	config INET_XFRM_TUNNEL
406	tristate	416	tristate
407	select INET_TUNNEL	417	select INET_TUNNEL

net/ipv4/inet_hashtables.c+5−5

  * Note that we use 32bit integers (vs RFC 'short integers')
  * because 2^16 is not a multiple of num_ephemeral and this
  * property might be used by clever attacker.
+ *
  * RFC claims using TABLE_LENGTH=10 buckets gives an improvement, though
- * attacks were since demonstrated, thus we use 65536 instead to really
+ * attacks were since demonstrated, thus we use 65536 by default instead
- * give more isolation and privacy, at the expense of 256kB of kernel
+ * to really give more isolation and privacy, at the expense of 256kB
- * memory.
+ * of kernel memory.
  */
-#define INET_TABLE_PERTURB_SHIFT 16
+#define INET_TABLE_PERTURB_SIZE (1 << CONFIG_INET_TABLE_PERTURB_ORDER)
-#define INET_TABLE_PERTURB_SIZE (1 << INET_TABLE_PERTURB_SHIFT)
 static u32 *table_perturb;
 int __inet_hash_connect(struct inet_timewait_death_row *death_row,

net/kcm/kcmsock.c+6−52

 	struct sk_buff *skb;
 	struct kcm_sock *kcm;
-	while ((skb = __skb_dequeue(head))) {
+	while ((skb = skb_dequeue(head))) {
 		/* Reset destructor to avoid calling kcm_rcv_ready */
 		skb->destructor = sock_rfree;
 		skb_orphan(skb);
 	return err;
 }
-static struct sk_buff *kcm_wait_data(struct sock *sk, int flags,
-				     long timeo, int *err)
-{
-	struct sk_buff *skb;
-	while (!(skb = skb_peek(&sk->sk_receive_queue))) {
-		if (sk->sk_err) {
-			*err = sock_error(sk);
-			return NULL;
-		}
-		if (sock_flag(sk, SOCK_DONE))
-			return NULL;
-		if ((flags & MSG_DONTWAIT) || !timeo) {
-			*err = -EAGAIN;
-			return NULL;
-		}
-		sk_wait_data(sk, &timeo, NULL);
-		/* Handle signals */
-		if (signal_pending(current)) {
-			*err = sock_intr_errno(timeo);
-			return NULL;
-		}
-	}
-	return skb;
-}
 static int kcm_recvmsg(struct socket *sock, struct msghdr *msg,
 		       size_t len, int flags)
 {
 	struct sock *sk = sock->sk;
 	struct kcm_sock *kcm = kcm_sk(sk);
 	int err = 0;
-	long timeo;
 	struct strp_msg *stm;
 	int copied = 0;
 	struct sk_buff *skb;
-	timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
+	skb = skb_recv_datagram(sk, flags, &err);
-	lock_sock(sk);
-	skb = kcm_wait_data(sk, flags, timeo, &err);
 	if (!skb)
 		goto out;
 			/* Finished with message */
 			msg->msg_flags |= MSG_EOR;
 			KCM_STATS_INCR(kcm->stats.rx_msgs);
-			skb_unlink(skb, &sk->sk_receive_queue);
-			kfree_skb(skb);
 		}
 	}
 out:
-	release_sock(sk);
+	skb_free_datagram(sk, skb);
 	return copied ? : err;
 }
 {
 	struct sock *sk = sock->sk;
 	struct kcm_sock *kcm = kcm_sk(sk);
-	long timeo;
 	struct strp_msg *stm;
 	int err = 0;
 	ssize_t copied;
 	/* Only support splice for SOCKSEQPACKET */
-	timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
+	skb = skb_recv_datagram(sk, flags, &err);
-	lock_sock(sk);
-	skb = kcm_wait_data(sk, flags, timeo, &err);
 	if (!skb)
 		goto err_out;
 	 * finish reading the message.
 	 */
-	release_sock(sk);
+	skb_free_datagram(sk, skb);
 	return copied;
 err_out:
-	release_sock(sk);
+	skb_free_datagram(sk, skb);
 	return err;
 }

net/l2tp/l2tp_core.c+13−6

 	}
 	/* Remove hooks into tunnel socket */
+	write_lock_bh(&sk->sk_callback_lock);
 	sk->sk_destruct = tunnel->old_sk_destruct;
 	sk->sk_user_data = NULL;
+	write_unlock_bh(&sk->sk_callback_lock);
 	/* Call the original destructor */
 	if (sk->sk_destruct)
 		sock = sockfd_lookup(tunnel->fd, &ret);
 		if (!sock)
 			goto err;
-		ret = l2tp_validate_socket(sock->sk, net, tunnel->encap);
-		if (ret < 0)
-			goto err_sock;
 	}
+	sk = sock->sk;
+	write_lock(&sk->sk_callback_lock);
+	ret = l2tp_validate_socket(sk, net, tunnel->encap);
+	if (ret < 0)
+		goto err_sock;
 	tunnel->l2tp_net = net;
 	pn = l2tp_pernet(net);
-	sk = sock->sk;
 	sock_hold(sk);
 	tunnel->sock = sk;
 		setup_udp_tunnel_sock(net, sock, &udp_cfg);
 	} else {
-		sk->sk_user_data = tunnel;
+		rcu_assign_sk_user_data(sk, tunnel);
 	}
 	tunnel->old_sk_destruct = sk->sk_destruct;
 	if (tunnel->fd >= 0)
 		sockfd_put(sock);
+	write_unlock(&sk->sk_callback_lock);
 	return 0;
 err_sock:
 		sock_release(sock);
 	else
 		sockfd_put(sock);
+	write_unlock(&sk->sk_callback_lock);
 err:
 	return ret;
 }

net/tls/tls_device_fallback.c+3−2

 		salt = tls_ctx->crypto_send.aes_gcm_256.salt;
 		break;
 	default:
-		return NULL;
+		goto free_req;
 	}
 	cipher_sz = &tls_cipher_size_desc[tls_ctx->crypto_send.info.cipher_type];
 	buf_len = cipher_sz->salt + cipher_sz->iv + TLS_AAD_SPACE_SIZE +
 		key = ((struct tls12_crypto_info_aes_gcm_256 *)crypto_info)->key;
 		break;
 	default:
-		return -EINVAL;
+		rc = -EINVAL;
+		goto free_aead;
 	}
 	cipher_sz = &tls_cipher_size_desc[crypto_info->cipher_type];

net/x25/x25_dev.c+1−1

@@ -117,7 +117,7 @@ int x25_lapb_receive_frame(struct sk_buff skb, struct net_device dev, · 116 unmodified lines
117		117
118	if (!pskb_may_pull(skb, 1)) {	118	if (!pskb_may_pull(skb, 1)) {
119	x25_neigh_put(nb);	119	x25_neigh_put(nb);
120	return 0;	120	goto drop;
121	}	121	}
122		122
123	switch (skb->data[0]) {	123	switch (skb->data[0]) {

scripts/package/mkdebian+1−1

@@ -90,7 +90,7 @@ if [ -n "$KDEB_PKGVERSION" ]; then · 89 unmodified lines
90	packageversion=$KDEB_PKGVERSION	90	packageversion=$KDEB_PKGVERSION
91	revision=${packageversion##*-}	91	revision=${packageversion##*-}
92	else	92	else
93	revision=$(cat .version 2>/dev/null\|\|echo 1)	93	revision=$($srctree/init/build-version)
94	packageversion=$version-$revision	94	packageversion=$version-$revision
95	fi	95	fi
96	sourcename=$KDEB_SOURCENAME	96	sourcename=$KDEB_SOURCENAME

sound/pci/hda/patch_realtek.c+2−0

 	SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_AMP),
 	SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_AMP),
 	SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
+	SND_PCI_QUIRK(0x144d, 0xc1a3, "Samsung Galaxy Book Pro (NP935XDB-KC1SE)", ALC298_FIXUP_SAMSUNG_AMP),
+	SND_PCI_QUIRK(0x144d, 0xc1a6, "Samsung Galaxy Book Pro 360 (NP930QBD)", ALC298_FIXUP_SAMSUNG_AMP),
 	SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
 	SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_AMP),
 	SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_AMP),

sound/soc/codecs/hdmi-codec.c+25−5

@@ -816,12 +816,19 @@ static int hdmi_dai_probe(struct snd_soc_dai *dai) · 815 unmodified lines
816	.source = "RX",	816	.source = "RX",
817	},	817	},
818	};	818	};
819	int ret;	819	int ret, i;
820		820
821	dapm = snd_soc_component_get_dapm(dai->component);	821	dapm = snd_soc_component_get_dapm(dai->component);
822	ret = snd_soc_dapm_add_routes(dapm, route, 2);	822
823	if (ret)	823	/* One of the directions might be omitted for unidirectional DAIs */
824	return ret;	824	for (i = 0; i < ARRAY_SIZE(route); i++) {
		825	if (!route[i].source \|\| !route[i].sink)
		826	continue;
		827
		828	ret = snd_soc_dapm_add_routes(dapm, &route[i], 1);
		829	if (ret)
		830	return ret;
		831	}
825		832
826	daifmt = devm_kzalloc(dai->dev, sizeof(*daifmt), GFP_KERNEL);	833	daifmt = devm_kzalloc(dai->dev, sizeof(*daifmt), GFP_KERNEL);
827	if (!daifmt)	834	if (!daifmt)
@@ -1009,11 +1016,24 @@ static int hdmi_codec_probe(struct platform_device *pdev) · 181 unmodified lines
1009	if (hcd->i2s) {	1016	if (hcd->i2s) {
1010	daidrv[i] = hdmi_i2s_dai;	1017	daidrv[i] = hdmi_i2s_dai;
1011	daidrv[i].playback.channels_max = hcd->max_i2s_channels;	1018	daidrv[i].playback.channels_max = hcd->max_i2s_channels;
		1019	if (hcd->no_i2s_playback)
		1020	memset(&daidrv[i].playback, 0,
		1021	sizeof(daidrv[i].playback));
		1022	if (hcd->no_i2s_capture)
		1023	memset(&daidrv[i].capture, 0,
		1024	sizeof(daidrv[i].capture));
1012	i++;	1025	i++;
1013	}	1026	}
1014		1027
1015	if (hcd->spdif)	1028	if (hcd->spdif) {
1016	daidrv[i] = hdmi_spdif_dai;	1029	daidrv[i] = hdmi_spdif_dai;
		1030	if (hcd->no_spdif_playback)
		1031	memset(&daidrv[i].playback, 0,
		1032	sizeof(daidrv[i].playback));
		1033	if (hcd->no_spdif_capture)
		1034	memset(&daidrv[i].capture, 0,
		1035	sizeof(daidrv[i].capture));
		1036	}
1017		1037
1018	dev_set_drvdata(dev, hcp);	1038	dev_set_drvdata(dev, hcp);
1019		1039

sound/usb/midi.c+1−3

 					port = &umidi->endpoints[i].out->ports[j];
 					break;
 				}
-	if (!port) {
+	if (!port)
-		snd_BUG();
 		return -ENXIO;
-	}
 	substream->runtime->private_data = port;
 	port->state = STATE_UNKNOWN;

tools/arch/x86/include/asm/msr-index.h+5−3

 #define MSR_AMD64_CPUID_FN_1		0xc0011004
 #define MSR_AMD64_LS_CFG		0xc0011020
 #define MSR_AMD64_DC_CFG		0xc0011022
+#define MSR_AMD64_DE_CFG		0xc0011029
+#define MSR_AMD64_DE_CFG_LFENCE_SERIALIZE_BIT	1
+#define MSR_AMD64_DE_CFG_LFENCE_SERIALIZE	BIT_ULL(MSR_AMD64_DE_CFG_LFENCE_SERIALIZE_BIT)
 #define MSR_AMD64_BU_CFG2		0xc001102a
 #define MSR_AMD64_IBSFETCHCTL		0xc0011030
 #define MSR_AMD64_IBSFETCHLINAD		0xc0011031
 #define FAM10H_MMIO_CONF_BASE_MASK	0xfffffffULL
 #define FAM10H_MMIO_CONF_BASE_SHIFT	20
 #define MSR_FAM10H_NODE_ID		0xc001100c
-#define MSR_F10H_DECFG			0xc0011029
-#define MSR_F10H_DECFG_LFENCE_SERIALIZE_BIT	1
-#define MSR_F10H_DECFG_LFENCE_SERIALIZE		BIT_ULL(MSR_F10H_DECFG_LFENCE_SERIALIZE_BIT)
 /* K8 MSRs */
 #define MSR_K8_TOP_MEM1			0xc001001a

tools/iio/iio_generic_buffer.c+2−2

 				continue;
 			}
-			toread = buf_len;
 		} else {
 			usleep(timedelay);
-			toread = 64;
 		}
+		toread = buf_len;
 		read_size = read(buf_fd, data, toread * scan_size);
 		if (read_size < 0) {
 			if (errno == EAGAIN) {

tools/testing/selftests/bpf/prog_tests/varlen.c+7−0

@@ -63,6 +63,13 @@ void test_varlen(void) · 62 unmodified lines
63	CHECK_VAL(data->total4, size1 + size2);	63	CHECK_VAL(data->total4, size1 + size2);
64	CHECK(memcmp(data->payload4, exp_str, size1 + size2), "content_check",	64	CHECK(memcmp(data->payload4, exp_str, size1 + size2), "content_check",
65	"doesn't match!\n");	65	"doesn't match!\n");
		66
		67	CHECK_VAL(bss->ret_bad_read, -EFAULT);
		68	CHECK_VAL(data->payload_bad[0], 0x42);
		69	CHECK_VAL(data->payload_bad[1], 0x42);
		70	CHECK_VAL(data->payload_bad[2], 0);
		71	CHECK_VAL(data->payload_bad[3], 0x42);
		72	CHECK_VAL(data->payload_bad[4], 0x42);
66	cleanup:	73	cleanup:
67	test_varlen__destroy(skel);	74	test_varlen__destroy(skel);
68	}	75	}

tools/testing/selftests/bpf/progs/test_varlen.c+5−0

 __u64 payload1_len2 = 0;
 __u64 total1 = 0;
 char payload1[MAX_LEN + MAX_LEN] = {};
+__u64 ret_bad_read = 0;
 /* .data */
 int payload2_len1 = -1;
 int total4= -1;
 char payload4[MAX_LEN + MAX_LEN] = { 1 };
+char payload_bad[5] = { 0x42, 0x42, 0x42, 0x42, 0x42 };
 SEC("raw_tp/sys_enter")
 int handler64_unsigned(void *regs)
 {
 	total1 = payload - (void *)payload1;
+	ret_bad_read = bpf_probe_read_kernel_str(payload_bad + 2, 1, (void *) -1);
 	return 0;
 }

tools/testing/selftests/bpf/test_progs.c+1−1

@@ -1010,7 +1010,7 @@ static inline const char str_msg(const struct msg msg, char *buf) · 1009 unmodified lines
1010	msg->subtest_done.have_log);	1010	msg->subtest_done.have_log);
1011	break;	1011	break;
1012	case MSG_TEST_LOG:	1012	case MSG_TEST_LOG:
1013	sprintf(buf, "MSG_TEST_LOG (cnt: %ld, last: %d)",	1013	sprintf(buf, "MSG_TEST_LOG (cnt: %zu, last: %d)",
1014	strlen(msg->test_log.log_buf),	1014	strlen(msg->test_log.log_buf),
1015	msg->test_log.is_last);	1015	msg->test_log.is_last);
1016	break;	1016	break;

tools/testing/selftests/bpf/test_verifier.c+1−1

@@ -1260,7 +1260,7 @@ static int get_xlated_program(int fd_prog, struct bpf_insn *buf, int cnt) · 1259 unmodified lines
1260		1260
1261	bzero(&info, sizeof(info));	1261	bzero(&info, sizeof(info));
1262	info.xlated_prog_len = xlated_prog_len;	1262	info.xlated_prog_len = xlated_prog_len;
1263	info.xlated_prog_insns = (__u64)*buf;	1263	info.xlated_prog_insns = (__u64)(unsigned long)*buf;
1264	if (bpf_obj_get_info_by_fd(fd_prog, &info, &info_len)) {	1264	if (bpf_obj_get_info_by_fd(fd_prog, &info, &info_len)) {
1265	perror("second bpf_obj_get_info_by_fd failed");	1265	perror("second bpf_obj_get_info_by_fd failed");
1266	goto out_free_buf;	1266	goto out_free_buf;

@@ -105,26 +105,28 @@ static const struct pci_device_id hns3_pci_tbl[] = { · 104 unmodified lines
105	};	105	};
106	MODULE_DEVICE_TABLE(pci, hns3_pci_tbl);	106	MODULE_DEVICE_TABLE(pci, hns3_pci_tbl);
107		107
108	#define HNS3_RX_PTYPE_ENTRY(ptype, l, s, t) \	108	#define HNS3_RX_PTYPE_ENTRY(ptype, l, s, t, h) \
109	{ ptype, \	109	{ ptype, \
110	l, \	110	l, \
111	CHECKSUM_##s, \	111	CHECKSUM_##s, \
112	HNS3_L3_TYPE_##t, \	112	HNS3_L3_TYPE_##t, \
113	1 }	113	1, \
		114	h}
114		115
115	#define HNS3_RX_PTYPE_UNUSED_ENTRY(ptype) \	116	#define HNS3_RX_PTYPE_UNUSED_ENTRY(ptype) \
116	{ ptype, 0, CHECKSUM_NONE, HNS3_L3_TYPE_PARSE_FAIL, 0 }	117	{ ptype, 0, CHECKSUM_NONE, HNS3_L3_TYPE_PARSE_FAIL, 0, \
		118	PKT_HASH_TYPE_NONE }
117		119
118	static const struct hns3_rx_ptype hns3_rx_ptype_tbl[] = {	120	static const struct hns3_rx_ptype hns3_rx_ptype_tbl[] = {
119	HNS3_RX_PTYPE_UNUSED_ENTRY(0),	121	HNS3_RX_PTYPE_UNUSED_ENTRY(0),
120	HNS3_RX_PTYPE_ENTRY(1, 0, COMPLETE, ARP),	122	HNS3_RX_PTYPE_ENTRY(1, 0, COMPLETE, ARP, PKT_HASH_TYPE_NONE),
121	HNS3_RX_PTYPE_ENTRY(2, 0, COMPLETE, RARP),	123	HNS3_RX_PTYPE_ENTRY(2, 0, COMPLETE, RARP, PKT_HASH_TYPE_NONE),
122	HNS3_RX_PTYPE_ENTRY(3, 0, COMPLETE, LLDP),	124	HNS3_RX_PTYPE_ENTRY(3, 0, COMPLETE, LLDP, PKT_HASH_TYPE_NONE),
123	HNS3_RX_PTYPE_ENTRY(4, 0, COMPLETE, PARSE_FAIL),	125	HNS3_RX_PTYPE_ENTRY(4, 0, COMPLETE, PARSE_FAIL, PKT_HASH_TYPE_NONE),
124	HNS3_RX_PTYPE_ENTRY(5, 0, COMPLETE, PARSE_FAIL),	126	HNS3_RX_PTYPE_ENTRY(5, 0, COMPLETE, PARSE_FAIL, PKT_HASH_TYPE_NONE),
125	HNS3_RX_PTYPE_ENTRY(6, 0, COMPLETE, PARSE_FAIL),	127	HNS3_RX_PTYPE_ENTRY(6, 0, COMPLETE, PARSE_FAIL, PKT_HASH_TYPE_NONE),
126	HNS3_RX_PTYPE_ENTRY(7, 0, COMPLETE, CNM),	128	HNS3_RX_PTYPE_ENTRY(7, 0, COMPLETE, CNM, PKT_HASH_TYPE_NONE),
127	HNS3_RX_PTYPE_ENTRY(8, 0, NONE, PARSE_FAIL),	129	HNS3_RX_PTYPE_ENTRY(8, 0, NONE, PARSE_FAIL, PKT_HASH_TYPE_NONE),
128	HNS3_RX_PTYPE_UNUSED_ENTRY(9),	130	HNS3_RX_PTYPE_UNUSED_ENTRY(9),
129	HNS3_RX_PTYPE_UNUSED_ENTRY(10),	131	HNS3_RX_PTYPE_UNUSED_ENTRY(10),
130	HNS3_RX_PTYPE_UNUSED_ENTRY(11),	132	HNS3_RX_PTYPE_UNUSED_ENTRY(11),
@@ -132,36 +134,36 @@ static const struct hns3_rx_ptype hns3_rx_ptype_tbl[] = { · 1 unmodified line
132	HNS3_RX_PTYPE_UNUSED_ENTRY(13),	134	HNS3_RX_PTYPE_UNUSED_ENTRY(13),
133	HNS3_RX_PTYPE_UNUSED_ENTRY(14),	135	HNS3_RX_PTYPE_UNUSED_ENTRY(14),
134	HNS3_RX_PTYPE_UNUSED_ENTRY(15),	136	HNS3_RX_PTYPE_UNUSED_ENTRY(15),
135	HNS3_RX_PTYPE_ENTRY(16, 0, COMPLETE, PARSE_FAIL),	137	HNS3_RX_PTYPE_ENTRY(16, 0, COMPLETE, PARSE_FAIL, PKT_HASH_TYPE_NONE),
136	HNS3_RX_PTYPE_ENTRY(17, 0, COMPLETE, IPV4),	138	HNS3_RX_PTYPE_ENTRY(17, 0, COMPLETE, IPV4, PKT_HASH_TYPE_NONE),
137	HNS3_RX_PTYPE_ENTRY(18, 0, COMPLETE, IPV4),	139	HNS3_RX_PTYPE_ENTRY(18, 0, COMPLETE, IPV4, PKT_HASH_TYPE_NONE),
138	HNS3_RX_PTYPE_ENTRY(19, 0, UNNECESSARY, IPV4),	140	HNS3_RX_PTYPE_ENTRY(19, 0, UNNECESSARY, IPV4, PKT_HASH_TYPE_L4),
139	HNS3_RX_PTYPE_ENTRY(20, 0, UNNECESSARY, IPV4),	141	HNS3_RX_PTYPE_ENTRY(20, 0, UNNECESSARY, IPV4, PKT_HASH_TYPE_L4),
140	HNS3_RX_PTYPE_ENTRY(21, 0, NONE, IPV4),	142	HNS3_RX_PTYPE_ENTRY(21, 0, NONE, IPV4, PKT_HASH_TYPE_NONE),
141	HNS3_RX_PTYPE_ENTRY(22, 0, UNNECESSARY, IPV4),	143	HNS3_RX_PTYPE_ENTRY(22, 0, UNNECESSARY, IPV4, PKT_HASH_TYPE_L4),
142	HNS3_RX_PTYPE_ENTRY(23, 0, NONE, IPV4),	144	HNS3_RX_PTYPE_ENTRY(23, 0, NONE, IPV4, PKT_HASH_TYPE_L3),
143	HNS3_RX_PTYPE_ENTRY(24, 0, NONE, IPV4),	145	HNS3_RX_PTYPE_ENTRY(24, 0, NONE, IPV4, PKT_HASH_TYPE_L3),
144	HNS3_RX_PTYPE_ENTRY(25, 0, UNNECESSARY, IPV4),	146	HNS3_RX_PTYPE_ENTRY(25, 0, UNNECESSARY, IPV4, PKT_HASH_TYPE_L4),
145	HNS3_RX_PTYPE_UNUSED_ENTRY(26),	147	HNS3_RX_PTYPE_UNUSED_ENTRY(26),
146	HNS3_RX_PTYPE_UNUSED_ENTRY(27),	148	HNS3_RX_PTYPE_UNUSED_ENTRY(27),
147	HNS3_RX_PTYPE_UNUSED_ENTRY(28),	149	HNS3_RX_PTYPE_UNUSED_ENTRY(28),
148	HNS3_RX_PTYPE_ENTRY(29, 0, COMPLETE, PARSE_FAIL),	150	HNS3_RX_PTYPE_ENTRY(29, 0, COMPLETE, PARSE_FAIL, PKT_HASH_TYPE_NONE),
149	HNS3_RX_PTYPE_ENTRY(30, 0, COMPLETE, PARSE_FAIL),	151	HNS3_RX_PTYPE_ENTRY(30, 0, COMPLETE, PARSE_FAIL, PKT_HASH_TYPE_NONE),
150	HNS3_RX_PTYPE_ENTRY(31, 0, COMPLETE, IPV4),	152	HNS3_RX_PTYPE_ENTRY(31, 0, COMPLETE, IPV4, PKT_HASH_TYPE_L3),
151	HNS3_RX_PTYPE_ENTRY(32, 0, COMPLETE, IPV4),	153	HNS3_RX_PTYPE_ENTRY(32, 0, COMPLETE, IPV4, PKT_HASH_TYPE_L3),
152	HNS3_RX_PTYPE_ENTRY(33, 1, UNNECESSARY, IPV4),	154	HNS3_RX_PTYPE_ENTRY(33, 1, UNNECESSARY, IPV4, PKT_HASH_TYPE_L4),
153	HNS3_RX_PTYPE_ENTRY(34, 1, UNNECESSARY, IPV4),	155	HNS3_RX_PTYPE_ENTRY(34, 1, UNNECESSARY, IPV4, PKT_HASH_TYPE_L4),
154	HNS3_RX_PTYPE_ENTRY(35, 1, UNNECESSARY, IPV4),	156	HNS3_RX_PTYPE_ENTRY(35, 1, UNNECESSARY, IPV4, PKT_HASH_TYPE_L4),
155	HNS3_RX_PTYPE_ENTRY(36, 0, COMPLETE, IPV4),	157	HNS3_RX_PTYPE_ENTRY(36, 0, COMPLETE, IPV4, PKT_HASH_TYPE_L3),
156	HNS3_RX_PTYPE_ENTRY(37, 0, COMPLETE, IPV4),	158	HNS3_RX_PTYPE_ENTRY(37, 0, COMPLETE, IPV4, PKT_HASH_TYPE_L3),
157	HNS3_RX_PTYPE_UNUSED_ENTRY(38),	159	HNS3_RX_PTYPE_UNUSED_ENTRY(38),
158	HNS3_RX_PTYPE_ENTRY(39, 0, COMPLETE, IPV6),	160	HNS3_RX_PTYPE_ENTRY(39, 0, COMPLETE, IPV6, PKT_HASH_TYPE_L3),
159	HNS3_RX_PTYPE_ENTRY(40, 0, COMPLETE, IPV6),	161	HNS3_RX_PTYPE_ENTRY(40, 0, COMPLETE, IPV6, PKT_HASH_TYPE_L3),
160	HNS3_RX_PTYPE_ENTRY(41, 1, UNNECESSARY, IPV6),	162	HNS3_RX_PTYPE_ENTRY(41, 1, UNNECESSARY, IPV6, PKT_HASH_TYPE_L4),
161	HNS3_RX_PTYPE_ENTRY(42, 1, UNNECESSARY, IPV6),	163	HNS3_RX_PTYPE_ENTRY(42, 1, UNNECESSARY, IPV6, PKT_HASH_TYPE_L4),
162	HNS3_RX_PTYPE_ENTRY(43, 1, UNNECESSARY, IPV6),	164	HNS3_RX_PTYPE_ENTRY(43, 1, UNNECESSARY, IPV6, PKT_HASH_TYPE_L4),
163	HNS3_RX_PTYPE_ENTRY(44, 0, COMPLETE, IPV6),	165	HNS3_RX_PTYPE_ENTRY(44, 0, COMPLETE, IPV6, PKT_HASH_TYPE_L3),
164	HNS3_RX_PTYPE_ENTRY(45, 0, COMPLETE, IPV6),	166	HNS3_RX_PTYPE_ENTRY(45, 0, COMPLETE, IPV6, PKT_HASH_TYPE_L3),
165	HNS3_RX_PTYPE_UNUSED_ENTRY(46),	167	HNS3_RX_PTYPE_UNUSED_ENTRY(46),
166	HNS3_RX_PTYPE_UNUSED_ENTRY(47),	168	HNS3_RX_PTYPE_UNUSED_ENTRY(47),
167	HNS3_RX_PTYPE_UNUSED_ENTRY(48),	169	HNS3_RX_PTYPE_UNUSED_ENTRY(48),
@@ -227,35 +229,35 @@ static const struct hns3_rx_ptype hns3_rx_ptype_tbl[] = { · 59 unmodified lines
227	HNS3_RX_PTYPE_UNUSED_ENTRY(108),	229	HNS3_RX_PTYPE_UNUSED_ENTRY(108),
228	HNS3_RX_PTYPE_UNUSED_ENTRY(109),	230	HNS3_RX_PTYPE_UNUSED_ENTRY(109),
229	HNS3_RX_PTYPE_UNUSED_ENTRY(110),	231	HNS3_RX_PTYPE_UNUSED_ENTRY(110),
230	HNS3_RX_PTYPE_ENTRY(111, 0, COMPLETE, IPV6),	232	HNS3_RX_PTYPE_ENTRY(111, 0, COMPLETE, IPV6, PKT_HASH_TYPE_L3),
231	HNS3_RX_PTYPE_ENTRY(112, 0, COMPLETE, IPV6),	233	HNS3_RX_PTYPE_ENTRY(112, 0, COMPLETE, IPV6, PKT_HASH_TYPE_L3),
232	HNS3_RX_PTYPE_ENTRY(113, 0, UNNECESSARY, IPV6),	234	HNS3_RX_PTYPE_ENTRY(113, 0, UNNECESSARY, IPV6, PKT_HASH_TYPE_L4),
233	HNS3_RX_PTYPE_ENTRY(114, 0, UNNECESSARY, IPV6),	235	HNS3_RX_PTYPE_ENTRY(114, 0, UNNECESSARY, IPV6, PKT_HASH_TYPE_L4),
234	HNS3_RX_PTYPE_ENTRY(115, 0, NONE, IPV6),	236	HNS3_RX_PTYPE_ENTRY(115, 0, NONE, IPV6, PKT_HASH_TYPE_L3),
235	HNS3_RX_PTYPE_ENTRY(116, 0, UNNECESSARY, IPV6),	237	HNS3_RX_PTYPE_ENTRY(116, 0, UNNECESSARY, IPV6, PKT_HASH_TYPE_L4),
236	HNS3_RX_PTYPE_ENTRY(117, 0, NONE, IPV6),	238	HNS3_RX_PTYPE_ENTRY(117, 0, NONE, IPV6, PKT_HASH_TYPE_L3),
237	HNS3_RX_PTYPE_ENTRY(118, 0, NONE, IPV6),	239	HNS3_RX_PTYPE_ENTRY(118, 0, NONE, IPV6, PKT_HASH_TYPE_L3),
238	HNS3_RX_PTYPE_ENTRY(119, 0, UNNECESSARY, IPV6),	240	HNS3_RX_PTYPE_ENTRY(119, 0, UNNECESSARY, IPV6, PKT_HASH_TYPE_L4),
239	HNS3_RX_PTYPE_UNUSED_ENTRY(120),	241	HNS3_RX_PTYPE_UNUSED_ENTRY(120),
240	HNS3_RX_PTYPE_UNUSED_ENTRY(121),	242	HNS3_RX_PTYPE_UNUSED_ENTRY(121),
241	HNS3_RX_PTYPE_UNUSED_ENTRY(122),	243	HNS3_RX_PTYPE_UNUSED_ENTRY(122),
242	HNS3_RX_PTYPE_ENTRY(123, 0, COMPLETE, PARSE_FAIL),	244	HNS3_RX_PTYPE_ENTRY(123, 0, COMPLETE, PARSE_FAIL, PKT_HASH_TYPE_NONE),
243	HNS3_RX_PTYPE_ENTRY(124, 0, COMPLETE, PARSE_FAIL),	245	HNS3_RX_PTYPE_ENTRY(124, 0, COMPLETE, PARSE_FAIL, PKT_HASH_TYPE_NONE),
244	HNS3_RX_PTYPE_ENTRY(125, 0, COMPLETE, IPV4),	246	HNS3_RX_PTYPE_ENTRY(125, 0, COMPLETE, IPV4, PKT_HASH_TYPE_L3),
245	HNS3_RX_PTYPE_ENTRY(126, 0, COMPLETE, IPV4),	247	HNS3_RX_PTYPE_ENTRY(126, 0, COMPLETE, IPV4, PKT_HASH_TYPE_L3),
246	HNS3_RX_PTYPE_ENTRY(127, 1, UNNECESSARY, IPV4),	248	HNS3_RX_PTYPE_ENTRY(127, 1, UNNECESSARY, IPV4, PKT_HASH_TYPE_L4),
247	HNS3_RX_PTYPE_ENTRY(128, 1, UNNECESSARY, IPV4),	249	HNS3_RX_PTYPE_ENTRY(128, 1, UNNECESSARY, IPV4, PKT_HASH_TYPE_L4),
248	HNS3_RX_PTYPE_ENTRY(129, 1, UNNECESSARY, IPV4),	250	HNS3_RX_PTYPE_ENTRY(129, 1, UNNECESSARY, IPV4, PKT_HASH_TYPE_L4),
249	HNS3_RX_PTYPE_ENTRY(130, 0, COMPLETE, IPV4),	251	HNS3_RX_PTYPE_ENTRY(130, 0, COMPLETE, IPV4, PKT_HASH_TYPE_L3),
250	HNS3_RX_PTYPE_ENTRY(131, 0, COMPLETE, IPV4),	252	HNS3_RX_PTYPE_ENTRY(131, 0, COMPLETE, IPV4, PKT_HASH_TYPE_L3),
251	HNS3_RX_PTYPE_UNUSED_ENTRY(132),	253	HNS3_RX_PTYPE_UNUSED_ENTRY(132),
252	HNS3_RX_PTYPE_ENTRY(133, 0, COMPLETE, IPV6),	254	HNS3_RX_PTYPE_ENTRY(133, 0, COMPLETE, IPV6, PKT_HASH_TYPE_L3),
253	HNS3_RX_PTYPE_ENTRY(134, 0, COMPLETE, IPV6),	255	HNS3_RX_PTYPE_ENTRY(134, 0, COMPLETE, IPV6, PKT_HASH_TYPE_L3),
254	HNS3_RX_PTYPE_ENTRY(135, 1, UNNECESSARY, IPV6),	256	HNS3_RX_PTYPE_ENTRY(135, 1, UNNECESSARY, IPV6, PKT_HASH_TYPE_L4),
255	HNS3_RX_PTYPE_ENTRY(136, 1, UNNECESSARY, IPV6),	257	HNS3_RX_PTYPE_ENTRY(136, 1, UNNECESSARY, IPV6, PKT_HASH_TYPE_L4),
256	HNS3_RX_PTYPE_ENTRY(137, 1, UNNECESSARY, IPV6),	258	HNS3_RX_PTYPE_ENTRY(137, 1, UNNECESSARY, IPV6, PKT_HASH_TYPE_L4),
257	HNS3_RX_PTYPE_ENTRY(138, 0, COMPLETE, IPV6),	259	HNS3_RX_PTYPE_ENTRY(138, 0, COMPLETE, IPV6, PKT_HASH_TYPE_L3),
258	HNS3_RX_PTYPE_ENTRY(139, 0, COMPLETE, IPV6),	260	HNS3_RX_PTYPE_ENTRY(139, 0, COMPLETE, IPV6, PKT_HASH_TYPE_L3),
259	HNS3_RX_PTYPE_UNUSED_ENTRY(140),	261	HNS3_RX_PTYPE_UNUSED_ENTRY(140),
260	HNS3_RX_PTYPE_UNUSED_ENTRY(141),	262	HNS3_RX_PTYPE_UNUSED_ENTRY(141),
261	HNS3_RX_PTYPE_UNUSED_ENTRY(142),	263	HNS3_RX_PTYPE_UNUSED_ENTRY(142),
@@ -3776,8 +3778,8 @@ static void hns3_nic_reuse_page(struct sk_buff *skb, int i, · 3514 unmodified lines
3776	desc_cb->reuse_flag = 1;	3778	desc_cb->reuse_flag = 1;
3777	} else if (frag_size <= ring->rx_copybreak) {	3779	} else if (frag_size <= ring->rx_copybreak) {
3778	ret = hns3_handle_rx_copybreak(skb, i, ring, pull_len, desc_cb);	3780	ret = hns3_handle_rx_copybreak(skb, i, ring, pull_len, desc_cb);
3779	if (ret)	3781	if (!ret)
3780	goto out;	3782	return;
3781	}	3783	}
3782		3784
3783	out:	3785	out:
@@ -4171,15 +4173,35 @@ static int hns3_set_gro_and_checksum(struct hns3_enet_ring *ring, · 387 unmodified lines
4171	}	4173	}
4172		4174
4173	static void hns3_set_rx_skb_rss_type(struct hns3_enet_ring *ring,	4175	static void hns3_set_rx_skb_rss_type(struct hns3_enet_ring *ring,
4174	struct sk_buff *skb, u32 rss_hash)	4176	struct sk_buff *skb, u32 rss_hash,
		4177	u32 l234info, u32 ol_info)
4175	{	4178	{
4176	struct hnae3_handle *handle = ring->tqp->handle;	4179	enum pkt_hash_types rss_type = PKT_HASH_TYPE_NONE;
4177	enum pkt_hash_types rss_type;	4180	struct net_device *netdev = ring_to_netdev(ring);
		4181	struct hns3_nic_priv *priv = netdev_priv(netdev);
4178		4182
4179	if (rss_hash)	4183	if (test_bit(HNS3_NIC_STATE_RXD_ADV_LAYOUT_ENABLE, &priv->state)) {
4180	rss_type = handle->kinfo.rss_type;	4184	u32 ptype = hnae3_get_field(ol_info, HNS3_RXD_PTYPE_M,
4181	else	4185	HNS3_RXD_PTYPE_S);
4182	rss_type = PKT_HASH_TYPE_NONE;	4186
		4187	rss_type = hns3_rx_ptype_tbl[ptype].hash_type;
		4188	} else {
		4189	int l3_type = hnae3_get_field(l234info, HNS3_RXD_L3ID_M,
		4190	HNS3_RXD_L3ID_S);
		4191	int l4_type = hnae3_get_field(l234info, HNS3_RXD_L4ID_M,
		4192	HNS3_RXD_L4ID_S);
		4193
		4194	if (l3_type == HNS3_L3_TYPE_IPV4 \|\|
		4195	l3_type == HNS3_L3_TYPE_IPV6) {
		4196	if (l4_type == HNS3_L4_TYPE_UDP \|\|
		4197	l4_type == HNS3_L4_TYPE_TCP \|\|
		4198	l4_type == HNS3_L4_TYPE_SCTP)
		4199	rss_type = PKT_HASH_TYPE_L4;
		4200	else if (l4_type == HNS3_L4_TYPE_IGMP \|\|
		4201	l4_type == HNS3_L4_TYPE_ICMP)
		4202	rss_type = PKT_HASH_TYPE_L3;
		4203	}
		4204	}
4183		4205
4184	skb_set_hash(skb, rss_hash, rss_type);	4206	skb_set_hash(skb, rss_hash, rss_type);
4185	}	4207	}
@@ -4282,7 +4304,8 @@ static int hns3_handle_bdinfo(struct hns3_enet_ring ring, struct sk_buff skb) · 96 unmodified lines
4282		4304
4283	ring->tqp_vector->rx_group.total_bytes += len;	4305	ring->tqp_vector->rx_group.total_bytes += len;
4284		4306
4285	hns3_set_rx_skb_rss_type(ring, skb, le32_to_cpu(desc->rx.rss_hash));	4307	hns3_set_rx_skb_rss_type(ring, skb, le32_to_cpu(desc->rx.rss_hash),
		4308	l234info, ol_info);
4286	return 0;	4309	return 0;
4287	}	4310	}
4288		4311